Introduction

A l’heure de la mondialisation et de l’internet, il n’est pas rare de voir des utilisateurs venir du monde entier pour visiter un site web. Mais un problème se pose alors : celui de la langue. Bien entendu, si vous voulez toucher un maximum de monde, vous réaliserez votre application en Anglais. Cela reste néanmoins loin d’être idéal ! Ces dernières années donc, les développeurs de framework et plug-ins multiplient les solutions de « localisation », c’est à dire les systèmes « automatisant » la gestion des langues. Nous allons donc voir comment utiliser les outils intégrés à Silverlight, afin de réaliser de la localisation dans votre application !

 

Les Ressources

"Localisation" ne veut pas dire traduction automatique. Cette tâche vous revient donc (et entre nous, ce n’est pas plus mal pour l’utilisateur final). Déterminez en premier lieu, quelle langue vous souhaitez proposer à vos utilisateurs. Eventuellement, vous pourrez définir des cultures (Anglais britannique, Anglais Américain sont des cultures, tandis que l’Anglais est la langue associée). Nous n’utiliserons ici que deux langues (Français et Anglais), mais la méthode est la même pour ajouter d’autres idiomes et cultures.

Silverlight gère la localisation à l’aide de fichiers de ressources, qui contiennent des chaines de caractères associées à une clé. On peut imaginer par exemple un champ « labelAccueil », qui contiendrait la chaine « Accueil ».  Afin de réaliser les changements de langue, vous aurez à réaliser ainsi un fichier de ressources par langue.

Classe de localisation

Afin de gérer les ressources précédemment créées, nous allons utiliser une classe qui permettra de déterminer quel est le fichier de langue associé à la culture de l’utilisateur. Nous appellerons ici notre classe LocalizatedStrings. Elle disposera d’un objet (nommé ici resource), que nous instancierons lors de la première utilisation de la classe, afin qu’il corresponde au bon fichier de ressources. Cet objet doit être statique, afin de garantir son accès depuis partout. Déclarez également un ResourceManager, lui aussi statique,  qui permettra d’accéder aux chaines contenues dans nos ressources. Nous déclarons également une méthode, qui instanciera notre objet resource, et le resourceManager, suivant la culture de l’utilisateur, accessible via CultureInfo.

private static object resource;

private static ResourceManager resourceManager;

public static object Resource1

{

get

{

if (resource == null)

Determiner_culture();

return resource;

}

}

public static void Determiner_culture()

{

if (CultureInfo.CurrentCulture.TwoLetterISOLanguageName == "fr")

{

resource = new Namespace.localization.StringLibrary();

resourceManager =

new System.Resources.ResourceManager("Namespace.localization.StringLibrary", Assembly.GetExecutingAssembly());

}

else

{

resource = new Namespace.localization.StringLibraryEN();

resourceManager =

new System.Resources.ResourceManager("Namespace.localization.StringLibraryEN", Assembly.GetExecutingAssembly());

}

}

Ici, Namespace correspond au nom de votre assembly, et localization au nom du dossier contenant les fichiers de ressources.

Utiliser les chaines localisées

Maintenant que nos chaines sont bien initialisées suivant la culture de l’utilisateur, nous allons les exploiter coté code behind (avec le ResourceManager) et coté XAML (avec du binding).

