TeaScriptForUnity

[Lion]

TeaScriptForUnity est une extension que je développe.
Je cite la documentation :

TeaScriptForUnity est une extension pour Unity3D qui permet à ses utilisateurs de coder sous Unity au moyen d’un nouveau langage de script nommé TeaScript.

Le TeaScript se veut du même esprit que le CoffeeScript: c’est une surchouche au UnityScript qui apporte principalement des sucres syntaxiques afin de rendre le code plus facile à lire, plus rapide à écrire, et moins sensible aux erreurs de syntaxe.

Plus précisément, le TeaScript cherche à apporter une syntaxe :

- plus facile à lire et comprendre pour les humain, en utilisant des mots au lieu d’expressions (par exemple : « and » au lieu de « && »).
- plus flexible. Elle permet au débutant (ainsi qu’aux chevronnés !) de se concentrer plus sur la logique du code que sur des détails syntaxiques qui ont tendance à générer des bugs.
- plus légère. Elle permet autant que possible d’omettre du code non nécessaire, ou apporte des raccourcis pour les expressions lourdes à écrire (par exemple : une propriété en lecture seule : prop PropertyName get;).

Néanmoins, gardez à l’esprit que la syntaxe qu’apporte le TeaScript n’est en aucun cas obligatoire.
Le TeaScript est convertit en UnityScript, vous pouvez donc à tout moment utiliser la syntaxe normale du UnityScript au sein de vos scripts en TeaScript.

Le TeaScript est juste une surcouche optionnelle et sympathique pour votre langage de script favoris qui vous rend la vie plus facile.

L’objet de ce post est de vous présenter TeaScriptForUnity, de trouver 5 beta testeurs enthousiastes et de vous permettre à tous de proposer des features auxquelles je n'ai pas pensé.

Vous trouverez toutes les informations, notamment ce qu'apporte en pratique le TeaScript, dans le manuel (en anglais uniquement) :

Lire la documentation et tester la démo


Voici les fonctionnalités qui ne sont pas encore implémentées mais qui me sembles intéressantes :
- rendre les points virgules à la fin des instructions optionnels
- rendre les accolades optionnelles (ou utiliser à la place une syntaxe comme en Lua then ... end et do ... end )
- rendre les parenthèses optionnelles (notamment pour tout ce qui est boucles et condition) (déjà possible à certains endroits)
- créer une boucle do ... while
- améliorer les fonctionnalités existantes car plusieurs d'entre elles ne fonctionnement que dans certains cas ou avec des conditions, ce qui n'est ni très pratique ni vraiment flexible.


Je vous laisse donc la parole :
Qu'en pensez-vous ?
Cela vous intéresserait-il de devenir l'un de mes beta testeur ?
Quels sucre syntaxique avez vous toujours rêvé d'utiliser avec votre langage favoris ?

[Max]

ça a l'air sympa, un translate de langage de prog ... mais perso, j'aime pas le thé
(y-a-t-il un public potentiel pour ce genre de truc ?)

[axel]

oui, pour les adeptes du basic qui n'aime pas le C et tout ses dérivés

[Franck]

C'est possible d'avoir un exemple concret?
Un script en js et le meme en tea script.

[Lion]

@Max Les préprocesseurs comme CoffeeScript gagnent en popularité chaque jour parce que les gens voient bien combien leur utilisation leur rend la vie plus facile. C'est particulièrement vrais pour le JavaScript web qui a une syntaxe relativement obtue dans bien des situations.

