Command Modules Documentation v1.7

					''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
					''''''''''''' Command Modules v1.7 Documentation '''''''''''''''
					''''''''''''''''''''  By nickcool9999 ''''''''''''''''''''''''''
					''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

	Security Disclaimers:

1)		DO NOT USE THIS IN SCRIPT BUILDERS. Although the script has its own built-in
		security system for preventing the wrong people from using commands directly,
		the global function _G.SendCommand forces the user to be OP (1 rank below admin)
		so that the command can execute. If you do include this, things may get out of
		hand quickly. Remember, this is a VERY powerful script.

2)		PLACE THIS SCRIPT IN THE SERVERSCRIPTSERVICE TO PREVENT EDITTING OF THE SCRIPT
		BY EXPLOITERS.

	List instructions:

		me - the speaker.
		others - everyone who is not the speaker.
		all - everyone.
		admins - everyone listed as an admin.
		nonadmins - everyone not listed as an admin.
		ops - everyone listed as an Operator.
		nonops - everyone not listed as an Operator.
		team - everyone on your team. If you are neutral, nobody will be selected.
		otherteams - everyone on a team which is not yours.
		random - select someone random
		random # - select # amount of random people

		And any other player will work. Also caps do not matter.

		i.e. me,admins,ops will work
		me, admins, ops will NOT work
		me,admins,nonadmins will select everyone.
		so will "all"

		to create several lists, seperate the lists with a ":"
		to create list items, connect the list items with a comma (",")
		Wildcards are used automatically, so try not to use ambiguous names.
		i.e. if you use kill:pla while Player1 and pLAYERofChips are in the game, it will kill those players.

		kill:me:me:me <-- will kill you three times

		kill:me,me,me <-- will kill you once because you are killed immediately three times
		ff:me,me,me <-- will give you three force fields, and make you lag.
		unff:me <-- removes all force fields.

	How to utilize {Flags}:

		There are three types of flags.
		One flag type is with settings:
			-<settingsflag> <settings>
		One flag type is without settings:
			-<singleflag>
		One flag type is with settings but can
		support spaces and dashes within them:
			-<settingsflag> *<longersettings>*
		And finally, flags can be trailed behind
		one another to set several settings:
			-<settingsflag> <settings> -<settingsflag> <settings>

	--{ Default Commands }--

1)		!kill:{Lists}
		kills everyone in the lists.
		create several lists to loopkill.

2)		!heal:{Lists}
		heals everyone in the lists.

3)		!teleport:{List}:{Player} OR !tp:{List}:{Player}
		teleports everyone in the list to the player.

4)		!ff:{Lists}
		forcefields everyone in the lists.

5)		!unff:{Lists}
		removes all forcefields from everyone in the lists.

6)		!vanish:{Lists}
		makes everyone in the lists completely invisible.

7)		!ghost:{Lists}
		makes everyone in the lists partially invisible.

8)		!unvanish:{Lists} OR !unghost:{Lists} OR !reveal:{Lists}
		reveals everyone in the lists.

9)		!clearinventory:{Lists} OR !clear:{Lists}
		clears everyone in the lists' tools.

10)		!clearcinventory:{Lists}
		clears everyone in the lists' tools that were given by this command script.

11)		!construction:{Lists}
		gives everyone in the lists the main building tools provided by roblox.

12)		!tool:{Lists}: {Arguments}
		gives everyone in the lists the arguments provided. You can rather specify the
		tools' names or use "all" as the argument.
		"tool:{Lists}: tools" gives only wieldable tools.
		"tool:{Lists}: bins" gives only scripted HopperBins.
		"tool:{Lists}: remotescripts" gives remote scripts.

13)		!m:{Arguments}
		Displays a message to everyone.

14)		!h: {Arguments}
		Displays a hint to everyone.

15)		!fog
		creates 5 blank messages in workspace emulating fog.

16)		!unfog
		removes all fog.

