Tutelarius Simulator: A Game Built & Localized from Scratch

1. Brainstorming Stage

• Game Genre: Identify the target genre (e.g., simulation, adventure) and game type (2D Top Down game).

• Game Process: Outline gameplay mechanics, core objectives, and player interaction loops.

• Quests: Define mission structures and progression systems, including main quests and player feedback (Developed a main storyline and an ending).

• Media Assets: Plan visual and audio elements, ensuring they align with the game’s theme and genre (Pixel art).

• Tools: Determine software and resources, including Unity, Procreate, and AI-based tools for asset creation.

When Coraline Yang proposed the game’s concept, it set the stage for our creative journey. As the plot writers, Coraline and I collaborated closely to craft an engaging main storyline and a satisfying ending. We identified the game genre as a 2D top-down adventure, outlined core gameplay mechanics, and designed mission structures that aligned with player progression.

For media assets, Coraline worked tirelessly to create pixel art that perfectly matched the theme, while I relied on tools like Unity, Procreate, and AI-based utilities to support asset development.

2. Game Structure Development

As the engineer, I focused on implementing the technical backbone:

• Character Movement: I used Unity’s RigidBody component to enable physics-based interactions and ensured smooth transitions in character animations.

• Camera Movement: With Cinemachine, I set up dynamic camera controls, adding a Polygon Collider to keep the view confined within the game world.

• Scene Transitions: I utilized Unity’s SceneManager API for seamless navigation between levels.

• Menus: I designed the main and pause menus, linking their buttons to C# functions for smooth interactivity.

I also worked on designing the game’s environment by layering the background, midground, and foreground. This combination of AI-generated and hand-drawn assets ensured visual consistency.

3. Game Development Workflow

Design

As a team, we prioritized creating intuitive gameplay mechanics and a compelling narrative. We focused on core gameplay mechanics, narrative elements, and level design and tried to ensure engaging player experiences with seamless progression.

Art

Visual aspects include:

• Menu Backgrounds: Expressive compositions generated via AI and refined manually.

• In-game Map and Props: Custom-made pixelated assets to match the 2D Top Down fixed-perspective style.

• Animations: Hand-drawn animations created in Procreate.

While AI art was useful for atmospheric visuals like menu scenes, we often relied on manual creation for precision. Asset development followed a structured routine:

1. Sketch initial concepts and hand them off for white-box testing.

2. Use real-world references or AI generation for base assets.

3. Post-edit generated assets for alignment and polish.

Coraline’s art assets—menu backgrounds, in-game maps, and props—brought the game’s vision to life, blending AI tools with her manual expertise.

Engineering/Programming and Localization

Handles technical implementation:

1. Core Mechanics: Implement movement, animations, and camera controls using Unity.

2. Localization:

   • Use Unity’s Localization Package to support multilingual gameplay.

   • Create Localization Settings.asset and Locale files for each target language, including a CCJK language.

   • Develop String Table Collections for text-based assets like UI, menu options, and dialogues.

   • Address font compatibility for CCJK languages by using fallback fonts or creating new SDF font assets.

Localization Implementation Steps:

• Add Localize String Event components to text objects like “Pause” in the Game HUD or “Play Button” in Menu Intro.

• Use dynamic string updates to switch language when the player selects a different locale.

• Externalize strings for easy export/import of translations (e.g., XLIFF format).

My role as the localizer included integrating Unity’s Localization package to support multilingual gameplay. I developed string tables, managed font compatibility for CCJK languages, and ensured translations were accurate and contextually consistent.

Production/Project Management

Oversee scheduling and task allocation. Effective cross-team collaboration ensured consistent progress:

• Designers finalized gameplay mechanics and quests early to avoid bottlenecks.

• Programmers implemented placeholder assets for iterative testing while artists refined visuals.

Alice Zhang, our project manager, skillfully coordinated schedules and ensured smooth cross-team communication, allowing us to meet milestones effectively.

Quality Assurance (QA)

Test gameplay and localization for:

Performance: Optimize scene loading times and frame rates.

Bugs: Fix functionality issues in mechanics, scene transitions, and menus.

Localization Accuracy: Verify translations and font rendering for all supported languages.

4. Real Case

Game Play

Localization

TBA

5. Lessons Learned

Challenges & Difficulties

1. Technical Challenges

   • Implementing the language dropdown menu required dynamic updates to UI components, such as TextMeshPro elements, through Localize String Event. The main difficulty was ensuring the localized strings updated seamlessly in real-time.

2. Fallback Fonts for CCJK Languages

   • A major hurdle was ensuring proper font rendering for Chinese, as the default fallback font occasionally failed for specific glyphs. Creating a custom SDF fallback font resolved this issue but added extra steps to the workflow.

3. Maintaining Contextual Consistency

   • The same text (e.g., “Pause”) appearing in multiple contexts (HUD vs. control settings) led to initial confusion in linking the correct localized strings. Properly naming and grouping strings in tables eliminated redundancy and ensured accuracy.

4. String Update Logic

   • Linking TextMeshPro objects to the dropdown’s event required manually assigning objects in the “Update String” list. While straightforward, it was tedious for large-scale projects, emphasizing the importance of efficient automation tools.

Game Creation

1. Clear Structure and Workflow

   • Establishing a well-defined game structure early on significantly simplifies the localization process. For example, separating game logic, UI elements, and assets helps ensure strings are easy to identify and externalize.

   • Using tools like Cinemachine for camera control, or properly organizing backgrounds into layers (foreground, midground, and background), improves both usability and aesthetics.

2. Efficient Use of Prefabs

   • Prefabs are invaluable for reusability and consistency across multiple scenes.

   • However, when reusing button prefabs in new scenes, it’s crucial to ensure the EventSystem is added to prevent UI functionality from breaking.

3. Scene Transitions and Interactivity

   • Smooth scene transitions are vital for maintaining player immersion. Using C# scripts for “onClick()” events while linking to scene-specific data helped streamline the game’s interactive components.

   • Testing transitions between localized and non-localized content ensures consistent player experience across languages.

4. Iterative Asset Workflow

   • Iterating on assets early helps catch issues with style, compatibility, and resolution. Integrating AI-generated elements with manual editing ensures the artistic quality meets the game’s visual identity.

Localization

1. Localization Framework

   • Using the Unity Localization package allows for efficient text externalization and management. Ensuring a consistent naming convention for strings (e.g., lowercase, descriptive keys) minimizes confusion during development.

   • Fallback fonts are a quick solution for CCJK languages but should only be temporary. Custom SDF font assets provide a cleaner, more professional result.

2. Testing Localization Across Scenes

   • Each scene has unique challenges, such as missing or improperly linked localized strings. Regularly testing for both functionality (e.g., dropdown menus) and text quality prevents costly fixes later.

3. Cross-Disciplinary Collaboration

   • Working closely with teammates enhances localization effectiveness. Aligning workflows and communication helps reduce inconsistencies in asset naming and file management.

Summary

Creating this game has been a challenging yet rewarding process. From writing the plot to implementing gameplay mechanics and managing localization, I’m proud of what we’ve achieved as a team. This experience has strengthened my skills as an engineer and localizer and deepened my appreciation for the power of collaboration in game development.