AncTe/template
1
0
Fork 0
mirror of https://github.com/motajs/template.git synced 2026-09-18 05:00:17 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

refactor: 调整录像命名

Browse Source
This commit is contained in:
unanmed 2026-09-16 21:51:19 +08:00
parent 513a9c354c
commit 49aacb087a
11 changed files with 171 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
packages-user/data-base/src/hero/equipment.ts
View File

@ -1,5 +1,5 @@
import { isNil } from 'lodash-es';
import { IDataCommon, ReplayCommandCode } from '@user/data-common';
import { IDataCommon, ReplayCode } from '@user/data-common';
import {
EquipStatus,
IEquipmentState,
@ -192,7 +192,7 @@ export class HeroEquipment<THero> implements IHeroEquipment<THero> {
// 最后恢复录像记录并记录录像
replay.revert();
replay.route.add(ReplayCommandCode.Equip, [uid]);
replay.route.add(ReplayCode.Equip, [uid]);
return curr;
}
@ -209,7 +209,7 @@ export class HeroEquipment<THero> implements IHeroEquipment<THero> {
// 记录录像
const replay = this.state.replaySystem;
replay.route.add(ReplayCommandCode.Unequip, [slot]);
replay.route.add(ReplayCode.Unequip, [slot]);
this.unloadEquipEffect(state);
this.equips.delete(slot);

4
packages-user/data-base/src/hero/items.ts
View File

@ -2,7 +2,7 @@ import { isNil } from 'lodash-es';
import {
IDataCommon,
ItemCategory,
ReplayCommandCode,
ReplayCode,
SaveCompression
} from '@user/data-common';
import { HeroEquipsStore } from './equipStore';
@ -127,7 +127,7 @@ export class HeroItems<THero> implements IHeroItems<THero> {
if (!raw.effect.canUse(raw)) return false;
const replay = this.state.replaySystem;
replay.route.add(ReplayCommandCode.UseItem, [raw.num]);
replay.route.add(ReplayCode.UseItem, [raw.num]);
raw.effect.useEffect(raw);

10
packages-user/data-base/src/hero/mover.ts
View File

@ -7,7 +7,7 @@ import {
ObjectMover,
ObjectMoveType,
IDataCommon,
ReplayCommandCode
ReplayCode
} from '@user/data-common';
import {
HeroMoveCode,
@ -176,16 +176,16 @@ export class HeroMover<T extends IHeroLocation>
const replay = this.state.replaySystem;
switch (handler.direction) {
case FaceDirection.Up:
replay.route.add(ReplayCommandCode.Up, []);
replay.route.add(ReplayCode.Up, []);
break;
case FaceDirection.Right:
replay.route.add(ReplayCommandCode.Right, []);
replay.route.add(ReplayCode.Right, []);
break;
case FaceDirection.Left:
replay.route.add(ReplayCommandCode.Left, []);
replay.route.add(ReplayCode.Left, []);
break;
case FaceDirection.Down:
replay.route.add(ReplayCommandCode.Down, []);
replay.route.add(ReplayCode.Down, []);
break;
default:
logger.warn(176);

2
packages-user/data-common/src/replay/types.ts
View File

@ -2,7 +2,7 @@ import { IHookable, IHookBase } from '@motajs/common';
import { ISaveableContent } from '../save';
/** 录像指令码，数值属于录像格式的一部分 */
export const enum ReplayCommandCode {
export const enum ReplayCode {
/** 向上移动一步 */
Up,
/** 向右移动一步 */

63
packages-user/data-state/src/core.ts
View File

@ -25,7 +25,7 @@ import {
MapStore,
IReplaySystem,
ReplaySystem,
ReplayCommandCode
ReplayCode
} from '@user/data-common';
import {
EnemyManager,
@ -84,11 +84,11 @@ import { isNil } from 'lodash-es';
import { DefaultHeroMoveTopImpl, DefaultPassPredicateImpl } from './hero';
import { createEventRegistrations } from './event/registrations';
import {
ReplayEquipCommand,
ReplayMoveCommand,
ReplayTeleportCommand,
ReplayUnequipCommand,
ReplayUseItemCommand
ReplayEquip,
ReplayMove,
ReplayTeleport,
ReplayUnequip,
ReplayUseItem
} from './replay';
export class CoreState implements ICoreState {
@ -282,38 +282,25 @@ export class CoreState implements ICoreState {
* 注册全部录像指令
*/
private registerReplayCommands() {
this.replaySystem.registerCommand(
ReplayCommandCode.Up,
new ReplayMoveCommand(this, FaceDirection.Up)
);
this.replaySystem.registerCommand(
ReplayCommandCode.Right,
new ReplayMoveCommand(this, FaceDirection.Right)
);
this.replaySystem.registerCommand(
ReplayCommandCode.Down,
new ReplayMoveCommand(this, FaceDirection.Down)
);
this.replaySystem.registerCommand(
ReplayCommandCode.Left,
new ReplayMoveCommand(this, FaceDirection.Left)
);
this.replaySystem.registerCommand(
ReplayCommandCode.Teleport,
new ReplayTeleportCommand(this)
);
this.replaySystem.registerCommand(
ReplayCommandCode.UseItem,
new ReplayUseItemCommand(this)
);
this.replaySystem.registerCommand(
ReplayCommandCode.Equip,
new ReplayEquipCommand(this)
);
this.replaySystem.registerCommand(
ReplayCommandCode.Unequip,
new ReplayUnequipCommand(this)
);
const replay = this.replaySystem;
const up = new ReplayMove(this, FaceDirection.Up);
const right = new ReplayMove(this, FaceDirection.Right);
const down = new ReplayMove(this, FaceDirection.Down);
const left = new ReplayMove(this, FaceDirection.Left);
const teleport = new ReplayTeleport(this);
const useItem = new ReplayUseItem(this);
const equip = new ReplayEquip(this);
const unequip = new ReplayUnequip(this);
replay.registerCommand(ReplayCode.Up, up);
replay.registerCommand(ReplayCode.Right, right);
replay.registerCommand(ReplayCode.Down, down);
replay.registerCommand(ReplayCode.Left, left);
replay.registerCommand(ReplayCode.Teleport, teleport);
replay.registerCommand(ReplayCode.UseItem, useItem);
replay.registerCommand(ReplayCode.Equip, equip);
replay.registerCommand(ReplayCode.Unequip, unequip);
}
/**

116
packages-user/data-state/src/replay/commands.test.ts
View File

@ -8,30 +8,30 @@ import {
endReplaySafetyCollection,
logReplaySafetyDetail,
shouldReplay,
ReplayCommandCode
ReplayCode
} from '@user/data-common';
import { readFileSync } from 'node:fs';
import { describe, expect, it, vi } from 'vitest';
import { createCoreState } from '../core';
import { ReplaySystem } from '../../../data-common/src/replay/system';
import {
ReplayEquipCommand,
ReplayMoveCommand,
ReplayTeleportCommand,
ReplayUnequipCommand,
ReplayUseItemCommand
ReplayEquip,
ReplayMove,
ReplayTeleport,
ReplayUnequip,
ReplayUseItem
} from './commands';
/** 供测试读取的稳定指令码顺序 */
export const REPLAY_COMMAND_ORDER: readonly ReplayCommandCode[] = [
ReplayCommandCode.Up,
ReplayCommandCode.Right,
ReplayCommandCode.Down,
ReplayCommandCode.Left,
ReplayCommandCode.Teleport,
ReplayCommandCode.UseItem,
ReplayCommandCode.Equip,
ReplayCommandCode.Unequip
export const REPLAY_COMMAND_ORDER: readonly ReplayCode[] = [
ReplayCode.Up,
ReplayCode.Right,
ReplayCode.Down,
ReplayCode.Left,
ReplayCode.Teleport,
ReplayCode.UseItem,
ReplayCode.Equip,
ReplayCode.Unequip
];
function step(
@ -61,14 +61,14 @@ describe('replay commands', () => {
it('registers the eight stable commands in order on every CoreState', () => {
const state = createCoreState();
expect(REPLAY_COMMAND_ORDER).toEqual([
ReplayCommandCode.Up,
ReplayCommandCode.Right,
ReplayCommandCode.Down,
ReplayCommandCode.Left,
ReplayCommandCode.Teleport,
ReplayCommandCode.UseItem,
ReplayCommandCode.Equip,
ReplayCommandCode.Unequip
ReplayCode.Up,
ReplayCode.Right,
ReplayCode.Down,
ReplayCode.Left,
ReplayCode.Teleport,
ReplayCode.UseItem,
ReplayCode.Equip,
ReplayCode.Unequip
]);
expect(
REPLAY_COMMAND_ORDER.every(code =>
@ -113,11 +113,11 @@ describe('replay commands', () => {
const start = vi
.spyOn(mover, 'start')
.mockReturnValueOnce(controller(first.promise));
const command = new ReplayMoveCommand(state, FaceDirection.Right);
const command = new ReplayMove(state, FaceDirection.Right);
await expect(
command.execute(step(ReplayCommandCode.Right, []))
).resolves.toBe(true);
await expect(command.execute(step(ReplayCode.Right, []))).resolves.toBe(
true
);
expect(move).toHaveBeenCalledWith(FaceDirection.Right);
expect(start).not.toHaveBeenCalled();
@ -139,10 +139,10 @@ describe('replay commands', () => {
const error = vi.spyOn(logger, 'error');
const mover = state.hero.location.mover;
(mover as unknown as { moving: boolean }).moving = true;
const command = new ReplayMoveCommand(state, FaceDirection.Up);
await expect(
command.execute(step(ReplayCommandCode.Up, []))
).resolves.toBe(false);
const command = new ReplayMove(state, FaceDirection.Up);
await expect(command.execute(step(ReplayCode.Up, []))).resolves.toBe(
false
);
expect(error).toHaveBeenCalledWith(2003);
(mover as unknown as { moving: boolean }).moving = false;
@ -162,11 +162,11 @@ describe('replay commands', () => {
controller: controller(first.promise),
path: []
});
const command = new ReplayTeleportCommand(state);
const command = new ReplayTeleport(state);
let result: boolean | undefined;
const pending = command
.execute(step(ReplayCommandCode.Teleport, [2, 3]))
.execute(step(ReplayCode.Teleport, [2, 3]))
.then(value => {
result = value;
});
@ -180,7 +180,7 @@ describe('replay commands', () => {
const error = vi.spyOn(logger, 'error');
teleport.mockReturnValueOnce(null);
await expect(
command.execute(step(ReplayCommandCode.Teleport, [4, 5]))
command.execute(step(ReplayCode.Teleport, [4, 5]))
).resolves.toBe(false);
expect(error).toHaveBeenCalledWith(2005, '4', '5');
error.mockRestore();
@ -194,13 +194,13 @@ describe('replay commands', () => {
.spyOn(state.hero.items, 'useItem')
.mockReturnValueOnce(true)
.mockReturnValueOnce(false);
const command = new ReplayUseItemCommand(state);
const command = new ReplayUseItem(state);
await expect(
command.execute(step(ReplayCommandCode.UseItem, [12]))
command.execute(step(ReplayCode.UseItem, [12]))
).resolves.toBe(true);
await expect(
command.execute(step(ReplayCommandCode.UseItem, [34]))
command.execute(step(ReplayCode.UseItem, [34]))
).resolves.toBe(false);
expect(useItem).toHaveBeenNthCalledWith(1, 12);
expect(error).toHaveBeenCalledWith(2006, '34');
@ -217,19 +217,19 @@ describe('replay commands', () => {
const equip = vi
.spyOn(equipment, 'equip')
.mockImplementation(() => undefined);
const command = new ReplayEquipCommand(state);
const command = new ReplayEquip(state);
// 装备后槽位为指定 uid
getEquipped.mockReturnValueOnce(99);
await expect(
command.execute(step(ReplayCommandCode.Equip, [99, 0, true]))
command.execute(step(ReplayCode.Equip, [99, 0, true]))
).resolves.toBe(true);
expect(equip).toHaveBeenCalledWith(99, 0, true);
// 装备后槽位未变为指定 uid
getEquipped.mockReturnValueOnce(undefined);
await expect(
command.execute(step(ReplayCommandCode.Equip, [99, 1, false]))
command.execute(step(ReplayCode.Equip, [99, 1, false]))
).resolves.toBe(false);
expect(error).toHaveBeenCalledWith(2007, '99', '1');
@ -245,19 +245,19 @@ describe('replay commands', () => {
const unequip = vi
.spyOn(equipment, 'unequip')
.mockImplementation(() => undefined);
const command = new ReplayUnequipCommand(state);
const command = new ReplayUnequip(state);
// 卸下后槽位为空
getEquipped.mockReturnValueOnce(undefined);
await expect(
command.execute(step(ReplayCommandCode.Unequip, [0]))
command.execute(step(ReplayCode.Unequip, [0]))
).resolves.toBe(true);
expect(unequip).toHaveBeenCalledWith(0);
// 卸下后槽位仍有装备
getEquipped.mockReturnValueOnce(88);
await expect(
command.execute(step(ReplayCommandCode.Unequip, [1]))
command.execute(step(ReplayCode.Unequip, [1]))
).resolves.toBe(false);
expect(error).toHaveBeenCalledWith(2008, '1');
@ -277,8 +277,8 @@ describe('replay commands', () => {
.spyOn(state.hero.items, 'useItem')
.mockReturnValueOnce(true);
const replay = state.replaySystem;
replay.record(ReplayCommandCode.Right);
replay.record(ReplayCommandCode.UseItem, 5);
replay.record(ReplayCode.Right);
replay.record(ReplayCode.UseItem, 5);
const sandbox = replay.createReplaySandbox({
route: replay.route,
reseter: { reset: () => {} }
@ -302,20 +302,20 @@ describe('replay commands', () => {
// 验证参数数量或类型不符的指令以 false 结束
it('returns false for invalid command parameters', async () => {
const state = createCoreState();
const move = new ReplayMoveCommand(state, FaceDirection.Up);
const teleport = new ReplayTeleportCommand(state);
const useItem = new ReplayUseItemCommand(state);
const equip = new ReplayEquipCommand(state);
const unequip = new ReplayUnequipCommand(state);
const move = new ReplayMove(state, FaceDirection.Up);
const teleport = new ReplayTeleport(state);
const useItem = new ReplayUseItem(state);
const equip = new ReplayEquip(state);
const unequip = new ReplayUnequip(state);
const invalid = [
move.execute(step(ReplayCommandCode.Up, [1])),
teleport.execute(step(ReplayCommandCode.Teleport, ['x', 1])),
teleport.execute(step(ReplayCommandCode.Teleport, [1])),
useItem.execute(step(ReplayCommandCode.UseItem, [])),
useItem.execute(step(ReplayCommandCode.UseItem, ['id'])),
equip.execute(step(ReplayCommandCode.Equip, [1, 0])),
equip.execute(step(ReplayCommandCode.Equip, [1, 0, 'x'])),
unequip.execute(step(ReplayCommandCode.Unequip, ['slot']))
move.execute(step(ReplayCode.Up, [1])),
teleport.execute(step(ReplayCode.Teleport, ['x', 1])),
teleport.execute(step(ReplayCode.Teleport, [1])),
useItem.execute(step(ReplayCode.UseItem, [])),
useItem.execute(step(ReplayCode.UseItem, ['id'])),
equip.execute(step(ReplayCode.Equip, [1, 0])),
equip.execute(step(ReplayCode.Equip, [1, 0, 'x'])),
unequip.execute(step(ReplayCode.Unequip, ['slot']))
];
await expect(Promise.all(invalid)).resolves.toEqual([
false,

22
packages-user/data-state/src/replay/commands.ts
View File

@ -70,10 +70,7 @@ export abstract class BaseReplayCommand implements IReplayCommand {
//#region 移动指令
export class ReplayMoveCommand
extends BaseReplayCommand
implements IReplayCommand
{
export class ReplayMove extends BaseReplayCommand implements IReplayCommand {
protected readonly name: string = 'move';
protected readonly paramTypes: readonly string[] = [];
@ -112,7 +109,7 @@ export class ReplayMoveCommand
//#region 瞬移指令
export class ReplayTeleportCommand
export class ReplayTeleport
extends BaseReplayCommand
implements IReplayCommand
{
@ -136,10 +133,7 @@ export class ReplayTeleportCommand
//#region 使用物品指令
export class ReplayUseItemCommand
extends BaseReplayCommand
implements IReplayCommand
{
export class ReplayUseItem extends BaseReplayCommand implements IReplayCommand {
protected readonly name: string = 'use-item';
protected readonly paramTypes: readonly string[] = ['number'];
@ -158,10 +152,7 @@ export class ReplayUseItemCommand
//#region 装备指令
export class ReplayEquipCommand
extends BaseReplayCommand
implements IReplayCommand
{
export class ReplayEquip extends BaseReplayCommand implements IReplayCommand {
protected readonly name: string = 'equip';
protected readonly paramTypes: readonly string[] = [
'number',
@ -190,10 +181,7 @@ export class ReplayEquipCommand
//#region 卸下装备指令
export class ReplayUnequipCommand
extends BaseReplayCommand
implements IReplayCommand
{
export class ReplayUnequip extends BaseReplayCommand implements IReplayCommand {
protected readonly name: string = 'unequip';
protected readonly paramTypes: readonly string[] = ['number'];

40
packages-user/data-state/test/dataClosure.test.ts
View File

@ -7,7 +7,7 @@ import {
ItemCategory,
ReplaySystem,
SaveCompression,
ReplayCommandCode,
ReplayCode,
TileType
} from '@user/data-common';
import { IEnemy, IReadonlyHeroAttribute } from '@user/data-base';
@ -17,15 +17,15 @@ import { MainDamageCalculator } from '../src/enemy/calculator';
import { createClosedLoopFixture } from './fixtures/closed-loop';
/** 供测试读取的稳定指令码顺序 */
export const REPLAY_COMMAND_ORDER: readonly ReplayCommandCode[] = [
ReplayCommandCode.Up,
ReplayCommandCode.Right,
ReplayCommandCode.Down,
ReplayCommandCode.Left,
ReplayCommandCode.Teleport,
ReplayCommandCode.UseItem,
ReplayCommandCode.Equip,
ReplayCommandCode.Unequip
export const REPLAY_COMMAND_ORDER: readonly ReplayCode[] = [
ReplayCode.Up,
ReplayCode.Right,
ReplayCode.Down,
ReplayCode.Left,
ReplayCode.Teleport,
ReplayCode.UseItem,
ReplayCode.Equip,
ReplayCode.Unequip
];
vi.hoisted(() => {
@ -258,19 +258,19 @@ describe('DATA-01 closure', () => {
)
).toBe(true);
expect(REPLAY_COMMAND_ORDER).toEqual([
ReplayCommandCode.Up,
ReplayCommandCode.Right,
ReplayCommandCode.Down,
ReplayCommandCode.Left,
ReplayCommandCode.Teleport,
ReplayCommandCode.UseItem,
ReplayCommandCode.Equip,
ReplayCommandCode.Unequip
ReplayCode.Up,
ReplayCode.Right,
ReplayCode.Down,
ReplayCode.Left,
ReplayCode.Teleport,
ReplayCode.UseItem,
ReplayCode.Equip,
ReplayCode.Unequip
]);
state.replaySystem.record(ReplayCommandCode.Right, 4, 'route');
state.replaySystem.record(ReplayCode.Right, 4, 'route');
expect(state.replaySystem.route.get(0)).toMatchObject({
command: ReplayCommandCode.Right,
command: ReplayCode.Right,
params: [4, 'route']
});

4
packages-user/data-state/test/fixtures/closed-loop.ts vendored
View File

@ -8,7 +8,7 @@ import {
IReplayArray,
IEnemyAttr,
IHeroAttr,
ReplayCommandCode,
ReplayCode,
SaveCompression,
TileType
} from '@user/data-common';
@ -168,7 +168,7 @@ export function createClosedLoopFixture(): IClosedLoopFixture {
state.hero.location.mover.setFaceDir(FaceDirection.Right);
const replay = state.replaySystem;
replay.record(ReplayCommandCode.Right);
replay.record(ReplayCode.Right);
const route = replay.route;
const initialState: IClosedLoopInitialState = {

96
packages-user/data-state/test/replayPlayback.test.ts
View File

@ -3,7 +3,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
import { logger } from '@motajs/common';
import {
FaceDirection,
ReplayCommandCode,
ReplayCode,
SaveCompression,
TileType,
type IReplayArray,
@ -14,11 +14,11 @@ import {
import { type CoreState, createCoreState } from '../src/core';
import { DefaultPassPredicateImpl } from '../src/hero/predicate';
import {
ReplayEquipCommand,
ReplayMoveCommand,
ReplayTeleportCommand,
ReplayUnequipCommand,
ReplayUseItemCommand
ReplayEquip,
ReplayMove,
ReplayTeleport,
ReplayUnequip,
ReplayUseItem
} from '../src/replay/commands';
vi.hoisted(() => {
@ -235,16 +235,16 @@ describe('replay recording and route read-back', () => {
const replay = state.replaySystem;
replay.disable();
replay.record(ReplayCommandCode.Right);
replay.record(ReplayCode.Right);
expect(replay.route.length).toBe(0);
replay.disable();
replay.revert();
replay.record(ReplayCommandCode.Right);
replay.record(ReplayCode.Right);
expect(replay.route.length).toBe(0);
replay.revert();
replay.record(ReplayCommandCode.Right);
replay.record(ReplayCode.Right);
expect(replay.route.length).toBe(1);
});
@ -252,31 +252,31 @@ describe('replay recording and route read-back', () => {
it('reads back every stable command code and its params', () => {
const state = createCoreState();
const replay = state.replaySystem;
replay.record(ReplayCommandCode.Up);
replay.record(ReplayCommandCode.Teleport, 3, 4);
replay.record(ReplayCommandCode.UseItem, 12);
replay.record(ReplayCommandCode.Equip, 99, 1, true);
replay.record(ReplayCommandCode.Unequip, 1);
replay.record(ReplayCode.Up);
replay.record(ReplayCode.Teleport, 3, 4);
replay.record(ReplayCode.UseItem, 12);
replay.record(ReplayCode.Equip, 99, 1, true);
replay.record(ReplayCode.Unequip, 1);
expect(replay.route.length).toBe(5);
expect(replay.route.get(0)).toMatchObject({
command: ReplayCommandCode.Up,
command: ReplayCode.Up,
params: []
});
expect(replay.route.get(1)).toMatchObject({
command: ReplayCommandCode.Teleport,
command: ReplayCode.Teleport,
params: [3, 4]
});
expect(replay.route.get(2)).toMatchObject({
command: ReplayCommandCode.UseItem,
command: ReplayCode.UseItem,
params: [12]
});
expect(replay.route.get(3)).toMatchObject({
command: ReplayCommandCode.Equip,
command: ReplayCode.Equip,
params: [99, 1, true]
});
expect(replay.route.get(4)).toMatchObject({
command: ReplayCommandCode.Unequip,
command: ReplayCode.Unequip,
params: [1]
});
});
@ -292,7 +292,7 @@ describe('replay recording and route read-back', () => {
expect(state.replaySystem.route.length).toBe(1);
expect(state.replaySystem.route.get(0)).toMatchObject({
command: ReplayCommandCode.Right,
command: ReplayCode.Right,
params: []
});
});
@ -322,18 +322,18 @@ describe('small-map replay playback and second recording', () => {
await runHeroStep(state, FaceDirection.Right);
await runHeroStep(state, FaceDirection.Right);
replay.record(ReplayCommandCode.Teleport, 1, 0);
replay.record(ReplayCommandCode.Up);
replay.record(ReplayCode.Teleport, 1, 0);
replay.record(ReplayCode.Up);
const firstSteps = snapshotRoute(replay.route);
expect(firstSteps.map(item => item.code)).toEqual([
ReplayCommandCode.Right,
ReplayCommandCode.Right,
ReplayCommandCode.Teleport,
ReplayCommandCode.Up
ReplayCode.Right,
ReplayCode.Right,
ReplayCode.Teleport,
ReplayCode.Up
]);
expect(replay.route.get(2)).toMatchObject({
command: ReplayCommandCode.Teleport,
command: ReplayCode.Teleport,
params: [1, 0]
});
@ -347,8 +347,8 @@ describe('small-map replay playback and second recording', () => {
await runHeroStep(state, FaceDirection.Right);
await runHeroStep(state, FaceDirection.Right);
replay.record(ReplayCommandCode.Teleport, 1, 0);
replay.record(ReplayCommandCode.Up);
replay.record(ReplayCode.Teleport, 1, 0);
replay.record(ReplayCode.Up);
const secondSteps = snapshotRoute(replay.route);
expectReplayEqual(secondSteps, firstSteps);
@ -368,7 +368,7 @@ describe('small-map replay playback and second recording', () => {
);
state.pathfinding.finder.useMapLayer(map.eventLayer);
await runHeroStep(state, FaceDirection.Right);
replay.record(ReplayCommandCode.Teleport, 2, 0);
replay.record(ReplayCode.Teleport, 2, 0);
await playRoute(state);
@ -382,16 +382,16 @@ describe('replay playback error codes 2001-2008', () => {
it('warns 2001 and 2002 for parameter count and type mismatches', async () => {
const state = createCoreState();
const error = vi.spyOn(logger, 'error');
const move = new ReplayMoveCommand(state, FaceDirection.Up);
const teleport = new ReplayTeleportCommand(state);
const move = new ReplayMove(state, FaceDirection.Up);
const teleport = new ReplayTeleport(state);
await expect(
move.execute(step(ReplayCommandCode.Up, [1]))
).resolves.toBe(false);
await expect(move.execute(step(ReplayCode.Up, [1]))).resolves.toBe(
false
);
expect(error).toHaveBeenCalledWith(2001, 'move', '0', '1');
await expect(
teleport.execute(step(ReplayCommandCode.Teleport, ['x', 1]))
teleport.execute(step(ReplayCode.Teleport, ['x', 1]))
).resolves.toBe(false);
expect(error).toHaveBeenCalledWith(
2002,
@ -407,12 +407,12 @@ describe('replay playback error codes 2001-2008', () => {
const state = createCoreState();
const error = vi.spyOn(logger, 'error');
const mover = state.hero.location.mover;
const move = new ReplayMoveCommand(state, FaceDirection.Up);
const move = new ReplayMove(state, FaceDirection.Up);
(mover as unknown as { moving: boolean }).moving = true;
await expect(
move.execute(step(ReplayCommandCode.Up, []))
).resolves.toBe(false);
await expect(move.execute(step(ReplayCode.Up, []))).resolves.toBe(
false
);
expect(error).toHaveBeenCalledWith(2003);
(mover as unknown as { moving: boolean }).moving = false;
@ -426,10 +426,10 @@ describe('replay playback error codes 2001-2008', () => {
const state = createCoreState();
const error = vi.spyOn(logger, 'error');
vi.spyOn(state.pathfinding, 'teleportTo').mockReturnValueOnce(null);
const teleport = new ReplayTeleportCommand(state);
const teleport = new ReplayTeleport(state);
await expect(
teleport.execute(step(ReplayCommandCode.Teleport, [4, 5]))
teleport.execute(step(ReplayCode.Teleport, [4, 5]))
).resolves.toBe(false);
expect(error).toHaveBeenCalledWith(2005, '4', '5');
});
@ -439,10 +439,10 @@ describe('replay playback error codes 2001-2008', () => {
const state = createCoreState();
const error = vi.spyOn(logger, 'error');
vi.spyOn(state.hero.items, 'useItem').mockReturnValueOnce(false);
const useItem = new ReplayUseItemCommand(state);
const useItem = new ReplayUseItem(state);
await expect(
useItem.execute(step(ReplayCommandCode.UseItem, [34]))
useItem.execute(step(ReplayCode.UseItem, [34]))
).resolves.toBe(false);
expect(error).toHaveBeenCalledWith(2006, '34');
});
@ -454,10 +454,10 @@ describe('replay playback error codes 2001-2008', () => {
const equipment = state.hero.equip;
vi.spyOn(equipment, 'equip').mockImplementation(() => undefined);
vi.spyOn(equipment, 'getEquipped').mockReturnValueOnce(undefined);
const equip = new ReplayEquipCommand(state);
const equip = new ReplayEquip(state);
await expect(
equip.execute(step(ReplayCommandCode.Equip, [99, 1, false]))
equip.execute(step(ReplayCode.Equip, [99, 1, false]))
).resolves.toBe(false);
expect(error).toHaveBeenCalledWith(2007, '99', '1');
});
@ -469,10 +469,10 @@ describe('replay playback error codes 2001-2008', () => {
const equipment = state.hero.equip;
vi.spyOn(equipment, 'unequip').mockImplementation(() => undefined);
vi.spyOn(equipment, 'getEquipped').mockReturnValueOnce(88);
const unequip = new ReplayUnequipCommand(state);
const unequip = new ReplayUnequip(state);
await expect(
unequip.execute(step(ReplayCommandCode.Unequip, [1]))
unequip.execute(step(ReplayCode.Unequip, [1]))
).resolves.toBe(false);
expect(error).toHaveBeenCalledWith(2008, '1');
});

11
packages-user/data-system/src/path/system.ts
View File

@ -1,9 +1,5 @@
import { ITileLocator, logger } from '@motajs/common';
import {
IObjectMovable,
IObjectMover,
ReplayCommandCode
} from '@user/data-common';
import { IObjectMovable, IObjectMover, ReplayCode } from '@user/data-common';
import { HeroMover, IStateBase } from '@user/data-base';
import { isNil } from 'lodash-es';
import { PathfindingFinder } from './finder';
@ -103,10 +99,7 @@ export class PathfindingSystem implements IPathfindingSystem {
// TODO：后续需要调整设计方式，最好不用 instanceof
if (this.mover instanceof HeroMover) {
const replay = this.state.replaySystem;
replay.route.add(ReplayCommandCode.Teleport, [
target.x,
target.y
]);
replay.route.add(ReplayCode.Teleport, [target.x, target.y]);
}
return this.startMove(path, true);
}