Make jRPG with RPG Maker

Analyze the architecture of RPG Maker, focusing on its database (JSON), event system, and plugin structure.

Compare the data-driven architecture of RPG Maker to common front-end frameworks and custom game engines.

Design the architecture for a simple game engine, including a game loop, scene manager, and rendering pipeline.

Implement a game loop using requestAnimationFrame, managing state updates and rendering with delta time.

Implement a canvas rendering system for drawing sprites from a tileset and spritesheet.

Implement a basic asset manager for preloading images and data files.

Implement frame-based sprite animation with timing and directional state.

Design a multi-layered tile map data structure (ground, collision, objects, overhead).

Implement a tile map renderer with a camera viewport that only draws the visible portion of the map.

Implement grid-based character movement logic controlled by player input.

Implement smooth visual interpolation for character movement between grid cells.

Implement collision detection against the map's collision layer.

Implement a camera system that smoothly follows the player character.

Design a data structure for NPC data and implement simple random movement patterns.

Design a scene manager architecture to handle transitions between game states (e.g., map, menu, battle).

Implement the scene manager to transition between the map, a main menu, and back.

Design the architecture for a data-driven event system, including event triggers, commands, and an interpreter.

Implement an event interpreter that processes a sequence of commands (e.g., Show Text, Move Character, Wait).

Implement a system for game flags (switches/variables) to track story progression.

Implement event triggers for player interaction, automatic execution, and map entry.

Script a treasure chest event that uses a game flag to prevent re-opening.

Script a map transition event (e.g., entering a building).

Design a flexible data format for dialogue, supporting multiple pages, character portraits, and branching choices.

Implement a dialogue UI with a typewriter text effect and support for player choices.

Integrate the dialogue system with the event system to show text and handle choice-based branching.

Implement event commands for controlling character and camera movement to create simple cutscenes.

Implement conditional event logic (IF/ELSE) based on game flags to alter dialogue and event outcomes.

Design the architecture for a classic turn-based combat system, including a state machine (start, input, execution, end).

Create a data structure for combatants (actors and enemies) with core stats (HP, MP, ATK, DEF, AGI).

Implement a turn-ordering system based on character agility (e.g., Active Time Battle).

Implement core combat actions: Attack, Defend, and Escape.

Design and implement damage calculation formulas inspired by classic JRPGs.

Implement victory and defeat condition checks, and the transition from the battle scene back to the map.

Implement the system for distributing experience points and loot upon victory.

Design a data structure for skills and magic, including cost, target type, power, and effects.

Implement logic for MP consumption and target selection for skills.

Implement status effects (e.g., Poison, Sleep) and elemental properties.

Design and implement a simple enemy AI system for selecting actions based on predefined patterns or conditions.

Integrate a basic animation player for sprite-based skill effects in combat.

Implement visual feedback for combat, such as damage pop-ups and sprite flashing.

Design and implement an experience and leveling system with stat growth curves.

Design a class/job system that dictates stat progression and available skills.

Implement the skill learning mechanics tied to leveling up within a class.

Design a database structure for items (consumable, equipment, key) and an inventory data structure.

Implement an API to add, remove, and query items in the player's inventory.

Implement the logic for using consumable items from both the menu and in battle.

Design and implement a data structure for equipment that modifies character stats.

Implement the logic for equipping items and calculating a character's final stats.

Design a reusable UI component architecture for a canvas-based game (e.g., windows, lists, cursors).

Implement the main menu scene, allowing access to sub-screens.

Implement the character status screen, displaying base stats, equipment, and final stats.

Implement the inventory and equipment screens, allowing for item usage and management.

Implement the UI for a shop, including buy/sell logic that interacts with the inventory and currency systems.

Implement the battle UI, including party/enemy status displays, command menus, and a target selection cursor.

Implement a save/load screen that interacts with multiple save slots.

Design a serializable game state object that aggregates all data needed for saving.

Implement save/load functionality using the browser's localStorage or IndexedDB API.

Integrate an audio manager for background music and sound effects using the Web Audio API.

Implement visual effects like screen fades, screen shake, and a basic particle system for spell effects.

Apply game design principles to create a town, a dungeon, and an overworld map.

Design and implement a simple environmental puzzle (e.g., switch and door).

Design a random encounter system with region-specific enemy groups and encounter rates.

Outline a short narrative arc and define the 'golden path' for a complete demo slice.

Script the opening cutscene and initial tutorial events using the event system.

Create a scripted combat encounter to introduce battle mechanics.

Design and implement a unique boss encounter with a distinct mechanic (e.g., phase change, special attack).

Balance enemy stats, encounter rates, and rewards to create a smooth difficulty curve for the demo.

Integrate all systems (events, combat, menus, progression) to create a seamless gameplay loop.

Conduct a full playthrough to identify and fix bugs, pacing issues, and usability problems.

Refine game parameters based on playtesting feedback to polish the final demo.