Fix links and formatting everywhere (#110)

* fix every single link

* fix formatting everywhere (remove trailing spaces, fix newlines, replace tabs with spaces)

Author: undefined06855

README.md

@@ -1,14 +1,14 @@
 # Geode Docs
 
-### [Visit the Docs site](https://docs.geode-sdk.org)
+### [Visit the Docs site](https://docs.geode-sdk.org/)
 
 This is the source code for Geode's docs, containing all the hand-written tutorials.
 
 Class & function documentation is built automatically from [the Geode source code](https://github.com/geode-sdk/geode).
 
 ## Building
 
-The docs are built using [Flash](https://github.com/geode-sdk/flash). To build the docs, you need Flash, along with [CMake](https://cmake.org/install/) and [Clang](https://clang.llvm.org/).
+The docs are built using [Flash](https://github.com/geode-sdk/flash). To build the docs, you need Flash, along with [CMake](https://cmake.org/install) and [Clang](https://clang.llvm.org/).
 
 To build the docs, you first need to clone Geode, and then clone the docs inside the Geode root, for a folder structure like this:
 

flash-template/default.css

@@ -24,7 +24,7 @@ body {
     body {
         grid-template-columns: 1fr;
     }
-    
+
     nav {
         position: absolute;
         width: 100%;

geometrydash/index.md

@@ -3,4 +3,4 @@ title: Geometry Dash
 order: 6
 ---
 
-These pages contain documentation for Geometry Dash.
+These pages contain documentation for Geometry Dash.

getting-started/cpp-stuff.md

@@ -7,8 +7,8 @@ order: 2
 
 To be able to use the Geode SDK, you **will** need at least the following:
  * [A C++ compiler](#compiler)
- * [CMake](https://cmake.org/download/) - Version 3.29+ is required - make sure to add to PATH when installing on Windows.
- * [Git](https://git-scm.com/downloads) - Hey you. Yes, you! I know a lot of people skip this step **but you will need it**. Don't come at us asking for why you "could not find git for clone of json-populate".
+ * [CMake](https://cmake.org/resources/) - Version 3.29+ is required - make sure to add to PATH when installing on Windows.
+ * [Git](https://git-scm.com/install/) - Hey you. Yes, you! I know a lot of people skip this step **but you will need it**. Don't come at us asking for why you "could not find git for clone of json-populate".
 
 ## Compiler
 
@@ -30,7 +30,7 @@ LLVM itself does not come with Windows SDK and CRT libraries, so you will need a
 
 Please note that Visual Studio **2022** or higher is required. If you have an older version already installed, you should upgrade to the latest available.
 
-Unless you want to install Visual Studio (the editor) itself, we recommend installing just the build tools. Open the VS [download page](https://visualstudio.microsoft.com/downloads), scroll to the bottom, and under "Tools for Visual Studio" download **Build Tools for Visual Studio**.
+Unless you want to install Visual Studio (the editor) itself, we recommend installing just the build tools. Open the VS [download page](https://visualstudio.microsoft.com/downloads/), scroll to the bottom, and under "Tools for Visual Studio" download **Build Tools for Visual Studio**.
 
 After launching the installer, select **Desktop development with C++** and optionally deselect all features except for **MSVC Build Tools** and **Windows SDK**, like on the screenshot below. Click Install and wait for it to finish.
 
@@ -86,4 +86,4 @@ After installing the CLI, run this command to install all the needed tools:
 geode sdk install-linux
 ```
 
-Now you can proceed to [setting up Geode CLI](/getting-started/geode-cli.md).
+Now you can proceed to [setting up Geode CLI](/getting-started/geode-cli).

getting-started/geode-cli.md

@@ -58,7 +58,7 @@ It is recommended that you [set up a profile afterwards](#profile-setup).
 
 ## MacOS
 
-You can easily install the CLI via [Brew](https://brew.sh)
+You can easily install the CLI via [Brew](https://brew.sh/)
 ```bash
 brew install geode-sdk/geode/geode-cli
 ```

getting-started/index.md

@@ -5,4 +5,4 @@ order: 1
 
 # Getting Started
 
-Please read through this chapter in order, starting in [Prerequisites](/getting-started/prerequisites.md).
+Please read through this chapter in order, starting in [Prerequisites](/getting-started/prerequisites).

getting-started/what-next.md

@@ -5,18 +5,18 @@ order: 7
 
 # What next?
 
-You should now be set on your journey to develope GD mods! If you are completely new to GD modding, a good place to start is [the Handbook](/handbook/chap0.md), which covers all of the basics of creating a Hello World.
+You should now be set on your journey to develope GD mods! If you are completely new to GD modding, a good place to start is [the Handbook](/handbook/chap0), which covers all of the basics of creating a Hello World.
 
 ## Geode Features
 
 Here are a list of Geode-specific concepts you might like to familiarize yourself with:
 
- * [Hooking with `$modify`](/tutorials/modify.md) and [adding fields](/tutorials/fields.md)
- * [Using sprites and other resources](/mods/resources.md)
- * [Settings](/mods/settings.md) and [saving data](/mods/savedata.md)
- * [String IDs](/tutorials/nodetree.md) and [Layouts](/tutorials/layouts.md)
- * [Events](/tutorials/events.md)
- * [Using dependencies](/mods/dependencies.md)
- * [Publishing mods](/mods/publishing.md)
+ * [Hooking with `$modify`](/tutorials/modify) and [adding fields](/tutorials/fields)
+ * [Using sprites and other resources](/mods/resources)
+ * [Settings](/mods/settings) and [saving data](/mods/savedata)
+ * [String IDs](/tutorials/nodetree) and [Layouts](/tutorials/layouts)
+ * [Events](/tutorials/events)
+ * [Using dependencies](/mods/dependencies)
+ * [Publishing mods](/mods/publishing)
 
 The [Tutorials](/tutorials) category in general is a great source for information about working with Geode mods.

handbook/chap0.md

@@ -74,4 +74,3 @@ Many things in this handbook are referred to as "traditional modding". This mean
 ## Ready, set, go!
 
 **And with that, let us start with [Chapter 1.1](/handbook/vol1/chap1_1)!**
-

handbook/vol1/chap1_1.md

@@ -10,22 +10,22 @@ But how exactly does a mod work? The actual executable file for Geometry Dash th
 
 Modifying binary code is a bit difficult, however, as it is not meant to be for humans; binary code is strictly for computers, and as such it is unreadable and unmodifiable for a human. Binary code is also **platform-specific**: a mod written purely in binary would only work on one platform, and could not be ported over to others without fully rewriting the entire mod from the ground up.
 
-As a historical curiosity, it should be noted that mods used to be written fully in binary. Or, more accurately, they were written in **assembly**, which is a (somewhat) human-readable form of binary. However, to make it very clear, **no sane person does this anymore**. Working with binary code directly is nowadays only done in rare cases, which will be explained in [Chapter 1.2](/handbook/vol1/chap1_2.md).
+As a historical curiosity, it should be noted that mods used to be written fully in binary. Or, more accurately, they were written in **assembly**, which is a (somewhat) human-readable form of binary. However, to make it very clear, **no sane person does this anymore**. Working with binary code directly is nowadays only done in rare cases, which will be explained in [Chapter 1.2](/handbook/vol1/chap1_2).
 
 But what's the alternative? We can make modding much easier by knowing two facts:
 
  - Binary code is produced through **compilation**.
  - Geometry Dash is written in **C++**.
 
-**Compilation is the process of turning source code into binary code**. While we can't modify GD's binary code easily, we can write our own source code in C++ and compile it into compatible binary code. Knowing what language GD was made in is vitally important, as not all binary code is equal. Some programming languages such as [Rust](https://www.rust-lang.org/) produce wildly different binary code from C++, and while it is technically compatible, it is much easier to work with a C++ game using C++. (Some modders, however, are working on making Rust usable for modding!) Writing our mods in a higher-level language like C++ also makes porting much easier; **C++ can be compiled to compatible machine code on all the platforms GD is available on**. This does come with multiple caveats though, however those are left for a later chapter.
+**Compilation is the process of turning source code into binary code**. While we can't modify GD's binary code easily, we can write our own source code in C++ and compile it into compatible binary code. Knowing what language GD was made in is vitally important, as not all binary code is equal. Some programming languages such as [Rust](https://rust-lang.org/) produce wildly different binary code from C++, and while it is technically compatible, it is much easier to work with a C++ game using C++. (Some modders, however, are working on making Rust usable for modding!) Writing our mods in a higher-level language like C++ also makes porting much easier; **C++ can be compiled to compatible machine code on all the platforms GD is available on**. This does come with multiple caveats though, however those are left for a later chapter.
 
 What all of this means is if we write our mod in C++ and then find some way to make GD run the compiled binary code of it, then we have unlocked a path to modding! And luckily, we know how to make GD load extra code: **binary injection**.
 
 Almost every platform GD is on has some sort of **dynamic library support**. On Windows, these are known as **.DLL files**; on Mac, they're **.DYLIBs**; on Android, they're **.SO files**. A dynamic library is like a binary executable, but they have one special property: other executables can load them. This is usually done through address tables and the such; these are much too complicated for the purposes of this tutorial, and the specifics are also platform-dependant and modern modloaders use proxy DLLs instead. As such, how binary injection works in detail will not be explained here. All you have to take away is that we have methods to make GD load a dynamic library, and that acts as our entry point to modding the game.
 
-> :information_source: There is one platform that doesn't have dynamic library support: iOS (unless jailbroken). Modding on iOS without jailbreaking requires basically baking all the mods you want into a premodified game, like [iCreate](https://icreate.pro/) has done, but a general mod loader like Geode will likely never see iOS support unless some major changes to the OS happen first.
+> :information_source: There is one platform that doesn't have dynamic library support: iOS (unless jailbroken). Modding on iOS without jailbreaking requires basically baking all the mods you want into a premodified binary, like [iCreate](https://icreate.pro/) has done. This is done by the iOS loader!
 
-> :green_book: If you are interested in **learning more about binary injection**, [the Wikipedia article on DLL injection](https://en.wikipedia.org/wiki/DLL_injection) is a pretty good place to start. 
+> :green_book: If you are interested in **learning more about binary injection**, [the Wikipedia article on DLL injection](https://en.wikipedia.org/wiki/DLL_injection) is a pretty good place to start.
 
 Usually, the first custom dynamic library we make GD load is a mod loader; that is, a mod whose purpose is to load other mods. This is because the methods we use for injection are not easily scalable, but once we have our one library running, we can invent much simpler ways of loading more of them. For example, on Windows, loading a library from another library that you control is as simple as calling the `LoadLibrary` function. This can also be done an arbitary number of times within our initial library, so we can for example automatically find all the .DLL files in some directory and load them. This is how old 2.1 mod loaders such as **Mega Hack v7** used to work: they would search for all of the `.dll` files in a predefined folder like `extensions` and call `LoadLibrary` on them.
 

handbook/vol1/chap1_2.md

@@ -157,7 +157,7 @@ However, at this point it should be noted that **the syntax for hooking in Geode
 
 For now, we can leave hooking be, as before we can find any practical applications for it, we must first **find some functions to hook**.
 
-[Chapter 1.3: Functions & Addresses](/handbook/vol1/chap1_3.md)
+[Chapter 1.3: Functions & Addresses](/handbook/vol1/chap1_3)
 
 ## Notes