[Scripts] CKPE - Editeur Papyrus français

[Gerauld]

Intéressant. S'il y a moyen de trier un peu à ce niveau les instructions, cela pourrait simplifier les recherches pour les traductions...
Pourrais-tu, s'il-te-plait, me présenter ce que tu as pour les fonctions notification, messagebox, setactorvalue() et modAV() (fonctions choisies presque au hasard n'ayant presque rien à voir avec ce sur quoi j'étais presque en train de bosser à l'instant...) ?
Arrives-tu également à sortir quelque chose du genre pour les fonctions SKSE ou seras-tu obligé de passer par les psc pour SKSE?

[Lucead]

Intéressant. S'il y a moyen de trier un peu à ce niveau les instructions, cela pourrait simplifier les recherches pour les traductions...

J'ai commencé à bosser sur une surcouche me permettant d'exploiter correctement la chose. Pour le moment, je n'ai pas coder la partie correspondante au code en lui-même (cela va être un peu plus long vu qu'il y a pas mal d'analyse à faire), mais dans l'absolu c'est tout à fait possible. Pour être précis, je pense que beaucoup de choses sont possibles avec ce système, juste qu'on y a pas encore penser

Pourrais-tu, s'il-te-plait, me présenter ce que tu as pour les fonctions notification, messagebox, setactorvalue() et modAV() (fonctions choisies presque au hasard n'ayant presque rien à voir avec ce sur quoi j'étais presque en train de bosser à l'instant...) ?

Je te sors ça ce soir. Mais globalement cela ressemble énormément à l'exemple de mon post précédent.

Arrives-tu également à sortir quelque chose du genre pour les fonctions SKSE ou seras-tu obligé de passer par les psc pour SKSE?

Il ne me semble pas avoir de script utilisant SKSE chez moi, donc je n'ai pas essayé.
Cependant, de mémoire, les fonctions SKSE présentes dans le psc sont déclarées comme natives. Dans mon exemple précédent, je viens de constater que j'ai copié par erreur la fonction IsDead, qui est une fonction native. Par conséquent, je pense qu'il est tout à fait possible d'appliquer ce fonctionnement aux scripts utilisant SKSE. Juste une précision : ce système fonctionne forcément à partir d'un psc, et surtout à partir d'un psc VALIDE ! Si celui-ci n'est pas valide, l'analyse ne s'effectue tout simplement pas (ce qui n'est pas plus mal, l'utilisateur sait ainsi qu'il a des erreurs).

Par "valide", comprenez qu'il s'agit d'un script qui compile.

J'aurai mis le temps (c'était pas facile non plus), mais à présent toutes les fonctionnalités que tu souhaites et où je te répondais que ce n'était pas possible deviennent réalisables (enfin presque, ça reste à voir bien sûr) En contrepartie, il faut fournir le boulot nécessaire, mais toute la base est là.

Le seul point qui me chagrine dans l'affaire est qu'il me manque certaines informations concernant le placement des textes : je n'ai que la ligne et la position dans la ligne. Il me manque la longueur

[Lucead]

Et voilà, un tout petit script juste pour illustrer comment Papyrus est géré à plus bas niveau.
Comme tu l'as demandé, j'ai mis toutes les fonctions qui t'intéressent, ainsi qu'une fonction SKSE pour tester. Tout semble fonctionner à merveille.

D'abord, le script source :

► Afficher le texte

Code : Tout sélectionner

ScriptName NouveauScript Extends Actor
{Ceci est mon tout nouveau script de test}

Function TestMessageBox(string msg)
    Debug.MessageBox(msg)
EndFunction

Function TestNotification(string msg)
    debug.Notification(msg)
EndFunction

Function TestSetActorValue(string asValueName, float afValue)
    SetActorValue(asValueName, afValue)
EndFunction

Function TestModActorValue(string asValueName, float afValue)
    ModActorValue(asValueName, afValue)
EndFunction

Function TestSKSE()
    int skseVersion = SKSE.GetVersion()
EndFunction

Et maintenant, l'équivalent en "assembleur" Papyrus :

► Afficher le texte

Code : Tout sélectionner

.info
    .source "NouveauScript.psc"
    .modifyTime 1357142480 ;Wed Jan 02 17:01:20 2013 Local
    .compileTime 1357142482 ;Wed Jan 02 17:01:22 2013 Local
    .user "Claude"
    .computer "HAPPY"
.endInfo
.userFlagsRef
    .flag hidden 0    ; 0x00000000
    .flag conditional 1    ; 0x00000001
.endUserFlagsRef
.objectTable
    .object NouveauScript Actor
        .userFlags 0    ; Flags: 0x00000000
        .docString "Ceci est mon tout nouveau script de test"
        .autoState 
        .variableTable
        .endVariableTable
        .propertyTable
        .endPropertyTable
        .stateTable
            .state 
                .function TestSetActorValue
                    .userFlags 0    ; Flags: 0x00000000
                    .docString ""
                    .return None
                    .paramTable
                        .param asValueName String
                        .param afValue Float
                    .endParamTable
                    .localTable
                        .local ::NoneVar None
                    .endLocalTable
                    .code
                        CallMethod SetActorValue self ::NoneVar asValueName afValue  ;@line 13
                    .endCode
                .endFunction
                .function TestNotification
                    .userFlags 0    ; Flags: 0x00000000
                    .docString ""
                    .return None
                    .paramTable
                        .param msg String
                    .endParamTable
                    .localTable
                        .local ::NoneVar None
                    .endLocalTable
                    .code
                        CallStatic debug Notification ::NoneVar msg              ;@line 9
                    .endCode
                .endFunction
                .function GetState
                    .userFlags 0    ; Flags: 0x00000000
                    .docString "Function that returns the current state"
                    .return String
                    .paramTable
                    .endParamTable
                    .localTable
                    .endLocalTable
                    .code
                        Return ::State                                           ;@line ??
                    .endCode
                .endFunction
                .function TestSKSE
                    .userFlags 0    ; Flags: 0x00000000
                    .docString ""
                    .return None
                    .paramTable
                    .endParamTable
                    .localTable
                        .local ::temp0 Int
                        .local skseVersion Int
                    .endLocalTable
                    .code
                        CallStatic skse GetVersion ::temp0                       ;@line 21
                        Assign skseVersion ::temp0                               ;@line 21
                    .endCode
                .endFunction
                .function TestModActorValue
                    .userFlags 0    ; Flags: 0x00000000
                    .docString ""
                    .return None
                    .paramTable
                        .param asValueName String
                        .param afValue Float
                    .endParamTable
                    .localTable
                        .local ::NoneVar None
                    .endLocalTable
                    .code
                        CallMethod ModActorValue self ::NoneVar asValueName afValue  ;@line 17
                    .endCode
                .endFunction
                .function GotoState
                    .userFlags 0    ; Flags: 0x00000000
                    .docString "Function that switches this object to the specified state"
                    .return None
                    .paramTable
                        .param newState String
                    .endParamTable
                    .localTable
                        .local ::NoneVar None
                    .endLocalTable
                    .code
                        CallMethod onEndState self ::NoneVar                     ;@line ??
                        Assign ::State newState                                  ;@line ??
                        CallMethod onBeginState self ::NoneVar                   ;@line ??
                    .endCode
                .endFunction
                .function TestMessageBox
                    .userFlags 0    ; Flags: 0x00000000
                    .docString ""
                    .return None
                    .paramTable
                        .param msg String
                    .endParamTable
                    .localTable
                        .local ::NoneVar None
                    .endLocalTable
                    .code
                        CallStatic debug MessageBox ::NoneVar msg                ;@line 5
                    .endCode
                .endFunction
            .endState
        .endStateTable
    .endObject
.endObjectTable

Et pour plus de praticité, une archive contenant les deux fichiers : http://www.mediafire.com/?h4bhwa997en7qa0
Si tu as de mal à comprendre certaine chose sur le code décompilé, n'hésite pas à me demander sue Steam

Question bête au passage : peut-on appeler "manuellement" un event comme une fonction ?

Pour récupérer le code "assembleur" d'un script Papyrus, suivez la démarche suivante :

► Afficher le texte

1- Compiler le script cible : la compilation doit fonctionner !

2- Copier le .pex généré dans le répertoire "<Skyrim>\Papyrus Compiler"

3- Ouvrir un invite de commande dans le répertoire "<Skyrim>\Papyrus Compiler" (dans le répertoire "<Skyrim>\Papyrus Compiler", maintenir la touche Shift enfoncée et faire un clic droit dans le vide, puis faites "Ouvrir une fenêtre de commandes ici")

4- Saisir la commande suivante : PapyrusAssembler <nom du script sans extension> -D

