home / skills / miles990 / flame_demo_game / flame-templates

flame-templates skill

/skills/flame-templates

This skill provides complete flame game templates for RPG, Platformer, and Roguelike, including core loops, UI, and basic classes.

npx playbooks add skill miles990/flame_demo_game --skill flame-templates

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
1.3 KB
---
name: flame-templates
description: Game type templates for Flame Engine - RPG, Platformer, Roguelike starter code
domain: game-development
version: 2.0.0
tags: [flame, flutter, dart, game-templates, starter]
---

# Flame Game Templates

三種主要遊戲類型的完整起始模板和架構。

## Reference Index

| Template | File | Description |
|----------|------|-------------|
| **RPG** | `references/rpg.md` | 回合制/動作 RPG 完整架構 |
| **Platformer** | `references/platformer.md` | 橫向卷軸平台遊戲 |
| **Roguelike** | `references/roguelike.md` | 程序生成地下城 |

## AI Usage Guide

```
需要 RPG 遊戲?      → Read references/rpg.md
需要平台遊戲?       → Read references/platformer.md
需要 Roguelike?    → Read references/roguelike.md
```

## Template Comparison

| Feature | RPG | Platformer | Roguelike |
|---------|-----|------------|-----------|
| View | Top-down / Isometric | Side-view | Top-down |
| Combat | Turn-based / Action | Real-time | Turn / Real-time |
| Progression | Level + Equipment | Checkpoints | Permadeath + Meta |
| Map | Static + Towns | Linear Levels | Procedural |

## Quick Start

每個模板包含:
- 完整 main.dart
- Player 類別
- 核心遊戲循環
- 基礎 UI

## Related Skills

- `flame-core` - 引擎核心基礎
- `flame-systems` - 14 個遊戲系統

Overview

This skill delivers three ready-to-use game templates for the Flame Engine: RPG, Platformer, and Roguelike. Each template provides a complete starter structure with player code, core game loop, and basic UI so you can prototype quickly. Templates are implemented in JavaScript and targeted at small-to-medium game projects.

How this skill works

The skill supplies three focused reference templates that outline architecture, systems, and example flows for each game type. Each template includes a main entry, player class patterns, core loop setup, and minimal UI components so you can adapt or extend them into a full game. Use the reference guide for each template to follow recommended patterns and integrate engine systems.

When to use it

  • You need a fast prototype for an RPG, platformer, or roguelike using Flame Engine.
  • You want clear architecture and starter code to learn Flame Engine patterns.
  • You need example systems like combat, progression, or procedural map layout.
  • You are building a small team project and want consistent base templates.
  • You want to compare design differences across top-down, side-view, and procedural genres.

Best practices

  • Start from the provided template that most closely matches your game loop (top-down vs side-view).
  • Keep game logic modular: separate player, map, UI, and system code for easier extension.
  • Use the template’s core loop and event hooks rather than modifying engine internals.
  • Replace placeholder assets early to validate performance and layout.
  • Iterate on one system at a time (movement, combat, progression, procedural generation).

Example use cases

  • Create a turn-based or action RPG prototype with town and dungeon layouts.
  • Build a side-scrolling platformer with player controls, checkpoints, and hazards.
  • Implement a roguelike with procedural dungeon generation and permadeath mechanics.
  • Teach students engine architecture and game systems using concrete examples.
  • Rapidly test gameplay ideas by swapping systems between templates.

FAQ

Are these templates ready for production?

They are solid starter architectures for prototypes and small projects; production readiness requires polishing, asset replacement, and performance testing.

Can I mix systems between templates?

Yes. The templates are modular so you can reuse player controllers, combat systems, or procedural map code across projects.

What engine language do the templates use?

Templates are implemented in JavaScript and follow Flame Engine patterns tailored for JS projects.