Procédure : Créer un jeu localisé

XNA Game Studio 4.0

Un jeu localisé est un jeu dans lequel l'interface utilisateur affiche des ensembles de texte alternatifs adaptés à la langue et à la culture du joueur.

Ce didacticiel présente la méthode qui permet à un jeu d'afficher un texte d'interface utilisateur différent en fonction du paramètre de culture actif de la plateforme stocké dans CultureInfo. Il explique également comment étendre le contenu à venir de façon à ce que le nombre minimal de caractères de police requis supplémentaires soient inclus dans l'exécutable du jeu pour le texte localisé.

Pour plus d'informations sur les problèmes liés à la localisation, voir Procédure : Générer une application localisée pour Windows Phone.

Exemple complet

Le code utilisé dans cette rubrique illustre la technique de création d'un jeu pouvant être localisé. Vous pouvez télécharger un exemple de code complet pour cette rubrique, notamment le code source complet et tous les fichiers de prise en charge requis par l'exemple.

Création des fichiers de ressources

Un jeu localisé doit gérer ses ressources dans des fichiers de ressources (.resx) dans le projet de code du jeu. Le jeu doit gérer au moins un fichier de ressources pour chaque langue/culture qu'il doit prendre en charge. Chaque fichier de ressources définit des identificateurs pour chaque chaîne d'interface utilisateur localisable, avec une version localisée de cette chaîne pour la langue/culture prévue. De cette façon, la localisation peut être gérée indépendamment du codage.

Pour créer des fichiers de ressources

  1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le nœud du projet de code, cliquez sur Ajouter, puis cliquez sur Nouvel élément.

  2. Dans la boîte de dialogue Ajouter un nouvel élément, sélectionnez le fichier de ressources et renommez-le de façon appropriée, par exemple, Strings.resx.

    Ce fichier contiendra les ressources pour la langue par défaut de l'application.

  3. Identifiez les chaînes de votre application et ajoutez-les au fichier de ressources.

    Chaque chaîne possède un nom, une valeur et un commentaire facultatif. Le nom doit être unique ; vous devez donc faire en sorte qu'il soit aussi descriptif que possible. La valeur correspond à la chaîne qui doit s'afficher dans l'application sur l'écran de l'utilisateur. L'ajout d'un commentaire est utile, surtout dans les fichiers de ressources de grande taille pour rappeler la fonction de la chaîne et, par la suite, pour aider le traducteur à comprendre le contexte approprié.

    Figure 1.  Exemple de chaîne en langue anglaise pour le fichier de ressources Strings.resx

    Ff966426.CP_HowTo_Localize_Strings(fr-FR,XNAGameStudio.40).png
  4. Ajoutez un nouveau fichier de ressources à votre projet pour chaque langue/culture que l'application va prendre en charge.

    Ff966426.note(fr-FR,XNAGameStudio.40).gifRemarque

    Chaque fichier de ressources doit respecter la convention d'affectation de noms :

    nom du fichier de ressources pour la langue par défaut.nom de la culture

    MyStrings.fr.resx est un exemple de ce format ; le nom de la culture (fr dans cet exemple) est dérivé de la classe CultureInfo.

    Comme illustré dans la figure suivante, les chaînes définies pour le fichier de ressources doivent avoir le même ensemble de noms d'identification que celui qui a été défini dans le fichier de ressources par défaut.

    Figure 2.   Exemple de chaîne en langue française pour le fichier de ressources Strings.fr.resx

    Ff966426.CP_HowTo_Localize_Strings_fr(fr-FR,XNAGameStudio.40).png

    Figure 3.  Exemple de chaîne en langue française pour le fichier de ressources Strings.fr.resx

    Ff966426.CP_HowTo_Localize_Strings_ja(fr-FR,XNAGameStudio.40).png
Ff966426.note(fr-FR,XNAGameStudio.40).gifInformations propres à Windows Phone

