I worked with my colleagues to create and localize a game from scratch using Ren’Py, a Python-based visual novel game engine, as the game engine! Doing everything from scratch presented new challenges to us, from character creation, narrative, and plot progression to more technical aspects such as coding the game, externalizing the strings, and localizing the game itself. My role in the process was split between dialogue/narrative creation and the localization process itself.
Here’s a one-minute rundown of what I worked on in this project:
Narrative Design
I really enjoyed this aspect of designing our game! It was incredibly fun to hear my group member’s thoughts and ideas on how we wanted to structure the plot of the game. At first, we wanted to go with a zombie theme, but we decided to go with a post-COVID theme where the protagonist is trying to reintegrate into society after an extensive lockdown period. We kept the game short, with only four scenes total, and limited the number of characters as well.
The characters include:
- Protagonist: The player character
- Sad Girl: NPC in the first scene
- Dog: Sad Girl’s pet
- Talking Vending Machine
- Talking Locker
- Locker Room Attendant
- Mom
- Pet
The characters don’t necessarily have too much to do with our theme, since we included sentient inanimate objects, which is a shortcoming in our narrative design.
Collaboration
Since our team members couldn’t work from one location all the time, we decided that working remotely would be ideal. But working on local files and sending our changes to each other is far from ideal, and merging all those changes would be incredibly difficult as well. To address this challenge, we created a GitHub Repository for our game! We had used something similar on a previous project, so implementing this streamlined our workflow. When our main engineer made changes to the code, they would push those changes, and we could receive them as needed.
Localization
Ren’Py has localization support, but their native system is rather inefficient on its own. According to the documentation, strings are externalized into a file format native to Ren’Py, which is incompatible with CAT tools on its own. Translations should be done within these files themselves, with the translation going right after the related string. This is very inefficient, especially in cases where the game is extensive and includes a lot of user-facing strings. Luckily, there was an alternative solution!
Translator Toolkit
We first had to generate the locales within Ren’Py. These files, however, are native to Ren’Py and therefore hard to work with in CAT tools. There is a free addition to Ren’Py, called Translator Toolkit, that converts the native Ren’Py files into a .po file, which we can easily work with in a CAT tool! Once translated, we were able to reimport the files using the toolkit as well, which recompiles the .po file into the native Ren’Py files.
Takeaways
Localizing a game can provide plenty of challenges on its own, but I felt that localizing a game that I had an active part in creating gave a lot of room for preparing for internationalization from the start: instead of externalizing strings after the fact, we were able to externalize them from the start, which saved us a lot of time when we needed to export the strings for translation; since the engineer was aware of internationalization best practices, we were able to avoid concatenating any user-facing strings in our code; we used very little text in our image assets.
That being said, it was difficult to make certain aspects i18n-friendly, such as having the background text box in the narrator scene expand with the text in the Spanish version.
If you’re interested in the other aspects of this project, check out the blog posts written by my colleagues: