GAMA-Platform

GAMA-Platform

  • Documentation
  • Tutorials
  • Download
  • Contribute
  • Blog

›Global Species

Home

  • GAMA

Introduction

  • Introduction

Changes from 1.6.1 to 1.8

  • New-Version-Changes

Moving to 1.9

  • Next-Version-Goals

Platform

  • Platform
  • Installation and Launching
  • Installation

    • Installation
    • Launching GAMA
    • Headless Mode
    • Updating GAMA
    • Installing Plugins
    • Troubleshooting
  • Workspace, Projects and Models
  • Navigating in the Workspace

    • Navigating in the Workspace
    • Changing Workspace
    • Importing Models
  • Editing models
  • GAML Editor (Generalities)

    • The GAML Editor - Generalities
    • GAML Editor tools
    • Validation of Models
  • Running Experiments
  • Launching Experiments

    • Launching Experiments from the User Interface
    • Experiments User Interface
    • Controls of experiments
    • Parameters View
    • Inspectors and monitors
    • Displays
    • Batch Specific UI
    • Errors View
  • Preferences

Learn GAML step by step

  • Learn GAML Step by Step
  • Introduction

    • Introduction
    • Start with GAML
    • Organization of a model
    • Basic programming concepts in GAML
  • Manipulate basic species
  • Global Species

    • The global species
    • Regular species
    • Defining actions and behaviors
    • Interaction between agents
    • Attaching Skills
    • Inheritance

    Defining Advanced Species

    • Defining advanced species
    • Grid Species
    • Graph Species
    • Mirror species
    • Multi-level architecture

    Defining GUI Experiment

    • Defining GUI Experiment
    • Defining Parameters
    • Defining displays (Generalities)
    • Defining Charts
    • Defining 3D Displays
    • Defining monitors and inspectors
    • Defining export files
    • Defining user interaction

    Exploring Models

    • Exploring Models
    • Run Several Simulations
    • Defining Batch Experiments
    • Exploration Methods

    Optimizing Model Section

    • Optimizing Models
    • Runtime Concepts
    • Optimizing Models

    Multi-Paradigm Modeling

    • Multi-Paradigm Modeling
    • Control Architectures
    • Using Equations

Recipes

  • Recipes
  • Manipulate OSM Datas
  • Implementing diffusion
  • Using Database Access
  • CallingR
  • Using FIPA ACL
  • Using GAMAnalyzer
  • Using BEN (simple_bdi)
  • Advanced Driving Skill
  • Manipulate Dates
  • Implementing light
  • Using Comodel
  • Save and Restore simulations
  • Using network
  • Editing Headless mode for dummies
  • The Graphical Editor
  • Using Git from GAMA to version and share models
  • Writing Unit Tests in GAML
  • FAQ (Frequently Asked Questions)
  • Known issues

GAML References

  • GAML References
  • Built-in Species

    • Built-in Species
    • The 'agent' built-in species (Under Construction)
    • The 'model' built-in species (Under Construction)
    • The 'experiment' built-in species (Under Construction)
  • Built-in Skills
  • Built-in Architectures
  • Statements
  • Types
  • File Types
  • Expressions

    • Expressions
    • Literals
    • Units and constants
    • Pseudo-variables
    • Variables and Attributes
    • Operators (A to A)
    • Operators (B to C)
    • Operators (D to H)
    • Operators (I to M)
    • Operators (N to R)
    • Operators (S to Z)
  • Exhaustive list of GAMA Keywords

Pedagogical materials

  • Some pedagogical materials

Extensions

  • Extensions
  • Developing Extensions
  • Installing the GIT version

    • Installing the GIT version
    • Architecture of GAMA
    • Developing Plugins
    • Developing a New Skill
    • Developing Statements
    • Developing Operators
    • Developing Types
    • Developing Species
    • Developing architecture
    • Index of annotations

Developing GAMA

  • Get into the GAMA Java API
  • Introduction-To-Gama-Java-API
  • IScope interface
  • Product your own release of GAMA
  • Documentation
  • How to write the Website Content

Scientific References

  • References

Projects using GAMA

  • Projects

Training Session

  • Training Session
    • Introduction

Events

  • References

Older versions

  • Versions of GAMA

Attaching Skills

GAMA allows the modeler to increase the capabilities of the GAMA agents by attaching skills to them through the facet skills. Skills are built-in modules that provide a set of related built-in attributes and built-in actions (in addition to those already proposed by GAMA) to the species that declare them. The list of the available skills can be found on the dedicated page.

Index

  • The moving skill
  • Other skills
  • Example of implementation

Skills

A declaration of skill is done by filling the skills facet in the species definition:

species my_species skills: [skill1,skill2] {
}

A very useful and common skill is the moving skill.

species my_species skills: [moving] {
}

Once your species has the moving skill, it earns automatically the following attributes: speed, heading, destination and the following actions: move, goto, follow, wander and wander_3D.

