index = 0    
On parcourt la liste : motActuel
    si motActuel ==  "*"
        incrémenter index
    si motActuel == "**"
        retourner -1(le mot n'est pas dans la liste)
    sinon
        si mot == liste[motActuel]
            retourner index

int trouverMot(char const *syno[], char *mot)
{
    int ret = 0;
    int i;

    for(i = 0 ;; i++)
    {
        /* On parcourt la liste de synonymes */
        if(syno[i][0] == '*')
        {
            /* On a atteint la fin d'une série de synonymes */
            if(syno[i][1] == '*')
            {
                /* On a atteint la fin de la liste , le mot n'est inconnu */
                return -1;
            }
            /* On passe à la prochaine série de synonymes */
            ret++;
        }
        else
        {
            /* On teste si le mot correspond à la "racine" du zynonyme actuel */
            if(strncmp(mot, syno[i], strlen(syno[i])) == 0)
            {
                /* On a trouvé le mot, on retourne son ID */
                return ret;
            }
        }
    }
}

On se place au début du prochain mot
Lecture du caractère courant    
Tant que le caractère courant est une lettre
    on ajoute la lettre en majuscule à notre mot
    lecture du caractère courant
On replace le dernier caractère lu

void lireMot(char *mot, int taille)
{
    int len = 0;
    int c;

    /* On se place au début du prochain mot */
    prochainMot();

    /* Tant qu'on lit une lettre, on est en présence d'un mot */
    c = getchar();
    while(len < taille - 1 && isalpha(c))
    {
        /* On place la lettre en majuscule à l'emplacement courant du mot */
        /* et on passe à l'emplacement suivant */
        mot[len++] = toupper(c);
        c = getchar();
    }
    /* On forme une chaîne valide */
    mot[len] = '\0';

    /* On replace le dernier caractère lu dans le flux */
    ungetc(c, stdin);
}

Lecture du caractère courant
Tant qu'on est pas à la fin de la phrase
    lire un mot
    si le mot est une action
        si on avait pas encore d'action
            actionLue = mot converti en action
        sinon
            retourner erreur
    sinon si le mot est un objet
        si on avait pas encore d'objet
            objetLu = motConverti en objet
        sinon
            retourner erreur
    Lecture du caractère courant

int lirePhrase(int *pIdAct, int *pIdObj)
{
    char mot[BUF_SIZE];
    int err = 0;
    int c = getchar();

    *pIdAct = -1;
    *pIdObj = -1;

    while(c != '\n' && !err)
    {
        int id;
        ungetc(c, stdin);

        lireMot(mot, BUF_SIZE);
        /* On regarde le mot est dans la liste des actions */
        id = trouverMot(a_actionsSyno, mot);
        if(id >= 0)
        {
            /* On a lu une action */
            if(*pIdAct < 0)
            {
                /* C'est la première action rencontrée dans la phrase */
                *pIdAct = id;
            }
            else
            {
                /* On a déjà rencontré une action aupravant, erreur ! */
                return -1;
            }
        }
        else
        {
            /* Le mot n'est pas une action */
            /* On Regarde si le mot est un objet */
            id = trouverMot(a_objetsSyno, mot);
            if(id >= 0)
            {
                /* On a lu un objet */
                if(*pIdObj < 0)
                {
                    /* C'est le premier objet rencontré dans la phrase */
                    *pIdObj = id;
                }
                else
                {
                    /* On a déjà rencontré un objet auparavant, erreur ! */
                    return -1;
                }
            }
        }
        /* On lit le caractère suivant */
        c = getchar();
    }
    /* action inconnue, objet inconnu */
    if(*pIdAct < 0 && *pIdObj < 0)
        err = -1;

    return err;
}

#include <stdio.h>
#include <ctype.h>
#include <string.h>

#define BUF_SIZE    32

typedef enum
{
    ACT_PRENDRE,
    ACT_FOUILLER,
    ACT_EXAMINER,
    ACT_NORD,
    ACT_SUD,
    ACT_EST,
    ACT_OUEST,
    ACT_FIN
} eAction;

typedef enum
{
    OBJ_AMPOULE,
    OBJ_TABLE,
    OBJ_CHAISE,
    OBJ_LIVRE,
    OBJ_CRAYON,
    OBJ_FENETRE,
    OBJ_PORTE,
    OBJ_CLE,
    OBJ_ORDI
} eObjet;



/* Descriptions */
char const *a_actions[] =
{
    "prenne",
    "fouille",
    "j'examine",
    "le nord",
    "le sud",
    "l'est",
    "l'ouest",
    "fin"
};


char const *a_actionsSyno[]=
{
    "PREN","VOL", "DEROB", "*",
    "FOUILL", "CHERCH", "*",
    "EXAMIN", "REGARD", "OBSERV", "*",
    "NORD", "*",
    "SUD", "*",
    "EST", "*",
    "OUEST", "*",
    "FIN", "QUIT", "EXIT",
    "**"
};


/* Synonnymes */
char const *a_objets[] =
{
    "l'ampoule",
    "la table",
    "la chaise",
    "le livre",
    "le crayon",
    "la fenetre",
    "la porte",
    "la cle",
    "l'ordi"
};




char const *a_objetsSyno[] =
{
    "AMPOULE", "LAMPE", "*",
    "TABLE", "BUREAU", "*",
    "CHAISE", "TABOURET", "SIEGE", "*",
    "LIVRE", "BOUQIN", "*",
    "CRAYON", "STYLO", "*",
    "FENETRE", "VITRE", "*",
    "PORTE", "*",
    "CLE", "*",
    "ORDI", "MICRO", "PC",
    "**"
};


void prochainMot(void)
{
    int c;
    /* On lit les caractère tant qu'il ne s'agit pas d'une lettre */
    do
    {
        c = getchar();
    }
    while(!isalpha(c) && c != '\n');

    /* On replace la dernière lettre lue dans le flux */
    ungetc(c, stdin);
}


int trouverMot(char const *syno[], char *mot)
{
    int ret = 0;
    int i;

    for(i = 0 ;; i++)
    {
        /* On parcourt la liste de synonymes */
        if(syno[i][0] == '*')
        {
            /* On a atteint la fin d'une série de synonymes */
            if(syno[i][1] == '*')
            {
                /* On a atteint la fin de la liste , le mot n'est inconnu */
                return -1;
            }
            /* On passe à la prochaine série de synonymes */
            ret++;
        }
        else
        {
            /* On teste si le mot correspond à la "racine" du zynonyme actuel */
            if(strncmp(mot, syno[i], strlen(syno[i])) == 0)
            {
                /* On a trouvé le mot, on retourne son ID */
                return ret;
            }
        }
    }
}


void lireMot(char *mot, int taille)
{
    int len = 0;
    int c;

    /* On se place au début du prochain mot */
    prochainMot();

    /* Tant qu'on lit une lettre, on est en présence d'un mot */
    c = getchar();
    while(len < taille - 1 && isalpha(c))
    {
        /* On place la lettre en majuscule à l'emplacement courant du mot */
        /* et on passe à l'emplacement suivant */
        mot[len++] = toupper(c);
        c = getchar();
    }
    /* On forme une chaîne valide */
    mot[len] = '\0';

    /* On replace le dernier caractère lu dans le flux */
    ungetc(c, stdin);
}



/* Lit une ligne sur stdin, et renseigne les les pointeurs pIdAct et pIdObj
 * Si une action lue
 * *pIdAct = index de l'action, sinon -1
 * Si un objet lu
 * *pIdObj = index de l'objet, sinon -1
 * Valeur retournée:
 *  0 si succès
 * -1 si la phrase est invalide
 */
int lirePhrase(int *pIdAct, int *pIdObj)
{
    char mot[BUF_SIZE];
    int err = 0;
    int c = getchar();

    *pIdAct = -1;
    *pIdObj = -1;

    while(c != '\n' && !err)
    {
        int id;
        ungetc(c, stdin);

        lireMot(mot, BUF_SIZE);
        /* On regarde le mot est dans la liste des actions */
        id = trouverMot(a_actionsSyno, mot);
        if(id >= 0)
        {
            /* On a lu une action */
            if(*pIdAct < 0)
            {
                /* C'est la première action rencontrée dans la phrase */
                *pIdAct = id;
            }
            else
            {
                /* On a déjà rencontré une action aupravant, erreur ! */
                return -1;
            }
        }
        else
        {
            /* Le mot n'est pas une action */
            /* On Regarde si le mot est un objet */
            id = trouverMot(a_objetsSyno, mot);
            if(id >= 0)
            {
                /* On a lu un objet */
                if(*pIdObj < 0)
                {
                    /* C'est le premier objet rencontré dans la phrase */
                    *pIdObj = id;
                }
                else
                {
                    /* On a déjà rencontré un objet auparavant, erreur ! */
                    return -1;
                }
            }
        }
        /* On lit le caractère suivant */
        c = getchar();
    }
    /* action inconnue, objet inconnu */
    if(*pIdAct < 0 && *pIdObj < 0)
        err = -1;

    return err;
}



int estDirection(eAction id)
{
    return id >= ACT_NORD && id <= ACT_OUEST;
}



int main(void)
{
    int idAction = -1;
    int idObjet = -1;

    while(idAction != ACT_FIN)
    {
        int err = 0;

        putchar('>');
        err = lirePhrase(&idAction, &idObjet);
        if(err)
            puts("Rien compris ! Oo");
        else
        {
            if(estDirection(idAction))
                printf("Direction %s !\n", a_actions[idAction]);
            else
            {
                if(idAction >= 0)
                {
                    if(idObjet < 0)
                        printf("Vous voulez que je %s quoi ?\n", a_actions[idAction]);
                    else
                        puts("ok");
                }
                else
                    printf("Voulez que je fasse quoi de %s ?\n", a_objets[idObjet]);
            }
        }
    }
    return 0;
}

>nord
Direction le nord !
>encore au nord!
Direction le nord !
>maintenant au sud, svp
Direction le sud !
>table
Voulez que je fasse quoi de la table ?
>porte alors!
Voulez que je fasse quoi de la porte ?
>observer la table
ok
>fin

Tant que le jeu n'est pas fini
    Si on est dans une nouvelle salle
       afficher description de la salle
    afficher les directions possibles
    analyse de la saisie utilisateur
    si la saisie est valide
        si c'est une direction
           actualiser la position du joueur
        sinon si c'est l'action prendre
           prendre objet
        sinon si c'est l'action poser
            poser objet
        sinon si c'est l'action inventaire
            afficherInventaire
        sinon
            gestion spécifique à chaque salle
    sinon
        afficher erreur