Update Vanilla Registry Documentation (#36)

* fix examples with java

* fix oredict description

* comment info about map key bug

* add examples of multiple ways to count

* name some code blocks

* update the modifications text

* add the new vanilla stuff

* add forge registry methods to mods

Author: WaitingIdly

docs/groovy-script/getting_started/classes.md

@@ -29,24 +29,32 @@ The default package classes are located in is `classes`, so you would run `impor
 
 ## Example
 
-::: info Basic Example {id="example"}
+:::: info Basic Example {id="example"}
 
-With this file, named `DemoClass.groovy`, placed inside the `classes` folder, and the folder being added to the `classes` element in `runConfig.json`:
+With a named `DemoClass.groovy` that is registered by the `runConfig.json` to the `classes` element,
+you can access that class from any script file or another class.
 
-```groovy
+::: code-group
+
+```groovy [classes/DemoClass.groovy]
 class DemoClass {
     final static def iron = item 'minecraft:iron_ingot'
     final static def gold = item 'minecraft:gold_ingot'
 }
 ```
 
-You are able to import and use it in other script files:
+```json [runConfig.json]
+"classes": [
+  "classes/" // targets either the file or a folder that the file is nested within
+]
+```
 
-```groovy
+```groovy [postInit/CheckIron.groovy]
 import classes.DemoClass
 
-log.info DemoClass.iron in ore('ingotIron')
+log.info(DemoClass.iron in ore('ingotIron'))
 ```
 
-
 :::
+
+::::

docs/groovy-script/getting_started/editors.md

@@ -90,8 +90,9 @@ This language support will work with any variation of Emacs, but will presume yo
 
 1. Open Emacs and install [lsp-mode](https://emacs-lsp.github.io/lsp-mode/page/installation/), and follow further installation instructions for lsp-mode.
 2. Install the GroovyScript LSP file here:
-::: details GroovyScript LSP {id="example"}
-```lisp title="lsp-groovyscript.el"
+:::: details GroovyScript LSP {id="example"}
+::: code-group
+```lisp [lsp-groovyscript.el]
 ;;; lsp-groovyscript.el --- GroovyScript LSP support for lsp-mode -*- lexical-binding: t; -*-
 
 ;; Version: 1.0.0
@@ -143,6 +144,7 @@ This language support will work with any variation of Emacs, but will presume yo
 ;;; lsp-groovyscript.el ends here
 ```
 :::
+::::
 3. [Start the Language Server](#start-the-language-server) via the instructions above
 4. The port in the `groovyscript.cfg` config file must match the port setting.
 5. Done

docs/groovy-script/getting_started/groovy_modifications.md

@@ -60,14 +60,17 @@ import static net.minecraft.util.math.MathHelper.*
 ## Maps
 
 
-GroovyScript replaces the use of `LinkedHashMap` with uses `Object2ObjectLinkedOpenHashMap` as the default map used in Groovy.
-This is done because it is slightly more memory efficient and keeps the element order.
+GroovyScript replaces uses of `LinkedHashMap` with `Object2ObjectLinkedOpenHashMap` as the default map used in Groovy.
+This is done because it is slightly more memory efficient while still keeping the element order.
 
+If you want to create a `LinkedHashMap` anyways, you can simply import it and create a new instance of it as normal.
+This only changes the shorthand method of creating maps (`[:]`).
 
 
 ## Security Restrictions
 
 
-A number of packages or classes are banned, and not able to be used by Groovy.
+A number of packages, classes, and methods are banned, and not able to be used by Groovy.
 
-When interacting with a File object through Groovy, the File can only refer to a file path that targets inside the minecraft directory.
+In particular, when interacting with a File object through Groovy,
+the File can only refer to a file path that targets inside the minecraft directory.

docs/groovy-script/getting_started/reloading.md

@@ -43,8 +43,10 @@ However, you can add your own custom class and implement reloading for your reci
 To do so, first make a new file in `classes` with the class containing an `add`, `remove`, and an `onReload` method.
 It should have an instance created inside it for access purposes.
 
-::: info DemoRegistry {id="example"}
-```groovy
+:::: info Example {id="example"}
+::: code-group {id="example"}
+
+```groovy [classes/DemoRegistry.groovy]
 import example.DemoHolder
 import example.DemoRecipe
 
@@ -74,11 +76,14 @@ class DemoRegistry {
 }
 ```
 :::
+::::
 
 Then, add an event listener that is listening for `GroovyReloadEvent`.
 Inside of this event listener, call the `onReload` method.
 
-```groovy
+::: code-group
+
+```groovy [postInit/ReloadHelper.groovy]
 import classes.DemoRegistry
 import com.cleanroommc.groovyscript.event.GroovyReloadEvent
 
@@ -87,5 +92,7 @@ eventManager.listen(GroovyReloadEvent) {
 }
 ```
 
+:::
+
 Finally, any time you would add a recipe to or remove a recipe from `DemoHolder.DemoRecipeList`,
 ensure it is manipulated via `DemoRegistry.instance`.

docs/groovy-script/getting_started/run_config.md

@@ -13,8 +13,9 @@ Scripts with stuff like Item Creation go in `groovy/preInit`.
 
 Let's see what the file can look like.
 
-::: info Example {id="example"}
-```json
+:::: info Example {id="example"}
+::: code-group
+```json [groovy/runConfig.json]
 {
   "packName": "",
   "packId": "",
@@ -42,6 +43,7 @@ Let's see what the file can look like.
 }
 ```
 :::
+::::
 
 Let's go through it bit by bit:
 

docs/groovy-script/groovy/differences_from_java.md

@@ -38,9 +38,9 @@ Parentheses around parameters are optional when there is no ambiguity.
 ::: code-group
 
 ```java
-Code.run('example');
-Code.run(Code.nested('example'));
-println('hello');
+Code.run("example");
+Code.run(Code.nested("example"));
+System.out.println("hello");
 ```
 
 ```groovy
@@ -105,7 +105,7 @@ In Groovy, you can easily create a list using square braces `[]`, using commas `
 ::: code-group
 
 ```java
-List<Integer> list = new ArrayList<>();
+List<String> list = new ArrayList<>();
 list.add("example");
 list.add("demo");
 ```
@@ -131,7 +131,11 @@ map.put(3, "demo");
 ```
 
 ```groovy
-def map = [1: "example", 3: "demo"]
+def map0 = [:]
+map0[1] = "example"
+map0[3] = "demo"
+def map1 = [1: "example", 3: "demo"]     // shorthand
+def map2 = [(1): "example", (3): "demo"] // if the key is an expression, wrapping it in parentheses may be needed
 ```
 
 :::
@@ -166,6 +170,7 @@ If the field is final, only a *getter* method will be created.
 
 ```java
 public class DemoClass {
+    private final String internal = "internal";
     private final String value = "value";
     private String name = "example";
 
@@ -185,8 +190,9 @@ public class DemoClass {
 
 ```groovy
 class DemoClass {
-    final def value = "value"
-    def name = "example"
+    private final def internal = 'internal'
+    final def value = 'value'
+    def name = 'example'
 }
 ```
 
@@ -244,7 +250,7 @@ public class DemoClass {
 
 ```groovy
 class DemoClass {
-    DemoClass foo() {
+    def foo() {
         this
     }
 
@@ -334,9 +340,9 @@ Groovy has multiple ways of simplifying interacting with multiple methods or fie
 DemoClass obj = new DemoClass();
 obj.sayHi();
 obj.value = 1;
-obj.name = 'hello';
+obj.name = "hello";
 obj.total = 100;
-obj.clay = 'clay';
+obj.clay = "clay";
 obj.current = 5;
 obj.sayGoodbye();
 ```

docs/groovy-script/groovy/loops.md

@@ -90,3 +90,60 @@ for (entry in elements) {
 
 `break` can be used at any time inside a loop to abort the current and all following runs.
 `continue` will only abort the current run and _continues_ with the next run (if the condition is still true)
+
+
+## Count
+
+There are multiple different strategies to iterate through a loop a specific number of times.
+
+::: code-group
+
+
+```groovy:no-line-numbers [while]
+def x = 0
+while (x < 10) {
+    log.info x++
+}
+```
+
+```groovy:no-line-numbers [do-while]
+def x = 0
+do {
+    log.info x++ // this would execute at least once, even if x was greater than 10
+} while (x < 10)
+```
+
+```groovy:no-line-numbers [for]
+for (def x = 0; x < 10; x++) {
+    log.info x
+}
+```
+
+```groovy:no-line-numbers [enhanced list]
+for (def x in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) {
+    log.info x
+}
+for (def x : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) { // "in" and ":" are the same here
+    log.info x
+}
+```
+
+```groovy:no-line-numbers [each list]
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].each {
+    log.info x
+}
+```
+
+```groovy:no-line-numbers [for in range]
+for (def x : 0..<10) { // creates a range
+    log.info x
+}
+```
+
+```groovy:no-line-numbers [each range]
+(0..<10).each {
+    log.info x
+}
+```
+
+:::

docs/groovy-script/groovy/maps.md

@@ -34,14 +34,37 @@ We are using the map we created above here.
 ```groovy:no-line-numbers
 println(elements['Pb']) // Lead
 println(elements['Ag']) // Silver
-println(elements['B']) // null since there is no key 'B'
+println(elements['B'])  // null since there is no key 'B'
 ```
 
 ## Modifying maps
 
 We are using the map we created above here.
 
 ```groovy:no-line-numbers
-elements['Au'] = 'Copper' // Au is know mapped to copper
-elements.remove('H') // removes H: Hydrogen
+elements['Au'] = 'Copper' // Au is now mapped to copper
+elements.remove('H')      // removes H: Hydrogen
 ```
+
+## Variable keys
+
+Groovy can have the keys of a map be set via variables.
+However, in order to do this, the key might need to be surrounded in parentheses
+to be properly handled.
+
+This is particularly relevant with GroovyScript [Object Mappers](../getting_started/object_mappers.md).
+
+```groovy:no-line-numbers
+def itemStackToValue = [
+    (item('minecraft:dirt')): -1,
+    (item('minecraft:stone')): 5,
+    (item('minecraft:clay')): 1000,
+]
+```
+
+::: info Warning {id="danger"}
+
+Failing to properly surround a key in parentheses if it requires them may result in the script file
+throwing a `MultipleCompilationErrorsException` due to being "unable to resolve class".
+
+:::