@Axel La syntaxe du TeaScript ne change pas fondamentalement du UnityScript et ne se rapproche certainement pas du Basic (le smiley dans ton message me laisse penser que tu l'avais bien compris). Comme dit dans la documentation, le TeaScript apporte simplement quelques raccourcis, qui peuvent néanmoins vous faire gagner du temps de réflexion, du temps de tapage, ainsi que du temps de débug.

@Franck Je n'ai pas vraiment d'exemple concret sous la main pour l'instant, mais j'ai prévus de développer un "vrai" petit jeu en TeaScript.
En attendant je te copie/colle ci dessous le fichier que j'utilise pour développer, qui sert en même temps de "show case" et qui regroupe toutes les features actuellement implémentées.

TeaScript

Code: Tout sélectionner

class Test extends MonoBehaviour {

   // Data Types
      
      // You can use "string" instead of "String"
      // and "bool" instead of "boolean"
      var aString: string = "a string";
      var aBoolean: bool = true;
 

      // You can use generic collections with a C#-like syntax
      // (without the dot before and opening chevron
      // and without the obligatory space between two clising chevron)
      var thisIsADico = Dictionary<string, List<bool>> ();
   
 
   // Variable declaration
      
      // You can declare a variable of type char if it's value consiste only
      // of one single character surounded by single quotation marks :
      var aSingleCharacter = 'a';
      var otherSingleCharacter: char = 'b';

      // You can set multiple variables of the same type in a single   line, while setting their value
      // Setting the variables type is mandatory
      var: boolean name1, name2= false  , name3,name4 =true;
      protected var: string text1='false' ,text2 = "another String";

      // New object instanciation syntax
      var thisIsADico new Dictionary<string, List<bool>>;
      var store new Hashtable (thisIsADico);
      

   // Properties declaration
   // You NEED to explicitely declare your class if you want to use properties

      // defaults get/set accessors
      health: double = 0.0;

      prop Health;
      prop Health: double;
      

      // default get accessors (read-only property)
      mana: int;

      property Mana get;
      prop Mana: int get;
      
      
      // default set accessors
      iDontWantToBeRead : string = "";

      prop IDontWantToBeRead set;
      property IDontWantToBeRead: String set;
      

      // custom accessors

      prop Health {
         // default getter. Note that there is no semicolon
         get

         set { // custom setter
            if (value > maxHealth)
               value = maxHealth;
            else if (value < 0)
               value = 0;
         }
      }

      prop PlayerAltitude: float {
         // custom getter
         get {
            return Vector3.Distance (transform.position, ground.transform.position);
         }
      }

      property PlayerStringId {
         set { // PlayerType = "Class Pseudo";
            string[] strings = value.Split (' ');
            m_playerClass = strings[0].Trim ();
            m_playerName = strings[1].Trim ();
         }

         get {
            return m_playerClass+" "+m_playerName;
         }
      }


   // Function declarations

      // You can use the "func" keyword instead of "function"
      func Start () {}

      // The parenthesis are optionnal if there is no parameters
      function Update {}

      func GetMeSomething: string {
         return "What do you want !";
      }
}

// You can create a struct with the "struct" keyword.
struct aStruct {
   // you can use the "constructor" keyword, just like in classes
   constructor (name1: string) {}

   constructor (name1: string, name2: bool) {
      constructor (name1);
   }
}

class OtherTest extends Test {

   // default constructor
   constructor {
      // default parent's constructor
      parent;
      parent ( something) ;

      // works outside a constructor, but only in classes that inherits from a parent
      parent.DoSomething ();
   }

   // another constructor of this class
   constructor (name1) {}

   // and yet another one
   constructor (name1: string, name2: bool) {
      // call another construtcor in this class
      constructor (name1);

      // call the default constructor :
      constructor;
      constructor ();
   }


   func Loops {
      // generic for(;;) loop
      foreach i from 0 to 10 step 2 {}

      for j: float from -5.2 to 52
         Debug.Log ("j="+j);

      foreach k: int to i step -2 {}
      

      // for(;;) loop with arrays (index will always be an int)
      foreach index i in anArray
         someVariable = anArray[i];

      for index i in col _collection {}

      foreach index i in collection _collection {}
         

      // for( in ) loop with collections
      for entry in collection {}
         
      foreach entry: type in collections
         someVar = entry;
   }


   func Conditions () {
      // switch
      switch someVariable {
         if 0: ...;
         if 1:
            ...;
            ...;
         if Enum.Option: ...;

         else: "meh wathever";
      }

      // new operators and, or, not, is isnot
      if (teaScript is "great" and youLikeIt isnt false)

      while (not doStopLoop)

      // isoneof and isnotoneof keyword
      if (name isoneof "TeaScript", "Coffee Script", "UnityScript")

      if (name isnotoneof otherValue, 3.5, false)
   }
}

Le même code, en UnityScript

Code: Tout sélectionner

class Test extends MonoBehaviour {

   // Data Types
      
      // You can use "string" instead of "String"
      // and "bool" instead of "boolean"
      var aString: String = "a string";
      var aBoolean: boolean = true;
 

      // You can use generic collections with a C#-like syntax
      // (without the dot before and opening chevron
      // and without the obligatory space between two clising chevron)
      var thisIsADico = Dictionary.<String, List.<boolean> > ();
   
 
   // Variable declaration
      
      // You can declare a variable of type char if it's value consiste only
      // of one single character surounded by single quotation marks :
      var aSingleCharacter: char = 'a'[0];
      var otherSingleCharacter: char = 'b'[0];

      // You can set multiple variables of the same type in a single   line, while setting their value
      // Setting the variables type is mandatory
      var name1: boolean;
var name2: boolean = false;
var name3: boolean;
var name4 : boolean =true;

      protected var text1: String ='false';
protected var text2 : String = "another String";


      // New object instanciation syntax
      var thisIsADico: Dictionary.<String, List.<boolean>> = new Dictionary.<String, List.<boolean> >();
      var store: Hashtable  = new Hashtable (thisIsADico);
      

   // Properties declaration
   // You NEED to explicitely declare your class if you want to use properties

      // defaults get/set accessors
      health: double = 0.0;

      function get Health() { return health; }
function set Health(value) { health = value; }

      function get Health(): double { return health; }
function set Health(value: double) { health = value; }

      

      // default get accessors (read-only property)
      mana: int;

      function get Mana() { return mana; }

      function get Mana(): int { return mana; }

      
      
      // default set accessors
      iDontWantToBeRead : String = "";

      function set IDontWantToBeRead(value) { iDontWantToBeRead = value; }

      function set IDontWantToBeRead(value: String) { iDontWantToBeRead = value; }

      

      // custom accessors

      function get Health() { return health; }
function set Health(value) { // custom setter
            if (value > maxHealth)
               value = maxHealth;
            else if (value < 0)
               value = 0;
         }


      function get PlayerAltitude(): float {
            return Vector3.Distance (transform.position, ground.transform.position);
         }


      function get PlayerStringId() {
            return m_playerClass+" "+m_playerName;
         }
function set PlayerStringId(value) { // PlayerType = "Class Pseudo";
            string[] strings = value.Split (' ');
            m_playerClass = strings[0].Trim ();
            m_playerName = strings[1].Trim ();
         }



   // Function declarations

      // You can use the "func" keyword instead of "function"
      function Start () {}

      // The parenthesis are optionnal if there is no parameters
      function Update() {}

      function GetMeSomething(): String {
         return "What do you want !";
      }
}

// You can create a struct with the "struct" keyword.
class aStruct extends System.ValueType {
   // you can use the "constructor" keyword, just like in classes
   public function aStruct (name1: String) {}

   public function aStruct (name1: String, name2: boolean) {
      aStruct (name1);
   }
}

class OtherTest extends Test {

   // default constructor
   public function OtherTest() {
      // default parent's constructor
      super();
      super ( something) ;

      // works outside a constructor, but only in classes that inherits from a parent
      super.DoSomething ();
   }

   // another constructor of this class
   public function OtherTest (name1) {}

   // and yet another one
   public function OtherTest (name1: String, name2: boolean) {
      // call another construtcor in this class
      OtherTest (name1);

      // call the default constructor :
      OtherTest();
      OtherTest ();
   }


   function Loops() {
      // generic for(;;) loop
      for (var i: int = 0; i<=10; i+=2) {}

      for (var j: float = -5.2; j<=52; j+=1)
         Debug.Log ("j="+j);

      for (var k: int = 0; k<=i; k+=-2) {}
      

      // for(;;) loop with arrays (index will always be an int)
      for (var i: int = 0; i<anArray.length; i++)
         someVariable = anArray[i];

      for (var i: int = 0; i<_collection.Count; i++) {}

      for (var i: int = 0; i<_collection.Count; i++) {}
         

      // for( in ) loop with collections
      for (var entry in collection) {}

      for (var entry: type in collections)
         someVar = entry;
   }


   function Conditions () {
      // switch
      switch (someVariable) {
         case 0: ...; break;
         case 1:
            ...;
            ...; break;
         case Enum.Option: ...; break;

         default: "meh wathever";
      }

      // new operators and, or, not, is isnot
      if (teaScript == "great" && youLikeIt isnt false)

      while (! doStopLoop)

      // isoneof and isnotoneof keyword
      if (name == "TeaScript" || name ==  "Coffee Script" || name ==  "UnityScript")

      if (name != otherValue && name !=  3.5 && name !=  false)
   }
}

Vous pouvez aussi comparer les deux codes côte à côte en utilisant la démo présente dans le manuel.
Copiez/coller le code en TeaScript dans le champs de gauche puis cliquez sur le bouton "Convert". Le code en UnityScript s'affichera dans le champs de droite.
(J'avais prévus que le WebPlayer fasse ça tout seul justement, mais ça ne fonctionne pas encore )

[Ahbadiane]

J'aime ce type d'initiative, intellectuellement parlant.

Plusieurs questions :
1) TeaScriptForUnity a son propre éditeur ?
2) Mac et PC ?
3) Complétion ?
4) La transcription vers Unity se fait en temps réel => ralentissement de la compilation ?