Chaines localisées et code behind (C#)

Utiliser les chaines localisées est très simple dans le code behind. Il suffit d’appeler la méthode GetString du ResourceManager, en passant en paramètre la clé correspondante dans les ressources. Imaginons que vous ayez une chaine de clé « LabelAccueil », le code sera :

resourceManager.GetString("LabelAccueil");

Vous l’aurez compris, il vous faudra avoir les mêmes noms de clé dans vos fichiers de ressources, mais des valeurs différentes. En français, la chaine pourra avoir pour valeur « Accueil », tandis qu’en Anglais, elle aura pour valeur « Home ».

Chaines localisées et XAML

Utiliser vos chaines localisées n’est pas plus compliqué en XAML qu’en C#. il suffit de faire un Binding sur l’attribut Text ou Content de votre contrôle comme ceci :

{Binding Path=Resource1.LabelAccueil, Source={StaticResource LocalizedStrings }}

Resource1 correspond à la méthode get de notre objet resource, dans notre classe LocalizatedStrings. Celle-ci est  indiquée en tant que ressource. LabelAccueil correspond à la clé dans vos ressources, comme en code behind. Vous avez donc accès à vos chaines localisées maintenant !

Astuce : tester son système de localisation

Si vous utilisez Windows Vista ou Seven, il y a un moyen très simple de tester votre localisation. Allez dans panneau de configuration, « Horloge,  Langue et Région », « Région et langue », et changez le format sur la culture à tester.

Conclusion

Comme vous le voyez, la localisation en Silverlight se fait aux moyens d’outils relativement puissants, et cela est bien plus aisé qu’avec d’autres langages. Attention toutefois à utiliser les mêmes clés dans vos fichiers de ressources. 

C#, Silverlight, Visual Studio 2010

Introduction

Il est parfois nécessaire de stocker des informations côté client, telles que des identifiants de connexion, un panier d’achat… Bien que nous puissions tout à fait utiliser les classiques cookies, Silverlight propose un dispositif bien plus organisé et simple pour le stockage : l’isolated storage. Sa taille maximale est de 1Mo par application, et peut augmenter en mode out of browser avec des droits élevés. Le but de cet article va donc être de vous en apprendre les bases.

Note : ne croyez surtout pas que l’isolated storage est quelque chose de sécurisé. Il est en effet possible au client d’accéder très facilement à ses données, même sans votre application. Evitez donc le stockage de mot de passe, d’informations confidentielles etc. Pour plus d’informations sur le sujet, je vous suggère l’excellente conférence de Shawn Wildermuth au mix 2010

Lien MIX 2010

Ecrire dans un fichier

L’isolated Storage n’est ni plus ni moins qu’un dossier où vous pouvez stocker des fichiers. Il va donc falloir en premier lieu, créer un fichier avant d’y écrire. Vous aurez besoin de l’using suivant :

using System.IO.IsolatedStorage;

Nous commençons par définir un try catch, car on agit directement sur le système de fichier de l’utilisateur. Il est donc préférable d’éviter le plantage de l’application par cette méthode.

Nous définissons ensuite une variable que représentera notre isolated storage représentera.

try

{

using (var store = IsolatedStorageFile.GetUserStoreForApplication())

{

;

}

}

catch

{

;

}

Nous avons donc accès à un espace de stockage côté client. Nous allons à présent créer un dossier, puis un fichier.

try

{

using (var store = IsolatedStorageFile.GetUserStoreForApplication())

{

string directory = "Key";

store.CreateDirectory(directory);

 

string filePath = System.IO.Path.Combine(directory, "Key.txt"); //On concatène le nom du fichier et du dossier

 

if (!store.FileExists(filePath)) //On vérifie que le fichier n'existe pas déja

{

IsolatedStorageFileStream File =

store.CreateFile(System.IO.Path.Combine(directory, "Key.txt")); //On créé le fichier

File.Close(); //On ferme le stream

}

}

}

catch

{

;

}

Maintenant que le fichier est créé, nous allons écrire dedans. Nous utiliserons un StreamWriter, en précisant le chemin du fichier, le mode de fichier (Open), et l’accès sur écriture. Encore une fois, nous allons utiliser un try catch. Mais cette fois-ci nous aurons le détail de l’erreur.

try

{

using (StreamWriter sw =

new StreamWriter(store.OpenFile(filePath,

FileMode.Open, FileAccess.Write)))

{

sw.WriteLine(“Je suis une chaine de caractère”);

}

}

catch (IsolatedStorageException ex)

{

MessageBox.Show(ex.Message);

}

Nous avons donc stocké dans un fichier, une chaine de caractères. Nous allons à présent voir comment y accéder.

Lire un fichier

Une fois que nous avons écrit dans le fichier, il nous faut y lire le contenu. Pour cela, nous allons commencer comme précédemment, c’est-à-dire utiliser un try/catch, ainsi qu’une variable qui représentera notre Isolated Storage.

try

{

using (var store = IsolatedStorageFile.GetUserStoreForApplication())

{

 

}

}

catch

{

;

}

Nous définissons ensuite notre chemin (qui pointera donc vers le fichier que nous avons créé tout à l’heure), et nous vérifions qu’il existe ! 

string directory = System.IO.Path.Combine("Key", "Key.txt");

if (store.FileExists(filePath))

{

{

;

}

}

Il ne reste plus qu’à utiliser un StreamReader pour lire le contenu de notre fichier !

using (StreamReader reader =

new StreamReader(store.OpenFile(filePath,

FileMode.Open, FileAccess.Read)))

{

string content = reader.ReadToEnd();

}

Et voilà, nous avons récupéré le contenu du fichier de l’Isolated Storage ! Simple non ? Vous pouvez donc dès à présent utiliser cette méthode qui est de loin plus simple que la gestion des cookies (en Silverlight en tout cas).

C#, Silverlight .net, silverlight, isolated storage

Le Out of Browser

De plus en plus, des applications web sont utilisées en tant qu’application de bureau. La montée en puissance du cloud-computing, et l’apparition du mode Out-Of-Browser montrent clairement que c’est la tendance.

Le Out Of Browser (OOB) consiste simplement à développer une application web (donc, dans le navigateur), et  “l’installer” sur le bureau de l’utilisateur. En somme, plus besoin d’ouvrir son navigateur, il suffit de cliquer sur une icône du bureau.

Nous allons ici nous intéresser à une nouveauté de Silverlight 4 : les fenêtres « chrome ». Nous allons donc redesigner ces petits boutons qui depuis des années, permettent de minimiser, maximiser, ou encore fermer une fenêtre.

 

Rendre notre application Out Of Browser

Bien entendu, puisque l’on parle de fenêtre d’application, il va tout d’abord nous falloir mettre notre application sur le bureau. Pour cela, rien de plus simple. Il vous suffit de vous rendre dans les propriétés d’un projet Silverlight, et de cliquer sur la case « Enable Running application out of the browser ». Mais cela ne suffit pas pour notre cas. En effet, Silverlight 4 introduit le concept de « trusted applications », des applications OOB s’exécutant avec des droits élevés (et pouvant potentiellement faire énormément de choses). C’est cela qui nous permettra le changement d’aspect de notre fenêtre. Pour activer ce mode, il vous faudra cliquer dans les propriétés du projet, sur le bouton des options OOB. Une fenêtre va apparaître. Tout en bas de celle-ci, vous devrez cocher la case qui permet d’obtenir ces fameux droits élevés. En dessous, une liste s’active, et nous intéresse. En effet, elle permet de changer le style de fenêtre de notre application.

Nous allons ici définir un style « Borderless Round Corners ». Cela enlèvera la barre de contrôle habituelle de Windows, et fera des coins de fenêtre arrondis. Très esthétique !

 

Déplacer notre fenêtre

Nous avons maintenant notre fenêtre, mais pas de quoi la contrôler ! Qu’à cela ne tienne ! Nous allons tout d’abord apprendre à la déplacer. Pour cela, vous pouvez créer un rectangle par exemple, en haut de votre application. Un superbe rectangle de couleur Aqua par exemple, fera parfaitement l’affaire.

Une fois cela fait, définissez un événement MouseLeftButtonDown dessus.

Lors de l’appel à cette méthode, nous allons devoir vérifier deux choses : que notre application est bien out of browser, et que celle-ci dispose de droits administrateurs. Nous allons pour cela utiliser des attributs de l’objet MainWindow, qui représente notre fenêtre. Si les deux conditions sont bien remplies, nous pouvons commencer le déplacement, par l’appel de la méthode DragMove de MainWindow.

private void rectangle1_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)

