Skip to content

PredatorPrey_step8

RoiArthurB edited this page Sep 11, 2023 · 11 revisions

8. Complex Behavior

This eighth step illustrates how to define more complex actions, how to use conditional statements and iterator operators over containers.

Formulation

  • Definition of more complex behaviors for prey and predator agents:
    • The preys agents are moving to the cell containing the highest quantity of food.
    • The predator agents are moving if possible to a cell that contains preys, otherwise to a random cell.

Model Definition

parent species

We modify the basic_move reflex of the generic_species in order to give the prey and predator more complex behaviors: instead of choosing a random vegetation cell in the neighborhood, the agents will choose a vegetation cell (still in the neighborhood) thanks to a choose_cell action. This action will return an empty (nil) value in the parent species and will be specialized for each species.

species generic_species {
    ...
    reflex basic_move {
	my_cell <- choose_cell();
	location <- my_cell.location; 
    } 
	
    vegetation_cell choose_cell {
	return nil;
    }
    ...
}

prey species

We specialize the choose_cell action for the prey species: the agent will choose the vegetation cell of the neighborhood (list my_cell.neighbors2) that maximizes the quantity of food.

Note that GAMA offers numerous operators to manipulate lists and containers:

  • Unary operators: min, max, sum...
  • Binary operators:
    • where: returns a sub-list where all the elements verify the condition defined in the right operand.
    • first_with: returns the first element of the list that verifies the condition defined in the right operand.
    • ...

In the case of binary operators, each element (of the first operand list) can be accessed with the pseudo-variable each.

Thus the choose_cell action of the prey species is defined by:

species prey parent: generic_species {
    ...  
    vegetation_cell choose_cell {
        return (my_cell.neighbors2) with_max_of (each.food);
    }
    ...
}

predator species

We specialize the choose_cell species for the predator species: the agent will choose, if possible, a vegetation cell of the neighborhood (list my_cell.neighbors2) that contains at least a prey agent; otherwise it will choose a random cell.

We use for this action the first_with operator on the list of neighbor vegetation cells (my_cell.neighbors2) with the following condition: the list of prey agents contained in the cell is not empty. Note that we use the shuffle operator to randomize the order of the list of the neighbor cells.

If all the neighbor cells are empty, then the agent chooses a random cell in the neighborhood (one_of (my_cell.neighbors2)).

GAMA contains statements that allow executing blocks depending on some conditions:

if condition1 {...} 
else if condition2{...} 
... 
else {...} 

This statement means that if condition1 = true then the first block is executed; otherwise, if condition2 = true, then it is the second block, etc. When no conditions are satisfied and an else block is defined (it is optional), this latter is executed.

We then write the choose_cell action as follows:

species predator parent: generic_species {
    ...
    vegetation_cell choose_cell {
        vegetation_cell my_cell_tmp <- shuffle(my_cell.neighbors2) first_with (!(empty (prey inside (each))));
	if my_cell_tmp != nil {
	    return my_cell_tmp;
	} else {
	    return one_of (my_cell.neighbors2);
	} 
    }
    ...
}

Note there is ternary operator allowing to directly use a conditioned structure to evaluate a variable:

condition ? value1 : value2

if condition is true, then returns value1; otherwise, returns value2.

Complete Model

https://github.com/gama-platform/gama/blob/GAMA_1.9.2/msi.gama.models/models/Tutorials/Predator%20Prey/models/Model%2008.gaml
  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