@v12-engine/create 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Doron Torangy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,27 @@
-# Temporary Holding Version
+# @v12-engine/create
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A project to start a game from, made with V12: its rules, its page, and the parts you choose.
+
+```sh
+npm create @v12-engine my-game
+```
+
+It asks where to make it, which starter, what the game is called, which parts it has, what server, and whether to make a git repository and install. `--yes` asks nothing; `--help` lists every flag.
+
+| Starter    | What it is                                                                                   |
+| ---------- | -------------------------------------------------------------------------------------------- |
+| `empty`    | Hello world: a flat field and a scout to walk it. The default.                               |
+| `melee`    | A whole RTS: two races and their heroes, bases and armies, against the computer.             |
+| `campaign` | A campaign of three missions with a hero carried between them, drawn with the shared models. |
+
+```sh
+npm create @v12-engine arena -- --yes --starter melee --server rooms --ratings
+```
+
+The parts: the map editor (`--no-editor`), a server of one game, of many games in rooms, or none (`--server single|rooms|none`), ratings (`--ratings`), a test of the rules (`--no-tests`), a git repository (`--no-git`), and installing at once (`--install`).
+
+In code: `createProject(folder, options)` from `@v12-engine/create`.
+
+The project it makes is yours: no attribution to this package is asked for in it. The package itself is MIT.
+
+The whole guide is the docs' page Starting a project (`docs/start/new-project.md` in the repository).

package/base/_gitignore

@@ -0,0 +1,10 @@
+node_modules
+dist
+*.local
+.DS_Store
+# the replays Play here keeps with a map: the designer's own, not the map's
+**/*.files/replays/
+# @if ratings
+# what the server keeps of who played: not code
+ratings.json
+# @end

package/base/index.html

@@ -0,0 +1,20 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="UTF-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+		<title>My game</title>
+		<style>
+			html,
+			body,
+			#game {
+				height: 100%;
+				margin: 0;
+			}
+		</style>
+	</head>
+	<body>
+		<div id="game"></div>
+		<script type="module" src="/src/main.ts"></script>
+	</body>
+</html>

package/base/package.json

@@ -0,0 +1,23 @@
+{
+	"name": "my-game",
+	"private": true,
+	"type": "module",
+	"scripts": {
+		"dev": "vite",
+		"build": "vite build",
+		"preview": "vite preview",
+		"typecheck": "tsc --noEmit"
+	},
+	"dependencies": {
+		"@v12-engine/engine": "^0.0.0",
+		"@v12-engine/client": "^0.0.0",
+		"@babylonjs/core": "^9.31.0",
+		"@babylonjs/gui": "^9.31.0",
+		"@babylonjs/loaders": "^9.31.0"
+	},
+	"devDependencies": {
+		"@types/node": "^26.6.5",
+		"typescript": "^7.0.2",
+		"vite": "^8.3.4"
+	}
+}

package/base/src/ground.worker.ts

@@ -0,0 +1,8 @@
+/**
+ * The page's worker that makes the ground's textures (the client's patterns: grass, gravel, cobbles…), so the page
+ * goes on while they are made. Given to the app in `main.ts` (`groundWorker`)
+ */
+// the client's ground alone: nothing of Babylon or the HUD is loaded into the worker
+import { serveGroundTextures } from '@v12-engine/client/ground'
+
+serveGroundTextures()

package/base/src/main.ts

