Copy PR 43 from the old docs repo (GregTechCEu#2739)

Author: mikerooni

docs/content/Modpacks/Materials-and-Elements/Material-Properties.md

@@ -5,41 +5,54 @@ title: Material Properties
 
 # Material Properties (WIP)
 
-```js
-
-BlastProperty.blastTemp() // (1)
-BlastProperty.gasTier() // (2)
-BlastProperty.durationOverride() // (3)
-BlastProperty.eutOverride() // (4)
-- DustProperty:
-   - .dust() // (5)
-- FluidPipeProperty:
-   - .fluidPipeProperties() // (6)
-- FluidProperty:
-   - .fluid() // (7)
-   - .isGas() // (8)
-   - .hasBlock() 
-- GemProperty:
-   - .gem()
-- IngotProperty:
-   - .ingot() // (9)
-      - .smeltInto()
-      - .arcSmeltInto()
-      - .magneticMaterial()
-      - .macerateInto()
-- OreProperty:
-   - .ore() // (10)
-```
-
-1. Sets the Blast Furnace Temperature of the material. If the temperature is below 1000K recipes will be generated in the Primitive Blast Furnace. If above 1750K recipes for the Hot Ingot will be created along with the Vacuum Freezer Recipe to cool the ingot. Example: `.blastTemp(2750)`
-
-2. Sets the Gas Tier which determins what GAS EBF recipes will be generated. Example: `.gasTier(LOW)`
-
-3. Overrides the EBF's default behaviour for recipe durations.
-
-4. Overrides the EBF's default behaviour for EU/t.
-
-5. Used for creating a dust material. The haverst level and burn time can be specified in the brackets. Example: `.dust(2, 4000)`
-
-6. Creates a fluid pipe out of the material it is added to. The possible values are: Max Fluid Temperature, Throughput, Gas Proof, Acid Proof, Cyro Proof, Plasma Proof,
- Channels. Example: `.fluidPipeProperties(9620, 850, false, false, false, false, 1)`
+## Blast Furnace Properties
+
+### `BlastProperty.blastTemp()`
+Sets the Blast Furnace Temperature of the material. If the temperature is below 1000K recipes will be generated in the Primitive Blast Furnace. If above 1750K recipes for the Hot Ingot will be created along with the Vacuum Freezer Recipe to cool the ingot. Example: `.blastTemp(2750)`
+
+### `BlastProperty.gasTier()`
+Sets the Gas Tier which determins what GAS EBF recipes will be generated. Example: `.gasTier(LOW)`
+
+### `BlastProperty.durationOverride()`
+Overrides the EBF's default behaviour for recipe durations.
+
+### `BlastProperty.eutOverride()`
+Overrides the EBF's default behaviour for EU/t.
+
+
+## `DustProperty.dust()`
+Used for creating a dust material. The haverst level and burn time can be specified in the brackets. Example: `.dust(2, 4000)`
+
+
+## `FluidPipeProperty.fluidPipeProperties()`
+Creates a fluid pipe out of the material it is added to. The possible values are: Max Fluid Temperature, Throughput, Gas Proof, Acid Proof, Cyro Proof, Plasma Proof,
+Channels. Example: `.fluidPipeProperties(9620, 850, false, false, false, false, 1)`
+
+
+## Fluid Properties
+
+### `FluidProperty.fluid()`
+!!! failure "Not yet documented"
+
+### `FluidProperty.isGas()`
+!!! failure "Not yet documented"
+
+### `FluidProperty.hasBlock()`
+!!! failure "Not yet documented"
+
+
+## `GemProperty.gem()`
+!!! failure "Not yet documented"
+
+
+## `IngotProperty.ingot()`
+!!! failure "Not yet documented"
+
+- `.smeltInto()`
+- `.arcSmeltInto()`
+- `.magneticMaterial()`
+- `.macerateInto()`
+
+
+## `OreProperty.ore()`
+!!! failure "Not yet documented"

docs/content/Modpacks/Materials-and-Elements/TagPrefixes-and-the-power-of-.setIgnored().md

@@ -1,46 +1,78 @@
 ---
-title: TagPrefixes and the power of .setIgnored()
+title: TagPrefixes and .setIgnored()
 ---
+
+
+# TagPrefixes And The Power Of `.setIgnored()`
+
 ## What is a TagPrefix?
-TagPrefixes are GTCEu Modern's way of streamlining applying item and block tags to Materials, along with some other functions. The `TagPrefix` class, 
-available for use in startup and server scripts, contains a number of predefined TagPrefixes that 
-associate potentially everything from drill heads to flawless gemstones with a material. A common and easy-to-understand example is `TagPrefix.ingot`, 
-which associates with all Materials that have an IngotProperty and thus an associated ingot item, including custom ones defined via KubeJS. 
-TagPrefixes provide localization, item and block tagging, and influence many crafting recipes, and are integral to the functioning of GTCEu's material definition system.
+
+TagPrefixes are GTCEu Modern's way of streamlining applying item and block tags to Materials, along with some other
+functions. The `TagPrefix` class, available for use in startup and server scripts, contains a number of predefined
+TagPrefixes that associate potentially everything from drill heads to flawless gemstones with a material.
+
+A common and easy-to-understand example is `TagPrefix.ingot`, which associates with all Materials that have an
+IngotProperty and thus an associated ingot item, including custom ones defined via KubeJS.  
+TagPrefixes provide localization, item and block tagging, and influence many crafting recipes, and are integral to the
+functioning of GTCEu's material definition system.
 
 !!! tip "What TagPrefixes are there?"
-    A list of all availabe TagPrefixes can be found in GTCEu Modern's GitHub or in the .JAR file, in the class `TagPrefix`.
+A list of all available TagPrefixes can be found in GTCEu Modern's GitHub, in the class `TagPrefix`.
+
 
-## What is .setIgnored()?
+## What is `.setIgnored()`?
+
+While trawling through GTCEu Modern's codebase, or simply by playing Minecraft, you may have noticed that GTCEu Modern
+treats some vanilla materials differently. For example, iron ingots are a vanilla item, yet GTCEu Modern does not create
+a duplicate iron ingot, as its Material definition would suggest it is meant to do.
+
+Instead, the GTCEu Modern Material entry for iron treats the vanilla iron ingot as the material's ingot, and thus
+produces no duplicates.  
+This functionality is governed by TagPrefixes, and can also be harnessed by packmakers for their own custom items, or
+when writing compatibility between GTCEu Modern and another mod.
 
-While trawling thorugh GTCEu Modern's codebase, or simply by playing Minecraft, you may have noticed that GTCEu Modern treats some vanilla materials differently.
-For example, iron ingots are a vanilla item, yet GTCEu Modern does not create a duplicate iron ingot, as its Material definition would suggest it is meant to do.
-Instead, the GTCEu Modern Material entry for iron treats the vanilla iron ingot as the material's ingot, and thus produces no duplicates.
-This functionality is governed by TagPrefixes, and can also be harnessed by packmakers for their own custom items, or when writing compatibility between GTCEu Modern and another mod.
 
 ## Okay, but how do I use this?
 
 This functionality can be leveraged in the material modification event, which is a startup event.
-The material modification event occurs in Minecraft's boot sequence after Material registration is finalized, but before the Material registry is closed; you won't be able to define any new Materials using it.
+The material modification event occurs in Minecraft's boot sequence after Material registration is finalized, but before
+the Material registry is closed; you won't be able to define any new Materials using it.
+
 The following calls are available for each TagPrefix:
-  - `.setIgnored()` with one input parameter: Takes a `Material` as input and prevents GTCEu from associating that specific TagPrefix with that Material.
-  - `.setIgnored()` with two input parameters: Takes a `Material` and an `Item` or `Block` (or any class that that implements the `ItemLike` interface) as input; causes GTCEu to treat the passed `ItemLike` as whatever item the TagPrefix would have originally generated for the Material. An `ItemLike...` varargs in the form of a JS array may also be passed to perform the action on multiple blocks and/or items at once.
-  - `.removeIgnored()`: takes a `Material` as input and re-enables generation of the item associated with the TagPrefix for that material.
 
-!!! caution "Beware of `Item.of()`!" The classic way to retrieve an `Item` in KubeJS, namely the `Item.of()` wrapper, doesn't work here. You will need to directly pass an `ItemLike` from a Java class for `.setIgnored()` to work correctly.
+- `.setIgnored()` with one input parameter:  
+  Takes a `Material` as input and prevents GTCEu from associating that specific TagPrefix with that Material.
+- `.setIgnored()` with two input parameters:  
+  Takes a `Material` and an `Item` or `Block` (or any class that that implements the `ItemLike` interface) as input;
+  causes GTCEu to treat the passed `ItemLike` as whatever item the TagPrefix would have originally generated for the
+  Material. An `ItemLike...` varargs in the form of a JS array may also be passed to perform the action on multiple
+  blocks and/or items at once.
+- `.removeIgnored()`:  
+  Takes a `Material` as input and re-enables generation of the item associated with the TagPrefix for that material.
+
+!!! caution "Beware of `Item.of()`!"
+The classic way to retrieve an `Item` in KubeJS, namely the `Item.of()` wrapper, doesn't work here.  
+You will need to directly pass an `ItemLike` from a Java class for `.setIgnored()` to work correctly.
 
 A more illustrative example, using some Applied Energistics 2 items:
 
-  ```js title="setignored_usage_example.js"
-  GTCEuStartupEvents.materialModification(event => { // (1)
-      TagPrefix.gemChipped.setIgnored(GTMaterialRegistry.getMaterial("fluix_crystal")) // (2)
-      TagPrefix.rock.setIgnored(GTMaterialRegistry.getMaterial("sky_stone"), AEBlocks.SKY_STONE_BLOCK) // (3)
-      TagPrefix.ingot.removeIgnored(GTMaterials.Iron) // (4)
-  })
-  ```
-  1. This event has no methods such as `event.create()`, as it is not intended to be used to create anything, only tweak pre-existing Material associations. In fact, this event has no accessible methods whatsoever.
-  2. This call prevents GTCEu Modern from creating a chipped gem variant of the custom 'fluix_crystal' Material.
-  3. This call makes GTCEu Modern associate AE2's Sky Stone block as a rock type (like vanilla stone is associated with the GTCEu Modern stone `Material`) with the custom 'sky_stone' Material. It may be necessary to manually load whatever data definition class contains the `ItemLike` you wish to associate with your `Material`, depending on how the mod's author has provided KubeJS access to the modn's classes.
-  4. This call makes GTCEu Modern de-associate vanilla iron ingots from GTCEu Modern's iron Material entry, causing it to generate a duplicate iron ingot.
-
-The `Material` for which you are adjusting the TagPrefix must be registered in GTCEu Modern's material registry; if this material is custom, this is done using `GTCEuStartupEvents.registry()`, as depicted in these docs.
+```js title="setignored_usage_example.js"
+GTCEuStartupEvents.materialModification(event => { // (1)
+    TagPrefix.gemChipped.setIgnored(GTMaterialRegistry.getMaterial("fluix_crystal")) // (2)
+    TagPrefix.rock.setIgnored(GTMaterialRegistry.getMaterial("sky_stone"), AEBlocks.SKY_STONE_BLOCK) // (3)
+    TagPrefix.ingot.removeIgnored(GTMaterials.Iron) // (4)
+})
+```
+
+1. This event has no methods such as `event.create()`, as it is not intended to be used to create anything, only tweak
+   pre-existing Material associations. In fact, this event has no accessible methods whatsoever.
+2. This call prevents GTCEu Modern from creating a chipped gem variant of the custom `fluix_crystal` Material.
+3. This call makes GTCEu Modern associate AE2's Sky Stone block as a rock type (like vanilla stone is associated with
+   the GTCEu Modern stone `Material`) with the custom `sky_stone` Material. It may be necessary to manually load
+   whatever data definition class contains the `ItemLike` you wish to associate with your `Material`, depending on how
+   the mod's author has provided KubeJS access to the mod's classes.
+4. This call makes GTCEu Modern de-associate vanilla iron ingots from GTCEu Modern's iron Material entry, causing it to
+   generate a duplicate iron ingot.
+
+The `Material` for which you are adjusting the TagPrefix must be registered in GTCEu Modern's material registry; if this
+material is custom, this is done using `GTCEuStartupEvents.registry()`, as depicted in these docs.

