
package ru.dbotthepony.mc.otm.registry

import net.minecraft.ChatFormatting
import net.minecraft.network.chat.Component
import net.minecraft.resources.ResourceLocation
import net.minecraft.world.food.FoodProperties
import net.minecraft.world.item.*
import net.minecraft.world.item.Item.Properties
import net.minecraft.world.item.crafting.Ingredient
import net.minecraft.world.level.Level
import net.minecraft.world.level.block.Block
import net.minecraftforge.common.ForgeTier
import net.minecraftforge.common.TierSortingRegistry
import net.minecraftforge.eventbus.api.IEventBus
import net.minecraftforge.registries.DeferredRegister
import net.minecraftforge.registries.ForgeRegistries
import net.minecraftforge.registries.RegistryObject
import ru.dbotthepony.mc.otm.OverdriveThatMatters
import ru.dbotthepony.mc.otm.capability.ITieredUpgradeSet
import ru.dbotthepony.mc.otm.capability.MatteryPlayerCapability
import ru.dbotthepony.mc.otm.capability.UpgradeType
import ru.dbotthepony.mc.otm.config.CablesConfig
import ru.dbotthepony.mc.otm.config.ItemsConfig
import ru.dbotthepony.mc.otm.core.collect.SupplierList
import ru.dbotthepony.mc.otm.core.TranslatableComponent
import ru.dbotthepony.mc.otm.core.addAll
import ru.dbotthepony.mc.otm.core.asSupplierArray
import ru.dbotthepony.mc.otm.core.collect.SupplierMap
import ru.dbotthepony.mc.otm.core.math.Decimal
import ru.dbotthepony.mc.otm.item.*
import ru.dbotthepony.mc.otm.item.exopack.ExopackProbeItem
import ru.dbotthepony.mc.otm.item.exopack.ExopackSlotUpgradeItem
import ru.dbotthepony.mc.otm.item.matter.CreativePatternItem
import ru.dbotthepony.mc.otm.item.matter.MatterCapacitorItem
import ru.dbotthepony.mc.otm.item.matter.MatterDustItem
import ru.dbotthepony.mc.otm.item.matter.PatternStorageItem
import ru.dbotthepony.mc.otm.item.weapon.EnergySwordItem
import ru.dbotthepony.mc.otm.item.tool.ExplosiveHammerItem
import ru.dbotthepony.mc.otm.item.tool.MatteryAxeItem
import ru.dbotthepony.mc.otm.item.armor.PortableGravitationStabilizerItem
import ru.dbotthepony.mc.otm.item.armor.SimpleTritaniumArmorItem
import ru.dbotthepony.mc.otm.item.armor.TritaniumArmorItem
import ru.dbotthepony.mc.otm.item.exopack.ExopackUpgradeItem
import ru.dbotthepony.mc.otm.item.exopack.ProceduralExopackSlotUpgradeItem
import ru.dbotthepony.mc.otm.item.weapon.PlasmaRifleItem
import java.util.function.Supplier

object MItems {
	private val DEFAULT_PROPERTIES = Properties()
	private val registry = MDeferredRegister(ForgeRegistries.ITEMS)

	private fun register(name: String, blocks: Map<DyeColor?, Block>, properties: Properties = DEFAULT_PROPERTIES): Map<DyeColor?, BlockItem> {
		return registry.coloredWithBase(name) { color -> BlockItem(blocks[color]!!, properties) }
	}

	internal fun register(bus: IEventBus) {
		registry.register(bus)
	}

	val ENERGY_CABLES: Map<CablesConfig.E, BlockItem> = SupplierMap(CablesConfig.E.entries.map { conf ->
		conf to registry.register("${conf.name.lowercase()}_energy_cable") { BlockItem(MBlocks.ENERGY_CABLES[conf]!!, DEFAULT_PROPERTIES) }
	})

	val ANDROID_STATION = register(MNames.ANDROID_STATION, MBlocks.ANDROID_STATION)
	val ANDROID_CHARGER = register(MNames.ANDROID_CHARGER, MBlocks.ANDROID_CHARGER)
	val BATTERY_BANK = register(MNames.BATTERY_BANK, MBlocks.BATTERY_BANK)
	val MATTER_DECOMPOSER = register(MNames.MATTER_DECOMPOSER, MBlocks.MATTER_DECOMPOSER)
	val MATTER_CAPACITOR_BANK = register(MNames.MATTER_CAPACITOR_BANK, MBlocks.MATTER_CAPACITOR_BANK)
	val MATTER_CABLE: BlockItem by registry.register(MNames.MATTER_CABLE) { BlockItem(MBlocks.MATTER_CABLE, DEFAULT_PROPERTIES) }
	val PATTERN_STORAGE: BlockItem by registry.register(MNames.PATTERN_STORAGE) { BlockItem(MBlocks.PATTERN_STORAGE, DEFAULT_PROPERTIES) }
	val MATTER_SCANNER = register(MNames.MATTER_SCANNER, MBlocks.MATTER_SCANNER)
	val MATTER_PANEL = register(MNames.MATTER_PANEL, MBlocks.MATTER_PANEL)
	val MATTER_REPLICATOR = register(MNames.MATTER_REPLICATOR, MBlocks.MATTER_REPLICATOR)
	val MATTER_BOTTLER = register(MNames.MATTER_BOTTLER, MBlocks.MATTER_BOTTLER)

	val TRITANIUM_ORE: BlockItem by registry.register(MNames.TRITANIUM_ORE) { BlockItem(MBlocks.TRITANIUM_ORE, DEFAULT_PROPERTIES) }
	val DEEPSLATE_TRITANIUM_ORE: BlockItem by registry.register(MNames.DEEPSLATE_TRITANIUM_ORE) { BlockItem(MBlocks.DEEPSLATE_TRITANIUM_ORE, DEFAULT_PROPERTIES) }
	val TRITANIUM_RAW_BLOCK: BlockItem by registry.register(MNames.TRITANIUM_RAW_BLOCK) { BlockItem(MBlocks.TRITANIUM_RAW_BLOCK, DEFAULT_PROPERTIES) }
	val ENERGY_COUNTER = register(MNames.ENERGY_COUNTER, MBlocks.ENERGY_COUNTER)
	val CHEMICAL_GENERATOR = register(MNames.CHEMICAL_GENERATOR, MBlocks.CHEMICAL_GENERATOR)
	val PLATE_PRESS = register(MNames.PLATE_PRESS, MBlocks.PLATE_PRESS)
	val TWIN_PLATE_PRESS = register(MNames.TWIN_PLATE_PRESS, MBlocks.TWIN_PLATE_PRESS)
	val MATTER_RECYCLER = register(MNames.MATTER_RECYCLER, MBlocks.MATTER_RECYCLER)