@@ -0,0 +1,61 @@
+/**
+ * The page: the game's start screen, and what it goes to from there, each a screen of an app of scenes (`startApp`,
+ * `@v12-engine/client/app`), one shown at a time. `appScenes` makes them: the start screen, the game, a random map when
+ * the rules have a generator, and the settings.
+// @if editor
+ * The map editor too, set up in `src/editor.ts`.
+// @end
+// @if server
+ * A seat at the game's server too (`npm run server`).
+// @end
+ * The list is a plain array: add a scene of your own to it, or take one away. The address opens straight into a scene
+ * by its id (`sceneAsked`: `/?settings`, and those the README says), the start screen otherwise. The debug panel (🐞 on
+ * the top bar, Alt+Shift+D) and its cheats are in the game while developing (`npm run dev`), not in a built page:
+ * `debug` says otherwise
+ */
+import { appScenes, sceneAsked, startApp } from '@v12-engine/client/app'
+import '@v12-engine/client/styles.css'
+// the theme's typefaces come with the client: the page's own font stays what it was
+import '@v12-engine/client/fonts.css'
+// @if editor
+import { editor } from './editor'
+// @end
+import { DEFAULT_MAP, maps } from './maps'
+import { rules, start } from './rules'
+
+const scenes = appScenes({
+	// the game's code (its looks, and the client that draws them) fetched as a scene first plays it: the start screen
+	// shows at once, its rules telling it what to say of the game
+	game: () => import('./game').then((module) => module.game),
+	rules,
+	maps,
+	map: DEFAULT_MAP,
+	start,
+	// @if editor
+	editor,
+	// @end
+	// @if single
+	server: true,
+	// @end
+	// @if rooms
+	server: { rooms: true },
+	// @end
+	// @if generator
+	// the random map's preview made in a worker of the page's (`src/generate.worker.ts`): the menu goes on while it is made
+	generatorWorker: () => new Worker(new URL('./generate.worker.ts', import.meta.url), { type: 'module' }),
+	// @end
+	menu: { description: 'A game made with V12.' },
+	// the Credits on the start screen (`creditsScene`): who made the game, by parts, scrolling
+	credits: {
+		sections: [
+			{ title: 'Made by', names: ['You'] },
+			{ title: 'Made with', names: ['V12'] }
+		]
+	}
+})
+
+/** The ground's textures made in a worker of the page's (`src/ground.worker.ts`), made at the first texture: the page goes on while they are made */
+const groundWorker = () => new Worker(new URL('./ground.worker.ts', import.meta.url), { type: 'module' })
+
+const app = startApp({ target: '#game', title: rules.name, scenes, start: sceneAsked(scenes, 'home'), groundWorker })
+Object.assign(window, { app })

package/base/tsconfig.json

@@ -0,0 +1,14 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"lib": ["ES2022", "DOM", "DOM.Iterable"],
+		"types": ["vite/client", "node"],
+		"resolveJsonModule": true,
+		"strict": true,
+		"noEmit": true,
+		"skipLibCheck": true
+	},
+	"include": ["src", "tests", "server.ts", "vite.config.ts"]
+}

package/base/vite.config.ts

@@ -0,0 +1,25 @@
+// @if editor|assets
+import { defineConfig } from 'vite'
+// @if assets
+import { assetsPackage } from '@v12-engine/client/vite'
+// @end
+// @if editor
+import { editorFiles } from '@v12-engine/editor/vite'
+// @end
+
+export default defineConfig({
+	plugins: [
+		// @if assets
+		// the shared art (@v12-engine/assets) served where the game's shared files are (/models/…), behind public/: a file
+		// of yours at the same path is the one served. A build copies what the game uses of it. `assetsPackage({ groups:
+		// ['forest'] })` takes some of its groups, `copy: 'all'` copies every file of them
+		assetsPackage(),
+		// @end
+		// @if editor
+		// the map editor keeps the game's maps in the project through the dev server: Save writes them into `src/maps`.
+		// Only in `npm run dev`; a built page keeps maps in the browser
+		editorFiles({ gameFolder: () => 'src' }),
+		// @end
+	]
+})
+// @end

package/bin.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/** `npm create @v12-engine [folder]`: a project to start from. `--help` says what it takes (`cli.mjs`) */
+import { run } from './cli.mjs'
+
+try {
+	await run(process.argv)
+} catch (error) {
+	console.error(error instanceof Error ? error.message : error)
+	process.exit(1)
+}

package/cli.mjs