17)		!superhardcore:{Lists}
		Makes it so if anyone in the lists die they get kicked from the game automatically.

18)		!jail:{Lists}
		Jails everyone in the lists.

19)		!unjail:{Lists}
		Removes all jails from everyone in the lists.

20)		!headlight:{Lists} OR !torch:{Lists}
		Gives everyone in the lists a yellow light (Like a torch) for dark areas.

21)		!unheadlight:{Lists} OR !untorch:{Lists}
		Undoes the headlight:{Lists} command.

22)		!walkspeed:{Lists}: {Argument} OR !ws:{Lists}: {Argument}
		Gives everyone in the lists a predetermined amount of walkspeed given by the
		argument (default 16).

23)		!normalwalkspeed:{Lists} OR !nws:{Lists}
		Returns everyone in the lists' walkspeeds to the default (16).

24)		!creative:{Lists}
		Gives the player the ability to fly by double tapping space and gives the player
		the ability to run by double tapping W.

25)		!nocreative:{Lists}
		Removes all abilities gained from the creative:{Lists} command.

26)		!ccolor:{Lists}: {Color ColorHead}[: {Color ColorTorso}[: {Color LeftArm}[: {Color RightArm}[: {Color LeftLeg}[: {Color RightLeg}] ] ] ] ]
		Set the character color, with 5 additional optional arguments for each body part.
		See the ColorTranslateAPI function for a list of colors.

27)		!swapheads:{Player}:{Player}
		Switches the two players' heads between each other (Including hats worn)

28)		!blockhead:{Lists}
		Turns everyone in the lists' heads into blocks.

29)		!stat:{Lists}: {Statname}: {Value}
		Changes everyone in the lists' stat {Statname}'s value to {Value}
		i.e. stat:SpeedySeat: Money: 1 will change speedyseat's money to 1.

30)		!relativestat:{Lists}: {Statname}: {Value}
		Changes everyone in the lists' stat {Statname}'s value to itself added onto {Value}
		i.e. stat:SpeedySeat: Money: 1 will give speedyseat 1 money.
		note - useful in modulogic API

31)		!gravity:{Lists}: {Factor}
		Changes everyone in the lists' gravity multiplied by the factor.
		1 is default
		2 is double
		0.5 is half
		online, -0.085 seems to be zero gravity for some reason.

32)		!guibuild:{Lists}
		Basically an alternative to the construction command.
		Gives a tool which gives far more flexibility when building.

33)		!modulogic:{Logic} OR !ml:{Logic} OR !logic:{Logic}
		This command executes separate commands based on structured coding here.
		This is an advanced command, and beginners are not recommended to use it.

34)		!mltoggle:{Argument}
		This command toggles a setting in the modulogic internal configuration.
		You don't need to mess with this unless you're very well educated and need it.
		**MISSING DOCUMENTATION**

		**See: Module Logic Documentation

35)		!wait: {Time}
		This command is useless outside of the Modulogic API. This command basically
		waits until the Time argument above is reached, then executes the next command.
		You do not need to provide an argument if you are executing this after the m command,
		as the wait command will automatically wait 5 seconds if not given an argument.

36)		!respawn:{Lists}
		respawns everyone in the lists.
		this is an instant respawn, and also activates respawn events.

37)		!music:{SoundID}
		Spawns in a music box above your head playing the SoundID assigned.

38)		!unmusic
		Removes any music that you've spawned in, stopping them as well.

39)		!looklike:{Lists}: {PlayerID/Username}
		Makes anybody in the lists' appear as another player based on their Player ID OR Username.

40)		!delimb:{Lists}
		Gets rid of "some" limbs :> Perfect trolling mechanism!

41)		!nohats:{Lists}
		Gets rid of everybody in the lists' hats.

42)		!material:{Lists}: {Material}
		Changes the material of everyone in the lists to the desired material.

43)		!blind:{Lists}
		Makes everybody in the lists blind.