{

if (App.Current.IsRunningOutOfBrowser

&& App.Current.HasElevatedPermissions)

App.Current.MainWindow.DragMove();

}

Vous pouvez lancer votre application, et vous verrez que le déplacement est opérationnel.

 

Redimensionner notre fenêtre

Il est possible que vous souhaitiez laisser la possibilité à votre utilisateur de redimensionner la fenêtre. Pour cela, rien de plus simple. Commencez par définir 4 coins à votre application, avec des rectangles par exemple.

Ensuite, il ne reste plus qu’à définir pour chacun un événement en cas de clic. Dans la fonction appelée, il nous faudra refaire bien entendu, nos deux vérifications, et appeler, en cas de succès, la méthode DragResize de MainWindow. Celle-ci prend en argument un coin de l’application pour le redimensionnement. Mettez celui qui correspond au sender d’événement.

private void rectangle2_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)

{

if (App.Current.IsRunningOutOfBrowser

&& App.Current.HasElevatedPermissions)

App.Current.MainWindow.DragResize(WindowResizeEdge.TopLeft);

}

Facile n’est-ce pas ?

 

Définir nos boutons

Dernière étape : afficher des boutons pour permettre de minimiser/maximiser notre fenêtre, et la fermer. Commencez par les définir, et sur chacun, invoquez  une méthode sur MouseLeftButtonDown.

