View difference between Paste ID: QSetupzQ and 1NC67Zqv

 					''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
 					''''''''''''' 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.
 
-	Commands:
+
 		me, admins, ops will NOT work
-1)		kill:{Lists}
+
 		so will "all"
 
 		to create several lists, seperate the lists with a ":"
-2)		heal:{Lists}
+
 		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.
-3)		teleport:{List}:{Player} OR tp:{List}:{Player}
+
 		kill:me:me:me <-- will kill you three times
 
-4)		ff:{Lists}
+
 		ff:me,me,me <-- will give you three force fields, and make you lag.
 		unff:me <-- removes all force fields.
-5)		unff:{Lists}
+
 	How to utilize {Flags}:
 
-6)		vanish:{Lists}
+		There are three types of flags.
 		One flag type is with settings:
 			-<settingsflag> <settings>
-7)		ghost:{Lists}
+		One flag type is without settings:
 			-<singleflag>
 		One flag type is with settings but can
-8)		unvanish:{Lists} OR unghost:{Lists} OR reveal:{Lists}
+		support spaces and dashes within them:
 			-<settingsflag> *<longersettings>*
 		And finally, flags can be trailed behind
-9)		clearinventory:{Lists} OR clear:{Lists}
+		one another to set several settings:
 			-<settingsflag> <settings> -<settingsflag> <settings>
 
-10)		clearcinventory:{Lists}
+	--{ Default Commands }--
 
 1)		!kill:{Lists}
-11)		construction:{Lists}
+
 		create several lists to loopkill.
 
-12)		tool:{Lists}: {Arguments}
+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}
-13)		m: {Arguments}
+
 
 5)		!unff:{Lists}
-14)		h: {Arguments}
+
 
 6)		!vanish:{Lists}
-15)		fog
+
 
 7)		!ghost:{Lists}
-16)		unfog
+
 
 8)		!unvanish:{Lists} OR !unghost:{Lists} OR !reveal:{Lists}
-17)		superhardcore:{Lists}
+
 
 9)		!clearinventory:{Lists} OR !clear:{Lists}
-18)		jail:{Lists}
+
 
 10)		!clearcinventory:{Lists}
-19)		unjail:{Lists}
+
 
 11)		!construction:{Lists}
-20)		headlight:{Lists} OR torch:{Lists}
+
 
 12)		!tool:{Lists}: {Arguments}
-21)		unheadlight:{Lists} OR untorch:{Lists}
+
 		tools' names or use "all" as the argument.
 		"tool:{Lists}: tools" gives only wieldable tools.
-22)		walkspeed:{Lists}: {Argument}
+
 		"tool:{Lists}: remotescripts" gives remote scripts.
 
 13)		!m:{Arguments}
-23)		normalwalkspeed:{Lists}
+
 
 14)		!h: {Arguments}
-24)		creative:{Lists}
+
 
 15)		!fog
 		creates 5 blank messages in workspace emulating fog.
-25)		nocreative:{Lists}
+
 16)		!unfog
 		removes all fog.
-26)		ccolor:{Lists}: {Color ColorHead}[, {Color ColorTorso}[, {Color LeftArm}[, {Color RightArm}[, {Color LeftLeg}[, {Color RightLeg}] ] ] ] ]
+
 17)		!superhardcore:{Lists}
 		Makes it so if anyone in the lists die they get kicked from the game automatically.
 
-27)		swapheads:{Player}:{Player}
+18)		!jail:{Lists}
 		Jails everyone in the lists.
 
-28)		blockhead:{Lists}
+19)		!unjail:{Lists}
 		Removes all jails from everyone in the lists.
 
-29)		stat:{Lists}: {Statname}: {Value}
+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}
-30)		relativestat:{Lists}: {Statname}: {Value}
+
 
 22)		!walkspeed:{Lists}: {Argument} OR !ws:{Lists}: {Argument}
 		Gives everyone in the lists a predetermined amount of walkspeed given by the
 		argument (default 16).
-31)		chair:{Lists}
+
-		Gives a chair to everyone in the lists.
+23)		!normalwalkspeed:{Lists} OR !nws:{Lists}
 		Returns everyone in the lists' walkspeeds to the default (16).
-32)		guibuild:{Lists}
+
 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.