44)		!unblind:{Lists}
		Removes blindness from everybody in the lists.

45)		!citem:{ID}
		Inserts the asset ID and puts it somewhere in your character.
		You must be admin to use this command if the ID is not from ROBLOX.

46)		!jumppower:{Lists}: {Argument} OR !jp:{Lists}: {Argument}
		Gives everyone in the lists a predetermined amount of JumpPower given by the
		argument (default 50).

47)		!normaljumppower:{Lists} OR !njp:{Lists}
		Resets everyone in the lists' JumpPower to 50.

	--{ ADMIN ONLY COMMANDS }--

1)		!lua: {Code}
		!lualocal: {Code}
		Runs some lua code. Must have ServerScriptService.LoadStringEnabled on.
		**WARNING: Enabling LoadString disables your ability to use player points!
		  USE MODULOGIC WHERE YOU CAN!

2)		!promote:{Lists}
		Makes everyone in the lists an Operator.

3)		!demote:{Lists}
		Removes everyone in the lists from the Operator list.

4)		!admin:{Lists}
		**WARNING: DO NOT USE THIS COMMAND FOR PEOPLE YOU DO NOT TRUST COMPLETELY.
		YOU DO NOT NEED ADMIN TO USE COMMANDS; OPERATOR ALLOWS ALL NON-RANK COMMANDS.
		Makes everyone in the lists an admin.
		This is only temporary and does not make the user a permanent admin.
		To make a user a permanent admin, add their name to the list of admins.

5)		!unadmin:{Lists}
		Removes everyone in the lists from the admin list.
		Permanent admins will keep their admin status outside of the server.

6)		!kick:{Lists}
		Kicks everyone from the lists out of the game. This command is not
		permanent and the users can rejoin the server.

7)		!ban:{Lists}
		Bans everyone from the lists from the server. This command IS
		permanent and can only be undone using the unban: {Arguments} command.

8)		!unban: {Arguments}
		Checks the ban list for anyone who is an argument in this command and removes them.
		A message will appear confirming the removal of a banned list item.

9)		!chatprefix:{Prefix}
		Changes the chat commands' prefix. This changes the script from its default settings.
		USE WITH CAUTION!
		If you do not want any chat prefixes for these commands, simply say "!chatprefix" OR
		change the value in the config to be empty.

10)		!insert:{ID}
		Inserts the item with the ID given into workspace.

	--{ SpecialEffects CoreAPI by nickcool9999, v1.0 }--

		This command script deals with several special effects offered in the lighting service.
		Delete this script if you do not wish to have lighting commands.

		To reset any of these effects, issue the command again without any arguments.
		i.e. "!ambient".

1)		!ambient:{red}:{green}:{blue}
		Sets the ambient lighting from 0 to 1 for each color.
		i.e. ambient:1:1:1 would make the ambient full red, full green and
			 full blue, which is white.

2)		!oambient:{red}:{green}:{blue}
		Sets the outdoor ambient lighting from 0 to 1 for each color.

3)		!bcshift:{red}:{green}:{blue}
		Sets the Color Shift (Bottom) from 0 to 1 for each color.

4)		!tcshift:{red}:{green}:{blue}
		Sets the Color Shift (Top) from 0 to 1 for each color.

5)		!brightness:{Brightness}
		Sets the brightness from 0 to 10.

6)		!shadows:{(yes/true)/(no/false) enabled}
		Sets if global shadows are enabled.

7)		!outlines:{(yes/true)/(no/false) enabled}
		Sets if outlines are enabled.

8)		!shadowcolor:{red}:{green}:{blue}
		Sets the Shadow Color from 0 to 1 for each color.

9)		!fogcolor:{red}:{green}:{blue}
		Sets the Fog Color from 0 to 1 for each color.

10)		!fogstart:{Amount}
		Sets the fog start amount.

11)		!fogend:{Amount}
		Sets the fog end amount.