Pour déployer les fichiers de ressources, les développeurs Windows Phone doivent ajouter l'élément <SupportedCultures> au fichier de projet Visual Studio (.csproj) pour le jeu Windows Phone. Pour plus d'informations sur la façon d'utiliser <SupportedCultures>, consultez Procédure : Générer une application localisée pour Windows Phone.

  1. Fermez le fichier de projet Visual Studio (.csproj) pour le projet de jeu Windows Phone, puis ouvrez-le dans un éditeur de texte.
  2. Recherchez l'élément <PropertyGroup> qui décrit la configuration de build et la plateforme Windows Phone.

  3. Ajoutez un nouvel élément nommé <SupportedCultures> à l'élément <PropertyGroup> pour la configuration de build désirée. Définissez comme valeur de <SupportedCultures> une liste délimitée par des points-virgules de toutes les cultures prises en charge pour le jeu.

    <SupportedCultures>ja-jp</SupportedCultures>
    

Extension du contenu à venir

Pour gérer un jeu localisé, vous devez créer une nouveau projet Bibliothèque d'extension de contenu à venir afin de traiter les fichiers de ressources et les polices.

La nouvelle extension de bibliothèque de contenu doit étendre la classe FontDescription pour prendre en charge une liste des fichiers de ressources qui seront inclus ultérieurement dans le fichier .spritefont.

Vous devrez également créer un nouveau processeur de contenu qui étend FontDescriptionProcessor pour traiter la liste des fichiers de ressources, et inclure les caractères requis dans l'exécutable du jeu généré.

Pour créer un projet Bibliothèque d'extension de contenu à venir

  1. Dans le menu Fichier, cliquez sur Nouveau projet.

  2. Sélectionnez le type de projet Bibliothèque d'extension de contenu à venir (4.0).

  3. Dans la zone Nom, tapez le nom du nouveau projet de bibliothèque.

    Vous pouvez nommer le projet LocalizationPipeline, par exemple.

  4. Cliquez sur OK pour créer et charger le nouveau projet.

Pour étendre la classe FontDescriptor

Vous ajouterez un nouveau fichier pour contenir la nouvelle classe.

  1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le nouveau projet Bibliothèque d'extension de contenu à venir créé, cliquez sur Ajouter, cliquez sur Nouvel élément, puis sélectionnez Classe.

    Assignez un nom tel que LocalizedFontDescription.cs au nouveau fichier.

  2. Dans le nouveau fichier de classe, déclarez une nouvelle classe (par exemple, LocalizedFontDescription) qui dérive de FontDescription.

    class LocalizedFontDescription : FontDescription
    
  3. Au sein de la classe, définissez une nouvelle propriété ResourceFiles.

    Cette action entraîne la reconnaissance d'un élément ResourceFiles dans le fichier XML .spritefont, lequel contiendra la liste des fichiers de ressources.

    [ContentSerializer(Optional = true, CollectionItemName = "Resx")]
    public List<string> ResourceFiles
    {
        get { return resourceFiles; }
    }
    
    List<string> resourceFiles = new List<string>();
    

Pour étendre la classe FontDescriptionProcessor

Un nouveau fichier devant contenir la nouvelle classe FontDescriptionProcessor sera ajouté.

  1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet d'extension du contenu à venir, cliquez sur Ajouter, cliquez sur Nouvel élément, puis sélectionnez Classe.

    Assignez un nom tel que LocalizedFontProcessor.cs au nouveau fichier.

  2. Dans le nouveau fichier de classe, déclarez une nouvelle classe (par exemple, LocalizedFontProcessor) qui dérive de ContentProcessor et qui spécifie la nouvelle classe LocalizedFontDescription en tant qu'entrée.

    [ContentProcessor]
    class LocalizedFontProcessor : ContentProcessor<LocalizedFontDescription,
                                                    SpriteFontContent>
    

    Au sein de la classe, remplacez Process par la nouvelle classe LocalizedFontDescription en tant qu'entrée.

    public override SpriteFontContent Process(LocalizedFontDescription input,
                                              ContentProcessorContext context)
    
  3. Dans la nouvelle méthode Process, progressez pas à pas dans la propriété ResourceFiles de l'objet LocalizedFontDescription pour charger chaque fichier de ressources déclaré.

    foreach (string resourceFile in input.ResourceFiles)
    {
        string absolutePath = Path.GetFullPath(resourceFile);
    
        // Make sure the .resx file really does exist.
        if (!File.Exists(absolutePath))
        {
            throw new InvalidContentException("Can't find " + absolutePath);
        }
    
        // Load the .resx data.
        XmlDocument xmlDocument = new XmlDocument();
    
        xmlDocument.Load(absolutePath);
    
  4. Pour chaque fichier de ressources, analysez chaque chaîne et ajoutez les caractères trouvés à l'objet LocalizedFontDescription.

    // Scan each string from the .resx file.
    foreach (XmlNode xmlNode in xmlDocument.SelectNodes("root/data/value"))
    {
        string resourceString = xmlNode.InnerText;
    
        // Scan each character of the string.
        foreach (char usedCharacter in resourceString)
        {
            input.Characters.Add(usedCharacter);
        }
    }
    
  5. À l'aide de AddDependency, signalez que la police doit être régénérée si le fichier de ressources est modifié.

    context.AddDependency(absolutePath);
    
  6. Utilisez la classe FontDescription pour générer la police.
  7.     return context.Convert<FontDescription,
                               SpriteFontContent>(input, "FontDescriptionProcessor");
    }
    

