Donc maintenant les prépositions sont importantes 
Faire cela dans la bibliothèque « de base » contribuerait à nous éloigner encore de la version anglophone d’inform (qui est la version originale).
En revanche ajouter cela sous la forme d’une extension optionnelle me semble une bonne idée.
- « Mon problème » est que si je saisie au lieu de le comportement d’inform est plutôt suprenant, que l’objet soit "static"ou pas.
- Si je n’ai pas la clef est qu’elle est dans le lieu Inform s’en saisie tout seul.
C’est tout. Rien de grave.
Bonne continuation.
D’accord, je comprends mieux. En effet, les actions implicites d’inform sont parfois assez étrange surtout quand il veut faire quelque chose à un objet à l’aide de lui-même (ce qui n’a aucune chance de fonctionner).
Il est possible, je crois, de définir une constante pour les désactiver purement et simplement.
Je suis en train de regarder les routines Translation du fichier French.h
[ DernierMot n;
if (n==NbMots()-1)
return true;
else
return (Mot(n+1) == THEN1__WD or THEN2__WD or THEN3__WD);
];
Doit être equivalent à
[ DernierMot n;
return (n==NbMots()-1) || (Mot(n+1) == THEN1__WD or THEN2__WD or THEN3__WD));
];
puisque avec || ou && le test ne continue que si l’expression située à gauche est vraie.
(Mais bon…)
sinon, pour la routine qui supprime les accents il est possible de rajouter le ÿ
« Note : la lettre « ÿ » est exceptionnellement utilisée en français ex. : « L’Haÿ-les-Roses », nom d’une localité du sud de Paris). »
(Mais bon…)
correction:
[ DernierMot n;
return ( n==NbMots()-1 || Mot(n+1) == THEN1__WD or THEN2__WD or THEN3__WD);
];
(Mais bon…)
.
Attention de ne pas tout chambouler. Cette phrase est utile si on veut taper : « fermer la porte à clé », cela me semble parfaitement logique de la garder !
Les structures de la forme :
- ‹ à ›/‹ a ›/‹ au ›/‹ aux › creature
sont obligatoires : on n’a pas besoin de la version avec accent (‹ a ›/‹ au ›/‹ aux › creature serait suffisant), mais dans les résultats des commandes si on ne met pas l’accent on se retrouve avec des phrases genre :
parler
(a la femme)
et cela fait une faute d’orthographe. Et si on ne place que la version ‹ à ›/‹ au ›/‹ aux › creature si qqu’un tape la commande sans accent cela peut poser problème
Comme a dit Stormi, Inform 6 ce n’est pas nous qui l’avons développé, aussi il est souhaitable de rester le plus proche possible de la version anglaise au niveau de la structure et des bibliothèques. D’autant plus que Inform 6 ne va sans doute plus du tout évoluer, du fait de l’arrivée d’Inform 7. De même, Inform 6 ne passera sans doute jamais en encodage utf8, vu que Inform 7 le supporte, et les compilations sous jacentes en I6 restent dans le vieil encodage (et ceci sous mac os x, windows, linux).
Si vous souhaitez faire des choses un peu plus expérimentales, à mon avis il vaut mieux avoir cela dans une bibliothèque séparée, soit en complément, soit en remplacement. À noter que c’est ce que fait platypus en anglais.
Non, cette ligne ne matche même pas « fermer la porte à clé », à cause du « held », d’où son inutilité.
« Fermer la porte à clé » reste compris dans une certaine mesure (l’action Lock a toujours besoin d’un « second »), donc on aura soit une action implicite (plus ou moins heureuse) soit une question « Préciser l’objet à utiliser » si on tape « Fermer la porte à clé »
Voici la grammaire du verbe fermer, après suppression de la ligne en trop :
Verb 'fermer' 'refermer'
* noun -> Close
* noun 'avec' held -> Lock
* noun 'à'/'a' 'clé'/'clef'/'cle' 'avec' held -> Lock;Une petite routine tirée de ShowVerbSub de parserm.h qui permet de savoir si un mot est un verbe ou pas.
[Is_Verb mot;
if (mot == 0 || ((mot->#dict_par1) & 1) == 0) rfalse;
];
Si le mot est nul ou si le bit_verbe du mot n’est pas mis alors ce n’est pas un Verbe, on retourne faux
Sinon c’est un Verbe, on retourne Vrai (par défaut)
Du coup, une autre petite routine qui permet au joueur d’afficher les verbes du dico.
[VerbesSub mot len i;
new_line;
len= (dict_end - dict_start) / dict_entry_size;
for (i = 0 : i < len: i++){
mot = No__Dword(i);
if (Is_Verb(mot)) print (address) mot,« / »;
}
new_line;
];
Verb meta ‹ verbes ›
* ->Verbes
A améliorer pour que le joueur puisse les saisir avec un joker:
< verbes lo*> affiche look lock …
bonjour, une petite routine maison que j’utilise pour debugger, si cela peut aider.
A insérer avant include « FrenchG » ou Include « Grammar »;
[ BeforeParsing i w at len;
#Ifdef TARGET_ZCODE;
print « Buffer_Text : « , « [ »,buffer->0, »] »,« [ »,buffer->1,« ]^ »;
print « [ »;
for (i = 2 : i < 2+buffer->1 : i++) print (char) buffer->i;
print « ][ »,buffer->0-i+2,« ]^ »;
print « Buffer_Parser : « , « [ »,parse->0, »] »,« [ »,parse->1,« ]^ »;
for (w=1 : w < parse->1 : w++){
at = parse->(4w+1);
len = parse->(4w);
if (parse–>(2w-1)==0) print « ( »;
else print « [ »;
for (i=0 : i< len : i++)
print (char) buffer-> (at+i);
if (parse–>(2w-1)==0) print « ) »;
else print « ] »;
}
new_line;
@tokenise buffer parse;
#Endif;
];
!*! pour Verb ‹ inventaire › ‹ inv › ‹ i// › ‹ haut › / ‹ large ›, en ‹ ligne › et en ‹ colonne › serait pas mal.
et ça sert à quoi ?
Sinon tu es en train d’écrire un jeu ? Pourrais-tu nous en dire plus ?
(Pour correction: <for (w=1 : w <=) parse->1 : w++> « <= » pas « < »)
Ca sert à ça (par exemple):
j’ai écrit une petite routine RempaceMot(wn,« ») qui comme son nom l’indique remplace ça:
if (word == ‹ dessous ›)
{ LTI_Insert(at, ’ '); ! remplace
buffer->at = ‹ s ›;
buffer->(at+1) = ‹ o ›;
buffer->(at+2) = ‹ u ›;
buffer->(at+3) = ‹ s ›;
buffer->(at+4) = ‹ - ›;
buffer->(at+5) = ‹ l ›;
buffer->(at+6) = ‹ u ›;
buffer->(at+7) = ‹ i ›;
Tokenise__(buffer,parse);
i = 0; continue;
}
par ça:
if (word == ‹ dessous ›) RemplaceMot(wn,« sous-lui »);
Ce qui doit diviser la partie « Translation » (5 pages imprimées en petit caractères) à peau de chagrin. Et surtout cela devient beaucoup plus lisible.
J’essaye simplement de comprendre un peu Inform. Après la lecture des remarquables « The Inform Designer’s Manual » et le « The Inform Beginner’s Guide » , je mesure à quel point Inform est un langage de programmation performant mais complexe. Je vois mal comment il est possible de faire un jeu sans maitriser un minimum ce langage.
Je me demande surtout pourquoi malgré le remarquable travail fait sur la traduction française des librairies, j’utilise les librairies anglaises malgré mon anglais médiocre.
Je revois intégralement le contenu des fichiers FrenchG.h et French.h, pas pour tout casser, bien au contraire mais pour faire une version au plus proche de la version anglaise. Une version que j’espère stable et lisible pour pouvoir faire des petits jeux en français.
Mais au fait, c’est vrai, ça sert à quoi?
La question, sauf erreur de ma part, portait sur ta fonction BeforeParsing.
Tout le monde ne lit pas le code inform couramment 
Là j’approuve tout à fait (comme quoi même si j’ai l’air borné…). Peux-tu nous donner le code de la fonction, que je l’intègre et que je réduise la fonction LanguageToInformese à « peau de chagrin » ?
Moi aussi je me le demande, je l’avoue, car je n’ai pas encore vu dans les remarques précédentes d’indication de problème majeur d’utilisabilité des libs françaises dans leur état actuel.
Par ailleurs la traduction françaises des bibliothèques est déjà très proche de la version anglaise, pour la bonne raison que le travail de départ a été commencé par Graham Nelson (comme on peut le voir dans le DM4), et je ne crois pas que les suivants aient particulièrement « trahi » l’esprit de la version anglaise.
Apporter des améliorations à French.h et FrenchG.h, c’est toujours nécessaire, mais ce que je ne comprends pas à l’heure actuelle c’est quels sont les points qui la rendent non utilisable.
Tu es arrivé sur le forum avec un paquet propositions pour modifier la bibliothèque, une partie desquelles me semblent intéressants, l’autre partie moins (suppression complète des prépositions, c’est en contradiction avec la version anglaise justement, ou avec d’autres systèmes tels que TADS), mais il nous manque toujours, pour comprendre tout ça, la motivation sous-jacente, et surtout quels sont les problèmes « concrets » (pas de beauté du code, mais d’utilisabilité réelle) rencontrés lors de tes tentatives d’utilisation (il y a dû en avoir vu la conclusion selon laquelle elles ne sont pas utilisables). Je pense que ce serait la première étape à suivre (donner des exemples, en discuter ensemble), avant de se lancer dans une revue complète du système.
Bonjour,
Work in progress…(ou pas):
Révision du fichier French.h à partir de ceux de l’inform6_kit_debutant.
- Traductions /* Ça à l’air remarquable et n’a pas du être simple!!! */
- suppression et remplacement totale de la partie « Translation »
- suppression et remplacement de la routine enleve_accent().
Les accents sont supprimés systématiquement de la saisie. Mais avant la suppression recherche de mots accentués problématiques (dé à jouer…)
Révision du fichier FrenchG.h
- révision et remplacement de tous les verbes.
- suppression de la routine ParseNoun() (Algorithme aberrant.)
- suppression et remplacement de la routine UnknownVerb();
La routine remplace les « kilomètres » de < if (word==‹ allonge ›) return ‹ allonger › > du fichier FrenchG.h;
Pour cela il faut ajouter le radical du verbe à ces synonymes. Il est evidement possible de remplacer le verbe lui-même par son radical mais on perd en lisibilité.
ex:
Verb ‹ allumer › ‹ demarrer › * noun → Switchon;
-Devient : Verb ‹ allumer › ‹ demarrer › ‹ allum › ‹ demarr › * noun → Switchon;
-Ou : Verb ‹ allum › ‹ demarr › * noun → Switchon;
-Donc : allum allume allumes allumons allumez allumer sont compris.
Dans tous les cas, la place occupée dans le dictionnaire et inférieur à l’ancienne formule.
Il est inutile d’ajouter un radical supérieur à 8 caractères, le Dictionnaire Inform n’en stocke que 9 maxi.(6 en mode Mini)
Il est inutile d’ajouter un radical inférieur à RADICAL_MINI caractères(4 arbitrairement), il faut alors traiter ce verbe dans la routine (voire routine.)
Constant RADICAL_MINI 4;
Constant RADICAL_MAX 9;
[ UnknownVerb w at len;
!/* gestion du verbe par radical significatif. /
!/ traiter les radicaux inférieurs a RADICAL_MINI (ex. aller). /
if (w ==‹ vais › or ‹ vas › or ‹ va › or ‹ allons › or ‹ allez ›) return ‹ aller ›;
if (w ==‹ dis › or ‹ disons › or ‹ dites ›) return ‹ dire ›;
if (w ==‹ fais › or ‹ faisons › or ‹ faites ›) return ‹ faire ›;
!/ … /
len = parse->(41);
if (len >= RADICAL_MINI){;
at = len + 1;
while(at > RADICAL_MINI+1){
buffer->(at)=’ ';
if (at <= RADICAL_MAX){
w = DictionaryLookup(buffer+2,at-1);
if (w ~= 0) return(w);
}
at–;
}
}
rfalse;
];
Reste à faire…(ou pas)
- Routines pour l’aide à la décision du parseur avec les pronoms, prépositions …
- Remplacement de ‹ et › par ‹ . › pour les saisies multiples.
- Gestion des noms et des adjectifs pour les objets (La propriété Name servira uniquement pour le nom de l’objet et ses synonymes. La propriété Adjectif permettra de différencier deux objets similaires. Plus aucune préposition ou article dans les propriétés Name et Adjectif.)
- Version Zplet et GLULX séparées (Translation_Zplet.h, Translation_GLULX.h)
- documentation lisible
-… - Déboguage!!!
Reste à faire un jeu…(ou pas.)
(Un petit bogue dans la SVN:
Verb ‹ manger › * ‹ de/du › held → Eat; ‹ de ›/‹ du › à la place de ‹ de/du ›)
Pour la routine RemplaceMot() j’utilise un indexage à 1 pas à 0. Donc, le Mot(1) se lit le mot 1 pas, le mot 0.
Ce qui évite ce genre de commentaires dans ton code:
/* word = Mot(0); ! 1er mot / !!!
Si tu choisis un indexage partant de 0, rien n’empêche de définir des constantes:
Constant Mot1 0;
Constant Mot2 1;
Constant Mot3 2;
/ word = Mot(Mot1); ! 1er mot */
C’est mieux non!!!
Pour ma routine il faudra donc la modifier.
Pas de précipitation…
1- Ma routine devrait tester le mot du dico pour savoir si c’est un verbe ou pas (c’est mieux.)
2- Il est possible de faire beaucoup mieux et ne pas avoir a rajouter de radical dans les synonymes des verbes.
Il suffit de parcourir le dictionnaire de verbe et de chercher dans chacun, celui qui contient le plus grand nombre de caractères significatifs du mot saisie.
La routine risque d’être plus lente mais bon… Je regarde…
attention, c’est une version qui est peut-être un peu vieille, préférer le svn comme base de travail. (faudra que je la mette à jour à l’occasion)
Bonjour,
cette fois vous pouvez tester la routine.
Dans le fichier FrenchG, désactivez votre routine [ UnknownVerb word;]; en ajoutant un X devant (ou n’importe qu’elle lettre) [ XUnknownVerb word;];
Insérez le code suivant à la place par copier/coller ou mieux par fichier Include.
La routine gère donc les verbes non compris par le parseur. Il n’est pas utile de rajouter quoique ce soit à vos Verbes.
< pre pomme > ne serra pas compris car ‹ pre › est inferieur à RADICAL_MINI, 4 caractères (valeur modifiable.)
< pren pomme > serra compris < prendre pomme>
< moi, pren pomme > serra compris < moi, prendre pomme >
< boby, pren pomme > serra compris < boby, prendre pomme >
Fonctionne donc pour ‹ pren › et supérieurs : prenons, prenez, prendre… La taille du dictionnaire et considérablement réduite car ces mots ne dont pas inscrits dans celui-ci.
Merci de bien vouloir tester la routine et faire vos commentaires.
!VERSION DE TEST_1 NE FONCTIONNE QUE POUR ZPLET (pour l’instant).
Constant RADICAL_MINI 4;
Array BufferMot->16+2;
[IsVerb mot;
if (mot == 0 || ((mot->#dict_par1) & 1) == 0) rfalse;
];
[UnknownVerb w at len len1 len_dic i j cpt cptmax Vmot w0 w1;
!gestion du verbe par radical significatif.
!traiter les radicaux inferieurs a RADICAL_MINI (ex. aller).
if (w ==‹ vais › or ‹ vas › or ‹ va › or ‹ allons › or ‹ allez ›) return ‹ aller ›;
if (w ==‹ dis › or ‹ disons › or ‹ dites ›) return ‹ dire ›;
if (w ==‹ fais › or ‹ faisons › or ‹ faites ›) return ‹ faire ›;
!..
len = parse->(4verb_wordnum);
at = parse->(4verb_wordnum+1);
len_dic = (dict_end-dict_start)/dict_entry_size;
for (i = 0 : i < len_dic: i++){
w = No__Dword(i);
if (IsVerb(w)){
@output_stream 3 BufferMot;
print (address) w;
@output_stream -3;
len1 = BufferMot–>0;
cpt = 0;
for (j=0 : j < len : j++){
if (j > len1) break;
w0 = buffer->(j+at);
w1 = BufferMot->(j+2);
if (w0 == w1){
cpt++;
if (cpt > cptmax){ cptmax = cpt; Vmot = i;}
}
else break;
}
}
}
if (cptmax > RADICAL_MINI-1)
return No__Dword(Vmot);
rfalse;
];
Bonjour,
comment rendre la saisie du Parser d’Inform plus « confortable ».
/*************
Trop Simple:
/*************
La saisie pose des problèmes avec ‹ , › et ‹ et ›
< prendre pomme, poire et scoubidoubidou et vas au nord > est invalider.
Comment faire(1)
Je décide que ce n’est plus ‹ , › qui permet de donner des ordres mais ‹ : ›
< Boby : va au nord >
Je récupère la virgule qui peut donc être utilisée pour énumérer les objets.
< Boby : prend la pomme, la poire et le scoubidoubidou > Ok
Le traitement du ‹ et › dans < et vas au nord > doit probablement se faire par programmation.
MAIS, pourquoi ne pas proposer le ‹ & › par défaut en attendant mieux.
< Boby : prend la pomme, la poire et le scoubidoubidou & vas au nord> Ok
ou classiquement :
< Boby : prend la pomme, la poire et le scoubidoubidou . Vas au nord> Ok
Comment faire(2)
J’apporte le modifications suivantes:
Dans le Fichier French,h
Constant AND2__WD = ‹ ,// ›;
Constant THEN3__WD = ‹ &// ›;
Dans le Fichier : Parserm,h
Routine NextWord (version Zplet et Glulx, donc deux modifications)
if (j == ‹ ,// ›) j = comma_word;
remplacé par
if (j == ‹ :// ›) j = comma_word;
Et je signale par un commentaires en tête de fichier les modifications faites.
Voilà. Trop simple.
(il est possible est préférable de faire des modifications par variable Global ou Constant. Ce qui permet au joueur (pourquoi pas avec un meta Verb) de choisir ce qui lui convient.
/*************
Programmation:
/*************
Il reste par programmation à « décoller » le ‹ : › du mot, si la saisie est
< BOB: vas au nord> devient
MAIS, ce n’est pas encore satisfaisant
< bob vas au nord > est invalider. Il faut ‹ : ›
Il est simple de tester si le premier mot saisie est un objet à qui je peux donner des ordres. Si c’est le cas et qu’il n’y a pas de ‹ : ›, je l’insère dans le buffer.
< prend la clef la pomme la poire > sont invalider. Il faut ‹ et › ou ‹ , ›
Le programme doit prendre cela en charge et permettre ce type de saisie, ainsi que < Bob prend clef pomme poire >
/***** mieux *******
/*********************
Si je saisie < Bob: > ou simplement < Bob > et un retour à la ligne, je change le Prompt ‹ > › par ‹ << › et je pilote maintenant Bob.
Bob:
<< Prend la pomme
<< Regarde le coffre
<< va au nord et regarde
<<
Je sors du système en faisant un saisie vide et je récupère le Prompt habituel ‹ > ›.
Je suis redevenu moiii.
La gestion des pronoms en Français sous Inform ne fonctionne pas du tout.
Avec la table actuelle, dans un jeu,
je saisie et < pronouns >, j’obtiens :
-le signifie le barman
-lui signifie le barman
luy signifie le barman
lui signifie le barman
je saisie et < pronouns >
-le signifie le breuvage
-lui signifie le breuvage
luy signifie le breuvage
lui signifie le breuvage
Plus aucune trace du Barman.
Le breuvage disparait à son tour si j’examine à nouveau le Barman, acaetera.
Les pronoms ne servent à rien.
-le et lui sont synonymes dans la table et partagent des bits communs avec luy et -lui et le.
La confusion est totale.
J’ai revue la table:
/*----------------------------------
Array LanguagePronouns table
! word possible GNAs connected
! to follow: to:
! a i
! s p s p
! mfnmfnmfnmfn
! Object pronouns
'-le' $$000000100000 NULL
'-la' $$000000010000 NULL
'-les' $$000000000110 NULL
'-lui' $$110000000000 NULL
'-leur' $$000110000000 NULL
'lui' $$100000000000 NULL
'elle' $$010000000000 NULL
'eux' $$000110000000 NULL
'elles' $$000010000000 NULL;
Array LanguageDescriptors table
! word possible GNAs descriptor connected
! to follow: type: to:
! a i
! s p s p
! mfnmfnmfnmfn
'mon' $$100000100000 POSSESS_PK 0
'ma' $$010000010000 POSSESS_PK 0
'mes' $$000110000110 POSSESS_PK 0
'ton' $$100000100000 POSSESS_PK 0
'ta' $$010000010000 POSSESS_PK 0
'tes' $$000110000110 POSSESS_PK 0
'notre' $$110000110000 POSSESS_PK 0
'nos' $$000110000110 POSSESS_PK 0
'votre' $$110000110000 POSSESS_PK 0
'vos' $$000110000110 POSSESS_PK 0
'son' $$100000100000 POSSESS_PK 'lui'
'sa' $$010000010000 POSSESS_PK 'lui'
'ses' $$000110000110 POSSESS_PK 'lui'
'son' $$100000100000 POSSESS_PK 'elle'
'sa' $$010000010000 POSSESS_PK 'elle'
'ses' $$000110000110 POSSESS_PK 'elle'
'son' $$100000100000 POSSESS_PK '-lui'
'sa' $$010000010000 POSSESS_PK '-lui'
'ses' $$000110000110 POSSESS_PK '-lui'
'leur' $$110000110000 POSSESS_PK 'eux'
'leurs' $$000110000110 POSSESS_PK 'eux'
'leur' $$110000110000 POSSESS_PK 'elles'
'leurs' $$000110000110 POSSESS_PK 'elles'
'le' $$100000101000 DEFART_PK NULL
'la' $$010000010000 DEFART_PK NULL
'l^' $$110000110000 DEFART_PK NULL
'les' $$000110000110 DEFART_PK NULL
'un' $$100000100000 INDEFART_PK NULL
'une' $$010000010000 INDEFART_PK NULL
'des' $$000110000110 INDEFART_PK NULL;
BON, ÇÀ VA VOUS CHANGER LA VIE !!!
-le → dernier objet Male
-la → dernier objet Female
-les → dernier objet Male/Female pluralname
-lui → dernier animate Male/Female
-leur → dernier animate Male/Female pluralname
lui → dernier animate Male
elle → dernier animate Female
elles → dernier animate Female pluralname
eux → dernier animate Male/Female pluralname
ET Là, C’EST LA FÊTE DES PRONOMS :
Regarder elle
Donner ma montre à eux
Donner son portefeuille à lui
Donne-lui leur montre
Regarder montre à eux…
La pronoms se remplissent ET RESTENT utilisables.
Si vous voulez essayer, désactivez toute la partie Translation du fichier French.h,
pour éviter les conflits. Il vaut mieux laisser travailler Inform.
Ne collez pas le pronom au verbe. Regarder -lui au lieu de Regarder-lui.
je définis Constant MANUAL_PRONOUNS; en tête du fichier jeu.
Définissez le genre de vos objets avec Male, Female, Pluralname et animate pour les personnages.
Reste plus qu’a déboguer.