	val POWERED_FURNACE = register(MNames.POWERED_FURNACE, MBlocks.POWERED_FURNACE)
	val POWERED_BLAST_FURNACE = register(MNames.POWERED_BLAST_FURNACE, MBlocks.POWERED_BLAST_FURNACE)
	val POWERED_SMOKER = register(MNames.POWERED_SMOKER, MBlocks.POWERED_SMOKER)

	val STORAGE_BUS: BlockItem by registry.register(MNames.STORAGE_BUS) { BlockItem(MBlocks.STORAGE_BUS, DEFAULT_PROPERTIES) }
	val STORAGE_IMPORTER: BlockItem by registry.register(MNames.STORAGE_IMPORTER) { BlockItem(MBlocks.STORAGE_IMPORTER, DEFAULT_PROPERTIES) }
	val STORAGE_EXPORTER: BlockItem by registry.register(MNames.STORAGE_EXPORTER) { BlockItem(MBlocks.STORAGE_EXPORTER, DEFAULT_PROPERTIES) }
	val DRIVE_VIEWER = register(MNames.DRIVE_VIEWER, MBlocks.DRIVE_VIEWER)
	val DRIVE_RACK: BlockItem by registry.register(MNames.DRIVE_RACK) { BlockItem(MBlocks.DRIVE_RACK, DEFAULT_PROPERTIES) }
	val ITEM_MONITOR = register(MNames.ITEM_MONITOR, MBlocks.ITEM_MONITOR)
	val STORAGE_CABLE: BlockItem by registry.register(MNames.STORAGE_CABLE) { BlockItem(MBlocks.STORAGE_CABLE, DEFAULT_PROPERTIES) }
	val STORAGE_POWER_SUPPLIER = register(MNames.STORAGE_POWER_SUPPLIER, MBlocks.STORAGE_POWER_SUPPLIER)

	val GRAVITATION_STABILIZER: BlockItem by registry.register(MNames.GRAVITATION_STABILIZER) { BlockItem(MBlocks.GRAVITATION_STABILIZER, DEFAULT_PROPERTIES) }

	val PHANTOM_ATTRACTOR: DoubleHighBlockItem by registry.register(MNames.PHANTOM_ATTRACTOR) { DoubleHighBlockItem(MBlocks.PHANTOM_ATTRACTOR, DEFAULT_PROPERTIES) }
	val ENERGY_SERVO = register(MNames.ENERGY_SERVO, MBlocks.ENERGY_SERVO)
	val COBBLESTONE_GENERATOR = register(MNames.COBBLESTONE_GENERATOR, MBlocks.COBBLESTONE_GENERATOR)

	val INFINITE_WATER_SOURCE: BlockItem by registry.register(MNames.INFINITE_WATER_SOURCE) { BlockItem(MBlocks.INFINITE_WATER_SOURCE, DEFAULT_PROPERTIES) }
	val ESSENCE_STORAGE = register(MNames.ESSENCE_STORAGE, MBlocks.ESSENCE_STORAGE)
	val MATTER_RECONSTRUCTOR = register(MNames.MATTER_RECONSTRUCTOR, MBlocks.MATTER_RECONSTRUCTOR)

	val DEV_CHEST: BlockItem by registry.register(MNames.DEV_CHEST) { BlockItem(MBlocks.DEV_CHEST, DEFAULT_PROPERTIES) }
	val PAINTER: BlockItem by registry.register(MNames.PAINTER) { BlockItem(MBlocks.PAINTER, DEFAULT_PROPERTIES) }
	val MATTER_ENTANGLER: BlockItem by registry.register(MNames.MATTER_ENTANGLER) { BlockItem(MBlocks.MATTER_ENTANGLER, DEFAULT_PROPERTIES) }

	val MACHINES: List<BlockItem>

	init {
		val machines = ArrayList<Supplier<BlockItem>>()

		machines.addAll(PLATE_PRESS.asSupplierArray())
		machines.addAll(TWIN_PLATE_PRESS.asSupplierArray())
		machines.addAll(POWERED_FURNACE.asSupplierArray())
		machines.addAll(POWERED_BLAST_FURNACE.asSupplierArray())
		machines.addAll(POWERED_SMOKER.asSupplierArray())

		machines.addAll(ANDROID_STATION.asSupplierArray())
		machines.addAll(ANDROID_CHARGER.asSupplierArray())
		machines.addAll(BATTERY_BANK.asSupplierArray())
		machines.addAll(ENERGY_COUNTER.asSupplierArray())
		machines.addAll(CHEMICAL_GENERATOR.asSupplierArray())
		machines.addAll(ENERGY_SERVO.asSupplierArray())

		machines.add(::PAINTER)
		machines.addAll(COBBLESTONE_GENERATOR.asSupplierArray().iterator())
		machines.addAll(ESSENCE_STORAGE.asSupplierArray().iterator())

		machines.addAll(MATTER_DECOMPOSER.asSupplierArray().iterator())
		machines.addAll(MATTER_CAPACITOR_BANK.asSupplierArray().iterator())
		machines.add(::MATTER_CABLE)
		machines.add(::PATTERN_STORAGE)
		machines.addAll(MATTER_SCANNER.asSupplierArray().iterator())
		machines.addAll(MATTER_PANEL.asSupplierArray().iterator())
		machines.addAll(MATTER_REPLICATOR.asSupplierArray().iterator())
		machines.addAll(MATTER_BOTTLER.asSupplierArray().iterator())
		machines.add(::MATTER_ENTANGLER)
		machines.addAll(MATTER_RECYCLER.asSupplierArray().iterator())

		machines.add(::STORAGE_BUS)
		machines.add(::STORAGE_IMPORTER)
		machines.add(::STORAGE_EXPORTER)
		machines.addAll(DRIVE_VIEWER.asSupplierArray().iterator())
		machines.add(::DRIVE_RACK)
		machines.addAll(ITEM_MONITOR.asSupplierArray().iterator())
		machines.add(::STORAGE_CABLE)
		machines.addAll(STORAGE_POWER_SUPPLIER.asSupplierArray().iterator())

		MACHINES = SupplierList(machines)
	}

