405 lines
14 KiB
TypeScript
405 lines
14 KiB
TypeScript
import UpgraderHandler from '@/roleHandlers/upgrader.handler';
|
|
import * as getById from '@/utils/funcs/getById';
|
|
import {
|
|
PositionSpotStatus,
|
|
createSourcePositionMatrix,
|
|
} from '@/utils/positions';
|
|
import '~/tests/__mocks__/screeps';
|
|
|
|
// ─── Helpers ────────────────────────────────────────────────────────────────
|
|
|
|
function makeState(overrides: Partial<GameState> = {}): GameState {
|
|
const spots = createSourcePositionMatrix(PositionSpotStatus.EMPTY);
|
|
return {
|
|
sourcesStates: {
|
|
src1: { spots },
|
|
},
|
|
...overrides,
|
|
} as unknown as GameState;
|
|
}
|
|
|
|
function makeCreepMemory(overrides: Partial<CreepMemory> = {}): CreepMemory {
|
|
return {
|
|
role: 'upgrader',
|
|
spawnId: 'spawn1',
|
|
...overrides,
|
|
} as CreepMemory;
|
|
}
|
|
|
|
function makeStore(used: number, capacity: number) {
|
|
return {
|
|
getFreeCapacity: (_res: string) => capacity - used,
|
|
getUsedCapacity: (_res: string) => used,
|
|
};
|
|
}
|
|
|
|
function makePos(x = 0, y = 0, roomName = 'W1N1') {
|
|
return new (global as any).RoomPosition(x, y, roomName);
|
|
}
|
|
|
|
function makeSource(id = 'src1', x = 5, y = 5, roomName = 'W1N1') {
|
|
return {
|
|
id,
|
|
pos: makePos(x, y, roomName),
|
|
} as unknown as Source;
|
|
}
|
|
|
|
function makeController(id = 'ctrl1') {
|
|
return { id } as unknown as StructureController;
|
|
}
|
|
|
|
function makeCreep(
|
|
memoryOverrides: Partial<CreepMemory> = {},
|
|
storeUsed = 0,
|
|
storeCapacity = 50,
|
|
controller: StructureController | null = null
|
|
): Creep {
|
|
const memory = makeCreepMemory(memoryOverrides);
|
|
return {
|
|
name: 'Creep1',
|
|
memory,
|
|
store: makeStore(storeUsed, storeCapacity),
|
|
pos: makePos(),
|
|
room: {
|
|
controller:
|
|
controller !== null ? (controller ?? makeController()) : null,
|
|
},
|
|
harvest: jest.fn().mockReturnValue((global as any).OK),
|
|
moveTo: jest.fn().mockReturnValue((global as any).OK),
|
|
upgradeController: jest.fn().mockReturnValue((global as any).OK),
|
|
} as unknown as Creep;
|
|
}
|
|
|
|
// ─── Tests ───────────────────────────────────────────────────────────────────
|
|
|
|
describe('UpgraderHandler', () => {
|
|
beforeEach(() => {
|
|
jest.clearAllMocks();
|
|
jest.spyOn(console, 'log').mockImplementation(() => {});
|
|
});
|
|
|
|
afterEach(() => {
|
|
jest.restoreAllMocks();
|
|
});
|
|
|
|
// ── destroy ──────────────────────────────────────────────────────────────
|
|
|
|
describe('destroy', () => {
|
|
it('releases the source spot from destination and clears it', () => {
|
|
const state = makeState();
|
|
state.sourcesStates['src1'].spots[0] = PositionSpotStatus.OCCUPIED;
|
|
|
|
const memory = makeCreepMemory({
|
|
destination: { type: 'source', id: 'src1', sourceSpot: 0 },
|
|
});
|
|
|
|
UpgraderHandler.destroy(memory, state);
|
|
|
|
expect(state.sourcesStates['src1'].spots[0]).toBe(
|
|
PositionSpotStatus.EMPTY
|
|
);
|
|
expect(memory.destination).toBeUndefined();
|
|
});
|
|
|
|
it('releases the source spot from previousDestination and clears it', () => {
|
|
const state = makeState();
|
|
state.sourcesStates['src1'].spots[3] = PositionSpotStatus.OCCUPIED;
|
|
|
|
const memory = makeCreepMemory({
|
|
previousDestination: {
|
|
type: 'source',
|
|
id: 'src1',
|
|
sourceSpot: 3,
|
|
},
|
|
});
|
|
|
|
UpgraderHandler.destroy(memory, state);
|
|
|
|
expect(state.sourcesStates['src1'].spots[3]).toBe(
|
|
PositionSpotStatus.EMPTY
|
|
);
|
|
expect(memory.previousDestination).toBeUndefined();
|
|
});
|
|
|
|
it('does nothing when destination is not a source', () => {
|
|
const state = makeState();
|
|
const memory = makeCreepMemory({
|
|
destination: { type: 'controller', id: 'ctrl1' },
|
|
});
|
|
|
|
UpgraderHandler.destroy(memory, state);
|
|
|
|
expect(
|
|
state.sourcesStates['src1'].spots.every(
|
|
(s: PositionSpotStatus) =>
|
|
s === PositionSpotStatus.EMPTY ||
|
|
s === PositionSpotStatus.CENTER
|
|
)
|
|
).toBe(true);
|
|
});
|
|
|
|
it('does nothing when memory has no destination', () => {
|
|
const state = makeState();
|
|
const memory = makeCreepMemory();
|
|
|
|
expect(() => UpgraderHandler.destroy(memory, state)).not.toThrow();
|
|
});
|
|
});
|
|
|
|
// ── validateCreepMemory (via run) ────────────────────────────────────────
|
|
|
|
describe('validateCreepMemory (via run)', () => {
|
|
it('releases previousDestination source spot and deletes it', () => {
|
|
const state = makeState();
|
|
state.sourcesStates['src1'].spots[1] = PositionSpotStatus.OCCUPIED;
|
|
|
|
const creep = makeCreep({
|
|
previousDestination: {
|
|
type: 'source',
|
|
id: 'src1',
|
|
sourceSpot: 1,
|
|
},
|
|
});
|
|
|
|
jest.spyOn(getById, 'getSourceById').mockReturnValue(null);
|
|
|
|
UpgraderHandler.run(creep, state);
|
|
|
|
expect(state.sourcesStates['src1'].spots[1]).toBe(
|
|
PositionSpotStatus.EMPTY
|
|
);
|
|
expect(creep.memory.previousDestination).toBeUndefined();
|
|
});
|
|
|
|
it('transitions from source to controller destination when energy is full', () => {
|
|
const state = makeState();
|
|
const source = makeSource();
|
|
jest.spyOn(getById, 'getSourceById').mockReturnValue(source);
|
|
|
|
const controller = makeController();
|
|
jest.spyOn(getById, 'getControllerById').mockReturnValue(
|
|
controller
|
|
);
|
|
|
|
const creep = makeCreep(
|
|
{
|
|
destination: { type: 'source', id: 'src1', sourceSpot: 0 },
|
|
},
|
|
50, // full
|
|
50,
|
|
controller
|
|
);
|
|
|
|
UpgraderHandler.run(creep, state);
|
|
|
|
expect(creep.memory.destination?.type).toBe('controller');
|
|
expect(creep.memory.previousDestination?.type).toBe('source');
|
|
});
|
|
|
|
it('clears controller destination when energy is empty', () => {
|
|
const state = makeState();
|
|
const controller = makeController();
|
|
jest.spyOn(getById, 'getControllerById').mockReturnValue(
|
|
controller
|
|
);
|
|
|
|
const creep = makeCreep(
|
|
{ destination: { type: 'controller', id: 'ctrl1' } },
|
|
0, // empty
|
|
50,
|
|
controller
|
|
);
|
|
|
|
UpgraderHandler.run(creep, state);
|
|
|
|
expect(creep.memory.destination).toBeUndefined();
|
|
});
|
|
|
|
it('clears destination and logs when room has no controller during source→controller transition', () => {
|
|
const state = makeState();
|
|
// Occupy all spots so onFindNewSource cannot reassign a source
|
|
state.sourcesStates['src1'].spots = state.sourcesStates[
|
|
'src1'
|
|
].spots.map((s: PositionSpotStatus) =>
|
|
s === PositionSpotStatus.CENTER
|
|
? s
|
|
: PositionSpotStatus.OCCUPIED
|
|
) as any;
|
|
|
|
jest.spyOn(getById, 'getSourceById').mockReturnValue(makeSource());
|
|
|
|
const creep = makeCreep(
|
|
{ destination: { type: 'source', id: 'src1', sourceSpot: 0 } },
|
|
50,
|
|
50,
|
|
null // no controller in room
|
|
);
|
|
|
|
UpgraderHandler.run(creep, state);
|
|
|
|
expect(creep.memory.destination).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
// ── onFindNewSource ───────────────────────────────────────────────────────
|
|
|
|
describe('onFindNewSource', () => {
|
|
it('assigns the first available source spot to the creep', () => {
|
|
const state = makeState();
|
|
jest.spyOn(getById, 'getSourceById').mockReturnValue(makeSource());
|
|
|
|
const creep = makeCreep(); // no destination, empty store
|
|
|
|
UpgraderHandler.run(creep, state);
|
|
|
|
expect(creep.memory.destination?.type).toBe('source');
|
|
expect((creep.memory.destination as any).id).toBe('src1');
|
|
});
|
|
|
|
it('does not assign a source when all spots are occupied', () => {
|
|
const state = makeState();
|
|
state.sourcesStates['src1'].spots = state.sourcesStates[
|
|
'src1'
|
|
].spots.map((s: PositionSpotStatus) =>
|
|
s === PositionSpotStatus.CENTER
|
|
? s
|
|
: PositionSpotStatus.OCCUPIED
|
|
) as any;
|
|
|
|
jest.spyOn(getById, 'getSourceById').mockReturnValue(makeSource());
|
|
const creep = makeCreep();
|
|
|
|
UpgraderHandler.run(creep, state);
|
|
|
|
expect(creep.memory.destination).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
// ── onSourceDestination ───────────────────────────────────────────────────
|
|
|
|
describe('onSourceDestination', () => {
|
|
it('harvests when in range', () => {
|
|
const state = makeState();
|
|
const source = makeSource();
|
|
jest.spyOn(getById, 'getSourceById').mockReturnValue(source);
|
|
|
|
const creep = makeCreep(
|
|
{ destination: { type: 'source', id: 'src1', sourceSpot: 0 } },
|
|
0,
|
|
50
|
|
);
|
|
(creep.harvest as jest.Mock).mockReturnValue((global as any).OK);
|
|
|
|
UpgraderHandler.run(creep, state);
|
|
|
|
expect(creep.harvest).toHaveBeenCalledWith(source);
|
|
expect(creep.moveTo).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('moves to source when not in range', () => {
|
|
const state = makeState();
|
|
const source = makeSource();
|
|
jest.spyOn(getById, 'getSourceById').mockReturnValue(source);
|
|
|
|
const creep = makeCreep(
|
|
{ destination: { type: 'source', id: 'src1', sourceSpot: 0 } },
|
|
0,
|
|
50
|
|
);
|
|
(creep.harvest as jest.Mock).mockReturnValue(
|
|
(global as any).ERR_NOT_IN_RANGE
|
|
);
|
|
|
|
UpgraderHandler.run(creep, state);
|
|
|
|
expect(creep.moveTo).toHaveBeenCalled();
|
|
});
|
|
|
|
it('logs and returns when source is not found', () => {
|
|
const state = makeState();
|
|
jest.spyOn(getById, 'getSourceById').mockReturnValue(null);
|
|
|
|
const creep = makeCreep(
|
|
{
|
|
destination: {
|
|
type: 'source',
|
|
id: 'unknown',
|
|
sourceSpot: 0,
|
|
},
|
|
},
|
|
0,
|
|
50
|
|
);
|
|
|
|
expect(() => UpgraderHandler.run(creep, state)).not.toThrow();
|
|
expect(creep.harvest).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
// ── onControllerDestination ───────────────────────────────────────────────
|
|
|
|
describe('onControllerDestination', () => {
|
|
it('upgrades controller when in range', () => {
|
|
const state = makeState();
|
|
const controller = makeController();
|
|
jest.spyOn(getById, 'getControllerById').mockReturnValue(
|
|
controller
|
|
);
|
|
|
|
const creep = makeCreep(
|
|
{ destination: { type: 'controller', id: 'ctrl1' } },
|
|
50,
|
|
50,
|
|
controller
|
|
);
|
|
(creep.upgradeController as jest.Mock).mockReturnValue(
|
|
(global as any).OK
|
|
);
|
|
|
|
UpgraderHandler.run(creep, state);
|
|
|
|
expect(creep.upgradeController).toHaveBeenCalledWith(controller);
|
|
expect(creep.moveTo).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('moves to controller when not in range', () => {
|
|
const state = makeState();
|
|
const controller = makeController();
|
|
jest.spyOn(getById, 'getControllerById').mockReturnValue(
|
|
controller
|
|
);
|
|
|
|
const creep = makeCreep(
|
|
{ destination: { type: 'controller', id: 'ctrl1' } },
|
|
50,
|
|
50,
|
|
controller
|
|
);
|
|
(creep.upgradeController as jest.Mock).mockReturnValue(
|
|
(global as any).ERR_NOT_IN_RANGE
|
|
);
|
|
|
|
UpgraderHandler.run(creep, state);
|
|
|
|
expect(creep.moveTo).toHaveBeenCalledWith(
|
|
controller,
|
|
expect.any(Object)
|
|
);
|
|
});
|
|
|
|
it('logs and returns when controller is not found by ID', () => {
|
|
const state = makeState();
|
|
jest.spyOn(getById, 'getControllerById').mockReturnValue(null);
|
|
|
|
const creep = makeCreep(
|
|
{ destination: { type: 'controller', id: 'ctrl1' } },
|
|
50,
|
|
50
|
|
);
|
|
|
|
expect(() => UpgraderHandler.run(creep, state)).not.toThrow();
|
|
expect(creep.upgradeController).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
});
|