Attributes:

  • speed (float) designs the speed of the agent, in m/s.
  • heading (int) designs the heading of an agent in degrees, which means that is the maximum angle the agent can turn around each step.
  • destination (point) is the updated destination of the agent, with respect to its speed and heading. It's a read-only attribute, you can't change its value.

Actions:

follow

moves the agent along a given path passed in the arguments.

  • returns: path
  • speed (float): the speed to use for this move (replaces the current value of speed)
  • path (path): a path to be followed.
  • move_weights (map): Weights used for the moving.
  • return_path (boolean): if true, return the path followed (by default: false)

goto

moves the agent towards the target passed in the arguments.

  • returns: path
  • target (agent,point,geometry): the location or entity towards which to move.
  • speed (float): the speed to use for this move (replaces the current value of speed)
  • on (graph): graph that restrains this move
  • recompute_path (boolean): if false, the path is not recompute even if the graph is modified (by default: true)
  • return_path (boolean): if true, return the path followed (by default: false)
  • move_weights (map): Weights used for the moving.

move

moves the agent forward, the distance being computed with respect to its speed and heading. The value of the corresponding variables are used unless arguments are passed.

  • returns: path
  • speed (float): the speed to use for this move (replaces the current value of speed)
  • heading (int): a restriction placed on the random heading choice. The new heading is chosen in the range (heading - amplitude/2, heading+amplitude/2)
  • bounds (geometry,agent): the geometry (the localized entity geometry) that restrains this move (the agent moves inside this geometry

wander

Moves the agent towards a random location at the maximum distance (with respect to its speed). The heading of the agent is chosen randomly if no amplitude is specified. This action changes the value of heading.

  • returns: void
  • speed (float): the speed to use for this move (replaces the current value of speed)
  • amplitude (int): a restriction placed on the random heading choice. The new heading is chosen in the range (heading - amplitude/2, heading+amplitude/2)
  • bounds (agent,geometry): the geometry (the localized entity geometry) that restrains this move (the agent moves inside this geometry

wander_3D

Moves the agent towards a random location (3D point) at the maximum distance (with respect to its speed). The heading of the agent is chosen randomly if no amplitude is specified. This action changes the value of heading.

  • returns: path
  • speed (float): the speed to use for this move (replaces the current value of speed)
  • amplitude (int): a restriction placed on the random heading choice. The new heading is chosen in the range (heading - amplitude/2, heading+amplitude/2)
  • z_max (int): the maximum altitude (z) the geometry can reach
  • bounds (agent,geometry): the geometry (the localized entity geometry) that restrains this move (the agent moves inside this geometry

Other skills

A lot of other skills are available. Some of them can be built in skills, integrated by default in GAMA, other are linked to additional plugins.

This is the list of skills: Advanced_driving, communication, driving, GAMASQL, graphic, grid, MDXSKILL, moving, moving3D, physical3D, skill_road, skill_road, skill_road_node, SQLSKILL

Example

We can now build a model using the skill moving. Let's design 2 species, one is "species_red", the other is "species_green". Species_green agents are moving randomly with a certain speed and a certain heading. Species_red agents wait for a species_green agent to be in a certain range of distance. Once it is the case, the agent move toward the species_green agent. A line link the red_species agent and its target.

images/green_and_red_species.png

Here is an example of implementation:

model green_and_red_species

global{
    float distance_to_intercept <- 10.0;
    int number_of_green_species <- 50;
    int number_of_red_species <- 50;
    
    init {
    create speciesA number:number_of_green_species;
    create speciesB number:number_of_red_species;
    }
}

species speciesA skills:[moving] {
    init {
    speed <- 1.0;
    }
    reflex move {
    do wander amplitude: 90.0;
    }
    aspect default {
    draw circle(1) color:#green border: #black;
    }
}

species speciesB skills:[moving] {
    speciesA target;
    init {
    speed <- 0.0;
    heading <- 90.0;
    }
    reflex search_target when: target=nil {
    ask speciesA at_distance(distance_to_intercept) {
        myself.target <- self;
    }
    }
    reflex follow when: target!=nil {
    speed <- 0.8;
    do goto target: target;
    }
    aspect default {
    draw circle(1) color:#red border: #black;
    if (target!=nil) {
        draw polyline([self.location,target.location]) color:#black;
    }
    }
}

experiment my_experiment type: gui {
    output{
    display myDisplay {
        species speciesA aspect:default;
        species speciesB aspect:default;
    }
    }
}
← Interaction between agentsInheritance →
  • Index
  • Skills
    • Attributes:
    • Actions:
    • Other skills
    • Example
GAMA-Platform
Networks
GitHub Facebook Twitter LinkedIn Youtube Blog RSS
Mailing list
For Users
gama-platform@googlegroups.com
For Developers
gama-dev@googlegroups.com
License

Copyright (C) - 2019 GAMA-Platform.

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.

A copy of the license is included here, in the repository of the wiki content.