c++ {
    PsNomSym tmp = Nom();

    triggerMechant -> setTableId(&_table);
    triggerMechant -> initTrigger(tmp);
    triggerMechant -> setPosition(27.5,-5);
  };

  use ordonne(
    triggerMechant,
    camera,boutonStart, boutonCamera1, boutonCamera2, boutonCamera3 ,
    kontondant,
    &_visiteurs, &_mechants, &_perdu, &_table
  );
}

scenario ordonne
(
  acteurTrigger * triggerMechant,
  acteurCamera * camera,
  acteurBouton * boutonStart,
  acteurBouton * boutonCamera1,
  acteurBouton * boutonCamera2,
  acteurBouton * boutonCamera3,
  acteurKontondant * kontondant,
  ensembleActeur * visiteurs,
  ensembleActeur * mechants,
  utilisateurCarte ** perdu,
  variableTableId * table
)
{
  instance iCreation of creationHumanos(visiteurs,mechants,perdu,table);
  instance iVoir of voir(
    camera,
    boutonCamera1,
    boutonCamera2,
    boutonCamera3
  );
  instance iActions of actions(
    triggerMechant,kontondant,
    visiteurs,mechants,perdu,table
  );
  instance iSecondaire of scenarioSecondaire(mechants,boutonStart);
 
  schedule {
     iCreation meets iVoir;
     start of iVoir equals start of iActions;
     iCreation meets iSecondaire;
  };
}

scenario creationUnHumano(
  utilisateurCarte **retour,
  variableTableId * table,
  std::string nom,
  std::string x,
  std::string z,
  std::string geometrie
)
{
  include {
    #include "utilisateurCarte.h"
    #include "variableTableId.h"
  };
  declaration { utilisateurCarte * nouveau; };
  c++ {
    nouveau = _refObjetSimul.utilisateurCarteCreation();
    nouveau -> creerModulesAssocies(
      _refObjetSimul,          // le createur de modules
      nom,                     // la base de nom de module cree
      "musee","sol",           // nom du musee et de l'etage
       "cible",Nom().Chaine(), // cible privee et module scenario
      x,z,"0","0",             // position + orientation
      "0",                     // delai au demarrage
      "humano",                // fichiers de donnees mouvements
      geometrie                // fichier de donnees geometrique
    );
  };
  wait (0.04),
  c++ { nouveau -> initId(); };
  waitfor ( nouveau -> idValide() );
  c++ {
    table -> ajouteActeur( nouveau -> getId(), nouveau);
    *retour = nouveau;
  };
}

scenario actions
(
  acteurTrigger * triggerMechant,
  acteurKontondant * kontondant,
  ensembleActeur * visiteurs,
  ensembleActeur * mechants,
  utilisateurCarte ** perdu,
  variableTableId * table
)
{
  include {
    #include "acteurTrigger.h"
    #include "variableTableId.h"
    #include "utilisateurCarte.h"
    #include "acteurKontondant.h"
  };

  declaration {
    utilisateurCarte * _perdu;
    utilisateurCarte * _unMechant;
    bool _situation;
    bool _enclumeTombee;
    bool _abandon;
    bool _free;
  };

  on entree(acteurTriggerGenere * emetteur,ensembleActeur & ensemble)
  from actor triggerMechant type acteurTrigger
  {
    ensembleActeur filtre = ensemble && *mechants;
    if (!filtre.empty())
    {
      _situation = true;
      _unMechant = dynamic_cast<utilisateurCarte *>(*(filtre .begin()));
    }
  };

  c++ {
    _perdu = *perdu;
    kontondant -> setChute(23,50,0, 23,0,0, 30, 1);
    _enclumeTombee = false;
    _situation = false;
    triggerMechant -> active();
  };

  aslongas (!_situation) { use longEnLarge(_perdu); };

  reserve ( actor _unMechant priority(10) )
  {
    success { _abandon = false; }
    failure { _abandon = true; }
  };

  if (!_abandon)
  {
    use discussion(_perdu,_unMechant);

    c++ { _unMechant -> vaJusque(90,0); };
    use versCroix(_perdu);
    c++ { kontondant -> timber(); };
 
    waitfor(_enclumeTombee);

    on butAtteind(acteurKontondantGenere * emetteur)
    from actor kontondant type acteurKontondant
    { _enclumeTombee = true; };
 

    c++ {
      _perdu -> detruireModulesAssocies(_refObjetSimul);
      table -> enleveActeur(_perdu -> getId());
      _refObjetSimul.utilisateurCarteDestruction(_perdu);
 
      kontondant -> setChute(23,0,0, 23,50,0, 200, 1);
      kontondant -> timber();
    };

    free actor _unMechant;

    wait (10),
    reserve ( actor _unMechant priority(1))
    {
      success {
        _unMechant -> stop();
        _free = false;
      }
      failure { _free = true; }
    };
    if (!_free) { free actor _unMechant; };
  };
}

scenario scenarioSecondaire(
  ensembleActeur * ptrMechants,
  acteurBouton * bouton
)
{
  include {
    #include "acteurBouton.h"
    #include "ensembleActeur.h"
  };

  declaration { bool _clic; };

  on clicGauche(acteurBoutonGenere * emetteur)
  from actor bouton type acteurBouton
  { _clic = true; };

  c++ { _clic = false; };
 
  eachtime(_clic)
  {
    c++ { _clic = false; };
    use actionSecondaire(ptrMechants);
  };

  join;
}

scenario actionSecondaire(
  ensembleActeur * ptrMechants
)
{
  include {
    #include "utilisateurCarte.h"
    #include "ensembleActeur.h"
  };

  declaration {
    ensembleActeur source;
    ensembleActeur selection;
    utilisateurCarte * effrayeur;
    bool _termine;
  };

  on confiscation(acteurComRes * confisque) { _termine = true; };

  c++ { source = *ptrMechants; };

  reserve ( from source to selection count(1) priority(1) )
  {
    success { _termine = false; }
    failure { _termine = true; }
  };

  aslongas ( !_termine)
  {
    use embeterOiseaux(selection);
    c++ { _termine = true; };
    free ( selection );
  };
}