Filmstrip Engine Development: GO GO GO!

0.1: The Base

Version 0.1 was largely about setting up the basics of any game and any game engine.

At first, that meant rendering a little guy on the screen and making him move. A humble beginning, lol. From there, however, the engine quickly grew into a functional foundation for everything we plan to build next.

During version 0.1, we:

• Built the core Windows-only Python 2D engine without Pygame.
• Added a functional scene editor with toolbar, hierarchy, inspector, and viewport.
• Implemented scene creation, loading, saving, and Save As support.
• Added object placement, selection, duplication, deletion, and renaming.
• Introduced a reusable component-based object system.
• Added sprite rendering, rectangle rendering, animation, and collider components.
• Implemented player movement, collision detection, and trigger areas.
• Added named player spawn points and scene-to-scene transitions.
• Created reusable object templates with editing and deletion support.
• Added a Tag Registry for organizing and targeting scene objects.
• Implemented interactable objects with keyboard input and on-screen prompts.
• Added a node-based dialogue system with a dedicated Dialogue Editor.
• Included speaker names, typewriter text, dialogue choices, and progression controls.
• Added trigger events for enter, exit, and interaction actions.
• Supported actions such as dialogue, teleporting, animation playback, variables, and object activation.
• Created sprite animation and animated tile editing tools.
• Improved editor performance by reducing unnecessary refreshes and draw calls.
• Refactored major editor systems into smaller controllers and shared services.
• Stabilized editor windows, focus handling, repainting, and closing behavior.

0.2: The Direction

Version 0.2 was more about figuring out exactly what we wanted this game engine to become.

We decided to build something accessible, easy to learn, and smooth to work with. So, you know the opposite of most game engines! That was fine, though. It was exactly the kind of challenge we wanted.

We added more visual menus, readable tools, and helpful tooltips that explain what you are doing while building your dream RPG. We also decided to focus on creating a smaller, more specialized engine rather than trying to compete with massive general-purpose tools.

For now, the goal is to make a focused and finely tuned RPG engine at a fair price point—likely somewhere around the $20 range.

With that direction established, we moved on to implementing many of the RPG authoring tools a user would need.

During version 0.2, we:

• Expanded the editor with more visual menus, readable controls, dropdowns, and helpful tooltips.
• Added a dedicated RPG Database for managing game-wide content.
• Created separate authoring panels for Actors and Stats.
• Added reusable registries for organizing RPG data consistently across the project.
• Implemented project-wide validation for Actor, Stat, dialogue, and other data references.
• Added warnings for missing, renamed, deleted, or invalid references.
• Added safer workflows for renaming and deleting data that may already be in use.
• Introduced configurable Stats such as health, mana, strength, defense, and other custom values.
• Added resource stats with minimum, maximum, and current values.
• Standardized resource calculations and rounding behavior.
• Created Actor definitions for players, enemies, NPCs, and other characters.
• Added configurable starting stats and stat modifiers to Actors.
• Improved modifier authoring with simpler controls and selection menus.
• Added tag-based dropdowns for connecting weapons, equipment, items, and other RPG data.
• Expanded the dialogue system with improved validation and RPG data integration.
• Added more readable dialogue authoring tools and reference selectors.
• Introduced an inventory foundation for storing items and currency.
• Added pickup objects that can award items or currency to the player.
• Expanded interaction actions so objects can trigger more RPG-related behavior.
• Added reusable data-driven tools instead of requiring users to manually edit JSON files.
• Improved regression testing for referenced Actors, Stats, and other registry entries.
• Refactored shared registry systems to make future additions easier and more consistent.
• Updated the engine documentation to explain the new RPG authoring workflows.
• Established the RPG foundation needed for quests, equipment, combat, shops, and other future systems.