	val DEBUG_EXPLOSION_SMALL: Item by registry.register(MNames.DEBUG_EXPLOSION_SMALL) { BlockItem(MBlocks.DEBUG_EXPLOSION_SMALL, Item.Properties().stacksTo(64)) }
	val DEBUG_SPHERE_POINTS: Item by registry.register(MNames.DEBUG_SPHERE_POINTS) { BlockItem(MBlocks.DEBUG_SPHERE_POINTS, Item.Properties().stacksTo(64)) }

	val TRITANIUM_ANVIL: List<BlockItem>

	init {
		val props = ArrayList<Supplier<BlockItem>>()

		for (i in MBlocks.TRITANIUM_ANVIL.indices) {
			props.add(registry.register(MNames.TRITANIUM_ANVIL + i) { BlockItem(MBlocks.TRITANIUM_ANVIL[i], DEFAULT_PROPERTIES) }::get)
		}

		TRITANIUM_ANVIL = SupplierList(props)
	}

	object MachineUpgrades {
		object Basic : ITieredUpgradeSet {
			override val BLANK: Item by registry.register("blank_machine_upgrade_basic") { Item(DEFAULT_PROPERTIES) }

			override val SPEED: SimpleUpgrade by registry.register("speed_upgrade_basic") { SimpleUpgrade(Item.Properties(), UpgradeType.SPEED.set(), speedBonus = 0.125, failureMultiplier = 1.125, energyConsumed = Decimal.ONE_EIGHTH) }
			override val ENERGY_CONSUMPTION: SimpleUpgrade by registry.register("energy_consumption_upgrade_basic") { SimpleUpgrade(Item.Properties(), UpgradeType.ENERGY_CONSUMPTION.set(), speedBonus = -0.25, failureMultiplier = 1.125, energyConsumed = Decimal.MINUS_ONE_EIGHTH) }
			override val FAILSAFE: SimpleUpgrade by registry.register("failsafe_upgrade_basic") { SimpleUpgrade(Item.Properties(), UpgradeType.FAILSAFE.set(), speedBonus = -0.125, failureMultiplier = 0.75, energyConsumed = Decimal.ONE_EIGHTH) }

			override val ENERGY_STORAGE: SimpleUpgrade by registry.register("energy_storage_upgrade_basic") { SimpleUpgrade(Item.Properties(), UpgradeType.ENERGY_STORAGE.set(), energyStorage = Decimal.ONE_HALF) }
			override val MATTER_STORAGE: SimpleUpgrade by registry.register("matter_storage_upgrade_basic") { SimpleUpgrade(Item.Properties(), UpgradeType.MATTER_STORAGE.set(), matterStorage = Decimal.ONE_HALF) }

			override val PROCESSING_ITEMS: SimpleUpgrade by registry.register("processing_upgrade_basic") { SimpleUpgrade(Item.Properties(), UpgradeType.PROCESSING.set(), processingItems = 1, speedBonus = -0.25, failureMultiplier = 1.25, energyConsumed = Decimal.ONE_QUARTER) }
		}

		object Normal : ITieredUpgradeSet {
			override val BLANK: Item by registry.register("blank_machine_upgrade_normal") { Item(DEFAULT_PROPERTIES) }

			override val SPEED: SimpleUpgrade by registry.register("speed_upgrade_normal") { SimpleUpgrade(Item.Properties(), UpgradeType.SPEED.set(), speedBonus = 0.25, failureMultiplier = 1.25, energyConsumed = Decimal.ONE_QUARTER) }
			override val ENERGY_CONSUMPTION: SimpleUpgrade by registry.register("energy_consumption_upgrade_normal") { SimpleUpgrade(Item.Properties(), UpgradeType.ENERGY_CONSUMPTION.set(), speedBonus = -0.5, failureMultiplier = 1.25, energyConsumed = Decimal.MINUS_ONE_QUARTER) }
			override val FAILSAFE: SimpleUpgrade by registry.register("failsafe_upgrade_normal") { SimpleUpgrade(Item.Properties(), UpgradeType.FAILSAFE.set(), speedBonus = -0.25, failureMultiplier = 0.5, energyConsumed = Decimal.ONE_QUARTER) }

			override val ENERGY_STORAGE: SimpleUpgrade by registry.register("energy_storage_upgrade_normal") { SimpleUpgrade(Item.Properties(), UpgradeType.ENERGY_STORAGE.set(), energyStorage = Decimal.ONE) }
			override val MATTER_STORAGE: SimpleUpgrade by registry.register("matter_storage_upgrade_normal") { SimpleUpgrade(Item.Properties(), UpgradeType.MATTER_STORAGE.set(), matterStorage = Decimal.ONE) }

			override val PROCESSING_ITEMS: SimpleUpgrade by registry.register("processing_upgrade_normal") { SimpleUpgrade(Item.Properties(), UpgradeType.PROCESSING.set(), processingItems = 1, speedBonus = -0.125, failureMultiplier = 1.125, energyConsumed = Decimal.ONE_EIGHTH) }
		}

		object Advanced : ITieredUpgradeSet {
			override val BLANK: Item by registry.register("blank_machine_upgrade_advanced") { Item(DEFAULT_PROPERTIES) }

			override val SPEED: SimpleUpgrade by registry.register("speed_upgrade_advanced") { SimpleUpgrade(Item.Properties().rarity(Rarity.UNCOMMON), UpgradeType.SPEED.set(), speedBonus = 0.25, failureMultiplier = 1.125, energyConsumed = Decimal.ONE_EIGHTH) }
			override val ENERGY_CONSUMPTION: SimpleUpgrade by registry.register("energy_consumption_upgrade_advanced") { SimpleUpgrade(Item.Properties().rarity(Rarity.UNCOMMON), UpgradeType.ENERGY_CONSUMPTION.set(), speedBonus = -0.25, failureMultiplier = 1.125, energyConsumed = Decimal.MINUS_ONE_QUARTER) }
			override val FAILSAFE: SimpleUpgrade by registry.register("failsafe_upgrade_advanced") { SimpleUpgrade(Item.Properties().rarity(Rarity.UNCOMMON), UpgradeType.FAILSAFE.set(), speedBonus = -0.125, failureMultiplier = 0.5, energyConsumed = Decimal.ONE_EIGHTH) }

			override val ENERGY_STORAGE: SimpleUpgrade by registry.register("energy_storage_upgrade_advanced") { SimpleUpgrade(Item.Properties(), UpgradeType.ENERGY_STORAGE.set(), energyStorage = Decimal.TWO) }
			override val MATTER_STORAGE: SimpleUpgrade by registry.register("matter_storage_upgrade_advanced") { SimpleUpgrade(Item.Properties(), UpgradeType.MATTER_STORAGE.set(), matterStorage = Decimal.TWO) }