Je suis aussi réticent sur ce type d'outil pour 2 raisons principalement :
a) On ajoute un niveau de bugs supplémentaires. Oui on peut toujours, je suppose, repasser sur les sources pures Unity mais ce type de problème se produisent avec un tas de sources. On arrive aussi à des cas de désynchronisation entre version TeaScriptForUnity et Unity Pure.
b) Pour un débutant, je ne suis pas certain que se soit un plus car on s'éloigne de l’esprit du code (ex "string" instead of "String" et pourquoi pas str ....)

[Lion]

Plusieurs réponses aux question de Ahbadiane :

1) Non, car cela ne sert à rien. Encore une fois, le TeaScript est du UnityScript avec quelques éléments en plus ou en mois. Les quelques éléments en plus sont pour l'instant les mot clés and, or, not, is, isnot, isoneof, isnotoneof, constructor, prop, property, func, struct, foreach, string et bool. J'utilise sous Sublime Text 2 une version modifiée du fichier comportant les règles de coloration syntaxique du JavaScript. Je prévois de fournir un équivalent pour Notepad++ ainsi que pour MonoDevelop. A voir si j'ai des demandes pour d'autres éditeurs.

2) Mac et Windows, et licence Pro et Free

3) Je n'ai rien fais de particulier dans ce sens là. Je n'en ai en tout cas pas besoin sous Sublime Text. Encore une fois, seul quelques mot clés sont introduits. Si certains éditeurs possèdent un fichier répertoriant les mots clés à autocompléter, je serais heureux d'en créer un pour le TeaScript (a priori une modification de celui pour le JavaScript suffira).

