=============================
System 1: Permanent Variables
=============================

The amount of permanent variables that in this Demo is 2 million (2 000 000)
The amount of temporary variables is roughly 2000
(Keep in mind both types are actually permanent until you reset them)
NOTE: These variables do not have a distinct/defined data type
THIS MEANS YOU CAN READ AND WRITE AS INTEGER OR FLOAT TO ANY VAR.

=========================
Permanent Var Read Syntax
=========================

Perm(0) >> Read Variable(0) as Integer
PermF(0) >> Read Variable(0) as Float

=========================
Permanent Var Set Syntax
=========================

The Set Function and SetF Functions take 'two' arguments
The Address, and the Value
When using Var Reading triggers inside the set function
They return their address instead of their value
This stores the address of the variable for usage
And we ensure that this returns 0 so we can properly store the value as another argument.
This is why the + operator is used, it sets the address and returns nothing.
This is done by a lookahead at the parsing step.
Meaning, you MUST supply the Perm/Temp/Custom Trigger as the first trigger after the parenthesis
As it is parsed left to right.
Secondly, we provide the value with a + operator
The + operator is the generally safest operator
You CANNOT use logical operators as if you are expecting a non-bool result.
Note bitwise operators cannot be used on floats.

Set(Perm(Random) + ID)
  SetInt
  This will Set a random permanent variable from 0 to 99 the value of 'ID'
SetF(Perm(Random) + ID * 1.01)
  SetFloat
  This will Set a random permanent variable from 0 to 99 the value of 'ID' * 1.01

WARNING:
Because SetF is a workaround for accepting floats as arguments
If you do not pass a float as the argument
Then SetF DOES NOT SET ANYTHING

==========================
Permanent Var Reset Syntax
==========================

The special function for resetting a range of Permanent Variables is as follows

[State -2]
Type = Null
Trigger1 = ResetPerm(Reset(0)+RoundNo)

RoundNo is the upper range, and the argument to Reset() is the start range.
NOTE: This is inclusive, meaning up to AND the number you specify are reset.

===============================
System 2: 'Temporary' Variables
===============================

Each Player has about 2000 Temporary Variables
The way temporary variables work is players in specific slots owns a specific range.
HOWEVER THE DATA IS NOT ERASED ON DESTROYSELF
THE CORE PRINCIPLE IS ALLOWING THE USER TO RESET THEIR VARIABLES AS NEEDED
WHEN ANOTHER HELPER ENTERS THE SAME SLOT, YOU MUST RESET THE DATA

=============================================
Temporary Var Reset Syntax and Best Practices
=============================================

ResetTemp(LIMIT)
The ResetTemp() function only takes one argument, the end range
This means it will reset every Temp Variable from 0 to LIMIT

BEST PRACTICES:
On the frame a helper is created
ResetTemp(xxx), where XXX is the highest temporary variable index you that helper can use.
NOTE: It is pointless to ResetTemp on DestroySelf, if you don't do full resets
NOTE: Because different helpers need different amount of variables

I suggest setting the first Temp Var as your Player ID so you can have an easier reset.

[State ]
Type = Null
Trigger1 = Temp(0) != ID
Trigger1 = Set(Temp(0) + ID)
Trigger1 = ResetTemp(1256)
IgnoreHitPause = 1

=========================
Temporary Var Read Syntax
=========================

Temp(0) >> Read TempVar(0) as Integer
TempF(0) >> Read TempVar(0) as Float

==================
Temp VarSet Syntax
==================

Only difference is the name 'Perm' and 'Temp'

[State -2]
Type = Null
Trigger1 = 1 || Set(Temp(Random) + ID)
Trigger1 = 1 || SetF(TempF(Random) + ID)

==============================
Assignment Disambiguation Note
==============================

When using Set or SetF
Perm/PermF and Temp/TempF are semantic triggers
They do the same thing in address mode.
They exist for disambiguation only.
!!! Write Type is ONLY DETERMINED by whether you use Set or SetF

=========
 Examples
=========

;; Reset All Perm Vars on a New Match
[State -2]
Type = Null
TriggerAll = IsHelper = 0
Trigger1 = RoundsExisted = 0
Trigger1 = RoundState = 0 
Trigger1 = ResetPerm(Reset(0)+2000000)
IgnoreHitPause = 1

;;Reset Temp Vars 0-1256 for the player/helper executing this.
;;I suggest setting the first Temp Var as your Player ID so you can have an easier reset.
[State ]
Type = Null
Trigger1 = Temp(0) != ID
Trigger1 = Set(Temp(0) + ID)
Trigger1 = ResetTemp(1256)
IgnoreHitPause = 1

 
=================
 Alternate Syntax
=================

If you desire to use Redirection
OR Want to separate address and value
SetPerm and SetTemp store the address as normal
Write is for setting integer values to an address (Same as Set, FLOAT arguments are truncated.)
WriteF is for setting float values to an address (Same as SetF, INTEGER arguments are ignored.)

[State -2]
Trigger1 = NumHelper(2200)
Trigger1 = 1 || Helper(2200),SetPerm(2) && Write(12345)
Trigger1 = 1 || Helper(2200),SetTemp(3) && WriteF(666.666)
Trigger1 = 1 || SetPerm(5) && Write(Time)
IgnoreHitPause = 1

[State -2]
Type = Null
Trigger1 = 1 || Helper(2200),SetTemp(3) && WriteF(666.666)

================
 Extra Questions
================

Q: What is the difference True Expansion and Fake Expansion?
True Expansion refers to expanding the amount of variables one can use
Fake Expansion refers to the ability to read (and usually write) to any variable
This is done by removing the var limit (60 and 39)
For writing, it also modifies the behaviour of the assignment operator :=
This expansion opts to not use the := operator for technical reasons.
Additionally, in WinMugen, there was a large amount of unused data
Then by using Fake Expansion, you could gain access to a larger number of variables.
This is why it is still referred to as expansion despite not being a true expansion.