docs/content/Modpacks/Materials-and-Elements/The-ChemicalHelper-class.md

@@ -1,42 +1,76 @@
 ---
-title: The ChemicalHelper class
+title: ChemicalHelper
 ---
 
-It may behoove a packmaker working with GTCEu Modern to learn about the ChemicalHelper class. This class, available for use in server scripts, 
-contains a number of useful methods that can ease working with GTCEu Materials in contexts where it might not be possible, or it might be unsafe, to work with item or block tags.
+
+# The `ChemicalHelper` Class
+
+It may behoove a packmaker working with GTCEu Modern to learn about the ChemicalHelper class.
+
+This class, available for use in server scripts, contains a number of useful methods that can ease working with GTCEu
+Materials in contexts where it might not be possible, or it might be unsafe, to work with item or block tags.
+
 
 ## Useful functions that ChemicalHelper offers
+
 The following functions are available for use by packmakers:
-  - `.getMaterial()`: can take almost any form of item reference (`Item`, `ItemStack`, `Ingredient` and so on) and will return the `Material` entry associated with it.
-If there is no associated Material, the method returns `null`. A `Fluid` may also be passed as input.
-  - `.getPrefix()`: Takes an item reference as input and will return the TagPrefix it is associated with it. If there is non associated, the method will return `null`.
-  - `.getIngot()`
-  - `.getDust()`
-    - These two methods take two parameters each as input: a `Material`, and a number representing a material amount, and will return an ItemStack representation of the respective Material's dust or ingot form, if it has one.
-      The material amount is usually very large; it is generally an integer multiple or fraction of the predefined value `GTValues.M`, which is the commonly agreed-upon material amount of one (1) ingot or regular dust.
-      Depending on the amount passed, the functions will return different items: `.getIngot()`, for example, will return
-      an ItemStack representation of a block or nugget of the associated Material if the passed amount is large or small enough.
-      `.getDust()`, in similar fashion, will return regular, small or tiny dust ItemStack representations depending on the material amount passed.
-  - `.getTag()`
-  - `.getBlockTag()`
-  - `.getTags()`
-  - `.getBlockTags()`
-    - Takes a `TagPrefix` and a non-`null` `Material` as input and returns the first item or block tag
-      (or a Java array of all item or block tags if the plural functions are used) possessed by the item represented by that `TagPrefix`-`Material` combination.
-  - `.get()`: Takes a `TagPrefix`, a `Material` and optionally an item count that otherwise defaults to 1, and returns an ItemStack representing that `TagPrefix`-`Material` combination with the specified item count.
-
-Some usage examples:
+
+
+### `.getMaterial()`
+
+Can take almost any form of item reference (`Item`, `ItemStack`, `Ingredient` and so on) and will return the
+`Material` entry associated with it. If there is no associated Material, the method returns `null`.
+A `Fluid` may also be passed as input.
+
+
+### `.getPrefix()`
+
+Takes an item reference as input and will return the TagPrefix it is associated with it. If there is
+non associated, the method will return `null`.
+
+
+### `.getIngot()` / `.getDust()`
+
+These two methods take two parameters each as input: a `Material`, and a number representing a material amount,
+and will return an ItemStack representation of the respective Material's dust or ingot form, if it has one.
+
+The material amount is usually very large; it is generally an integer multiple or fraction of the predefined value
+`GTValues.M`, which is the commonly agreed-upon material amount of one (1) ingot or regular dust.
+
+Depending on the amount passed, the functions will return different items:
+
+- `.getIngot()`, for example, will return an ItemStack representation of a block or nugget of the associated Material if
+  the passed amount is large or small enough.
+- `.getDust()`, in similar fashion, will return regular, small or tiny dust ItemStack representations depending on the
+  material amount passed.
+
+
+### `.getTag()` / `.getBlockTag()` / `.getTags()` / `.getBlockTags()`
+
+Takes a `TagPrefix` and a non-`null` `Material` as input and returns the first item or block tag
+(or a Java array of all item or block tags if the plural functions are used) possessed by the item represented by
+that `TagPrefix`-`Material` combination.
+
+
+### `.get()`
+
+Takes a `TagPrefix`, a `Material` and optionally an item count that otherwise defaults to 1, and returns an
+ItemStack representing that `TagPrefix`-`Material` combination with the specified item count.
+
+
+## Usage Examples
 
 ```js title="chemicalhelper_example_script.js"
 var ironMaterial = ChemicalHelper.getMaterial(Item.of("gtceu:double_iron_plate").asItem()) // (1)
 var rawOrePrefix = ChemicalHelper.getPrefix(Item.of("gtceu:raw_platinum").asItem()) // (2)
 var cobaltIngotStack = ChemicalHelper.get(TagPrefix.ingot, GTMaterials.Cobalt, 32) // (3)
 
-var goldNugget = ChemicalHelper.getIngot(GTMaterials.Gold, GTValues.M / 9)// (4)
+var goldNugget = ChemicalHelper.getIngot(GTMaterials.Gold, GTValues.M / 9) // (4)
 var steelBlock = ChemicalHelper.getIngot(GTMaterials.Steel, GTValues.M * 9)
 
-var ashSmallDust = ChemicalHelper.getDust(GTMaterials.Ash, GTValues.M / 4)// (5)
+var ashSmallDust = ChemicalHelper.getDust(GTMaterials.Ash, GTValues.M / 4) // (5)
 ```
