Triggers

Some starter notes:
• Int – any integer (-1, 0, 1, 2, etc.)
• Float – any decimal (1.5,-3.5, etc.) MUST be a decimal to be read as a float.
• String – anything enclosed by quotation marks (“hello world”, “myVariableName”, etc.)
• Bool – either true or false.
• Everything MUST be on a separate line.
• Every piece of code starts with an Event List (OnFirstLoad(), OnPlayerEnterRegion) and
is enclosed by curly braces.
• Eg:  OnFirstLoad() will execute everything within the { } upon first loading the script.
{
}
• LoopTypes (If, While) are used to signify conditions before performing actions. All
actions done by a condition is also enclosed by curly braces.
• Eg: OnFirstLoad()
      {
            If(Int.Equals(VariableInt(“myInt”), 1))
     {
     }
}
• Variables are accessed by first typing the variable type, and then the variable name as a
string enclosed by parenthesis.
Eg: VariableInt(“myInt”) will get the integer stored as variable name myInt. Note the
variable must be set first or an error will be returned.
• Event types with variable strings will store variables based on type.
Eg: OnPlayerEnterRegion[“region1”](“myPlayer”) will set VariablePlayer(“myPlayer”)
to the entered player once it enters region1.
• Region locations, sizes, and names are defined in the map editor, but used in the script.
• I’ll try to make this more comprehensive later, for now this should get you started on the
basics. There are very few type checks right now, so if your game doesn’t work it’s more
likely a mistake you made in the scripting.

I. Event List:

A. OnFirstLoad()
B. OnRoundStart()
C. OnUpdate () – run every second
D. OnPlayerEnterRegion[string RegionName](string VariablePlayerName)
E. OnPlayerLeaveRegion[string RegionName](string VariablePlayerName)
F. OnTitanEnterRegion[string RegionName](string VariableTitanName)
G. OnTitanLeaveRegion[string RegionName](string VariableTitanName)
H. OnTitanDie(string VariableTitanName, string VariablePlayerName)
I. OnPlayerDieByTitan(string VariablePlayerName, string VariableTitanName)
J. OnPlayerDieByPlayer(string VariablePlayerName, string VariablePlayerName)
K. OnChatInput(string VariableStringName) – MasterClient only



II. LoopTypes:

A. If (condition)
B. While(condition)
C. ForeachTitan(string VariableTitanName)
D. ForeachPlayer(string VariablePlayerName)



III. Conditions:

A. Integers

	i. Int.Equals(int base, int compare)
	ii. Int.NotEquals(int base, int compare)
	iii. Int.LessThan(int base, int compare)
	iv. Int.LessThanOrEqual(int base, int compare)
	v. Int.GreaterThanOrEqual(int base, int compare)
	vi. Int.GreaterThan(int base, int compare)

B. Booleans

	i. Bool.Equals(bool base, bool compare)
	ii. Bool.NotEquals(bool base, bool compare)

C. Strings

	i. String.Equals(string base, string compare)
	ii. String.NotEquals(string base, string compare)
	iii. String.Contains(string base, string contained)
	iv. String.NotContains(string base, string contained)
	v. String.StartsWith(string base, string start)
	vi. String.NotStartsWith(string base, string start)
	vii. String.EndsWith(string base, string end)
	viii. String.NotEndsWith(string base, string end)

D. Floats

	i. Float.Equals(float base, float compare)
	ii. Float.NotEquals(float base, float compare)
	iii. Float.LessThan(float base, float compare)
	iv. Float.LessThanOrEqual(float base, float compare)
	v. Float.GreaterThanOrEqual(float base, float compare)
	vi. Float.GreaterThan(float base, float compare)

E. Player

	i. Player.Equals(Player base, Player compare)
	ii. Player.NotEquals(Player base, Player compare)

F. Titan
	i. Titan.Equals(Titan base, Titan compare)
	ii. Titan.NotEquals(Titan base, Titan compare)



IV. Actions:

A. Class VariableInt

	i. VariableInt.Set(string variableName, int value)
	ii. VariableInt.Add(string variableName, int value)
	iii. VariableInt.Subtract(string variableName, int value)
	iv. VariableInt.Multiply(string variableName, int value)
	v. VariableInt.Divide(string variableName, int value)
	vi. VariableInt.Modulo(string variableName, int value)
	vii. VariableInt.Power(string variableName, int value)
	viii. VariableInt.SetRandom(string variableName, int lower, int higher)

B. Class VariableBool

	i. VariableBool.Set(string variableName, bool value)
	ii. VariableBool.SetToOpposite(string VariableName)
	iii. VariableBool.SetRandom(string variableName)

C. Class VariableString

	i. VariableString.Set(string variableName, string value)
	ii. VariableString.Concat(string variableName, string value1, string value2, …)
	iii. VariableString.Append(string variableName, string value)
	iv. VariableString.Replace(string variableName, string oldValue, string newValue)
	v. VariableString.Remove(string VariableName, string removeMe)

D. Class VariableFloat

	i. VariableFloat.Set(string variableName, float value)
	ii. VariableFloat.Add(string variableName, float value)
	iii. VariableFloat.Subtract(string variableName, float value)
	iv. VariableFloat.Multiply(string variableName, float value)
	v. VariableFloat.Divide(string variableName, float value)
	vi. VariableFloat.Modulo(string variableName, float value)
	vii. VariableFloat.Power(string variableName, float value)
	viii. VariableFloat.SetRandom(string VariableName, float lower, float higher)