			override val PROCESSING_ITEMS: SimpleUpgrade by registry.register("processing_upgrade_advanced") { SimpleUpgrade(Item.Properties().rarity(Rarity.UNCOMMON), UpgradeType.PROCESSING.set(), processingItems = 2, speedBonus = -0.125, failureMultiplier = 1.125, energyConsumed = Decimal.ONE_EIGHTH) }
		}

		object Creative {
			val SPEED: SimpleUpgrade by registry.register("creative_speed_upgrade") { SimpleUpgrade(Item.Properties().rarity(Rarity.EPIC), UpgradeType.SPEED.set(), speedBonus = 1.0) }
			val ENERGY_CONSUMPTION: SimpleUpgrade by registry.register("creative_energy_consumption_upgrade") { SimpleUpgrade(Item.Properties().rarity(Rarity.EPIC), UpgradeType.ENERGY_CONSUMPTION.set(), energyConsumed = Decimal.MINUS_ONE) }
			val ENERGY_STORAGE: SimpleUpgrade by registry.register("creative_energy_storage_upgrade") { SimpleUpgrade(Item.Properties().rarity(Rarity.EPIC), UpgradeType.ENERGY_STORAGE.set(), energyStorage = Decimal.ONE) }
			val ENERGY_STORAGE_FLAT: SimpleUpgrade by registry.register("creative_energy_storage_flat_upgrade") { SimpleUpgrade(Item.Properties().rarity(Rarity.EPIC), UpgradeType.ENERGY_STORAGE.set(), energyStorageFlat = Decimal.LONG_MAX_VALUE) }
			val ENERGY_STORAGE_FLAT_SMALL: SimpleUpgrade by registry.register("creative_energy_storage_flat2_upgrade") { SimpleUpgrade(Item.Properties().rarity(Rarity.EPIC), UpgradeType.ENERGY_STORAGE.set(), energyStorageFlat = Decimal.INT_MAX_VALUE) }
			val ENERGY_THROUGHPUT: SimpleUpgrade by registry.register("creative_energy_throughput_upgrade") { SimpleUpgrade(Item.Properties().rarity(Rarity.EPIC), UpgradeType.ENERGY_THROUGHPUT.set(), energyThroughput = Decimal.ONE) }
			val ENERGY_THROUGHPUT_FLAT: SimpleUpgrade by registry.register("creative_energy_throughput_flat_upgrade") { SimpleUpgrade(Item.Properties().rarity(Rarity.EPIC), UpgradeType.ENERGY_THROUGHPUT.set(), energyThroughputFlat = Decimal.LONG_MAX_VALUE) }
			val ENERGY_THROUGHPUT_FLAT_SMALL: SimpleUpgrade by registry.register("creative_energy_throughput_flat2_upgrade") { SimpleUpgrade(Item.Properties().rarity(Rarity.EPIC), UpgradeType.ENERGY_THROUGHPUT.set(), energyThroughputFlat = Decimal.INT_MAX_VALUE) }
			val FAILSAFE: SimpleUpgrade by registry.register("creative_failsafe_upgrade") { SimpleUpgrade(Item.Properties().rarity(Rarity.EPIC), UpgradeType.FAILSAFE.set(), failureMultiplier = 0.0) }
			val FAILURE: SimpleUpgrade by registry.register("creative_failure_upgrade") { SimpleUpgrade(Item.Properties().rarity(Rarity.EPIC), UpgradeType.FAILSAFE.set(), failureMultiplier = 2.0) }
			val PROCESSING_ITEMS: SimpleUpgrade by registry.register("creative_processing_upgrade") { SimpleUpgrade(Item.Properties().rarity(Rarity.EPIC), UpgradeType.PROCESSING.set(), processingItems = 1) }

			val MATTER_STORAGE: SimpleUpgrade by registry.register("creative_matter_storage_upgrade") { SimpleUpgrade(Item.Properties().rarity(Rarity.EPIC), UpgradeType.MATTER_STORAGE.set(), matterStorage = Decimal.ONE) }
			val MATTER_STORAGE_FLAT: SimpleUpgrade by registry.register("creative_matter_storage_flat_upgrade") { SimpleUpgrade(Item.Properties().rarity(Rarity.EPIC), UpgradeType.MATTER_STORAGE.set(), matterStorageFlat = Decimal.LONG_MAX_VALUE) }
			val MATTER_STORAGE_FLAT_SMALL: SimpleUpgrade by registry.register("creative_matter_storage_flat2_upgrade") { SimpleUpgrade(Item.Properties().rarity(Rarity.EPIC), UpgradeType.MATTER_STORAGE.set(), matterStorageFlat = Decimal.INT_MAX_VALUE) }

			val LIST = SupplierList(
				::SPEED,
				::ENERGY_CONSUMPTION,
				::ENERGY_STORAGE,
				::ENERGY_STORAGE_FLAT,
				::ENERGY_STORAGE_FLAT_SMALL,
				::ENERGY_THROUGHPUT,
				::ENERGY_THROUGHPUT_FLAT,
				::ENERGY_THROUGHPUT_FLAT_SMALL,
				::FAILSAFE,
				::FAILURE,
				::PROCESSING_ITEMS,
				::MATTER_STORAGE,
				::MATTER_STORAGE_FLAT,
				::MATTER_STORAGE_FLAT_SMALL,
			)
		}

		init {
			Basic
			Normal
			Advanced
			Creative
		}

		val CRAFTABLE_TIERS = listOf(
			Basic,
			Normal,
			Advanced,
		)
	}

	init {
		MachineUpgrades
	}

	val MATTER_DUST: MatterDustItem by registry.register(MNames.MATTER_DUST) { MatterDustItem() }

	val TRITANIUM_ORE_CLUMP: Item by registry.register(MNames.TRITANIUM_ORE_CLUMP) { Item(DEFAULT_PROPERTIES) }
	val TRITANIUM_DUST: Item by registry.register(MNames.TRITANIUM_DUST) { Item(DEFAULT_PROPERTIES) }
	val TRITANIUM_NUGGET: Item by registry.register(MNames.TRITANIUM_NUGGET) { Item(DEFAULT_PROPERTIES) }
	val TRITANIUM_INGOT: Item by registry.register(MNames.TRITANIUM_INGOT) { Item(DEFAULT_PROPERTIES) }
	val TRITANIUM_INGOT_BLOCK: BlockItem by registry.register(MNames.TRITANIUM_INGOT_BLOCK) { BlockItem(MBlocks.TRITANIUM_INGOT_BLOCK, DEFAULT_PROPERTIES) }
	val TRITANIUM_BARS: BlockItem by registry.register(MNames.TRITANIUM_BARS) { BlockItem(MBlocks.TRITANIUM_BARS, DEFAULT_PROPERTIES) }