Association des données et des processeurs de localisation avec des polices

Maintenant que les données du projet sont réparties en fichiers de ressources et qu'un processeur de contenu personnalisé a été créé pour les utiliser, il est nécessaire de relier les parties entre elles pour leur permettre de fonctionner. Pour ce faire, vous devez fournir des informations étendues dans un fichier .spritefont, puis lier ce fichier au processeur de contenu personnalisé.

Pour étendre le fichier .spritefont

Créez un nouveau fichier .spritefont.

  1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le nœud du projet de contenu, cliquez sur Ajouter, puis cliquez sur Nouvel élément.

  2. Dans la boîte de dialogue Ajouter un nouvel élément, sélectionnez « Police sprite », puis dans la zone Nom, entrez un nom (par exemple Font.spritefont) pour le nouveau fichier.

  3. Cliquez sur Ajouter pour créer le nouveau fichier.

  4. Double-cliquez sur le nouveau fichier créé pour l'ouvrir en vue de le modifier.

  5. Modifiez la déclaration de type de ressource de façon à référencer la classe FontDescriptor étendue créée précédemment.

    <Asset Type="LocalizationPipeline.LocalizedFontDescription">
  6. Ajoutez dans les balises <ResourceFiles> un bloc qui répertorie chaque fichier de ressources à l'aide des éléments <Resx>.

    Les exemples de balises ci-dessous spécifient des fichiers de ressources pour la langue par défaut, ainsi que pour le danois (da), le français (fr), le japonais (ja) et le coréen (ko).

    <ResourceFiles>
       <Resx>..\Strings.resx</Resx>
       <Resx>..\Strings.da.resx</Resx>
       <Resx>..\Strings.fr.resx</Resx>
       <Resx>..\Strings.ja.resx</Resx>
       <Resx>..\Strings.ko.resx</Resx>
    </ResourceFiles>
  7. Enregistrez le fichier.

Pour assigner le processeur de contenu personnalisé au fichier .spritefont

  1. Compilez la solution pour générer le projet Bibliothèque d'extension de contenu à venir.

  2. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis cliquez sur Ajouter une référence.

  3. Dans la boîte de dialogue Ajouter une référence, cliquez sur l'onglet Projets, puis sélectionnez le projet Bibliothèque d'extension de contenu à venir créé précédemment (par exemple, LocalizationPipeline).

  4. Cliquez sur OK.

  5. Dans le projet de contenu, cliquez avec le bouton droit sur le fichier .spritefont, puis sélectionnez Propriétés.

  6. Dans le volet Propriétés résultant, sélectionnez votre processeur personnalisé (par exemple, LocalizedFontProcessor) dans la liste déroulante associée au champ ContentProcessor.

Utilisation des chaînes localisées dans le jeu

Les chaînes localisées seront disponibles dans votre jeu sous la forme d'une classe ayant le même nom que le fichier de base du fichier de ressources pour la langue par défaut (par exemple, Strings).

La définition de la propriété Culture de cette classe à partir de la propriété CultureInfo.CurrentCulture entraînera le chargement des chaînes localisées dans la version de langue appropriée en fonction du paramètre de culture actif de la plateforme.

Strings.Culture = CultureInfo.CurrentCulture;
Afficher: