Sometimes, a simple image can tell more than a million words! Today, we are proud to announce that Chop Chop Ninja will be available on Appstore on December 25th.

Merry Christmas and see you in 2 days for more Chop Chop Ninja surprises!!!

With love – Gamerizon

From December 24th until January 4th 2010, QuantZ will be available on Steam for $2.99. This version includes a Christmas theme (new backgrounds and new QuantZ), and a brand new Tutorial Mode to learn how to play QuantZ.

Hope you will enjoy this!

Merry Christmas!

Gamerizon

Today, we are proud to announce our first game for iPhone and iPod Touch: Chop Chop Ninja

Chop Chop Ninja is a platformer developed specifically for iPhone and iPod Touch. You control Iro the ninja and you have to explore the world to save your princess from a terrible curse.

Chop Chop Ninja is actualy in the review phase and should be avalable on the App Store on January 15th! Please check out our Chop Chop web page to get more info about the game.

More delightful surprises will come soon…

A small update for the Linux Community. The Linux version of QuantZ is still in testing phase. During our beta, we received a lot of feedback and we would like to thank you for all your help! And because of all your support, we are happy to say that:

QuantZ for Linux should be available in January 2010!

If you haven’t tried QuantZ on Linux yet, we invite you to download the beta version available here!

Have fun!

We just finished to develop QuantZ for the Linux Platforms.  You can try the beta versions for free before the official release!

Linux 32bit versions

.tar.gz version
.deb version
.rpm version

Linux 64bit versions

.rpm version
.deb version
.tar.gz version

You can send us feedback about this version by email : support@gamerizon.com or post a comment on our reddit thread.

Games created using the Unity3D game engine can be easily localized, thanks to the great flexibility provided by their components system, but several choices must be made achieve it. Indeed, a decision must be made on how exactly to create and use localizable data within the game.

One approach, which I would call the “easy way” is to ensure that all the game text is only present in the game code. That way, before displaying any text string to the user, a localization table can used to translate the string into the user’s language. The main drawback of this method is that all the text is rendered programmatically, which will probably not give the flexibility of having the text manually integrated into textures by an artist.

The opposite idea would be to include all the texts inside textures such that they are rendered exactly as desired giving the best visual result. Localizing these assets thus requires translating the text directly into the textures and creating a system that chooses automatically the correct texture.

We developed an iPhone game using the Unity3D game engine that uses both of these strategies to display localized text to the users. Messages displayed dynamically and information display is rendered programmatically using the first approach. Story and GUI-related messages are directly included into textures to provide pertty visual integration of the localized content.

Implementing the first technique was easily achieved by using a csv file parser. We chose to use a csv file as our localization database since it is a simple and convenient format, which can be edited under tools like Microsoft Office or OpenOffice by our translation team. Using the in-code English text strings as our database key, we then simply use a translation method before displaying a string in the game. In our case, this function can be summarized by the following code:

public class Localization
{
  // ...
  public static string Translate(string id)
  {
    string key = id.ToLower();  // case insensitive id are used
    string lang = LocalizationManager.Instance().GetCurrentLanguage();
 
    LoadTranslations(); // only loaded once
    int lang_index = FindLangIndex(lang);
 
    if (lang_index == -1)
    {
      Debug.Log("Unknown translation language: " + lang);
      return id;
    }
 
    string translation = (string)_translationData.content[lang_index][key];
 
    if (translation == null)
    {
      Debug.Log("Missing translation for text id: "+id);
      return id;
    }
 
    return translation;
  }
  // ...
}

Localizing image assets is a greater challenge because they are often used automatically in Unity3D and added to GameObjects using the component system. To localize these assets, we use components that can be “dragged-and-dropped” into the Prefabs or GameObject instances that uses these localized image assets to automatically choose the correct texture. The abstract class LocalizedAsset is used to perform this task.

public abstract class LocalizedAsset : MonoBehaviour
{
  public Texture TranslateAsset(Texture initTexture)
  {
    Texture translatedTexture = null;
    if (initTexture != null)
    {
      translatedTexture = TranslateAsset(initTexture.name);
    }
    return translatedTexture;
  }
 
  public Texture TranslateAsset(string assetName)
  {
    Texture translatedTexture = null;
    string langAssetName =
      StripLanguageExtension(assetName) +
      LocalizationManager.Instance().CurrentLanguageToExtension();
 
    translatedTexture =
      (Texture)LocalizationManager.Instance().LoadAsset(langAssetName);
 
    return translatedTexture;
  }
 
  public abstract void LoadAssets();
 
  public void Start()
  {
    LocalizedAssetsObserver.AddLocalizedAsset(this);
    LoadAssets();
  }
}

The LoadAssets method must be implemented by subclasses such that it will ensure that all the localized assets present in the current object will be correctly translated. The TranslateAsset methods can be used to get the translated textures easily. The Start implementation will then load all the localized assets of the object at runtime for all the subclasses. The observer design pattern is used to register any localized assets in the aim of having the possibility to to reload them as needed when the language is changed at runtime by the user. An example implementation of LocalizedAsset is provided below:

public class LocalizedMaterialAsset : LocalizedAsset
{
  public override void LoadAssets()
  {
    // Assuming only 1 material is used...
    MeshRenderer renderer = 
      (MeshRenderer)gameObject.GetComponent("MeshRenderer");
    if (renderer != null && renderer.material.mainTexture != null)
    {
      renderer.material.mainTexture = 
        TranslateAsset(renderer.material.mainTexture);
    }
  }
}

Thus, adding the LocalizedMaterialAsset to any Prefab or GameObjects that have a certain material component will automatically translate the texture image used by that material. The LocalizationManager singleton instance is responsible for keeping track of the current localization state (current language, etc…) and uses the Unity3D Resources class to dynamically load localized assets:

public class LocalizationManager : MonoBehaviour
{
  // ...
  public Object LoadAsset(string assetName)
  {
    return Resources.Load("Localization/"+_currentLanguage+"/"+assetName);
  }
  // ...
}

Thus using a csv database and Unity3D components and dynamic resources enabled us to easily localize our game to multiple languages. I hope this can help other Unity3D community members to localize their game.

Welcome to Gamerizon’s shiny new blog.

We’ll be posting about game making and about the games we are developing.

Enjoy!