	val ESSENCE_SERVO: EssenceServoItem by registry.register("essence_servo") { EssenceServoItem() }
	val ESSENCE_CAPSULE: EssenceCapsuleItem by registry.register("essence_capsule") { EssenceCapsuleItem(false) }
	val ESSENCE_DRIVE: EssenceCapsuleItem by registry.register("essence_drive") { EssenceCapsuleItem(true) }

	val FLUID_CAPSULE: FluidCapsuleItem by registry.register("fluid_capsule") { FluidCapsuleItem(ItemsConfig::FLUID_CAPSULE_CAPACITY) }
	val FLUID_TANK: FluidTankItem by registry.register(MNames.FLUID_TANK) { FluidTankItem(MBlocks.FLUID_TANK, Item.Properties().stacksTo(1), ItemsConfig::FLUID_TANK_CAPACITY) }
	val LIQUID_XP_BUCKET: BucketItem by registry.register("liquid_xp_bucket") { BucketItem(MFluids::LIQUID_XP, Item.Properties().stacksTo(1).rarity(Rarity.UNCOMMON)) }

	val TRITANIUM_COMPONENT: ForgeTier = ForgeTier(
		Tiers.IRON.level,
		3072,
		Tiers.IRON.speed * 1.1f,
		3.5f,
		16,
		MBlockTags.REQUIRES_TRITANIUM_TOOL
	) { Ingredient.of(TRITANIUM_INGOT) }

	val TRITANIUM_COMPONENT_NAME = ResourceLocation(OverdriveThatMatters.MOD_ID, "tritanium")

	init {
		TierSortingRegistry.registerTier(TRITANIUM_COMPONENT, TRITANIUM_COMPONENT_NAME, listOf(Tiers.IRON), listOf(Tiers.DIAMOND))
	}

	private val TOOLS_PROPRTIES = Item.Properties()

	val TRITANIUM_SWORD: SwordItem by registry.register(MNames.TRITANIUM_SWORD) { SwordItem(TRITANIUM_COMPONENT, 4, -2.7f, TOOLS_PROPRTIES) }
	val TRITANIUM_SHOVEL: ShovelItem by registry.register(MNames.TRITANIUM_SHOVEL) { ShovelItem(TRITANIUM_COMPONENT, 1.5f, -2.4f, TOOLS_PROPRTIES) }
	val TRITANIUM_AXE: MatteryAxeItem by registry.register(MNames.TRITANIUM_AXE) { MatteryAxeItem(TRITANIUM_COMPONENT, 8.5f, -3.4f, TOOLS_PROPRTIES) }
	val TRITANIUM_PICKAXE: PickaxeItem by registry.register(MNames.TRITANIUM_PICKAXE) { PickaxeItem(TRITANIUM_COMPONENT, 2, -2.8f, TOOLS_PROPRTIES) }
	val TRITANIUM_HOE: HoeItem by registry.register(MNames.TRITANIUM_HOE) { HoeItem(TRITANIUM_COMPONENT, 0, -3.4f, TOOLS_PROPRTIES) }
	val TRITANIUM_SHEARS: ShearsItem by registry.register(MNames.TRITANIUM_SHEARS) { object : ShearsItem(Properties().durability(3072)) {
		override fun isValidRepairItem(pToRepair: ItemStack, pRepair: ItemStack): Boolean {
			return pRepair.`is`(MItemTags.TRITANIUM_INGOTS)
		}
	} }

	val TRITANIUM_SHIELD: ShieldItem by registry.register(MNames.TRITANIUM_SHIELD) { object : ShieldItem(Properties().durability(2048)) {
		override fun isValidRepairItem(pToRepair: ItemStack, pRepair: ItemStack): Boolean {
			return pRepair.`is`(MItemTags.REINFORCED_TRITANIUM_PLATES)
		}
	} }

	val TRITANIUM_TOOLS = SupplierList(
		::TRITANIUM_SWORD,
		::TRITANIUM_SHOVEL,
		::TRITANIUM_AXE,
		::TRITANIUM_PICKAXE,
		::TRITANIUM_HOE,
		::TRITANIUM_SHEARS,
	)

	val TRITANIUM_HELMET: TritaniumArmorItem by registry.register(MNames.TRITANIUM_HELMET) { TritaniumArmorItem(ArmorItem.Type.HELMET) }
	val TRITANIUM_CHESTPLATE: TritaniumArmorItem by registry.register(MNames.TRITANIUM_CHESTPLATE) { TritaniumArmorItem(ArmorItem.Type.CHESTPLATE) }
	val TRITANIUM_PANTS: TritaniumArmorItem by registry.register(MNames.TRITANIUM_PANTS) { TritaniumArmorItem(ArmorItem.Type.LEGGINGS) }
	val TRITANIUM_BOOTS: TritaniumArmorItem by registry.register(MNames.TRITANIUM_BOOTS) { TritaniumArmorItem(ArmorItem.Type.BOOTS) }

	val SIMPLE_TRITANIUM_HELMET: SimpleTritaniumArmorItem by registry.register(MNames.SIMPLE_TRITANIUM_HELMET) { SimpleTritaniumArmorItem(ArmorItem.Type.HELMET) }
	val SIMPLE_TRITANIUM_CHESTPLATE: SimpleTritaniumArmorItem by registry.register(MNames.SIMPLE_TRITANIUM_CHESTPLATE) { SimpleTritaniumArmorItem(ArmorItem.Type.CHESTPLATE) }
	val SIMPLE_TRITANIUM_PANTS: SimpleTritaniumArmorItem by registry.register(MNames.SIMPLE_TRITANIUM_PANTS) { SimpleTritaniumArmorItem(ArmorItem.Type.LEGGINGS) }
	val SIMPLE_TRITANIUM_BOOTS: SimpleTritaniumArmorItem by registry.register(MNames.SIMPLE_TRITANIUM_BOOTS) { SimpleTritaniumArmorItem(ArmorItem.Type.BOOTS) }

	val TRITANIUM_ARMOR = SupplierList(
		::TRITANIUM_HELMET,
		::TRITANIUM_CHESTPLATE,
		::TRITANIUM_PANTS,
		::TRITANIUM_BOOTS
	)

