Skip to content

DefiningActionsAndBehaviors

Julien Mazars edited this page Jan 15, 2016 · 15 revisions

Defining actions and behaviors

Both actions and behaviors can be seen as methods in OOP. They can be defined in any species.

Index

Action

Declare an action

An action is a function run by an instance of species. An action can return a value (in that case, the type of return has to be specify just before the name of the action), or not (in that case, you just have to put the keyword action before the name of the action).

species my_specie {
	int action_with_return_value {
		// statements...
		return 1;
	}
	action action_without_return_value {
		// statements...
	}
}

Arguments can also be mandated in your action. You have to specify the type and the name of the argument:

action action_without_return_value (int argA, float argB) {
	// statements...
}

If you want to have some optional arguments in the list, you can give some by default values to turn them optional. Nb: it is better to define the optional arguments at the end of the list of argument.

action my_action (int argA, float argB <- 5.1, point argC <- {0,0}) {
	// statements...
}

Call an action

To call an action, you have to use the statement do. You can use the statement do different ways:

  • With facets : after specifying the name of your action, you can specify the values of your arguments as if the name of your arguments were facets:
do my_action argA:5 argB:5.1;
  • With parenthesis : after specifying the name of your action, you can specify the values of your arguments in the same order they were declared, between parenthesis:
do my_action (5,5.1);

We incite you to promote the second writing. To catch the returned value, you can also skip the do statement, and store the value directly in a temporary variable:

int var1 <- my_action(5,5.1);

Behaviour

A behavior, or reflex, is an action which is called automatically at each time step by an agent.

reflex my_reflex {
	write ("Executing the inconditional reflex");
// statements...
}

With the facet when, this reflex is only executed when the boolean expression evaluates to true. It is a convenient way to specify the behavior of agents.

reflex my_reflex when:flip(0.5) {
	write ("Executing the conditional reflex");
// statements...
}

Reflex, unlike actions, cannot be called from another context. But a reflex can, of course, call actions.

Nb : Init is a special reflex, that occurs only when the agent is created.

Example

To practice a bit with those notions, we will build an easy example. Let's build a model with a species balloon that has 2 attributes: balloon_size (float) and balloon_color (rgb). Each balloon has a random position and color, his aspect is a sphere. Each step, a balloon has a probability to spawn in the environment. Once a balloon is created, its size is 10cm, and each step, the size increases by 1cm. Once the balloon size reaches 50cm, the balloon has a probability to burst. Once 10 balloons are destroyed, the simulation stops. The volume of each balloon is displayed in the balloon position.

images/burst_the_baloon.png

Here is one of the multiple possible implementation:

model burst_the_baloon

global{
	float worldDimension <- 5#m;
	geometry shape <- square(worldDimension);
	int nbBaloonDead <- 0;

	reflex buildBaloon when:(flip(0.1)) {
		create species:balloon number:1;
	}
	
	reflex endSimulation when:nbBaloonDead>10 {
		do halt;
	}
}

species balloon {
	float balloon_size;
	rgb balloon_color;
	init {
		balloon_size <- 0.1;
		balloon_color <- rgb(rnd(255),rnd(255),rnd(255));
	}

	reflex balloon_grow {
		balloon_size <- balloon_size + 0.01;
		if (balloon_size > 0.5) {
			if (flip(0.2)) {
				do balloon_burst;
			}
		}
	}
	
	float balloon_volume (float diameter) {
		float exact_value <- 2/3*#pi*diameter^3;
		float round_value <- (round(exact_value*1000))/1000;
		return round_value;
	}
	
	action balloon_burst {
		write "the baloon is dead !";
		nbBaloonDead <- nbBaloonDead + 1;
		do die;
	}
	
	aspect balloon_aspect {
		draw circle(balloon_size) color:balloon_color;
		draw text:string(balloon_volume(balloon_size)) color:#black;
	}
}

experiment my_experiment type:gui
{
	output{
		display myDisplay {
			species balloon aspect:balloon_aspect;
		}
	}
}
  1. What's new (Changelog)
  1. Installation and Launching
    1. Installation
    2. Launching GAMA
    3. Updating GAMA
    4. Installing Plugins
  2. Workspace, Projects and Models
    1. Navigating in the Workspace
    2. Changing Workspace
    3. Importing Models
  3. Editing Models
    1. GAML Editor (Generalities)
    2. GAML Editor Tools
    3. Validation of Models
  4. Running Experiments
    1. Launching Experiments
    2. Experiments User interface
    3. Controls of experiments
    4. Parameters view
    5. Inspectors and monitors
    6. Displays
    7. Batch Specific UI
    8. Errors View
  5. Running Headless
    1. Headless Batch
    2. Headless Server
    3. Headless Legacy
  6. Preferences
  7. Troubleshooting
  1. Introduction
    1. Start with GAML
    2. Organization of a Model
    3. Basic programming concepts in GAML
  2. Manipulate basic Species
  3. Global Species
    1. Regular Species
    2. Defining Actions and Behaviors
    3. Interaction between Agents
    4. Attaching Skills
    5. Inheritance
  4. Defining Advanced Species
    1. Grid Species
    2. Graph Species
    3. Mirror Species
    4. Multi-Level Architecture
  5. Defining GUI Experiment
    1. Defining Parameters
    2. Defining Displays Generalities
    3. Defining 3D Displays
    4. Defining Charts
    5. Defining Monitors and Inspectors
    6. Defining Export files
    7. Defining User Interaction
  6. Exploring Models
    1. Run Several Simulations
    2. Batch Experiments
    3. Exploration Methods
  7. Optimizing Model Section
    1. Runtime Concepts
    2. Optimizing Models
  8. Multi-Paradigm Modeling
    1. Control Architecture
    2. Defining Differential Equations
  1. Manipulate OSM Data
  2. Diffusion
  3. Using Database
  4. Using FIPA ACL
  5. Using BDI with BEN
  6. Using Driving Skill
  7. Manipulate dates
  8. Manipulate lights
  9. Using comodel
  10. Save and restore Simulations
  11. Using network
  12. Headless mode
  13. Using Headless
  14. Writing Unit Tests
  15. Ensure model's reproducibility
  16. Going further with extensions
    1. Calling R
    2. Using Graphical Editor
    3. Using Git from GAMA
  1. Built-in Species
  2. Built-in Skills
  3. Built-in Architecture
  4. Statements
  5. Data Type
  6. File Type
  7. Expressions
    1. Literals
    2. Units and Constants
    3. Pseudo Variables
    4. Variables And Attributes
    5. Operators [A-A]
    6. Operators [B-C]
    7. Operators [D-H]
    8. Operators [I-M]
    9. Operators [N-R]
    10. Operators [S-Z]
  8. Exhaustive list of GAMA Keywords
  1. Installing the GIT version
  2. Developing Extensions
    1. Developing Plugins
    2. Developing Skills
    3. Developing Statements
    4. Developing Operators
    5. Developing Types
    6. Developing Species
    7. Developing Control Architectures
    8. Index of annotations
  3. Introduction to GAMA Java API
    1. Architecture of GAMA
    2. IScope
  4. Using GAMA flags
  5. Creating a release of GAMA
  6. Documentation generation

  1. Predator Prey
  2. Road Traffic
  3. 3D Tutorial
  4. Incremental Model
  5. Luneray's flu
  6. BDI Agents

  1. Team
  2. Projects using GAMA
  3. Scientific References
  4. Training Sessions

Resources

  1. Videos
  2. Conferences
  3. Code Examples
  4. Pedagogical materials
Clone this wiki locally