5- Un fichier "<nom du script>.disassemble.pas" a été créé contenant le code du script

Petite précision : pour une récupération aisée, il est plus simple de décompiler un script.
Cependant, lorsque j'appliquerai ce système dans CKPE, une compilation en amont ne sera pas nécessaire, le moyen utilisé étant légèrement différent.

[Gerauld]

Ce que je comprends, c'est qu'il est donc assez facile d'extraire les fonctions ayant seulement un paramètre de type string et d'exclure celles qui utilisent un paramètre d'un autre type ou plus d'un paramètre pour les traductions.
Cela va modifier un peu le boulot de réflexion mené sur les traductions.

On ne peut appeler directement un event. Il faut le déclencher (du genre faire un activate sur un objet pour déclencher l'event correspondant du script qui y est attaché). Le story manager est un truc pas mal pour certains events.

[Lucead]

Ce que je comprends, c'est qu'il est donc assez facile d'extraire les fonctions ayant seulement un paramètre de type string et d'exclure celles qui utilisent un paramètre d'un autre type ou plus d'un paramètre pour les traductions.
Cela va modifier un peu le boulot de réflexion mené sur les traductions.

Pour les paramètres, c'est en effet possible. Après il faut garder à l'esprit pour les choses plus compliquées que je ne récupère pas exactement ce résultat. Celui-ci a l'avantage d'être plus facilement lisible et applicable que la vraie version. Cela n'empêchera pas de chercher tous les appels aux fonctions sus-mentionnées, et d'agir en conséquence

Cela va modifier un peu le boulot de réflexion mené sur les traductions.

Cela devrait cependant permettre de le simplifier de façon assez conséquente.

On ne peut appeler directement un event. Il faut le déclencher (du genre faire un activate sur un objet pour déclencher l'event correspondant du script qui y est attaché). Le story manager est un truc pas mal pour certains events.

Merci, c'est bien ce qu'il me semblait. En y regardant de plus près, on voit que le compilateur de Papyrus inclus directement les fonction GetState() et GotoState() en "dur" dans le script. Dans le second cas, on le voit appeller un évènement directement par son nom. Je me demande s'il n'est pas possible de berner de la compilateur et d'appliquer ce genre de fonctionnement pour du code personnalisé. L'utilité reste à voir bien évidemment, mais je suis curieux : cela pour simplifier la vie des débutants plutôt qu'employer les méthodes que tu cites (par exemple).

[Gerauld]

On voit clairement l'appel à l'event onendstate puis le code assigner le nouvel état et ensuit appeler l'event onbeginstate. Il faudrait voir à quoi ressemble ces events décompilés et les comparer avec d'autres pour voir.
Je pense que certains appels sont hardcodés (non atteignable via papyrus) mais utilisent la même méthode d'appel ou une méthode voisine. Pourquoi Beth se serait embêter à coder différemment les appels aux events?
Cependant, cela risque d'emmêler les pinceaux aux débutants car ils onfondront plus facilement events et fonctions...

[Lucead]

Je pense que certains appels sont hardcodés (non atteignable via papyrus) mais utilisent la même méthode d'appel ou une méthode voisine.

Je pense que tous les évènements sont codés en dur étant donné qu'il s'agit quand même de la logique même du jeu. Laisse la possibilité à un moddeur de pouvoir redéfinir l'évènement OnActivate() et tu risques d'avoir des bricoles

Cependant, cela risque d'emmêler les pinceaux aux débutants car ils onfondront plus facilement events et fonctions...

Je comprends parfaitement où tu veux en venir, mais d'un certain point de vue, cela relève aussi de l'apprentissage. Ceci dit, ce n'était qu'un exemple. L'idée est surtout de voir comment le compilateur fait son boulot, et s'il n'utilise pas quelques astuces à-priori "cachées" et qu'on puissent les réutiliser.

Au passage, avec le petit tuto que j'ai fait précédemment, on tient une façon de retrouver les sources d'un script à partir d'un fichier script compilé (et on a même la documentation !). Cela peut aussi servir dans une certaine mesure.

Autre point intéressant : à partir d'un script bien documenté, il pourrait être tout à fait possible de créer automatiquement une documentation liée au script (dans le même style que le wiki du CK). Je pense notamment à ça quand je vois t'as série des SE qui, à mon avis, doit comporter pas mal de fonction.

[Lucead]

Bonjour par ici !

J'en ai fini avec la prise en charge de l'arbre de logique sémantique !
CKPE sera donc à l'avenir capable d'analyser la structure d'un script (propriétés, variables, fonctions, évènements, etc), mais aussi le code en lui-même !

Il me reste bien sûr une phase de test à entreprendre, même si cela semble bien fonctionner dans la mesure où j'arrive à analyser les scripts de base les plus complexes du jeu.
Donc si vous savez où je peux trouver des scritps costauds (genre quelques milliers de lignes ), ça m'intéresse ! En dehors des scripts vanilla, j'ai qu'un script de Gerauld, plutôt limité comme tests donc.

Concernant les comparaisons de script
J'ai maintenant toutes les clés en main pour réaliser cette fonction, même si cela me prendra encore un peu de temps.
Trier des fragments ne sera pas faciles, dans la mesure où ils sont écrits avec des commentaires, et que le lexer ignore les commentaires.
Cependant, l'analyse peut être réalisée par "contexte", ce qui est parfait (par exemple, au sein d'une même fonction, et ce quelque soit l'emplaçement de la fonction dans les scripts).
La comparaison de propriétés/variables devient au passage un jeu d'enfant

Bref bref, ça avance ENFIN !

[Lucead]

@Gerauld : Comme il me semble que tu étais parti pour essayer d'écrire un algorithme de détection des chaînes à traduire, je poste rapidement pour t'arrêter, ou au moins te faire ralentir

En effet, je peux maintenant appliquer une méthode de développement un peu particulière me permettant de traiter un script comme une base de données (en quelque sorte) !
En gros, voici le code dont j'ai besoin maintenant pour récupérer tous les appels à Notification() et MessageBox() dans un script, quelque soit l'emplaçement de l'appel. Tous les cas de figure ne sont pas encore pris en comptes cependant.

Code : Tout sélectionner

// Récupération des appels à Notification() et MessageBox() dans les évènements
var events_notifications = LookFor<ExpressionCall>(script.Events).Where(x => x.MethodName.Text == "Notification");
var events_messageBox    = LookFor<ExpressionCall>(script.Events).Where(x => x.MethodName.Text == "MessageBox");

// Récupération des appels à Notification() et MessageBox() dans les fonctions
var functions_notifications = LookFor<ExpressionCall>(script.Functions).Where(x => x.MethodName.Text == "Notification");
var functions_messageBox    = LookFor<ExpressionCall>(script.Functions).Where(x => x.MethodName.Text == "MessageBox");

// On fusionne les appels de Notification() trouvés dans les évènements avec ceux trouver dans les fonctions
var notifications = from x in events_notifications.Union(functions_notifications) 
                    select x;

// On fusionne les appels de MessageBox() trouvés dans les évènements avec ceux trouver dans les fonctions
var messageBox = from x in events_messageBox.Union(functions_messageBox)
                 select x;

Les lignes de LookFor peuvent être traduites comme ceci :
Rechercher dans les évènements/fonctions du script des appels de fonctions (ExpressionCall) dont le nom de méthode est Notification/MessageBox

En réalité, j'aurai même pu faire encore plus court, mais par soucis de lisibilité, je laisse comme ça.

Bien évidemment, dans le cas présent, j'ai filtré les appels sur le nom de la méthode, mais on peux filtrer d'autres informations. Mon application de test ressort, pour chaque élément, la ligne où l'appel est fait. Avec ça, je pense qu'on peut faire un très bon outil de traduction. J'attends par conséquent ton retour sur le sujet pour incorporer tes suggestions, et après ça sera terminé pour ce point-là

[Gerauld]

Effectivement, cela change du tout au tout la manière de procéder. Je vais donc partir dans l'autre sens.
Deux questions pour savoir si ça vaut e coup que je continue à bosser sur le passé des variables de type string devant potentiellement être traduites :
Peux-tu également filtrer les instructions nécessitant une seule variable de type string (celle en contenant plusieurs ne devant pas être traduites)?
Peux-tu "pister" une variable utilisée avec une instruction (notification par exemple) et remonter les valeurs qui lui sont assignées et/ou l'endroit et la manière dont elle est définie?

Je vais tenter d'adapter ce que j'ai fait à ceci (normalement, ça va le faire).
J'ai fini de bosser sur ma petite base en VB (et quelques fonctions de traitement très simples).
Je vais donc pouvoir ressortir le C# et les sources de CKPE pour regarder un peu cette semaine (arpès avoir terminé 2/3 trucs pour la Forge).