# Configuration file

##########################################################################################################
# Overrides
#--------------------------------------------------------------------------------------------------------#
# A set of blocks from other mods to override to act like NetherOres.
# This does not include controling oregen, or recipes; only behavior when mined or destroyed.
##########################################################################################################

Overrides {
}


general {
    # If true, when NetherOres are mined, nearby pigmen become angry to the player.
    B:AngryPigmenEnable=true

    # NetherOre explosions can trigger more explosions if true. Does nothing if ExplosionEnable is false.
    B:ExplosionChainReactEnable=true

    # NetherOres have a chance to explode when mined if true.
    B:ExplosionEnable=true

    # How powerful an explosion will be. Creepers are 3, TNT is 4, electrified creepers are 6. This affects both the ability of the explosion to punch through blocks as well as the blast radius.
    I:ExplosionPower=2

    # The likelyhood an adjacent netherore will turn into an armed ore when one is mined. Percent chance out of 1000 (lower is less likely).
    I:ExplosionProbability=75

    # NetherOres have a higher chance to explode when mined with fortune if true.
    B:FortuneExplosionEnable=true

    # The maximum health a HellFish will have when spawned.
    D:HellFish.MaxHealth=12.5

    # If true, any entity not a player exploding a NetherOre will anger nearby pigmen. This only accounts for exploding, entities breaking the blocks normally will still anger pigmen.
    B:MobsAngerPigmen=true

    # If true, when NetherOres are mined with Silk Touch, nearby pigmen become angry to the player.
    B:SilkyAngryPigmenEnable=false
}


