Gumbo Script

## Temporary Links

Gumbo\_Script\_Reference

Gumbo\_Script\_101

Gumbo\_Snippets

## Overview

GumboScript is a basic script which uses plant text commands similar to a natural language to direct AI actions.

Script can be broken down to the following keywords:

 Math | Refers to your standard math operators. (e.g. +, -, \*, / )

## Editing Gumbo Script

We recommend using Sublime Text 3 for editing Gumbo Script.

### Installation

1. Install Sublime Text 3
2. Run Sublime Text 3
3. Select Preferences -> Browse Packages...
4. Browse to ..\Sublime Text 3\Installed Packages
5. Download the Gumb Syntax Highlighter copy it to the above folder
6. Restart Sublime Text

With the package installed, you should be able to select Gumbo from the bottom-right menu in sublime that dictates the syntax highlighting.

### Theme

Following the installation of Sublime run the editor and setup package control.

Install the Predawn Theme

### Tabs

Gumbo Script uses a 4 spaces or tab to indicate branching statements.

1. Select the tab indicator at the bottom-right of the editor
2. Set the Tab Width to 4

With that in place, you should be ready to start creating and editing in Gumbo Script!

## Basic Flow

```
IF A
    IF B
        DO C
    ELSE
        RETURN E
DO D

```

The above snippet gives an example to how the Flow keywords work. A quick breakdown:

1. If A is True, we continue to the IF B. Otherwise we skip to Do D.
2. If B is True, we continue to DO C. Otherwise we skip to ELSE
3. The AI will DO C. Then it will DO D
4. If B was False, the code will RETURN E. It does not DO D
5. If A was False, AI will still DO D

## Basic Script

```
SELECT ENEMY NOT(in_cover)
IF SELECT INVENTORY MATCH(debuff)
    DO ITEM_SELECTION

```

```
VERB NOUN NOT(ADJECTIVE)
FLOW VERB NOUN MATCH(ADJECTIVE)
    VERB NOUN

```

A quick breakdown of the above script:

1. The Actor is told to Select an Enemy not matching the attribute In\_Cover
2. If the Actor can Select an Inventory Item that has a matching attribute of debuff
3. The Actor is told to use the selected item on the selected enemy

## Basic Function

Functions or Methods are easy ways of re-using a code snippet without having to retype the whole thing. Take the Basic Script for example, you could retype the snippet anytime you would want an Actor to use a debuff. However, we can also change the code so it is accessible like this:

```
[DEBUFF]
SELECT ENEMY NOT(in_cover)
IF SELECT INVENTORY MATCH(debuff)
    DO ITEM_SELECTION

```

In brackets, set the name you want to access the function. (e.g. [Debuff], [Check Ammo]) Now the function can be called with the following:

```
RUN DEBUFF

```

### Function Parameters

Functions may also have optional parameters to modify how they run.

 @throttle=<num> | Defines the millisecond delay between actioons

The following script contains an example of a gated function.

```
[CAN_ENGAGE]
RETURN ENEMY MATCH(alive, in_sight)

[ENGAGE]
@gate=CAN_ENGAGE
IF SELECT ENEMY MATCH(alive, in_sight)
    MOVE ACTOR_SELECTION in_cover, sweet_range
    ELSEIF SELECT INVENTORY MATCH(attack)
        DO ITEM_SELECTION
RETURN

```

Given the above script, we call RUN ENGAGE

1. The AI sees that it has a parameter it needs to fulfill and runs CAN\_ENGAGE
2. CAN\_ENGAGE checks that there is an ENEMY that is alive and in sight then returns true or false
3. If CAN\_ENGAGE returns true, then ENGAGE continues to execute and the AI selects an enemy that is alive and in sight
4. If CAN\_ENGAGE returns false, then ENGAGE does not execute

## Importing

Importing allows us to have an AI inherit functions from another. This is done at the beginning of the script before variables are declared.

```
{import gumbo_common}

```

With the above line included, a new script will have access to all of the function already created in gumbo\_common.

Notes:

* Functions created in the "child" script with the same name will override the imported script
* Variables in the imported script are not accessible from the imported script.

## Debugging

Debugging allows you to display text in the console and over the Actor. This is great for testing your logic and keeping track of variables within your script

### Accessing the Debugger

With a scene loaded you can access dev mode to test your work.

1. Ctrl + F1 enables dev mdoe
2. Select the Debug tag and click "dbgai"

This causes every AI Actor to have a scrolling log above their heads showing their actions.

With the mouse hovered over an Actor, you may modify your log view:

* Press **.** to cycle through modes
* Press **'** to expand the scrolling log

Finally you may open the Console window and select the Gumbo tab for a complete log of all actions that have been made.

### Sample Debug

```
{string,GREETINGS,A New World}

[Hello_World]
DEBUG "Hello World"
DEBUG GREETINGS
SET GREETINGS "A Third World"
DEBUG "Hello World" GREETINGS

```

The above function breaks down a couple of ways to use the DEBUG Verb.

* The first line outputs "Hello World" as a string.
* The second line uses a String Variable and outputs its value "A New World"
* In the third line we set GREETINGS to the new value "A Third World"
* The final line outputs "Hello World, A Third World"