E. Class VariablePlayer

	i. VariablePlayer.Set(string variableName, VariablePlayer player)

F. Class VariableTitan

	i. VariableTitan.Set(string variableName, VariableTitan titan)

G. Class Player

	i. Player.KillPlayer(VariablePlayer player, String KillerName)
	ii. Player.SpawnPlayer(VariablePlayer player)
	iii. Player.SpawnPlayerAt(VariablePlayer player, float PositionX, float PositionY, float PositionZ)
	iv. Player.MovePlayer(VariablePlayer player, float PositionX, float PositionY, float PositionZ)
	v. Player.SetKills(VariablePlayer player, int kills)
	vi. Player.SetDeaths(VariablePlayer player, int deaths)
	vii. Player.SetMaxDmg(VariablePlayer player, int MaxDmg)
	viii. Player.SetTotalDmg(VariablePlayer player, int TotalDmg)
	ix. Player.SetName(VariablePlayer player, string name)
	x. Player.SetGuildName(VariablePlayer player, string guildname)
	xi. Player.SetTeam(VariablePlayer player, int team)
	xii. Player.SetCustomInt(VariablePlayer player, int integer)
	xiii. Player.SetCustomBool(VariablePlayer player, bool Boolean)
	xiv. Player.SetCustomString(VariablePlayer player, string str)
	xv. Player.SetCustomFloat(VariablePlayer player, float decimal)

H. Class Titan

	i. Titan.KillTitan(VariableTitan titan, VariablePlayer killer, int damage)
	ii. Titan.SpawnTitan(int type, float size, int health, int number)
	iii. Titan.SpawnTitanAt(int type, float size, int health, int number, float PositionX, float PositionY, float PositionZ,)
	iv. Titan.SetHealth(VariableTitan titan, int health)
	v. Titan.MoveTitan(VariableTitan titan, float PositionX, float PositionY, float PositionZ)
		Titan types: 0 for normal, 1 for abnormal, 2 for jumper, 3 for crawler, 4 for punk.

I. Class Game

	i. Game.PrintMessage(string message)
	ii. Game.LoseGame(bool clearVariables)
	iii. Game.WinGame(bool clearVariables)
	iv. Game.Restart(bool clearVariables)



V. Return Properties

A. Class Primitives

	i. Integers – any non-decimal
	ii. Boolean – true or false
	iii. Float – any decimal
	iv. String – enclosed by “ “

B. Class Variable

	i. int VariableInt(string variableName)
	ii. bool VariableBool(string variableName)
	iii. string VariableString(string variableName)
	iv. float VariableFloat(string variableName)
	v. Player VariablePlayer(string variableName)
	vi. Titan VariableTitan(string variableName)

C. Class Player

	i. int player.GetTeam()
	ii. int player.GetType()
	iii. bool player.GetIsAlive()
	iv. int player.GetTitan()
	v. int player.GetKills()
	vi. int player.GetDeaths()
	vii. int player.GetMaxDmg()
	viii. int player.GetTotalDmg()
	ix. int player.GetCustomInt()
	x. bool player.GetCustomBool()
	xi. string player.GetCustomString()
	xii. float player.GetCustomFloat()
	xiii. float player.GetPositionX()
	xiv. float player.GetPositionY()
	xv. float player.GetPositionZ()
	xvi. string player.GetName()
	xvii. string player.GetGuildName()
	xviii. float player.GetSpeed()

D. Class Titan

	i. int titan.GetType()
	ii. float titan.GetSize()
	iii. int titan.GetHealth()
	iv. float titan.GetPositionX()
	v. float titan.GetPositionY()
	vi. float titan.GetPositionZ()

E. Class Region

	i. float RegionRandomX(string RegionName)
	ii. float RegionRandomY(string RegionName)
	iii. float RegionRandomZ(string RegionName)



VI. Other Extensions

A. ConvertToInt
B. ConvertToBool
C. ConvertToString
D. ConvertToFloat

Examples:

Titan split mode:

OnTitanDie("myTitan","myPlayer")
	{
	VariableFloat.Set("mySize",VariableTitan("myTitan").GetSize());
	If (Float.GreaterThan(VariableFloat("mySize"),1.0))
		{
		VariableFloat.Divide("mySize",2.0);
		VariableFloat.Set("posX",VariableTitan("myTitan").GetPositionX());
		VariableFloat.Set("posY",VariableTitan("myTitan").GetPositionY());
		VariableFloat.Set("posZ",VariableTitan("myTitan").GetPositionZ());
		VariableFloat.Add("posX",5.0);
	Titan.SpawnTitanAt(0, VariableFloat("mySize"), 100, 1, VariableFloat("posX"), VariableFloat("posY"), VariableFloat("posZ"));

		VariableFloat.Subtract("posX",10.0);
		Titan.SpawnTitanAt(0, VariableFloat("mySize"), 100, 1, VariableFloat("posX"),
		VariableFloat("posY"), VariableFloat("posZ"));
		}
	}


Spawn 5 titans in region2 when a player enters region1.
	First enter level editor & add two regions, one labeled region1 and the other labeled region2.
	Afterwards use this script alongside the custom level.

OnPlayerEnterRegion["region1"]("myPlayer")
	{
	Titan.SpawnTitanAt(0, 2.0, 100, 5,
	RegionRandomX("region2"),RegionRandomY("region2"),RegionRandomZ("region2"));
	}