Pour chacune, n’oubliez pas de faire nos deux vérifications habituelles.  Une autre méthode est de n’afficher vos boutons que si les deux conditions sont vérifiées. Cela permet de faire une seule vérification pour le tout.

Pour minimiser ou maximiser notre fenêtre, il suffit de changer le WindowState de notre MainWindow, qui est une énumération. Vous pouvez le définir sur maximisé, minimisé, ou normal (la fenêtre reprendra alors sa taille d’origine).

De là, il devient très simple de définir nos méthodes :

private void OOB_WindowMaximize(object sender, MouseButtonEventArgs e)

{

App.Current.MainWindow.WindowState = WindowState.Maximized;

}

private void OOB_WindowMinimize(object sender, MouseButtonEventArgs e)

{

App.Current.MainWindow.WindowState = WindowState.Minimized;

}

Et pour fermer notre fenêtre ? Encore une fois, c’est très simple. Il suffit d’un simple appel à la méthode Close de notre MainWindow.

private void OOB_WindowClose(object sender, MouseButtonEventArgs e)

{

App.Current.MainWindow.Close();

}

 

Conclusion

Comme vous le voyez, redéfinir les événements de gestion d’une fenêtre est simple, et permet d’avoir quelque chose de visuellement plus personnalisé, si ce n’est plus joli. Si vous voulez aller plus loin, pourquoi ne pas changer le WindowState à Normal lorsque vous déplacez la fenêtre (pour reproduire le comportement d’une fenêtre normale sur Window). Vous pourriez également permettre de revenir en état normal après un clic sur le bouton maximiser, lorsque notre fenêtre l’est déjà. Et pour ceux qui voudrait avoir un petit aperçu de ce que l’on peut obtenir :

C#, Silverlight

Introduction

On constate ces dernières années, un regain d’importance pour le game design et l’originalité d’un jeu, au détriment de la qualité graphique. Le succès des jeux sur wii, ces casual games, en est la preuve. Mais ces jeux incluent bien souvent un élément important : le moteur physique. De nombreux jeux sont même uniquement basés sur ce genre d’interactions.

Avec l’utilisation croissante de technologies telles que XNA ou Silverlight, il est important de comprendre l’intérêt de ces moteurs physiques, et comment les utiliser. Une série d'articles va donc être consacrée à une présentation de l’un de ces moteurs Farseer physics, qui fonctionne avec ces deux technologies.

I)Introduction aux moteurs physiques et Farseer

1)Qu’est-ce qu’un moteur physique ?

Commençons par la base : Qu’est-ce qu’un moteur physique finalement ? Il s’agit d’un ensemble de fonctionnalités, classes et objets, qui permettent l’instauration de la gravité (et de ce que cela engendre), dans un espace. Imaginons que dans votre jeu, vous avez un personnage qui peut sauter. Concrètement, le moteur physique s’occupera tout seul d’appliquer une force à votre personnage, qui le fera d’abord monter, puis descendre. Finalement, les moteurs physiques aident grandement à reproduire les lois physiques de notre monde.

2) Qu’est-ce que Farseer Physics ?

Farseer Physics est un moteur physique open-source. Il est disponible pour Silverlight, XNA, WPF, mais dispose aussi de classes indépendantes de toute plateforme. Vous pouvez télécharger le contenu qui vous intéresse sur http://farseerphysics.codeplex.com. De nombreux exemples sont également disponibles.

3)Quelques exemples

 

 

II)Farseer Physics avec XNA

1)Intégrer Farseer Physics à votre projet

La première étape dans l’utilisation du moteur Farseer, est son intégration au sein du projet.  Dans un premier temps, téléchargez-le sur le site de Farseer Physics sur Codeplex. Ajoutez ensuite le projet Farseer Physics pour XNA à votre solution. Ajoutez ensuite les assemblies suivants pour utilisez les classes du moteur :

using FarseerGames.FarseerPhysics;

