2317 lines
78 KiB
TypeScript
2317 lines
78 KiB
TypeScript
/**
|
|
* Unit & Parity Tests for Keyboard Conflict Resolution & Hotkey Harmonization (Requirement R1 / R5)
|
|
* Verifies ghost interaction decoupling, combat safety, and potion drinking invariants.
|
|
*/
|
|
|
|
import * as fs from 'node:fs'
|
|
import * as path from 'node:path'
|
|
import { describe, expect, it } from 'vitest'
|
|
import { KeyboardInput } from '../src/sim/input.ts'
|
|
import { HudManager } from '../src/ui/hud-manager.ts'
|
|
import { GameEngine, type GameEngineOptions, type WorldMapProvider } from '../src/game/engine.ts'
|
|
import { ViewportCamera } from '../src/sim/camera.ts'
|
|
import { WaypointNetwork } from '../src/game/portal.ts'
|
|
import type { SceneEntrance, SceneWarp } from '../src/game/level-links.ts'
|
|
import { subTileToScene } from '../src/scene/transition.ts'
|
|
import { getLevelNames } from '../src/game/level-names-zh.ts'
|
|
import {
|
|
SceneMouseController,
|
|
screenToWorld,
|
|
facingOf,
|
|
PASSIVE_SKILL_IDS,
|
|
isPassiveSkill,
|
|
getSkillRange,
|
|
getSkillMana,
|
|
TELEKINESIS_RANGE_PX,
|
|
getWarpLabelWorldPos,
|
|
getEntranceLabelWorldPos,
|
|
hitTestWarp,
|
|
hitTestEntrance,
|
|
isPlayerWithinLinkRange,
|
|
resolveObstacleAwareSteerTarget,
|
|
sceneToSubTile,
|
|
type MapRuntime,
|
|
} from '../src/scene/act-scene.ts'
|
|
|
|
class MockWindow extends EventTarget {
|
|
innerWidth = 1920
|
|
innerHeight = 1080
|
|
devicePixelRatio = 1
|
|
}
|
|
|
|
class MockCanvas extends EventTarget {
|
|
clientWidth = 1920
|
|
clientHeight = 1080
|
|
width = 1920
|
|
height = 1080
|
|
style = { pointerEvents: 'none', cursor: '' }
|
|
getBoundingClientRect() {
|
|
return { left: 0, top: 0, width: 1920, height: 1080 }
|
|
}
|
|
getContext() {
|
|
return null
|
|
}
|
|
}
|
|
|
|
class SyntheticKeyboardEvent extends Event {
|
|
readonly code: string
|
|
readonly key: string
|
|
|
|
constructor(type: string, init: { code: string; key: string }) {
|
|
super(type, { cancelable: true })
|
|
this.code = init.code
|
|
this.key = init.key
|
|
}
|
|
}
|
|
|
|
class SyntheticPointerEvent extends Event {
|
|
readonly clientX: number
|
|
readonly clientY: number
|
|
readonly button: number
|
|
readonly buttons: number
|
|
readonly shiftKey: boolean
|
|
private _defaultPrevented = false
|
|
|
|
constructor(type: string, init: { clientX: number; clientY: number; button?: number; buttons?: number; shiftKey?: boolean; cancelable?: boolean }) {
|
|
super(type, { cancelable: init.cancelable ?? true })
|
|
this.clientX = init.clientX
|
|
this.clientY = init.clientY
|
|
this.button = init.button ?? 0
|
|
this.buttons = init.buttons !== undefined ? init.buttons : (1 << (init.button ?? 0))
|
|
this.shiftKey = init.shiftKey ?? false
|
|
}
|
|
|
|
override get defaultPrevented(): boolean {
|
|
return this._defaultPrevented
|
|
}
|
|
|
|
override preventDefault() {
|
|
super.preventDefault()
|
|
this._defaultPrevented = true
|
|
}
|
|
}
|
|
|
|
// Global DOM shims for HudManager
|
|
const mockWin = new MockWindow()
|
|
// @ts-ignore
|
|
globalThis.window = mockWin
|
|
// @ts-ignore
|
|
globalThis.HTMLInputElement = class HTMLInputElement {}
|
|
// @ts-ignore
|
|
globalThis.HTMLSelectElement = class HTMLSelectElement {}
|
|
|
|
describe('Milestone 1: Keyboard Conflict Resolution & Hotkey Harmonization (R1)', () => {
|
|
it('decouples KeyT from input.talking to eliminate ghost NPC interactions', () => {
|
|
const win = new MockWindow()
|
|
const input = new KeyboardInput(win as unknown as Window)
|
|
input.attach()
|
|
|
|
expect(input.talking).toBe(false)
|
|
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'KeyT', key: 't' }))
|
|
expect(input.talking).toBe(false)
|
|
|
|
// Held across multiple frames/ticks
|
|
for (let i = 0; i < 25; i++) {
|
|
expect(input.talking).toBe(false)
|
|
}
|
|
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keyup', { code: 'KeyT', key: 't' }))
|
|
expect(input.talking).toBe(false)
|
|
})
|
|
|
|
it('decouples KeyB from input.takeWaypoint() to eliminate ghost waypoint travel', () => {
|
|
const win = new MockWindow()
|
|
const input = new KeyboardInput(win as unknown as Window)
|
|
input.attach()
|
|
|
|
expect(input.takeWaypoint()).toBe(false)
|
|
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'KeyB', key: 'b' }))
|
|
expect(input.takeWaypoint()).toBe(false)
|
|
|
|
for (let i = 0; i < 25; i++) {
|
|
expect(input.takeWaypoint()).toBe(false)
|
|
}
|
|
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keyup', { code: 'KeyB', key: 'b' }))
|
|
expect(input.takeWaypoint()).toBe(false)
|
|
})
|
|
|
|
it('removes Space from ATTACK_KEYS so Space never triggers combat swings or skill casts', () => {
|
|
const win = new MockWindow()
|
|
const input = new KeyboardInput(win as unknown as Window)
|
|
input.attach()
|
|
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'Space', key: ' ' }))
|
|
expect(input.attacking).toBe(false)
|
|
|
|
// Legitimate attack keys still work
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'KeyJ', key: 'j' }))
|
|
expect(input.attacking).toBe(true)
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keyup', { code: 'KeyJ', key: 'j' }))
|
|
expect(input.attacking).toBe(false)
|
|
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'Enter', key: 'Enter' }))
|
|
expect(input.attacking).toBe(true)
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keyup', { code: 'Enter', key: 'Enter' }))
|
|
expect(input.attacking).toBe(false)
|
|
})
|
|
|
|
it('verifies Space in GameEngine does not damage monsters or trigger combat hits', () => {
|
|
const dummyTerrain: WorldMapProvider = { widthPx: 1000, heightPx: 1000, overlap: () => 0 }
|
|
const dummyOpts: GameEngineOptions = {
|
|
spawn: { x: 100, y: 100 },
|
|
stats: [{ id: 'mon1', name: 'Zombie', hp: 100, damage: 0, cooldownTicks: 100, reach: 20, aggroRadius: 100, speed: 0, xp: 5 }],
|
|
xpTable: [0, 0, 10, 30, 60],
|
|
itemBases: [],
|
|
prefixAffixes: [],
|
|
suffixAffixes: [],
|
|
skills: [{ id: 'attack', name: 'Attack', manaCost: 0, cooldownTicks: 1, range: 48, projectile: false, speed: 0, baseMinDamage: 10, baseMaxDamage: 15, damagePerLevel: 1, radius: 20 }],
|
|
npcDefs: [],
|
|
questDefs: [],
|
|
combatOptions: { playerSpeed: 100, playerReach: 50, playerCooldownTicks: 1, playerDamage: 10, playerManaPerAttack: 0, respawnTicks: 100 },
|
|
lootSeed: 12345,
|
|
talkRadius: 50,
|
|
pickupRadius: 50,
|
|
inventoryCols: 10,
|
|
inventoryRows: 4,
|
|
}
|
|
|
|
const engine = new GameEngine(dummyTerrain, dummyOpts)
|
|
engine.world.monsters[0]!.x = 110
|
|
engine.world.monsters[0]!.y = 100
|
|
const startHp = engine.world.monsters[0]!.hp
|
|
const startHits = engine.metrics.playerHits
|
|
|
|
const win = new MockWindow()
|
|
const input = new KeyboardInput(win as unknown as Window)
|
|
input.attach()
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'Space', key: ' ' }))
|
|
|
|
for (let i = 0; i < 30; i++) {
|
|
engine.tick({
|
|
movement: input.movement(),
|
|
attacking: input.attacking,
|
|
pickingUp: input.pickingUp,
|
|
talking: input.talking,
|
|
digits: input.digits,
|
|
saving: input.saving,
|
|
loading: input.loading,
|
|
})
|
|
}
|
|
|
|
expect(engine.world.monsters[0]!.hp).toBe(startHp)
|
|
expect(engine.metrics.playerHits).toBe(startHits)
|
|
})
|
|
|
|
it('harmonizes Space with Escape to close open HUD panels', () => {
|
|
const canvas = new MockCanvas() as unknown as HTMLCanvasElement
|
|
const hud = new HudManager(canvas, {
|
|
onToggleAutomap: () => {},
|
|
onWaypointTeleport: () => {},
|
|
})
|
|
hud['bindEvents']()
|
|
|
|
// Character Sheet toggle and Space dismiss
|
|
hud.toggleLeftPanel('char')
|
|
expect(hud.leftPanel).toBe('char')
|
|
mockWin.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'Space', key: ' ' }))
|
|
expect(hud.leftPanel).toBe('none')
|
|
|
|
// Skill Tree toggle and Space dismiss
|
|
hud.toggleRightPanel('skill')
|
|
expect(hud.rightPanel).toBe('skill')
|
|
mockWin.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'Space', key: ' ' }))
|
|
expect(hud.rightPanel).toBe('none')
|
|
|
|
// Inventory toggle and Space dismiss
|
|
hud.toggleRightPanel('inv')
|
|
expect(hud.rightPanel).toBe('inv')
|
|
mockWin.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'Space', key: ' ' }))
|
|
expect(hud.rightPanel).toBe('none')
|
|
})
|
|
|
|
it('drinks belt potions from columns 0..3 via keys 1..4 without resetting active skills', () => {
|
|
const canvas = new MockCanvas() as unknown as HTMLCanvasElement
|
|
const hud = new HudManager(canvas, {
|
|
onToggleAutomap: () => {},
|
|
onWaypointTeleport: () => {},
|
|
})
|
|
hud['bindEvents']()
|
|
|
|
hud.hotkeys.leftSkillId = 47 // Fire Ball
|
|
hud.hotkeys.rightSkillId = 64 // Frozen Orb
|
|
hud.syncPublishedState()
|
|
hud.hp = 400
|
|
hud.mana = 200
|
|
|
|
expect(hud.belt.countTotalPotions()).toBe(16)
|
|
|
|
// Press '1' -> drinks column 0 (hp potion, healHp 180)
|
|
mockWin.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'Digit1', key: '1' }))
|
|
expect(hud.hp).toBe(400 + 180)
|
|
expect(hud.hotkeys.leftSkillId).toBe(47)
|
|
expect(hud.hotkeys.rightSkillId).toBe(64)
|
|
expect(hud.state.leftSkillId).toBe(47)
|
|
expect(hud.state.rightSkillId).toBe(64)
|
|
expect(hud.belt.countTotalPotions()).toBe(15)
|
|
|
|
// Press '2' -> drinks column 1 (hp potion, healHp 320)
|
|
mockWin.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'Digit2', key: '2' }))
|
|
expect(hud.hp).toBe(580 + 320)
|
|
expect(hud.hotkeys.leftSkillId).toBe(47)
|
|
expect(hud.hotkeys.rightSkillId).toBe(64)
|
|
expect(hud.belt.countTotalPotions()).toBe(14)
|
|
|
|
// Press '3' -> drinks column 2 (mana potion, healMana 150)
|
|
mockWin.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'Digit3', key: '3' }))
|
|
expect(hud.mana).toBe(200 + 150)
|
|
expect(hud.hotkeys.leftSkillId).toBe(47)
|
|
expect(hud.hotkeys.rightSkillId).toBe(64)
|
|
expect(hud.belt.countTotalPotions()).toBe(13)
|
|
|
|
// Press '4' -> drinks column 3 (rejuv potion, healHp 400, healMana 400)
|
|
mockWin.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'Digit4', key: '4' }))
|
|
expect(hud.hp).toBe(900 + 400 > hud.maxHp ? hud.maxHp : 1300)
|
|
expect(hud.mana).toBe(350 + 400)
|
|
expect(hud.hotkeys.leftSkillId).toBe(47)
|
|
expect(hud.hotkeys.rightSkillId).toBe(64)
|
|
expect(hud.belt.countTotalPotions()).toBe(12)
|
|
})
|
|
|
|
it('isolates WASD keys from movement Contribution', () => {
|
|
const win = new MockWindow()
|
|
const input = new KeyboardInput(win as unknown as Window)
|
|
input.attach()
|
|
|
|
for (const code of ['KeyW', 'KeyA', 'KeyS', 'KeyD']) {
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code, key: code.slice(-1).toLowerCase() }))
|
|
expect(input.movement()).toEqual({ x: 0, y: 0 })
|
|
expect(input.active).toBe(false)
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keyup', { code, key: code.slice(-1).toLowerCase() }))
|
|
}
|
|
|
|
// Arrow keys still move
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'ArrowUp', key: 'ArrowUp' }))
|
|
expect(input.movement()).toEqual({ x: 0, y: -1 })
|
|
expect(input.active).toBe(true)
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keyup', { code: 'ArrowUp', key: 'ArrowUp' }))
|
|
expect(input.active).toBe(false)
|
|
})
|
|
|
|
it('tracks shiftHeld state for force stand still attack', () => {
|
|
const win = new MockWindow()
|
|
const input = new KeyboardInput(win as unknown as Window)
|
|
input.attach()
|
|
|
|
expect(input.shiftHeld).toBe(false)
|
|
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'ShiftLeft', key: 'Shift' }))
|
|
expect(input.shiftHeld).toBe(true)
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keyup', { code: 'ShiftLeft', key: 'Shift' }))
|
|
expect(input.shiftHeld).toBe(false)
|
|
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'ShiftRight', key: 'Shift' }))
|
|
expect(input.shiftHeld).toBe(true)
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keyup', { code: 'ShiftRight', key: 'Shift' }))
|
|
expect(input.shiftHeld).toBe(false)
|
|
})
|
|
})
|
|
|
|
function createTestScene(options?: {
|
|
playerPos?: { x: number; y: number }
|
|
mana?: number
|
|
leftSkillId?: number
|
|
rightSkillId?: number
|
|
npcs?: Array<{ id: number; name: string; x: number; y: number }>
|
|
waypoints?: Array<{ waypointId: number; x: number; y: number }>
|
|
warps?: SceneWarp[]
|
|
entrances?: SceneEntrance[]
|
|
portalSlot?: { mouthInLevel: (levelId: number) => { x: number; y: number } | null }
|
|
onEnterPortal?: () => void
|
|
onEnterWarp?: (warp: SceneWarp) => void
|
|
onEnterEntrance?: (entrance: SceneEntrance) => void
|
|
isTravelling?: () => boolean
|
|
labelsContainer?: HTMLElement | null
|
|
monsters?: Array<{ id: string; name: string; x: number; y: number; hp: number }>
|
|
blockedOverlap?: (x: number, y: number) => number
|
|
}) {
|
|
const canvas = new MockCanvas() as unknown as HTMLCanvasElement
|
|
const win = new MockWindow()
|
|
const input = new KeyboardInput(win as unknown as Window)
|
|
input.attach()
|
|
|
|
const dummyTerrain: WorldMapProvider = {
|
|
widthPx: 2000,
|
|
heightPx: 2000,
|
|
overlap: options?.blockedOverlap ?? (() => 0),
|
|
}
|
|
|
|
const dummyOpts: GameEngineOptions = {
|
|
spawn: options?.playerPos ?? { x: 500, y: 500 },
|
|
stats: (options?.monsters ?? []).map(m => ({
|
|
id: m.id,
|
|
name: m.name,
|
|
hp: m.hp,
|
|
damage: 10,
|
|
cooldownTicks: 100,
|
|
reach: 20,
|
|
aggroRadius: 100,
|
|
speed: 0,
|
|
xp: 10,
|
|
})),
|
|
xpTable: [0, 0, 10, 30, 60],
|
|
itemBases: [],
|
|
prefixAffixes: [],
|
|
suffixAffixes: [],
|
|
skills: [{ id: 'attack', name: 'Attack', manaCost: 0, cooldownTicks: 1, range: 48, projectile: false, speed: 0, baseMinDamage: 10, baseMaxDamage: 15, damagePerLevel: 1, radius: 20 }],
|
|
npcDefs: (options?.npcs ?? []).map(n => ({
|
|
id: `npc-${n.id}`,
|
|
name: n.name,
|
|
questId: null,
|
|
offerLines: ['Greetings, wanderer.'],
|
|
progressLines: [],
|
|
doneLines: [],
|
|
})),
|
|
questDefs: [],
|
|
combatOptions: { playerSpeed: 100, playerReach: 52, playerCooldownTicks: 1, playerDamage: 10, playerManaPerAttack: 0, respawnTicks: 100 },
|
|
lootSeed: 12345,
|
|
talkRadius: 80,
|
|
pickupRadius: 50,
|
|
inventoryCols: 10,
|
|
inventoryRows: 4,
|
|
}
|
|
|
|
const engine = new GameEngine(dummyTerrain, dummyOpts)
|
|
if (options?.monsters) {
|
|
for (let i = 0; i < options.monsters.length; i++) {
|
|
engine.world.monsters[i]!.x = options.monsters[i]!.x
|
|
engine.world.monsters[i]!.y = options.monsters[i]!.y
|
|
}
|
|
}
|
|
|
|
if (options?.npcs) {
|
|
for (const n of options.npcs) {
|
|
engine.npcEntities.push({
|
|
def: {
|
|
id: `npc-${n.id}`,
|
|
name: n.name,
|
|
questId: null,
|
|
offerLines: ['Greetings, wanderer.'],
|
|
progressLines: [],
|
|
doneLines: [],
|
|
},
|
|
x: n.x,
|
|
y: n.y,
|
|
hasSprite: false,
|
|
})
|
|
}
|
|
}
|
|
|
|
const camera = new ViewportCamera(canvas, 2000, 2000)
|
|
camera.zoom = 1
|
|
|
|
const hudManager = new HudManager(canvas, {
|
|
onToggleAutomap: () => {},
|
|
onWaypointTeleport: () => {},
|
|
})
|
|
hudManager.mana = options?.mana ?? 200
|
|
hudManager.hotkeys.leftSkillId = options?.leftSkillId ?? 0
|
|
hudManager.hotkeys.rightSkillId = options?.rightSkillId ?? 0
|
|
hudManager.syncPublishedState()
|
|
|
|
const waypointNetwork = new WaypointNetwork()
|
|
if (options?.waypoints) {
|
|
for (const wp of options.waypoints) {
|
|
waypointNetwork.register({
|
|
waypointId: wp.waypointId,
|
|
levelId: 1,
|
|
act: 1,
|
|
name: 'Test WP',
|
|
x: wp.x,
|
|
y: wp.y,
|
|
})
|
|
}
|
|
}
|
|
|
|
const gridWidth = 500
|
|
const blockedGrid = new Uint8Array(500 * 500)
|
|
const runtime: MapRuntime = {
|
|
source: 'pack',
|
|
base: 'samples/d2-packs',
|
|
act: 1,
|
|
level: 'Rogue Encampment',
|
|
levelId: 1,
|
|
variant: 'default',
|
|
variants: ['default'],
|
|
quadrant: 'default',
|
|
quadrants: ['default'],
|
|
cellsX: 100,
|
|
cellsY: 100,
|
|
widthPx: 2000,
|
|
heightPx: 2000,
|
|
floors: [],
|
|
walls: [],
|
|
roofs: [],
|
|
objectDrawables: [],
|
|
pages: [],
|
|
priorityPages: [],
|
|
objectPages: [],
|
|
grid: {
|
|
originX: 0,
|
|
originY: 0,
|
|
cellsX: 100,
|
|
cellsY: 100,
|
|
blocked: blockedGrid,
|
|
gridWidth,
|
|
},
|
|
npcs: (options?.npcs ?? []).map(n => ({
|
|
id: n.id,
|
|
type: 1,
|
|
name: n.name,
|
|
x: n.x,
|
|
y: n.y,
|
|
})),
|
|
entrances: options?.entrances ?? [],
|
|
warps: options?.warps ?? [],
|
|
waypoints: (options?.waypoints ?? []).map(wp => {
|
|
const dx = wp.x / 16
|
|
const dy = wp.y / 8
|
|
const subX = Math.round((dy + dx) / 2)
|
|
const subY = Math.round((dy - dx) / 2)
|
|
return {
|
|
source: 'placed' as const,
|
|
waypointId: wp.waypointId,
|
|
arriveX: subX,
|
|
arriveY: subY,
|
|
x: subX,
|
|
y: subY,
|
|
}
|
|
}),
|
|
animatedDrawables: [],
|
|
animSpeed: 1,
|
|
frameDurationMs: 40,
|
|
palette: null,
|
|
charBases: [],
|
|
monsterTypes: [],
|
|
monsterPacks: [],
|
|
entryPath: '',
|
|
loadPages: async () => {},
|
|
} as unknown as MapRuntime
|
|
|
|
const status = { textContent: '' } as HTMLElement
|
|
|
|
const controller = new SceneMouseController({
|
|
canvas,
|
|
engine,
|
|
camera,
|
|
input,
|
|
getRuntime: () => runtime,
|
|
hudManager,
|
|
waypointNetwork,
|
|
status,
|
|
portalSlot: options?.portalSlot as any,
|
|
onEnterPortal: options?.onEnterPortal,
|
|
onEnterWarp: options?.onEnterWarp,
|
|
onEnterEntrance: options?.onEnterEntrance,
|
|
isTravelling: options?.isTravelling,
|
|
labelsContainer: options?.labelsContainer,
|
|
})
|
|
controller.attach()
|
|
|
|
return {
|
|
canvas,
|
|
win,
|
|
input,
|
|
engine,
|
|
camera,
|
|
hudManager,
|
|
waypointNetwork,
|
|
runtime,
|
|
status,
|
|
controller,
|
|
}
|
|
}
|
|
|
|
describe('Milestone 2: Mouse Interaction, Click-to-Move, and Combat Controls (R2, R3, R4)', () => {
|
|
it('projects screen coordinates to world coordinates through inverse camera transform', () => {
|
|
const canvas = new MockCanvas() as unknown as HTMLCanvasElement
|
|
const rect = canvas.getBoundingClientRect()
|
|
const camX = 500
|
|
const camY = 484 // player.y - 16 = 500 - 16
|
|
|
|
// Center of screen (960, 540) maps exactly to (camX, camY) = (500, 484)
|
|
const center = screenToWorld({
|
|
clientX: 960,
|
|
clientY: 540,
|
|
rect,
|
|
canvas,
|
|
camX,
|
|
camY,
|
|
cameraZoom: 1,
|
|
})
|
|
expect(center.x).toBe(500)
|
|
expect(center.y).toBe(484)
|
|
|
|
// Offset +100px X, +50px Y at zoom 1
|
|
const offset = screenToWorld({
|
|
clientX: 1060,
|
|
clientY: 590,
|
|
rect,
|
|
canvas,
|
|
camX,
|
|
camY,
|
|
cameraZoom: 1,
|
|
})
|
|
expect(offset.x).toBe(600)
|
|
expect(offset.y).toBe(534)
|
|
|
|
// Offset at zoom 2
|
|
const offsetZoom2 = screenToWorld({
|
|
clientX: 1060,
|
|
clientY: 590,
|
|
rect,
|
|
canvas,
|
|
camX,
|
|
camY,
|
|
cameraZoom: 2,
|
|
})
|
|
expect(offsetZoom2.x).toBe(550)
|
|
expect(offsetZoom2.y).toBe(509)
|
|
})
|
|
|
|
it('computes 8-direction facing index with 0=South turning clockwise (D2 convention)', () => {
|
|
// 0 = South (dx=0, dy>0)
|
|
expect(facingOf(0, 1)).toBe(0)
|
|
// 1 = South-West (dx<0, dy>0)
|
|
expect(facingOf(-1, 1)).toBe(1)
|
|
// 2 = West (dx<0, dy=0)
|
|
expect(facingOf(-1, 0)).toBe(2)
|
|
// 3 = North-West (dx<0, dy<0)
|
|
expect(facingOf(-1, -1)).toBe(3)
|
|
// 4 = North (dx=0, dy<0)
|
|
expect(facingOf(0, -1)).toBe(4)
|
|
// 5 = North-East (dx>0, dy<0)
|
|
expect(facingOf(1, -1)).toBe(5)
|
|
// 6 = East (dx>0, dy=0)
|
|
expect(facingOf(1, 0)).toBe(6)
|
|
// 7 = South-East (dx>0, dy>0)
|
|
expect(facingOf(1, 1)).toBe(7)
|
|
})
|
|
|
|
it('R3: left-click on ground sets navTarget and generates movement towards target, stopping within 8px', () => {
|
|
const scene = createTestScene({ playerPos: { x: 500, y: 500 } })
|
|
|
|
// Click ground at +100px X, +0px Y (clientX = 960 + 100, clientY = 540)
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 1060,
|
|
clientY: 540,
|
|
button: 0,
|
|
}))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerup', {
|
|
clientX: 1060,
|
|
clientY: 540,
|
|
button: 0,
|
|
}))
|
|
|
|
expect(scene.controller.navTarget).toEqual({ x: 600, y: 484 })
|
|
|
|
// First tick produces movement vector pointing right towards (600, 484)
|
|
const tick1 = scene.controller.tick()
|
|
expect(tick1.movement.x).toBeGreaterThan(0)
|
|
|
|
// Move player closer to target (598, 484) - distance is 2px (< 8px arrival threshold)
|
|
scene.engine.world.player.x = 598
|
|
scene.engine.world.player.y = 484
|
|
|
|
const arrivalTick = scene.controller.tick()
|
|
expect(arrivalTick.movement).toEqual({ x: 0, y: 0 })
|
|
expect(scene.controller.navTarget).toBeNull()
|
|
})
|
|
|
|
it('R3: continuous left-click drag updates navTarget with cursor coordinates', () => {
|
|
const scene = createTestScene({ playerPos: { x: 500, y: 500 } })
|
|
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 1060,
|
|
clientY: 540,
|
|
button: 0,
|
|
buttons: 1,
|
|
}))
|
|
expect(scene.controller.navTarget).toEqual({ x: 600, y: 484 })
|
|
|
|
// Drag pointer to (1060, 640) -> world (600, 584)
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointermove', {
|
|
clientX: 1060,
|
|
clientY: 640,
|
|
button: 0,
|
|
buttons: 1,
|
|
}))
|
|
expect(scene.controller.navTarget).toEqual({ x: 600, y: 584 })
|
|
|
|
// pointerup releases hold
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerup', {
|
|
clientX: 1060,
|
|
clientY: 640,
|
|
button: 0,
|
|
buttons: 0,
|
|
}))
|
|
expect(scene.controller.isLeftMouseDown).toBe(false)
|
|
})
|
|
|
|
it('R4: left-click with Shift held executes force stand still attack without pathing', () => {
|
|
const scene = createTestScene({
|
|
playerPos: { x: 500, y: 500 },
|
|
leftSkillId: 47, // Fire Ball
|
|
mana: 100,
|
|
})
|
|
|
|
// Hold Shift via window keydown
|
|
scene.win.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'ShiftLeft', key: 'Shift' }))
|
|
expect(scene.input.shiftHeld).toBe(true)
|
|
|
|
// Left-click towards (600, 484)
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 1060,
|
|
clientY: 540,
|
|
button: 0,
|
|
shiftKey: true,
|
|
}))
|
|
|
|
// Movement must be strictly 0 (no pathing / stand still)
|
|
const tickResult = scene.controller.tick()
|
|
expect(tickResult.movement).toEqual({ x: 0, y: 0 })
|
|
expect(scene.controller.navTarget).toBeNull()
|
|
|
|
// Player faces cursor (East = 6)
|
|
expect(scene.engine.world.player.facing).toBe(6)
|
|
|
|
// Projectile spawned towards cursor
|
|
expect(scene.engine.projectiles.length).toBe(1)
|
|
expect(scene.engine.projectiles[0]!.skillId).toBe('47')
|
|
expect(scene.engine.projectiles[0]!.vx).toBeGreaterThan(0)
|
|
// Mana deducted (Fire Ball lv 8 costs 8.5)
|
|
expect(scene.hudManager.mana).toBe(100 - 8.5)
|
|
})
|
|
|
|
it('R3: left-click on NPC talks immediately if <= 80px, or paths and talks on arrival if > 80px', () => {
|
|
// NPC 1 is nearby (530, 500), distance 30px <= 80px
|
|
// NPC 2 is far away (750, 500), distance 250px > 80px
|
|
const scene = createTestScene({
|
|
playerPos: { x: 500, y: 500 },
|
|
npcs: [
|
|
{ id: 1, name: 'Akara', x: 530, y: 500 },
|
|
{ id: 2, name: 'Kashya', x: 750, y: 500 },
|
|
],
|
|
})
|
|
|
|
// 1. Click nearby NPC Akara (world 530, 500 -> clientX = 960 + 30 = 990, clientY = 540)
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 990,
|
|
clientY: 540,
|
|
button: 0,
|
|
}))
|
|
|
|
// Talks immediately without pathing
|
|
expect(scene.controller.navTarget).toBeNull()
|
|
expect(scene.controller.pendingInteraction).toBeNull()
|
|
expect(scene.status.textContent).toContain('Akara')
|
|
expect(scene.engine.world.player.facing).toBe(6) // Facing East towards Akara
|
|
|
|
// 2. Click far NPC Kashya (world 750, 500 -> clientX = 960 + 250 = 1210, clientY = 540)
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 1210,
|
|
clientY: 540,
|
|
button: 0,
|
|
}))
|
|
|
|
// Sets pending interaction and navTarget towards Kashya
|
|
expect(scene.controller.pendingInteraction).toEqual({
|
|
kind: 'npc',
|
|
npc: expect.objectContaining({ x: 750, y: 500 }),
|
|
})
|
|
expect(scene.controller.navTarget).toEqual({ x: 750, y: 500 })
|
|
|
|
// Walks towards Kashya
|
|
const walkTick = scene.controller.tick()
|
|
expect(walkTick.movement.x).toBeGreaterThan(0)
|
|
|
|
// Player arrives within 80px (e.g. x = 680, dist = 70px)
|
|
scene.engine.world.player.x = 680
|
|
const arriveTick = scene.controller.tick()
|
|
expect(arriveTick.movement).toEqual({ x: 0, y: 0 })
|
|
expect(scene.controller.pendingInteraction).toBeNull()
|
|
expect(scene.status.textContent).toContain('Kashya')
|
|
})
|
|
|
|
it('R3: left-click on Waypoint activates and opens menu if <= 80px, or paths and opens on arrival', () => {
|
|
// WP 1 nearby at (540, 500), dist 40px <= 80px
|
|
// WP 2 far away at (800, 500), dist 300px > 80px
|
|
// Note: waypoint subTile to scene is handled in test mock
|
|
const scene = createTestScene({
|
|
playerPos: { x: 500, y: 500 },
|
|
waypoints: [
|
|
{ waypointId: 1, x: 540, y: 500 },
|
|
{ waypointId: 2, x: 800, y: 500 },
|
|
],
|
|
})
|
|
|
|
// Click nearby WP 1 (clientX = 960 + 40 = 1000, clientY = 540)
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 1000,
|
|
clientY: 540,
|
|
button: 0,
|
|
}))
|
|
|
|
// Activated immediately and opened waypoint menu
|
|
expect(scene.waypointNetwork.destinations().some(d => d.waypointId === 1)).toBe(true)
|
|
expect(scene.hudManager.leftPanel).toBe('waypoint')
|
|
expect(scene.controller.navTarget).toBeNull()
|
|
|
|
// Close waypoint panel
|
|
scene.hudManager.toggleLeftPanel('waypoint')
|
|
expect(scene.hudManager.leftPanel).toBe('none')
|
|
|
|
// Click far WP 2 (clientX = 960 + 300 = 1260, clientY = 540)
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 1260,
|
|
clientY: 540,
|
|
button: 0,
|
|
}))
|
|
|
|
expect(scene.controller.pendingInteraction?.kind).toBe('waypoint')
|
|
expect(scene.controller.navTarget).toBeDefined()
|
|
|
|
// Player moves within 80px (e.g. x = 740, dist = 60px)
|
|
scene.engine.world.player.x = 740
|
|
const arriveTick = scene.controller.tick()
|
|
expect(arriveTick.movement).toEqual({ x: 0, y: 0 })
|
|
expect(scene.hudManager.leftPanel).toBe('waypoint')
|
|
expect(scene.controller.pendingInteraction).toBeNull()
|
|
})
|
|
|
|
it('R3: left-click on Monster attacks melee if <= 52px, or paths to monster and attacks on arrival', () => {
|
|
// Monster 1 nearby at (530, 500), dist 30px <= 52px
|
|
// Monster 2 far away at (700, 500), dist 200px > 52px
|
|
const scene = createTestScene({
|
|
playerPos: { x: 500, y: 500 },
|
|
leftSkillId: 0, // Melee attack
|
|
monsters: [
|
|
{ id: 'mon1', name: 'Fallen', x: 530, y: 500, hp: 50 },
|
|
{ id: 'mon2', name: 'Zombie', x: 700, y: 500, hp: 100 },
|
|
],
|
|
})
|
|
|
|
// Click nearby monster 1 (clientX = 960 + 30 = 990, clientY = 540)
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 990,
|
|
clientY: 540,
|
|
button: 0,
|
|
}))
|
|
|
|
// Attacks immediately: deals damage, no pathing
|
|
expect(scene.engine.world.monsters[0]!.hp).toBeLessThan(50)
|
|
expect(scene.engine.metrics.playerHits).toBe(1)
|
|
expect(scene.controller.navTarget).toBeNull()
|
|
|
|
// Click far monster 2 (clientX = 960 + 200 = 1160, clientY = 540)
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 1160,
|
|
clientY: 540,
|
|
button: 0,
|
|
}))
|
|
|
|
expect(scene.controller.pendingInteraction?.kind).toBe('monster')
|
|
expect(scene.controller.navTarget).toEqual({ x: 700, y: 500 })
|
|
|
|
// Move player within reach (e.g. x = 660, dist = 40px <= 52px)
|
|
scene.engine.world.player.x = 660
|
|
scene.engine.world.player.cooldown = 0
|
|
const attackTick = scene.controller.tick()
|
|
expect(attackTick.movement).toEqual({ x: 0, y: 0 })
|
|
expect(scene.engine.world.monsters[1]!.hp).toBeLessThan(100)
|
|
expect(scene.engine.metrics.playerHits).toBe(2)
|
|
})
|
|
|
|
it('R2: right-click active skill checks mana, deducts mana, enforces cooldown, and casts', () => {
|
|
const scene = createTestScene({
|
|
playerPos: { x: 500, y: 500 },
|
|
rightSkillId: 47, // Fire Ball, cost 8.5
|
|
mana: 100,
|
|
})
|
|
|
|
// 1. Sufficient mana
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 1060,
|
|
clientY: 540,
|
|
button: 2,
|
|
}))
|
|
|
|
expect(scene.hudManager.mana).toBe(100 - 8.5)
|
|
expect(scene.engine.projectiles.length).toBe(1)
|
|
expect(scene.engine.world.player.cooldown).toBeGreaterThan(0)
|
|
expect(scene.engine.world.player.facing).toBe(6) // Facing East
|
|
|
|
// 2. Insufficient mana: reduce mana to 5
|
|
scene.hudManager.mana = 5
|
|
scene.engine.world.player.cooldown = 0
|
|
scene.engine.projectiles.length = 0
|
|
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 1060,
|
|
clientY: 540,
|
|
button: 2,
|
|
}))
|
|
|
|
// Must not move player, must display "法力不足！", must not spawn projectile
|
|
expect(scene.controller.navTarget).toBeNull()
|
|
expect(scene.controller.tick().movement).toEqual({ x: 0, y: 0 })
|
|
expect(scene.status.textContent).toBe('法力不足！')
|
|
expect(scene.engine.projectiles.length).toBe(0)
|
|
expect(scene.hudManager.mana).toBe(5) // Unducted
|
|
})
|
|
|
|
it('R2: right-click Teleport (54) verifies target walkability and relocates player', () => {
|
|
const scene = createTestScene({
|
|
playerPos: { x: 500, y: 500 },
|
|
rightSkillId: 54, // Teleport, cost 21
|
|
mana: 100,
|
|
blockedOverlap: (x, y) => (x > 1500 ? 1 : 0),
|
|
})
|
|
|
|
// Teleport to walkable location (600, 484)
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 1060,
|
|
clientY: 540,
|
|
button: 2,
|
|
}))
|
|
|
|
expect(scene.engine.world.player.x).toBe(600)
|
|
expect(scene.engine.world.player.y).toBe(484)
|
|
expect(scene.hudManager.mana).toBe(100 - 21)
|
|
expect(scene.status.textContent).toBe('已施展传送')
|
|
|
|
// Teleport to blocked location (1600, 484) -> clientX = 960 + 1000 = 1960
|
|
scene.engine.world.player.cooldown = 0
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 1960,
|
|
clientY: 540,
|
|
button: 2,
|
|
}))
|
|
|
|
// Does not move player
|
|
expect(scene.engine.world.player.x).toBe(600)
|
|
expect(scene.status.textContent).toBe('无法传送到该位置')
|
|
})
|
|
|
|
it('R2: right-click unassigned (0) or passive skill (37, 61) routes to walk/run towards cursor', () => {
|
|
// 1. Unassigned skill 0
|
|
const scene1 = createTestScene({
|
|
playerPos: { x: 500, y: 500 },
|
|
rightSkillId: 0,
|
|
})
|
|
|
|
scene1.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 1060,
|
|
clientY: 540,
|
|
button: 2,
|
|
}))
|
|
|
|
expect(scene1.controller.navTarget).toEqual({ x: 600, y: 484 })
|
|
expect(scene1.controller.tick().movement.x).toBeGreaterThan(0)
|
|
|
|
// 2. Passive skill Warmth (37)
|
|
const scene2 = createTestScene({
|
|
playerPos: { x: 500, y: 500 },
|
|
rightSkillId: 37,
|
|
})
|
|
|
|
scene2.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 1060,
|
|
clientY: 540,
|
|
button: 2,
|
|
}))
|
|
|
|
expect(scene2.controller.navTarget).toEqual({ x: 600, y: 484 })
|
|
expect(scene2.controller.tick().movement.x).toBeGreaterThan(0)
|
|
|
|
// 3. Passive skill Fire Mastery (61)
|
|
const scene3 = createTestScene({
|
|
playerPos: { x: 500, y: 500 },
|
|
rightSkillId: 61,
|
|
})
|
|
|
|
scene3.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 1060,
|
|
clientY: 540,
|
|
button: 2,
|
|
}))
|
|
|
|
expect(scene3.controller.navTarget).toEqual({ x: 600, y: 484 })
|
|
expect(scene3.controller.tick().movement.x).toBeGreaterThan(0)
|
|
})
|
|
|
|
it('prevents contextmenu default on canvas and respects HUD interception', () => {
|
|
const scene = createTestScene({ playerPos: { x: 500, y: 500 } })
|
|
|
|
// Test contextmenu preventDefault
|
|
const contextMenuEvent = new SyntheticPointerEvent('contextmenu', {
|
|
clientX: 500,
|
|
clientY: 500,
|
|
})
|
|
scene.canvas.dispatchEvent(contextMenuEvent)
|
|
expect(contextMenuEvent.defaultPrevented).toBe(true)
|
|
|
|
// Test HUD interception at bottom control bar (clientY = 1000 -> logical.y = 555.5 >= 546)
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 960,
|
|
clientY: 1000,
|
|
button: 0,
|
|
}))
|
|
expect(scene.controller.navTarget).toBeNull()
|
|
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 960,
|
|
clientY: 1000,
|
|
button: 2,
|
|
}))
|
|
expect(scene.controller.navTarget).toBeNull()
|
|
})
|
|
|
|
it('clears navTarget on stuck detection after 12 ticks without moving', () => {
|
|
const scene = createTestScene({ playerPos: { x: 500, y: 500 } })
|
|
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 1060,
|
|
clientY: 540,
|
|
button: 0,
|
|
}))
|
|
expect(scene.controller.navTarget).toEqual({ x: 600, y: 484 })
|
|
|
|
// Simulate player being stuck at (500, 500) for 12 ticks
|
|
for (let i = 0; i < 11; i++) {
|
|
scene.controller.tick()
|
|
expect(scene.controller.navTarget).not.toBeNull()
|
|
}
|
|
|
|
// 12th tick triggers stuck mitigation
|
|
scene.controller.tick()
|
|
expect(scene.controller.navTarget).toBeNull()
|
|
})
|
|
})
|
|
|
|
describe('Warp & Entrance Mouse-Click Transitions, KeyG Removal & Overhead Labels', () => {
|
|
it('disables KeyG so pressing KeyG no longer triggers takeUse()', () => {
|
|
const win = new MockWindow()
|
|
const input = new KeyboardInput(win as unknown as Window)
|
|
input.attach()
|
|
|
|
expect(input.takeUse()).toBe(false)
|
|
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keydown', { code: 'KeyG', key: 'g' }))
|
|
expect(input.takeUse()).toBe(false)
|
|
|
|
for (let i = 0; i < 25; i++) {
|
|
expect(input.takeUse()).toBe(false)
|
|
}
|
|
|
|
win.dispatchEvent(new SyntheticKeyboardEvent('keyup', { code: 'KeyG', key: 'g' }))
|
|
expect(input.takeUse()).toBe(false)
|
|
})
|
|
|
|
it('immediately triggers onEnterWarp without setting navTarget when left-clicking an in-range SceneWarp', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
const warp: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Den of Evil',
|
|
toLevelId: 8, // Den of Evil
|
|
warpId: 4,
|
|
x: 30,
|
|
y: 30,
|
|
arriveX: 32,
|
|
arriveY: 30,
|
|
exitWalkX: 32,
|
|
exitWalkY: 30,
|
|
selectX: 0,
|
|
selectY: 0,
|
|
selectDX: 0,
|
|
selectDY: 0,
|
|
}
|
|
const anchorPos = subTileToScene(warp.x, warp.y, grid)
|
|
const playerPos = subTileToScene(31, 30, grid)
|
|
const enteredWarps: SceneWarp[] = []
|
|
|
|
const scene = createTestScene({
|
|
playerPos,
|
|
warps: [warp],
|
|
onEnterWarp: (w) => enteredWarps.push(w),
|
|
})
|
|
|
|
// Click directly on the warp anchor (relative to camera centered at playerPos.x, playerPos.y - 16)
|
|
const clientX = 960 + (anchorPos.x - playerPos.x)
|
|
const clientY = 540 + (anchorPos.y - (playerPos.y - 16))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX,
|
|
clientY,
|
|
button: 0,
|
|
}))
|
|
|
|
expect(enteredWarps).toEqual([warp])
|
|
expect(scene.controller.navTarget).toBeNull()
|
|
expect(scene.controller.pendingInteraction).toBeNull()
|
|
expect(scene.status.textContent).toContain('邪恶洞窟')
|
|
})
|
|
|
|
it('sets navTarget to walkable arrivePos when left-clicking a distant SceneWarp and triggers onEnterWarp on tick() upon arrival', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
// Warp where arriveX/arriveY is 7 sub-tiles from anchor (like Harem / Catacombs stairs)
|
|
const warp: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Catacombs Level 2',
|
|
toLevelId: 35, // Catacombs Level 2
|
|
warpId: 18,
|
|
x: 40,
|
|
y: 20,
|
|
arriveX: 47,
|
|
arriveY: 20,
|
|
exitWalkX: 47,
|
|
exitWalkY: 20,
|
|
selectX: -54,
|
|
selectY: -39,
|
|
selectDX: 121,
|
|
selectDY: 102,
|
|
}
|
|
const anchorPos = subTileToScene(warp.x, warp.y, grid)
|
|
const arrivePos = subTileToScene(warp.arriveX, warp.arriveY, grid)
|
|
const playerPos = subTileToScene(70, 50, grid)
|
|
const enteredWarps: SceneWarp[] = []
|
|
|
|
const scene = createTestScene({
|
|
playerPos: { ...playerPos },
|
|
warps: [warp],
|
|
onEnterWarp: (w) => enteredWarps.push(w),
|
|
})
|
|
|
|
const clientX = 960 + (anchorPos.x - playerPos.x)
|
|
const clientY = 540 + (anchorPos.y - (playerPos.y - 16))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX,
|
|
clientY,
|
|
button: 0,
|
|
}))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerup', {
|
|
clientX,
|
|
clientY,
|
|
button: 0,
|
|
}))
|
|
|
|
expect(enteredWarps).toHaveLength(0)
|
|
expect(scene.controller.navTarget).toEqual(arrivePos)
|
|
expect(scene.controller.pendingInteraction?.kind).toBe('warp')
|
|
|
|
// Move partway toward arrivePos: still out of range
|
|
scene.engine.world.player.x = (playerPos.x + arrivePos.x) * 0.5
|
|
scene.engine.world.player.y = (playerPos.y + arrivePos.y) * 0.5
|
|
const step = scene.controller.tick()
|
|
expect(enteredWarps).toHaveLength(0)
|
|
expect(step.movement.x !== 0 || step.movement.y !== 0).toBe(true)
|
|
|
|
// Arrive within trigger range of arrivePos
|
|
scene.engine.world.player.x = arrivePos.x
|
|
scene.engine.world.player.y = arrivePos.y
|
|
const arriveTick = scene.controller.tick()
|
|
expect(enteredWarps).toEqual([warp])
|
|
expect(scene.controller.navTarget).toBeNull()
|
|
expect(scene.controller.pendingInteraction).toBeNull()
|
|
expect(arriveTick.movement).toEqual({ x: 0, y: 0 })
|
|
})
|
|
|
|
it('resolves and activates a SceneWarp when left-clicking inside its LvlWarp.txt (selectX, selectY, selectDX, selectDY) bounding box', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
const warp: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Harem Level 1',
|
|
toLevelId: 50, // Harem Level 1
|
|
warpId: 23,
|
|
x: 35,
|
|
y: 35,
|
|
arriveX: 37,
|
|
arriveY: 35,
|
|
exitWalkX: 37,
|
|
exitWalkY: 35,
|
|
selectX: -120,
|
|
selectY: -100,
|
|
selectDX: 180,
|
|
selectDY: 140,
|
|
}
|
|
const anchorPos = subTileToScene(warp.x, warp.y, grid)
|
|
const playerPos = subTileToScene(36, 35, grid)
|
|
const enteredWarps: SceneWarp[] = []
|
|
|
|
const scene = createTestScene({
|
|
playerPos: { ...playerPos },
|
|
warps: [warp],
|
|
onEnterWarp: (w) => enteredWarps.push(w),
|
|
})
|
|
|
|
// Click near the top-left corner of the LvlWarp.txt selection box:
|
|
// ~140px from anchorPos (well outside radial proximity 56px, but inside [-120..60, -100..40])
|
|
const clickWorldX = anchorPos.x - 110
|
|
const clickWorldY = anchorPos.y - 90
|
|
const clientX = 960 + (clickWorldX - playerPos.x)
|
|
const clientY = 540 + (clickWorldY - (playerPos.y - 16))
|
|
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX,
|
|
clientY,
|
|
button: 0,
|
|
}))
|
|
|
|
expect(enteredWarps).toEqual([warp])
|
|
expect(scene.controller.navTarget).toBeNull()
|
|
})
|
|
|
|
it('paths to arrivePos and triggers onEnterEntrance when left-clicking a SceneEntrance', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
const entrance: SceneEntrance = {
|
|
toLevelId: 2, // Blood Moor
|
|
side: 'east',
|
|
label: 'Blood Moor Exit',
|
|
x: 25,
|
|
y: 25,
|
|
arriveX: 31,
|
|
arriveY: 25,
|
|
}
|
|
const anchorPos = subTileToScene(entrance.x, entrance.y, grid)
|
|
const arrivePos = subTileToScene(entrance.arriveX, entrance.arriveY, grid)
|
|
const playerPos = subTileToScene(60, 45, grid)
|
|
const enteredEntrances: SceneEntrance[] = []
|
|
|
|
const scene = createTestScene({
|
|
playerPos: { ...playerPos },
|
|
entrances: [entrance],
|
|
onEnterEntrance: (e) => enteredEntrances.push(e),
|
|
})
|
|
|
|
const clientX = 960 + (anchorPos.x - playerPos.x)
|
|
const clientY = 540 + (anchorPos.y - (playerPos.y - 16))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX,
|
|
clientY,
|
|
button: 0,
|
|
}))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerup', {
|
|
clientX,
|
|
clientY,
|
|
button: 0,
|
|
}))
|
|
|
|
expect(enteredEntrances).toHaveLength(0)
|
|
expect(scene.controller.navTarget).toEqual(arrivePos)
|
|
expect(scene.controller.pendingInteraction?.kind).toBe('entrance')
|
|
|
|
// Move player to arrivePos and tick
|
|
scene.engine.world.player.x = arrivePos.x
|
|
scene.engine.world.player.y = arrivePos.y
|
|
scene.controller.tick()
|
|
|
|
expect(enteredEntrances).toEqual([entrance])
|
|
expect(scene.controller.navTarget).toBeNull()
|
|
expect(scene.controller.pendingInteraction).toBeNull()
|
|
expect(scene.status.textContent).toContain('鲜血荒地')
|
|
})
|
|
|
|
it('allows Telekinesis (Skill 43) right-click casts to activate a clicked SceneWarp within TELEKINESIS_RANGE_PX (320px)', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
const nearWarp: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Den of Evil',
|
|
toLevelId: 8,
|
|
warpId: 4,
|
|
x: 30,
|
|
y: 30,
|
|
arriveX: 32,
|
|
arriveY: 30,
|
|
exitWalkX: 32,
|
|
exitWalkY: 30,
|
|
selectX: -48,
|
|
selectY: -48,
|
|
selectDX: 96,
|
|
selectDY: 96,
|
|
}
|
|
const farWarp: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Cold Plains Cave',
|
|
toLevelId: 9,
|
|
warpId: 5,
|
|
x: 60,
|
|
y: 30,
|
|
arriveX: 62,
|
|
arriveY: 30,
|
|
exitWalkX: 62,
|
|
exitWalkY: 30,
|
|
selectX: -48,
|
|
selectY: -48,
|
|
selectDX: 96,
|
|
selectDY: 96,
|
|
}
|
|
const nearPos = subTileToScene(nearWarp.x, nearWarp.y, grid)
|
|
const farPos = subTileToScene(farWarp.x, farWarp.y, grid)
|
|
// Place player 220px away from nearWarp (< 320px) and > 320px from farWarp
|
|
const playerPos = { x: nearPos.x - 220, y: nearPos.y }
|
|
expect(Math.hypot(nearPos.x - playerPos.x, nearPos.y - playerPos.y)).toBeLessThanOrEqual(TELEKINESIS_RANGE_PX)
|
|
expect(Math.hypot(farPos.x - playerPos.x, farPos.y - playerPos.y)).toBeGreaterThan(TELEKINESIS_RANGE_PX)
|
|
|
|
const enteredWarps: SceneWarp[] = []
|
|
const scene = createTestScene({
|
|
playerPos,
|
|
rightSkillId: 43, // Telekinesis
|
|
warps: [nearWarp, farWarp],
|
|
onEnterWarp: (w) => enteredWarps.push(w),
|
|
})
|
|
|
|
// Right-click farWarp (> 320px) -> rejected without deducting mana
|
|
const startMana = scene.hudManager.mana
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 960 + (farPos.x - playerPos.x),
|
|
clientY: 540 + (farPos.y - (playerPos.y - 16)),
|
|
button: 2,
|
|
}))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerup', {
|
|
clientX: 960 + (farPos.x - playerPos.x),
|
|
clientY: 540 + (farPos.y - (playerPos.y - 16)),
|
|
button: 2,
|
|
}))
|
|
expect(enteredWarps).toHaveLength(0)
|
|
expect(scene.hudManager.mana).toBe(startMana)
|
|
|
|
// Right-click nearWarp (<= 320px) -> deducts mana and activates warp
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 960 + (nearPos.x - playerPos.x),
|
|
clientY: 540 + (nearPos.y - (playerPos.y - 16)),
|
|
button: 2,
|
|
}))
|
|
expect(enteredWarps).toEqual([nearWarp])
|
|
expect(scene.hudManager.mana).toBeLessThan(startMana)
|
|
})
|
|
|
|
it('renders overhead destination labels in labelsContainer and updates pointer cursor + badge highlight on hover', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
const warp: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Den of Evil',
|
|
toLevelId: 8, // 邪恶洞窟
|
|
warpId: 4,
|
|
x: 30,
|
|
y: 30,
|
|
arriveX: 32,
|
|
arriveY: 30,
|
|
exitWalkX: 32,
|
|
exitWalkY: 30,
|
|
selectX: -60,
|
|
selectY: -60,
|
|
selectDX: 120,
|
|
selectDY: 90,
|
|
}
|
|
const entrance: SceneEntrance = {
|
|
toLevelId: 2, // 鲜血荒地
|
|
side: 'east',
|
|
label: 'Blood Moor Exit',
|
|
x: 38,
|
|
y: 30,
|
|
arriveX: 40,
|
|
arriveY: 30,
|
|
}
|
|
const playerPos = subTileToScene(34, 30, grid)
|
|
const warpAnchor = subTileToScene(warp.x, warp.y, grid)
|
|
const entranceAnchor = subTileToScene(entrance.x, entrance.y, grid)
|
|
|
|
const children: HTMLDivElement[] = []
|
|
const mockLabelsContainer = {
|
|
children,
|
|
appendChild(el: HTMLDivElement) {
|
|
children.push(el)
|
|
return el
|
|
},
|
|
} as unknown as HTMLElement
|
|
|
|
const scene = createTestScene({
|
|
playerPos,
|
|
warps: [warp],
|
|
entrances: [entrance],
|
|
labelsContainer: mockLabelsContainer,
|
|
})
|
|
|
|
const badges = children
|
|
expect(badges.length).toBe(2)
|
|
expect(badges[0]!.textContent).toBe('通往 邪恶洞窟')
|
|
expect(badges[1]!.textContent).toBe('通往 鲜血荒地')
|
|
expect(badges[0]!.dataset.hovered).toBe('false')
|
|
expect(badges[1]!.dataset.hovered).toBe('false')
|
|
expect(scene.canvas.style.cursor).not.toBe('pointer')
|
|
|
|
// Hover over the SceneWarp bounding box
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointermove', {
|
|
clientX: 960 + (warpAnchor.x - playerPos.x),
|
|
clientY: 540 + (warpAnchor.y - (playerPos.y - 16)),
|
|
}))
|
|
expect(scene.controller.hoveredWarp).toBe(warp)
|
|
expect(scene.controller.hoveredEntrance).toBeNull()
|
|
expect(scene.canvas.style.cursor).toBe('pointer')
|
|
expect(badges[0]!.dataset.hovered).toBe('true')
|
|
expect(badges[0]!.className).toContain('is-hovered')
|
|
expect(badges[1]!.dataset.hovered).toBe('false')
|
|
|
|
// Hover over the SceneEntrance
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointermove', {
|
|
clientX: 960 + (entranceAnchor.x - playerPos.x),
|
|
clientY: 540 + (entranceAnchor.y - (playerPos.y - 16)),
|
|
}))
|
|
expect(scene.controller.hoveredWarp).toBeNull()
|
|
expect(scene.controller.hoveredEntrance).toBe(entrance)
|
|
expect(scene.canvas.style.cursor).toBe('pointer')
|
|
expect(badges[0]!.dataset.hovered).toBe('false')
|
|
expect(badges[1]!.dataset.hovered).toBe('true')
|
|
expect(badges[1]!.className).toContain('is-hovered')
|
|
|
|
// Move cursor to empty ground
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointermove', {
|
|
clientX: 100,
|
|
clientY: 100,
|
|
}))
|
|
expect(scene.controller.hoveredWarp).toBeNull()
|
|
expect(scene.controller.hoveredEntrance).toBeNull()
|
|
expect(scene.canvas.style.cursor).toBe('')
|
|
expect(badges[0]!.dataset.hovered).toBe('false')
|
|
expect(badges[1]!.dataset.hovered).toBe('false')
|
|
})
|
|
|
|
it('paths around a concave dungeon wall obstacle when clicking a distant SceneWarp without false stuck cancellation', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
const warp: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Catacombs Level 3',
|
|
toLevelId: 36,
|
|
warpId: 19,
|
|
x: 20,
|
|
y: 33,
|
|
arriveX: 20,
|
|
arriveY: 32,
|
|
exitWalkX: 20,
|
|
exitWalkY: 32,
|
|
selectX: -48,
|
|
selectY: -48,
|
|
selectDX: 96,
|
|
selectDY: 96,
|
|
}
|
|
const playerStart = subTileToScene(20, 20, grid)
|
|
const warpAnchor = subTileToScene(warp.x, warp.y, grid)
|
|
const enteredWarps: SceneWarp[] = []
|
|
|
|
const scene = createTestScene({
|
|
playerPos: { ...playerStart },
|
|
warps: [warp],
|
|
onEnterWarp: (w) => enteredWarps.push(w),
|
|
})
|
|
|
|
// Build a concave U-shaped dungeon wall between (20, 20) and (20, 32):
|
|
// Horizontal bar at y = 26, x = 16..24, plus side walls extending up toward player at x = 16 and x = 24, y = 22..26
|
|
const gridW = scene.runtime.grid.gridWidth
|
|
const blocked = scene.runtime.grid.blocked as Uint8Array
|
|
for (let x = 16; x <= 24; x++) {
|
|
blocked[26 * gridW + x] = 1
|
|
}
|
|
for (let y = 22; y <= 26; y++) {
|
|
blocked[y * gridW + 16] = 1
|
|
blocked[y * gridW + 24] = 1
|
|
}
|
|
|
|
// Left-click the distant warp behind the concave wall
|
|
const clientX = 960 + (warpAnchor.x - playerStart.x)
|
|
const clientY = 540 + (warpAnchor.y - (playerStart.y - 16))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX,
|
|
clientY,
|
|
button: 0,
|
|
}))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerup', {
|
|
clientX,
|
|
clientY,
|
|
button: 0,
|
|
}))
|
|
|
|
expect(scene.controller.pendingInteraction?.kind).toBe('warp')
|
|
expect(enteredWarps).toHaveLength(0)
|
|
|
|
// Step simulation ticks: player must route out of the concave pocket, around x < 16 or x > 24, and arrive at (20, 32)
|
|
let detouredOutsideWall = false
|
|
for (let stepIdx = 0; stepIdx < 160 && enteredWarps.length === 0; stepIdx++) {
|
|
const { movement } = scene.controller.tick()
|
|
if (enteredWarps.length > 0) break
|
|
expect(movement.x !== 0 || movement.y !== 0).toBe(true)
|
|
scene.engine.world.player.x += movement.x * 5
|
|
scene.engine.world.player.y += movement.y * 5
|
|
const sub = sceneToSubTile(scene.engine.world.player.x, scene.engine.world.player.y, grid)
|
|
expect(blocked[sub.y * gridW + sub.x]).toBe(0)
|
|
if (sub.x < 16 || sub.x > 24) {
|
|
detouredOutsideWall = true
|
|
}
|
|
}
|
|
|
|
expect(detouredOutsideWall).toBe(true)
|
|
expect(enteredWarps).toEqual([warp])
|
|
expect(scene.controller.navTarget).toBeNull()
|
|
expect(scene.controller.pendingInteraction).toBeNull()
|
|
})
|
|
|
|
it('hit-tests and activates overhead destination badges across their full rectangular footprint', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
const warp: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Den of Evil',
|
|
toLevelId: 8,
|
|
warpId: 4,
|
|
x: 30,
|
|
y: 30,
|
|
arriveX: 31,
|
|
arriveY: 30,
|
|
exitWalkX: 31,
|
|
exitWalkY: 30,
|
|
selectX: -50,
|
|
selectY: -60,
|
|
selectDX: 100,
|
|
selectDY: 80,
|
|
}
|
|
const playerPos = subTileToScene(31, 30, grid)
|
|
const labelPos = getWarpLabelWorldPos(warp, grid)
|
|
const enteredWarps: SceneWarp[] = []
|
|
|
|
const scene = createTestScene({
|
|
playerPos: { ...playerPos },
|
|
warps: [warp],
|
|
onEnterWarp: (w) => enteredWarps.push(w),
|
|
})
|
|
|
|
// Point near the top-right of the rendered overhead badge:
|
|
// +58px right and -18px above labelPos (Euclidean distance = 60.73px > 56px radial threshold, and above selectY box)
|
|
const badgeClickX = labelPos.x + 58
|
|
const badgeClickY = labelPos.y - 18
|
|
const clientX = 960 + (badgeClickX - playerPos.x)
|
|
const clientY = 540 + (badgeClickY - (playerPos.y - 16))
|
|
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointermove', {
|
|
clientX,
|
|
clientY,
|
|
}))
|
|
expect(scene.controller.hoveredWarp).toBe(warp)
|
|
expect(scene.canvas.style.cursor).toBe('pointer')
|
|
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX,
|
|
clientY,
|
|
button: 0,
|
|
}))
|
|
expect(enteredWarps).toEqual([warp])
|
|
})
|
|
|
|
it('prioritizes monsters and ground items over SceneWarp when overlapping inside a LvlWarp.txt box for both hover and click', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
const warp: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Catacombs Level 1',
|
|
toLevelId: 34,
|
|
warpId: 17,
|
|
x: 35,
|
|
y: 35,
|
|
arriveX: 36,
|
|
arriveY: 35,
|
|
exitWalkX: 36,
|
|
exitWalkY: 35,
|
|
selectX: -120,
|
|
selectY: -100,
|
|
selectDX: 180,
|
|
selectDY: 140,
|
|
}
|
|
const anchorPos = subTileToScene(warp.x, warp.y, grid)
|
|
const playerPos = subTileToScene(36, 35, grid)
|
|
const monsterPos = { x: anchorPos.x - 20, y: anchorPos.y - 10 }
|
|
const enteredWarps: SceneWarp[] = []
|
|
|
|
const children: HTMLDivElement[] = []
|
|
const mockLabelsContainer = {
|
|
children,
|
|
appendChild(el: HTMLDivElement) {
|
|
children.push(el)
|
|
return el
|
|
},
|
|
} as unknown as HTMLElement
|
|
|
|
const scene = createTestScene({
|
|
playerPos: { ...playerPos },
|
|
leftSkillId: 0,
|
|
monsters: [
|
|
{ id: 'mon-overlap', name: 'Fallen', x: monsterPos.x, y: monsterPos.y, hp: 40 },
|
|
],
|
|
warps: [warp],
|
|
onEnterWarp: (w) => enteredWarps.push(w),
|
|
labelsContainer: mockLabelsContainer,
|
|
})
|
|
scene.engine.world.monsters.length = 1
|
|
|
|
// 1. Hovering over the living monster inside the warp's LvlWarp.txt box must NOT highlight the warp badge
|
|
const monClientX = 960 + (monsterPos.x - playerPos.x)
|
|
const monClientY = 540 + (monsterPos.y - (playerPos.y - 16))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointermove', {
|
|
clientX: monClientX,
|
|
clientY: monClientY,
|
|
}))
|
|
expect(scene.controller.hoveredWarp).toBeNull()
|
|
expect(children[0]!.dataset.hovered).toBe('false')
|
|
|
|
// 2. Left-clicking the living monster attacks the monster instead of triggering the warp
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: monClientX,
|
|
clientY: monClientY,
|
|
button: 0,
|
|
}))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerup', {
|
|
clientX: monClientX,
|
|
clientY: monClientY,
|
|
button: 0,
|
|
}))
|
|
expect(enteredWarps).toHaveLength(0)
|
|
expect(scene.engine.world.monsters[0]!.hp).toBeLessThan(40)
|
|
|
|
// 3. Place a ground item at that spot and verify GroundItem > SceneWarp
|
|
scene.engine.world.monsters[0]!.hp = 0
|
|
scene.engine.world.monsters[0]!.state = 'dead'
|
|
scene.engine.groundItems.clear()
|
|
const groundItem = scene.engine.groundItems.add(
|
|
{ isGold: true, code: 'gld', name: 'Gold' },
|
|
0,
|
|
0,
|
|
monsterPos.x,
|
|
monsterPos.y,
|
|
{ amount: 25 },
|
|
)
|
|
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointermove', {
|
|
clientX: monClientX,
|
|
clientY: monClientY,
|
|
}))
|
|
expect(scene.controller.hoveredGroundItem?.id).toBe(groundItem.id)
|
|
expect(scene.controller.hoveredWarp).toBeNull()
|
|
expect(children[0]!.dataset.hovered).toBe('false')
|
|
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: monClientX,
|
|
clientY: monClientY,
|
|
button: 0,
|
|
}))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerup', {
|
|
clientX: monClientX,
|
|
clientY: monClientY,
|
|
button: 0,
|
|
}))
|
|
expect(enteredWarps).toHaveLength(0)
|
|
expect(scene.engine.groundItems.count).toBe(0)
|
|
|
|
// 4. Once both the monster is dead and the ground item is picked up, hovering and clicking that exact spot inside the LvlWarp.txt box highlights and activates the warp
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointermove', {
|
|
clientX: monClientX,
|
|
clientY: monClientY,
|
|
}))
|
|
expect(scene.controller.hoveredWarp).toBe(warp)
|
|
expect(children[0]!.dataset.hovered).toBe('true')
|
|
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: monClientX,
|
|
clientY: monClientY,
|
|
button: 0,
|
|
}))
|
|
expect(enteredWarps).toEqual([warp])
|
|
})
|
|
|
|
it('maintains exact overhead badge screen alignment across non-unit camera zooms, camera scrolling, and clearTarget()', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
const warp: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Den of Evil',
|
|
toLevelId: 8,
|
|
warpId: 4,
|
|
x: 30,
|
|
y: 30,
|
|
arriveX: 31,
|
|
arriveY: 30,
|
|
exitWalkX: 31,
|
|
exitWalkY: 30,
|
|
selectX: -60,
|
|
selectY: -60,
|
|
selectDX: 120,
|
|
selectDY: 90,
|
|
}
|
|
const entrance: SceneEntrance = {
|
|
toLevelId: 2,
|
|
side: 'east',
|
|
label: 'Blood Moor',
|
|
x: 36,
|
|
y: 28,
|
|
arriveX: 38,
|
|
arriveY: 28,
|
|
}
|
|
const playerPos = subTileToScene(32, 30, grid)
|
|
const warpLabelWorld = getWarpLabelWorldPos(warp, grid)
|
|
const entranceLabelWorld = getEntranceLabelWorldPos(entrance, grid)
|
|
|
|
const children: HTMLDivElement[] = []
|
|
const mockLabelsContainer = {
|
|
children,
|
|
appendChild(el: HTMLDivElement) {
|
|
children.push(el)
|
|
return el
|
|
},
|
|
} as unknown as HTMLElement
|
|
|
|
const scene = createTestScene({
|
|
playerPos: { ...playerPos },
|
|
warps: [warp],
|
|
entrances: [entrance],
|
|
labelsContainer: mockLabelsContainer,
|
|
})
|
|
|
|
for (const zoom of [1.5, 0.75]) {
|
|
scene.camera.zoom = zoom
|
|
scene.controller.updateOverheadLabels(playerPos.x, playerPos.y - 16)
|
|
|
|
const warpBadge = children[0]!
|
|
const entranceBadge = children[1]!
|
|
const warpDomX = parseFloat(warpBadge.style.left)
|
|
const warpDomY = parseFloat(warpBadge.style.top) + 2
|
|
const entranceDomX = parseFloat(entranceBadge.style.left)
|
|
const entranceDomY = parseFloat(entranceBadge.style.top) + 2
|
|
|
|
const invWarp = screenToWorld({
|
|
clientX: warpDomX,
|
|
clientY: warpDomY,
|
|
rect: scene.canvas.getBoundingClientRect(),
|
|
canvas: scene.canvas,
|
|
camX: playerPos.x,
|
|
camY: playerPos.y - 16,
|
|
cameraZoom: zoom,
|
|
})
|
|
const invEntrance = screenToWorld({
|
|
clientX: entranceDomX,
|
|
clientY: entranceDomY,
|
|
rect: scene.canvas.getBoundingClientRect(),
|
|
canvas: scene.canvas,
|
|
camX: playerPos.x,
|
|
camY: playerPos.y - 16,
|
|
cameraZoom: zoom,
|
|
})
|
|
expect(Math.hypot(invWarp.x - warpLabelWorld.x, invWarp.y - warpLabelWorld.y)).toBeLessThan(1e-6)
|
|
expect(Math.hypot(invEntrance.x - entranceLabelWorld.x, invEntrance.y - entranceLabelWorld.y)).toBeLessThan(1e-6)
|
|
|
|
// Hover the projected badge position at this zoom
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointermove', {
|
|
clientX: warpDomX,
|
|
clientY: warpDomY,
|
|
}))
|
|
expect(scene.controller.hoveredWarp).toBe(warp)
|
|
expect(warpBadge.dataset.hovered).toBe('true')
|
|
|
|
// If the camera scrolls away while the pointer stays stationary, updateOverheadLabels clears hover
|
|
scene.controller.updateOverheadLabels(playerPos.x + 600, playerPos.y + 600)
|
|
expect(scene.controller.hoveredWarp).toBeNull()
|
|
expect(warpBadge.dataset.hovered).toBe('false')
|
|
|
|
// Re-hover at original camera position, then verify clearTarget() immediately clears badge hover
|
|
scene.controller.updateOverheadLabels(playerPos.x, playerPos.y - 16)
|
|
expect(scene.controller.hoveredWarp).toBe(warp)
|
|
expect(warpBadge.dataset.hovered).toBe('true')
|
|
scene.controller.clearTarget()
|
|
expect(scene.controller.hoveredWarp).toBeNull()
|
|
expect(warpBadge.dataset.hovered).toBe('false')
|
|
expect(warpBadge.className).not.toContain('is-hovered')
|
|
}
|
|
})
|
|
|
|
it('verifies all 365 baked map packs (495 SceneWarp and 166 SceneEntrance entries) resolve valid Chinese destination badges, hitboxes, and arrival triggers', () => {
|
|
const baseDir = path.resolve(process.cwd(), 'samples/d2-packs')
|
|
const indexPath = path.join(baseDir, 'index.json')
|
|
const index = JSON.parse(fs.readFileSync(indexPath, 'utf8'))
|
|
const packs: Array<{ path: string }> = index.levels ?? []
|
|
expect(packs.length).toBe(365)
|
|
|
|
let warpCount = 0
|
|
let nonZeroBoxWarps = 0
|
|
let zeroBoxWarps = 0
|
|
let entranceCount = 0
|
|
|
|
for (const entry of packs) {
|
|
const pack = JSON.parse(fs.readFileSync(path.join(baseDir, entry.path, 'scene.json'), 'utf8'))
|
|
const cellsX: number = pack.cellsX ?? 40
|
|
const cellsY: number = pack.cellsY ?? 40
|
|
const grid = {
|
|
originX: Math.ceil((cellsX + cellsY) * 80 * 0.5),
|
|
originY: 64,
|
|
}
|
|
|
|
for (const warp of (pack.warps ?? []) as SceneWarp[]) {
|
|
warpCount += 1
|
|
if (warp.selectDX > 0 && warp.selectDY > 0) nonZeroBoxWarps += 1
|
|
else zeroBoxWarps += 1
|
|
|
|
expect(warp.toLevelId).toBeGreaterThan(0)
|
|
const nameZh = getLevelNames(warp.toLevelId).nameZh
|
|
expect(nameZh.length).toBeGreaterThan(0)
|
|
|
|
const labelPos = getWarpLabelWorldPos(warp, grid)
|
|
expect(Number.isFinite(labelPos.x)).toBe(true)
|
|
expect(Number.isFinite(labelPos.y)).toBe(true)
|
|
|
|
const hitLabel = hitTestWarp(warp, labelPos.x, labelPos.y - 12, grid)
|
|
expect(hitLabel.hit).toBe(true)
|
|
|
|
const hitArrive = hitTestWarp(warp, hitLabel.arrivePos.x, hitLabel.arrivePos.y, grid)
|
|
expect(hitArrive.hit).toBe(true)
|
|
expect(isPlayerWithinLinkRange(hitLabel.arrivePos.x, hitLabel.arrivePos.y, warp, grid)).toBe(true)
|
|
}
|
|
|
|
for (const entrance of (pack.entrances ?? []) as SceneEntrance[]) {
|
|
entranceCount += 1
|
|
expect(entrance.toLevelId).toBeGreaterThan(0)
|
|
const nameZh = getLevelNames(entrance.toLevelId).nameZh
|
|
expect(nameZh.length).toBeGreaterThan(0)
|
|
|
|
const labelPos = getEntranceLabelWorldPos(entrance, grid)
|
|
expect(Number.isFinite(labelPos.x)).toBe(true)
|
|
expect(Number.isFinite(labelPos.y)).toBe(true)
|
|
|
|
const hitLabel = hitTestEntrance(entrance, labelPos.x, labelPos.y - 12, grid)
|
|
expect(hitLabel.hit).toBe(true)
|
|
|
|
const hitArrive = hitTestEntrance(entrance, hitLabel.arrivePos.x, hitLabel.arrivePos.y, grid)
|
|
expect(hitArrive.hit).toBe(true)
|
|
expect(isPlayerWithinLinkRange(hitLabel.arrivePos.x, hitLabel.arrivePos.y, entrance, grid)).toBe(true)
|
|
}
|
|
}
|
|
|
|
expect(warpCount).toBe(495)
|
|
expect(nonZeroBoxWarps).toBe(464)
|
|
expect(zeroBoxWarps).toBe(31)
|
|
// 166 since the Act I outdoor levels come from the DRLG port: D2 has no
|
|
// Stony Field <-> Dark Wood seam (DrlgOutPlace.cpp gAct1WildernessDrlgLink /
|
|
// gAct1MonasteryDrlgLink put them in separate groups, joined only through
|
|
// the Underground Passage), so the 2 seam entrances the old generator
|
|
// invented in each of the 3 act copies are gone.
|
|
expect(entranceCount).toBe(166)
|
|
})
|
|
|
|
it('ignores unresolved warps and entrances (toLevelId <= 0) for overhead badges, hover, left-click, and Telekinesis', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
const unresolvedWarp: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Unresolved Warp',
|
|
toLevelId: -1,
|
|
warpId: 4,
|
|
x: 30,
|
|
y: 30,
|
|
arriveX: 31,
|
|
arriveY: 30,
|
|
exitWalkX: 31,
|
|
exitWalkY: 30,
|
|
selectX: -60,
|
|
selectY: -60,
|
|
selectDX: 120,
|
|
selectDY: 90,
|
|
}
|
|
const unresolvedEntrance: SceneEntrance = {
|
|
toLevelId: -1,
|
|
side: 'east',
|
|
label: 'Unresolved Seam',
|
|
x: 34,
|
|
y: 30,
|
|
arriveX: 33,
|
|
arriveY: 30,
|
|
}
|
|
const playerPos = subTileToScene(31, 30, grid)
|
|
const warpAnchor = subTileToScene(unresolvedWarp.x, unresolvedWarp.y, grid)
|
|
const enteredWarps: SceneWarp[] = []
|
|
const enteredEntrances: SceneEntrance[] = []
|
|
|
|
expect(hitTestWarp(unresolvedWarp, warpAnchor.x, warpAnchor.y, grid).hit).toBe(false)
|
|
const entranceAnchor = subTileToScene(unresolvedEntrance.x, unresolvedEntrance.y, grid)
|
|
expect(hitTestEntrance(unresolvedEntrance, entranceAnchor.x, entranceAnchor.y, grid).hit).toBe(false)
|
|
|
|
const children: HTMLDivElement[] = []
|
|
const mockLabelsContainer = {
|
|
children,
|
|
appendChild(el: HTMLDivElement) {
|
|
children.push(el)
|
|
return el
|
|
},
|
|
} as unknown as HTMLElement
|
|
|
|
const scene = createTestScene({
|
|
playerPos: { ...playerPos },
|
|
rightSkillId: 43,
|
|
warps: [unresolvedWarp],
|
|
entrances: [unresolvedEntrance],
|
|
onEnterWarp: (w) => enteredWarps.push(w),
|
|
onEnterEntrance: (e) => enteredEntrances.push(e),
|
|
labelsContainer: mockLabelsContainer,
|
|
})
|
|
|
|
// No overhead badges should be rendered for unresolved links
|
|
expect(children.filter(el => !el.hidden)).toHaveLength(0)
|
|
|
|
const clientX = 960 + (warpAnchor.x - playerPos.x)
|
|
const clientY = 540 + (warpAnchor.y - (playerPos.y - 16))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointermove', {
|
|
clientX,
|
|
clientY,
|
|
}))
|
|
expect(scene.controller.hoveredWarp).toBeNull()
|
|
expect(scene.controller.hoveredEntrance).toBeNull()
|
|
expect(scene.canvas.style.cursor).toBe('')
|
|
|
|
// Left-click should walk on ground rather than activating unresolved warp
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX,
|
|
clientY,
|
|
button: 0,
|
|
}))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerup', {
|
|
clientX,
|
|
clientY,
|
|
button: 0,
|
|
}))
|
|
expect(enteredWarps).toHaveLength(0)
|
|
expect(enteredEntrances).toHaveLength(0)
|
|
|
|
// Right-click Telekinesis should not trigger unresolved warp
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX,
|
|
clientY,
|
|
button: 2,
|
|
}))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerup', {
|
|
clientX,
|
|
clientY,
|
|
button: 2,
|
|
}))
|
|
expect(enteredWarps).toHaveLength(0)
|
|
})
|
|
|
|
it('strictly enforces TELEKINESIS_RANGE_PX against warp anchorPos/arrivePos and does not spam Telekinesis while right mouse is held', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
// Warp with a wide selection box: anchor and arrive are > 320px away from player,
|
|
// but the left edge of the selection box is < 320px from player.
|
|
const wideBoxWarp: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Harem Level 1',
|
|
toLevelId: 50,
|
|
warpId: 23,
|
|
x: 50,
|
|
y: 30,
|
|
arriveX: 52,
|
|
arriveY: 30,
|
|
exitWalkX: 52,
|
|
exitWalkY: 30,
|
|
selectX: -140,
|
|
selectY: -80,
|
|
selectDX: 200,
|
|
selectDY: 140,
|
|
}
|
|
const anchorPos = subTileToScene(wideBoxWarp.x, wideBoxWarp.y, grid)
|
|
const arrivePos = subTileToScene(wideBoxWarp.arriveX, wideBoxWarp.arriveY, grid)
|
|
// Place player 380px left of anchorPos (> 320px), so anchorPos-120px is 260px from player (<= 320px)
|
|
const playerPos = { x: anchorPos.x - 380, y: anchorPos.y }
|
|
expect(Math.hypot(anchorPos.x - playerPos.x, anchorPos.y - playerPos.y)).toBeGreaterThan(TELEKINESIS_RANGE_PX)
|
|
expect(Math.hypot(arrivePos.x - playerPos.x, arrivePos.y - playerPos.y)).toBeGreaterThan(TELEKINESIS_RANGE_PX)
|
|
|
|
const enteredWarps: SceneWarp[] = []
|
|
const scene = createTestScene({
|
|
playerPos: { ...playerPos },
|
|
rightSkillId: 43,
|
|
warps: [wideBoxWarp],
|
|
onEnterWarp: (w) => enteredWarps.push(w),
|
|
})
|
|
|
|
const nearCornerWorldX = anchorPos.x - 120
|
|
const nearCornerWorldY = anchorPos.y
|
|
expect(Math.hypot(nearCornerWorldX - playerPos.x, nearCornerWorldY - playerPos.y)).toBeLessThanOrEqual(TELEKINESIS_RANGE_PX)
|
|
|
|
const startMana = scene.hudManager.mana
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 960 + (nearCornerWorldX - playerPos.x),
|
|
clientY: 540 + (nearCornerWorldY - (playerPos.y - 16)),
|
|
button: 2,
|
|
}))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerup', {
|
|
clientX: 960 + (nearCornerWorldX - playerPos.x),
|
|
clientY: 540 + (nearCornerWorldY - (playerPos.y - 16)),
|
|
button: 2,
|
|
}))
|
|
// Must reject activation and refund mana because warp anchor & arrive are > 320px away
|
|
expect(enteredWarps).toHaveLength(0)
|
|
expect(scene.hudManager.mana).toBe(startMana)
|
|
expect(scene.status.textContent).toBe('目标超出心灵传动范围！')
|
|
|
|
// Move player within range (200px left of anchorPos) and hold right mouse down across 5 ticks
|
|
scene.engine.world.player.x = anchorPos.x - 200
|
|
scene.engine.world.player.y = anchorPos.y
|
|
const inRangeClientX = 960 + 200
|
|
const inRangeClientY = 540 - 16
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: inRangeClientX,
|
|
clientY: inRangeClientY,
|
|
button: 2,
|
|
buttons: 2,
|
|
}))
|
|
expect(enteredWarps).toHaveLength(1)
|
|
const manaAfterSingleCast = scene.hudManager.mana
|
|
expect(manaAfterSingleCast).toBeLessThan(startMana)
|
|
|
|
// Holding right button across subsequent ticks must NOT re-cast Telekinesis 25 times/sec
|
|
for (let i = 0; i < 5; i++) {
|
|
scene.controller.tick()
|
|
}
|
|
expect(enteredWarps).toHaveLength(1)
|
|
expect(scene.hudManager.mana).toBe(manaAfterSingleCast)
|
|
})
|
|
|
|
it('handles non-unit collision bitmask bytes (e.g. 0x21) and routes around walls when target is inside a 3x3 blocked footprint', () => {
|
|
const gridW = 100
|
|
const blocked = new Uint8Array(gridW * gridW)
|
|
const grid = {
|
|
originX: 0,
|
|
originY: 0,
|
|
cellsX: 20,
|
|
cellsY: 20,
|
|
gridWidth: gridW,
|
|
blocked,
|
|
}
|
|
// Place a horizontal wall at y = 25, x = 15..25 using non-unit collision bitmask 0x21 (COLLIDE_BLANK | COLLIDE_WALL)
|
|
for (let x = 15; x <= 25; x++) {
|
|
blocked[25 * gridW + x] = 0x21
|
|
}
|
|
// Enclose the target (20, 30) in a 3x3 blocked object footprint (e.g. stash/chest/monster)
|
|
for (let dy = -1; dy <= 1; dy++) {
|
|
for (let dx = -1; dx <= 1; dx++) {
|
|
blocked[(30 + dy) * gridW + (20 + dx)] = 0x04
|
|
}
|
|
}
|
|
|
|
const startPos = subTileToScene(20, 20, grid)
|
|
const targetPos = subTileToScene(20, 30, grid)
|
|
const steer = resolveObstacleAwareSteerTarget(startPos.x, startPos.y, targetPos, grid)
|
|
|
|
// Direct line from (20,20) to (20,30) crosses the 0x21 wall at y=25;
|
|
// A* must route around the wall rather than returning targetPos directly.
|
|
expect(steer).not.toEqual(targetPos)
|
|
const steerSub = sceneToSubTile(steer.x, steer.y, grid)
|
|
expect(blocked[steerSub.y * gridW + steerSub.x]).toBe(0)
|
|
})
|
|
|
|
it('expands badge hit-testing width for long Chinese destination names and cleans up state on detach()', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
// Level 66: 塔·拉夏古墓 (1) -> badgeText = '通往 塔·拉夏古墓 (1)' (13 chars, half-width = 99px > 64px)
|
|
const tombWarp: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Tal Rasha Tomb',
|
|
toLevelId: 66,
|
|
warpId: 49,
|
|
x: 30,
|
|
y: 30,
|
|
arriveX: 31,
|
|
arriveY: 30,
|
|
exitWalkX: 31,
|
|
exitWalkY: 30,
|
|
selectX: -40,
|
|
selectY: -40,
|
|
selectDX: 80,
|
|
selectDY: 80,
|
|
}
|
|
const labelPos = getWarpLabelWorldPos(tombWarp, grid)
|
|
// Click 85px to the right of badge center (> 64px default half-width, within 13-char badge half-width 99px)
|
|
const wideClick = hitTestWarp(tombWarp, labelPos.x + 85, labelPos.y - 12, grid)
|
|
expect(wideClick.hit).toBe(true)
|
|
|
|
const playerPos = subTileToScene(31, 30, grid)
|
|
const children: HTMLDivElement[] = []
|
|
const mockLabelsContainer = {
|
|
children,
|
|
appendChild(el: HTMLDivElement) {
|
|
children.push(el)
|
|
return el
|
|
},
|
|
} as unknown as HTMLElement
|
|
|
|
const scene = createTestScene({
|
|
playerPos: { ...playerPos },
|
|
warps: [tombWarp],
|
|
labelsContainer: mockLabelsContainer,
|
|
})
|
|
|
|
// Hover over the wide badge edge
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointermove', {
|
|
clientX: 960 + ((labelPos.x + 85) - playerPos.x),
|
|
clientY: 540 + ((labelPos.y - 12) - (playerPos.y - 16)),
|
|
}))
|
|
expect(scene.controller.hoveredWarp).toBe(tombWarp)
|
|
expect(scene.canvas.style.cursor).toBe('pointer')
|
|
expect(children[0]!.hidden).toBe(false)
|
|
|
|
// Detach must clear hover, reset cursor, and hide pooled labels
|
|
scene.controller.detach()
|
|
expect(scene.controller.hoveredWarp).toBeNull()
|
|
expect(scene.canvas.style.cursor).toBe('')
|
|
expect(children[0]!.hidden).toBe(true)
|
|
})
|
|
|
|
it('resolves multi-warp and warp-vs-entrance overlaps by true Euclidean distance and prioritizes foreground overhead badges over background LvlWarp.txt boxes', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
// Warp A has a huge LvlWarp.txt selection box centered at (30, 30)
|
|
const warpA: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Harem Level 1',
|
|
toLevelId: 50,
|
|
warpId: 23,
|
|
x: 30,
|
|
y: 30,
|
|
arriveX: 31,
|
|
arriveY: 30,
|
|
exitWalkX: 31,
|
|
exitWalkY: 30,
|
|
selectX: -120,
|
|
selectY: -120,
|
|
selectDX: 240,
|
|
selectDY: 240,
|
|
}
|
|
// Warp B is a zero-box warp at (33, 30) (48px right of Warp A)
|
|
const warpB: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'up',
|
|
label: 'Lut Gholein',
|
|
toLevelId: 40,
|
|
warpId: 22,
|
|
x: 33,
|
|
y: 30,
|
|
arriveX: 34,
|
|
arriveY: 30,
|
|
exitWalkX: 34,
|
|
exitWalkY: 30,
|
|
selectX: 0,
|
|
selectY: 0,
|
|
selectDX: 0,
|
|
selectDY: 0,
|
|
}
|
|
// Entrance C is at (27, 30) (48px left of Warp A)
|
|
const entranceC: SceneEntrance = {
|
|
toLevelId: 41,
|
|
side: 'west',
|
|
label: 'Rocky Waste',
|
|
x: 27,
|
|
y: 30,
|
|
arriveX: 28,
|
|
arriveY: 30,
|
|
}
|
|
|
|
const posB = subTileToScene(warpB.x, warpB.y, grid)
|
|
const posC = subTileToScene(entranceC.x, entranceC.y, grid)
|
|
|
|
// Clicking 16px from Warp B's anchor (still inside Warp A's [-120..120] box, 32px from A's center)
|
|
// must select Warp B because 16px < 32px.
|
|
const hitAatB = hitTestWarp(warpA, posB.x - 16, posB.y, grid)
|
|
const hitBatB = hitTestWarp(warpB, posB.x - 16, posB.y, grid)
|
|
expect(hitAatB.hit).toBe(true)
|
|
expect(hitBatB.hit).toBe(true)
|
|
expect(hitBatB.dist).toBeLessThan(hitAatB.dist)
|
|
|
|
// Clicking 16px from Entrance C's anchor (inside Warp A's box, 32px from A's center)
|
|
// must select Entrance C because 16px < 32px.
|
|
const hitAatC = hitTestWarp(warpA, posC.x + 16, posC.y, grid)
|
|
const hitCatC = hitTestEntrance(entranceC, posC.x + 16, posC.y, grid)
|
|
expect(hitAatC.hit).toBe(true)
|
|
expect(hitCatC.hit).toBe(true)
|
|
expect(hitCatC.dist).toBeLessThan(hitAatC.dist)
|
|
|
|
// Clicking directly on Warp B's overhead badge (which overlaps Warp A's LvlWarp.txt box)
|
|
// must prioritize the foreground overhead badge of Warp B over Warp A's background box.
|
|
const badgeB = getWarpLabelWorldPos(warpB, grid)
|
|
const hitAonBadgeB = hitTestWarp(warpA, badgeB.x + 20, badgeB.y - 12, grid)
|
|
const hitBonBadgeB = hitTestWarp(warpB, badgeB.x + 20, badgeB.y - 12, grid)
|
|
expect(hitAonBadgeB.hit).toBe(true)
|
|
expect(hitBonBadgeB.hit).toBe(true)
|
|
expect(hitBonBadgeB.dist).toBeLessThan(hitAonBadgeB.dist)
|
|
})
|
|
|
|
it('prioritizes an open Town Portal over an overlapping SceneWarp for hover, left-click, and Telekinesis across the full [portalPos.y - 80, portalPos.y] vertical oval', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
const warp: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Den of Evil',
|
|
toLevelId: 8,
|
|
warpId: 4,
|
|
x: 30,
|
|
y: 30,
|
|
arriveX: 31,
|
|
arriveY: 30,
|
|
exitWalkX: 31,
|
|
exitWalkY: 30,
|
|
selectX: -100,
|
|
selectY: -120,
|
|
selectDX: 200,
|
|
selectDY: 160,
|
|
}
|
|
const portalPos = subTileToScene(30, 30, grid)
|
|
const playerPos = subTileToScene(31, 30, grid)
|
|
let enteredPortalCount = 0
|
|
const enteredWarps: SceneWarp[] = []
|
|
|
|
const scene = createTestScene({
|
|
playerPos: { ...playerPos },
|
|
rightSkillId: 43, // Telekinesis
|
|
warps: [warp],
|
|
portalSlot: {
|
|
mouthInLevel: () => ({ x: 30, y: 30 }),
|
|
},
|
|
onEnterPortal: () => {
|
|
enteredPortalCount += 1
|
|
},
|
|
onEnterWarp: (w) => enteredWarps.push(w),
|
|
})
|
|
|
|
// Upper part of the Town Portal oval: (portalPos.x + 24, portalPos.y - 75)
|
|
// Within 48px of [portalPos.y - 80, portalPos.y], and also inside warp's LvlWarp.txt box.
|
|
const targetWorldX = portalPos.x + 24
|
|
const targetWorldY = portalPos.y - 75
|
|
const clientX = 960 + (targetWorldX - playerPos.x)
|
|
const clientY = 540 + (targetWorldY - (playerPos.y - 16))
|
|
|
|
// 1. Hovering the portal oval suppresses hoveredWarp
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointermove', {
|
|
clientX,
|
|
clientY,
|
|
}))
|
|
expect(scene.controller.hoveredWarp).toBeNull()
|
|
|
|
// 2. Left-clicking the portal oval enters the Town Portal instead of the SceneWarp
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX,
|
|
clientY,
|
|
button: 0,
|
|
}))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerup', {
|
|
clientX,
|
|
clientY,
|
|
button: 0,
|
|
}))
|
|
expect(enteredPortalCount).toBe(1)
|
|
expect(enteredWarps).toHaveLength(0)
|
|
|
|
// 3. Right-clicking with Telekinesis (Skill 43) near the top of the portal oval (targetY = portalPos.y - 95,
|
|
// distance to clampedPortalY (portalPos.y - 80) ishypot(30, -15) = 33.5px <= 64px, whereas distance to
|
|
// portalPos.y - 40 is hypot(30, -55) = 62.6px and at (40, -95) is hypot(40, -15) = 42.7px <= 64px vs hypot(40, -55) = 68.0px > 64px)
|
|
// enters the Town Portal rather than the underlying SceneWarp.
|
|
const tkWorldX = portalPos.x + 40
|
|
const tkWorldY = portalPos.y - 95
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX: 960 + (tkWorldX - playerPos.x),
|
|
clientY: 540 + (tkWorldY - (playerPos.y - 16)),
|
|
button: 2,
|
|
}))
|
|
expect(enteredPortalCount).toBe(2)
|
|
expect(enteredWarps).toHaveLength(0)
|
|
})
|
|
|
|
it('clears isLeftMouseDown and activeClickType on warp/entrance/portal trigger and suppresses pointer/tick actions while isTravelling() is true', () => {
|
|
const grid = { originX: 0, originY: 0 }
|
|
const warp: SceneWarp = {
|
|
source: 'tile',
|
|
direction: 'down',
|
|
label: 'Den of Evil',
|
|
toLevelId: 8,
|
|
warpId: 4,
|
|
x: 30,
|
|
y: 30,
|
|
arriveX: 31,
|
|
arriveY: 30,
|
|
exitWalkX: 31,
|
|
exitWalkY: 30,
|
|
selectX: -48,
|
|
selectY: -48,
|
|
selectDX: 96,
|
|
selectDY: 96,
|
|
}
|
|
const anchorPos = subTileToScene(warp.x, warp.y, grid)
|
|
const arrivePos = subTileToScene(warp.arriveX, warp.arriveY, grid)
|
|
const distantPlayer = subTileToScene(45, 30, grid)
|
|
let travelling = false
|
|
const enteredWarps: SceneWarp[] = []
|
|
|
|
const scene = createTestScene({
|
|
playerPos: { ...distantPlayer },
|
|
warps: [warp],
|
|
isTravelling: () => travelling,
|
|
onEnterWarp: (w) => {
|
|
enteredWarps.push(w)
|
|
travelling = true
|
|
},
|
|
})
|
|
|
|
// Hold left mouse button down on distant warp (no pointerup)
|
|
const clientX = 960 + (anchorPos.x - distantPlayer.x)
|
|
const clientY = 540 + (anchorPos.y - (distantPlayer.y - 16))
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX,
|
|
clientY,
|
|
button: 0,
|
|
buttons: 1,
|
|
}))
|
|
expect(scene.controller.isLeftMouseDown).toBe(true)
|
|
expect(scene.controller.activeClickType).toBe('warp')
|
|
expect(scene.controller.pendingInteraction?.kind).toBe('warp')
|
|
|
|
// Arrive at warp while still holding left mouse button down
|
|
scene.engine.world.player.x = arrivePos.x
|
|
scene.engine.world.player.y = arrivePos.y
|
|
const arriveTick = scene.controller.tick()
|
|
expect(enteredWarps).toEqual([warp])
|
|
expect(arriveTick.movement).toEqual({ x: 0, y: 0 })
|
|
// Left mouse hold and activeClickType must be cleared immediately upon transition trigger
|
|
expect(scene.controller.isLeftMouseDown).toBe(false)
|
|
expect(scene.controller.activeClickType).toBe('none')
|
|
|
|
// While travelling is true, new pointerdown events and tick() calls must be suppressed
|
|
scene.canvas.dispatchEvent(new SyntheticPointerEvent('pointerdown', {
|
|
clientX,
|
|
clientY,
|
|
button: 0,
|
|
buttons: 1,
|
|
}))
|
|
expect(scene.controller.isLeftMouseDown).toBe(false)
|
|
expect(enteredWarps).toHaveLength(1)
|
|
expect(scene.controller.tick()).toEqual({ movement: { x: 0, y: 0 }, attacking: false })
|
|
})
|
|
})
|
|
|
|
|