12)		!latitude:{Amount}
		Sets the Geographic Latitude.

	--{ GridsAPI by nickcool9999, v1.0 }--

		This is the fundemental command script that deals with 2D Arrays. This is not useful outside of
		the "assign" function of ModuLogic, which assigns the contents of a returned command to a variable.

		This API is a recreation of the popular ds_grid library from Game Maker: Studio in Lua.

1)		!ds_grid_create:{ID}:{width}:{height}
		Creates a 2D Grid

2)		!ds_grid_width:{ID}
		Gets the Grid's Width

3)		!ds_grid_height:{ID}
		Gets the Grid's Height

4)		!ds_grid_resize:{ID}:{width}:{height}
		Resizes a Grid to new dimensions

5)		!ds_grid_clear:{ID}
		Clears a grid

6)		!ds_grid_set:{ID}:{x}:{y}:{value}
		Sets a spesific value in the grid

7)		!ds_grid_set_disk:{ID}:{x}:{y}:{radius}:{value}
		Sets a circular area to a value

8)		!ds_grid_set_grid_region:{ID}:{x}:{y}:{x2}:{y2}:{x_copyto}:{y_copyto}
		Copies an area on the grid to another location

9)		!ds_grid_shuffle:{ID}
		Randomly Shuffle Values Everywhere

10)		!ds_grid_sort:{ID}:{column}:{ascending}
		Sort a row

11)		!ds_grid_get:{ID}:{x}:{y}
		Return Grid Value

12)		!ds_grid_get_max:{ID}:{x}:{y}:{x2}:{y2}
		Get Highest value in area

13)		!ds_grid_get_mean:{ID}:{x}:{y}:{x2}:{y2}
		Get Average value in area

14)		!ds_grid_get_min:{ID}:{x}:{y}:{x2}:{y2}
		Get Lowest value in area

15)		!ds_grid_get_sum:{ID}:{x}:{y}:{x2}:{y2}
		Get a sum of the values in the area

16)		!ds_grid_get_disk_max:{ID}:{x}:{y}:{radius}
		Get Highest value in circular area

17)		!ds_grid_get_disk_mean:{ID}:{x}:{y}:{radius}
		Get Average value in circular area

18)		!ds_grid_get_disk_min:{ID}:{x}:{y}:{radius}
		Get Lowest value in circular area

19)		!ds_grid_get_disk_sum:{ID}:{x}:{y}:{radius}
		Get a sum of all values in a circular area

20)		!ds_grid_add:{ID}:{x}:{y}:{value}
		Sum a value to a cell

21)		!ds_grid_add_region:{ID}:{x}:{y}:{x2}:{y2}:{value}
		Sum a value to a region

22)		!ds_grid_multiply:{ID}:{x}:{y}:{value}
		Multiply a single cell by a value

23)		!ds_grid_multiply_disk:{ID}:{x}:{y}:{radius}:{value}
		Multiply a circular region by a value

24)		!ds_grid_multiply_region:{ID}:{x}:{y}:{x2}:{y2}:{value}
		Multiply an entire region by a value

25)		!ds_grid_value_exists:{ID}:{x}:{y}:{x2}:{y2}:{value}
		Check if a value exists in an entire region

26)		!ds_grid_value_disk_exists:{ID}:{x}:{y}:{radius}:{value}
		Check if a value exists in a circular region

27)		!ds_grid_value_x:{ID}:{x}:{y}:{x2}:{y2}:{value}
		Return the x value of the first cell in a region with the value

28)		!ds_grid_value_y:{ID}:{x}:{y}:{x2}:{y2}:{value}
		Return the y value of the first cell in a region with the value

29)		!ds_grid_value_disk_x:{ID}:{x}:{y}:{radius}:{value}
		Return the x value of the first cell in a circular region with the value

30)		!ds_grid_value_disk_y:{ID}:{x}:{y}:{radius}:{value}
		Return the y value of the first cell in a circular region with the value