	val SIMPLE_TRITANIUM_ARMOR = SupplierList(
		::SIMPLE_TRITANIUM_HELMET,
		::SIMPLE_TRITANIUM_CHESTPLATE,
		::SIMPLE_TRITANIUM_PANTS,
		::SIMPLE_TRITANIUM_BOOTS
	)

	val EXPLOSIVE_HAMMER: ExplosiveHammerItem by registry.register("explosive_hammer") { ExplosiveHammerItem() }

	val ENERGY_SWORD: Item by registry.register(MNames.ENERGY_SWORD) { EnergySwordItem() }

	val PLASMA_RIFLE: Item by registry.register(MNames.PLASMA_RIFLE) { PlasmaRifleItem() }

	val BLACK_HOLE_SCANNER: Item by registry.register(MNames.BLACK_HOLE_SCANNER) { MatteryItem(DEFAULT_PROPERTIES).addSimpleDescription().addSimpleDescription("2") }

	val GRAVITATION_FIELD_LIMITER: Item by registry.register(MNames.GRAVITATION_FIELD_LIMITER) { Item(DEFAULT_PROPERTIES) }
	val GRAVITATION_FIELD_SENSOR: Item by registry.register(MNames.GRAVITATION_FIELD_SENSOR) { Item(DEFAULT_PROPERTIES) }
	val PORTABLE_GRAVITATION_STABILIZER: Item by registry.register(MNames.PORTABLE_GRAVITATION_STABILIZER) { PortableGravitationStabilizerItem() }

	val BLACK_HOLE: Item by registry.register(MNames.BLACK_HOLE) { BlockItem(MBlocks.BLACK_HOLE, DEFAULT_PROPERTIES) }

	val GRAVITATIONAL_DISRUPTOR: Item by registry.register(MNames.GRAVITATIONAL_DISRUPTOR) { GravitationalDisruptorItem() }

	val PILL_ANDROID: Item by registry.register(MNames.PILL_ANDROID) { PillItem(PillType.BECOME_ANDROID) }
	val PILL_HUMANE: Item by registry.register(MNames.PILL_HUMANE) { PillItem(PillType.BECOME_HUMANE) }
	val PILL_OBLIVION: Item by registry.register(MNames.PILL_OBLIVION) { PillItem(PillType.OBLIVION) }
	val PILL_HEAL: Item by registry.register(MNames.PILL_HEAL) { HealPillItem() }

	val PILLS = SupplierList(
		::PILL_ANDROID,
		::PILL_HUMANE,
		::PILL_OBLIVION,
		::PILL_HEAL,
	)

	val BATTERY_CRUDE: Item by registry.register(MNames.BATTERY_CRUDE) { CrudeBatteryItem() }
	val BATTERY_BASIC: Item by registry.register(MNames.BATTERY_BASIC) { BatteryItem(ItemsConfig.Batteries.BASIC) }
	val BATTERY_NORMAL: Item by registry.register(MNames.BATTERY_NORMAL) { BatteryItem(ItemsConfig.Batteries.NORMAL) }
	val BATTERY_DENSE: Item by registry.register(MNames.BATTERY_DENSE) { BatteryItem(ItemsConfig.Batteries.DENSE) }
	val BATTERY_CAPACITOR: Item by registry.register(MNames.BATTERY_CAPACITOR) { BatteryItem(ItemsConfig.Batteries.CAPACITOR) }
	val BATTERY_CREATIVE: Item by registry.register(MNames.BATTERY_CREATIVE) { BatteryItem() }

	val QUANTUM_BATTERY: QuantumBatteryItem by registry.register(MNames.QUANTUM_BATTERY) { QuantumBatteryItem(MNames.QUANTUM_BATTERY, ItemsConfig.Batteries.QUANTUM_BATTERY) }
	val QUANTUM_CAPACITOR: QuantumBatteryItem by registry.register(MNames.QUANTUM_CAPACITOR) { QuantumBatteryItem(MNames.QUANTUM_CAPACITOR, ItemsConfig.Batteries.QUANTUM_CAPACITOR) }
	val QUANTUM_BATTERY_CREATIVE: QuantumBatteryItem by registry.register(MNames.QUANTUM_BATTERY_CREATIVE) { QuantumBatteryItem(MNames.QUANTUM_BATTERY_CREATIVE, null) }
	val ZPM_BATTERY: ZPMItem by registry.register(MNames.ZPM_BATTERY) { ZPMItem() }
	val PROCEDURAL_BATTERY: ProceduralBatteryItem by registry.register(MNames.PROCEDURAL_BATTERY) { ProceduralBatteryItem() }

	val BATTERIES = SupplierList(
		::BATTERY_CRUDE,
		::BATTERY_BASIC,
		::BATTERY_NORMAL,
		::BATTERY_DENSE,
		::BATTERY_CAPACITOR,
	)

	val UNIQUE_BATTERIES = SupplierList(
		::QUANTUM_BATTERY,
		::QUANTUM_CAPACITOR,
		::QUANTUM_BATTERY_CREATIVE,
		::ZPM_BATTERY,
	)

	val ALL_BATTERIES = SupplierList(
		::BATTERY_CRUDE,
		::BATTERY_BASIC,
		::BATTERY_NORMAL,
		::BATTERY_DENSE,
		::BATTERY_CAPACITOR,
		::BATTERY_CREATIVE,

		::QUANTUM_BATTERY,
		::QUANTUM_CAPACITOR,
		::QUANTUM_BATTERY_CREATIVE,
		::ZPM_BATTERY,
	)

	val MATTER_CAPACITOR_BASIC: Item by registry.register(MNames.MATTER_CAPACITOR_BASIC) { MatterCapacitorItem(ItemsConfig.Capacitors::BASIC) }
	val MATTER_CAPACITOR_NORMAL: Item by registry.register(MNames.MATTER_CAPACITOR_NORMAL) { MatterCapacitorItem(ItemsConfig.Capacitors::NORMAL) }
	val MATTER_CAPACITOR_DENSE: Item by registry.register(MNames.MATTER_CAPACITOR_DENSE) { MatterCapacitorItem(ItemsConfig.Capacitors::DENSE) }
	val MATTER_CAPACITOR_CREATIVE: Item by registry.register(MNames.MATTER_CAPACITOR_CREATIVE) { MatterCapacitorItem() }

	val MATTER_CAPACITORS = SupplierList(
		::MATTER_CAPACITOR_BASIC,
		::MATTER_CAPACITOR_NORMAL,
		::MATTER_CAPACITOR_DENSE,
		::MATTER_CAPACITOR_CREATIVE,
	)