+
 1. `ironMaterial` is now a reference to `GTMaterials.Iron`.
 2. `rawOrePrefix` is now a reference to `TagPrefix.rawOre`.
 3. `cobaltIngotStack` is now an ItemStack representing half a stack of cobalt ingots.

docs/content/Modpacks/Ore-Generation/Bedrock-Ore-Veins.md

@@ -0,0 +1,39 @@
+---
+title: Bedrock Ore Veins
+---
+
+
+# Bedrock Ore Veins
+
+While not enabled by default, GTCEu Modern contains bedrock ore veins and bedrock ore miners.
+
+To enable this feature, you need to enable the config option **Machines -> doBedrockOres** and restart your game.
+
+!!! warning "No recipes by default"
+    The various tiers of bedrock ore miners don't have any recipes by default. It is up to modpack developers to create
+    crafting recipes for these machines.
+
+
+## Adding Bedrock Veins
+
+By default, the mod doesn't include any bedrock ore veins.
+
+You can add them using the `bedrockOreVeins` server event:
+
+```js
+GTCEuServerEvents.bedrockOreVeins(event => {
+    event.add('kubejs:overworld_bedrock_ore_vein_iron', vein => {
+        vein.weight(100)
+            .size(3) // (1)
+            .yield(10, 20)
+            .material(GTMaterials.Goethite, 5) // (2)
+            .material(GTMaterials.YellowLimonite, 2)
+            .material(GTMaterials.Hematite, 2)
+            .material(GTMaterials.Malachite, 1)
+            .dimensions('minecraft:overworld')
+    })
+})
+```
+
+1. The diameter of the bedrock vein in chunks
+2. The second parameter defines the chance of each material being mined on each cycle