31)		!ds_grid_copy:{ID}:{templateID}
		Overwrite the current Grid ID with a template one.

32)		!ds_grid_read:{JSON}:{ID}
		Writes to Grid ID from JSON string.

33)		!ds_grid_write:{ID}
		returns JSON string from Grid ID

34)		!ds_grid_exists:{ID}
		Checks existance of Grid ID.

35)		!ds_grid_raw:{ID}
		Returns raw grid data of an ID.

	--{ GuiAPI by nickcool9999, v0.1 }--

		Use this to see all of the commands available in the script (that are documented).
		Unfinished API implementation for Interface support.

1)		!view
		Toggles the display of the command interface.

2)		!input_box:{Lists}: {Flags}
		Displays an input box where you can input information for another command.
		Useful if you are demonstrating commands!
		You MUST provide an -id flag!

3)		!input_wait:{BoxID}
		Wait for input from the input box ID given.

4)		!input_getinfo:{BoxID}
		Returns information about the input box ID given.
		Only works after input has been entered.
		Since this is a return command, it is only useful for ModuLogic programming.
		i.e. !ml:assign>input_getinfo:hi>variablename

	--{ ExtraCommands by nickcool9999, v1.0 }--

		This command script is purely for optional commands that are relatively advanced and experimental. This
		command script includes several extra functions that allow the user to create parts and HopperBins and more.

1)	 	!hop:{Flags}
		This command creates a HopperBin given the parameters.
		Any flag that has (Off by default) next to it means that the flag's properties won't
		be considered unless it is included during creation.
		Any flag that has a default marked next to it means that you can call the flag as a -singleflag and it uses
		the default value when parsing.
		Flags:
			-regen <HP>: The amount of HP to regen per tick() [Default: 4] (Off by default)
			-name <name>: The display name of the HopperBin [Default: CommandBin]
			-deadly: The HopperBin will kill the user of it like a reset tool. (Off by default)
			-hpset <HP>: What to set the user's HP to when clicked and selected. [Default: 0] (Off by default)
			-macro <MACRO>: Macro flag. This flag sets what commands get executed when this HopperBin is clicked. (Off by default)
			-expire <time>: The amount of time this HopperBin is allowed to exist in your world (Useful for minigames utilizing
				commands) (Off by default)

2)		!p:[x] [y] [z] {Flags}
		This command creates a Part given the parameters.
		Note: You don't need to include any flags if you want to keep their default (i.e. p: 4 1 4 or p: -c Bright blue)
		Flags:
			-n <Name> or -name <Name>: The name of the part (Part by default)
			-x <x>: The x position (Off by default)
			-y <y>: The y position (Off by default)
			-z <z>: The z position (Off by default)
			-xr <xr>: The x relative position [Default: 0 studs]
			-yr <yr>: The y relative position [Default: 5+(y size/2) studs]
			-zr <zr>: The z relative position [Default: 0 studs]
			-rx <rx>: The x rotation (In Degreesº) [Default: 0º]
			-ry <ry>: The y rotation (In Degreesº) [Default: 0º]
			-rz <rz>: The z rotation (In Degreesº) [Default: 0º]
			-us <SurfaceType>: The string surface name to set as the top [Default: Smooth]
			-ds <SurfaceType>: The string surface name to set as the bottom [Default: Smooth]
			-fs <SurfaceType>: The string surface name to set as the front [Default: Smooth]
			-bs <SurfaceType>: The string surface name to set as the back [Default: Smooth]
			-ls <SurfaceType>: The string surface name to set as the left [Default: Smooth]
			-rs <SurfaceType>: The string surface name to set as the right [Default: Smooth]
			-mat <Material>: The material setting for the part. Can be any Material. [Default: SmoothPlastic]
			-expire <time>: The amount of time this brick is allowed to exist in your world (Off by default)
			-a <true/false>: The anchored property [Default: true]
			-cc <true/false>: The CanCollide property [Default: true]
			-cj: Connects the joints of this block when created.
			-deadly <kill/explode>: Create a temporary kill brick (Off by default)
			-tpad <link>: Create a permanent teleport pad given the link string (Off by default)
			-tpadtemp <link>: Create a temporary server-only teleport pad given the link string (Off by default)
			-deb <time>: The time in seconds that the ontouch macro has before it can be used again. [Default: 1 second]
			-ontouch <MACRO>: Executes commands on behalf of the player when they touch this part.

	--{ ListsAPI by nickcool9999, v1.0 }--

		This is the fundemental command script that deals with 1D Arrays. This is not useful outside of
		the "assign" function of ModuLogic, which assigns the contents of a returned command to a variable.

		This is a far simpler version of the GridsAPI.
		This API is a recreation of the popular ds_list library from Game Maker: Studio in Lua.