-33)		modulogic:{Logic} OR ml:{Logic} OR logic:{Logic}
+
 25)		!nocreative:{Lists}
 		Removes all abilities gained from the creative:{Lists} command.
 
-34)		mltoggle: {Argument}
+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}
-								-- MODULE LOGIC API --
+
 
 28)		!blockhead:{Lists}
 		Turns everyone in the lists' heads into blocks.
 
 29)		!stat:{Lists}: {Statname}: {Value}
-		|			Variable content (can be number, string or bool)
+
 		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.
-		-- EXAMPLES BELOW (PASTE FULL TEXT IN ONLINE CHAT TO TEST) --
+
 38)		!unmusic
 		Removes any music that you've spawned in, stopping them as well.
-				ml:case>mlv>given~(<)1.5{m: You are running a past version of ModuLogic.}>{m: You are up to date!}
+
 39)		!looklike:{Lists}: {PlayerID/Username}
-				ml:case>me/stat/Money>given~(>)9000{m: %me/name% has over 9000 Money!!!!1}
+		Makes anybody in the lists' appear as another player based on their Player ID OR Username.
 
-				ml:m:%me/name%: You are %me/distancefrom/Pending% studs away from the brick.
+40)		!delimb:{Lists}
 		Gets rid of "some" limbs :> Perfect trolling mechanism!
-				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.}
+
 41)		!nohats:{Lists}
-				ml:loop>%players%>{m: I ate %player index% for breakfast!;kill:%player index%;wait}
+		Gets rid of everybody in the lists' hats.
 
-35)		wait: {Time}
+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.
 
-36)		respawn:{Lists}
+44)		!unblind:{Lists}
 		Removes blindness from everybody in the lists.
 
 45)		!citem:{ID}
---	ADMIN ONLY COMMANDS:  --
+		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.
-1)		promote:{Lists}
+
 46)		!jumppower:{Lists}: {Argument} OR !jp:{Lists}: {Argument}
 		Gives everyone in the lists a predetermined amount of JumpPower given by the
-2)		demote:{Lists}
+		argument (default 50).
 
 47)		!normaljumppower:{Lists} OR !njp:{Lists}
-3)		admin:{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.
-4)		unadmin:{Lists}
+		**WARNING: Enabling LoadString disables your ability to use player points!
 		  USE MODULOGIC WHERE YOU CAN!
 
 2)		!promote:{Lists}
-5)		kick:{Lists}
+
 
 3)		!demote:{Lists}
 		Removes everyone in the lists from the Operator list.
-6)		ban:{Lists}
+
 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.
-7)		unban: {Arguments}
+
 		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.
 
-	How to utilize flags:
+5)		!unadmin:{Lists}
 		Removes everyone in the lists from the admin list.
-	There are three types of flags.
+
-	One flag type is with settings:
+
-		-<settingsflag> <settings>
+6)		!kick:{Lists}
-	One flag type is without settings:
+
-		-<singleflag>
+
-	One flag type is with settings but can
+
-	support spaces and dashes within them:
+7)		!ban:{Lists}
-		-<settingsflag> *<longersettings>*
+
-	And finally, flags can be trailed behind
+
-	one another to set several settings:
+
-		-<settingsflag> <settings> -<settingsflag> <settings>
+8)		!unban: {Arguments}
 		Checks the ban list for anyone who is an argument in this command and removes them.
-	Examples using commands in ExtraCommands:
+
 
-		hop:-macro *p: 2 2 2 -c Bright blue -ry 45*
+9)		!chatprefix:{Prefix}
-		hop:-name RightClickFrenzy -rmacro *p: 2 2 2 -c Bright red* -macro *p: 2 2 2 -c Bright blue -ry 45*
+		Changes the chat commands' prefix. This changes the script from its default settings.
 		USE WITH CAUTION!
-	The ExtraCommands Commands:
+		If you do not want any chat prefixes for these commands, simply say "!chatprefix" OR
 		change the value in the config to be empty.
-1)	 	hop:{Flags}
+
 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".
 
-			-rmacro <MACRO>: Macro flag. This flag sets what commands get executed when this HopperBin is right clicked. (Off by default)
+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)		p:[[x] [y] [z] ]{Flags}
+
 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.
-			-ontouch <MACRO>: Executes commands on behalf of the player when they touch this part.
+
 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%
 				};