@@ -0,0 +1,381 @@
+/**
+ * The command line of `npm create @v12-engine` (`bin.mjs`): what it is told by its flags, and what it asks a person for
+ * what they did not say. Everything ends in one object, `createProject`'s options and what is done once it is made
+ * (a repository, an install), so a new option is a flag, a question and a field of it, here
+ */
+import { execFileSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, relative, resolve } from 'node:path'
+import * as clack from '@clack/prompts'
+import { Command, InvalidArgumentError, Option } from 'commander'
+import {
+	commandsOf,
+	createProject,
+	DEFAULT_STARTER,
+	notEmpty,
+	PACKAGE_MANAGERS,
+	SERVERS,
+	starterNamed,
+	starters,
+	titleOf,
+	titleProblem
+} from './index.mjs'
+
+const own = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8'))
+
+/** The folder a project is made in when nobody says which */
+const DEFAULT_FOLDER = 'my-game'
+
+/** What the options that are parts of the project are, for the help and the questions */
+const PARTS = {
+	editor: 'the map editor, at /?editor, saving maps into the project',
+	tests: 'a test of the rules with no page, in Vitest',
+	assets: 'shared models to start with (@v12-engine/assets): adventurers with their clips, buildings, trees and rocks, props, weapons'
+}
+
+/** What each kind of server is, for the help and the question */
+const SERVER_KINDS = {
+	single: 'one game at a time, joined from the page at /?server',
+	rooms: 'many games in rooms: Find a game at /?find-game, New game, Play now',
+	none: 'no server: the game is played in the page'
+}
+
+/** What the help says after the flags: the starters, and how it is used */
+const helpAfter = () => `
+Starters:
+${starters.map((starter) => wrap(starter.summary, 13).replace(/^ {13}/, `  ${starter.name.padEnd(10)} `)).join('\n')}
+
+Servers:
+${Object.entries(SERVER_KINDS)
+	.map(([kind, what]) => `  ${kind.padEnd(10)} ${what}`)
+	.join('\n')}
+
+With no flags it asks for what it needs. With --yes, or where nobody can answer
+(CI, a pipe), it asks nothing and takes the defaults for what it was not told:
+the empty starter, the editor, a single server with no ratings, the tests, the
+shared art, a git repository, and no install.
+
+Examples:
+  npm create @v12-engine                         ask for everything
+  npm create @v12-engine orc-wars                in ./orc-wars, asking the rest
+  npm create @v12-engine orc-wars -- --yes       in ./orc-wars, all the defaults
+  npm create @v12-engine . -- --starter melee --name "Orc Wars"
+  npm create @v12-engine duel -- -y --server none --no-editor --install
+  npm create @v12-engine arena -- -y --starter melee --server rooms --ratings
+  npx create-v12 apps/orc-wars -y --source in the library's own repository
+  npx @v12-engine/create --list                  the starters
+
+npm hands flags on after a --. With pnpm, yarn and bun they come straight after
+the folder.
+`
+
+/** Words in lines of at most 80, each indented by `indent` */
+const wrap = (text, indent) => {
+	const lines = []
+	let line = ''
+	for (const word of text.split(' ')) {
+		if (line && indent + line.length + 1 + word.length > 80) {
+			lines.push(line)
+			line = word
+		} else line = line ? `${line} ${word}` : word
+	}
+	lines.push(line)
+	return lines.map((each) => ' '.repeat(indent) + each).join('\n')
+}
+
+/** A starter's name, checked as the flag is read */
+const starterFlag = (value) => {
+	try {
+		return starterNamed(value).name
+	} catch (error) {
+		throw new InvalidArgumentError(error instanceof Error ? error.message : String(error))
+	}
+}
+
+/** A game's name, checked as the flag is read */
+const titleFlag = (value) => {
+	const problem = titleProblem(value)
+	if (problem) throw new InvalidArgumentError(problem)
+	return value
+}
+
+/** The command: its flags, its help, and what it does with them (`act`, given the folder and the flags) */
+export function program(act) {
+	return new Command('create-v12')
+		.description('Makes a game to start from, made with V12: its rules, its page, and what you choose to go with them.')
+		.argument('[folder]', `where the project is made, empty or not there yet (${DEFAULT_FOLDER} when not said)`)
+		.option('-s, --starter <name>', `the game it starts from: ${starters.map((starter) => starter.name).join(', ')}`, starterFlag)
+		.option('-n, --name <name>', "the game's name, as players see it (from the folder's name when not said)", titleFlag)
+		.option('--editor', `with ${PARTS.editor}`)
+		.option('--no-editor', 'without it')
+		.addOption(new Option('--server <kind>', 'a server of the game, or none (see Servers)').choices(SERVERS))
+		.option('--ratings', 'the server keeps a rating for each player, in ratings.json')
+		.option('--no-ratings', 'no ratings')
+		.option('--tests', `with ${PARTS.tests}`)
+		.option('--no-tests', 'without it')
+		.option('--assets', `with ${PARTS.assets}`)
+		.option('--no-assets', 'without it (melee and the campaign cannot be made without it)')
+		.option('--git', 'make it a git repository, with a first commit (not inside one)')
+		.option('--no-git', 'no repository')
+		.option('--source', "read the library as it is written: for a project inside the library's own repository (apps/), to work on both at once")
+		.option('--install', 'install its packages once it is made')
+		.option('--no-install', 'leave installing to you')
+		.addOption(
+			new Option(
+				'--package-manager <name>',
+				'what installs and runs it, in what it does and what it says: the one this was run with when not said'
+			).choices(PACKAGE_MANAGERS)
+		)
+		.option('-y, --yes', 'ask nothing: the defaults for what is not said')
+		.option('-l, --list', 'list the starters, and make nothing')
+		.version(own.version, '-v, --version', 'the version of this command')
+		.helpOption('-h, --help', 'this help')
+		.addHelpText('after', helpAfter())
+		.showHelpAfterError('(--help says what it takes)')
+		.action(act)
+}
+
+/**
+ * Runs the command line on `argv` (`process.argv`). `ask` is whether a person can answer questions; `prompts` are
+ * the questions' library (clack), and `exec` runs a command in a folder (git, the install), for a test to stand in
+ * for them. Gives what was made, or nothing when nothing was
+ */
+export async function run(argv, { ask = canAsk(), prompts = clack, log = console.log, exec = execIn } = {}) {
+	let made
+	await program(async (folder, flags) => {
+		if (flags.list) {
+			for (const starter of starters) log(wrap(`${starter.title}: ${starter.summary}`, 11).replace(/^ {11}/, starter.name.padEnd(11)))
+			return
+		}
+		// a folder that is not empty is said before anything is asked
+		if (folder !== undefined && notEmpty(resolve(folder)))
+			throw new Error(`${resolve(folder)} is not empty: a project is made in an empty folder, or a new one`)
+		const questions = ask && !flags.yes
+		const options = questions ? await askFor(folder, flags, prompts) : decide(folder, flags)
+		if (!options) return
+		const { where, git, install, ...rest } = options
+		const project = await createProject(where, rest)
+		made = { ...project, git: false, installed: false }
+		const say = questions ? (text) => prompts.log.step(text) : log
+		const warn = questions ? (text) => prompts.log.warn(text) : log
+		if (git) made.git = makeRepository(project.where, { exec, say, warn })
+		const words = commandsOf(project.packageManager)
+		if (install) {
+			say(`Installing, with ${words.install}…`)
+			try {
+				exec(project.packageManager, ['install'], project.where, true)
+				made.installed = true
+			} catch {
+				warn(`${words.install} did not finish: run it in the project`)
+			}
+		}
+		// where it is, from here: the whole path where it is not under here
+		const below = relative(process.cwd(), project.where)
+		const into = below.startsWith('..') ? project.where : below || '.'
+		// a project that reads the library as it is written is a workspace of its repository: installed and run from the root
+		const next = project.source
+			? [...(made.installed ? [] : ['npm install']), `npm run dev -w ${project.name}`]
+			: [
+					...(into === '.' ? [] : [`cd ${/\s/.test(into) ? JSON.stringify(into) : into}`]),
+					...(made.installed ? [] : [words.install]),
+					words.run('dev')
+				]
+		const plays = [
+			'The page plays it',
+			project.editor && '/?editor is its map editor',
+			project.server === 'rooms' && '/?find-game finds games on its server'
+		]
+			.filter(Boolean)
+			.join('; ')
+			.concat('.')
+		if (questions) {
+			prompts.note(next.join('\n'), 'Next')
+			prompts.outro(`${project.title} is in ${into}. ${plays} Its README.md says the rest.`)
+		} else {
+			log(`\n${project.title}, in ${into}. Next:\n`)
+			for (const line of next) log(`  ${line}`)
+			log(`\n${plays} Its README.md says the rest.`)
+		}
+	}).parseAsync(argv)
+	return made
+}
+
+/** Whether a person is there to answer: a terminal, and not CI */
+export const canAsk = () => !!process.stdin.isTTY && !!process.stdout.isTTY && !clack.isCI()
+
+/** The package manager this was run with (`npm create`, `pnpm create`, `yarn create`, `bun create`), npm when it cannot tell */
+export function packageManagerOf(agent = process.env.npm_config_user_agent ?? '') {
+	const name = agent.split('/')[0]
+	return PACKAGE_MANAGERS.includes(name) ? name : 'npm'
+}
+
+/** `createProject`'s options and what is done once it is made, from the flags alone: the defaults for what they do not say */
+export function decide(folder, flags) {
+	const where = resolve(folder ?? DEFAULT_FOLDER)
+	return {
+		where,
+		starter: flags.starter ?? DEFAULT_STARTER,
+		title: flags.name ?? titleOf(where),
+		editor: flags.editor ?? true,
+		server: flags.server ?? 'single',
+		ratings: flags.ratings ?? false,
+		tests: flags.tests ?? true,
+		assets: assetsOf(flags.starter ?? DEFAULT_STARTER, flags.assets),
+		source: flags.source ?? false,
+		git: flags.git ?? !insideRepository(where),
+		install: flags.install ?? false,
+		packageManager: flags.packageManager ?? packageManagerOf()
+	}
+}
+
+/** `decide`'s options, asking for what the flags do not say. Nothing when the person stops (Ctrl+C, Escape) */
+async function askFor(folder, flags, prompts) {
+	prompts.intro(`V12 ${own.version}: a game to start from`)
+	const answer = async (asked) => {
+		const value = await asked
+		if (prompts.isCancel(value)) throw CANCELLED
+		return value
+	}
+	try {
+		folder ??= await answer(
+			prompts.text({
+				message: 'Where should it be made?',
+				placeholder: DEFAULT_FOLDER,
+				defaultValue: DEFAULT_FOLDER,
+				validate: (value) => (value && notEmpty(resolve(value)) ? `${value} is not empty: a new folder, or an empty one` : undefined)
+			})
+		)
+		const starter =
+			flags.starter ??
+			(await answer(
+				prompts.select({
+					message: 'Which game should it start from?',
+					initialValue: DEFAULT_STARTER,
+					options: starters.map((starter) => ({ value: starter.name, label: starter.title, hint: starter.summary }))
+				})
+			))
+		const suggested = titleOf(folder)
+		const title =
+			flags.name ??
+			(await answer(
+				prompts.text({
+					message: 'What is the game called? (players see it; you can change it later)',
+					placeholder: suggested,
+					defaultValue: suggested,
+					validate: (value) => (value ? titleProblem(value) : undefined)
+				})
+			))
+		// a starter that cannot be made without the shared art has it, and is not asked
+		const needed = starterNamed(starter).needs?.includes('assets')
+		const parts = { editor: flags.editor, tests: flags.tests, assets: needed ? assetsOf(starter, flags.assets) : flags.assets }
+		const unsaid = Object.keys(PARTS).filter((part) => parts[part] === undefined)
+		if (unsaid.length) {
+			const chosen = await answer(
+				prompts.multiselect({
+					message: 'What should it have? (space to choose, enter when done)',
+					options: unsaid.map((part) => ({ value: part, label: part, hint: PARTS[part] })),
+					initialValues: unsaid,
+					required: false
+				})
+			)
+			for (const part of unsaid) parts[part] = chosen.includes(part)
+		}
+		const server =
+			flags.server ??
+			(await answer(
+				prompts.select({
+					message: 'A server of the game?',
+					initialValue: 'single',
+					options: Object.entries(SERVER_KINDS).map(([kind, what]) => ({ value: kind, label: kind, hint: what }))
+				})
+			))
+		const ratings =
+			server === 'none'
+				? false
+				: (flags.ratings ?? (await answer(prompts.confirm({ message: 'Should the server keep a rating for each player?', initialValue: false }))))
+		const where = resolve(folder)
+		const packageManager = flags.packageManager ?? packageManagerOf()
+		const git =
+			flags.git ??
+			(insideRepository(where)
+				? false
+				: await answer(prompts.confirm({ message: 'Make it a git repository, with a first commit?', initialValue: true })))
+		const install =
+			flags.install ??
+			(await answer(prompts.confirm({ message: `Install its packages now (${commandsOf(packageManager).install})?`, initialValue: true })))
+		return {
+			where,
+			starter,
+			title,
+			editor: parts.editor,
+			server,
+			ratings,
+			tests: parts.tests,
+			assets: parts.assets,
+			source: flags.source ?? false,
+			git,
+			install,
+			packageManager
+		}
+	} catch (error) {
+		if (error !== CANCELLED) throw error
+		prompts.cancel('Nothing was made.')
+		return undefined
+	}
+}
+
+/**
+ * Whether a project has the shared art: as it was told, on when it was not; a starter that plays with it cannot be
+ * made without (an error that says so)
+ */
+function assetsOf(starter, asked) {
+	if (asked === false && starterNamed(starter).needs?.includes('assets'))
+		throw new InvalidArgumentError(`the ${starter} starter plays with the shared art (@v12-engine/assets): --no-assets cannot go with it`)
+	return asked ?? true
+}
+
+/** What a question that was cancelled throws, to stop asking */
+const CANCELLED = Symbol('cancelled')
+
+/**
+ * Whether a command is run through a shell: on Windows the package managers are `.cmd` files, which need one; git is
+ * an executable, and a shell would split its commit message at the spaces
+ */
+export const needsShell = (command, platform = process.platform) => platform === 'win32' && command !== 'git'
+
+/** Runs a command in a folder: its output shown (`shown`) or kept back. Throws when it fails */
+function execIn(command, args, cwd, shown = false) {
+	return execFileSync(command, args, { cwd, stdio: shown ? 'inherit' : 'pipe', encoding: 'utf8', shell: needsShell(command) })
+}
+
+/** Whether a folder (or where it will be) is in a git repository already: a project there is not made one of its own */
+function insideRepository(where, exec = execIn) {
+	let folder = where
+	while (!existsSync(folder)) folder = dirname(folder)
+	try {
+		return exec('git', ['rev-parse', '--is-inside-work-tree'], folder).trim() === 'true'
+	} catch {
+		return false
+	}
+}
+
+/**
+ * Makes the project a repository with a first commit of everything. False, and said, where git is not there; a
+ * repository with nothing committed where git does not know who commits (its `user.name` and `user.email`)
+ */
+function makeRepository(where, { exec, say, warn }) {
+	try {
+		exec('git', ['init', '--quiet'], where)
+	} catch {
+		warn('git is not there: the project is not a repository')
+		return false
+	}
+	try {
+		exec('git', ['add', '-A'], where)
+		exec('git', ['commit', '--quiet', '-m', 'A game to start from, made with npm create @v12-engine'], where)
+		say('A git repository, with a first commit')
+	} catch {
+		warn('A git repository, with nothing committed: git does not know who you are yet (git config user.name, user.email)')
+	}
+	return true
+}