1)	 	!ds_list_create:{Name}
			*RETURNS the list
		Creates an empty list

2)		!ds_list_get:{Name}
			*RETURNS the list

3)		!ds_list_add:{Name}:{Contents}
			*RETURNS the list
		Adds an entry to the list with {Contents} in it

4)		!ds_list_size:{Name}
			*RETURNS the list's size, the amount of items in it

5)		!ds_list_delete:{Name}:{Index}
			*RETURNS the list
		Omits {Index} from the {Name} list.

6)		!ds_list_remove:{Name}:{Contents}
			*RETURNS the list
		Omits all indexes with {Contents} from the {Name} list.

7)		!ds_list_clear:{Name}
			*RETURNS the list
		Completely clears the list.

8)		!ds_list_find_index:{Name}:{Contents}
			*RETURNS the {Contents} index or a negative error code.
		Finds the first entry in the list with {Contents} assigned to it.

9)		!ds_list_find_value:{Name}:{Index}
			*RETURNS the {Contents} of the {Index} in the {Name} list.
		Finds the entry in the list with the index number {Index}.

10)		!ds_list_shuffle:{Name}
			*RETURNS the list
		Shuffles the list randomly.

11)		!ds_list_sort:{Name}:{isAscending(1 if yes, 0 if no)}
			*RETURNS the list
		Sorts the list.
		ALL ENTRIES MUST BE A NUMBER OR STRING OR THIS WILL BREAK.

12)		!ds_list_copy:{Name}:{Name2}
			*RETURNS the {Name} list
		Copies the contents of the {Name2} list to {Name}.
		This process eliminates any contents {Name} had.
		Useful for list templates.

13)		!ds_list_destroy:{Name}
			*RETURNS -1 if no list goes by the name {Name}.
		Removes the {Name} list from the index memory.

14)		!ds_list_exists:{Name}
			*RETURNS true if list exists and false if not
		Checks existance of {Name} list.

	--{ PastebinAPI by nickcool9999, v0.1 }--

		Very simple commands to alias very long commands by using the Pastebin service.
		Unfinished API implementation for internal support.

1)		!pastebin:{PasteID}
		Runs the command in the Pastebin ID. Not very useful unless you do pastebin:ml:{ModuLogic}.

2)		!pml:{PasteID}
		Aliases both pastebin and "pastebin:ml:". combines the two and runs the provided pastebin ID as Modulogic.