using FarseerGames.FarseerPhysics.Collisions;

using FarseerGames.FarseerPhysics.Dynamics;

using FarseerGames.FarseerPhysics.Factories;

Vous voilà prét à découvrir les lois de la physique !

2)Ajouter la Gravité

Une fois le projet prêt, il vous faudra tout d’abord ajouter l’élément essentiel à votre projet : le PhysicsSimulator, qui aura pour rôle de gérer toute la physique de votre environnement. L’objet dispose de deux constructeurs. L’un ne prend aucun paramètre, l’autre accepte un vecteur de gravité.

PhysicsSimulator simulator = new PhysicsSimulator(new Vector2(0, 750));

Dans cet exemple, on créé un simulateur physique avec une force de gravité de 0 en X, et de 750 en Y. Cela correspond environ à une gravité normale. Maintenant que la gravité est integrée au système, il va falloir insérer des éléments qui y sont soumis.

3)Ajouter des corps

Tout objet a intégré à l’environnement physique est appelé un corps. Ceux-ci sont composés de Body et de Geom Le Body correspond  à la position et les caractéristiques physiques du corps. Le Geom, lui, détermine la forme de celui-ci, et permet de gérer les collisions. Pour créer un Body, il vous faudra utiliser un objet statique nommé BodyFactory. La méthode de création prend pour argument  la largeur du corps, la hauteur, la masse, et éventuellement le PhysicsSimulator.

body = BodyFactory.Instance.CreateRectangleBody(width, height, 1);

Nous allons utiliser la même méthode ensuite pour la géométrie. La méthode de construction prend en paramètre un corps auquel  la géométrie est attachée, ainsi qu’une largeur et une hauteur. 7 autres constructeurs sont disponibles pour gérer les différentes situations.

geom = GeomFactory.Instance.CreateRectangleGeom(body, width, height);

Ensuite, il vous faudra ajouter tout simplement ces objets au simulateur physique.

simulator.Add(body);

simulator.Add(geom);

Et voilà, vos objets physiques sont integrés au simulateur. Mais comment visualiser ces objets ? Pourquoi ne pas afficher une image qui changera de position avec le corps ?

Texture2D texture;

Body body;

Geom geom;

protected override void LoadContent()

{

PhysicsSimulator simulator = new PhysicsSimulator(new Vector2(0, 750));

texture = Content.Load<Texture2D>(@"gfx/img");

body = BodyFactory.Instance.CreateRectangleBody(100, 100, 1);

geom = GeomFactory.Instance.CreateRectangleGeom(body, width, height);

simulator.Add(body);

simulator.Add(geom);

}

protected override void Update(GameTime gameTime)

{

simulator.Update(gameTime.ElapsedGameTime.Milliseconds * .001f);

base.Update(gameTime);

}

protected override void Draw(GameTime gameTime)

{

GraphicsDevice.Clear(Color.CornflowerBlue);

spriteBatch.Begin();

spriteBatch.Draw(texture, new Rectangle(body.Position.X, body.Position.Y, 100, 100)

,Color.White);

spriteBatch.End();

base.Draw(gameTime);

}

Et voilà, ce code vous permettra de suivre “en direct”, la chute d’un objet soumis aux lois de la gravité. Vous pouvez vous amuser à changer les valeurs des différents éléments.

Et que faire si vous voulez rendre votre objet statique, indispensable pour faire un plateformer. Il vous suffit de mettre à true l’attribut IsStatic.

4)Gestion des collisions

Une fois vos corps créés, vous voudrez peut-être les faire interagir entre eux. La gestion des collisions avec Farseer Physics se fait très simplement. Il vous suffira d’ajouter un élément de type CollisionEventHandler sur l’événement OnCollision de votre Geom.

geom.OnCollision += new CollisionEventHandler(CollisionOccursPlay1);

La méthode recevra trois arguments : les deux corps qui sont entrés en collision, et un objet de type ContactList, qui contient, comme son nom l’indique, les points de contact. A vous ensuite de gérer les collisions comme vous le souhaitez !

Vous êtes à présent parés pour gérer la gravité dans votre jeu !

 

III)Farseer Physics avec Silverlight

 

1)Intégrer Farseer Physics à votre projet Silverlight