	val PATTERN_DRIVE_NORMAL: Item by registry.register(MNames.PATTERN_DRIVE_NORMAL) { PatternStorageItem(ItemsConfig.PatternDrives::NORMAL) }
	val PATTERN_DRIVE_CREATIVE: Item by registry.register(MNames.PATTERN_DRIVE_CREATIVE) { PatternStorageItem() }
	val PATTERN_DRIVE_CREATIVE2: Item by registry.register(MNames.PATTERN_DRIVE_CREATIVE2) { CreativePatternItem() }

	val PORTABLE_CONDENSATION_DRIVE: Item by registry.register(MNames.PORTABLE_CONDENSATION_DRIVE) { PortableCondensationDriveItem(4000) }
	val PORTABLE_DENSE_CONDENSATION_DRIVE: Item by registry.register(MNames.PORTABLE_DENSE_CONDENSATION_DRIVE) { PortableCondensationDriveItem(25000) }

	val NUTRIENT_PASTE: Item by registry.register(MNames.NUTRIENT_PASTE) { Item(Item.Properties().stacksTo(64).food(FoodProperties.Builder().meat().nutrition(8).saturationMod(0.9F).build())) }

	val LABORATORY_LAMP: Item by registry.register(MNames.LABORATORY_LAMP) { BlockItem(MBlocks.LABORATORY_LAMP, DEFAULT_PROPERTIES) }
	val LABORATORY_LAMP_INVERTED: Item by registry.register(MNames.LABORATORY_LAMP_INVERTED) { BlockItem(MBlocks.LABORATORY_LAMP_INVERTED, DEFAULT_PROPERTIES) }
	val DANGER_STRIPE_BLOCK: Item by registry.register(MNames.DANGER_STRIPE_BLOCK) { BlockItem(MBlocks.DANGER_STRIPE_BLOCK, DEFAULT_PROPERTIES) }
	val METAL_BEAM: Item by registry.register(MNames.METAL_BEAM) { BlockItem(MBlocks.METAL_BEAM, DEFAULT_PROPERTIES) }
	val ENGINE: Item by registry.register(MNames.ENGINE) { BlockItem(MBlocks.ENGINE, DEFAULT_PROPERTIES) }
	val HOLO_SIGN: Item by registry.register(MNames.HOLO_SIGN) { BlockItem(MBlocks.HOLO_SIGN, DEFAULT_PROPERTIES) }

	val TRITANIUM_DOOR = register(MNames.TRITANIUM_DOOR, MBlocks.TRITANIUM_DOOR)
	val TRITANIUM_TRAPDOOR = register(MNames.TRITANIUM_TRAPDOOR, MBlocks.TRITANIUM_TRAPDOOR)

	// components
	val MATTER_IO_PORT: Item by registry.register(MNames.MATTER_IO_PORT) { Item(DEFAULT_PROPERTIES) }
	val MATTER_TRANSFORM_MATRIX: Item by registry.register(MNames.MATTER_TRANSFORM_MATRIX) { Item(DEFAULT_PROPERTIES) }
	val ENERGY_BUS: Item by registry.register(MNames.ENERGY_BUS) { Item(DEFAULT_PROPERTIES) }
	val ELECTRIC_PARTS: Item by registry.register(MNames.ELECTRIC_PARTS) { Item(DEFAULT_PROPERTIES) }
	val MACHINE_FRAME: Item by registry.register(MNames.MACHINE_FRAME) { Item(DEFAULT_PROPERTIES) }
	val TRITANIUM_PLATE: Item by registry.register(MNames.TRITANIUM_PLATE) { Item(DEFAULT_PROPERTIES) }
	val IRON_PLATE: Item by registry.register(MNames.IRON_PLATE) { Item(DEFAULT_PROPERTIES) }
	val GOLD_PLATE: Item by registry.register(MNames.GOLD_PLATE) { Item(DEFAULT_PROPERTIES) }
	val COPPER_WIRING: Item by registry.register(MNames.COPPER_WIRING) { Item(DEFAULT_PROPERTIES) }
	val GOLD_WIRING: Item by registry.register(MNames.GOLD_WIRING) { Item(DEFAULT_PROPERTIES) }
	val PORTABLE_CONDENSATION_DRIVE_CASING: Item by registry.register(MNames.PORTABLE_CONDENSATION_DRIVE_CASING) { Item(DEFAULT_PROPERTIES) }
	val PORTABLE_DENSE_CONDENSATION_DRIVE_CASING: Item by registry.register(MNames.PORTABLE_DENSE_CONDENSATION_DRIVE_CASING) { Item(DEFAULT_PROPERTIES) }
	val CIRCUIT_PLATING: Item by registry.register(MNames.CIRCUIT_PLATING) { Item(DEFAULT_PROPERTIES) }
	val BASIC_CONTROL_CIRCUIT: Item by registry.register(MNames.BASIC_CONTROL_CIRCUIT) { Item(DEFAULT_PROPERTIES) }
	val ADVANCED_CONTROL_CIRCUIT: Item by registry.register(MNames.ADVANCED_CONTROL_CIRCUIT) { Item(DEFAULT_PROPERTIES) }
	val MATTER_CAPACITOR_PARTS: Item by registry.register(MNames.MATTER_CAPACITOR_PARTS) { Item(DEFAULT_PROPERTIES) }
	val CARBON_MESH: Item by registry.register(MNames.CARBON_MESH) { Item(DEFAULT_PROPERTIES) }
	val REINFORCED_TRITANIUM_PLATE: Item by registry.register(MNames.REINFORCED_TRITANIUM_PLATE) { MatteryItem(DEFAULT_PROPERTIES).addSimpleDescription() }

	val QUANTUM_TRANSCEIVER: Item by registry.register(MNames.QUANTUM_TRANSCEIVER) { Item(DEFAULT_PROPERTIES) }
	val ELECTROMAGNET: Item by registry.register(MNames.ELECTROMAGNET) { Item(DEFAULT_PROPERTIES) }
	val ELECTROMOTOR: Item by registry.register(MNames.ELECTROMOTOR) { Item(DEFAULT_PROPERTIES) }
	val MIRROR_COMPOUND: Item by registry.register(MNames.MIRROR_COMPOUND) { Item(DEFAULT_PROPERTIES) }
	val MIRROR: Item by registry.register(MNames.MIRROR) { MatteryItem(DEFAULT_PROPERTIES).addSimpleDescription() }

