retour aux mémos
retour au modèle
retour à la page d'accueilG On peut utiliser le nom d'une interface comme type de variable, ce qui signifie que l'on accepte en paramètre toutes les classes qui implémentent cette interface. Ainsi, on pourra utiliser des méthodes d'interactions des agents avec d'autres agents ou des agents avec le terrain sans tenir compte du nom de la classe (il suffit que celle ci implémente l'interface « agent »). On peut créer autant de classe représentant un type particulier d'agent que nécessaire, ce seront toujours des « Agents ».
Diagramme de classe représentant la structure des éléments de la simulation
§ Avant de commencer à programmer le comportement des agents et les méthodes correspondantes dans leur gestionnaire de terrain, il faut définir quels sont les rôles que doivent remplir les agents et le gestionnaire de terrain.
§ Les agents sont les éléments les plus sujets à des modifications, on va essentiellement définir les interactions de base permettant aux agents de connaître leur environnement et de pouvoir interagir avec. Une fois que l'on aura défini ces fonctions de base, on pourra les utiliser pour créer des interactions plus complexes.
§ La création d'un agent dans la simulation ne peut pas se faire sans savoir sur quel type de support on le place, la fonction de placement des agents doit donc être prise en charge par le gestionnaire de terrain (le gestionnaire de simulation - ContextCreator - gère normalement la création)
§ Un agent doit pouvoir connaître son emplacement. Comme ses coordonnées vont dépendre de la nature du terrain, il faut que ce soit le Ground_Manager qui soit capable de renvoyer les coordonnées d'un objet donné.
§ Un agent doit pouvoir se déplacer. Or, là aussi le déplacement va dépendre du support. L'agent va donc demander au Ground_Manager de le déplacer (selon une distance choisie par l'agent en mètre). C'est au Ground_Manager de s'adapter et d'effectuer les tests et les conversions nécessaires pour adapter le déplacement de l'agent dans le terrain.
§ Un agent possède une certaine représentation de son environnement, puisque le terme de distance dépend également du terrain, le gestionnaire de terrain doit pouvoir renvoyer à l'agent tous les objets qui lui sont visibles selon un champ de vision donné (spécifié par l'agent en mètres).
§ Pour finir, puisqu'un agent peut se déplacer à l'intérieur des terrains, il faut que le gestionnaire de terrain puisse lui envoyer non pas les coordonnées du terrain où veut se rendre l'agent, mais un point à l'intérieur du terrain.
Si on récapitule les quelques informations ci dessus, on peut réaliser l'interface Ground_Manager :
Public
interface
Ground_Manager
{
/**
*
@param
o
an
object
contained
in
the
projection
*
@return
the
coordinate
of
the
object
in
the
projection
*/
public
Coordinate give_object_coordinate(Object o);
/**
*
@param
fa
a
reference
to
an
instance
of
field
agent
*
@return
a
point
within
the
area
of
the
field
agent
*/
public
Coordinate get_internal_point(Field_Agent fa);
/**
*
@param
a
:
the
object
to
move
*
@param
c
:
the
destination
coordinate
*/
public
void
move_Object(Agent a,Coordinate c);
/**
*
@param
a
:
the
agent
which
is
looking
around
him
*
@param
radius
the
field
of
view
*
@return
an
array
list
of
the
object
which
are
in
the
field
of
view
of
the
agent
*/
public
ArrayList<Object> find_object(Agent a,
double
radius);
/**
*
@param
context
:the
context
where
the
current
projection
is
*
@param
nb_agent
:
the
number
of
agents
to
add
in
the
projection
*/
public
void
add_agents(Context context,int
nb_agent);
}
retour aux mémos
retour au modèle
retour à la page d'accueil