@v12-engine/create 0.1.1 → 0.4.0

package/starters/examples/src/examples/dialogs/index.ts

@@ -0,0 +1,383 @@
+/**
+ * The dialogue examples on the rules' side: their list entries, maps and starts, and what the rules say. A line the
+ * rules say (`world.dialog.say`, `talk` in a sequence) is heard by every screen at the same moment and kept in a save;
+ * its words are a message key the view has words for (`hud.messages`, in `./looks.ts`). Objectives (`world.objectives`)
+ * are the quest log; messages (`world.message`) the line of news over the console. A choice asked in a cinematic comes
+ * back to the rules as a command of the player's (`cinematicChoice`), so the story branches the same everywhere
+ */
+import {
+	cinematicChoice,
+	defineCommand,
+	defineComponent,
+	defineIds,
+	defineSequence,
+	entityDied,
+	exactMath,
+	type Game,
+	grantXp,
+	type LineDef,
+	oneOf,
+	talk,
+	type UnitTypeDef,
+	wait,
+	type World
+} from '@v12-engine/engine'
+import { CINE } from '../cinematics/index'
+import { ROAD_END, SQUARE, villageMap } from '../cinematics/village'
+import { ENEMY, PLAYER, UNIT } from '../common/units'
+import type { ExampleCategory } from '../define'
+
+/** The dialogue examples' own unit types: the village's elder, and a villager who has things to say */
+export const TALK = defineIds('dialogs.elder', 'dialogs.villager')
+
+const units: UnitTypeDef[] = [
+	{
+		id: TALK['dialogs.elder'],
+		name: 'Elder Maren',
+		kind: 'unit',
+		radius: 0.42,
+		stats: { health: 300, moveSpeed: 2.4 },
+		sight: 9
+	},
+	{
+		id: TALK['dialogs.villager'],
+		name: 'Villager',
+		kind: 'unit',
+		radius: 0.4,
+		stats: { health: 150, moveSpeed: 2.8 },
+		sight: 8
+	}
+]
+
+/** What each example's map is called: its rules tell their own world by it (`world.map.name`) */
+export const MAPS = { conversation: 'Hearth', choice: 'Toll', quest: 'Quest', barks: 'Market', messages: 'News', ownBox: 'Parchment' } as const
+
+/** The speakers, by the ids the rules say lines with; their names and faces are the view's (`cinematics.speakers`) */
+export const SPEAKER = { knight: 'dialogs.knight', elder: 'dialogs.elder', bandit: 'dialogs.bandit' } as const
+
+/** The cinematic of the toll (the view's, by this id), and what its question is called */
+export const TOLL_CINEMATIC = 'dialogs.toll'
+export const TOLL_QUESTION = 'toll'
+
+/** Where the elder stands, by the fire */
+export const ELDER_AT = { x: SQUARE.x + 1.6, z: SQUARE.z + 0.8 }
+
+// ---- Two talking
+
+/** The conversation at the fire: a line each in turn, each said by a unit (its face in the box, talking) */
+const conversationLines: LineDef[] = [
+	{ speaker: SPEAKER.elder, unit: 'elder', text: 'dialogsTalk1', seconds: 4.5 },
+	{ speaker: SPEAKER.knight, unit: 'hero', text: 'dialogsTalk2', seconds: 3.5 },
+	{ speaker: SPEAKER.elder, unit: 'elder', text: 'dialogsTalk3', seconds: 5, emotion: 'worried' },
+	{ speaker: SPEAKER.knight, unit: 'hero', text: 'dialogsTalk4', seconds: 3.5 },
+	{ speaker: SPEAKER.elder, unit: 'elder', text: 'dialogsTalk5', seconds: 4 }
+]
+const conversation = defineSequence({ id: 'dialogs.conversation', steps: [...talk(PLAYER, conversationLines)] })
+
+/** Starts the conversation: what the Talk button sends */
+export const converse = defineCommand('dialogs.converse', {}, (world) => void world.sequences.start(conversation))
+
+// ---- A choice that matters
+
+/**
+ * What the player chose at the toll, heard by the rules as the command the cinematic sent: they pay (the bandits
+ * take the gold and go), fight (the bandits attack), or talk them round (the bandits join the player)
+ */
+function answerToll(world: World, choice: string): void {
+	const bandits = world.find({ owner: ENEMY }).filter((unit) => unit.alive)
+	const hero = world.named('hero')
+	if (choice === 'pay') {
+		world.message(PLAYER, 'dialogsPaid', 'info')
+		for (const bandit of bandits) bandit.order('move', { x: bandit.pos.x + (bandit.pos.x < 24 ? -14 : 14), z: bandit.pos.z + 10 })
+		world.sequences.start(banditsLeave)
+	} else if (choice === 'fight') {
+		world.message(PLAYER, 'dialogsFight', 'error')
+		if (hero) for (const bandit of bandits) bandit.order('attack', hero)
+		if (hero && bandits[0]) hero.order('attack', bandits[0])
+	} else {
+		world.message(PLAYER, 'dialogsJoined', 'hint')
+		for (const bandit of bandits) {
+			world.setOwner(bandit, PLAYER)
+			if (hero) bandit.order('move', { x: hero.pos.x + (bandit.pos.x - 24) * 0.5, z: hero.pos.z - 1.5 })
+		}
+	}
+}
+
+/** The paid bandits gone into the woods a few seconds later */
+const banditsLeave = defineSequence({
+	id: 'dialogs.banditsLeave',
+	steps: [
+		wait(4),
+		(world) => {
+			for (const bandit of world.find({ owner: ENEMY })) if (bandit.alive) world.kill(bandit, undefined, false, 'removed')
+		}
+	]
+})
+
+/** The toll laid out again: the knight on the road, three bandits across it, out of reach of each other's eyes (9 cells) */
+function toll(world: World): void {
+	world.spawn(UNIT.knight, { at: { x: ROAD_END.x, z: ROAD_END.z + 5 }, owner: PLAYER, facing: 0, name: 'hero' })
+	const across = [-2, 0, 2]
+	across.forEach((dx, i) =>
+		world.spawn(CINE['cinematics.raider'], {
+			at: { x: ROAD_END.x + dx, z: ROAD_END.z + 14.5 + Math.abs(dx) * 0.4 },
+			owner: ENEMY,
+			facing: Math.PI,
+			name: `bandit${i + 1}`
+		})
+	)
+}
+
+/** Takes every unit away and lays the toll out again */
+export const resetToll = defineCommand('dialogs.resetToll', {}, (world) => {
+	for (const unit of [...world.units.values()]) if (unit.alive) world.kill(unit, undefined, false, 'removed')
+	toll(world)
+})
+
+// ---- A quest giver
+
+/** The quest's objectives (the quest log) */
+const QUEST = {
+	bandits: { id: 'dialogs.bandits', text: 'dialogsQuestBandits', detail: 'dialogsQuestBanditsDetail' },
+	back: { id: 'dialogs.back', text: 'dialogsQuestBack' }
+}
+const QUEST_BANDITS = 3
+/** How near the elder the knight stands to talk to her */
+const TALK_RANGE = 3.2
+
+/** Where the quest stands: not given, given (the bandits to kill), done (back to the elder), rewarded */
+const questState = defineComponent<{ stage: 'none' | 'given' | 'killed' | 'rewarded'; killed: number }>({
+	id: 'dialogs.quest',
+	default: () => ({ stage: 'none', killed: 0 })
+})
+
+/** The elder gives the quest: lines, then the objective in the log */
+const giveQuest = defineSequence({
+	id: 'dialogs.giveQuest',
+	steps: [
+		...talk(PLAYER, [
+			{ speaker: SPEAKER.elder, unit: 'elder', text: 'dialogsQuest1', seconds: 4.5 },
+			{ speaker: SPEAKER.knight, unit: 'hero', text: 'dialogsQuest2', seconds: 3 },
+			{ speaker: SPEAKER.elder, unit: 'elder', text: 'dialogsQuest3', seconds: 4 }
+		]),
+		(world) => {
+			// the client says "New objective" by itself as one is given
+			world.objectives.add(PLAYER, { ...QUEST.bandits, required: false }, { progress: { value: 0, max: QUEST_BANDITS } })
+		}
+	]
+})
+
+/** The elder thanks the knight and rewards him: experience, and his health back */
+const rewardQuest = defineSequence({
+	id: 'dialogs.rewardQuest',
+	steps: [
+		...talk(PLAYER, [
+			{ speaker: SPEAKER.elder, unit: 'elder', text: 'dialogsQuest4', seconds: 4 },
+			{ speaker: SPEAKER.knight, unit: 'hero', text: 'dialogsQuest5', seconds: 3 }
+		]),
+		(world) => {
+			world.objectives.complete(PLAYER, QUEST.back.id)
+			const hero = world.named('hero')
+			if (hero?.alive) {
+				grantXp(world, hero, 500)
+				hero.health = hero.maxHealth
+			}
+			world.message(PLAYER, 'dialogsQuestReward', 'info')
+		}
+	]
+})
+
+/** The quest's turns: the knight comes to the elder to be given it, and back to be rewarded */
+const questGiver = {
+	name: 'dialogs.questGiver',
+	every: 3,
+	update(world: World) {
+		if (world.map.name !== MAPS.quest) return
+		const hero = world.named('hero')
+		const elder = world.named('elder')
+		if (!hero?.alive || !elder?.alive) return
+		const near = exactMath.hypot(hero.pos.x - elder.pos.x, hero.pos.z - elder.pos.z) <= TALK_RANGE
+		const state = world.state(questState)
+		if (near && state.stage === 'none') {
+			world.setState(questState, { ...state, stage: 'given' })
+			hero.order('stop')
+			world.sequences.start(giveQuest)
+		} else if (near && state.stage === 'killed') {
+			world.setState(questState, { ...state, stage: 'rewarded' })
+			hero.order('stop')
+			world.sequences.start(rewardQuest)
+		}
+	}
+}
+
+/** A bandit of the quest fell: one more on the objective, and when all are down, back to the elder */
+function banditFell(world: World, unit: { owner: number; def: { id: string } }): void {
+	if (world.map.name !== MAPS.quest || unit.owner !== ENEMY) return
+	const state = world.state(questState)
+	if (state.stage !== 'given') return
+	const killed = state.killed + 1
+	world.objectives.progress(PLAYER, QUEST.bandits.id, killed)
+	if (killed < QUEST_BANDITS) return world.setState(questState, { ...state, killed })
+	world.setState(questState, { stage: 'killed', killed })
+	world.objectives.complete(PLAYER, QUEST.bandits.id)
+	world.objectives.add(PLAYER, { ...QUEST.back, required: false })
+	world.dialog.say(PLAYER, { speaker: SPEAKER.knight, unit: 'hero', text: 'dialogsQuestBackLine', seconds: 3 })
+}
+
+/** The quest's village: the elder at the fire, the knight on the road, three bandits in the east woods */
+function questVillage(world: World): void {
+	world.spawn(TALK['dialogs.elder'], { at: ELDER_AT, owner: PLAYER, facing: Math.PI, name: 'elder' })
+	world.spawn(UNIT.knight, { at: { x: ROAD_END.x, z: ROAD_END.z + 8 }, owner: PLAYER, facing: 0, name: 'hero' })
+	const camp = [
+		[38, 29],
+		[39.5, 31],
+		[37.5, 32.5]
+	]
+	for (const [x, z] of camp) world.spawn(CINE['cinematics.raider'], { at: { x, z }, owner: ENEMY, facing: -Math.PI / 2 })
+}
+
+// ---- Barks
+
+/** The market's people, milling about: the client has them say things over their heads */
+function market(world: World): void {
+	const spots = [
+		[20, 26.5],
+		[21.5, 29],
+		[27, 24],
+		[28.5, 27.5],
+		[24, 30.5],
+		[25.5, 22]
+	]
+	for (const [x, z] of spots)
+		world.spawn(TALK['dialogs.villager'], { at: { x, z }, owner: PLAYER, facing: exactMath.atan2(SQUARE.x - x, SQUARE.z - z) })
+	world.spawn(UNIT.footman, { at: { x: 22, z: 21 }, owner: PLAYER, facing: 0, name: 'guard' })
+	world.spawn(UNIT.footman, { at: { x: 26, z: 21 }, owner: PLAYER, facing: 0 })
+}
+
+/** Sends the villagers wandering a little: a few steps each, somewhere round the square */
+export const wander = defineCommand('dialogs.wander', {}, (world) => {
+	let n = world.tick
+	for (const unit of world.find({ type: TALK['dialogs.villager'] })) {
+		if (!unit.alive) continue
+		n = (n * 1103515245 + 12345) % 2147483648
+		const angle = (n / 2147483648) * Math.PI * 2
+		const away = 2.5 + (n % 5)
+		unit.order('move', { x: SQUARE.x + exactMath.cos(angle) * away, z: SQUARE.z + exactMath.sin(angle) * away })
+	}
+})
+
+// ---- Messages
+
+/** Each kind of news the rules can tell the player, sent from the example's buttons */
+export const news = defineCommand(
+	'dialogs.news',
+	{ kind: oneOf('info', 'hint', 'error', 'objective', 'done', 'line') },
+	(world, _player, { kind }) => {
+		if (kind === 'info' || kind === 'hint' || kind === 'error') return world.message(PLAYER, `dialogsNews_${kind}`, kind)
+		if (kind === 'objective') {
+			if (!world.objectives.has(PLAYER, 'dialogs.news'))
+				world.objectives.add(PLAYER, { id: 'dialogs.news', text: 'dialogsNewsObjective', required: false })
+			return
+		}
+		if (kind === 'done') {
+			if (world.objectives.has(PLAYER, 'dialogs.news')) world.objectives.complete(PLAYER, 'dialogs.news')
+			return
+		}
+		world.dialog.say(PLAYER, { speaker: SPEAKER.elder, unit: 'elder', text: 'dialogsNewsLine', seconds: 4 })
+	}
+)
+
+/** The elder and the knight at the fire, facing each other */
+function hearth(world: World): void {
+	world.spawn(TALK['dialogs.elder'], { at: ELDER_AT, owner: PLAYER, facing: -Math.PI / 2, name: 'elder' })
+	world.spawn(UNIT.knight, { at: { x: SQUARE.x - 1.6, z: SQUARE.z + 0.8 }, owner: PLAYER, facing: Math.PI / 2, name: 'hero' })
+}
+
+export const category: ExampleCategory = {
+	rules: (game: Game<any>) => {
+		for (const unit of units) game.unit(unit)
+		game.component(questState)
+		game.sequence(conversation)
+		game.sequence(banditsLeave)
+		game.sequence(giveQuest)
+		game.sequence(rewardQuest)
+		game.system(questGiver)
+		game.command(converse)
+		game.command(resetToll)
+		game.command(wander)
+		game.command(news)
+		// the toll's answer, as the cinematic sent it: only the toll's question of the toll's cinematic
+		game.on(cinematicChoice, (world, { cinematic, question, choice }) => {
+			if (cinematic === TOLL_CINEMATIC && question === TOLL_QUESTION) answerToll(world, choice)
+		})
+		game.on(entityDied, (world, { entity, reason }) => reason !== 'removed' && banditFell(world, entity))
+	},
+	examples: [
+		{
+			id: 'dialogs-conversation',
+			category: 'dialogs',
+			title: 'Two talking',
+			summary:
+				'The knight and the elder talk at the fire, each line with the speaker’s face. Press Talk, then move the box, switch to subtitles or a typewriter, and talk again.',
+			tags: ['dialog', 'portrait', 'face', 'talk', 'lines', 'speaker', 'subtitles', 'typewriter', 'setDialogLook'],
+			map: () => villageMap(MAPS.conversation, 1),
+			start: (world) => hearth(world),
+			source: ['examples/dialogs/index.ts', 'examples/dialogs/looks.ts']
+		},
+		{
+			id: 'dialogs-choice',
+			category: 'dialogs',
+			title: 'A choice that matters',
+			summary:
+				'Bandits block the road and ask a toll. Pay, fight or talk them round: the answer goes to the rules, and the bandits leave, attack or join you.',
+			tags: ['choice', 'branch', 'choose', 'cinematicChoice', 'story', 'options', 'conversation'],
+			map: () => villageMap(MAPS.choice),
+			start: (world) => toll(world),
+			source: ['examples/dialogs/index.ts', 'examples/dialogs/looks.ts']
+		},
+		{
+			id: 'dialogs-quest',
+			category: 'dialogs',
+			title: 'A quest giver',
+			summary:
+				'Walk the knight to the elder (the ! by the fire): she asks him to clear the bandits in the east woods. The quest log counts them; go back to her for the reward.',
+			tags: ['quest', 'objective', 'reward', 'npc', 'quest log', 'progress', 'experience', 'talk'],
+			map: () => villageMap(MAPS.quest),
+			start: (world) => questVillage(world),
+			source: ['examples/dialogs/index.ts', 'examples/dialogs/looks.ts']
+		},
+		{
+			id: 'dialogs-barks',
+			category: 'dialogs',
+			title: 'Barks and speech bubbles',
+			summary:
+				'The market chatters: people say things in bubbles over their heads. Click one and it answers; order the guard about and he acknowledges. Bubbles or floating words.',
+			tags: ['bark', 'speech bubble', 'chatter', 'npc', 'acknowledge', 'floating text', 'attach'],
+			map: () => villageMap(MAPS.barks, 1),
+			start: (world) => market(world),
+			source: ['examples/dialogs/index.ts', 'examples/dialogs/looks.ts']
+		},
+		{
+			id: 'dialogs-messages',
+			category: 'dialogs',
+			title: 'Messages, alerts and pings',
+			summary:
+				'Every way the game tells the player something: messages of three kinds, an objective given and done, a line, an alert, a ping on the map and words floating up.',
+			tags: ['message', 'alert', 'notification', 'ping', 'objective', 'floating text', 'toast', 'news'],
+			map: () => villageMap(MAPS.messages, 1),
+			start: (world) => hearth(world),
+			source: ['examples/dialogs/index.ts', 'examples/dialogs/looks.ts']
+		},
+		{
+			id: 'dialogs-own-box',
+			category: 'dialogs',
+			title: 'A dialog box of your own',
+			summary:
+				'The same conversation in a box and a choice menu drawn by the game itself: a parchment scroll that types the words out, and wax-seal answers.',
+			tags: ['dialog box', 'custom', 'mount', 'DialogLook', 'ChoiceLook', 'typewriter', 'style'],
+			map: () => villageMap(MAPS.ownBox, 1),
+			start: (world) => hearth(world),
+			source: ['examples/dialogs/index.ts', 'examples/dialogs/looks.ts']
+		}
+	]
+}