4) Unity ne compilera que le UnityScript. L'extension se chargera de la conversion TeaScript -> UnityScript. Donc il faut effectivement ajouter ce temps à celui de la compilation mais la conversion est quasi instantanée. Même avec une conversion très lourde (UnityScript vers C#) sur laquelle j'ai déjà travaillé, la vitesse de conversion est de l'ordre plusieurs milliers de lignes par secondes. En ne convertissant que les fichiers qui en ont besoin (nouveaux, modifiés..) c'est tout à fait utilisable en pratique.

a) C'est effectivement un risque. L'extension peut buger tant dans la conversion que dans le maintient à jour des versions UnityScript.
A moi de bosser correctement et de fournir une extension stable .
Concernant les bugs de conversion, c'est aussi à moi de m'arranger pour prévoir tous les cas de figure possible, et d'autre part je rappelle que vous pouvez coder en UnityScript pur dans vos script TeaScript (même en cas de bug dans une feature, la syntaxe du UnityScript fonctionnera toujours).

b) Qu'est-ce que tu entend par esprit du code ? Les sucres syntaxiques permettent autant de raccourcir certaines syntaxes que de protéger contre des "bugs de syntaxe" tels que oublier ce putain de S majuscule au début de String (alors que tous les autre type natifs n'en ont pas). Rendre optionnel les parenthèses, les points virgule et peut être les accolades est dans le même esprit.
Mais après tout pourquoi pas permettre d'utiliser "str" au lieu de "string" ou "String". Je permet déjà d'écrire "func" ou "function", "prop" ou "property"...