processing {

    enable {
        # Set this to false to remove the AE Grind Stone recipes (i.e., nether iron ore -> 4x iron dust).
        B:GrinderRecipes=true

        # Set this to false to remove the TE Induction Smelter recipes (i.e., nether iron ore -> 2x normal iron ore).
        B:InductionSmelterRecipes=true

        # Set this to false to remove the IC2 Macerator recipes (i.e., nether iron ore -> 4x iron dust).
        B:MaceratorRecipes=true

        # Set this to false to remove the TE Pulvierzer recipes (i.e., nether iron ore -> 4x iron dust).
        B:PulverizerRecipes=true

        # Set this to false to remove smelting NetherOres to ores (i.e., netheriron ore -> 2x normal iron ore).
        # Instead, ores will smelt to ingots or some other appropriate item.
        B:SmeltToOre=true

        # Set this to false to remove the standard furnace recipes (i.e., nether iron ore -> normal iron ore).
        B:StandardFurnaceRecipes=true
    }

    ores {

        coal {
            # Output from grinding Coal if dustCoal is not found (i.e., crystallineCoal)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Coal if oreCoal is not found or SmeltToOre is false (i.e., ingotCoal)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Coal
            I:PulverizedCount=5

            # Output from smelting Coal
            I:SmeltedCount=2
        }

        diamond {
            # Output from grinding Diamond if dustDiamond is not found (i.e., gemDiamond)
            S:AlternateOrePrefix=gem

            # Output from smelting Diamond if oreDiamond is not found or SmeltToOre is false (i.e., gemDiamond)
            S:PrimaryOrePrefix=gem

            # Output from grinding Diamond
            I:PulverizedCount=5

            # Output from smelting Diamond
            I:SmeltedCount=2
        }

        gold {
            # Output from grinding Gold if dustGold is not found (i.e., crystallineGold)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Gold if oreGold is not found or SmeltToOre is false (i.e., ingotGold)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Gold
            I:PulverizedCount=4

            # Output from smelting Gold
            I:SmeltedCount=2
        }

        iron {
            # Output from grinding Iron if dustIron is not found (i.e., crystallineIron)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Iron if oreIron is not found or SmeltToOre is false (i.e., ingotIron)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Iron
            I:PulverizedCount=4

            # Output from smelting Iron
            I:SmeltedCount=2
        }

        lapis {
            # Output from grinding Lapis if dustLapis is not found (i.e., gemLapis)
            S:AlternateOrePrefix=gem

            # Output from smelting Lapis if oreLapis is not found or SmeltToOre is false (i.e., gemLapis)
            S:PrimaryOrePrefix=gem

            # Output from grinding Lapis
            I:PulverizedCount=24

            # Output from smelting Lapis
            I:SmeltedCount=2
        }

        redstone {
            # Output from grinding Redstone if dustRedstone is not found (i.e., dustRedstone)
            S:AlternateOrePrefix=dust

            # Output from smelting Redstone if oreRedstone is not found or SmeltToOre is false (i.e., dustRedstone)
            S:PrimaryOrePrefix=dust

            # Output from grinding Redstone
            I:PulverizedCount=21

            # Output from smelting Redstone
            I:SmeltedCount=2
        }

        copper {
            # Output from grinding Copper if dustCopper is not found (i.e., crystallineCopper)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Copper if oreCopper is not found or SmeltToOre is false (i.e., ingotCopper)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Copper
            I:PulverizedCount=4

            # Output from smelting Copper
            I:SmeltedCount=2
        }

        tin {
            # Output from grinding Tin if dustTin is not found (i.e., crystallineTin)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Tin if oreTin is not found or SmeltToOre is false (i.e., ingotTin)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Tin
            I:PulverizedCount=4

            # Output from smelting Tin
            I:SmeltedCount=2
        }

        emerald {
            # Output from grinding Emerald if dustEmerald is not found (i.e., gemEmerald)
            S:AlternateOrePrefix=gem

            # Output from smelting Emerald if oreEmerald is not found or SmeltToOre is false (i.e., gemEmerald)
            S:PrimaryOrePrefix=gem

            # Output from grinding Emerald
            I:PulverizedCount=5

            # Output from smelting Emerald
            I:SmeltedCount=2
        }

        silver {
            # Output from grinding Silver if dustSilver is not found (i.e., crystallineSilver)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Silver if oreSilver is not found or SmeltToOre is false (i.e., ingotSilver)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Silver
            I:PulverizedCount=4

            # Output from smelting Silver
            I:SmeltedCount=2
        }

        lead {
            # Output from grinding Lead if dustLead is not found (i.e., crystallineLead)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Lead if oreLead is not found or SmeltToOre is false (i.e., ingotLead)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Lead
            I:PulverizedCount=4

            # Output from smelting Lead
            I:SmeltedCount=2
        }

        uranium {
            # Output from grinding Uranium if dustUranium is not found (i.e., crushedUranium)
            S:AlternateOrePrefix=crushed

            # Output from smelting Uranium if oreUranium is not found or SmeltToOre is false (i.e., ingotUranium)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Uranium
            I:PulverizedCount=4

            # Output from smelting Uranium
            I:SmeltedCount=2
        }

        nikolite {
            # Output from grinding Nikolite if dustNikolite is not found (i.e., dustNikolite)
            S:AlternateOrePrefix=dust

            # Output from smelting Nikolite if oreNikolite is not found or SmeltToOre is false (i.e., dustNikolite)
            S:PrimaryOrePrefix=dust

            # Output from grinding Nikolite
            I:PulverizedCount=21

            # Output from smelting Nikolite
            I:SmeltedCount=2
        }

        ruby {
            # Output from grinding Ruby if dustRuby is not found (i.e., gemRuby)
            S:AlternateOrePrefix=gem

            # Output from smelting Ruby if oreRuby is not found or SmeltToOre is false (i.e., gemRuby)
            S:PrimaryOrePrefix=gem

            # Output from grinding Ruby
            I:PulverizedCount=5

            # Output from smelting Ruby
            I:SmeltedCount=2
        }

        peridot {
            # Output from grinding Peridot if dustPeridot is not found (i.e., gemPeridot)
            S:AlternateOrePrefix=gem

            # Output from smelting Peridot if orePeridot is not found or SmeltToOre is false (i.e., gemPeridot)
            S:PrimaryOrePrefix=gem

            # Output from grinding Peridot
            I:PulverizedCount=5

            # Output from smelting Peridot
            I:SmeltedCount=2
        }

        sapphire {
            # Output from grinding Sapphire if dustSapphire is not found (i.e., gemSapphire)
            S:AlternateOrePrefix=gem

            # Output from smelting Sapphire if oreSapphire is not found or SmeltToOre is false (i.e., gemSapphire)
            S:PrimaryOrePrefix=gem

            # Output from grinding Sapphire
            I:PulverizedCount=5

            # Output from smelting Sapphire
            I:SmeltedCount=2
        }

        platinum {
            # Output from grinding Platinum if dustPlatinum is not found (i.e., crystallinePlatinum)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Platinum if orePlatinum is not found or SmeltToOre is false (i.e., ingotPlatinum)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Platinum
            I:PulverizedCount=4

            # Output from smelting Platinum
            I:SmeltedCount=2
        }

        nickel {
            # Output from grinding Nickel if dustNickel is not found (i.e., crystallineNickel)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Nickel if oreNickel is not found or SmeltToOre is false (i.e., ingotNickel)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Nickel
            I:PulverizedCount=4

            # Output from smelting Nickel
            I:SmeltedCount=2
        }

        steel {
            # Output from grinding Steel if dustSteel is not found (i.e., crystallineSteel)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Steel if oreSteel is not found or SmeltToOre is false (i.e., ingotSteel)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Steel
            I:PulverizedCount=4

            # Output from smelting Steel
            I:SmeltedCount=2
        }

        iridium {
            # Output from grinding Iridium if dustIridium is not found (i.e., dropIridium)
            S:AlternateOrePrefix=drop

            # Output from smelting Iridium if oreIridium is not found or SmeltToOre is false (i.e., ingotIridium)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Iridium
            I:PulverizedCount=4

            # Output from smelting Iridium
            I:SmeltedCount=2
        }

        osmium {
            # Output from grinding Osmium if dustOsmium is not found (i.e., crystallineOsmium)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Osmium if oreOsmium is not found or SmeltToOre is false (i.e., ingotOsmium)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Osmium
            I:PulverizedCount=4

            # Output from smelting Osmium
            I:SmeltedCount=2
        }

        sulfur {
            # Output from grinding Sulfur if dustSulfur is not found (i.e., crystalSulfur)
            S:AlternateOrePrefix=crystal

            # Output from smelting Sulfur if oreSulfur is not found or SmeltToOre is false (i.e., crystalSulfur)
            S:PrimaryOrePrefix=crystal

            # Output from grinding Sulfur
            I:PulverizedCount=24

            # Output from smelting Sulfur
            I:SmeltedCount=2
        }

        titanium {
            # Output from grinding Titanium if dustTitanium is not found (i.e., crystallineTitanium)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Titanium if oreTitanium is not found or SmeltToOre is false (i.e., ingotTitanium)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Titanium
            I:PulverizedCount=4

            # Output from smelting Titanium
            I:SmeltedCount=2
        }

        mithril {
            # Output from grinding Mithril if dustMithril is not found (i.e., crystallineMithril)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Mithril if oreMithril is not found or SmeltToOre is false (i.e., ingotMithril)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Mithril
            I:PulverizedCount=4

            # Output from smelting Mithril
            I:SmeltedCount=2
        }

        adamantium {
            # Output from grinding Adamantium if dustAdamantium is not found (i.e., crystallineAdamantium)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Adamantium if oreAdamantium is not found or SmeltToOre is false (i.e., ingotAdamantium)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Adamantium
            I:PulverizedCount=4

            # Output from smelting Adamantium
            I:SmeltedCount=2
        }

        rutile {
            # Output from grinding Rutile if dustRutile is not found (i.e., crystallineRutile)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Rutile if oreRutile is not found or SmeltToOre is false (i.e., ingotRutile)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Rutile
            I:PulverizedCount=4

            # Output from smelting Rutile
            I:SmeltedCount=2
        }

        tungsten {
            # Output from grinding Tungsten if dustTungsten is not found (i.e., crystallineTungsten)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Tungsten if oreTungsten is not found or SmeltToOre is false (i.e., ingotTungsten)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Tungsten
            I:PulverizedCount=4

            # Output from smelting Tungsten
            I:SmeltedCount=2
        }

        amber {
            # Output from grinding Amber if dustAmber is not found (i.e., gemAmber)
            S:AlternateOrePrefix=gem

            # Output from smelting Amber if oreAmber is not found or SmeltToOre is false (i.e., gemAmber)
            S:PrimaryOrePrefix=gem

            # Output from grinding Amber
            I:PulverizedCount=5

            # Output from smelting Amber
            I:SmeltedCount=2
        }

        tennantite {
            # Output from grinding Tennantite if dustTennantite is not found (i.e., crystallineTennantite)
            S:AlternateOrePrefix=crystalline

            # Output from smelting Tennantite if oreTennantite is not found or SmeltToOre is false (i.e., ingotTennantite)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Tennantite
            I:PulverizedCount=4

            # Output from smelting Tennantite
            I:SmeltedCount=2
        }

        salt {
            # Output from grinding Salt if dustSalt is not found (i.e., foodSalt)
            S:AlternateOrePrefix=food

            # Output from smelting Salt if oreSalt is not found or SmeltToOre is false (i.e., foodSalt)
            S:PrimaryOrePrefix=food

            # Output from grinding Salt
            I:PulverizedCount=12

            # Output from smelting Salt
            I:SmeltedCount=2
        }

        saltpeter {
            # Output from grinding Saltpeter if dustSaltpeter is not found (i.e., crystalSaltpeter)
            S:AlternateOrePrefix=crystal

            # Output from smelting Saltpeter if oreSaltpeter is not found or SmeltToOre is false (i.e., crystalSaltpeter)
            S:PrimaryOrePrefix=crystal

            # Output from grinding Saltpeter
            I:PulverizedCount=10

            # Output from smelting Saltpeter
            I:SmeltedCount=2
        }

        magnesium {
            # Output from grinding Magnesium if dustMagnesium is not found (i.e., crushedMagnesium)
            S:AlternateOrePrefix=crushed

            # Output from smelting Magnesium if oreMagnesium is not found or SmeltToOre is false (i.e., ingotMagnesium)
            S:PrimaryOrePrefix=ingot

            # Output from grinding Magnesium
            I:PulverizedCount=8

            # Output from smelting Magnesium
            I:SmeltedCount=2
        }

    }

}