L’intégration de Farseer en Silverlight se fait de la même manière qu’en XNA si vous souhaitez utiliser le moteur physique dans votre code behind. Cependant, il est possible, comme nous allons le voir, d’utiliser Farseer sans une seule ligne de code, en usant de behaviors dans Expression Blend.

2)Utiliser Farseer avec les behaviors

Si vous êtes un utilisateur de Expression Blend, vous savez certainement ce qu’est un behavior. C’est une extension à des contrôles existants, pour l’ajout d’effets par exemple, et cela, sans ligne de code. Il vous faudra, pour utiliser ceux de Farseer, intégrer la bonne dll au projet.

Commencez par convertir votre LayoutRoot en Canvas. Cela est une pratique courante dans la programmation de jeux, et vous sera très utile plus tard. Dessinez ensuite une ellipse.

Une fois cela fait, vous avez les bases du prochain jeu Silverlight de l’année !

Faites glisser depuis votre liste de behaviors, le PhysicsControllerBehavior, sur votre Canvas. Vous pourrez y modifier divers paramètres dans la fenêtre de propriété, comme la gravité. Je vous conseille de cocher la case « MousePickEnabled », pour pouvoir diriger votre balle comme vous le souhaitez. Ajoutez ensuite le behavior « PhysicsObjectBehavior », le plus utile de tous. C’est en effet lui qui va déterminer si un objet réagit à la physique ou non. Encore une fois, il est possible de gérer divers propriétés, comme la masse, le moment d’inertie etc. Compilez, exécutez, et admirez le travail. Votre balle tombe, et est déplaçable avec la souris.

Vous pouvez vous amuser à rajouter quelques éléments, et modifier leurs propriétés physiques.

Mais comment faire si l’on souhaite gérer des événements physiques ? C’est possible soit en code-behind, soit directement dans Blend, et oui ! Nous allons par exemple, appliquer une force à notre balle, à chaque fois que la touche espace est relâchée. Glissez donc le behavior « PhysicsApplyForceBehavior » dessus. Dans la fenêtre des propriétés, il vous sera proposé de rajouter un EventTrigger pour déclencher l’application de la force. Cliquez sur « New ». Vous verrez apparaître une liste d’événements.

Nous allons donc rajouter un trigger de type « KeyTrigger ». Il vous faudra ensuite mettre le Parent de l’événement, typiquement, il s’agit de votre LayoutRoot. La petite icône de cible vous permettra de cibler directement votre Canvas. Réglez ensuite le type d’événement associé (KeyUp ou keyDown ici), la force à appliquer, et la touche qui déclenchera l’événement, avec éventuellement une touche supplémentaire (comme Alt, Shift etc.).

Vous pouvez tester maintenant, et votre balle réagit aux événements ! Attention cependant, vérifiez bien que votre Canvas a le focus, sinon les entrées clavier ne seront pas prises en compte. Et voilà le résultat :

Il est possible de gérer de nombreuses choses en mixant les behaviors et du code behind. Vous pourrez trouver beaucoup d’informations et de tutoriaux sur la page Codeplex de Farseer, y compris une vidéo sur le mélange entre les behaviors et du traitement en C#.

3)Utiliser Farseer dans votre code behind

Utiliser Farseer se fait presque de la même manière qu’en XNA. Votre code sera donc facilement portable de l’un à l’autre. Vous pouvez initialiser le moteur physique comme en XNA. Le seul changement concerne la gestion du temps pour mettre à jour le moteur. En effet, en XNA, la boucle de jeu, et donc le temps, sont gérés automatiquement, ce qui n’est pas le cas de base en Silverlight.

Le plus simple est certainement de faire un storyboard, et de lui mettre la durée que vous souhaitez. Mais il est aussi possible de réaliser une boucle automatiquement grâce à l’objet CompositiionTarget, qui vous permettra de réaliser des boucles de jeu, de sorte que votre application ait bien 60 FPS (frames par seconde). Vous pouvez associer une méthode à son événement Rendering, pour ainsi avoir une boucle de jeu prête !

Conclusion

Vous savez à présent comment gérer la physique dans vos jeux, que ce soit avec XNA et Silverlight. Le moteur Farseer n’est certainement pas le plus complet des moteurs physiques, mais il a l’avantage d’être compatible avec .NET, et d’être simple d’utilisation. Un monde plein de gravité et de moments d’inertie vous attend désormais !

C#, XNA, Silverlight