	/**
	 * List of components for everything else
	 */
	val COMPONENTS = SupplierList(
		::MATTER_IO_PORT,
		::MATTER_TRANSFORM_MATRIX,
		::ENERGY_BUS,
		::ELECTRIC_PARTS,
		::MACHINE_FRAME,
		::TRITANIUM_PLATE,
		::IRON_PLATE,
		::GOLD_PLATE,
		::COPPER_WIRING,
		::GOLD_WIRING,
		::PORTABLE_CONDENSATION_DRIVE_CASING,
		::PORTABLE_DENSE_CONDENSATION_DRIVE_CASING,
		::CIRCUIT_PLATING,
		::BASIC_CONTROL_CIRCUIT,
		::ADVANCED_CONTROL_CIRCUIT,
		::MATTER_CAPACITOR_PARTS,

		::QUANTUM_TRANSCEIVER,
		::ELECTROMAGNET,
		::ELECTROMOTOR,
		::MIRROR_COMPOUND,
		::MIRROR,

		::CARBON_MESH,
		::REINFORCED_TRITANIUM_PLATE,

		MachineUpgrades.Basic::BLANK,
		MachineUpgrades.Normal::BLANK,
		MachineUpgrades.Advanced::BLANK,
	)

	/**
	 * List of components for datagen code
	 */
	val DATAGEN_COMPONENTS = SupplierList(
		::ENERGY_BUS,
		::ELECTRIC_PARTS,
		::TRITANIUM_PLATE,
		::IRON_PLATE,
		::GOLD_PLATE,
		::COPPER_WIRING,
		::GOLD_WIRING,
		::CIRCUIT_PLATING,
		::BASIC_CONTROL_CIRCUIT,
		::ADVANCED_CONTROL_CIRCUIT,
		::MATTER_CAPACITOR_PARTS,
		::MATTER_IO_PORT,
		::MATTER_TRANSFORM_MATRIX,
		::QUANTUM_TRANSCEIVER,
		::ELECTROMAGNET,
		::ELECTROMOTOR,
		::MIRROR_COMPOUND,
		::MIRROR,

		::CARBON_MESH,
		::REINFORCED_TRITANIUM_PLATE,
	)

	val CARGO_CRATE_MINECARTS = registry.coloredWithBase(MNames.MINECART_CARGO_CRATE, ::MinecartCargoCrateItem)

	val EXOPACK_PROBE: Item by registry.register(MNames.EXOPACK_PROBE, ::ExopackProbeItem)

	object ExopackUpgrades {
		val INVENTORY_UPGRADE_CREATIVE: ExopackSlotUpgradeItem by registry.register("exosuit_inventory_upgrade_creative") { ExopackSlotUpgradeItem(null, 27, Rarity.EPIC) }
		val CRAFTING_UPGRADE: ExopackUpgradeItem by registry.register("exosuit_crafting_upgrade") { ExopackUpgradeItem(MatteryPlayerCapability.UpgradeType.CRAFTING, "crafting_upgrade", "crafting_upgraded") }
		val SMELTING_UPGRADE: ExopackUpgradeItem by registry.register("exopack_smelting_upgrade") { ExopackUpgradeItem(MatteryPlayerCapability.UpgradeType.SMELTING, "smelting_upgrade", "smelting_installed") }
		val ENDER_UPGRADE: ExopackUpgradeItem by registry.register("exopack_ender_upgrade") { ExopackUpgradeItem(MatteryPlayerCapability.UpgradeType.ENDER_ACCESS, "ender_access_upgrade", "ender_access_installed") }

		val INVENTORY_UPGRADES = SupplierList(8) {
			registry.register("exosuit_inventory_upgrade_$it") { ExopackSlotUpgradeItem(18, Rarity.COMMON) }
		}

		val INVENTORY_UPGRADE_PROCEDURAL: ProceduralExopackSlotUpgradeItem by registry.register("exosuit_inventory_upgrade_procedural") { ProceduralExopackSlotUpgradeItem() }

		val INVENTORY_UPGRADE_BIG: ExopackSlotUpgradeItem by registry.register("exosuit_inventory_upgrade_big") { ExopackSlotUpgradeItem(60, Rarity.RARE) }
		val INVENTORY_UPGRADE_HUGE: ExopackSlotUpgradeItem by registry.register("exosuit_inventory_upgrade_huge") { ExopackSlotUpgradeItem(135, Rarity.RARE) }

		val INVENTORY_UPGRADE_WITHER: ExopackSlotUpgradeItem by registry.register("exosuit_inventory_upgrade_wither") { ExopackSlotUpgradeItem(180, Rarity.RARE, hasDescription = true) }
		val INVENTORY_UPGRADE_ENDER_DRAGON: ExopackSlotUpgradeItem by registry.register("exosuit_inventory_upgrade_ender_dragon") { ExopackSlotUpgradeItem(180, Rarity.EPIC, hasDescription = true) }
	}

	init {
		// call static initializer
		ExopackUpgrades
	}

	val TRITANIUM_STRIPED_BLOCK: Item by registry.register(MNames.TRITANIUM_STRIPED_BLOCK) { BlockItem(MBlocks.TRITANIUM_STRIPED_BLOCK, DEFAULT_PROPERTIES) }
	val TRITANIUM_STRIPED_STAIRS: Item by registry.register(MNames.TRITANIUM_STRIPED_STAIRS) { BlockItem(MBlocks.TRITANIUM_STRIPED_STAIRS, DEFAULT_PROPERTIES) }
	val TRITANIUM_STRIPED_SLAB: Item by registry.register(MNames.TRITANIUM_STRIPED_SLAB) { BlockItem(MBlocks.TRITANIUM_STRIPED_SLAB, DEFAULT_PROPERTIES) }
	val TRITANIUM_STRIPED_WALL: Item by registry.register(MNames.TRITANIUM_STRIPED_WALL) { BlockItem(MBlocks.TRITANIUM_STRIPED_WALL, DEFAULT_PROPERTIES) }
	val CARBON_FIBRE_BLOCK: Item by registry.register(MNames.CARBON_FIBRE_BLOCK) { BlockItem(MBlocks.CARBON_FIBRE_BLOCK, DEFAULT_PROPERTIES) }
	val METAL_JUNK: Item by registry.register(MNames.METAL_JUNK) { BlockItem(MBlocks.METAL_JUNK, DEFAULT_PROPERTIES) }
	val METAL_MESH: Item by registry.register(MNames.METAL_MESH) { BlockItem(MBlocks.METAL_MESH, DEFAULT_PROPERTIES) }

	val CHEST_UPGRADER: Item by registry.register(MNames.CHEST_UPGRADER) { ChestUpgraderItem() }

	init {
		MRegistry.registerItems(registry)
	}
}