worldgen {

    enable {
        # If true, Nether Ores worldgen will run in all dimensions instead of just the Nether. It will still require netherrack to place ores.
        B:AllDimensionWorldGen=false

        # If true, will spawn nether ores regardless of if a furnace or macerator recipe was found. If false, at least one of those two must be found to spawn the ore.
        B:ForceOreSpawn=false

        # If true, Nether Ores oregen will run and places ores in the world where appropriate. Only disable this if you intend to use the ores with a custom ore generator. (overrides per-ore forcing; hellfish still generate if enabled)
        B:OreGen=true

        # If true, Nether Quartz ore will be a NetherOre and will follow the same rules as all other NetherOres.
        B:OverrideNetherQuartz=true
    }

    hellfish {
        # The maximum number of hellfish blocks per vein.
        I:BlocksPerGroup=12

        # If true, Hellfish will spawn in the Nether. Note that setting this false will not kill active Hellfish mobs.
        B:Enable=true

        # If true, Hellfish will spawn from broken NetherOres.
        B:EnableSpawningFromOre=false

        # The maximum number of hellfish veins per chunk.
        I:GroupsPerChunk=9
        I:MaxY=127
        I:MinY=1

        # Retroactively generate HellFish
        B:Retrogen=true

        # The chance out of 10000 that a broken ore will spawn a hellfish.
        I:SpawningFromOreChance=1000
    }

    ores {

        coal {
            I:BlocksPerGroup=16

            # Disables generation of Coal (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Coal to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=8
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Coal
            I:MiningLevel=2

            # Retroactively generate Coal if enabled in CoFHCore
            B:Retrogen=true
        }

        diamond {
            I:BlocksPerGroup=3

            # Disables generation of Diamond (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Diamond to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=4
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Diamond
            I:MiningLevel=2

            # Retroactively generate Diamond if enabled in CoFHCore
            B:Retrogen=true
        }

        gold {
            I:BlocksPerGroup=6

            # Disables generation of Gold (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Gold to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=8
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Gold
            I:MiningLevel=2

            # Retroactively generate Gold if enabled in CoFHCore
            B:Retrogen=true
        }

        iron {
            I:BlocksPerGroup=8

            # Disables generation of Iron (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Iron to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=8
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Iron
            I:MiningLevel=2

            # Retroactively generate Iron if enabled in CoFHCore
            B:Retrogen=true
        }

        lapis {
            I:BlocksPerGroup=6

            # Disables generation of Lapis (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Lapis to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=6
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Lapis
            I:MiningLevel=2

            # Retroactively generate Lapis if enabled in CoFHCore
            B:Retrogen=true
        }

        redstone {
            I:BlocksPerGroup=8

            # Disables generation of Redstone (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Redstone to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=6
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Redstone
            I:MiningLevel=2

            # Retroactively generate Redstone if enabled in CoFHCore
            B:Retrogen=true
        }

        copper {
            I:BlocksPerGroup=8

            # Disables generation of Copper (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Copper to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=8
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Copper
            I:MiningLevel=2

            # Retroactively generate Copper if enabled in CoFHCore
            B:Retrogen=true
        }

        tin {
            I:BlocksPerGroup=8

            # Disables generation of Tin (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Tin to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=8
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Tin
            I:MiningLevel=2

            # Retroactively generate Tin if enabled in CoFHCore
            B:Retrogen=true
        }

        emerald {
            I:BlocksPerGroup=2

            # Disables generation of Emerald (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Emerald to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=3
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Emerald
            I:MiningLevel=2

            # Retroactively generate Emerald if enabled in CoFHCore
            B:Retrogen=true
        }

        silver {
            I:BlocksPerGroup=4

            # Disables generation of Silver (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Silver to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=6
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Silver
            I:MiningLevel=2

            # Retroactively generate Silver if enabled in CoFHCore
            B:Retrogen=true
        }

        lead {
            I:BlocksPerGroup=6

            # Disables generation of Lead (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Lead to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=6
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Lead
            I:MiningLevel=2

            # Retroactively generate Lead if enabled in CoFHCore
            B:Retrogen=true
        }

        uranium {
            I:BlocksPerGroup=2

            # Disables generation of Uranium (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Uranium to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=3
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Uranium
            I:MiningLevel=2

            # Retroactively generate Uranium if enabled in CoFHCore
            B:Retrogen=true
        }

        nikolite {
            I:BlocksPerGroup=4

            # Disables generation of Nikolite (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Nikolite to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=8
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Nikolite
            I:MiningLevel=2

            # Retroactively generate Nikolite if enabled in CoFHCore
            B:Retrogen=true
        }

        ruby {
            I:BlocksPerGroup=3

            # Disables generation of Ruby (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Ruby to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=6
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Ruby
            I:MiningLevel=2

            # Retroactively generate Ruby if enabled in CoFHCore
            B:Retrogen=true
        }

        peridot {
            I:BlocksPerGroup=3

            # Disables generation of Peridot (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Peridot to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=6
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Peridot
            I:MiningLevel=2

            # Retroactively generate Peridot if enabled in CoFHCore
            B:Retrogen=true
        }

        sapphire {
            I:BlocksPerGroup=3

            # Disables generation of Sapphire (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Sapphire to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=6
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Sapphire
            I:MiningLevel=2

            # Retroactively generate Sapphire if enabled in CoFHCore
            B:Retrogen=true
        }

        platinum {
            I:BlocksPerGroup=3

            # Disables generation of Platinum (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Platinum to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=1
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Platinum
            I:MiningLevel=2

            # Retroactively generate Platinum if enabled in CoFHCore
            B:Retrogen=true
        }

        nickel {
            I:BlocksPerGroup=6

            # Disables generation of Nickel (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Nickel to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=4
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Nickel
            I:MiningLevel=2

            # Retroactively generate Nickel if enabled in CoFHCore
            B:Retrogen=true
        }

        steel {
            I:BlocksPerGroup=4

            # Disables generation of Steel (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Steel to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=3
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Steel
            I:MiningLevel=2

            # Retroactively generate Steel if enabled in CoFHCore
            B:Retrogen=true
        }

        iridium {
            I:BlocksPerGroup=2

            # Disables generation of Iridium (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Iridium to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=1
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Iridium
            I:MiningLevel=2

            # Retroactively generate Iridium if enabled in CoFHCore
            B:Retrogen=true
        }

        osmium {
            I:BlocksPerGroup=7

            # Disables generation of Osmium (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Osmium to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=8
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Osmium
            I:MiningLevel=2

            # Retroactively generate Osmium if enabled in CoFHCore
            B:Retrogen=true
        }

        sulfur {
            I:BlocksPerGroup=12

            # Disables generation of Sulfur (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Sulfur to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=12
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Sulfur
            I:MiningLevel=2

            # Retroactively generate Sulfur if enabled in CoFHCore
            B:Retrogen=true
        }

        titanium {
            I:BlocksPerGroup=2

            # Disables generation of Titanium (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Titanium to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=3
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Titanium
            I:MiningLevel=2

            # Retroactively generate Titanium if enabled in CoFHCore
            B:Retrogen=true
        }

        mithril {
            I:BlocksPerGroup=6

            # Disables generation of Mithril (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Mithril to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=6
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Mithril
            I:MiningLevel=2

            # Retroactively generate Mithril if enabled in CoFHCore
            B:Retrogen=true
        }

        adamantium {
            I:BlocksPerGroup=4

            # Disables generation of Adamantium (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Adamantium to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=5
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Adamantium
            I:MiningLevel=2

            # Retroactively generate Adamantium if enabled in CoFHCore
            B:Retrogen=true
        }

        rutile {
            I:BlocksPerGroup=4

            # Disables generation of Rutile (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Rutile to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=3
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Rutile
            I:MiningLevel=2

            # Retroactively generate Rutile if enabled in CoFHCore
            B:Retrogen=true
        }

        tungsten {
            I:BlocksPerGroup=8

            # Disables generation of Tungsten (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Tungsten to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=8
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Tungsten
            I:MiningLevel=2

            # Retroactively generate Tungsten if enabled in CoFHCore
            B:Retrogen=true
        }

        amber {
            I:BlocksPerGroup=6

            # Disables generation of Amber (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Amber to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=5
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Amber
            I:MiningLevel=2

            # Retroactively generate Amber if enabled in CoFHCore
            B:Retrogen=true
        }

        tennantite {
            I:BlocksPerGroup=8

            # Disables generation of Tennantite (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Tennantite to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=8
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Tennantite
            I:MiningLevel=2

            # Retroactively generate Tennantite if enabled in CoFHCore
            B:Retrogen=true
        }

        salt {
            I:BlocksPerGroup=5

            # Disables generation of Salt (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Salt to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=5
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Salt
            I:MiningLevel=2

            # Retroactively generate Salt if enabled in CoFHCore
            B:Retrogen=true
        }

        saltpeter {
            I:BlocksPerGroup=4

            # Disables generation of Saltpeter (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Saltpeter to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=6
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Saltpeter
            I:MiningLevel=2

            # Retroactively generate Saltpeter if enabled in CoFHCore
            B:Retrogen=true
        }

        magnesium {
            I:BlocksPerGroup=5

            # Disables generation of Magnesium (overrides global ForceOreSpawn)
            B:Disable=false

            # Force Magnesium to generate (overrides Disable)
            B:Force=false
            I:GroupsPerChunk=4
            I:MaxY=127
            I:MinY=1

            # The pickaxe level required to mine Magnesium
            I:MiningLevel=2

            # Retroactively generate Magnesium if enabled in CoFHCore
            B:Retrogen=true
        }

    }

}


