Here is a list of terminology used in GameSalad, including behaviors & functions, and what these terms mean:
Accelerometer: Determines the angle and rate of movement of the device; useful for determining when a user rotates or tilts their device.
Accelerate (Behavior): Specifies the speed and direction of acceleration for an actor. Actors will continue to accelerate unless drag is applied or another movement behavior takes precedence.
Accelerate Toward (Behavior): Allows user to specify the precise location an actor will accelerate toward.
Action: These are behaviors that are not meant to fire continuously, such as movement, changing image, color, or size, or accepting keyboard input; they are best used when governed by a rule.
Actor: All the items (both visible and invisible) in your game are actors; they are governed by Behaviors that control how they interact with both other actors as well as with people playing your game.
Actor Mode: This is the default mode for the scene editor, and allows the actors to be placed, moved, rotated, and resized in the scene.
Actor Tag: Actor Tags are used to categorize actors; they can be added and removed through the Project Editor.
Alpha Color: Alpha controls the transparency of an actor, and can be set to any real number between 0 and 1, with 0 being completely transparent and 1 being completely opaque.
Animate (Behavior): Displays a series of images in rapid succession to create animation.
Attribute: Attributes contain numeric or text values that govern various aspects of the game, scene, and actors.
Behavior Library: A list of all available behaviors which can be assigned to actors.
Behaviors: Behaviors are actions or states of being that apply to actors; they can change how actors move, look, sound, and act.
Camera Mode: An alternative mode while editing a scene, Camera mode allows the user to set the sensitivity and range of the camera’s movement.
Change Attribute (Behavior): Allows user to set or change a game, scene, or actor attribute. For instance, users can create score-keeping systems, instructing the game to add points (or remove points) to a specific actor, or remove health/life from a player or actor.
Change Image (Behavior): Change an actor’s image to a new image – useful for showing damage or other changes to an actor without having to create multiple actors.
Change Scene (Behavior): Goes to a specific scene – useful for moving to the next level, a credits scene, or the game menu.
Change Size (Behavior): Grows or shrinks an actor (use a negative number to shrink). Insert a timer container to control how long the growth or shrink should take.
Change Velocity (Behavior): Specify movement changes relative to another actor or to the scene.
Collide (Behavior): Use this behavior in conjunction with a tag to control which actor or groups of actors the primary actor will bounce against.
Collision Shape: This option determines whether other objects will collide with this object as if it were round (or rounded), or square (or rectangular).
Constrain Attribute (Behavior): Continuously updates an attribute – for instance,constraining the actor’s location to that of the mouse. Essentially ties two attributes together.
Control Camera (Behavior): Allows users to cause the camera to follow an actor – keeping it in view.
Density: Density refers to the heaviness of the actor. A higher value will make the object harder to move by less dense actors. A value of 0 will make an object immovable but still affect other actors in the scene. Density can be set to any real positive number. (i.e.Density >= 0)
Destroy (Behavior): Removes the ACTOR from the scene – apply this rule to objects that can be destroyed, like the blocks in Breakout or the bricks in Mario. Best used with a rule – for instance, contact with the ball in Breakout.
Devices: The Devices pane (under the “Game” tab in the Scene Editor) allows you to change various attributes relating to the device, including mouse, touch, accelerometer, screen, and audio.
Display Text (Behavior): Allows users to change the color, size, font, and other elements of text displayed in-game. Change “alpha” to 0 (found under color in the attributes list) to make all parts of the actor invisible other than the text.
Editor: Can refer to one of three editors: the Project Editor, the Scene Editor, or the Actor Editor.
* The Project editor is used for editing overall detail about your game.
* The Scene Editor is used for creating your scenes by placing actors, changing various attributes, setting tags, and more.
* Actor editor is used for changing a variety of attributes about your actors.
Fixed Rotation: Selecting this option will prevent the object from rotating when it collides with other actors in the scene. Leaving this box unchecked means that the actor will rotate normally when it collides with other actors.
Friction: Increasing this number will slow this object down more when it interacts with other objects. Set to 0 for no friction (and hence no slowing).
GameSalad Creator: The best software in the world for making games with no coding!
Gravity: Each scene can be set up with an X and Y gravity attribute.These are real numbers that affect all actors which are Movable.
Group (Behavior): Creates a group container that holds a set of rules or behaviors.
Image Library: A repository of .png assets that have been imported into the GameSalad Creator.
Instance (actor): An instance is a unique example of an actor, with altered behaviors, attributes, or abilities from the prototype actor.
Interpolate (Behavior): Allows you to cause an attribute (location, value) to go from A to B in a set amount of time – for instance, from 100 to 1 (a countdown) or from position X to position Y (for pre-programmed movement). Note: Interpolating an Actor’s size does NOT change the size of its collision box to match.
iOS: The operating system created by Apple, Inc. to run on the iPhone, iPad, and iPod Touch.
Layers: Layers allow you to prevent actors from interacting with each other – this can allow you to create backgrounds, scores, and more without having the player’s actors bump into them.
Load Attribute (Behavior): Loads the value stored by a custom key name from persistent storage. Allows users to change an attribute upon specific input or events.
Logic: A term which refers to the combination of rules and behaviors that jointly define how a project operates.
Max Speed: This attribute controls the maximum speed an actor can reach through acceleration and gravity. Please note that some behaviors, such as Change Velocity and Interpolate, will override Max Speed.
Movable: Allows you to specify that an actors is able to move (or not able to move) when interacting with other actors. (Check the box to allow it to move)
Move (Behavior): Specifies movement in a particular direction relative to the actor or scene. Movement is perpetual unless stopped by some other rule or object.
Move To (Behavior): Specify movement towards a particular X&Y coordinate; upon arrival the actor stops moving, or resumes any prior movement that the Move To behavior overrode.
Note (Behavior): Allows users to write a note to self or other creators about a particular behavior, rule, actor, or group – useful or explaining why something is done a particular way.
Open URL ( Behaviors): Only available to individuals with a Professional-level membership, this option allows the developer to specify a specific URL to open when a certain action takes place (we recommend a button being clicked or pressed). The URL will open in the user’s default browser.
Orientation: This determines whether your game runs in “up and down” mode (portrait) or “side to side” mode (landscape) on iDevices (iPhone, iTouch, iPad).
Otherwise: An optional component of a rule; behaviors placed under this heading will trigger whenever the conditions of the Rule are not valid.
Particles: Particles are small objects that move out from the actor in a defined way. See “Particles (Behavior)” for more information.
Particles (Behavior): Create an explosion! Radial or fountain of particles – can also set an image, color, lifetime, and other parameters.
Pause Music (Behavior): Pauses a currently playing music file upon a particular event.
Platform: The devices or locations where your game will be able to run. Platforms that are currently available include iOS, Mac Desktop, Android, and HTML5.
Play Music (Behavior): Triggers a music file to play – can play once or loop.
Play Sound (Behavior): Triggers a sound file to play – can play once or loop
Preview: Allows you to see how your game will look and run instantly! Can be done both in GameSalad and in a browser window. Use often to ensure that the rules and actions you are giving your actors are working properly.
Project Size: The current memory needs of your project can be found in the bottom-right corner of the GameSalad Creator. The recommended maximum size for GameSalad Arcade games is 20 MB
Prototype (Actor): A prototype actor is an actor that possesses all the overall governing behaviors, but does not possess some of the specifics that an Instance Actor possess (such as spawning location).
Publish: Publishing uploads your game to GameSalad’s servers, where it is turned into a binary that you can then submit directly to Apple, GameSalad Arcade, or an Android store.
Replicate (Behavior): Creates copies of an actor based on an attribute or integer. Useful for displaying the number of lives a player has left, having an item duplicate itself, and much more.
Reset Game (Behavior): Resets the game and all scenes (best used with a rule to specify WHEN or HOW this happens)
Reset Scene (Behavior): Resets the current scene and all actors in it (best used with a rule to specify WHEN or HOW this happens)
Resolution Independence: Allows your game to be displayed in low or high resolution, depending upon the capabilities of the device
Bounciness: Makes your actor bouncy – 0 is no bounciness; 2 is superball bouncy. Any real positive number from 0 to 2 can be used.
Rotate (Behavior): Alone, this causes consistent clockwise or counter-clockwise rotation. Can also cause an item to only rotate when an event happens, such as pressing a keyboard key or collision with another actor.
Rotate to Angle (Behavior): Causes rotation to an angle relative to another actor or to a scene.
Rotate to Position (Behavior): Causes rotation to a specific XY coordinate on the screen or relative to actor
Rule: Rules create a condition or set of conditions that, when met, cause actors to act in specific ways.
Rule (Behavior): Creates a condition or set of conditions to check for player input or an attribute change.
Save Attribute (Behavior): Save a particular value into persistent storage with a custom name. Allows users to save games (see “Load Attribute” for information on loading saved information)
Scene Attributes: These are attributes that specifically affect a scene, rather than an actor or the entire game. They include Name, Time, Size, Wrap X, Wrap Y, Gravity, Color, Camera, and Autorotate.
Show iAd (Behavior): Shows an ad whose text and destination is determined through Apple’s iAd system.
Spawn Actor (Behavior): Creates a new actor instance in the scene – useful for projectiles, dropping items, etc.
Stop Music (Behavior): Causes a music file to stop playing.
Timer (Behavior): Timer allows you to perform behaviors or rules at specified intervals. These intervals are defined as after a certain number of seconds, every couple of seconds, or for a certain number of seconds.
Keyboard Input: Saves keyboard input text into a specified attribute.
Pause Game (Behavior): This behavior will pause the scene by freezing all activity in a given scene and opening another scene that you specify. Use this to open up in-game menus or simply pause the action. Use “unpause” to resume the scene.
Unpause Game (Behavior): This behavior removes the pause screen and resumes the paused scene.
Log Debugging Statement (Behavior): Logs a statement in the debugging window. Statements can be attribute values for error-checking or text entry to flag an event when your game is running for testing purposes.
Function: Functions are various mathematical formulas available through the expression editor that allow you to have the Creator calculate sines, cosines, logs, and much more.
abs (Function): provides the “absolute value” of a number. In other words, it will make a negative number into a positive number.
For example, abs(-5.23)=5.23.
acos (Function): This is the trigonometric arccosine (inverse cosine) function. Values for x should range from -1 to 1, with results from 180 to 0, respectively. Any other input values will result in ‘nan’.
asin (Function): This is the trigonometric arcsine (inverse sine) function. Values for x should range from -1 to 1 with results from -90 to 90, respectively. Any other input values will result in ‘nan’.
atan (Function): This is the trigonometric arctangent (inverse tangent) function. Results will range from -90 to 90.
ceil (Function): The integer when you round up a value.
For instance, ceil(0.3095)=1, ceil(9.2850)=10, and ceil(-3.5)= -3.
cos (Function): This is the trigonometric cosine function. cos(0)=1.
For more information on sine and cosine, see http://en.wikipedia.org/wiki/Trigonometric_functions
exp (Function): The exponential function e^x, where e is approximately 2.71828182818.
For more information, see http://en.wikipedia.org/wiki/Exponential_function
floor (Function): The integer when you round down a value. For instance, floor(1.5)= 1, floor(9.2850)= 9, and floor(-3.5)= -4.
In (Function): The natural logarithm of a value. The natural logarithm is the logarithm to the base e, where e is approximately 2.71828182818.
For more information, see http://en.wikipedia.org/wiki/Natural_logarithm
log10 (Function): The base 10 logarithm of a value.
For instance, log10(10)=1, log10(100)=2.
For more information, see http://en.wikipedia.org/wiki/Logarithm
magnitude (Function): Finds the length of a line segment drawn directly from the origin 0,0 to the given point.
You can also include an offset to find the length between two points – for example, magnitude(x-x’,y-y’).
If you have one actor at 100, 240 and another at 25, 30, you can find the distance between them with magnitude(25-100,30-240).
max (Function): Returns the higher value of the two numbers or variable units. This can be very useful for determining if a new score is higher than an existing score, or for other similar comparisons.
For example, max(12,35)=35.
min (Function): Returns the smaller value of the two numbers or variable units.
For example, min(12,35)=12.
padInt (Function): Displays an integer with the specified number of digits.
For instance, padInt(32,5) will display 00032. However, padInt(38025,2) will display 38025. It will always display at least the minimum number of digits needed to retain the value of x.
padReal (Function): Displays a floating point with padding and precision.
For instance, padReal(9.1234,15,6) will display 9.1234 with at least 15 total digits (including the decimal) and at most 6 digits to the right of the decimal. – 00000009.123400.
pow (Function): Returns the value of x to the power of y.
For example, pow(2,3)=222=8.
precision (Function): Displays a floating point number with the specified number of decimal places.
For instance,prec(1234.234,2) will display 1234.23.
random (Function): Returns a random integer equal to or between the first integer and the second.
For instance, random(1,5) could return any of the following values: 1,2,3,4,5.
sin (Function): The trigonometric sine function. This is similar to the cosine function, but is offset by one quarter of a wave cycle. For more information, see http://en.wikipedia.org/wiki/Trigonometric_functions
Tip: if you use the sine function and start your incrementing variable at 0, your actor’s movement does not start at the middle point between the minimum and maximum points of the wave.
sqrt (Function): Provides the square root of a value. Input values less than 0 will result in ‘nan’.
tableCellValue (Function): Returns the value of a cell of a selected table at a certain row and column. Tables are numbered starting at 1. You can also use the row or column name as an input for this function.
For example, tableCellValue(game.Data,1,15) will return the value in table, Data, at row 1 and column 15.
tableColCount (Function): Returns the number of columns in the selected table.
tableColNumber (Function): This will return the column number with the given column label.
tableColSum (Function): Returns the sum of the table cells in a given column between the starting row and ending row. This only works on numerical type columns (integer, real, angle).
tableMergeValues (Function) – This will return a string value with the concatenated values from a given column or row (depending on the setting in the 2rd parameter). If the start range is greater than end range, then it will go from last value to first value, appending to the end. The separator will be concatenated between each value.
tableRowCount (Function): Returns the number of rows in the selected table.
tableRowNumber (Function): This will return the row number with the given row label. It will return 0 if it doesn’t exist. This is useful if you want to jump to a section of a table and start iterating through rows from there.
tableSearch (Function): Searches a given column or row (depending on the setting in the 3rd parameter), and returns the index for the first instance of the given key (or keyword) where a match is found (also depending on the match type as set in the 7th parameter). It will search between the specified range. If the start range is greater than the end range, it will do a reverse search. A “0” will be returned if the key value is not found. If you specify “not” in front of the last parameter, it will check against the opposite search.For example,
tableSearch(game.table,”yes”,”row”,1,1,10,”exact”)will look for the first instance of “yes” in a cell value in row 1 between columns 1 and 10, and return the column value. While
tableSearch(game.table,”yes”,”row”,1,1,10,”notexact”)will return the column number where the cell value is not exactly “yes”.
tan (Function): The trigonometric tangent function. For more information, check outhttp://en.wikipedia.org/wiki/Trigonometric_functions
textFind (Function): Returns the index of the location of the text, pattern, in the text attribute, text, starting the index startIndex. If the text was not found, it returns “-1”. CASE SENSITIVEUsage: Given a text attribute with the value “the quick sly fox jumped over the lazy dog.”
textFind(self.Text,”the”,1) returns the value 1.
However, textFind(self.Text,”the”,2) returns the value 31.
textLength (Function): This returns the length of the text or numerical attribute
textRepeat (Function): Returns a text which repeat the text attribute, text, n times, where n is a non-negative integer value.Usage: Given a text attribute with the value “yo”, textRepeat(self.Text,2) returns the value “yoyo”.
You can also enter the text directly into the function and use an expression for the n value. For example: textRepeat(“buffalo”,mod(self.Time,3)) will return either “buffalo” or “buffalo buffalo” depending on the time.
textReplace (Function): This will return the text or text attribute, text, with the first instance of text value, pattern, with text value, replacement.Usage: Given you have a list of separated values in a text attribute like, “s01s02s03s04s05s”, you can replace “s02s” with “s” to signify that question 2 has already been used. See the textSubStr for more usage.
textReplaceAll (Function): This works just like the textReplace function but will return a text value with ALL instances replaced.
textSubStr (Function): This returns a text which is the substring of attribute, text, starting from index startIndex and ending at index endIndex.Usage: Given a text attribute with the value “the quick sly fox jumped over the lazy dog.”
textSubStr(self.Text ,5,8)returns the value “quic”. You can also use this to extract a random set of numbers from a string and use that as a way to choose a unique question via table row number.
vectorToAngle (Function): Finds the angle relative to the origin 0,0, given an X and Y coordinate. For instance, vectorToAngle(100,200)=63.435. You can also find the angle relative to an offset.
For instance, vectorToAngle(x-x’,y-y’).
VectorToAngle(100-200,150-250) will find the angle between the points 100,150 and 200,250, or -135 degrees.
round (Function): The integer when you round to the nearest. If exactly 0.5 between two integers, the result is the greater.
For instance, round(1.5)= 2, round(9.2850)= 9, and round(3.7)= 4.
roundTo (Function): Round a real number to a specific decimal digit. Unlike the precision function, the return value is still a number, not text. To pad the decimal with 0’s for display purposes, use the precision function instead.
roundTo(0.12345, 3) = 0.123;
roundTo(2.5, 0) = 3;
roundTo(4, 2) = 4;
Built-In Game Attributes
- Name: The name of the project.
- Time: An attribute that will update with the amount of elapsed time the game has been running.
- Display Size: The default size of the scene/camera when you create a new scene.
- Random Seed: This value is used to initialize the pseudorandom number generator. When a seed is used, the sequence of random numbers that are generated will always be the same.
For example if you got 5 random numbers with a seed of '3' (the numbers generated were 1, 7, 2, 5, 32). Then every time you preview or run the game, those would be the same first 5 random numbers to be generated.
By default the seed is set to "-1" which will randomize the seed every time the game is run.
- Ad Rewards Value: When reward ads are set up for the project, this will update with the value the game gets back from the ad provider. (i.e if you configured the value to be 100 on the ad providers side, then this would update to be 100 when a reward ad is viewed)
- Ad Rewards Name: When reward ads are set up for the project, this will update with the name of the ad provider when an ad is watched.
- Game Multiplayer Type: This value defaults to single player, but needs to be set to multiplayer for the networking behaviors to work.
Built-In Scene Attributes
- Name: The name of the scene.
- Time: An attribute that will update with the amount of elapsed time that the scene has been running.
- Scene Size: The size of the scene.
- Wrap X: Toggling this attribute on will cause actors that move off the left or right side of the scene to instead loop around to the other side.
- Wrap Y: Toggling this attribute on will cause actors that move off the top or bottom of the scene.
- Gravity: Applies an acceleration to every movable actors on the scene based off of the filled in X and Y values.
- Color: Sets the background color of the scene.
- Camera Attributes - Origin: The X and Y values of the starting place of the camera.
- Camera Attributes - Size: The size of the camera. By default the camera will be the same size as the scene.
- Camera Attributes - Tracking Area: The area an actor controlling the camera can move before the camera starts to follow it. (Note: This is only important if your scene is larger than the camera, otherwise the camera has nowhere to move.)
- Camera Attributes - Rotation: Sets the rotation of the camera. Can be used for some neat swirling effects of the whole scene.
- Auto-Rotation Orientations: These values determine the allowed orientations of the project on an Android device. By default only landscape left is selected.
Built-In Actor Attributes
- Name: The name of the actor.
- Time: The amount of time since the actor has loaded.
- Size: The size of the actor prototype. Setting the width and height here will determine what size the actor appears at by default when an instance of the actor is added to a scene.
- Rotation: The rotation of the actor.
- Color: The color and alpha (opacity) of the actor.
- Image: Lists the default image for the actor prototype.
- Tags: List of custom tags for the actor. Adding tags to actors allows you to create rules that reference a set of actors based off of their tag instead of a bunch of individual actors.
I.e if you are building a platformer game, you could have all of the hazards the player needs to avoid tagged as "Hazards", then have a rule run when the player collides with an actor with tag "Hazards", instead of a rule for each hazard in the game.
- Preload Art: This tells the engine to load the art used for this actor at the start of the game. If you have a large game, toggling this off may help with startup load times.
Built-In Actor Attributes - Graphics
- Visible: This sets whether or not the actor is visible on the scene (by default toggled on). This is different than the Alpha value of the actor, because if this is toggled off text isn't displayed, whereas if the alpha of an actor is set to 0, text will still show up.
- Blending Mode: Determines how the colors behind the actor on the scene impact the actor. Some info about specific blending modes can be found on Wikipedia
- Horizontal and Vertical Wrap: These values determine how the image applied to the actor behaves when the actor has a different aspect ratio than the image.
- Stretch - By default the actor will stretch and skew the image to fit the size of the actor.
- Fixed - This will cause the image to stay at its fixed aspect ratio regardless of the actor size.
- Tile - When the actor is larger than the tile width or tile height bounds the image will start to repeat itself instead of skewing. (Note: A tile width and height need to be set for this to work.)
- Horizontal Anchor: This value determines where the image on the actor will be anchored to when the horizontal wrap is set to something other than stretch.
- Vertical Anchor: This values determines where the image on the actor will be anchored to when the vertical wrap is set to something other than stretch.
- Flip Horizontally: Toggling this on will flip the image on the actor over the Y axis.
- Flip Vertically: Toggling this on will flip the image on the actor over the X axis.
- Tile Width and Height: These values are used when the horizontal or vertical wrap is set to tile. When the actor is larger than the bounds set here, it will begin tiling the image.
Built-In Actor Attributes - Physics
- Density: How dense the actor is treated in the physics engine. Learn more about density here.
- Friction: This value determines how much an actor slows down when colliding with another actor. Zero friction results in no loss of velocity, while a higher friction value will cause the actor to slow down quicker.
- Bounciness: Determines how much bounce an actor has when it collides with another actor. Zero bounciness results in the actors not bouncing off each other. A higher bounciness value results in the actors' velocities increasing in the opposite direction of the collision.
- Fixed Rotation: Toggling this attribute on will stop the actor from rotating when colliding with other actors.
- Movable: Toggling this attribute off will stop the actor from being able to move. (Note: This also stops the actor from rotating as that is a form of motion.)
- Collision Shape: This value tells the physics engine what type of shape to draw around the image on the actor for collisions.
- Rectangle - The default. The physics engine draws a rectangle around the image on the actor and uses that as the collision shape.
- Circle - The physics engine draws a circle around the image on the actor and uses that as the collision shape.
- Custom - If you've made your own collision shape (as a json file) you can select custom to import it. Alternatively you can select custom and then select "auto-trace" to have the physics engine draw a custom collision shape to fit the image on your actor.
- Drag: Drag is the tendency of an object to slow down due to friction with the air or water that surrounds it. Having a higher drag value will cause the actor to slow down faster when not colliding with any other actors.
- Angular Drag: This value slows down the rotation of an actor over time to simulate air-resistance.
- Can Sleep: Toggling this value off will cause the physics engine to constantly factor this actor into physics computations, even when the actor is not actively colliding with anything. Leaving the value turned on will allow the engine to ignore actors that aren't actively colliding from the physics computations and improve project performance.
- Better Collisions: Toggling this value on will cause the physics engine to run more computations per second when computing collisions with this actor. This will impact performance of the project, and is not suggested to be used on many actors.
Built-In Actor Attributes - Motion
- Linear Velocity: These attributes store the X and Y velocity of the actor.
- Center of Mass: These attributes store the X and Y position of the center of mass of the actor for use in physics computations by the engine. By default the center of mass for an actor is its center point.
- Angular Velocity: This attribute stores the rotational velocity of the actor. A positive value results in a counter-clockwise rotation, and a negative value results in a clockwise rotation.
- Max Speed: If the enforce max speed attribute is turned on, this attribute sets the upper limit for the velocity of the actor.
- Enforce Max Speed: When turned on, sets the max speed attribute as the maximum velocity for the actor.
- Pin to COM: Turning this on locks the actor to a spot on the scene based off of its center of mass (by default the center of the actor).