Pour aller plus loin, pourquoi ne pas permettre à chacun de définir des alias pour les mot clés de base du langage ?!
C'est d’ailleurs une idée à laquelle je réfléchirais plus avant, un jour où il sera moins tard.
Je te remercie Ahbadiane de m'y avoir fais penser, ce topic porte déjà ses fruits

[cayou66]

Voilà quelque chose d'intéressant qu'on a là.
Etant plutôt du côté des puristes je suis toujours retissant lorsque l'on vient rajouter une couche juste pour rendre le code plus "facile". Déjà que le C# et Unity nous rendre les choses trèèèèèès simple je ne vois pas trop l'intérêt.
Donc je suis ça par curiosité, afin de voir si la demande sur ce genre d'outil est forte.

Je pense que ce milieu là est assez peu représenté, c'est soit des total débutants et donc un tool graphique serait une bonne alternative, soit ce sont des codeurs d'origine et un tool comme ça peut paraître non essentiel.

[Max]

@Max Les préprocesseurs comme CoffeeScript gagnent en popularité chaque jour parce que les gens voient bien combien leur utilisation leur rend la vie plus facile. C'est particulièrement vrais pour le JavaScript web qui a une syntaxe relativement obtue dans bien des situations.

Je rejoint parfaitement Cayou (c'est probablement le fait d'être codeur depuis 30 ans) mais Unity simplifie déjà grandement les choses.
Rajouter une couche qui soit disant simplifie les choses, dans une syntaxe qui reste marginale (et qui à mon humble avis le restera) ne peut apporter que des soucis (bug supplémentaire, diffusion restreinte, pas de compatibilité, voir mauvaises habitudes, etc..).
Bref, si je salut l'effort intellectuel et j'adhère au coté 'curiosité' de la chose, je reste toujours aussi perplexe quand à sa réelle utilité.
On a souvent débattu sur ce forum de l'utilité de vouloir simplifier à l’extrême la partie codage. Si j'abonde dans le sens où un outil graphique de qualité pourrait indiscutablement trouver sa place, vouloir créer une surcouche linguistique me laisse très perplexe, et en tant que formateur, je serais le premier à le déconseiller. Celui qui veut apprendre à scripter, des langages comme le JS ou le C# sont parfaitement accessible et déjà fort simple et des plus accessible pour celui qui veut se donner la peine d'une minimum d'effort.

Maintenant, comme dirait l'autre, "mon humble opinion, cela reste"

bon courage pour la suite.