3)		!plua:{PasteID}
		This command only works for admins. Executes lua via a Pastebin ID. Must have ServerScriptService.LoadStringEnabled checked.
		**WARNING: Enabling LoadString disables your ability to use player points!
		  USE MODULOGIC WHERE YOU CAN!

	--{ ModuleLogic API v1.1 }--

		|define - creates a variable
		|	>
		|	VariableName
		|		>
		|		Variable content (can be number, string or bool)
		|-=-
		|case - checks a variable
		|	>
		|	VariableName/Variable subgroup (Optional)
		|		>
		|		Case~(type of comparison)Number,String compared{Code executed when true}>{Otherwise case (Optional)}
		|-=-
		|function - Creates a callable function
		|	>
		|	FunctionName/Arg1,Arg2,... - Arranges the necessary arguments and name
		|		>
		|		{When called code} - Creates a new definition with this code
		|-=-
		|call - Looks through definitions of code/arguments
		|	>
		|	FunctionName - Looks for this name
		|		>
		|		Arg1,Arg2,... -- Gives these arguments
		|-=-
		|loop - Repeats a line of code
		|	>
		|	Count - Tells how many times to repeat (for player function use %players%)
		|		>
		|		{When called code} - Loops this code count many times giving %index% as a variable name. Use %player index% for player getting.
		|-=-
		|assign - Assigns results of command to a variable
		|	>
		|	Command - The command to run
		|		>
		|		Variable - The variable name to assign to.
		|-=-
		|forlist - Loops through a ds_list (Requires Lists API)
		|	>
		|	ListID - The ID of the list created from commands.
		|		>
		|		{When called code} - Loops this code list count many times giving %index%, %i% as a variable name.
		|-=-
		|forgrid - Loops through a ds_grid for each cell (Requires Grids API)
		|	>
		|	GridID - The ID of the grid created from commands.
		|		>
		|		{When called code} - Loops this code for every cell giving %index%, %x% and %y% as variable names.
		|-=-
		|		=>{
		|			This syntax creates a new thread for commands to execute. Runs aside from normal logic.
		|		}
		|-=-
		|All default variables (to access surround name in percent signs):
		|pln - speaker's name
		|mlv - version of modules being used
		|elvl - same as below, only shortenned
		|executionLevel - useful for preventing stack overflows, tells which sub-function you are in.
		|index - only useful in loops. The number of times this code block has been executed thus far
		|Playername/stat/statname - Gives the player stat's value
		|Playername/playervar/Variable in player - Gives the playervar's value
		|Playername/teamname - Gives the name of the player's team
		|Playername/name - this is used for getting which player Playername has chosen
		|players - number of players in the list
		|player # - Player from the player list with the number #
		|? new variables can be created with the define function
		|
		|module code can be executed from anywhere

	--{ ModuleLogic Examples Below (PASTE FULL TEXT IN ONLINE CHAT TO TEST) }--

			How to check your modulogic version (This snippet will be updated with new versions):
				!ml:case>mlv>given~(<)1.5{m: You are running a past version of ModuLogic.}>{m: You are up to date!}
			How to check your "Money" stat (Tells you if you have lots!):
				!ml:case>me/stat/Money>given~(>)9000{m: %me/name% has over 9000 Money!!!!1}
			How to test how far you are from a workspace instance (This case is "Pending"):
				!ml:m:%me/name%: You are %me/distancefrom/SpawnLocation% studs away from the brick.
			Case checking to see if you are close to the spawn (Creates "alt" as a variable then checks it):
				!ml:define>alt>%me/distancefrom/Pending%;case>alt>given~(<)25{m:%me/name%: You are close enough to the spawn}>{m:%me/name%: You are %SpeedySeat/distancefrom/Pending% studs away from spawn.}
			Loop through each player and tell them the script ate them:
				!ml:loop>%players%>{m: I ate %player index% for breakfast!;kill:%player index%;wait}
			Textboxes with input (Pastebin ID is WW0SScNU, you should use the command "pastebin:WW0SScNU" instead):
				ml:
				=>{  ##Thread separation##
					input_box:me: -id box -boxlabel Message 1 -dtext Test1 -button true -blabel SubTest -col 0,0,0 -tcol White -pos 0.25,0,0.25,0;
					input_wait:box;
					assign>input_getinfo:box>val;
					m:%val%
				};
				=>{  ##Thread separation##
					input_box:me: -id box2 -boxlabel Message 2 -dtext Test1 -button true -blabel SubTest -col 0,0,0 -tcol White -pos 0.75,0,0.25,0;
					input_wait:box2;
					assign>input_getinfo:box2>val;
					m:%val%
				};