Add Optional_Arguments note and page

Author: Fernando-A-Rocha

types/nil.yaml

@@ -0,0 +1,4 @@
+description: |
+  *Nil* is a type with a single value, *nil*, whose main property is to be different from any other value. A global variable has a *nil* value by default, before a first assignment, and you can assign *nil* to a global variable to delete it. Lua uses *nil* as a kind of non-value, to represent the absence of a useful value.
+
+  Reference: [Nil in Programming in Lua](https://www.lua.org/pil/2.1.html)

web/src/pages/Optional_Arguments.mdx

@@ -0,0 +1,83 @@
+import StarlightPage from '@astrojs/starlight/components/StarlightPage.astro';
+import { getSeeAlsoLinksFromList } from '@src/utils/general';
+import SeeAlsoSection from '@src/components/SeeAlsoSection.astro';
+
+<StarlightPage frontmatter={{
+    template: 'doc',
+    title: 'Optional Arguments',
+    tableOfContents: false,
+}}>
+
+**Optional arguments** are arguments which can be optionally passed to any Lua function, including MTA\:SA built-in ones. They are not required for the function to run, and can be unset ([`value == nil`](/nil)). Often, this kind of arguments do not make a huge difference in the behaviour of the function.
+
+It's a Lua convention that the arguments written between square brackets are optional, so in this Wiki you can find functions with some arguments between square brackets too. That means they are optional and that providing them is not necessary.
+
+Let's take a look at this common function:
+
+```lua
+vehicle createVehicle ( int model, float x, float y, float z, [ float rx, float ry, float rz ] )
+```
+
+In this example, `rx`, `ry`, and `rz` are optional arguments, because they are between square brackets. They do not need to be provided to the function; it will default to no rotation in every axis. If provided, the function will use the rotations specified instead.
+
+### Why are optional arguments used?
+
+More often than not, it's boring having to provide all the arguments of a certain function, especially if they are the same over and over again. The optional arguments allow the scripter to only pass the data that is really needed for their script, and that helps improve code readability and size.
+
+### Use of the optional arguments
+
+Optional arguments are used just like normal arguments. The only difference is that they will default to a certain value if not provided (in other words, `if optionalArgument == nil then optionalArgument = defaultValue`).
+
+One common problem for new scripters is when they want to provide only an optional argument, without setting the ones that are before it. Well, this is really simple to "fix". Normally, they can be set to `nil`, so they will default to their corresponding values while the scripter is still able to set the one they really want. For example, if you want to only set the rotation in the Z axis of the `createVehicle` function (and don't know that `rx` and `ry` default to zero):
+
+```lua
+vehicle createVehicle ( int model, float x, float y, float z, [ float rx, float ry, float rz ] )
+```
+
+You can use:
+
+```lua
+local myAwesomeVehicle = createVehicle( getVehicleModelFromName( "Infernus" ), 0, 0, 5, nil, nil, 180 )
+```
+
+And the result will be an Infernus rotated 180 degrees in the Z axis in the center of the map.
+
+> ⚠️ **Warning**
+> There are some built-in MTA\:SA functions that don't follow this convention, especially when an optional argument is closely related to another (e.g. color arguments in DX functions, and probably others): instead of replacing the `nil` value, they output a 'bad argument' error and do nothing.
+> **Always check if this works with a function before using it in a script.**
+
+### Scripting custom functions with optional arguments
+
+Scripting functions with optional arguments is as easy as using `if` statements:
+
+```lua
+function aNotSoUsefulFunction( text )
+    if type( text ) == "string" or type( text ) == "nil" then -- Check if correct arguments have been provided
+        local realTextToOutput
+        if text == nil then
+            realTextToOutput = "I <3 optional arguments" -- If the text is nil (not specified), use a default one
+        else
+            realTextToOutput = text -- Use the text that the user specified if defined
+        end
+        outputChatBox( realTextToOutput ) -- Output the text
+    end
+end
+```
+
+You can also use [short-circuit evaluation](http://en.wikipedia.org/wiki/Short-circuit_evaluation), if you prefer to:
+
+```lua
+function aNotSoUsefulFunction( text )
+    local realTextToOutput = ( type( text ) == "string" or type( text ) == "nil" ) and ( type( text ) == "string" and text or "I <3 optional arguments" ) or nil
+    if realTextToOutput then -- Check if there is something to output
+        outputChatBox( realTextToOutput ) -- Output the text
+    end
+end
+```
+
+
+<SeeAlsoSection seeAlsoLinks={getSeeAlsoLinksFromList([
+    'article:Scripting_Introduction',
+])} currentId='' />
+
+</StarlightPage>

web/src/pages/[func].astro

@@ -164,6 +164,7 @@ let funcSyntaxes = parseFunctionSyntaxes(func.id, func.data);
                     {syntax.parameters.some((param: any) => param.default) && (
                     <>
                         <h5>Optional Arguments</h5>
+                        <p><strong>NOTE</strong>: When using <a href="/Optional_Arguments">optional arguments</a>, you might need to supply all arguments before the one you wish to use.</p>
                         <ul>
                         {syntax.parameters
                             .filter((param: any) => param.default)