prefix
stringlengths 82
32.6k
| middle
stringlengths 5
470
| suffix
stringlengths 0
81.2k
| file_path
stringlengths 6
168
| repo_name
stringlengths 16
77
| context
listlengths 5
5
| lang
stringclasses 4
values | ground_truth
stringlengths 5
470
|
|---|---|---|---|---|---|---|---|
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
const gameData = await gameEngineProvider.getGameData(game.id);
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider.removePlayer(game.id, player.id, 'leave');
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
const rankings = await ds.Leaderboard.getTopN(20);
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort((a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
|
const gameData = await gameEngineProvider.startGame(game.id);
|
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game.gameState = `ended_${now.format(DATE_FORMAT)}`;
game.endedAt = now.format(FULL_DATETIME_FORMAT);
let gameData: GameEngine.IGameData | undefined = undefined;
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
await gameEngineProvider.endGame(game.id);
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
}
|
src/apis/coop.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8590794801712036
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\n static async endGame(gameId: string) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n engine.gameData.state = 'abandoned';\n engine.broadcast.push({ type: 'gameEnd' });\n });\n }\n static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n if (engine.gameData.players.has(playerId)) throw new Error('player already in game');",
"score": 0.8444929122924805
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const playerState = await engine._createPlayerState(playerId, cardIds);\n engine.gameData.players.set(playerId, playerState);\n engine.broadcast.push({ type: 'playerJoin', playerState });\n }\n engine.gameData.pendingPlayers.clear();\n engine.gameData.state = 'started';\n engine.broadcast.push({ type: 'gameStart' });\n engine.ruleset.initGame(engine);\n });\n return gameData;",
"score": 0.8365572690963745
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const existingGameData = await ds.GameData.get(gameId);\n if (existingGameData) throw new Error('game with id already exists: ' + gameId);\n const gameData: GameEngine.IGameData = {\n id: gameId,\n difficulty: Math.max(1, difficulty),\n state: 'created',\n turn: 1,\n players: new Map(),\n defaultMovesPerTurn: 3,\n enemies: [],",
"score": 0.8283168077468872
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " // Stop if the game was won/lost due to an EndTurn effect\n return;\n }\n engine.onTurnStart();\n }\n });\n }\n static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {\n let kickedPlayerId = '';\n await _Engine._withEngine(gameId, ['started'], async engine => {",
"score": 0.823363721370697
}
] |
typescript
|
const gameData = await gameEngineProvider.startGame(game.id);
|
import * as moment from 'moment';
import { z } from 'zod';
import { IAuthProvider, IDataSource, IMetricsProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { toClientDeck, toClientPlayer } from '../models';
import { IHttpRouteHandler, StatusCodes } from '../net-utils';
import { FULL_DATETIME_FORMAT } from '../utils';
export const createDeckHandler = (ds: IDataSource, authProvider: IAuthProvider, metrics?: IMetricsProvider): IHttpRouteHandler =>
async (path, query, body, req) => {
switch (path[0]) {
case 'activate': {
const schema = z.object({
deckId: z.string(),
});
const payload = schema.parse(body);
const player = await authProvider.getPlayerFromRequest(req);
const deck = await ds.CardDecks.get(player.id, payload.deckId);
if (!deck) return [StatusCodes.notFound];
player.activeDeckId = deck.createdAt;
await ds.Players.update.exec(player);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), deck: toClientDeck(player, deck) }];
}
case 'create': {
const schema = z.object({
deckLabel: z.string().min(1).max(20),
nftIds: z.array(z.string().startsWith('nft1')).length(6),
});
const payload = schema.parse(body);
const player = await authProvider.getPlayerFromRequest(req);
const nfts = (await Promise.all((payload.nftIds).slice(0, 6).map(ExtDeps.getNft))).filter(Boolean).map(x => x.nft);
if (nfts.length !== 6) {
return [StatusCodes.forbidden, { reason: `not enough nftIds, need 6, got ${nfts.length}` }];
}
const deck = await ds.CardDecks.update.exec({
playerId: player.id,
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
label: payload.deckLabel,
cards: nfts.map(x => ({ nftId: x.nftId, mintHeight: x.firstBlock, url: x.urls[0] || '' })),
});
metrics?.deckUpdated(player.id, deck.createdAt);
return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];
}
case 'list': {
const schema = z.object({
ct: z.string().optional(),
});
const q = schema.parse(query);
const player = await authProvider.getPlayerFromRequest(req);
const decks = await Promise.all((await ds.CardDecks.queryByDid(player.id, 10, q.ct)).items);
if (!decks.length) {
const defaultDeck = await getOrCreateActiveDeck(player, ds);
defaultDeck && decks.push(defaultDeck)
}
return [StatusCodes.ok, { decks: decks.map(deck => toClientDeck(player, deck)) }];
}
case 'update': {
const schema = z.object({
deckId: z.string(),
deckLabel: z.string().min(1).max(20),
nftIds: z.array(z.string().startsWith('nft1')).length(6),
});
const payload = schema.parse(body);
const uniqueNftIds = new Set<string>(payload.nftIds);
if (uniqueNftIds.size !== 6) {
return [StatusCodes.badRequest, { reason: 'nftIds must contain 6 unique NFT ids that belong to the player' }];
}
const player = await authProvider.getPlayerFromRequest(req);
const deck = await ds.CardDecks.get(player.id, payload.deckId);
if (!deck) {
return [StatusCodes.notFound, { reason: 'invalid deck id' }];
}
payload.deckLabel && (deck.label = deck.label);
const nfts = (await Promise.all((payload.nftIds).map(ExtDeps.getNft))).filter((x): x is NonNullable<typeof x> => x?.nft.did === player.id).map(x => x.nft);
if (nfts.length !== payload.nftIds.length) {
return [StatusCodes.notFound, { reason: 'one or more nft ids were not found, or did not belong to the player' }];
}
deck.cards = nfts.map(x => ({ nftId: x.nftId, mintHeight: x.firstBlock, url: x.urls[0] || '' }));
await ds.CardDecks.update.exec(deck);
metrics?.deckUpdated(player.id, deck.createdAt);
return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];
}
case 'activeDeck': {
const player = await authProvider.getPlayerFromRequest(req);
return [StatusCodes.ok, { deck: toClientDeck(player, await getOrCreateActiveDeck(player, ds)) }];
}
default: {
if (!path[0]) {
return;
}
const player = await authProvider.getPlayerFromRequest(req);
const deck = await ds.CardDecks.get(player.id, path[0]);
if (!deck) {
return [StatusCodes.notFound];
}
return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];
}
}
};
export const getOrCreateActiveDeck = async (player: IDataSource.IPlayer, ds: IDataSource) => {
let deck = player.activeDeckId ? (await ds.CardDecks.get(player.id, player.activeDeckId)) : null;
if (deck) {
return deck;
}
|
const cards = (await ExtDeps.getNftsByDidOrWallet(player.id, 6))?.nfts.filter(Boolean) || [];
|
if (cards.length < 6) {
return null;
}
const nowStr = moment.utc().format(FULL_DATETIME_FORMAT);
player.activeDeckId = nowStr;
deck = {
playerId: player.id,
createdAt: nowStr,
cards: cards.map(x => ({ nftId: x.nftId, mintHeight: x.firstBlock, url: x.urls[0] || '' })),
label: 'default',
};
await ds.execUpdates(
ds.Players.update.make(player, true),
ds.CardDecks.update.make(deck, true),
);
return deck;
};
|
src/apis/decks.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " }\n async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {\n const deck = await getOrCreateActiveDeck(player, ds);\n if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');\n if (validateNftOwnership) {\n const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));\n if (nfts.find(x => !x || x.nft.did !== player.id)) {\n metrics?.nftOwnershipConflict(player.id);\n throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');\n }",
"score": 0.9087264537811279
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const gameData = await ds.GameData.get(gameId);\n if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n return gameData;\n }\n private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {\n const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))\n .filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)\n .map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));\n if (cards.length !== cardIds.length) {\n throw `could not resolve all cards for player ${playerId}`;",
"score": 0.8778350353240967
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " const [deck, game] = await Promise.all([\n _expectValidActiveDeck(player, true),\n _expectCoopGameJoinable(teammate.activeGameId),\n ]);\n const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));\n player.activeGameId = game.id;\n game.playersIds.add(player.id);\n game.ingorePlayerIds.delete(player.id);\n await ds.execUpdates(\n ds.Players.update.make(player),",
"score": 0.8661097288131714
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " const rankings = await ds.Leaderboard.getTopN(20);\n return [StatusCodes.ok, { rankings }];\n }\n case 'search': {\n const player = await _expectAuthPlayerNotInGame(req);\n // Don't need to validate nft ownership yet, either join() or create() will do this\n const deck = await _expectValidActiveDeck(player, false);\n let ct: any = undefined;\n do {\n const result = await ds.CoopGames.queryByGameState('open', 10, ct);",
"score": 0.8538633584976196
},
{
"filename": "src/models.ts",
"retrieved_chunk": "import { appraiseCard } from './appraise';\nimport { IAuthProvider, IDataSource } from './dependencies';\nexport const toClientPlayer = (player: IDataSource.IPlayer, authProvider: IAuthProvider) => {\n return {\n ...player,\n authToken: authProvider.getAuthTokenForPlayer(player),\n };\n}\nexport const toClientDeck = (player: IDataSource.IPlayer, deck: IDataSource.ICardDeck | null) => {\n if (!deck) return null;",
"score": 0.8518247008323669
}
] |
typescript
|
const cards = (await ExtDeps.getNftsByDidOrWallet(player.id, 6))?.nfts.filter(Boolean) || [];
|
import * as moment from 'moment';
import { z } from 'zod';
import { IAuthProvider, IDataSource, IMetricsProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { toClientPlayer } from '../models';
import { IHttpRouteHandler, StatusCodes } from '../net-utils';
import { FULL_DATETIME_FORMAT } from '../utils';
export const createPlayerHandler = (ds: IDataSource, authProvider: IAuthProvider, metrics?: IMetricsProvider): IHttpRouteHandler =>
async (path, _query, body, req) => {
switch (path[0]) {
case 'connectDid': {
const schema = z.object({
didProof: z.object({
latestCoinId: z.string(),
pubkey: z.string(),
signature: z.string(),
}),
});
const payload = schema.parse(body);
const did = (await ExtDeps.verifyDidProof({
...payload.didProof,
message: 'Proof of DID ownership for ChiaTCG',
}))?.did;
if (!did) {
return [StatusCodes.unauthorized, { reason: 'unable to validate did proof' }];
}
let player = await ds.Players.get(did);
const isNew = !player;
const now = moment.utc();
const newSecret = authProvider.generateNewSecret();
const newAuthExpireAt = moment.utc(now).add({ days: 14 }).format(FULL_DATETIME_FORMAT);
if (!player) {
const nowStr = now.format(FULL_DATETIME_FORMAT);
player = await ds.Players.update.exec({
id: did,
createdAt: nowStr,
lastSeenAt: nowStr,
secret: newSecret,
authExpiresAt: newAuthExpireAt,
activeGameId: '',
activeDeckId: 'default',
score: 0,
});
metrics?.newUser(player.id);
} else {
ds.Leaderboard.set(player.id, player.score);
player.secret = newSecret;
player.authExpiresAt = newAuthExpireAt;
await ds.Players.update.exec(player);
}
return [StatusCodes.ok, {
player
|
: toClientPlayer(player, authProvider),
status: isNew ? 'new' : 'existing',
}];
|
}
case 'me': {
const player = await authProvider.getPlayerFromRequest(req);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
}
return;
};
|
src/apis/players.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " ds.CoopGames.update.make(game),\n );\n if (!game.startedAt && game.playersIds.size >= 2) {\n await _onGameStart(game, !!payload.fromMatchmaking);\n }\n metrics?.gameJoined(game.id, gameData.turn >= 2);\n return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];\n }\n case 'leave': {\n const { player, game } = await _expectAuthPlayerInGame(req);",
"score": 0.8692513108253479
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " game.startedAt = now.format(FULL_DATETIME_FORMAT);\n game._dbTtl = 9999999999;\n await ds.CoopGames.update.exec(game);\n metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);\n }\n async function _expectAuthPlayerInGame(req: IHttpRequest) {\n const player = await authProvider.getPlayerFromRequest(req);\n if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');\n const game = await ds.CoopGames.get(player.activeGameId);\n if (game) {",
"score": 0.8654800057411194
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " removePlayers && (player.activeGameId = '');\n const playerState = gameData?.players.get(playerId);\n if (playerState?.score) {\n player.score += playerState?.score || 0;\n await ds.Leaderboard.set(player.id, player.score);\n }\n return [\n ds.PlayerCoopGames.update.make({\n playerId,\n endedAt: game.endedAt,",
"score": 0.859790563583374
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];\n }\n case 'history': {\n const playerId = authProvider.getPlayerIdFromRequest(req);\n const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);\n return [StatusCodes.ok, games];\n }\n case 'join': {\n const schema = z.object({\n teammateDid: z.string().nonempty(),",
"score": 0.8595261573791504
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " await gameEngineProvider.removePlayer(game.id, player.id, 'leave');\n } catch {\n // Respect the player's request to leave even if the gameData couldn't be updated for some reason\n }\n if (!game.playersIds.size) {\n await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);\n }\n return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];\n }\n case 'rankings': {",
"score": 0.8591442108154297
}
] |
typescript
|
: toClientPlayer(player, authProvider),
status: isNew ? 'new' : 'existing',
}];
|
import { GameEngine } from './game/game-engine';
import { IHttpRequest } from './net-utils';
declare namespace IDataSource {
export type GetterSingle<MODEL> = (id: string) => Promise<MODEL | null>;
export type GetterPair<MODEL> = (id1: string, id2: string) => Promise<MODEL | null>;
export type UpdateRequest = any;
export type Updater<MODEL> = {
/**
* Creates an UpdateRequest for the specified item that can be used with execUpdates(...).
*/
make(item: MODEL, overwrite?: boolean): UpdateRequest;
/**
* Updates the specified item. Fails if the specified item has changed since it was retrieved if `overwrite` is true.
*/
exec(item: MODEL, overwrite?: boolean): Promise<typeof item>;
};
export type Query<KEY, MODEL> = (key: NonNullable<KEY>, limit?: number, ct?: string) => Promise<{ items: MODEL[]; ct?: typeof ct; }>;
export interface ICardDeck {
readonly playerId: string;
readonly createdAt: string;
cards: { nftId: string, mintHeight: number, url: string }[];
label: string;
}
export type CardDecks = {
get: GetterPair<ICardDeck>;
update: Updater<ICardDeck>;
queryByDid: Query<ICardDeck['playerId'], ICardDeck>;
};
export interface ICoopGame {
id: string;
difficulty: number;
createdAt: string;
gameState: 'open' | 'private' | `ended_${string}`;
playersIds: Set<string>;
ingorePlayerIds: Set<string>;
startedAt: string;
endedAt: string;
isCompleted: boolean;
_dbTtl?: number;
}
export type CoopGames = {
get: GetterSingle<ICoopGame>;
update: Updater<ICoopGame>;
queryByGameState: Query<ICoopGame['gameState'], ICoopGame>;
};
export interface IPlayer {
id: string;
createdAt: string;
lastSeenAt: string;
secret: string;
authExpiresAt: string;
activeGameId: string;
activeDeckId: string;
score: number;
}
export type Players = {
get: GetterSingle<IPlayer>;
update: Updater<IPlayer>;
};
export interface IPlayerCoopGame {
playerId: string;
endedAt: string;
gameId: string;
gameResult: 'win' | 'loss' | 'abandoned' | 'unknown';
teammates: string[];
score: number;
turns: number;
difficulty: number;
rulesetIds: string[];
}
export type PlayerCoopGame = {
update: Updater<IPlayerCoopGame>;
queryByPlayerId: Query<string, IPlayerCoopGame>;
}
export type GameData = {
|
get: GetterSingle<GameEngine.IGameData>;
|
update: Updater<GameEngine.IGameData>;
};
export type Leaderboard = {
getTopN(n: number): Promise<[string, number][]>;
set(playerId: string, score: number): Promise<void>;
};
}
declare interface IDataSource {
CardDecks: IDataSource.CardDecks;
CoopGames: IDataSource.CoopGames;
GameData: IDataSource.GameData;
Leaderboard: IDataSource.Leaderboard;
PlayerCoopGames: IDataSource.PlayerCoopGame;
Players: IDataSource.Players;
/**
* Transactionlly executes all UpdateRequests; no changes are made if any one of the UpdateRquests fail.
*/
execUpdates(...updateRequests: IDataSource.UpdateRequest[]): Promise<void>;
}
declare interface IAuthProvider {
generateNewSecret(): string;
getAuthTokenForPlayer(player: IDataSource.IPlayer): string;
getPlayerFromRequest(req: IHttpRequest): Promise<IDataSource.IPlayer>;
getPlayerIdFromRequest(req: IHttpRequest): string;
}
declare namespace IPlayerPushProvider {
export interface IPushMessage {
[key: string]: any;
type: string;
}
}
declare interface IPlayerPushProvider {
push(playerId: string, messages: IPlayerPushProvider.IPushMessage[]): Promise<void>;
}
declare interface IRateLimitProvider {
shouldRateLimitCreateGame(playerId: string): Promise<boolean>;
shouldRateLimitSearchGame(playerId: string): Promise<boolean>;
}
declare interface IMetricsProvider {
userPresence(playerId: string): void;
httpRequest(path: string, status: number): void;
wsRequest(api: string, isSuccess: boolean): void;
newUser(playerId: string): void;
deckUpdated(playerId: string, deckId: string): void;
nftOwnershipConflict(playerId: string): void;
gameCreated(gameId: string, playerId: string, initialRulesetId: string, visibility: string, difficulty: number): void;
gameStarted(gameId: string, initialRulesetId: string, players: string[], fromMatchmaking: boolean): void;
gameJoined(gameId: string, midGame: boolean): void;
gameEnded(gameId: string, result: string, rulesets: string[], players: string[], turns: number, totalScore: number): void;
playerCardPlayed(gameId: string, currentRulesetId: string, playerId: string, card: GameEngine.IPlayerCardState, scriptName: string): void;
idlePlayerRemoved(gameId: string, idlePlayerId: string): void;
flush(): Promise<void>;
}
|
src/dependencies.d.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " rulesetIds: string[];\n }\n export interface IPlayerState {\n id: string;\n cards: IPlayerCardState[];\n endedTurn: boolean;\n idleKickTime: number;\n movesLeft: number;\n movesPerTurn: number;\n score: number;",
"score": 0.8824900388717651
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " },\n Players: {\n ...playersTable,\n },\n PlayerCoopGames: {\n ...playerCoopGamesTable,\n async queryByPlayerId(playerId: string) {\n return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };\n },\n },",
"score": 0.8633221387863159
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " id: string;\n difficulty: number;\n state: 'created' | 'started' | 'players_won' | 'players_lost' | 'abandoned';\n enemies: IEnemyCardState[];\n maxEnemies: number;\n players: Map<string, IPlayerState>;\n defaultMovesPerTurn: number;\n turn: number;\n nextId: number;\n pendingPlayers: Map<string, string[]>;",
"score": 0.8517004251480103
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " teammates: _getOtherPlayerIds(player.id, game),\n turns: gameData.turn,\n difficulty: gameData.difficulty,\n rulesetIds: gameData.rulesetIds,\n }, true);\n }\n } catch (e: any) {\n console.error(e);\n }\n try {",
"score": 0.8496715426445007
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " },\n },\n CoopGames: {\n ...coopGamesTable,\n async queryByGameState(gameState) {\n return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };\n },\n },\n GameData: {\n ...createMockTableSingleKey<GameEngine.IGameData>('id'),",
"score": 0.8482472896575928
}
] |
typescript
|
get: GetterSingle<GameEngine.IGameData>;
|
import * as moment from 'moment';
import { z } from 'zod';
import { IAuthProvider, IDataSource, IMetricsProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { toClientDeck, toClientPlayer } from '../models';
import { IHttpRouteHandler, StatusCodes } from '../net-utils';
import { FULL_DATETIME_FORMAT } from '../utils';
export const createDeckHandler = (ds: IDataSource, authProvider: IAuthProvider, metrics?: IMetricsProvider): IHttpRouteHandler =>
async (path, query, body, req) => {
switch (path[0]) {
case 'activate': {
const schema = z.object({
deckId: z.string(),
});
const payload = schema.parse(body);
const player = await authProvider.getPlayerFromRequest(req);
const deck = await ds.CardDecks.get(player.id, payload.deckId);
if (!deck) return [StatusCodes.notFound];
player.activeDeckId = deck.createdAt;
await ds.Players.update.exec(player);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), deck: toClientDeck(player, deck) }];
}
case 'create': {
const schema = z.object({
deckLabel: z.string().min(1).max(20),
nftIds: z.array(z.string().startsWith('nft1')).length(6),
});
const payload = schema.parse(body);
const player = await authProvider.getPlayerFromRequest(req);
const nfts = (await Promise.all((payload.nftIds).slice(0, 6).map(ExtDeps.getNft))).filter(Boolean).map(x => x.nft);
if (nfts.length !== 6) {
return [StatusCodes.forbidden, { reason: `not enough nftIds, need 6, got ${nfts.length}` }];
}
const deck = await ds.CardDecks.update.exec({
playerId: player.id,
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
label: payload.deckLabel,
cards: nfts.map(x => ({ nftId: x.nftId, mintHeight: x.firstBlock, url: x.urls[0] || '' })),
});
metrics?.deckUpdated(player.id, deck.createdAt);
return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];
}
case 'list': {
const schema = z.object({
ct: z.string().optional(),
});
const q = schema.parse(query);
const player = await authProvider.getPlayerFromRequest(req);
const decks = await Promise.all((await ds.CardDecks.queryByDid(player.id, 10, q.ct)).items);
if (!decks.length) {
const defaultDeck = await getOrCreateActiveDeck(player, ds);
defaultDeck && decks.push(defaultDeck)
}
return [StatusCodes.ok, {
|
decks: decks.map(deck => toClientDeck(player, deck)) }];
|
}
case 'update': {
const schema = z.object({
deckId: z.string(),
deckLabel: z.string().min(1).max(20),
nftIds: z.array(z.string().startsWith('nft1')).length(6),
});
const payload = schema.parse(body);
const uniqueNftIds = new Set<string>(payload.nftIds);
if (uniqueNftIds.size !== 6) {
return [StatusCodes.badRequest, { reason: 'nftIds must contain 6 unique NFT ids that belong to the player' }];
}
const player = await authProvider.getPlayerFromRequest(req);
const deck = await ds.CardDecks.get(player.id, payload.deckId);
if (!deck) {
return [StatusCodes.notFound, { reason: 'invalid deck id' }];
}
payload.deckLabel && (deck.label = deck.label);
const nfts = (await Promise.all((payload.nftIds).map(ExtDeps.getNft))).filter((x): x is NonNullable<typeof x> => x?.nft.did === player.id).map(x => x.nft);
if (nfts.length !== payload.nftIds.length) {
return [StatusCodes.notFound, { reason: 'one or more nft ids were not found, or did not belong to the player' }];
}
deck.cards = nfts.map(x => ({ nftId: x.nftId, mintHeight: x.firstBlock, url: x.urls[0] || '' }));
await ds.CardDecks.update.exec(deck);
metrics?.deckUpdated(player.id, deck.createdAt);
return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];
}
case 'activeDeck': {
const player = await authProvider.getPlayerFromRequest(req);
return [StatusCodes.ok, { deck: toClientDeck(player, await getOrCreateActiveDeck(player, ds)) }];
}
default: {
if (!path[0]) {
return;
}
const player = await authProvider.getPlayerFromRequest(req);
const deck = await ds.CardDecks.get(player.id, path[0]);
if (!deck) {
return [StatusCodes.notFound];
}
return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];
}
}
};
export const getOrCreateActiveDeck = async (player: IDataSource.IPlayer, ds: IDataSource) => {
let deck = player.activeDeckId ? (await ds.CardDecks.get(player.id, player.activeDeckId)) : null;
if (deck) {
return deck;
}
const cards = (await ExtDeps.getNftsByDidOrWallet(player.id, 6))?.nfts.filter(Boolean) || [];
if (cards.length < 6) {
return null;
}
const nowStr = moment.utc().format(FULL_DATETIME_FORMAT);
player.activeDeckId = nowStr;
deck = {
playerId: player.id,
createdAt: nowStr,
cards: cards.map(x => ({ nftId: x.nftId, mintHeight: x.firstBlock, url: x.urls[0] || '' })),
label: 'default',
};
await ds.execUpdates(
ds.Players.update.make(player, true),
ds.CardDecks.update.make(deck, true),
);
return deck;
};
|
src/apis/decks.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];\n }\n case 'history': {\n const playerId = authProvider.getPlayerIdFromRequest(req);\n const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);\n return [StatusCodes.ok, games];\n }\n case 'join': {\n const schema = z.object({\n teammateDid: z.string().nonempty(),",
"score": 0.8914487361907959
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " const rankings = await ds.Leaderboard.getTopN(20);\n return [StatusCodes.ok, { rankings }];\n }\n case 'search': {\n const player = await _expectAuthPlayerNotInGame(req);\n // Don't need to validate nft ownership yet, either join() or create() will do this\n const deck = await _expectValidActiveDeck(player, false);\n let ct: any = undefined;\n do {\n const result = await ds.CoopGames.queryByGameState('open', 10, ct);",
"score": 0.878765344619751
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " } while (ct);\n // No joinable game found - proceed to create a public game\n const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);\n return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);\n }\n case 'start': {\n const { game } = await _expectAuthPlayerInGame(req);\n const gameData = await ds.GameData.get(game.id);\n if (gameData?.state !== 'created') {\n return [StatusCodes.forbidden];",
"score": 0.8703807592391968
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " fromMatchmaking: z.boolean().optional(),\n });\n const payload = schema.parse(body);\n const [player, teammate] = await Promise.all([\n _expectAuthPlayerNotInGame(req),\n ds.Players.get(payload.teammateDid),\n ]);\n if (!teammate?.activeGameId) {\n return [StatusCodes.notFound];\n }",
"score": 0.8597676157951355
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " return [StatusCodes.ok, {\n player: toClientPlayer(player, authProvider),\n status: isNew ? 'new' : 'existing',\n }];\n }\n case 'me': {\n const player = await authProvider.getPlayerFromRequest(req);\n return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];\n }\n }",
"score": 0.8583452701568604
}
] |
typescript
|
decks: decks.map(deck => toClientDeck(player, deck)) }];
|
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export abstract class CardMod {
duration = -1;
stackingConfig: Parameters<typeof CardMod['makeStackingData']>[0] = { behavior: CardMod.StackingBehavior.neverReplace };
readonly modName: string;
constructor(
private _extraModData?: IArguments,
) {
this.modName = this.constructor.name;
}
onSecDamageIn?(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState): { secDmgBonus: number } | void;
onSecDamageOut?(deps: CardMod.ICardModDeps, baseDmg: number): { secDmgBonus: number } | void;
onMemDmgIn?(deps: CardMod.ICardModDeps, memDmg: number): void;
onMemDmgOut?(deps: CardMod.ICardModDeps, memDmg: number): void;
onInitMod?(deps: CardMod.ICardModDeps): void;
onRemoveMod?(deps: CardMod.ICardModDeps): void;
onCardDestroyed?(deps: CardMod.ICardModDeps): void;
onStackMod?(deps: CardMod.ICardModDeps, stackDelta: number): void;
onTurnStart?(deps: CardMod.ICardModDeps): void;
onTurnEnd?(deps: CardMod.ICardModDeps): void;
onEnemyDestroyed?(deps: CardMod.ICardModDeps): void;
serialize() {
const stackingData = CardMod.makeStackingData(this.stackingConfig);
const modData = [this.modName, stackingData] as CardMod.ModData;
(this.duration >= 0) && (modData.push(CardMod.makeDurationData(this.duration)));
this._extraModData && modData.push(...this._extraModData);
return modData;
}
static addMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, mod: CardMod, contextCard?: GameEngine.ICardState) {
const modData = mod.serialize();
switch (mod.stackingConfig.behavior) {
case CardMod.StackingBehavior.append: {
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.neverReplace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) return;
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.ranked: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
if (existingStackingData[2] >= mod.stackingConfig.rank) {
return;
}
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.replace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.stack: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
existingStackingData && (existingStackingData[2] += mod.stackingConfig.stackCount);
engine.broadcast.push({
type: 'modStackChanged',
cardId: card.id,
modData: existingModData,
stackDelta: mod.stackingConfig.stackCount,
newStackCount: existingStackingData[2],
});
this.trigger('onStackMod', existingModData, { engine, sourceCard: card, contextCard }, mod.stackingConfig.stackCount);
return;
}
card.mods.push(modData);
break;
}
}
engine.broadcast.push({
type: 'modAdded',
cardId: card.id,
modData,
});
this.trigger('onInitMod', modData, { engine, sourceCard: card, contextCard });
}
static areEqual(left: CardMod.ModData, right: CardMod.ModData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, modData: CardMod.ModData) {
const modCtor = engine.ruleset.cardMods?.[modData[0]];
if (!modCtor) throw new Error('mod not found: ' + modData.join());
const durationData = this.findDurationData(modData);
const mod = new modCtor(...modData.slice(durationData ? 3 : 2));
durationData && (mod.duration = durationData[1]);
const stackingData = modData[1];
mod.stackingConfig.behavior = stackingData[1];
switch (stackingData[1]) {
case CardMod.StackingBehavior.ranked:
(mod.stackingConfig as any).rank = stackingData[2];
break;
case CardMod.StackingBehavior.stack:
(mod.stackingConfig as any).stackCount = stackingData[2];
break;
}
return mod;
}
static findDurationData(modData: CardMod.ModData) {
const maybeDurationData = modData[2];
return (Array.isArray(maybeDurationData) && maybeDurationData[0] === '$duration') ? (modData[2] as CardMod.DurationData) : undefined;
}
static findModOfType(card: GameEngine.ICardState, modType: CardMod.ModConstructor) {
return card.mods.find(x => x[0] === modType.name);
}
static getStackCount(modData: CardMod.ModData) {
return modData[1][1] === CardMod.StackingBehavior.stack ? modData[1][2] : 0;
}
static makeDurationData(duration: number): CardMod.DurationData {
return ['$duration', duration];
}
static makeStackingData(
stackConfig: { behavior: CardMod.StackingBehavior.append }
| { behavior: CardMod.StackingBehavior.neverReplace }
| { behavior: CardMod.StackingBehavior.ranked, rank: number }
| { behavior: CardMod.StackingBehavior.replace }
| { behavior: CardMod.StackingBehavior.stack, stackCount: number }
) {
const stackingData = ['$stack', stackConfig.behavior];
(stackConfig.behavior === CardMod.StackingBehavior.ranked) && stackingData.push(stackConfig.rank);
(stackConfig.behavior === CardMod.StackingBehavior.stack) && stackingData.push(stackConfig.stackCount);
return stackingData as CardMod.StackingData;
}
static removeMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modData: CardMod.ModData, contextCard?: GameEngine.ICardState) {
engine.broadcast.push({
type: 'modRemoved',
cardId: card.id,
modData,
});
if (!card.mods.find(x => this.areEqual(x, modData))) {
throw new Error('mod not found');
}
this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });
card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));
}
static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {
const mod = card.mods.find(x => x[0] === modName);
mod && this.removeMod(engine, card, mod, contextCard);
}
static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {
const deps = args[0];
const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));
if (!modDataFromCard) {
throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);
}
const mod = this.deserialize(deps.engine, modDataFromCard);
const evnt = mod[ev];
const evntRetVal = evnt ? (evnt as any).apply(mod, args) : undefined;
if (deps.sourceCard.isRemoved) {
return;
}
if (ev === 'onTurnStart') {
const durationData = this.findDurationData(modDataFromCard);
if (durationData) {
if (durationData[1] > 1) {
durationData[1]--;
deps.engine.broadcast.push({
type: 'modDurationChanged',
cardId: deps.sourceCard.id,
modData: modData,
newDuration: durationData[1],
});
} else {
this.removeMod(deps.engine, deps.sourceCard, modData);
}
}
}
return evntRetVal as ReturnType<NonNullable<CardMod[T]>> | undefined;
}
}
export namespace CardMod {
export type ModData = [string, StackingData, ...unknown[],];
export type DurationData = ['$duration', number];
export type EnemyModData = unknown[];
export type ModConstructor = TypeConstructor<CardMod>;
export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;
export type ModLibrary = Record<string, ModConstructor>;
export type AppendStackingData = ['$stack', StackingBehavior.append];
export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];
export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];
export type ReplaceStackingData = ['$stack', StackingBehavior.replace];
export type StackStackingData = ['$stack', StackingBehavior.stack, number];
export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;
export enum StackingBehavior {
append,
neverReplace,
ranked,
replace,
stack,
}
export interface ICardModDeps {
engine: GameEngine.IGameEngine;
sourceCard: GameEngine.ICardState;
contextCard?: GameEngine.ICardState;
}
export namespace Content {
// Defines a card modifier - the class name is treated as the mod name
export class backdoor extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(public damage: number) {
// Any extra data to serialize into this.modData as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display modifier effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI modifiers,
// see _standardAi below for example
super(arguments);
this.stackingConfig.rank = damage;
}
}
export class diagnostics extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public secBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = secBonus;
}
override onTurnEnd(deps: ICardModDeps): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
}
export class firewall extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(override duration: number) {
super(arguments);
this.stackingConfig.rank = duration;
}
override onInitMod(deps: ICardModDeps) {
if (GameEngineUtils.
|
isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
|
return;
}
GameEngineUtils.revalidateIntents(deps.engine, true);
}
}
export class impervious extends CardMod {
constructor(override duration = -1) {
super(arguments);
}
override onSecDamageIn(_deps: ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return {
secDmgBonus: -9999,
};
}
}
export class lag extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class offline extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
}
GameEngineUtils.revalidateIntents(deps.engine, GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard));
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class secured extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public tempSecBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = tempSecBonus;
}
override onInitMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
override onStackMod(deps: ICardModDeps, stackDelta: number): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, stackDelta, false);
}
override onRemoveMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -this.stackingConfig.stackCount, true);
}
}
export class _waveBonus_extraMove extends CardMod {
override onInitMod(deps: ICardModDeps): void {
const player = GameEngineUtils.findPlayerByCardId(deps.engine.gameData, deps.sourceCard.id);
player.movesPerTurn++;
player.movesLeft = player.movesPerTurn;
deps.engine.broadcast.push({
type: 'movesPerTurnsChange',
playerId: player.id,
newMovesLeft: player.movesLeft,
newMovesPerTurn: player.movesPerTurn,
});
}
}
export class _winOnDeath extends CardMod {
override onCardDestroyed(deps: ICardModDeps) {
const player = deps.contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null;
player && player.stats.kills++;
deps.engine.onWinGame();
player && player.stats.kills--;
}
}
export class _standardAi extends CardMod {
override onTurnStart(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
}
override onTurnEnd(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.executeIntent(deps.engine, deps.sourceCard);
}
}
export class _yieldScript extends CardMod {
constructor(
public scriptData: CardScript.ScriptData,
override duration: number,
) {
super(arguments);
}
override onRemoveMod(deps: ICardModDeps) {
CardScript.addScript(deps.engine, deps.sourceCard, this.scriptData);
}
}
export class _waveTrigger extends CardMod {
constructor(
public rulesetIds: string[],
override duration = -1,
) {
super(arguments);
}
override onInitMod(deps: ICardModDeps): void {
deps.engine.gameData.difficulty < 3 && GameEngineUtils.changeSec(deps.engine, deps.sourceCard, 25, true);
}
override onCardDestroyed(deps: ICardModDeps) {
deps.engine.onNextWave(this.rulesetIds.random());
deps.contextCard && CardMod.addMod(deps.engine, deps.contextCard, new _waveBonus_extraMove());
}
override onRemoveMod(deps: ICardModDeps): void {
CardMod.addMod(deps.engine, deps.sourceCard, new _winOnDeath());
}
}
}
}
|
src/game/card-mods.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,\n };\n constructor(public stackCount: number) {\n super(arguments);\n this.stackingConfig.stackCount = stackCount;\n }\n override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {\n return { secDmgBonus: this.stackingConfig.stackCount };\n }",
"score": 0.9107617139816284
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " };\n constructor(cpuBonus: number, override duration: number) {\n super(arguments);\n this.stackingConfig.stackCount = cpuBonus;\n }\n override onInitMod(deps: CardMod.ICardModDeps) {\n GameEngineUtils.changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);\n }\n override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {\n deps.sourceCard.cpu += stackDelta;",
"score": 0.9025394320487976
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,\n };\n constructor(public dot: number) {\n super(arguments);\n this.stackingConfig.stackCount = dot;\n }\n override onTurnEnd(deps: CardMod.ICardModDeps) {\n CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);\n }",
"score": 0.8974486589431763
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " },\n // Returns damage to attacker\n feedback: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,\n };\n constructor(public damage: number) {\n super(arguments);\n this.stackingConfig.stackCount = damage;",
"score": 0.8763589859008789
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " }\n override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {\n CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);\n }\n },\n // Increases CPU\n optimized: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,",
"score": 0.8680277466773987
}
] |
typescript
|
isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
|
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export abstract class CardMod {
duration = -1;
stackingConfig: Parameters<typeof CardMod['makeStackingData']>[0] = { behavior: CardMod.StackingBehavior.neverReplace };
readonly modName: string;
constructor(
private _extraModData?: IArguments,
) {
this.modName = this.constructor.name;
}
onSecDamageIn?(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState): { secDmgBonus: number } | void;
onSecDamageOut?(deps: CardMod.ICardModDeps, baseDmg: number): { secDmgBonus: number } | void;
onMemDmgIn?(deps: CardMod.ICardModDeps, memDmg: number): void;
onMemDmgOut?(deps: CardMod.ICardModDeps, memDmg: number): void;
onInitMod?(deps: CardMod.ICardModDeps): void;
onRemoveMod?(deps: CardMod.ICardModDeps): void;
onCardDestroyed?(deps: CardMod.ICardModDeps): void;
onStackMod?(deps: CardMod.ICardModDeps, stackDelta: number): void;
onTurnStart?(deps: CardMod.ICardModDeps): void;
onTurnEnd?(deps: CardMod.ICardModDeps): void;
onEnemyDestroyed?(deps: CardMod.ICardModDeps): void;
serialize() {
const stackingData = CardMod.makeStackingData(this.stackingConfig);
const modData = [this.modName, stackingData] as CardMod.ModData;
(this.duration >= 0) && (modData.push(CardMod.makeDurationData(this.duration)));
this._extraModData && modData.push(...this._extraModData);
return modData;
}
static addMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, mod: CardMod, contextCard?: GameEngine.ICardState) {
const modData = mod.serialize();
switch (mod.stackingConfig.behavior) {
case CardMod.StackingBehavior.append: {
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.neverReplace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) return;
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.ranked: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
if (existingStackingData[2] >= mod.stackingConfig.rank) {
return;
}
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.replace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.stack: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
existingStackingData && (existingStackingData[2] += mod.stackingConfig.stackCount);
engine.broadcast.push({
type: 'modStackChanged',
cardId: card.id,
modData: existingModData,
stackDelta: mod.stackingConfig.stackCount,
newStackCount: existingStackingData[2],
});
this.trigger('onStackMod', existingModData, { engine, sourceCard: card, contextCard }, mod.stackingConfig.stackCount);
return;
}
card.mods.push(modData);
break;
}
}
engine.broadcast.push({
type: 'modAdded',
cardId: card.id,
modData,
});
this.trigger('onInitMod', modData, { engine, sourceCard: card, contextCard });
}
static areEqual(left: CardMod.ModData, right: CardMod.ModData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, modData: CardMod.ModData) {
const modCtor = engine.ruleset.cardMods?.[modData[0]];
if (!modCtor) throw new Error('mod not found: ' + modData.join());
const durationData = this.findDurationData(modData);
const mod = new modCtor(...modData.slice(durationData ? 3 : 2));
durationData && (mod.duration = durationData[1]);
const stackingData = modData[1];
mod.stackingConfig.behavior = stackingData[1];
switch (stackingData[1]) {
case CardMod.StackingBehavior.ranked:
(mod.stackingConfig as any).rank = stackingData[2];
break;
case CardMod.StackingBehavior.stack:
(mod.stackingConfig as any).stackCount = stackingData[2];
break;
}
return mod;
}
static findDurationData(modData: CardMod.ModData) {
const maybeDurationData = modData[2];
return (Array.isArray(maybeDurationData) && maybeDurationData[0] === '$duration') ? (modData[2] as CardMod.DurationData) : undefined;
}
static findModOfType(card: GameEngine.ICardState, modType: CardMod.ModConstructor) {
return card.mods.find(x => x[0] === modType.name);
}
static getStackCount(modData: CardMod.ModData) {
return modData[1][1] === CardMod.StackingBehavior.stack ? modData[1][2] : 0;
}
static makeDurationData(duration: number): CardMod.DurationData {
return ['$duration', duration];
}
static makeStackingData(
stackConfig: { behavior: CardMod.StackingBehavior.append }
| { behavior: CardMod.StackingBehavior.neverReplace }
| { behavior: CardMod.StackingBehavior.ranked, rank: number }
| { behavior: CardMod.StackingBehavior.replace }
| { behavior: CardMod.StackingBehavior.stack, stackCount: number }
) {
const stackingData = ['$stack', stackConfig.behavior];
(stackConfig.behavior === CardMod.StackingBehavior.ranked) && stackingData.push(stackConfig.rank);
(stackConfig.behavior === CardMod.StackingBehavior.stack) && stackingData.push(stackConfig.stackCount);
return stackingData as CardMod.StackingData;
}
static removeMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modData: CardMod.ModData, contextCard?: GameEngine.ICardState) {
engine.broadcast.push({
type: 'modRemoved',
cardId: card.id,
modData,
});
if (!card.mods.find(x => this.areEqual(x, modData))) {
throw new Error('mod not found');
}
this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });
card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));
}
static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {
const mod = card.mods.find(x => x[0] === modName);
mod && this.removeMod(engine, card, mod, contextCard);
}
static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {
const deps = args[0];
const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));
if (!modDataFromCard) {
throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);
}
const mod = this.deserialize(deps.engine, modDataFromCard);
const evnt = mod[ev];
const evntRetVal = evnt ? (evnt as any).apply(mod, args) : undefined;
if (deps.sourceCard.isRemoved) {
return;
}
if (ev === 'onTurnStart') {
const durationData = this.findDurationData(modDataFromCard);
if (durationData) {
if (durationData[1] > 1) {
durationData[1]--;
deps.engine.broadcast.push({
type: 'modDurationChanged',
cardId: deps.sourceCard.id,
modData: modData,
newDuration: durationData[1],
});
} else {
this.removeMod(deps.engine, deps.sourceCard, modData);
}
}
}
return evntRetVal as ReturnType<NonNullable<CardMod[T]>> | undefined;
}
}
export namespace CardMod {
export type ModData = [string, StackingData, ...unknown[],];
export type DurationData = ['$duration', number];
export type EnemyModData = unknown[];
export type ModConstructor = TypeConstructor<CardMod>;
export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;
export type ModLibrary = Record<string, ModConstructor>;
export type AppendStackingData = ['$stack', StackingBehavior.append];
export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];
export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];
export type ReplaceStackingData = ['$stack', StackingBehavior.replace];
export type StackStackingData = ['$stack', StackingBehavior.stack, number];
export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;
export enum StackingBehavior {
append,
neverReplace,
ranked,
replace,
stack,
}
export interface ICardModDeps {
engine: GameEngine.IGameEngine;
sourceCard: GameEngine.ICardState;
contextCard?: GameEngine.ICardState;
}
export namespace Content {
// Defines a card modifier - the class name is treated as the mod name
export class backdoor extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(public damage: number) {
// Any extra data to serialize into this.modData as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display modifier effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI modifiers,
// see _standardAi below for example
super(arguments);
this.stackingConfig.rank = damage;
}
}
export class diagnostics extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public secBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = secBonus;
}
override onTurnEnd(deps: ICardModDeps): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
}
export class firewall extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(override duration: number) {
super(arguments);
this.stackingConfig.rank = duration;
}
override onInitMod(deps: ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
return;
}
GameEngineUtils.revalidateIntents(deps.engine, true);
}
}
export class impervious extends CardMod {
constructor(override duration = -1) {
super(arguments);
}
override onSecDamageIn(_deps: ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return {
secDmgBonus: -9999,
};
}
}
export class lag extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class offline extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
}
GameEngineUtils.revalidateIntents(deps.engine, GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard));
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class secured extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public tempSecBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = tempSecBonus;
}
override onInitMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
override onStackMod(deps: ICardModDeps, stackDelta: number): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, stackDelta, false);
}
override onRemoveMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -this.stackingConfig.stackCount, true);
}
}
export class _waveBonus_extraMove extends CardMod {
override onInitMod(deps: ICardModDeps): void {
const player = GameEngineUtils.findPlayerByCardId(deps.engine.gameData, deps.sourceCard.id);
player.movesPerTurn++;
player.movesLeft = player.movesPerTurn;
deps.engine.broadcast.push({
type: 'movesPerTurnsChange',
playerId: player.id,
newMovesLeft: player.movesLeft,
newMovesPerTurn: player.movesPerTurn,
});
}
}
export class _winOnDeath extends CardMod {
override onCardDestroyed(deps: ICardModDeps) {
const player = deps.contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null;
player && player.stats.kills++;
deps.engine.onWinGame();
player && player.stats.kills--;
}
}
export class _standardAi extends CardMod {
override onTurnStart(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
}
override onTurnEnd(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.executeIntent(deps.engine, deps.sourceCard);
}
}
export class _yieldScript extends CardMod {
constructor(
public scriptData: CardScript.ScriptData,
override duration: number,
) {
super(arguments);
}
override onRemoveMod(deps: ICardModDeps) {
CardScript
|
.addScript(deps.engine, deps.sourceCard, this.scriptData);
|
}
}
export class _waveTrigger extends CardMod {
constructor(
public rulesetIds: string[],
override duration = -1,
) {
super(arguments);
}
override onInitMod(deps: ICardModDeps): void {
deps.engine.gameData.difficulty < 3 && GameEngineUtils.changeSec(deps.engine, deps.sourceCard, 25, true);
}
override onCardDestroyed(deps: ICardModDeps) {
deps.engine.onNextWave(this.rulesetIds.random());
deps.contextCard && CardMod.addMod(deps.engine, deps.contextCard, new _waveBonus_extraMove());
}
override onRemoveMod(deps: ICardModDeps): void {
CardMod.addMod(deps.engine, deps.sourceCard, new _winOnDeath());
}
}
}
}
|
src/game/card-mods.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " (this.cooldownCur > 0 || this.cooldownMax > 0) && retVal.push(CardScript.makeCooldownData(this.cooldownMax, this.cooldownCur));\n return retVal;\n }\n static addScript(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptData: CardScript.ScriptData) {\n card.scripts.push(scriptData);\n engine.broadcast.push({\n type: 'scriptAdded',\n cardId: card.id,\n scriptData,\n });",
"score": 0.8576754331588745
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " });\n }\n }\n}\nexport namespace CardScript {\n export type ScriptData = [string, ...unknown[]];\n export type CooldownData = ['$cooldown', number, number];\n export type ScriptConstructor = { new(card: GameEngine.ICardState, ...args: any[]): CardScript };\n export type ScriptLibrary = Record<string, ScriptConstructor>;\n export interface ITargetResolver {",
"score": 0.8570566177368164
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " };\n export const AddMod = (mod: CardMod): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n CardMod.addMod(engine, targetCard, mod, sourceCard);\n };\n export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;\n if (secExceeded) {\n MemDmg(1)(engine, sourceCard, targetCard);",
"score": 0.8481273651123047
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": "import { CoreScriptNames } from '../appraise';\nimport { IPlayerPushProvider } from '../dependencies';\nimport { randInt, round } from '../utils';\nimport { CardMod } from './card-mods';\nimport { CardScriptParts } from './card-script-parts';\nimport { GameEngine } from './game-engine';\nimport { GameEngineUtils } from './game-engine-utils';\nexport class CardScript {\n cooldownMax = -1;\n cooldownCur = 0;",
"score": 0.8475765585899353
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " }\n static fromScriptName(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptName: string) {\n return this.deserialize(engine, card, [scriptName]).serialize();\n }\n static isOnCooldown(data: CardScript.ScriptData) {\n return (this.findCooldownData(data)?.[1] || 0) > 0;\n }\n static makeCooldownData(max: number, cur = 0): CardScript.CooldownData {\n return ['$cooldown', cur, max];\n }",
"score": 0.845352828502655
}
] |
typescript
|
.addScript(deps.engine, deps.sourceCard, this.scriptData);
|
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export abstract class CardMod {
duration = -1;
stackingConfig: Parameters<typeof CardMod['makeStackingData']>[0] = { behavior: CardMod.StackingBehavior.neverReplace };
readonly modName: string;
constructor(
private _extraModData?: IArguments,
) {
this.modName = this.constructor.name;
}
onSecDamageIn?(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState): { secDmgBonus: number } | void;
onSecDamageOut?(deps: CardMod.ICardModDeps, baseDmg: number): { secDmgBonus: number } | void;
onMemDmgIn?(deps: CardMod.ICardModDeps, memDmg: number): void;
onMemDmgOut?(deps: CardMod.ICardModDeps, memDmg: number): void;
onInitMod?(deps: CardMod.ICardModDeps): void;
onRemoveMod?(deps: CardMod.ICardModDeps): void;
onCardDestroyed?(deps: CardMod.ICardModDeps): void;
onStackMod?(deps: CardMod.ICardModDeps, stackDelta: number): void;
onTurnStart?(deps: CardMod.ICardModDeps): void;
onTurnEnd?(deps: CardMod.ICardModDeps): void;
onEnemyDestroyed?(deps: CardMod.ICardModDeps): void;
serialize() {
const stackingData = CardMod.makeStackingData(this.stackingConfig);
const modData = [this.modName, stackingData] as CardMod.ModData;
(this.duration >= 0) && (modData.push(CardMod.makeDurationData(this.duration)));
this._extraModData && modData.push(...this._extraModData);
return modData;
}
static addMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, mod: CardMod, contextCard?: GameEngine.ICardState) {
const modData = mod.serialize();
switch (mod.stackingConfig.behavior) {
case CardMod.StackingBehavior.append: {
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.neverReplace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) return;
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.ranked: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
if (existingStackingData[2] >= mod.stackingConfig.rank) {
return;
}
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.replace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.stack: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
existingStackingData && (existingStackingData[2] += mod.stackingConfig.stackCount);
engine.broadcast.push({
type: 'modStackChanged',
cardId: card.id,
modData: existingModData,
stackDelta: mod.stackingConfig.stackCount,
newStackCount: existingStackingData[2],
});
this.trigger('onStackMod', existingModData, { engine, sourceCard: card, contextCard }, mod.stackingConfig.stackCount);
return;
}
card.mods.push(modData);
break;
}
}
engine.broadcast.push({
type: 'modAdded',
cardId: card.id,
modData,
});
this.trigger('onInitMod', modData, { engine, sourceCard: card, contextCard });
}
static areEqual(left: CardMod.ModData, right: CardMod.ModData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, modData: CardMod.ModData) {
const modCtor = engine.ruleset.cardMods?.[modData[0]];
if (!modCtor) throw new Error('mod not found: ' + modData.join());
const durationData = this.findDurationData(modData);
const mod = new modCtor(...modData.slice(durationData ? 3 : 2));
durationData && (mod.duration = durationData[1]);
const stackingData = modData[1];
mod.stackingConfig.behavior = stackingData[1];
switch (stackingData[1]) {
case CardMod.StackingBehavior.ranked:
(mod.stackingConfig as any).rank = stackingData[2];
break;
case CardMod.StackingBehavior.stack:
(mod.stackingConfig as any).stackCount = stackingData[2];
break;
}
return mod;
}
static findDurationData(modData: CardMod.ModData) {
const maybeDurationData = modData[2];
return (Array.isArray(maybeDurationData) && maybeDurationData[0] === '$duration') ? (modData[2] as CardMod.DurationData) : undefined;
}
static findModOfType(card: GameEngine.ICardState, modType: CardMod.ModConstructor) {
return card.mods.find(x => x[0] === modType.name);
}
static getStackCount(modData: CardMod.ModData) {
return modData[1][1] === CardMod.StackingBehavior.stack ? modData[1][2] : 0;
}
static makeDurationData(duration: number): CardMod.DurationData {
return ['$duration', duration];
}
static makeStackingData(
stackConfig: { behavior: CardMod.StackingBehavior.append }
| { behavior: CardMod.StackingBehavior.neverReplace }
| { behavior: CardMod.StackingBehavior.ranked, rank: number }
| { behavior: CardMod.StackingBehavior.replace }
| { behavior: CardMod.StackingBehavior.stack, stackCount: number }
) {
const stackingData = ['$stack', stackConfig.behavior];
(stackConfig.behavior === CardMod.StackingBehavior.ranked) && stackingData.push(stackConfig.rank);
(stackConfig.behavior === CardMod.StackingBehavior.stack) && stackingData.push(stackConfig.stackCount);
return stackingData as CardMod.StackingData;
}
static removeMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modData: CardMod.ModData, contextCard?: GameEngine.ICardState) {
engine.broadcast.push({
type: 'modRemoved',
cardId: card.id,
modData,
});
if (!card.mods.find(x => this.areEqual(x, modData))) {
throw new Error('mod not found');
}
this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });
card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));
}
static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {
const mod = card.mods.find(x => x[0] === modName);
mod && this.removeMod(engine, card, mod, contextCard);
}
static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {
const deps = args[0];
const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));
if (!modDataFromCard) {
throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);
}
const mod = this.deserialize(deps.engine, modDataFromCard);
const evnt = mod[ev];
const evntRetVal = evnt ? (evnt as any).apply(mod, args) : undefined;
if (deps.sourceCard.isRemoved) {
return;
}
if (ev === 'onTurnStart') {
const durationData = this.findDurationData(modDataFromCard);
if (durationData) {
if (durationData[1] > 1) {
durationData[1]--;
deps.engine.broadcast.push({
type: 'modDurationChanged',
cardId: deps.sourceCard.id,
modData: modData,
newDuration: durationData[1],
});
} else {
this.removeMod(deps.engine, deps.sourceCard, modData);
}
}
}
return evntRetVal as ReturnType<NonNullable<CardMod[T]>> | undefined;
}
}
export namespace CardMod {
export type ModData = [string, StackingData, ...unknown[],];
export type DurationData = ['$duration', number];
export type EnemyModData = unknown[];
export type ModConstructor = TypeConstructor<CardMod>;
export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;
export type ModLibrary = Record<string, ModConstructor>;
export type AppendStackingData = ['$stack', StackingBehavior.append];
export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];
export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];
export type ReplaceStackingData = ['$stack', StackingBehavior.replace];
export type StackStackingData = ['$stack', StackingBehavior.stack, number];
export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;
export enum StackingBehavior {
append,
neverReplace,
ranked,
replace,
stack,
}
export interface ICardModDeps {
engine: GameEngine.IGameEngine;
sourceCard: GameEngine.ICardState;
contextCard?: GameEngine.ICardState;
}
export namespace Content {
// Defines a card modifier - the class name is treated as the mod name
export class backdoor extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(public damage: number) {
// Any extra data to serialize into this.modData as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display modifier effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI modifiers,
// see _standardAi below for example
super(arguments);
this.stackingConfig.rank = damage;
}
}
export class diagnostics extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public secBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = secBonus;
}
override onTurnEnd(deps: ICardModDeps): void {
|
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
|
}
}
export class firewall extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(override duration: number) {
super(arguments);
this.stackingConfig.rank = duration;
}
override onInitMod(deps: ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
return;
}
GameEngineUtils.revalidateIntents(deps.engine, true);
}
}
export class impervious extends CardMod {
constructor(override duration = -1) {
super(arguments);
}
override onSecDamageIn(_deps: ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return {
secDmgBonus: -9999,
};
}
}
export class lag extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class offline extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
}
GameEngineUtils.revalidateIntents(deps.engine, GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard));
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class secured extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public tempSecBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = tempSecBonus;
}
override onInitMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
override onStackMod(deps: ICardModDeps, stackDelta: number): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, stackDelta, false);
}
override onRemoveMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -this.stackingConfig.stackCount, true);
}
}
export class _waveBonus_extraMove extends CardMod {
override onInitMod(deps: ICardModDeps): void {
const player = GameEngineUtils.findPlayerByCardId(deps.engine.gameData, deps.sourceCard.id);
player.movesPerTurn++;
player.movesLeft = player.movesPerTurn;
deps.engine.broadcast.push({
type: 'movesPerTurnsChange',
playerId: player.id,
newMovesLeft: player.movesLeft,
newMovesPerTurn: player.movesPerTurn,
});
}
}
export class _winOnDeath extends CardMod {
override onCardDestroyed(deps: ICardModDeps) {
const player = deps.contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null;
player && player.stats.kills++;
deps.engine.onWinGame();
player && player.stats.kills--;
}
}
export class _standardAi extends CardMod {
override onTurnStart(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
}
override onTurnEnd(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.executeIntent(deps.engine, deps.sourceCard);
}
}
export class _yieldScript extends CardMod {
constructor(
public scriptData: CardScript.ScriptData,
override duration: number,
) {
super(arguments);
}
override onRemoveMod(deps: ICardModDeps) {
CardScript.addScript(deps.engine, deps.sourceCard, this.scriptData);
}
}
export class _waveTrigger extends CardMod {
constructor(
public rulesetIds: string[],
override duration = -1,
) {
super(arguments);
}
override onInitMod(deps: ICardModDeps): void {
deps.engine.gameData.difficulty < 3 && GameEngineUtils.changeSec(deps.engine, deps.sourceCard, 25, true);
}
override onCardDestroyed(deps: ICardModDeps) {
deps.engine.onNextWave(this.rulesetIds.random());
deps.contextCard && CardMod.addMod(deps.engine, deps.contextCard, new _waveBonus_extraMove());
}
override onRemoveMod(deps: ICardModDeps): void {
CardMod.addMod(deps.engine, deps.sourceCard, new _winOnDeath());
}
}
}
}
|
src/game/card-mods.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,\n };\n constructor(public stackCount: number) {\n super(arguments);\n this.stackingConfig.stackCount = stackCount;\n }\n override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {\n return { secDmgBonus: this.stackingConfig.stackCount };\n }",
"score": 0.9512333273887634
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,\n };\n constructor(public dot: number) {\n super(arguments);\n this.stackingConfig.stackCount = dot;\n }\n override onTurnEnd(deps: CardMod.ICardModDeps) {\n CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);\n }",
"score": 0.9390296936035156
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " };\n constructor(cpuBonus: number, override duration: number) {\n super(arguments);\n this.stackingConfig.stackCount = cpuBonus;\n }\n override onInitMod(deps: CardMod.ICardModDeps) {\n GameEngineUtils.changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);\n }\n override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {\n deps.sourceCard.cpu += stackDelta;",
"score": 0.923985481262207
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " }\n override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {\n CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);\n }\n },\n // Increases CPU\n optimized: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,",
"score": 0.9144400358200073
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " },\n // Returns damage to attacker\n feedback: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,\n };\n constructor(public damage: number) {\n super(arguments);\n this.stackingConfig.stackCount = damage;",
"score": 0.8828763365745544
}
] |
typescript
|
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
|
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export namespace CardScriptParts {
export interface IScriptPart {
(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): void;
}
export const _Chance = (chance: number, curriedPart: IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (Math.random() < chance) {
curriedPart(engine, sourceCard, targetCard);
}
};
export const _TargetHasMod = <T extends CardMod.ModLibrary, K extends keyof T>(modName: K, curry: (mod: InstanceType<T[K]>) => IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
const mod = targetCard.mods.find(x => x[0] === modName);
if (mod) {
curry(CardMod.deserialize(engine, mod) as InstanceType<T[K]>)(engine, sourceCard, targetCard);
}
};
export const AddMod = (mod: CardMod): IScriptPart =>
(engine, sourceCard, targetCard) => {
CardMod.addMod(engine, targetCard, mod, sourceCard);
};
export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;
if (secExceeded) {
MemDmg(1)(engine, sourceCard, targetCard);
}
};
export const SecDmg = (secDmg: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
let resolvedDamage = secDmg;
if (!dontTriggerOut) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageOut', { engine, sourceCard, contextCard: targetCard }, resolvedDamage)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (!dontTriggerIn) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (CardMod
|
.findModOfType(targetCard, CardMod.Content.impervious)) {
|
return false;
}
resolvedDamage = Math.max(0, resolvedDamage);
const secExceeded = resolvedDamage > targetCard.sec;
GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);
return secExceeded;
};
export const MemDmg = (memDmg: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.triggerMods('onMemDmgOut', { engine, sourceCard, contextCard: targetCard }, memDmg);
GameEngineUtils.triggerMods('onMemDmgIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, memDmg);
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return;
}
targetCard.mem -= memDmg;
engine.broadcast.push({
type: 'memDamage',
cardId: targetCard.id,
newMem: targetCard.mem,
value: -memDmg,
});
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, sourceCard.id);
player && (player.stats.memDmg += memDmg);
if (targetCard.mem <= 0) {
GameEngineUtils.removeCard(engine, targetCard, sourceCard);
}
};
export const ChangeCpu = (cpuDelta: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
};
export const RaiseMem = (memBonus: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
targetCard.mem += memBonus;
engine.broadcast.push({
type: 'memBonus',
cardId: targetCard.id,
newMem: targetCard.mem,
value: memBonus,
});
};
export const RaiseSec = (secBonus: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.changeSec(engine, targetCard, secBonus, false, sourceCard);
};
export const RedirectIntentRandom: IScriptPart =
(engine, _sourceCard, targetCard) => {
if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;
const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);
if (script.targetFinder === CardScript.TargetFinders.Self) return;
const targets = script.targetFinder(engine.gameData, targetCard);
if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;
const origTargetId = targetCard.intent.targetCardId;
while (targetCard.intent.targetCardId === origTargetId) {
targetCard.intent.targetCardId = targets.random().id;
}
engine.broadcast.push({
type: 'cardIntent',
cardId: targetCard.id,
intent: targetCard.intent,
});
};
export const RemoveMod = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modName: K, mustRemove = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (mustRemove) {
if (!targetCard.mods.find(x => x[0] === modName)) {
throw new Error(`Could not find [${modName}] to remove`);
}
}
CardMod.removeModByName(engine, targetCard, modName, sourceCard);
};
export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>
(engine, sourceCard, _targetCard) => {
let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);
switch (spawnPosition) {
case 'absLeft': spawnIndex = 0; break;
case 'absRight': spawnIndex = engine.gameData.enemies.length; break;
case 'relRight': spawnIndex++; break;
}
GameEngineUtils.spawnEnemy(engine, enemyClass, spawnIndex, generateIntent);
};
}
|
src/game/card-script-parts.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (deps.sourceCard.mem - memDmg <= 0) return;\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n let secBonus = 100;\n const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);\n if (shieldBuff) {\n secBonus += CardMod.getStackCount(shieldBuff) * 100;\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);\n for (const enemy of [...deps.engine.gameData.enemies]) {\n if (enemy === boss) continue;",
"score": 0.8633779287338257
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " },\n reaper_feederPower: class extends CardMod {\n override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {\n if (deps.sourceCard.sec - damage > 0) return;\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);\n CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);\n CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);\n CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);\n const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);\n player && player.stats.kills++;",
"score": 0.8591925501823425
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " if (source.sec <= 0) {\n GameEngineUtils.removeCard(engine, source);\n return;\n }\n } else {\n GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);\n GameEngineUtils.changeCpu(engine, source, 1);\n for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {\n CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));\n }",
"score": 0.8521729707717896
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " }\n override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {\n CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);\n }\n },\n // Increases CPU\n optimized: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,",
"score": 0.8484849333763123
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n const bdChance = round(GameEngineUtils.scaleByCpuMem(40, card.mem, 'more') / 100, 2);\n super(\n [damage, bdChance],\n (gameData: GameEngine.IGameData, card: GameEngine.ICardState) => [\n ...TargetFinders.Opponents()(gameData, card),\n ...TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],\n TargetFinders.Opponents(true))(gameData, card),\n ],\n [",
"score": 0.8479453325271606
}
] |
typescript
|
.findModOfType(targetCard, CardMod.Content.impervious)) {
|
import * as moment from 'moment';
import { z } from 'zod';
import { IAuthProvider, IDataSource, IMetricsProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { toClientPlayer } from '../models';
import { IHttpRouteHandler, StatusCodes } from '../net-utils';
import { FULL_DATETIME_FORMAT } from '../utils';
export const createPlayerHandler = (ds: IDataSource, authProvider: IAuthProvider, metrics?: IMetricsProvider): IHttpRouteHandler =>
async (path, _query, body, req) => {
switch (path[0]) {
case 'connectDid': {
const schema = z.object({
didProof: z.object({
latestCoinId: z.string(),
pubkey: z.string(),
signature: z.string(),
}),
});
const payload = schema.parse(body);
const did = (await ExtDeps.verifyDidProof({
...payload.didProof,
message: 'Proof of DID ownership for ChiaTCG',
}))?.did;
if (!did) {
return [StatusCodes.unauthorized, { reason: 'unable to validate did proof' }];
}
let player = await ds.Players.get(did);
const isNew = !player;
const now = moment.utc();
const newSecret = authProvider.generateNewSecret();
const newAuthExpireAt = moment.utc(now).add({ days: 14 }).format(FULL_DATETIME_FORMAT);
if (!player) {
const nowStr = now.format(FULL_DATETIME_FORMAT);
player = await ds.Players.update.exec({
id: did,
createdAt: nowStr,
lastSeenAt: nowStr,
secret: newSecret,
authExpiresAt: newAuthExpireAt,
activeGameId: '',
activeDeckId: 'default',
score: 0,
});
metrics?.
|
newUser(player.id);
|
} else {
ds.Leaderboard.set(player.id, player.score);
player.secret = newSecret;
player.authExpiresAt = newAuthExpireAt;
await ds.Players.update.exec(player);
}
return [StatusCodes.ok, {
player: toClientPlayer(player, authProvider),
status: isNew ? 'new' : 'existing',
}];
}
case 'me': {
const player = await authProvider.getPlayerFromRequest(req);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
}
return;
};
|
src/apis/players.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " playersIds: new Set([player.id]),\n gameState: payload.gameVisibility === 'public' ? 'open' : 'private',\n startedAt: '',\n endedAt: '',\n ingorePlayerIds: new Set(),\n isCompleted: false,\n _dbTtl: moment.utc(now).add({ days: 1 }).unix(),\n };\n const initialRulesetId = 'mfrm';\n metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);",
"score": 0.885636031627655
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " game.startedAt = now.format(FULL_DATETIME_FORMAT);\n game._dbTtl = 9999999999;\n await ds.CoopGames.update.exec(game);\n metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);\n }\n async function _expectAuthPlayerInGame(req: IHttpRequest) {\n const player = await authProvider.getPlayerFromRequest(req);\n if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');\n const game = await ds.CoopGames.get(player.activeGameId);\n if (game) {",
"score": 0.8706197142601013
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " playerId: player.id,\n createdAt: nowStr,\n cards: cards.map(x => ({ nftId: x.nftId, mintHeight: x.firstBlock, url: x.urls[0] || '' })),\n label: 'default',\n };\n await ds.execUpdates(\n ds.Players.update.make(player, true),\n ds.CardDecks.update.make(deck, true),\n );\n return deck;",
"score": 0.8508251905441284
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);\n await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));\n if (payload.gameVisibility === 'solo') {\n await _onGameStart(game, false);\n }\n player.activeGameId = game.id;\n await ds.execUpdates(\n ds.CoopGames.update.make(game),\n ds.Players.update.make(player),\n );",
"score": 0.8413829803466797
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),\n score: 0,\n }\n playersTable._db.set(mockPlayer.id, mockPlayer);\n /**\n * This calls into /coop/create which is a complex API.\n * Step thru this to learn about how the route handlers work.\n */\n console.log('Creating game...');\n await handleRequest({",
"score": 0.8377455472946167
}
] |
typescript
|
newUser(player.id);
|
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export abstract class CardMod {
duration = -1;
stackingConfig: Parameters<typeof CardMod['makeStackingData']>[0] = { behavior: CardMod.StackingBehavior.neverReplace };
readonly modName: string;
constructor(
private _extraModData?: IArguments,
) {
this.modName = this.constructor.name;
}
onSecDamageIn?(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState): { secDmgBonus: number } | void;
onSecDamageOut?(deps: CardMod.ICardModDeps, baseDmg: number): { secDmgBonus: number } | void;
onMemDmgIn?(deps: CardMod.ICardModDeps, memDmg: number): void;
onMemDmgOut?(deps: CardMod.ICardModDeps, memDmg: number): void;
onInitMod?(deps: CardMod.ICardModDeps): void;
onRemoveMod?(deps: CardMod.ICardModDeps): void;
onCardDestroyed?(deps: CardMod.ICardModDeps): void;
onStackMod?(deps: CardMod.ICardModDeps, stackDelta: number): void;
onTurnStart?(deps: CardMod.ICardModDeps): void;
onTurnEnd?(deps: CardMod.ICardModDeps): void;
onEnemyDestroyed?(deps: CardMod.ICardModDeps): void;
serialize() {
const stackingData = CardMod.makeStackingData(this.stackingConfig);
const modData = [this.modName, stackingData] as CardMod.ModData;
(this.duration >= 0) && (modData.push(CardMod.makeDurationData(this.duration)));
this._extraModData && modData.push(...this._extraModData);
return modData;
}
static addMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, mod: CardMod, contextCard?: GameEngine.ICardState) {
const modData = mod.serialize();
switch (mod.stackingConfig.behavior) {
case CardMod.StackingBehavior.append: {
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.neverReplace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) return;
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.ranked: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
if (existingStackingData[2] >= mod.stackingConfig.rank) {
return;
}
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.replace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.stack: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
existingStackingData && (existingStackingData[2] += mod.stackingConfig.stackCount);
engine.broadcast.push({
type: 'modStackChanged',
cardId: card.id,
modData: existingModData,
stackDelta: mod.stackingConfig.stackCount,
newStackCount: existingStackingData[2],
});
this.trigger('onStackMod', existingModData, { engine, sourceCard: card, contextCard }, mod.stackingConfig.stackCount);
return;
}
card.mods.push(modData);
break;
}
}
engine.broadcast.push({
type: 'modAdded',
cardId: card.id,
modData,
});
this.trigger('onInitMod', modData, { engine, sourceCard: card, contextCard });
}
static areEqual(left: CardMod.ModData, right: CardMod.ModData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, modData: CardMod.ModData) {
const modCtor = engine.ruleset.cardMods?.[modData[0]];
if (!modCtor) throw new Error('mod not found: ' + modData.join());
const durationData = this.findDurationData(modData);
const mod = new modCtor(...modData.slice(durationData ? 3 : 2));
durationData && (mod.duration = durationData[1]);
const stackingData = modData[1];
mod.stackingConfig.behavior = stackingData[1];
switch (stackingData[1]) {
case CardMod.StackingBehavior.ranked:
(mod.stackingConfig as any).rank = stackingData[2];
break;
case CardMod.StackingBehavior.stack:
(mod.stackingConfig as any).stackCount = stackingData[2];
break;
}
return mod;
}
static findDurationData(modData: CardMod.ModData) {
const maybeDurationData = modData[2];
return (Array.isArray(maybeDurationData) && maybeDurationData[0] === '$duration') ? (modData[2] as CardMod.DurationData) : undefined;
}
static findModOfType(card: GameEngine.ICardState, modType: CardMod.ModConstructor) {
return card.mods.find(x => x[0] === modType.name);
}
static getStackCount(modData: CardMod.ModData) {
return modData[1][1] === CardMod.StackingBehavior.stack ? modData[1][2] : 0;
}
static makeDurationData(duration: number): CardMod.DurationData {
return ['$duration', duration];
}
static makeStackingData(
stackConfig: { behavior: CardMod.StackingBehavior.append }
| { behavior: CardMod.StackingBehavior.neverReplace }
| { behavior: CardMod.StackingBehavior.ranked, rank: number }
| { behavior: CardMod.StackingBehavior.replace }
| { behavior: CardMod.StackingBehavior.stack, stackCount: number }
) {
const stackingData = ['$stack', stackConfig.behavior];
(stackConfig.behavior === CardMod.StackingBehavior.ranked) && stackingData.push(stackConfig.rank);
(stackConfig.behavior === CardMod.StackingBehavior.stack) && stackingData.push(stackConfig.stackCount);
return stackingData as CardMod.StackingData;
}
static removeMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modData: CardMod.ModData, contextCard?: GameEngine.ICardState) {
engine.broadcast.push({
type: 'modRemoved',
cardId: card.id,
modData,
});
if (!card.mods.find(x => this.areEqual(x, modData))) {
throw new Error('mod not found');
}
this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });
card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));
}
static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {
const mod = card.mods.find(x => x[0] === modName);
mod && this.removeMod(engine, card, mod, contextCard);
}
static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {
const deps = args[0];
const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));
if (!modDataFromCard) {
throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);
}
const mod = this.deserialize(deps.engine, modDataFromCard);
const evnt = mod[ev];
const evntRetVal = evnt ? (evnt as any).apply(mod, args) : undefined;
if (deps.sourceCard.isRemoved) {
return;
}
if (ev === 'onTurnStart') {
const durationData = this.findDurationData(modDataFromCard);
if (durationData) {
if (durationData[1] > 1) {
durationData[1]--;
deps.engine.broadcast.push({
type: 'modDurationChanged',
cardId: deps.sourceCard.id,
modData: modData,
newDuration: durationData[1],
});
} else {
this.removeMod(deps.engine, deps.sourceCard, modData);
}
}
}
return evntRetVal as ReturnType<NonNullable<CardMod[T]>> | undefined;
}
}
export namespace CardMod {
export type ModData = [string, StackingData, ...unknown[],];
export type DurationData = ['$duration', number];
export type EnemyModData = unknown[];
export type ModConstructor = TypeConstructor<CardMod>;
export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;
export type ModLibrary = Record<string, ModConstructor>;
export type AppendStackingData = ['$stack', StackingBehavior.append];
export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];
export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];
export type ReplaceStackingData = ['$stack', StackingBehavior.replace];
export type StackStackingData = ['$stack', StackingBehavior.stack, number];
export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;
export enum StackingBehavior {
append,
neverReplace,
ranked,
replace,
stack,
}
export interface ICardModDeps {
engine: GameEngine.IGameEngine;
sourceCard: GameEngine.ICardState;
contextCard?: GameEngine.ICardState;
}
export namespace Content {
// Defines a card modifier - the class name is treated as the mod name
export class backdoor extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(public damage: number) {
// Any extra data to serialize into this.modData as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display modifier effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI modifiers,
// see _standardAi below for example
super(arguments);
this.stackingConfig.rank = damage;
}
}
export class diagnostics extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public secBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = secBonus;
}
override onTurnEnd(deps: ICardModDeps): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
}
export class firewall extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(override duration: number) {
super(arguments);
this.stackingConfig.rank = duration;
}
override onInitMod(deps: ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
return;
}
GameEngineUtils.revalidateIntents(deps.engine, true);
}
}
export class impervious extends CardMod {
constructor(override duration = -1) {
super(arguments);
}
override onSecDamageIn(_deps: ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return {
secDmgBonus: -9999,
};
}
}
export class lag extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class offline extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
}
GameEngineUtils.revalidateIntents(deps.engine, GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard));
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class secured extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public tempSecBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = tempSecBonus;
}
override onInitMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
override onStackMod(deps: ICardModDeps, stackDelta: number): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, stackDelta, false);
}
override onRemoveMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -this.stackingConfig.stackCount, true);
}
}
export class _waveBonus_extraMove extends CardMod {
override onInitMod(deps: ICardModDeps): void {
const player = GameEngineUtils.findPlayerByCardId(deps.engine.gameData, deps.sourceCard.id);
player.movesPerTurn++;
player.movesLeft = player.movesPerTurn;
deps.engine.broadcast.push({
type: 'movesPerTurnsChange',
playerId: player.id,
newMovesLeft: player.movesLeft,
newMovesPerTurn: player.movesPerTurn,
});
}
}
export class _winOnDeath extends CardMod {
override onCardDestroyed(deps: ICardModDeps) {
const player = deps.
|
contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null;
|
player && player.stats.kills++;
deps.engine.onWinGame();
player && player.stats.kills--;
}
}
export class _standardAi extends CardMod {
override onTurnStart(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
}
override onTurnEnd(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.executeIntent(deps.engine, deps.sourceCard);
}
}
export class _yieldScript extends CardMod {
constructor(
public scriptData: CardScript.ScriptData,
override duration: number,
) {
super(arguments);
}
override onRemoveMod(deps: ICardModDeps) {
CardScript.addScript(deps.engine, deps.sourceCard, this.scriptData);
}
}
export class _waveTrigger extends CardMod {
constructor(
public rulesetIds: string[],
override duration = -1,
) {
super(arguments);
}
override onInitMod(deps: ICardModDeps): void {
deps.engine.gameData.difficulty < 3 && GameEngineUtils.changeSec(deps.engine, deps.sourceCard, 25, true);
}
override onCardDestroyed(deps: ICardModDeps) {
deps.engine.onNextWave(this.rulesetIds.random());
deps.contextCard && CardMod.addMod(deps.engine, deps.contextCard, new _waveBonus_extraMove());
}
override onRemoveMod(deps: ICardModDeps): void {
CardMod.addMod(deps.engine, deps.sourceCard, new _winOnDeath());
}
}
}
}
|
src/game/card-mods.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " triggerMods('onEnemyDestroyed', { engine, sourceCard: card, contextCard });\n }\n if (contextCard) {\n const player = findPlayerByCardIdMaybe(engine.gameData, contextCard.id);\n player && player.stats.kills++;\n }\n GameEngineUtils.revalidateIntents(engine, true);\n } else {\n const player = GameEngineUtils.findPlayerByCardId(engine.gameData, card.id);\n player.cards.removeFirst(card);",
"score": 0.8555799722671509
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {\n CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);\n if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {\n GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n }\n }\n },\n },",
"score": 0.8427133560180664
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": "import { CardMod } from '../card-mods';\nimport { CardScript } from '../card-scripts';\nimport { GameContent_v1 } from '../game-content-v1';\nimport { GameEngine } from '../game-engine';\nimport { GameEngineUtils } from '../game-engine-utils';\nconst GOLIATH_ID = 9999;\nexport const RulesetGoliath = {\n cardMods: {\n goliath_power_supply: class extends CardMod {\n override onCardDestroyed(deps: CardMod.ICardModDeps) {",
"score": 0.8414308428764343
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);\n CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_power(), deps.sourceCard);\n }\n },\n goliath_shield_supply: class extends CardMod {\n override onCardDestroyed(deps: CardMod.ICardModDeps) {\n const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);\n CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_shield(), deps.sourceCard);\n }\n },",
"score": 0.8413799405097961
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\n const player: GameEngine.IPlayerState = {\n id: playerId,\n cards: cards.map(card => ({\n id: this.nextId(),\n card,\n isUsed: false,\n cpu: card.cpu,\n mem: card.mem,\n sec: card.mem * 6 + card.cpu * 3,",
"score": 0.8390394449234009
}
] |
typescript
|
contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null;
|
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export namespace CardScriptParts {
export interface IScriptPart {
(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): void;
}
export const _Chance = (chance: number, curriedPart: IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (Math.random() < chance) {
curriedPart(engine, sourceCard, targetCard);
}
};
export const _TargetHasMod = <T extends CardMod.ModLibrary, K extends keyof T>(modName: K, curry: (mod: InstanceType<T[K]>) => IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
const mod = targetCard.mods.find(x => x[0] === modName);
if (mod) {
curry(CardMod.deserialize(engine, mod) as InstanceType<T[K]>)(engine, sourceCard, targetCard);
}
};
export const AddMod = (mod: CardMod): IScriptPart =>
(engine, sourceCard, targetCard) => {
CardMod.addMod(engine, targetCard, mod, sourceCard);
};
export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;
if (secExceeded) {
MemDmg(1)(engine, sourceCard, targetCard);
}
};
export const SecDmg = (secDmg: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
let resolvedDamage = secDmg;
if (!dontTriggerOut) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageOut', { engine, sourceCard, contextCard: targetCard }, resolvedDamage)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (!dontTriggerIn) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return false;
}
resolvedDamage = Math.max(0, resolvedDamage);
const secExceeded = resolvedDamage > targetCard.sec;
|
GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);
|
return secExceeded;
};
export const MemDmg = (memDmg: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.triggerMods('onMemDmgOut', { engine, sourceCard, contextCard: targetCard }, memDmg);
GameEngineUtils.triggerMods('onMemDmgIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, memDmg);
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return;
}
targetCard.mem -= memDmg;
engine.broadcast.push({
type: 'memDamage',
cardId: targetCard.id,
newMem: targetCard.mem,
value: -memDmg,
});
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, sourceCard.id);
player && (player.stats.memDmg += memDmg);
if (targetCard.mem <= 0) {
GameEngineUtils.removeCard(engine, targetCard, sourceCard);
}
};
export const ChangeCpu = (cpuDelta: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
};
export const RaiseMem = (memBonus: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
targetCard.mem += memBonus;
engine.broadcast.push({
type: 'memBonus',
cardId: targetCard.id,
newMem: targetCard.mem,
value: memBonus,
});
};
export const RaiseSec = (secBonus: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.changeSec(engine, targetCard, secBonus, false, sourceCard);
};
export const RedirectIntentRandom: IScriptPart =
(engine, _sourceCard, targetCard) => {
if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;
const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);
if (script.targetFinder === CardScript.TargetFinders.Self) return;
const targets = script.targetFinder(engine.gameData, targetCard);
if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;
const origTargetId = targetCard.intent.targetCardId;
while (targetCard.intent.targetCardId === origTargetId) {
targetCard.intent.targetCardId = targets.random().id;
}
engine.broadcast.push({
type: 'cardIntent',
cardId: targetCard.id,
intent: targetCard.intent,
});
};
export const RemoveMod = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modName: K, mustRemove = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (mustRemove) {
if (!targetCard.mods.find(x => x[0] === modName)) {
throw new Error(`Could not find [${modName}] to remove`);
}
}
CardMod.removeModByName(engine, targetCard, modName, sourceCard);
};
export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>
(engine, sourceCard, _targetCard) => {
let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);
switch (spawnPosition) {
case 'absLeft': spawnIndex = 0; break;
case 'absRight': spawnIndex = engine.gameData.enemies.length; break;
case 'relRight': spawnIndex++; break;
}
GameEngineUtils.spawnEnemy(engine, enemyClass, spawnIndex, generateIntent);
};
}
|
src/game/card-script-parts.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (deps.sourceCard.mem - memDmg <= 0) return;\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n let secBonus = 100;\n const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);\n if (shieldBuff) {\n secBonus += CardMod.getStackCount(shieldBuff) * 100;\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);\n for (const enemy of [...deps.engine.gameData.enemies]) {\n if (enemy === boss) continue;",
"score": 0.8848592638969421
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " if (source.sec <= 0) {\n GameEngineUtils.removeCard(engine, source);\n return;\n }\n } else {\n GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);\n GameEngineUtils.changeCpu(engine, source, 1);\n for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {\n CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));\n }",
"score": 0.8795551061630249
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " },\n reaper_feederPower: class extends CardMod {\n override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {\n if (deps.sourceCard.sec - damage > 0) return;\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);\n CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);\n CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);\n CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);\n const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);\n player && player.stats.kills++;",
"score": 0.8775857090950012
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " }\n override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {\n CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);\n }\n },\n // Increases CPU\n optimized: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,",
"score": 0.866183340549469
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " export function changeSec(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, secDelta: number, isPassive: boolean, contextCard?: GameEngine.ICardState) {\n const clampedSecDelta = (card.sec < -secDelta) ? -card.sec : secDelta;\n card.sec += clampedSecDelta;\n engine.broadcast.push({\n type: isPassive ? 'secChange' : (secDelta < 0 ? 'secDamage' : 'secBonus'),\n cardId: card.id,\n newSec: card.sec,\n value: secDelta,\n });\n if (!isPassive && contextCard) {",
"score": 0.8649786710739136
}
] |
typescript
|
GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);
|
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export abstract class CardMod {
duration = -1;
stackingConfig: Parameters<typeof CardMod['makeStackingData']>[0] = { behavior: CardMod.StackingBehavior.neverReplace };
readonly modName: string;
constructor(
private _extraModData?: IArguments,
) {
this.modName = this.constructor.name;
}
onSecDamageIn?(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState): { secDmgBonus: number } | void;
onSecDamageOut?(deps: CardMod.ICardModDeps, baseDmg: number): { secDmgBonus: number } | void;
onMemDmgIn?(deps: CardMod.ICardModDeps, memDmg: number): void;
onMemDmgOut?(deps: CardMod.ICardModDeps, memDmg: number): void;
onInitMod?(deps: CardMod.ICardModDeps): void;
onRemoveMod?(deps: CardMod.ICardModDeps): void;
onCardDestroyed?(deps: CardMod.ICardModDeps): void;
onStackMod?(deps: CardMod.ICardModDeps, stackDelta: number): void;
onTurnStart?(deps: CardMod.ICardModDeps): void;
onTurnEnd?(deps: CardMod.ICardModDeps): void;
onEnemyDestroyed?(deps: CardMod.ICardModDeps): void;
serialize() {
const stackingData = CardMod.makeStackingData(this.stackingConfig);
const modData = [this.modName, stackingData] as CardMod.ModData;
(this.duration >= 0) && (modData.push(CardMod.makeDurationData(this.duration)));
this._extraModData && modData.push(...this._extraModData);
return modData;
}
static addMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, mod: CardMod, contextCard?: GameEngine.ICardState) {
const modData = mod.serialize();
switch (mod.stackingConfig.behavior) {
case CardMod.StackingBehavior.append: {
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.neverReplace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) return;
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.ranked: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
if (existingStackingData[2] >= mod.stackingConfig.rank) {
return;
}
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.replace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.stack: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
existingStackingData && (existingStackingData[2] += mod.stackingConfig.stackCount);
engine.broadcast.push({
type: 'modStackChanged',
cardId: card.id,
modData: existingModData,
stackDelta: mod.stackingConfig.stackCount,
newStackCount: existingStackingData[2],
});
this.trigger('onStackMod', existingModData, { engine, sourceCard: card, contextCard }, mod.stackingConfig.stackCount);
return;
}
card.mods.push(modData);
break;
}
}
engine.broadcast.push({
type: 'modAdded',
cardId: card.id,
modData,
});
this.trigger('onInitMod', modData, { engine, sourceCard: card, contextCard });
}
static areEqual(left: CardMod.ModData, right: CardMod.ModData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, modData: CardMod.ModData) {
const modCtor = engine.ruleset.cardMods?.[modData[0]];
if (!modCtor) throw new Error('mod not found: ' + modData.join());
const durationData = this.findDurationData(modData);
const mod = new modCtor(...modData.slice(durationData ? 3 : 2));
durationData && (mod.duration = durationData[1]);
const stackingData = modData[1];
mod.stackingConfig.behavior = stackingData[1];
switch (stackingData[1]) {
case CardMod.StackingBehavior.ranked:
(mod.stackingConfig as any).rank = stackingData[2];
break;
case CardMod.StackingBehavior.stack:
(mod.stackingConfig as any).stackCount = stackingData[2];
break;
}
return mod;
}
static findDurationData(modData: CardMod.ModData) {
const maybeDurationData = modData[2];
return (Array.isArray(maybeDurationData) && maybeDurationData[0] === '$duration') ? (modData[2] as CardMod.DurationData) : undefined;
}
static findModOfType(card: GameEngine.ICardState, modType: CardMod.ModConstructor) {
return card.mods.find(x => x[0] === modType.name);
}
static getStackCount(modData: CardMod.ModData) {
return modData[1][1] === CardMod.StackingBehavior.stack ? modData[1][2] : 0;
}
static makeDurationData(duration: number): CardMod.DurationData {
return ['$duration', duration];
}
static makeStackingData(
stackConfig: { behavior: CardMod.StackingBehavior.append }
| { behavior: CardMod.StackingBehavior.neverReplace }
| { behavior: CardMod.StackingBehavior.ranked, rank: number }
| { behavior: CardMod.StackingBehavior.replace }
| { behavior: CardMod.StackingBehavior.stack, stackCount: number }
) {
const stackingData = ['$stack', stackConfig.behavior];
(stackConfig.behavior === CardMod.StackingBehavior.ranked) && stackingData.push(stackConfig.rank);
(stackConfig.behavior === CardMod.StackingBehavior.stack) && stackingData.push(stackConfig.stackCount);
return stackingData as CardMod.StackingData;
}
static removeMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modData: CardMod.ModData, contextCard?: GameEngine.ICardState) {
engine.broadcast.push({
type: 'modRemoved',
cardId: card.id,
modData,
});
if (!card.mods.find(x => this.areEqual(x, modData))) {
throw new Error('mod not found');
}
this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });
card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));
}
static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {
const mod = card.mods.find(x => x[0] === modName);
mod && this.removeMod(engine, card, mod, contextCard);
}
static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {
const deps = args[0];
const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));
if (!modDataFromCard) {
throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);
}
const mod = this.deserialize(deps.engine, modDataFromCard);
const evnt = mod[ev];
const evntRetVal = evnt ? (evnt as any).apply(mod, args) : undefined;
if (deps.sourceCard.isRemoved) {
return;
}
if (ev === 'onTurnStart') {
const durationData = this.findDurationData(modDataFromCard);
if (durationData) {
if (durationData[1] > 1) {
durationData[1]--;
deps.engine.broadcast.push({
type: 'modDurationChanged',
cardId: deps.sourceCard.id,
modData: modData,
newDuration: durationData[1],
});
} else {
this.removeMod(deps.engine, deps.sourceCard, modData);
}
}
}
return evntRetVal as ReturnType<NonNullable<CardMod[T]>> | undefined;
}
}
export namespace CardMod {
export type ModData = [string, StackingData, ...unknown[],];
export type DurationData = ['$duration', number];
export type EnemyModData = unknown[];
export type ModConstructor = TypeConstructor<CardMod>;
export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;
export type ModLibrary = Record<string, ModConstructor>;
export type AppendStackingData = ['$stack', StackingBehavior.append];
export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];
export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];
export type ReplaceStackingData = ['$stack', StackingBehavior.replace];
export type StackStackingData = ['$stack', StackingBehavior.stack, number];
export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;
export enum StackingBehavior {
append,
neverReplace,
ranked,
replace,
stack,
}
export interface ICardModDeps {
engine: GameEngine.IGameEngine;
sourceCard: GameEngine.ICardState;
contextCard?: GameEngine.ICardState;
}
export namespace Content {
// Defines a card modifier - the class name is treated as the mod name
export class backdoor extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(public damage: number) {
// Any extra data to serialize into this.modData as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display modifier effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI modifiers,
// see _standardAi below for example
super(arguments);
this.stackingConfig.rank = damage;
}
}
export class diagnostics extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public secBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = secBonus;
}
override onTurnEnd(deps: ICardModDeps): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
}
export class firewall extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(override duration: number) {
super(arguments);
this.stackingConfig.rank = duration;
}
override onInitMod(deps: ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
return;
}
GameEngineUtils.revalidateIntents(deps.engine, true);
}
}
export class impervious extends CardMod {
constructor(override duration = -1) {
super(arguments);
}
override onSecDamageIn(_deps: ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return {
secDmgBonus: -9999,
};
}
}
export class lag extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class offline extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
}
GameEngineUtils.revalidateIntents(deps.engine, GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard));
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class secured extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public tempSecBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = tempSecBonus;
}
override onInitMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
override onStackMod(deps: ICardModDeps, stackDelta: number): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, stackDelta, false);
}
override onRemoveMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -this.stackingConfig.stackCount, true);
}
}
export class _waveBonus_extraMove extends CardMod {
override onInitMod(deps: ICardModDeps): void {
const player = GameEngineUtils
|
.findPlayerByCardId(deps.engine.gameData, deps.sourceCard.id);
|
player.movesPerTurn++;
player.movesLeft = player.movesPerTurn;
deps.engine.broadcast.push({
type: 'movesPerTurnsChange',
playerId: player.id,
newMovesLeft: player.movesLeft,
newMovesPerTurn: player.movesPerTurn,
});
}
}
export class _winOnDeath extends CardMod {
override onCardDestroyed(deps: ICardModDeps) {
const player = deps.contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null;
player && player.stats.kills++;
deps.engine.onWinGame();
player && player.stats.kills--;
}
}
export class _standardAi extends CardMod {
override onTurnStart(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
}
override onTurnEnd(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.executeIntent(deps.engine, deps.sourceCard);
}
}
export class _yieldScript extends CardMod {
constructor(
public scriptData: CardScript.ScriptData,
override duration: number,
) {
super(arguments);
}
override onRemoveMod(deps: ICardModDeps) {
CardScript.addScript(deps.engine, deps.sourceCard, this.scriptData);
}
}
export class _waveTrigger extends CardMod {
constructor(
public rulesetIds: string[],
override duration = -1,
) {
super(arguments);
}
override onInitMod(deps: ICardModDeps): void {
deps.engine.gameData.difficulty < 3 && GameEngineUtils.changeSec(deps.engine, deps.sourceCard, 25, true);
}
override onCardDestroyed(deps: ICardModDeps) {
deps.engine.onNextWave(this.rulesetIds.random());
deps.contextCard && CardMod.addMod(deps.engine, deps.contextCard, new _waveBonus_extraMove());
}
override onRemoveMod(deps: ICardModDeps): void {
CardMod.addMod(deps.engine, deps.sourceCard, new _winOnDeath());
}
}
}
}
|
src/game/card-mods.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " deps.engine.broadcast.push({\n type: 'cpuChanged',\n cardId: deps.sourceCard.id,\n newCpu: deps.sourceCard.cpu,\n });\n GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);\n }\n override onRemoveMod(deps: CardMod.ICardModDeps) {\n deps.sourceCard.cpu -= this.stackingConfig.stackCount;\n deps.engine.broadcast.push({",
"score": 0.8852783441543579
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {\n CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);\n if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {\n GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n }\n }\n },\n },",
"score": 0.880141019821167
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (deps.sourceCard.mem - memDmg <= 0) return;\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n let secBonus = 100;\n const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);\n if (shieldBuff) {\n secBonus += CardMod.getStackCount(shieldBuff) * 100;\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);\n for (const enemy of [...deps.engine.gameData.enemies]) {\n if (enemy === boss) continue;",
"score": 0.8746060132980347
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " }\n override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {\n CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);\n }\n },\n // Increases CPU\n optimized: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,",
"score": 0.8718464374542236
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,\n };\n constructor(public dot: number) {\n super(arguments);\n this.stackingConfig.stackCount = dot;\n }\n override onTurnEnd(deps: CardMod.ICardModDeps) {\n CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);\n }",
"score": 0.8647722005844116
}
] |
typescript
|
.findPlayerByCardId(deps.engine.gameData, deps.sourceCard.id);
|
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export abstract class CardMod {
duration = -1;
stackingConfig: Parameters<typeof CardMod['makeStackingData']>[0] = { behavior: CardMod.StackingBehavior.neverReplace };
readonly modName: string;
constructor(
private _extraModData?: IArguments,
) {
this.modName = this.constructor.name;
}
onSecDamageIn?(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState): { secDmgBonus: number } | void;
onSecDamageOut?(deps: CardMod.ICardModDeps, baseDmg: number): { secDmgBonus: number } | void;
onMemDmgIn?(deps: CardMod.ICardModDeps, memDmg: number): void;
onMemDmgOut?(deps: CardMod.ICardModDeps, memDmg: number): void;
onInitMod?(deps: CardMod.ICardModDeps): void;
onRemoveMod?(deps: CardMod.ICardModDeps): void;
onCardDestroyed?(deps: CardMod.ICardModDeps): void;
onStackMod?(deps: CardMod.ICardModDeps, stackDelta: number): void;
onTurnStart?(deps: CardMod.ICardModDeps): void;
onTurnEnd?(deps: CardMod.ICardModDeps): void;
onEnemyDestroyed?(deps: CardMod.ICardModDeps): void;
serialize() {
const stackingData = CardMod.makeStackingData(this.stackingConfig);
const modData = [this.modName, stackingData] as CardMod.ModData;
(this.duration >= 0) && (modData.push(CardMod.makeDurationData(this.duration)));
this._extraModData && modData.push(...this._extraModData);
return modData;
}
static addMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, mod: CardMod, contextCard?: GameEngine.ICardState) {
const modData = mod.serialize();
switch (mod.stackingConfig.behavior) {
case CardMod.StackingBehavior.append: {
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.neverReplace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) return;
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.ranked: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
if (existingStackingData[2] >= mod.stackingConfig.rank) {
return;
}
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.replace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.stack: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
existingStackingData && (existingStackingData[2] += mod.stackingConfig.stackCount);
engine.broadcast.push({
type: 'modStackChanged',
cardId: card.id,
modData: existingModData,
stackDelta: mod.stackingConfig.stackCount,
newStackCount: existingStackingData[2],
});
this.trigger('onStackMod', existingModData, { engine, sourceCard: card, contextCard }, mod.stackingConfig.stackCount);
return;
}
card.mods.push(modData);
break;
}
}
engine.broadcast.push({
type: 'modAdded',
cardId: card.id,
modData,
});
this.trigger('onInitMod', modData, { engine, sourceCard: card, contextCard });
}
static areEqual(left: CardMod.ModData, right: CardMod.ModData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, modData: CardMod.ModData) {
const modCtor = engine.ruleset.cardMods?.[modData[0]];
if (!modCtor) throw new Error('mod not found: ' + modData.join());
const durationData = this.findDurationData(modData);
const mod = new modCtor(...modData.slice(durationData ? 3 : 2));
durationData && (mod.duration = durationData[1]);
const stackingData = modData[1];
mod.stackingConfig.behavior = stackingData[1];
switch (stackingData[1]) {
case CardMod.StackingBehavior.ranked:
(mod.stackingConfig as any).rank = stackingData[2];
break;
case CardMod.StackingBehavior.stack:
(mod.stackingConfig as any).stackCount = stackingData[2];
break;
}
return mod;
}
static findDurationData(modData: CardMod.ModData) {
const maybeDurationData = modData[2];
return (Array.isArray(maybeDurationData) && maybeDurationData[0] === '$duration') ? (modData[2] as CardMod.DurationData) : undefined;
}
static findModOfType(card: GameEngine.ICardState, modType: CardMod.ModConstructor) {
return card.mods.find(x => x[0] === modType.name);
}
static getStackCount(modData: CardMod.ModData) {
return modData[1][1] === CardMod.StackingBehavior.stack ? modData[1][2] : 0;
}
static makeDurationData(duration: number): CardMod.DurationData {
return ['$duration', duration];
}
static makeStackingData(
stackConfig: { behavior: CardMod.StackingBehavior.append }
| { behavior: CardMod.StackingBehavior.neverReplace }
| { behavior: CardMod.StackingBehavior.ranked, rank: number }
| { behavior: CardMod.StackingBehavior.replace }
| { behavior: CardMod.StackingBehavior.stack, stackCount: number }
) {
const stackingData = ['$stack', stackConfig.behavior];
(stackConfig.behavior === CardMod.StackingBehavior.ranked) && stackingData.push(stackConfig.rank);
(stackConfig.behavior === CardMod.StackingBehavior.stack) && stackingData.push(stackConfig.stackCount);
return stackingData as CardMod.StackingData;
}
static removeMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modData: CardMod.ModData, contextCard?: GameEngine.ICardState) {
engine.broadcast.push({
type: 'modRemoved',
cardId: card.id,
modData,
});
if (!card.mods.find(x => this.areEqual(x, modData))) {
throw new Error('mod not found');
}
this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });
card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));
}
static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {
const mod = card.mods.find(x => x[0] === modName);
mod && this.removeMod(engine, card, mod, contextCard);
}
static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {
const deps = args[0];
const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));
if (!modDataFromCard) {
throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);
}
const mod = this.deserialize(deps.engine, modDataFromCard);
const evnt = mod[ev];
const evntRetVal = evnt ? (evnt as any).apply(mod, args) : undefined;
if (deps.sourceCard.isRemoved) {
return;
}
if (ev === 'onTurnStart') {
const durationData = this.findDurationData(modDataFromCard);
if (durationData) {
if (durationData[1] > 1) {
durationData[1]--;
deps.engine.broadcast.push({
type: 'modDurationChanged',
cardId: deps.sourceCard.id,
modData: modData,
newDuration: durationData[1],
});
} else {
this.removeMod(deps.engine, deps.sourceCard, modData);
}
}
}
return evntRetVal as ReturnType<NonNullable<CardMod[T]>> | undefined;
}
}
export namespace CardMod {
export type ModData = [string, StackingData, ...unknown[],];
export type DurationData = ['$duration', number];
export type EnemyModData = unknown[];
export type ModConstructor = TypeConstructor<CardMod>;
export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;
export type ModLibrary = Record<string, ModConstructor>;
export type AppendStackingData = ['$stack', StackingBehavior.append];
export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];
export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];
export type ReplaceStackingData = ['$stack', StackingBehavior.replace];
export type StackStackingData = ['$stack', StackingBehavior.stack, number];
export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;
export enum StackingBehavior {
append,
neverReplace,
ranked,
replace,
stack,
}
export interface ICardModDeps {
engine: GameEngine.IGameEngine;
sourceCard: GameEngine.ICardState;
contextCard?: GameEngine.ICardState;
}
export namespace Content {
// Defines a card modifier - the class name is treated as the mod name
export class backdoor extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(public damage: number) {
// Any extra data to serialize into this.modData as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display modifier effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI modifiers,
// see _standardAi below for example
super(arguments);
this.stackingConfig.rank = damage;
}
}
export class diagnostics extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public secBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = secBonus;
}
override onTurnEnd(deps: ICardModDeps): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
}
export class firewall extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(override duration: number) {
super(arguments);
this.stackingConfig.rank = duration;
}
override onInitMod(deps: ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
return;
}
GameEngineUtils.revalidateIntents(deps.engine, true);
}
}
export class impervious extends CardMod {
constructor(override duration = -1) {
super(arguments);
}
override onSecDamageIn(_deps: ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return {
secDmgBonus: -9999,
};
}
}
export class lag extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class offline extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
}
GameEngineUtils.revalidateIntents(deps.engine, GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard));
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class secured extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public tempSecBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = tempSecBonus;
}
override onInitMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
override onStackMod(deps: ICardModDeps, stackDelta: number): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, stackDelta, false);
}
override onRemoveMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -this.stackingConfig.stackCount, true);
}
}
export class _waveBonus_extraMove extends CardMod {
override onInitMod(deps: ICardModDeps): void {
const player = GameEngineUtils.findPlayerByCardId(deps.engine.gameData, deps.sourceCard.id);
player.movesPerTurn++;
player.movesLeft = player.movesPerTurn;
deps.engine.broadcast.push({
type: 'movesPerTurnsChange',
playerId: player.id,
newMovesLeft: player.movesLeft,
newMovesPerTurn: player.movesPerTurn,
});
}
}
export class _winOnDeath extends CardMod {
override onCardDestroyed(deps: ICardModDeps) {
const player = deps.contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null;
player && player.stats.kills++;
deps.engine.onWinGame();
player && player.stats.kills--;
}
}
export class _standardAi extends CardMod {
override onTurnStart(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
}
override onTurnEnd(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.executeIntent(deps.engine, deps.sourceCard);
}
}
export class _yieldScript extends CardMod {
constructor(
public
|
scriptData: CardScript.ScriptData,
override duration: number,
) {
|
super(arguments);
}
override onRemoveMod(deps: ICardModDeps) {
CardScript.addScript(deps.engine, deps.sourceCard, this.scriptData);
}
}
export class _waveTrigger extends CardMod {
constructor(
public rulesetIds: string[],
override duration = -1,
) {
super(arguments);
}
override onInitMod(deps: ICardModDeps): void {
deps.engine.gameData.difficulty < 3 && GameEngineUtils.changeSec(deps.engine, deps.sourceCard, 25, true);
}
override onCardDestroyed(deps: ICardModDeps) {
deps.engine.onNextWave(this.rulesetIds.random());
deps.contextCard && CardMod.addMod(deps.engine, deps.contextCard, new _waveBonus_extraMove());
}
override onRemoveMod(deps: ICardModDeps): void {
CardMod.addMod(deps.engine, deps.sourceCard, new _winOnDeath());
}
}
}
}
|
src/game/card-mods.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " });\n }\n }\n}\nexport namespace CardScript {\n export type ScriptData = [string, ...unknown[]];\n export type CooldownData = ['$cooldown', number, number];\n export type ScriptConstructor = { new(card: GameEngine.ICardState, ...args: any[]): CardScript };\n export type ScriptLibrary = Record<string, ScriptConstructor>;\n export interface ITargetResolver {",
"score": 0.8487431406974792
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " targetCardId: targetCard.id,\n scriptData: sourceCardScript,\n });\n if (this.isOnCooldown(sourceCardScript)) {\n throw new Error('Script is on cooldown: ' + sourceCardScript.join());\n }\n const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript));\n const isEnemy = GameEngineUtils.isEnemyCard(engine.gameData, sourceCard);\n if (!isEnemy) {\n if (!scriptDataFromCard) {",
"score": 0.8467730283737183
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());\n }\n }\n const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);\n if (cooldownData) {\n cooldownData[1] = cooldownData[2] + 1;\n }\n const script = this.deserialize(engine, sourceCard, sourceCardScript);\n const targets = script.targetFinder(engine.gameData, sourceCard);\n if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {",
"score": 0.844347357749939
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " if (cooldownData) {\n script.cooldownCur = cooldownData[1];\n script.cooldownMax = cooldownData[2];\n }\n return script;\n }\n static execute(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, sourceCardScript: CardScript.ScriptData, targetCard: GameEngine.ICardState) {\n engine.broadcast.push({\n type: 'cardExecuting',\n cardId: sourceCard.id,",
"score": 0.8435991406440735
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " (this.cooldownCur > 0 || this.cooldownMax > 0) && retVal.push(CardScript.makeCooldownData(this.cooldownMax, this.cooldownCur));\n return retVal;\n }\n static addScript(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptData: CardScript.ScriptData) {\n card.scripts.push(scriptData);\n engine.broadcast.push({\n type: 'scriptAdded',\n cardId: card.id,\n scriptData,\n });",
"score": 0.8420424461364746
}
] |
typescript
|
scriptData: CardScript.ScriptData,
override duration: number,
) {
|
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export namespace CardScriptParts {
export interface IScriptPart {
(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): void;
}
export const _Chance = (chance: number, curriedPart: IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (Math.random() < chance) {
curriedPart(engine, sourceCard, targetCard);
}
};
export const _TargetHasMod = <T extends CardMod.ModLibrary, K extends keyof T>(modName: K, curry: (mod: InstanceType<T[K]>) => IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
const mod = targetCard.mods.find(x => x[0] === modName);
if (mod) {
curry(CardMod.deserialize(engine, mod) as InstanceType<T[K]>)(engine, sourceCard, targetCard);
}
};
export const AddMod = (mod: CardMod): IScriptPart =>
(engine, sourceCard, targetCard) => {
CardMod.addMod(engine, targetCard, mod, sourceCard);
};
export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;
if (secExceeded) {
MemDmg(1)(engine, sourceCard, targetCard);
}
};
export const SecDmg = (secDmg: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
let resolvedDamage = secDmg;
if (!dontTriggerOut) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageOut', { engine, sourceCard, contextCard: targetCard }, resolvedDamage)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (!dontTriggerIn) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return false;
}
resolvedDamage = Math.max(0, resolvedDamage);
const secExceeded = resolvedDamage > targetCard.sec;
GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);
return secExceeded;
};
export const MemDmg = (memDmg: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.triggerMods('onMemDmgOut', { engine, sourceCard, contextCard: targetCard }, memDmg);
GameEngineUtils.triggerMods('onMemDmgIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, memDmg);
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return;
}
targetCard.mem -= memDmg;
engine.broadcast.push({
type: 'memDamage',
cardId: targetCard.id,
newMem: targetCard.mem,
value: -memDmg,
});
const player = GameEngineUtils
|
.findPlayerByCardIdMaybe(engine.gameData, sourceCard.id);
|
player && (player.stats.memDmg += memDmg);
if (targetCard.mem <= 0) {
GameEngineUtils.removeCard(engine, targetCard, sourceCard);
}
};
export const ChangeCpu = (cpuDelta: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
};
export const RaiseMem = (memBonus: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
targetCard.mem += memBonus;
engine.broadcast.push({
type: 'memBonus',
cardId: targetCard.id,
newMem: targetCard.mem,
value: memBonus,
});
};
export const RaiseSec = (secBonus: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.changeSec(engine, targetCard, secBonus, false, sourceCard);
};
export const RedirectIntentRandom: IScriptPart =
(engine, _sourceCard, targetCard) => {
if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;
const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);
if (script.targetFinder === CardScript.TargetFinders.Self) return;
const targets = script.targetFinder(engine.gameData, targetCard);
if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;
const origTargetId = targetCard.intent.targetCardId;
while (targetCard.intent.targetCardId === origTargetId) {
targetCard.intent.targetCardId = targets.random().id;
}
engine.broadcast.push({
type: 'cardIntent',
cardId: targetCard.id,
intent: targetCard.intent,
});
};
export const RemoveMod = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modName: K, mustRemove = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (mustRemove) {
if (!targetCard.mods.find(x => x[0] === modName)) {
throw new Error(`Could not find [${modName}] to remove`);
}
}
CardMod.removeModByName(engine, targetCard, modName, sourceCard);
};
export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>
(engine, sourceCard, _targetCard) => {
let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);
switch (spawnPosition) {
case 'absLeft': spawnIndex = 0; break;
case 'absRight': spawnIndex = engine.gameData.enemies.length; break;
case 'relRight': spawnIndex++; break;
}
GameEngineUtils.spawnEnemy(engine, enemyClass, spawnIndex, generateIntent);
};
}
|
src/game/card-script-parts.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (deps.sourceCard.mem - memDmg <= 0) return;\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n let secBonus = 100;\n const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);\n if (shieldBuff) {\n secBonus += CardMod.getStackCount(shieldBuff) * 100;\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);\n for (const enemy of [...deps.engine.gameData.enemies]) {\n if (enemy === boss) continue;",
"score": 0.9030243158340454
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " export function changeMem(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, memDelta: number) {\n card.mem += memDelta;\n engine.broadcast.push({\n type: 'memChanged',\n cardId: card.id,\n newMem: card.mem,\n memDelta,\n });\n GameEngineUtils.recalculateScripts(engine, card);\n }",
"score": 0.8882127404212952
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n (engine, _sourceCard, targetCard) => {\n const totalStats = targetCard.cpu + targetCard.mem;\n const newCpu = randInt(1, totalStats - 1);\n const cpuDelta = newCpu - targetCard.cpu;\n GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);\n const newMem = totalStats - newCpu;\n const memDelta = newMem - targetCard.mem;\n GameEngineUtils.changeMem(engine, targetCard, memDelta);\n },",
"score": 0.8858290910720825
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " triggerMods('onEnemyDestroyed', { engine, sourceCard: card, contextCard });\n }\n if (contextCard) {\n const player = findPlayerByCardIdMaybe(engine.gameData, contextCard.id);\n player && player.stats.kills++;\n }\n GameEngineUtils.revalidateIntents(engine, true);\n } else {\n const player = GameEngineUtils.findPlayerByCardId(engine.gameData, card.id);\n player.cards.removeFirst(card);",
"score": 0.8729609251022339
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());\n }\n }\n const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);\n if (cooldownData) {\n cooldownData[1] = cooldownData[2] + 1;\n }\n const script = this.deserialize(engine, sourceCard, sourceCardScript);\n const targets = script.targetFinder(engine.gameData, sourceCard);\n if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {",
"score": 0.8660550117492676
}
] |
typescript
|
.findPlayerByCardIdMaybe(engine.gameData, sourceCard.id);
|
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export abstract class CardMod {
duration = -1;
stackingConfig: Parameters<typeof CardMod['makeStackingData']>[0] = { behavior: CardMod.StackingBehavior.neverReplace };
readonly modName: string;
constructor(
private _extraModData?: IArguments,
) {
this.modName = this.constructor.name;
}
onSecDamageIn?(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState): { secDmgBonus: number } | void;
onSecDamageOut?(deps: CardMod.ICardModDeps, baseDmg: number): { secDmgBonus: number } | void;
onMemDmgIn?(deps: CardMod.ICardModDeps, memDmg: number): void;
onMemDmgOut?(deps: CardMod.ICardModDeps, memDmg: number): void;
onInitMod?(deps: CardMod.ICardModDeps): void;
onRemoveMod?(deps: CardMod.ICardModDeps): void;
onCardDestroyed?(deps: CardMod.ICardModDeps): void;
onStackMod?(deps: CardMod.ICardModDeps, stackDelta: number): void;
onTurnStart?(deps: CardMod.ICardModDeps): void;
onTurnEnd?(deps: CardMod.ICardModDeps): void;
onEnemyDestroyed?(deps: CardMod.ICardModDeps): void;
serialize() {
const stackingData = CardMod.makeStackingData(this.stackingConfig);
const modData = [this.modName, stackingData] as CardMod.ModData;
(this.duration >= 0) && (modData.push(CardMod.makeDurationData(this.duration)));
this._extraModData && modData.push(...this._extraModData);
return modData;
}
static addMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, mod: CardMod, contextCard?: GameEngine.ICardState) {
const modData = mod.serialize();
switch (mod.stackingConfig.behavior) {
case CardMod.StackingBehavior.append: {
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.neverReplace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) return;
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.ranked: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
if (existingStackingData[2] >= mod.stackingConfig.rank) {
return;
}
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.replace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.stack: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
existingStackingData && (existingStackingData[2] += mod.stackingConfig.stackCount);
engine.broadcast.push({
type: 'modStackChanged',
cardId: card.id,
modData: existingModData,
stackDelta: mod.stackingConfig.stackCount,
newStackCount: existingStackingData[2],
});
this.trigger('onStackMod', existingModData, { engine, sourceCard: card, contextCard }, mod.stackingConfig.stackCount);
return;
}
card.mods.push(modData);
break;
}
}
engine.broadcast.push({
type: 'modAdded',
cardId: card.id,
modData,
});
this.trigger('onInitMod', modData, { engine, sourceCard: card, contextCard });
}
static areEqual(left: CardMod.ModData, right: CardMod.ModData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, modData: CardMod.ModData) {
const modCtor = engine.ruleset.cardMods?.[modData[0]];
if (!modCtor) throw new Error('mod not found: ' + modData.join());
const durationData = this.findDurationData(modData);
const mod = new modCtor(...modData.slice(durationData ? 3 : 2));
durationData && (mod.duration = durationData[1]);
const stackingData = modData[1];
mod.stackingConfig.behavior = stackingData[1];
switch (stackingData[1]) {
case CardMod.StackingBehavior.ranked:
(mod.stackingConfig as any).rank = stackingData[2];
break;
case CardMod.StackingBehavior.stack:
(mod.stackingConfig as any).stackCount = stackingData[2];
break;
}
return mod;
}
static findDurationData(modData: CardMod.ModData) {
const maybeDurationData = modData[2];
return (Array.isArray(maybeDurationData) && maybeDurationData[0] === '$duration') ? (modData[2] as CardMod.DurationData) : undefined;
}
static findModOfType(card: GameEngine.ICardState, modType: CardMod.ModConstructor) {
return card.mods.find(x => x[0] === modType.name);
}
static getStackCount(modData: CardMod.ModData) {
return modData[1][1] === CardMod.StackingBehavior.stack ? modData[1][2] : 0;
}
static makeDurationData(duration: number): CardMod.DurationData {
return ['$duration', duration];
}
static makeStackingData(
stackConfig: { behavior: CardMod.StackingBehavior.append }
| { behavior: CardMod.StackingBehavior.neverReplace }
| { behavior: CardMod.StackingBehavior.ranked, rank: number }
| { behavior: CardMod.StackingBehavior.replace }
| { behavior: CardMod.StackingBehavior.stack, stackCount: number }
) {
const stackingData = ['$stack', stackConfig.behavior];
(stackConfig.behavior === CardMod.StackingBehavior.ranked) && stackingData.push(stackConfig.rank);
(stackConfig.behavior === CardMod.StackingBehavior.stack) && stackingData.push(stackConfig.stackCount);
return stackingData as CardMod.StackingData;
}
static removeMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modData: CardMod.ModData, contextCard?: GameEngine.ICardState) {
engine.broadcast.push({
type: 'modRemoved',
cardId: card.id,
modData,
});
if (!card.mods.find(x => this.areEqual(x, modData))) {
throw new Error('mod not found');
}
this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });
card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));
}
static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {
const mod = card.mods.find(x => x[0] === modName);
mod && this.removeMod(engine, card, mod, contextCard);
}
static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {
const deps = args[0];
const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));
if (!modDataFromCard) {
throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);
}
const mod = this.deserialize(deps.engine, modDataFromCard);
const evnt = mod[ev];
const evntRetVal = evnt ? (evnt as any).apply(mod, args) : undefined;
if (deps.sourceCard.isRemoved) {
return;
}
if (ev === 'onTurnStart') {
const durationData = this.findDurationData(modDataFromCard);
if (durationData) {
if (durationData[1] > 1) {
durationData[1]--;
deps.engine.broadcast.push({
type: 'modDurationChanged',
cardId: deps.sourceCard.id,
modData: modData,
newDuration: durationData[1],
});
} else {
this.removeMod(deps.engine, deps.sourceCard, modData);
}
}
}
return evntRetVal as ReturnType<NonNullable<CardMod[T]>> | undefined;
}
}
export namespace CardMod {
export type ModData = [string, StackingData, ...unknown[],];
export type DurationData = ['$duration', number];
export type EnemyModData = unknown[];
export type ModConstructor = TypeConstructor<CardMod>;
export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;
export type ModLibrary = Record<string, ModConstructor>;
export type AppendStackingData = ['$stack', StackingBehavior.append];
export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];
export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];
export type ReplaceStackingData = ['$stack', StackingBehavior.replace];
export type StackStackingData = ['$stack', StackingBehavior.stack, number];
export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;
export enum StackingBehavior {
append,
neverReplace,
ranked,
replace,
stack,
}
export interface ICardModDeps {
engine: GameEngine.IGameEngine;
sourceCard: GameEngine.ICardState;
contextCard?: GameEngine.ICardState;
}
export namespace Content {
// Defines a card modifier - the class name is treated as the mod name
export class backdoor extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(public damage: number) {
// Any extra data to serialize into this.modData as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display modifier effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI modifiers,
// see _standardAi below for example
super(arguments);
this.stackingConfig.rank = damage;
}
}
export class diagnostics extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public secBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = secBonus;
}
override onTurnEnd(deps: ICardModDeps): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
}
export class firewall extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(override duration: number) {
super(arguments);
this.stackingConfig.rank = duration;
}
override onInitMod(deps: ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
return;
}
GameEngineUtils.revalidateIntents(deps.engine, true);
}
}
export class impervious extends CardMod {
constructor(override duration = -1) {
super(arguments);
}
override onSecDamageIn(_deps: ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return {
secDmgBonus: -9999,
};
}
}
export class lag extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
|
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
|
}
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class offline extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
}
GameEngineUtils.revalidateIntents(deps.engine, GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard));
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class secured extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public tempSecBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = tempSecBonus;
}
override onInitMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
override onStackMod(deps: ICardModDeps, stackDelta: number): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, stackDelta, false);
}
override onRemoveMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -this.stackingConfig.stackCount, true);
}
}
export class _waveBonus_extraMove extends CardMod {
override onInitMod(deps: ICardModDeps): void {
const player = GameEngineUtils.findPlayerByCardId(deps.engine.gameData, deps.sourceCard.id);
player.movesPerTurn++;
player.movesLeft = player.movesPerTurn;
deps.engine.broadcast.push({
type: 'movesPerTurnsChange',
playerId: player.id,
newMovesLeft: player.movesLeft,
newMovesPerTurn: player.movesPerTurn,
});
}
}
export class _winOnDeath extends CardMod {
override onCardDestroyed(deps: ICardModDeps) {
const player = deps.contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null;
player && player.stats.kills++;
deps.engine.onWinGame();
player && player.stats.kills--;
}
}
export class _standardAi extends CardMod {
override onTurnStart(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
}
override onTurnEnd(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.executeIntent(deps.engine, deps.sourceCard);
}
}
export class _yieldScript extends CardMod {
constructor(
public scriptData: CardScript.ScriptData,
override duration: number,
) {
super(arguments);
}
override onRemoveMod(deps: ICardModDeps) {
CardScript.addScript(deps.engine, deps.sourceCard, this.scriptData);
}
}
export class _waveTrigger extends CardMod {
constructor(
public rulesetIds: string[],
override duration = -1,
) {
super(arguments);
}
override onInitMod(deps: ICardModDeps): void {
deps.engine.gameData.difficulty < 3 && GameEngineUtils.changeSec(deps.engine, deps.sourceCard, 25, true);
}
override onCardDestroyed(deps: ICardModDeps) {
deps.engine.onNextWave(this.rulesetIds.random());
deps.contextCard && CardMod.addMod(deps.engine, deps.contextCard, new _waveBonus_extraMove());
}
override onRemoveMod(deps: ICardModDeps): void {
CardMod.addMod(deps.engine, deps.sourceCard, new _winOnDeath());
}
}
}
}
|
src/game/card-mods.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {\n CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);\n if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {\n GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n }\n }\n },\n },",
"score": 0.8832052946090698
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " goliath_boss_ai: class extends CardMod {\n override onTurnStart(deps: CardMod.ICardModDeps) {\n GameEngineUtils.generateIntent(deps.engine, deps.sourceCard as GameEngine.IEnemyCardState);\n }\n override onTurnEnd(deps: CardMod.ICardModDeps) {\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n const targetId = boss.intent?.targetCardId;\n if (!targetId) return;\n let numAttacks = 1;\n const powerBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_power);",
"score": 0.8679781556129456
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " constructor(_card: GameEngine.ICardState) {\n const lagDuration = 1;\n super(\n [lagDuration],\n CardScript.TargetFinders.Any(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(",
"score": 0.8591284155845642
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);\n CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_power(), deps.sourceCard);\n }\n },\n goliath_shield_supply: class extends CardMod {\n override onCardDestroyed(deps: CardMod.ICardModDeps) {\n const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);\n CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_shield(), deps.sourceCard);\n }\n },",
"score": 0.8529406785964966
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (deps.sourceCard.mem - memDmg <= 0) return;\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n let secBonus = 100;\n const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);\n if (shieldBuff) {\n secBonus += CardMod.getStackCount(shieldBuff) * 100;\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);\n for (const enemy of [...deps.engine.gameData.enemies]) {\n if (enemy === boss) continue;",
"score": 0.8517000675201416
}
] |
typescript
|
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
|
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export abstract class CardMod {
duration = -1;
stackingConfig: Parameters<typeof CardMod['makeStackingData']>[0] = { behavior: CardMod.StackingBehavior.neverReplace };
readonly modName: string;
constructor(
private _extraModData?: IArguments,
) {
this.modName = this.constructor.name;
}
onSecDamageIn?(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState): { secDmgBonus: number } | void;
onSecDamageOut?(deps: CardMod.ICardModDeps, baseDmg: number): { secDmgBonus: number } | void;
onMemDmgIn?(deps: CardMod.ICardModDeps, memDmg: number): void;
onMemDmgOut?(deps: CardMod.ICardModDeps, memDmg: number): void;
onInitMod?(deps: CardMod.ICardModDeps): void;
onRemoveMod?(deps: CardMod.ICardModDeps): void;
onCardDestroyed?(deps: CardMod.ICardModDeps): void;
onStackMod?(deps: CardMod.ICardModDeps, stackDelta: number): void;
onTurnStart?(deps: CardMod.ICardModDeps): void;
onTurnEnd?(deps: CardMod.ICardModDeps): void;
onEnemyDestroyed?(deps: CardMod.ICardModDeps): void;
serialize() {
const stackingData = CardMod.makeStackingData(this.stackingConfig);
const modData = [this.modName, stackingData] as CardMod.ModData;
(this.duration >= 0) && (modData.push(CardMod.makeDurationData(this.duration)));
this._extraModData && modData.push(...this._extraModData);
return modData;
}
static addMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, mod: CardMod, contextCard?: GameEngine.ICardState) {
const modData = mod.serialize();
switch (mod.stackingConfig.behavior) {
case CardMod.StackingBehavior.append: {
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.neverReplace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) return;
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.ranked: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
if (existingStackingData[2] >= mod.stackingConfig.rank) {
return;
}
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.replace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.stack: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
existingStackingData && (existingStackingData[2] += mod.stackingConfig.stackCount);
engine.broadcast.push({
type: 'modStackChanged',
cardId: card.id,
modData: existingModData,
stackDelta: mod.stackingConfig.stackCount,
newStackCount: existingStackingData[2],
});
this.trigger('onStackMod', existingModData, { engine, sourceCard: card, contextCard }, mod.stackingConfig.stackCount);
return;
}
card.mods.push(modData);
break;
}
}
engine.broadcast.push({
type: 'modAdded',
cardId: card.id,
modData,
});
this.trigger('onInitMod', modData, { engine, sourceCard: card, contextCard });
}
static areEqual(left: CardMod.ModData, right: CardMod.ModData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, modData: CardMod.ModData) {
const modCtor = engine.ruleset.cardMods?.[modData[0]];
if (!modCtor) throw new Error('mod not found: ' + modData.join());
const durationData = this.findDurationData(modData);
const mod = new modCtor(...modData.slice(durationData ? 3 : 2));
durationData && (mod.duration = durationData[1]);
const stackingData = modData[1];
mod.stackingConfig.behavior = stackingData[1];
switch (stackingData[1]) {
case CardMod.StackingBehavior.ranked:
(mod.stackingConfig as any).rank = stackingData[2];
break;
case CardMod.StackingBehavior.stack:
(mod.stackingConfig as any).stackCount = stackingData[2];
break;
}
return mod;
}
static findDurationData(modData: CardMod.ModData) {
const maybeDurationData = modData[2];
return (Array.isArray(maybeDurationData) && maybeDurationData[0] === '$duration') ? (modData[2] as CardMod.DurationData) : undefined;
}
static findModOfType(card: GameEngine.ICardState, modType: CardMod.ModConstructor) {
return card.mods.find(x => x[0] === modType.name);
}
static getStackCount(modData: CardMod.ModData) {
return modData[1][1] === CardMod.StackingBehavior.stack ? modData[1][2] : 0;
}
static makeDurationData(duration: number): CardMod.DurationData {
return ['$duration', duration];
}
static makeStackingData(
stackConfig: { behavior: CardMod.StackingBehavior.append }
| { behavior: CardMod.StackingBehavior.neverReplace }
| { behavior: CardMod.StackingBehavior.ranked, rank: number }
| { behavior: CardMod.StackingBehavior.replace }
| { behavior: CardMod.StackingBehavior.stack, stackCount: number }
) {
const stackingData = ['$stack', stackConfig.behavior];
(stackConfig.behavior === CardMod.StackingBehavior.ranked) && stackingData.push(stackConfig.rank);
(stackConfig.behavior === CardMod.StackingBehavior.stack) && stackingData.push(stackConfig.stackCount);
return stackingData as CardMod.StackingData;
}
static removeMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modData: CardMod.ModData, contextCard?: GameEngine.ICardState) {
engine.broadcast.push({
type: 'modRemoved',
cardId: card.id,
modData,
});
if (!card.mods.find(x => this.areEqual(x, modData))) {
throw new Error('mod not found');
}
this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });
card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));
}
static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {
const mod = card.mods.find(x => x[0] === modName);
mod && this.removeMod(engine, card, mod, contextCard);
}
static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {
const deps = args[0];
const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));
if (!modDataFromCard) {
throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);
}
const mod = this.deserialize(deps.engine, modDataFromCard);
const evnt = mod[ev];
const evntRetVal = evnt ? (evnt as any).apply(mod, args) : undefined;
if (deps.sourceCard.isRemoved) {
return;
}
if (ev === 'onTurnStart') {
const durationData = this.findDurationData(modDataFromCard);
if (durationData) {
if (durationData[1] > 1) {
durationData[1]--;
deps.engine.broadcast.push({
type: 'modDurationChanged',
cardId: deps.sourceCard.id,
modData: modData,
newDuration: durationData[1],
});
} else {
this.removeMod(deps.engine, deps.sourceCard, modData);
}
}
}
return evntRetVal as ReturnType<NonNullable<CardMod[T]>> | undefined;
}
}
export namespace CardMod {
export type ModData = [string, StackingData, ...unknown[],];
export type DurationData = ['$duration', number];
export type EnemyModData = unknown[];
export type ModConstructor = TypeConstructor<CardMod>;
export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;
export type ModLibrary = Record<string, ModConstructor>;
export type AppendStackingData = ['$stack', StackingBehavior.append];
export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];
export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];
export type ReplaceStackingData = ['$stack', StackingBehavior.replace];
export type StackStackingData = ['$stack', StackingBehavior.stack, number];
export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;
export enum StackingBehavior {
append,
neverReplace,
ranked,
replace,
stack,
}
export interface ICardModDeps {
engine: GameEngine.IGameEngine;
sourceCard: GameEngine.ICardState;
contextCard?: GameEngine.ICardState;
}
export namespace Content {
// Defines a card modifier - the class name is treated as the mod name
export class backdoor extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(public damage: number) {
// Any extra data to serialize into this.modData as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display modifier effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI modifiers,
// see _standardAi below for example
super(arguments);
this.stackingConfig.rank = damage;
}
}
export class diagnostics extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public secBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = secBonus;
}
override onTurnEnd(deps: ICardModDeps): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
}
export class firewall extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(override duration: number) {
super(arguments);
this.stackingConfig.rank = duration;
}
override onInitMod(deps: ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
return;
}
GameEngineUtils
|
.revalidateIntents(deps.engine, true);
|
}
}
export class impervious extends CardMod {
constructor(override duration = -1) {
super(arguments);
}
override onSecDamageIn(_deps: ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return {
secDmgBonus: -9999,
};
}
}
export class lag extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class offline extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
}
GameEngineUtils.revalidateIntents(deps.engine, GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard));
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class secured extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public tempSecBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = tempSecBonus;
}
override onInitMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
override onStackMod(deps: ICardModDeps, stackDelta: number): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, stackDelta, false);
}
override onRemoveMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -this.stackingConfig.stackCount, true);
}
}
export class _waveBonus_extraMove extends CardMod {
override onInitMod(deps: ICardModDeps): void {
const player = GameEngineUtils.findPlayerByCardId(deps.engine.gameData, deps.sourceCard.id);
player.movesPerTurn++;
player.movesLeft = player.movesPerTurn;
deps.engine.broadcast.push({
type: 'movesPerTurnsChange',
playerId: player.id,
newMovesLeft: player.movesLeft,
newMovesPerTurn: player.movesPerTurn,
});
}
}
export class _winOnDeath extends CardMod {
override onCardDestroyed(deps: ICardModDeps) {
const player = deps.contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null;
player && player.stats.kills++;
deps.engine.onWinGame();
player && player.stats.kills--;
}
}
export class _standardAi extends CardMod {
override onTurnStart(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
}
override onTurnEnd(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.executeIntent(deps.engine, deps.sourceCard);
}
}
export class _yieldScript extends CardMod {
constructor(
public scriptData: CardScript.ScriptData,
override duration: number,
) {
super(arguments);
}
override onRemoveMod(deps: ICardModDeps) {
CardScript.addScript(deps.engine, deps.sourceCard, this.scriptData);
}
}
export class _waveTrigger extends CardMod {
constructor(
public rulesetIds: string[],
override duration = -1,
) {
super(arguments);
}
override onInitMod(deps: ICardModDeps): void {
deps.engine.gameData.difficulty < 3 && GameEngineUtils.changeSec(deps.engine, deps.sourceCard, 25, true);
}
override onCardDestroyed(deps: ICardModDeps) {
deps.engine.onNextWave(this.rulesetIds.random());
deps.contextCard && CardMod.addMod(deps.engine, deps.contextCard, new _waveBonus_extraMove());
}
override onRemoveMod(deps: ICardModDeps): void {
CardMod.addMod(deps.engine, deps.sourceCard, new _winOnDeath());
}
}
}
}
|
src/game/card-mods.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " };\n constructor(cpuBonus: number, override duration: number) {\n super(arguments);\n this.stackingConfig.stackCount = cpuBonus;\n }\n override onInitMod(deps: CardMod.ICardModDeps) {\n GameEngineUtils.changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);\n }\n override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {\n deps.sourceCard.cpu += stackDelta;",
"score": 0.9025295972824097
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,\n };\n constructor(public stackCount: number) {\n super(arguments);\n this.stackingConfig.stackCount = stackCount;\n }\n override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {\n return { secDmgBonus: this.stackingConfig.stackCount };\n }",
"score": 0.889078676700592
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,\n };\n constructor(public dot: number) {\n super(arguments);\n this.stackingConfig.stackCount = dot;\n }\n override onTurnEnd(deps: CardMod.ICardModDeps) {\n CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);\n }",
"score": 0.8803149461746216
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " }\n override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {\n CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);\n }\n },\n // Increases CPU\n optimized: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,",
"score": 0.8595809936523438
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " },\n // Returns damage to attacker\n feedback: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,\n };\n constructor(public damage: number) {\n super(arguments);\n this.stackingConfig.stackCount = damage;",
"score": 0.8558228015899658
}
] |
typescript
|
.revalidateIntents(deps.engine, true);
|
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export abstract class CardMod {
duration = -1;
stackingConfig: Parameters<typeof CardMod['makeStackingData']>[0] = { behavior: CardMod.StackingBehavior.neverReplace };
readonly modName: string;
constructor(
private _extraModData?: IArguments,
) {
this.modName = this.constructor.name;
}
onSecDamageIn?(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState): { secDmgBonus: number } | void;
onSecDamageOut?(deps: CardMod.ICardModDeps, baseDmg: number): { secDmgBonus: number } | void;
onMemDmgIn?(deps: CardMod.ICardModDeps, memDmg: number): void;
onMemDmgOut?(deps: CardMod.ICardModDeps, memDmg: number): void;
onInitMod?(deps: CardMod.ICardModDeps): void;
onRemoveMod?(deps: CardMod.ICardModDeps): void;
onCardDestroyed?(deps: CardMod.ICardModDeps): void;
onStackMod?(deps: CardMod.ICardModDeps, stackDelta: number): void;
onTurnStart?(deps: CardMod.ICardModDeps): void;
onTurnEnd?(deps: CardMod.ICardModDeps): void;
onEnemyDestroyed?(deps: CardMod.ICardModDeps): void;
serialize() {
const stackingData = CardMod.makeStackingData(this.stackingConfig);
const modData = [this.modName, stackingData] as CardMod.ModData;
(this.duration >= 0) && (modData.push(CardMod.makeDurationData(this.duration)));
this._extraModData && modData.push(...this._extraModData);
return modData;
}
static addMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, mod: CardMod, contextCard?: GameEngine.ICardState) {
const modData = mod.serialize();
switch (mod.stackingConfig.behavior) {
case CardMod.StackingBehavior.append: {
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.neverReplace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) return;
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.ranked: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
if (existingStackingData[2] >= mod.stackingConfig.rank) {
return;
}
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.replace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.stack: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
existingStackingData && (existingStackingData[2] += mod.stackingConfig.stackCount);
engine.broadcast.push({
type: 'modStackChanged',
cardId: card.id,
modData: existingModData,
stackDelta: mod.stackingConfig.stackCount,
newStackCount: existingStackingData[2],
});
this.trigger('onStackMod', existingModData, { engine, sourceCard: card, contextCard }, mod.stackingConfig.stackCount);
return;
}
card.mods.push(modData);
break;
}
}
engine.broadcast.push({
type: 'modAdded',
cardId: card.id,
modData,
});
this.trigger('onInitMod', modData, { engine, sourceCard: card, contextCard });
}
static areEqual(left: CardMod.ModData, right: CardMod.ModData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, modData: CardMod.ModData) {
const modCtor = engine.ruleset.cardMods?.[modData[0]];
if (!modCtor) throw new Error('mod not found: ' + modData.join());
const durationData = this.findDurationData(modData);
const mod = new modCtor(...modData.slice(durationData ? 3 : 2));
durationData && (mod.duration = durationData[1]);
const stackingData = modData[1];
mod.stackingConfig.behavior = stackingData[1];
switch (stackingData[1]) {
case CardMod.StackingBehavior.ranked:
(mod.stackingConfig as any).rank = stackingData[2];
break;
case CardMod.StackingBehavior.stack:
(mod.stackingConfig as any).stackCount = stackingData[2];
break;
}
return mod;
}
static findDurationData(modData: CardMod.ModData) {
const maybeDurationData = modData[2];
return (Array.isArray(maybeDurationData) && maybeDurationData[0] === '$duration') ? (modData[2] as CardMod.DurationData) : undefined;
}
static findModOfType(card: GameEngine.ICardState, modType: CardMod.ModConstructor) {
return card.mods.find(x => x[0] === modType.name);
}
static getStackCount(modData: CardMod.ModData) {
return modData[1][1] === CardMod.StackingBehavior.stack ? modData[1][2] : 0;
}
static makeDurationData(duration: number): CardMod.DurationData {
return ['$duration', duration];
}
static makeStackingData(
stackConfig: { behavior: CardMod.StackingBehavior.append }
| { behavior: CardMod.StackingBehavior.neverReplace }
| { behavior: CardMod.StackingBehavior.ranked, rank: number }
| { behavior: CardMod.StackingBehavior.replace }
| { behavior: CardMod.StackingBehavior.stack, stackCount: number }
) {
const stackingData = ['$stack', stackConfig.behavior];
(stackConfig.behavior === CardMod.StackingBehavior.ranked) && stackingData.push(stackConfig.rank);
(stackConfig.behavior === CardMod.StackingBehavior.stack) && stackingData.push(stackConfig.stackCount);
return stackingData as CardMod.StackingData;
}
static removeMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modData: CardMod.ModData, contextCard?: GameEngine.ICardState) {
engine.broadcast.push({
type: 'modRemoved',
cardId: card.id,
modData,
});
if (!card.mods.find(x => this.areEqual(x, modData))) {
throw new Error('mod not found');
}
this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });
card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));
}
static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {
const mod = card.mods.find(x => x[0] === modName);
mod && this.removeMod(engine, card, mod, contextCard);
}
static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {
const deps = args[0];
const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));
if (!modDataFromCard) {
throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);
}
const mod = this.deserialize(deps.engine, modDataFromCard);
const evnt = mod[ev];
const evntRetVal = evnt ? (evnt as any).apply(mod, args) : undefined;
if (deps.sourceCard.isRemoved) {
return;
}
if (ev === 'onTurnStart') {
const durationData = this.findDurationData(modDataFromCard);
if (durationData) {
if (durationData[1] > 1) {
durationData[1]--;
deps.engine.broadcast.push({
type: 'modDurationChanged',
cardId: deps.sourceCard.id,
modData: modData,
newDuration: durationData[1],
});
} else {
this.removeMod(deps.engine, deps.sourceCard, modData);
}
}
}
return evntRetVal as ReturnType<NonNullable<CardMod[T]>> | undefined;
}
}
export namespace CardMod {
export type ModData = [string, StackingData, ...unknown[],];
export type DurationData = ['$duration', number];
export type EnemyModData = unknown[];
export type ModConstructor = TypeConstructor<CardMod>;
export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;
export type ModLibrary = Record<string, ModConstructor>;
export type AppendStackingData = ['$stack', StackingBehavior.append];
export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];
export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];
export type ReplaceStackingData = ['$stack', StackingBehavior.replace];
export type StackStackingData = ['$stack', StackingBehavior.stack, number];
export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;
export enum StackingBehavior {
append,
neverReplace,
ranked,
replace,
stack,
}
export interface ICardModDeps {
engine: GameEngine.IGameEngine;
sourceCard: GameEngine.ICardState;
contextCard?: GameEngine.ICardState;
}
export namespace Content {
// Defines a card modifier - the class name is treated as the mod name
export class backdoor extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(public damage: number) {
// Any extra data to serialize into this.modData as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display modifier effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI modifiers,
// see _standardAi below for example
super(arguments);
this.stackingConfig.rank = damage;
}
}
export class diagnostics extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public secBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = secBonus;
}
override onTurnEnd(deps: ICardModDeps): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
}
export class firewall extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(override duration: number) {
super(arguments);
this.stackingConfig.rank = duration;
}
override onInitMod(deps: ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
return;
}
GameEngineUtils.revalidateIntents(deps.engine, true);
}
}
export class impervious extends CardMod {
constructor(override duration = -1) {
super(arguments);
}
override onSecDamageIn(_deps: ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return {
secDmgBonus: -9999,
};
}
}
export class lag extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
|
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
|
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class offline extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
}
GameEngineUtils.revalidateIntents(deps.engine, GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard));
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class secured extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public tempSecBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = tempSecBonus;
}
override onInitMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
override onStackMod(deps: ICardModDeps, stackDelta: number): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, stackDelta, false);
}
override onRemoveMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -this.stackingConfig.stackCount, true);
}
}
export class _waveBonus_extraMove extends CardMod {
override onInitMod(deps: ICardModDeps): void {
const player = GameEngineUtils.findPlayerByCardId(deps.engine.gameData, deps.sourceCard.id);
player.movesPerTurn++;
player.movesLeft = player.movesPerTurn;
deps.engine.broadcast.push({
type: 'movesPerTurnsChange',
playerId: player.id,
newMovesLeft: player.movesLeft,
newMovesPerTurn: player.movesPerTurn,
});
}
}
export class _winOnDeath extends CardMod {
override onCardDestroyed(deps: ICardModDeps) {
const player = deps.contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null;
player && player.stats.kills++;
deps.engine.onWinGame();
player && player.stats.kills--;
}
}
export class _standardAi extends CardMod {
override onTurnStart(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
}
override onTurnEnd(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.executeIntent(deps.engine, deps.sourceCard);
}
}
export class _yieldScript extends CardMod {
constructor(
public scriptData: CardScript.ScriptData,
override duration: number,
) {
super(arguments);
}
override onRemoveMod(deps: ICardModDeps) {
CardScript.addScript(deps.engine, deps.sourceCard, this.scriptData);
}
}
export class _waveTrigger extends CardMod {
constructor(
public rulesetIds: string[],
override duration = -1,
) {
super(arguments);
}
override onInitMod(deps: ICardModDeps): void {
deps.engine.gameData.difficulty < 3 && GameEngineUtils.changeSec(deps.engine, deps.sourceCard, 25, true);
}
override onCardDestroyed(deps: ICardModDeps) {
deps.engine.onNextWave(this.rulesetIds.random());
deps.contextCard && CardMod.addMod(deps.engine, deps.contextCard, new _waveBonus_extraMove());
}
override onRemoveMod(deps: ICardModDeps): void {
CardMod.addMod(deps.engine, deps.sourceCard, new _winOnDeath());
}
}
}
}
|
src/game/card-mods.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {\n CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);\n if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {\n GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n }\n }\n },\n },",
"score": 0.877325177192688
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " goliath_boss_ai: class extends CardMod {\n override onTurnStart(deps: CardMod.ICardModDeps) {\n GameEngineUtils.generateIntent(deps.engine, deps.sourceCard as GameEngine.IEnemyCardState);\n }\n override onTurnEnd(deps: CardMod.ICardModDeps) {\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n const targetId = boss.intent?.targetCardId;\n if (!targetId) return;\n let numAttacks = 1;\n const powerBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_power);",
"score": 0.8635618686676025
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " constructor(_card: GameEngine.ICardState) {\n const lagDuration = 1;\n super(\n [lagDuration],\n CardScript.TargetFinders.Any(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(",
"score": 0.8570729494094849
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);\n CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_power(), deps.sourceCard);\n }\n },\n goliath_shield_supply: class extends CardMod {\n override onCardDestroyed(deps: CardMod.ICardModDeps) {\n const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);\n CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_shield(), deps.sourceCard);\n }\n },",
"score": 0.8483371138572693
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " };\n constructor(cpuBonus: number, override duration: number) {\n super(arguments);\n this.stackingConfig.stackCount = cpuBonus;\n }\n override onInitMod(deps: CardMod.ICardModDeps) {\n GameEngineUtils.changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);\n }\n override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {\n deps.sourceCard.cpu += stackDelta;",
"score": 0.8481179475784302
}
] |
typescript
|
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
|
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export namespace CardScriptParts {
export interface IScriptPart {
(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): void;
}
export const _Chance = (chance: number, curriedPart: IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (Math.random() < chance) {
curriedPart(engine, sourceCard, targetCard);
}
};
export const _TargetHasMod = <T extends CardMod.ModLibrary, K extends keyof T>(modName: K, curry: (mod: InstanceType<T[K]>) => IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
const mod = targetCard.mods.find(x => x[0] === modName);
if (mod) {
curry(CardMod.deserialize(engine, mod) as InstanceType<T[K]>)(engine, sourceCard, targetCard);
}
};
export const AddMod = (mod: CardMod): IScriptPart =>
(engine, sourceCard, targetCard) => {
CardMod.addMod(engine, targetCard, mod, sourceCard);
};
export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;
if (secExceeded) {
MemDmg(1)(engine, sourceCard, targetCard);
}
};
export const SecDmg = (secDmg: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
let resolvedDamage = secDmg;
if (!dontTriggerOut) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageOut', { engine, sourceCard, contextCard: targetCard }, resolvedDamage)
.reduce(
|
(sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
|
}
if (!dontTriggerIn) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return false;
}
resolvedDamage = Math.max(0, resolvedDamage);
const secExceeded = resolvedDamage > targetCard.sec;
GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);
return secExceeded;
};
export const MemDmg = (memDmg: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.triggerMods('onMemDmgOut', { engine, sourceCard, contextCard: targetCard }, memDmg);
GameEngineUtils.triggerMods('onMemDmgIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, memDmg);
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return;
}
targetCard.mem -= memDmg;
engine.broadcast.push({
type: 'memDamage',
cardId: targetCard.id,
newMem: targetCard.mem,
value: -memDmg,
});
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, sourceCard.id);
player && (player.stats.memDmg += memDmg);
if (targetCard.mem <= 0) {
GameEngineUtils.removeCard(engine, targetCard, sourceCard);
}
};
export const ChangeCpu = (cpuDelta: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
};
export const RaiseMem = (memBonus: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
targetCard.mem += memBonus;
engine.broadcast.push({
type: 'memBonus',
cardId: targetCard.id,
newMem: targetCard.mem,
value: memBonus,
});
};
export const RaiseSec = (secBonus: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.changeSec(engine, targetCard, secBonus, false, sourceCard);
};
export const RedirectIntentRandom: IScriptPart =
(engine, _sourceCard, targetCard) => {
if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;
const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);
if (script.targetFinder === CardScript.TargetFinders.Self) return;
const targets = script.targetFinder(engine.gameData, targetCard);
if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;
const origTargetId = targetCard.intent.targetCardId;
while (targetCard.intent.targetCardId === origTargetId) {
targetCard.intent.targetCardId = targets.random().id;
}
engine.broadcast.push({
type: 'cardIntent',
cardId: targetCard.id,
intent: targetCard.intent,
});
};
export const RemoveMod = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modName: K, mustRemove = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (mustRemove) {
if (!targetCard.mods.find(x => x[0] === modName)) {
throw new Error(`Could not find [${modName}] to remove`);
}
}
CardMod.removeModByName(engine, targetCard, modName, sourceCard);
};
export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>
(engine, sourceCard, _targetCard) => {
let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);
switch (spawnPosition) {
case 'absLeft': spawnIndex = 0; break;
case 'absRight': spawnIndex = engine.gameData.enemies.length; break;
case 'relRight': spawnIndex++; break;
}
GameEngineUtils.spawnEnemy(engine, enemyClass, spawnIndex, generateIntent);
};
}
|
src/game/card-script-parts.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n CardScriptParts.SecDmg(secDelta),\n CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),\n CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),\n ],\n },\n {\n targetResolver: CardScript.TargetResolvers.Self,\n parts: [\n CardScriptParts.RaiseSec(secDelta),",
"score": 0.8814727663993835
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (deps.sourceCard.mem - memDmg <= 0) return;\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n let secBonus = 100;\n const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);\n if (shieldBuff) {\n secBonus += CardMod.getStackCount(shieldBuff) * 100;\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);\n for (const enemy of [...deps.engine.gameData.enemies]) {\n if (enemy === boss) continue;",
"score": 0.8804346323013306
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " }\n override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {\n CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);\n }\n },\n // Increases CPU\n optimized: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,",
"score": 0.8765038847923279
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " super(\n [secDelta],\n CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.SecDmg(secDelta),\n ],\n },",
"score": 0.8735756278038025
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " export function changeSec(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, secDelta: number, isPassive: boolean, contextCard?: GameEngine.ICardState) {\n const clampedSecDelta = (card.sec < -secDelta) ? -card.sec : secDelta;\n card.sec += clampedSecDelta;\n engine.broadcast.push({\n type: isPassive ? 'secChange' : (secDelta < 0 ? 'secDamage' : 'secBonus'),\n cardId: card.id,\n newSec: card.sec,\n value: secDelta,\n });\n if (!isPassive && contextCard) {",
"score": 0.8667367696762085
}
] |
typescript
|
(sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
|
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export abstract class CardMod {
duration = -1;
stackingConfig: Parameters<typeof CardMod['makeStackingData']>[0] = { behavior: CardMod.StackingBehavior.neverReplace };
readonly modName: string;
constructor(
private _extraModData?: IArguments,
) {
this.modName = this.constructor.name;
}
onSecDamageIn?(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState): { secDmgBonus: number } | void;
onSecDamageOut?(deps: CardMod.ICardModDeps, baseDmg: number): { secDmgBonus: number } | void;
onMemDmgIn?(deps: CardMod.ICardModDeps, memDmg: number): void;
onMemDmgOut?(deps: CardMod.ICardModDeps, memDmg: number): void;
onInitMod?(deps: CardMod.ICardModDeps): void;
onRemoveMod?(deps: CardMod.ICardModDeps): void;
onCardDestroyed?(deps: CardMod.ICardModDeps): void;
onStackMod?(deps: CardMod.ICardModDeps, stackDelta: number): void;
onTurnStart?(deps: CardMod.ICardModDeps): void;
onTurnEnd?(deps: CardMod.ICardModDeps): void;
onEnemyDestroyed?(deps: CardMod.ICardModDeps): void;
serialize() {
const stackingData = CardMod.makeStackingData(this.stackingConfig);
const modData = [this.modName, stackingData] as CardMod.ModData;
(this.duration >= 0) && (modData.push(CardMod.makeDurationData(this.duration)));
this._extraModData && modData.push(...this._extraModData);
return modData;
}
static addMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, mod: CardMod, contextCard?: GameEngine.ICardState) {
const modData = mod.serialize();
switch (mod.stackingConfig.behavior) {
case CardMod.StackingBehavior.append: {
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.neverReplace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) return;
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.ranked: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
if (existingStackingData[2] >= mod.stackingConfig.rank) {
return;
}
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.replace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.stack: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
existingStackingData && (existingStackingData[2] += mod.stackingConfig.stackCount);
engine.broadcast.push({
type: 'modStackChanged',
cardId: card.id,
modData: existingModData,
stackDelta: mod.stackingConfig.stackCount,
newStackCount: existingStackingData[2],
});
this.trigger('onStackMod', existingModData, { engine, sourceCard: card, contextCard }, mod.stackingConfig.stackCount);
return;
}
card.mods.push(modData);
break;
}
}
engine.broadcast.push({
type: 'modAdded',
cardId: card.id,
modData,
});
this.trigger('onInitMod', modData, { engine, sourceCard: card, contextCard });
}
static areEqual(left: CardMod.ModData, right: CardMod.ModData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, modData: CardMod.ModData) {
const modCtor = engine.ruleset.cardMods?.[modData[0]];
if (!modCtor) throw new Error('mod not found: ' + modData.join());
const durationData = this.findDurationData(modData);
const mod = new modCtor(...modData.slice(durationData ? 3 : 2));
durationData && (mod.duration = durationData[1]);
const stackingData = modData[1];
mod.stackingConfig.behavior = stackingData[1];
switch (stackingData[1]) {
case CardMod.StackingBehavior.ranked:
(mod.stackingConfig as any).rank = stackingData[2];
break;
case CardMod.StackingBehavior.stack:
(mod.stackingConfig as any).stackCount = stackingData[2];
break;
}
return mod;
}
static findDurationData(modData: CardMod.ModData) {
const maybeDurationData = modData[2];
return (Array.isArray(maybeDurationData) && maybeDurationData[0] === '$duration') ? (modData[2] as CardMod.DurationData) : undefined;
}
static findModOfType(card: GameEngine.ICardState, modType: CardMod.ModConstructor) {
return card.mods.find(x => x[0] === modType.name);
}
static getStackCount(modData: CardMod.ModData) {
return modData[1][1] === CardMod.StackingBehavior.stack ? modData[1][2] : 0;
}
static makeDurationData(duration: number): CardMod.DurationData {
return ['$duration', duration];
}
static makeStackingData(
stackConfig: { behavior: CardMod.StackingBehavior.append }
| { behavior: CardMod.StackingBehavior.neverReplace }
| { behavior: CardMod.StackingBehavior.ranked, rank: number }
| { behavior: CardMod.StackingBehavior.replace }
| { behavior: CardMod.StackingBehavior.stack, stackCount: number }
) {
const stackingData = ['$stack', stackConfig.behavior];
(stackConfig.behavior === CardMod.StackingBehavior.ranked) && stackingData.push(stackConfig.rank);
(stackConfig.behavior === CardMod.StackingBehavior.stack) && stackingData.push(stackConfig.stackCount);
return stackingData as CardMod.StackingData;
}
static removeMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modData: CardMod.ModData, contextCard?: GameEngine.ICardState) {
engine.broadcast.push({
type: 'modRemoved',
cardId: card.id,
modData,
});
if (!card.mods.find(x => this.areEqual(x, modData))) {
throw new Error('mod not found');
}
this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });
card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));
}
static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {
const mod = card.mods.find(x => x[0] === modName);
mod && this.removeMod(engine, card, mod, contextCard);
}
static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {
const deps = args[0];
const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));
if (!modDataFromCard) {
throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);
}
const mod = this.deserialize(deps.engine, modDataFromCard);
const evnt = mod[ev];
const evntRetVal = evnt ? (evnt as any).apply(mod, args) : undefined;
if (deps.sourceCard.isRemoved) {
return;
}
if (ev === 'onTurnStart') {
const durationData = this.findDurationData(modDataFromCard);
if (durationData) {
if (durationData[1] > 1) {
durationData[1]--;
deps.engine.broadcast.push({
type: 'modDurationChanged',
cardId: deps.sourceCard.id,
modData: modData,
newDuration: durationData[1],
});
} else {
this.removeMod(deps.engine, deps.sourceCard, modData);
}
}
}
return evntRetVal as ReturnType<NonNullable<CardMod[T]>> | undefined;
}
}
export namespace CardMod {
export type ModData = [string, StackingData, ...unknown[],];
export type DurationData = ['$duration', number];
export type EnemyModData = unknown[];
export type ModConstructor = TypeConstructor<CardMod>;
export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;
export type ModLibrary = Record<string, ModConstructor>;
export type AppendStackingData = ['$stack', StackingBehavior.append];
export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];
export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];
export type ReplaceStackingData = ['$stack', StackingBehavior.replace];
export type StackStackingData = ['$stack', StackingBehavior.stack, number];
export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;
export enum StackingBehavior {
append,
neverReplace,
ranked,
replace,
stack,
}
export interface ICardModDeps {
engine: GameEngine.IGameEngine;
sourceCard: GameEngine.ICardState;
contextCard?: GameEngine.ICardState;
}
export namespace Content {
// Defines a card modifier - the class name is treated as the mod name
export class backdoor extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(public damage: number) {
// Any extra data to serialize into this.modData as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display modifier effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI modifiers,
// see _standardAi below for example
super(arguments);
this.stackingConfig.rank = damage;
}
}
export class diagnostics extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public secBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = secBonus;
}
override onTurnEnd(deps: ICardModDeps): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
}
export class firewall extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(override duration: number) {
super(arguments);
this.stackingConfig.rank = duration;
}
override onInitMod(deps: ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
return;
}
GameEngineUtils.revalidateIntents(deps.engine, true);
}
}
export class impervious extends CardMod {
constructor(override duration = -1) {
super(arguments);
}
override onSecDamageIn(_deps: ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return {
secDmgBonus: -9999,
};
}
}
export class lag extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class offline extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
}
GameEngineUtils.revalidateIntents(deps.engine, GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard));
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class secured extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public tempSecBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = tempSecBonus;
}
override onInitMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
override onStackMod(deps: ICardModDeps, stackDelta: number): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, stackDelta, false);
}
override onRemoveMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -this.stackingConfig.stackCount, true);
}
}
export class _waveBonus_extraMove extends CardMod {
override onInitMod(deps: ICardModDeps): void {
const player = GameEngineUtils.findPlayerByCardId(deps.engine.gameData, deps.sourceCard.id);
player.movesPerTurn++;
player.movesLeft = player.movesPerTurn;
deps.engine.broadcast.push({
type: 'movesPerTurnsChange',
playerId: player.id,
newMovesLeft: player.movesLeft,
newMovesPerTurn: player.movesPerTurn,
});
}
}
export class _winOnDeath extends CardMod {
override onCardDestroyed(deps: ICardModDeps) {
const player = deps.contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null;
player && player.stats.kills++;
deps.engine.onWinGame();
player && player.stats.kills--;
}
}
export class _standardAi extends CardMod {
override onTurnStart(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
}
override onTurnEnd(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.
|
executeIntent(deps.engine, deps.sourceCard);
|
}
}
export class _yieldScript extends CardMod {
constructor(
public scriptData: CardScript.ScriptData,
override duration: number,
) {
super(arguments);
}
override onRemoveMod(deps: ICardModDeps) {
CardScript.addScript(deps.engine, deps.sourceCard, this.scriptData);
}
}
export class _waveTrigger extends CardMod {
constructor(
public rulesetIds: string[],
override duration = -1,
) {
super(arguments);
}
override onInitMod(deps: ICardModDeps): void {
deps.engine.gameData.difficulty < 3 && GameEngineUtils.changeSec(deps.engine, deps.sourceCard, 25, true);
}
override onCardDestroyed(deps: ICardModDeps) {
deps.engine.onNextWave(this.rulesetIds.random());
deps.contextCard && CardMod.addMod(deps.engine, deps.contextCard, new _waveBonus_extraMove());
}
override onRemoveMod(deps: ICardModDeps): void {
CardMod.addMod(deps.engine, deps.sourceCard, new _winOnDeath());
}
}
}
}
|
src/game/card-mods.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " goliath_boss_ai: class extends CardMod {\n override onTurnStart(deps: CardMod.ICardModDeps) {\n GameEngineUtils.generateIntent(deps.engine, deps.sourceCard as GameEngine.IEnemyCardState);\n }\n override onTurnEnd(deps: CardMod.ICardModDeps) {\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n const targetId = boss.intent?.targetCardId;\n if (!targetId) return;\n let numAttacks = 1;\n const powerBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_power);",
"score": 0.8806421160697937
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " (engine, _sourceCard, targetCard) => {\n if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;\n const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);\n if (script.targetFinder === CardScript.TargetFinders.Self) return;\n const targets = script.targetFinder(engine.gameData, targetCard);\n if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;\n const origTargetId = targetCard.intent.targetCardId;\n while (targetCard.intent.targetCardId === origTargetId) {\n targetCard.intent.targetCardId = targets.random().id;\n }",
"score": 0.8747221827507019
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (deps.sourceCard.mem - memDmg <= 0) return;\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n let secBonus = 100;\n const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);\n if (shieldBuff) {\n secBonus += CardMod.getStackCount(shieldBuff) * 100;\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);\n for (const enemy of [...deps.engine.gameData.enemies]) {\n if (enemy === boss) continue;",
"score": 0.8698173761367798
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " type: 'cardAdded',\n enemy,\n position: spawnIndex,\n });\n GameEngineUtils.triggerMods('onInitMod', { engine, sourceCard: enemy });\n if (generateIntent) {\n GameEngineUtils.generateIntent(engine, enemy);\n }\n return enemy;\n }",
"score": 0.8683335781097412
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " })));\n if (isEnemyCard(engine.gameData, card) && card.intent?.scriptData) {\n card.intent.scriptData = CardScript.deserialize(engine, card, card.intent.scriptData).serialize();\n engine.broadcast.push({\n type: 'cardIntent',\n cardId: card.id,\n intent: card.intent,\n });\n }\n }",
"score": 0.8633277416229248
}
] |
typescript
|
executeIntent(deps.engine, deps.sourceCard);
|
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export namespace CardScriptParts {
export interface IScriptPart {
(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): void;
}
export const _Chance = (chance: number, curriedPart: IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (Math.random() < chance) {
curriedPart(engine, sourceCard, targetCard);
}
};
export const _TargetHasMod = <T extends CardMod.ModLibrary, K extends keyof T>(modName: K, curry: (mod: InstanceType<T[K]>) => IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
const mod = targetCard.mods.find(x => x[0] === modName);
if (mod) {
curry(CardMod.deserialize(engine, mod) as InstanceType<T[K]>)(engine, sourceCard, targetCard);
}
};
export const AddMod = (mod: CardMod): IScriptPart =>
(engine, sourceCard, targetCard) => {
CardMod.addMod(engine, targetCard, mod, sourceCard);
};
export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;
if (secExceeded) {
MemDmg(1)(engine, sourceCard, targetCard);
}
};
export const SecDmg = (secDmg: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
let resolvedDamage = secDmg;
if (!dontTriggerOut) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageOut', { engine, sourceCard, contextCard: targetCard }, resolvedDamage)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (!dontTriggerIn) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return false;
}
resolvedDamage = Math.max(0, resolvedDamage);
const secExceeded = resolvedDamage > targetCard.sec;
GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);
return secExceeded;
};
export const MemDmg = (memDmg: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.triggerMods('onMemDmgOut', { engine, sourceCard, contextCard: targetCard }, memDmg);
GameEngineUtils.triggerMods('onMemDmgIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, memDmg);
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return;
}
targetCard.mem -= memDmg;
engine.broadcast.push({
type: 'memDamage',
cardId: targetCard.id,
newMem: targetCard.mem,
value: -memDmg,
});
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, sourceCard.id);
player && (player.stats.memDmg += memDmg);
if (targetCard.mem <= 0) {
|
GameEngineUtils.removeCard(engine, targetCard, sourceCard);
|
}
};
export const ChangeCpu = (cpuDelta: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
};
export const RaiseMem = (memBonus: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
targetCard.mem += memBonus;
engine.broadcast.push({
type: 'memBonus',
cardId: targetCard.id,
newMem: targetCard.mem,
value: memBonus,
});
};
export const RaiseSec = (secBonus: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.changeSec(engine, targetCard, secBonus, false, sourceCard);
};
export const RedirectIntentRandom: IScriptPart =
(engine, _sourceCard, targetCard) => {
if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;
const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);
if (script.targetFinder === CardScript.TargetFinders.Self) return;
const targets = script.targetFinder(engine.gameData, targetCard);
if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;
const origTargetId = targetCard.intent.targetCardId;
while (targetCard.intent.targetCardId === origTargetId) {
targetCard.intent.targetCardId = targets.random().id;
}
engine.broadcast.push({
type: 'cardIntent',
cardId: targetCard.id,
intent: targetCard.intent,
});
};
export const RemoveMod = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modName: K, mustRemove = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (mustRemove) {
if (!targetCard.mods.find(x => x[0] === modName)) {
throw new Error(`Could not find [${modName}] to remove`);
}
}
CardMod.removeModByName(engine, targetCard, modName, sourceCard);
};
export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>
(engine, sourceCard, _targetCard) => {
let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);
switch (spawnPosition) {
case 'absLeft': spawnIndex = 0; break;
case 'absRight': spawnIndex = engine.gameData.enemies.length; break;
case 'relRight': spawnIndex++; break;
}
GameEngineUtils.spawnEnemy(engine, enemyClass, spawnIndex, generateIntent);
};
}
|
src/game/card-script-parts.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (deps.sourceCard.mem - memDmg <= 0) return;\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n let secBonus = 100;\n const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);\n if (shieldBuff) {\n secBonus += CardMod.getStackCount(shieldBuff) * 100;\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);\n for (const enemy of [...deps.engine.gameData.enemies]) {\n if (enemy === boss) continue;",
"score": 0.8941629528999329
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " export function changeMem(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, memDelta: number) {\n card.mem += memDelta;\n engine.broadcast.push({\n type: 'memChanged',\n cardId: card.id,\n newMem: card.mem,\n memDelta,\n });\n GameEngineUtils.recalculateScripts(engine, card);\n }",
"score": 0.8917652368545532
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n (engine, _sourceCard, targetCard) => {\n const totalStats = targetCard.cpu + targetCard.mem;\n const newCpu = randInt(1, totalStats - 1);\n const cpuDelta = newCpu - targetCard.cpu;\n GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);\n const newMem = totalStats - newCpu;\n const memDelta = newMem - targetCard.mem;\n GameEngineUtils.changeMem(engine, targetCard, memDelta);\n },",
"score": 0.8854389190673828
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " triggerMods('onEnemyDestroyed', { engine, sourceCard: card, contextCard });\n }\n if (contextCard) {\n const player = findPlayerByCardIdMaybe(engine.gameData, contextCard.id);\n player && player.stats.kills++;\n }\n GameEngineUtils.revalidateIntents(engine, true);\n } else {\n const player = GameEngineUtils.findPlayerByCardId(engine.gameData, card.id);\n player.cards.removeFirst(card);",
"score": 0.8808257579803467
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " deps.engine.broadcast.push({\n type: 'cpuChanged',\n cardId: deps.sourceCard.id,\n newCpu: deps.sourceCard.cpu,\n });\n GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);\n }\n override onRemoveMod(deps: CardMod.ICardModDeps) {\n deps.sourceCard.cpu -= this.stackingConfig.stackCount;\n deps.engine.broadcast.push({",
"score": 0.8697469234466553
}
] |
typescript
|
GameEngineUtils.removeCard(engine, targetCard, sourceCard);
|
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export namespace CardScriptParts {
export interface IScriptPart {
(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): void;
}
export const _Chance = (chance: number, curriedPart: IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (Math.random() < chance) {
curriedPart(engine, sourceCard, targetCard);
}
};
export const _TargetHasMod = <T extends CardMod.ModLibrary, K extends keyof T>(modName: K, curry: (mod: InstanceType<T[K]>) => IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
const mod = targetCard.mods.find(x => x[0] === modName);
if (mod) {
curry(CardMod.deserialize(engine, mod) as InstanceType<T[K]>)(engine, sourceCard, targetCard);
}
};
export const AddMod = (mod: CardMod): IScriptPart =>
(engine, sourceCard, targetCard) => {
CardMod.addMod(engine, targetCard, mod, sourceCard);
};
export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;
if (secExceeded) {
MemDmg(1)(engine, sourceCard, targetCard);
}
};
export const SecDmg = (secDmg: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
let resolvedDamage = secDmg;
if (!dontTriggerOut) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageOut', { engine, sourceCard, contextCard: targetCard }, resolvedDamage)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (!dontTriggerIn) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
|
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
|
return false;
}
resolvedDamage = Math.max(0, resolvedDamage);
const secExceeded = resolvedDamage > targetCard.sec;
GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);
return secExceeded;
};
export const MemDmg = (memDmg: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.triggerMods('onMemDmgOut', { engine, sourceCard, contextCard: targetCard }, memDmg);
GameEngineUtils.triggerMods('onMemDmgIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, memDmg);
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return;
}
targetCard.mem -= memDmg;
engine.broadcast.push({
type: 'memDamage',
cardId: targetCard.id,
newMem: targetCard.mem,
value: -memDmg,
});
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, sourceCard.id);
player && (player.stats.memDmg += memDmg);
if (targetCard.mem <= 0) {
GameEngineUtils.removeCard(engine, targetCard, sourceCard);
}
};
export const ChangeCpu = (cpuDelta: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
};
export const RaiseMem = (memBonus: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
targetCard.mem += memBonus;
engine.broadcast.push({
type: 'memBonus',
cardId: targetCard.id,
newMem: targetCard.mem,
value: memBonus,
});
};
export const RaiseSec = (secBonus: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.changeSec(engine, targetCard, secBonus, false, sourceCard);
};
export const RedirectIntentRandom: IScriptPart =
(engine, _sourceCard, targetCard) => {
if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;
const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);
if (script.targetFinder === CardScript.TargetFinders.Self) return;
const targets = script.targetFinder(engine.gameData, targetCard);
if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;
const origTargetId = targetCard.intent.targetCardId;
while (targetCard.intent.targetCardId === origTargetId) {
targetCard.intent.targetCardId = targets.random().id;
}
engine.broadcast.push({
type: 'cardIntent',
cardId: targetCard.id,
intent: targetCard.intent,
});
};
export const RemoveMod = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modName: K, mustRemove = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (mustRemove) {
if (!targetCard.mods.find(x => x[0] === modName)) {
throw new Error(`Could not find [${modName}] to remove`);
}
}
CardMod.removeModByName(engine, targetCard, modName, sourceCard);
};
export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>
(engine, sourceCard, _targetCard) => {
let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);
switch (spawnPosition) {
case 'absLeft': spawnIndex = 0; break;
case 'absRight': spawnIndex = engine.gameData.enemies.length; break;
case 'relRight': spawnIndex++; break;
}
GameEngineUtils.spawnEnemy(engine, enemyClass, spawnIndex, generateIntent);
};
}
|
src/game/card-script-parts.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (deps.sourceCard.mem - memDmg <= 0) return;\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n let secBonus = 100;\n const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);\n if (shieldBuff) {\n secBonus += CardMod.getStackCount(shieldBuff) * 100;\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);\n for (const enemy of [...deps.engine.gameData.enemies]) {\n if (enemy === boss) continue;",
"score": 0.8643627762794495
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " },\n reaper_feederPower: class extends CardMod {\n override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {\n if (deps.sourceCard.sec - damage > 0) return;\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);\n CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);\n CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);\n CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);\n const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);\n player && player.stats.kills++;",
"score": 0.8591346740722656
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " }\n override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {\n CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);\n }\n },\n // Increases CPU\n optimized: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,",
"score": 0.8591265082359314
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " export function changeSec(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, secDelta: number, isPassive: boolean, contextCard?: GameEngine.ICardState) {\n const clampedSecDelta = (card.sec < -secDelta) ? -card.sec : secDelta;\n card.sec += clampedSecDelta;\n engine.broadcast.push({\n type: isPassive ? 'secChange' : (secDelta < 0 ? 'secDamage' : 'secBonus'),\n cardId: card.id,\n newSec: card.sec,\n value: secDelta,\n });\n if (!isPassive && contextCard) {",
"score": 0.8552448749542236
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n CardScriptParts.SecDmg(secDelta),\n CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),\n CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),\n ],\n },\n {\n targetResolver: CardScript.TargetResolvers.Self,\n parts: [\n CardScriptParts.RaiseSec(secDelta),",
"score": 0.8516676425933838
}
] |
typescript
|
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
|
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export abstract class CardMod {
duration = -1;
stackingConfig: Parameters<typeof CardMod['makeStackingData']>[0] = { behavior: CardMod.StackingBehavior.neverReplace };
readonly modName: string;
constructor(
private _extraModData?: IArguments,
) {
this.modName = this.constructor.name;
}
onSecDamageIn?(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState): { secDmgBonus: number } | void;
onSecDamageOut?(deps: CardMod.ICardModDeps, baseDmg: number): { secDmgBonus: number } | void;
onMemDmgIn?(deps: CardMod.ICardModDeps, memDmg: number): void;
onMemDmgOut?(deps: CardMod.ICardModDeps, memDmg: number): void;
onInitMod?(deps: CardMod.ICardModDeps): void;
onRemoveMod?(deps: CardMod.ICardModDeps): void;
onCardDestroyed?(deps: CardMod.ICardModDeps): void;
onStackMod?(deps: CardMod.ICardModDeps, stackDelta: number): void;
onTurnStart?(deps: CardMod.ICardModDeps): void;
onTurnEnd?(deps: CardMod.ICardModDeps): void;
onEnemyDestroyed?(deps: CardMod.ICardModDeps): void;
serialize() {
const stackingData = CardMod.makeStackingData(this.stackingConfig);
const modData = [this.modName, stackingData] as CardMod.ModData;
(this.duration >= 0) && (modData.push(CardMod.makeDurationData(this.duration)));
this._extraModData && modData.push(...this._extraModData);
return modData;
}
static addMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, mod: CardMod, contextCard?: GameEngine.ICardState) {
const modData = mod.serialize();
switch (mod.stackingConfig.behavior) {
case CardMod.StackingBehavior.append: {
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.neverReplace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) return;
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.ranked: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
if (existingStackingData[2] >= mod.stackingConfig.rank) {
return;
}
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.replace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.stack: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
existingStackingData && (existingStackingData[2] += mod.stackingConfig.stackCount);
engine.broadcast.push({
type: 'modStackChanged',
cardId: card.id,
modData: existingModData,
stackDelta: mod.stackingConfig.stackCount,
newStackCount: existingStackingData[2],
});
this.trigger('onStackMod', existingModData, { engine, sourceCard: card, contextCard }, mod.stackingConfig.stackCount);
return;
}
card.mods.push(modData);
break;
}
}
engine.broadcast.push({
type: 'modAdded',
cardId: card.id,
modData,
});
this.trigger('onInitMod', modData, { engine, sourceCard: card, contextCard });
}
static areEqual(left: CardMod.ModData, right: CardMod.ModData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, modData: CardMod.ModData) {
const modCtor = engine.ruleset.cardMods?.[modData[0]];
if (!modCtor) throw new Error('mod not found: ' + modData.join());
const durationData = this.findDurationData(modData);
const mod = new modCtor(...modData.slice(durationData ? 3 : 2));
durationData && (mod.duration = durationData[1]);
const stackingData = modData[1];
mod.stackingConfig.behavior = stackingData[1];
switch (stackingData[1]) {
case CardMod.StackingBehavior.ranked:
(mod.stackingConfig as any).rank = stackingData[2];
break;
case CardMod.StackingBehavior.stack:
(mod.stackingConfig as any).stackCount = stackingData[2];
break;
}
return mod;
}
static findDurationData(modData: CardMod.ModData) {
const maybeDurationData = modData[2];
return (Array.isArray(maybeDurationData) && maybeDurationData[0] === '$duration') ? (modData[2] as CardMod.DurationData) : undefined;
}
static findModOfType(card: GameEngine.ICardState, modType: CardMod.ModConstructor) {
return card.mods.find(x => x[0] === modType.name);
}
static getStackCount(modData: CardMod.ModData) {
return modData[1][1] === CardMod.StackingBehavior.stack ? modData[1][2] : 0;
}
static makeDurationData(duration: number): CardMod.DurationData {
return ['$duration', duration];
}
static makeStackingData(
stackConfig: { behavior: CardMod.StackingBehavior.append }
| { behavior: CardMod.StackingBehavior.neverReplace }
| { behavior: CardMod.StackingBehavior.ranked, rank: number }
| { behavior: CardMod.StackingBehavior.replace }
| { behavior: CardMod.StackingBehavior.stack, stackCount: number }
) {
const stackingData = ['$stack', stackConfig.behavior];
(stackConfig.behavior === CardMod.StackingBehavior.ranked) && stackingData.push(stackConfig.rank);
(stackConfig.behavior === CardMod.StackingBehavior.stack) && stackingData.push(stackConfig.stackCount);
return stackingData as CardMod.StackingData;
}
static removeMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modData: CardMod.ModData, contextCard?: GameEngine.ICardState) {
engine.broadcast.push({
type: 'modRemoved',
cardId: card.id,
modData,
});
if (!card.mods.find(x => this.areEqual(x, modData))) {
throw new Error('mod not found');
}
this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });
card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));
}
static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {
const mod = card.mods.find(x => x[0] === modName);
mod && this.removeMod(engine, card, mod, contextCard);
}
static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {
const deps = args[0];
const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));
if (!modDataFromCard) {
throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);
}
const mod = this.deserialize(deps.engine, modDataFromCard);
const evnt = mod[ev];
const evntRetVal = evnt ? (evnt as any).apply(mod, args) : undefined;
if (deps.sourceCard.isRemoved) {
return;
}
if (ev === 'onTurnStart') {
const durationData = this.findDurationData(modDataFromCard);
if (durationData) {
if (durationData[1] > 1) {
durationData[1]--;
deps.engine.broadcast.push({
type: 'modDurationChanged',
cardId: deps.sourceCard.id,
modData: modData,
newDuration: durationData[1],
});
} else {
this.removeMod(deps.engine, deps.sourceCard, modData);
}
}
}
return evntRetVal as ReturnType<NonNullable<CardMod[T]>> | undefined;
}
}
export namespace CardMod {
export type ModData = [string, StackingData, ...unknown[],];
export type DurationData = ['$duration', number];
export type EnemyModData = unknown[];
export type ModConstructor = TypeConstructor<CardMod>;
export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;
export type ModLibrary = Record<string, ModConstructor>;
export type AppendStackingData = ['$stack', StackingBehavior.append];
export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];
export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];
export type ReplaceStackingData = ['$stack', StackingBehavior.replace];
export type StackStackingData = ['$stack', StackingBehavior.stack, number];
export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;
export enum StackingBehavior {
append,
neverReplace,
ranked,
replace,
stack,
}
export interface ICardModDeps {
engine: GameEngine.IGameEngine;
sourceCard: GameEngine.ICardState;
contextCard?: GameEngine.ICardState;
}
export namespace Content {
// Defines a card modifier - the class name is treated as the mod name
export class backdoor extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(public damage: number) {
// Any extra data to serialize into this.modData as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display modifier effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI modifiers,
// see _standardAi below for example
super(arguments);
this.stackingConfig.rank = damage;
}
}
export class diagnostics extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public secBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = secBonus;
}
override onTurnEnd(deps: ICardModDeps): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
}
export class firewall extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(override duration: number) {
super(arguments);
this.stackingConfig.rank = duration;
}
override onInitMod(deps: ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
return;
}
GameEngineUtils.revalidateIntents(deps.engine, true);
}
}
export class impervious extends CardMod {
constructor(override duration = -1) {
super(arguments);
}
override onSecDamageIn(_deps: ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return {
secDmgBonus: -9999,
};
}
}
export class lag extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
|
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
|
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class offline extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
}
GameEngineUtils.revalidateIntents(deps.engine, GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard));
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class secured extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public tempSecBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = tempSecBonus;
}
override onInitMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
override onStackMod(deps: ICardModDeps, stackDelta: number): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, stackDelta, false);
}
override onRemoveMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -this.stackingConfig.stackCount, true);
}
}
export class _waveBonus_extraMove extends CardMod {
override onInitMod(deps: ICardModDeps): void {
const player = GameEngineUtils.findPlayerByCardId(deps.engine.gameData, deps.sourceCard.id);
player.movesPerTurn++;
player.movesLeft = player.movesPerTurn;
deps.engine.broadcast.push({
type: 'movesPerTurnsChange',
playerId: player.id,
newMovesLeft: player.movesLeft,
newMovesPerTurn: player.movesPerTurn,
});
}
}
export class _winOnDeath extends CardMod {
override onCardDestroyed(deps: ICardModDeps) {
const player = deps.contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null;
player && player.stats.kills++;
deps.engine.onWinGame();
player && player.stats.kills--;
}
}
export class _standardAi extends CardMod {
override onTurnStart(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
}
override onTurnEnd(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.executeIntent(deps.engine, deps.sourceCard);
}
}
export class _yieldScript extends CardMod {
constructor(
public scriptData: CardScript.ScriptData,
override duration: number,
) {
super(arguments);
}
override onRemoveMod(deps: ICardModDeps) {
CardScript.addScript(deps.engine, deps.sourceCard, this.scriptData);
}
}
export class _waveTrigger extends CardMod {
constructor(
public rulesetIds: string[],
override duration = -1,
) {
super(arguments);
}
override onInitMod(deps: ICardModDeps): void {
deps.engine.gameData.difficulty < 3 && GameEngineUtils.changeSec(deps.engine, deps.sourceCard, 25, true);
}
override onCardDestroyed(deps: ICardModDeps) {
deps.engine.onNextWave(this.rulesetIds.random());
deps.contextCard && CardMod.addMod(deps.engine, deps.contextCard, new _waveBonus_extraMove());
}
override onRemoveMod(deps: ICardModDeps): void {
CardMod.addMod(deps.engine, deps.sourceCard, new _winOnDeath());
}
}
}
}
|
src/game/card-mods.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " goliath_boss_ai: class extends CardMod {\n override onTurnStart(deps: CardMod.ICardModDeps) {\n GameEngineUtils.generateIntent(deps.engine, deps.sourceCard as GameEngine.IEnemyCardState);\n }\n override onTurnEnd(deps: CardMod.ICardModDeps) {\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n const targetId = boss.intent?.targetCardId;\n if (!targetId) return;\n let numAttacks = 1;\n const powerBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_power);",
"score": 0.8947461843490601
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " for (const playerCard of [...playerCards]) {\n if (!playerCards.includes(playerCard)) continue;\n GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: playerCard });\n }\n for (const enemy of [...this.gameData.enemies]) {\n if (!this.gameData.enemies.includes(enemy)) continue;\n GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: enemy });\n }\n this._checkGameOver();\n }",
"score": 0.8680741190910339
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " (engine, _sourceCard, targetCard) => {\n if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;\n const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);\n if (script.targetFinder === CardScript.TargetFinders.Self) return;\n const targets = script.targetFinder(engine.gameData, targetCard);\n if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;\n const origTargetId = targetCard.intent.targetCardId;\n while (targetCard.intent.targetCardId === origTargetId) {\n targetCard.intent.targetCardId = targets.random().id;\n }",
"score": 0.8582102060317993
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " type: 'cardAdded',\n enemy,\n position: spawnIndex,\n });\n GameEngineUtils.triggerMods('onInitMod', { engine, sourceCard: enemy });\n if (generateIntent) {\n GameEngineUtils.generateIntent(engine, enemy);\n }\n return enemy;\n }",
"score": 0.857109546661377
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " triggerMods('onEnemyDestroyed', { engine, sourceCard: card, contextCard });\n }\n if (contextCard) {\n const player = findPlayerByCardIdMaybe(engine.gameData, contextCard.id);\n player && player.stats.kills++;\n }\n GameEngineUtils.revalidateIntents(engine, true);\n } else {\n const player = GameEngineUtils.findPlayerByCardId(engine.gameData, card.id);\n player.cards.removeFirst(card);",
"score": 0.8547101020812988
}
] |
typescript
|
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
|
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export namespace CardScriptParts {
export interface IScriptPart {
(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): void;
}
export const _Chance = (chance: number, curriedPart: IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (Math.random() < chance) {
curriedPart(engine, sourceCard, targetCard);
}
};
export const _TargetHasMod = <T extends CardMod.ModLibrary, K extends keyof T>(modName: K, curry: (mod: InstanceType<T[K]>) => IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
const mod = targetCard.mods.find(x => x[0] === modName);
if (mod) {
curry(CardMod.deserialize(engine, mod) as InstanceType<T[K]>)(engine, sourceCard, targetCard);
}
};
export const AddMod = (mod: CardMod): IScriptPart =>
(engine, sourceCard, targetCard) => {
CardMod.addMod(engine, targetCard, mod, sourceCard);
};
export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;
if (secExceeded) {
MemDmg(1)(engine, sourceCard, targetCard);
}
};
export const SecDmg = (secDmg: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
let resolvedDamage = secDmg;
if (!dontTriggerOut) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageOut', { engine, sourceCard, contextCard: targetCard }, resolvedDamage)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (!dontTriggerIn) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return false;
}
resolvedDamage = Math.max(0, resolvedDamage);
const secExceeded = resolvedDamage > targetCard.sec;
GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);
return secExceeded;
};
export const MemDmg = (memDmg: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.triggerMods('onMemDmgOut', { engine, sourceCard, contextCard: targetCard }, memDmg);
GameEngineUtils.triggerMods('onMemDmgIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, memDmg);
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return;
}
targetCard.mem -= memDmg;
engine.broadcast.push({
type: 'memDamage',
cardId: targetCard.id,
newMem: targetCard.mem,
value: -memDmg,
});
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, sourceCard.id);
player && (player.stats.memDmg += memDmg);
if (targetCard.mem <= 0) {
GameEngineUtils.removeCard(engine, targetCard, sourceCard);
}
};
export const ChangeCpu = (cpuDelta: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
};
export const RaiseMem = (memBonus: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
targetCard.mem += memBonus;
engine.broadcast.push({
type: 'memBonus',
cardId: targetCard.id,
newMem: targetCard.mem,
value: memBonus,
});
};
export const RaiseSec = (secBonus: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.changeSec(engine, targetCard, secBonus, false, sourceCard);
};
export const RedirectIntentRandom: IScriptPart =
(engine, _sourceCard, targetCard) => {
if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;
const script
|
= CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);
|
if (script.targetFinder === CardScript.TargetFinders.Self) return;
const targets = script.targetFinder(engine.gameData, targetCard);
if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;
const origTargetId = targetCard.intent.targetCardId;
while (targetCard.intent.targetCardId === origTargetId) {
targetCard.intent.targetCardId = targets.random().id;
}
engine.broadcast.push({
type: 'cardIntent',
cardId: targetCard.id,
intent: targetCard.intent,
});
};
export const RemoveMod = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modName: K, mustRemove = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (mustRemove) {
if (!targetCard.mods.find(x => x[0] === modName)) {
throw new Error(`Could not find [${modName}] to remove`);
}
}
CardMod.removeModByName(engine, targetCard, modName, sourceCard);
};
export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>
(engine, sourceCard, _targetCard) => {
let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);
switch (spawnPosition) {
case 'absLeft': spawnIndex = 0; break;
case 'absRight': spawnIndex = engine.gameData.enemies.length; break;
case 'relRight': spawnIndex++; break;
}
GameEngineUtils.spawnEnemy(engine, enemyClass, spawnIndex, generateIntent);
};
}
|
src/game/card-script-parts.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);\n const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);\n super(\n [minBonus, maxBonus],\n CardScript.TargetFinders.Self,\n [\n {\n targetResolver: CardScript.TargetResolvers.RandomAlly,\n parts: [\n CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),",
"score": 0.8884454965591431
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [secBonus],\n TargetFinders.Any(),\n [\n {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseSec(secBonus),\n ],\n }\n ],",
"score": 0.878108024597168
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Self,\n parts: [\n CardScriptParts.RaiseSec(secBonus),\n CardScriptParts.AddMod(\n new CardMod.Content.firewall(modDuration),\n ),\n ],\n }\n ],",
"score": 0.8748918175697327
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " const script = CardScript.deserialize(engine, enemy, scriptData);\n const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();\n if (!target) {\n return;\n }\n enemy.intent = {\n scriptData,\n targetCardId: target.id,\n };\n engine.broadcast.push({",
"score": 0.8701576590538025
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n CardScriptParts.SecDmg(secDelta),\n CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),\n CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),\n ],\n },\n {\n targetResolver: CardScript.TargetResolvers.Self,\n parts: [\n CardScriptParts.RaiseSec(secDelta),",
"score": 0.867367148399353
}
] |
typescript
|
= CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);
|
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export namespace CardScriptParts {
export interface IScriptPart {
(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): void;
}
export const _Chance = (chance: number, curriedPart: IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (Math.random() < chance) {
curriedPart(engine, sourceCard, targetCard);
}
};
export const _TargetHasMod = <T extends CardMod.ModLibrary, K extends keyof T>(modName: K, curry: (mod: InstanceType<T[K]>) => IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
const mod = targetCard.mods.find(x => x[0] === modName);
if (mod) {
curry(CardMod.deserialize(engine, mod) as InstanceType<T[K]>)(engine, sourceCard, targetCard);
}
};
export const AddMod = (mod: CardMod): IScriptPart =>
(engine, sourceCard, targetCard) => {
CardMod.addMod(engine, targetCard, mod, sourceCard);
};
export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;
if (secExceeded) {
MemDmg(1)(engine, sourceCard, targetCard);
}
};
export const SecDmg = (secDmg: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
let resolvedDamage = secDmg;
if (!dontTriggerOut) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageOut', { engine, sourceCard, contextCard: targetCard }, resolvedDamage)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (!dontTriggerIn) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return false;
}
resolvedDamage = Math.max(0, resolvedDamage);
const secExceeded = resolvedDamage > targetCard.sec;
GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);
return secExceeded;
};
export const MemDmg = (memDmg: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.triggerMods('onMemDmgOut', { engine, sourceCard, contextCard: targetCard }, memDmg);
GameEngineUtils.triggerMods('onMemDmgIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, memDmg);
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return;
}
targetCard.mem -= memDmg;
engine.broadcast.push({
type: 'memDamage',
cardId: targetCard.id,
newMem: targetCard.mem,
value: -memDmg,
});
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, sourceCard.id);
player && (player.stats.memDmg += memDmg);
if (targetCard.mem <= 0) {
GameEngineUtils.removeCard(engine, targetCard, sourceCard);
}
};
export const ChangeCpu = (cpuDelta: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
};
export const RaiseMem = (memBonus: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
targetCard.mem += memBonus;
engine.broadcast.push({
type: 'memBonus',
cardId: targetCard.id,
newMem: targetCard.mem,
value: memBonus,
});
};
export const RaiseSec = (secBonus: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.changeSec(engine, targetCard, secBonus, false, sourceCard);
};
export const RedirectIntentRandom: IScriptPart =
(engine, _sourceCard, targetCard) => {
if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;
const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);
if (script.targetFinder === CardScript.TargetFinders.Self) return;
const targets = script.targetFinder(engine.gameData, targetCard);
if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;
const origTargetId = targetCard.intent.targetCardId;
while (targetCard.intent.targetCardId === origTargetId) {
targetCard.intent.targetCardId = targets.random().id;
}
engine.broadcast.push({
type: 'cardIntent',
cardId: targetCard.id,
intent: targetCard.intent,
});
};
export const RemoveMod = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modName: K, mustRemove = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (mustRemove) {
if (!targetCard.mods.find(x => x[0] === modName)) {
throw new Error(`Could not find [${modName}] to remove`);
}
}
CardMod.
|
removeModByName(engine, targetCard, modName, sourceCard);
|
};
export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>
(engine, sourceCard, _targetCard) => {
let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);
switch (spawnPosition) {
case 'absLeft': spawnIndex = 0; break;
case 'absRight': spawnIndex = engine.gameData.enemies.length; break;
case 'relRight': spawnIndex++; break;
}
GameEngineUtils.spawnEnemy(engine, enemyClass, spawnIndex, generateIntent);
};
}
|
src/game/card-script-parts.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {\n const mod = card.mods.find(x => x[0] === modName);\n mod && this.removeMod(engine, card, mod, contextCard);\n }\n static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {\n const deps = args[0];\n const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));\n if (!modDataFromCard) {\n throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);\n }",
"score": 0.8963751792907715
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " type: 'modRemoved',\n cardId: card.id,\n modData,\n });\n if (!card.mods.find(x => this.areEqual(x, modData))) {\n throw new Error('mod not found');\n }\n this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });\n card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));\n }",
"score": 0.8641057014465332
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " export class _yieldScript extends CardMod {\n constructor(\n public scriptData: CardScript.ScriptData,\n override duration: number,\n ) {\n super(arguments);\n }\n override onRemoveMod(deps: ICardModDeps) {\n CardScript.addScript(deps.engine, deps.sourceCard, this.scriptData);\n }",
"score": 0.838903546333313
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n (engine, sourceCard, targetCard) => {\n CardScript.removeScript(engine, sourceCard, _cardScripts.mw_copypaste);\n if (!targetCard.scripts[1]) return;\n CardScript.addScript(engine, sourceCard, CardScript.fromScriptName(engine, sourceCard, targetCard.scripts[1][0]));\n },\n ],\n }",
"score": 0.8362866044044495
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " throw new Error('Invalid target ' + targets.map(x => x.id).join());\n }\n for (const pair of script.targetScriptParts) {\n const resolvedTargets = pair.targetResolver(engine.gameData, sourceCard, targetCard);\n for (const part of pair.parts) {\n for (const resolvedTarget of resolvedTargets) {\n if (resolvedTarget.isRemoved) continue;\n part(engine, sourceCard, resolvedTarget);\n }\n }",
"score": 0.835172712802887
}
] |
typescript
|
removeModByName(engine, targetCard, modName, sourceCard);
|
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export namespace CardScriptParts {
export interface IScriptPart {
(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): void;
}
export const _Chance = (chance: number, curriedPart: IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (Math.random() < chance) {
curriedPart(engine, sourceCard, targetCard);
}
};
export const _TargetHasMod = <T extends CardMod.ModLibrary, K extends keyof T>(modName: K, curry: (mod: InstanceType<T[K]>) => IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
const mod = targetCard.mods.find(x => x[0] === modName);
if (mod) {
curry(CardMod.deserialize(engine, mod) as InstanceType<T[K]>)(engine, sourceCard, targetCard);
}
};
export const AddMod = (mod: CardMod): IScriptPart =>
(engine, sourceCard, targetCard) => {
CardMod.addMod(engine, targetCard, mod, sourceCard);
};
export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;
if (secExceeded) {
MemDmg(1)(engine, sourceCard, targetCard);
}
};
export const SecDmg = (secDmg: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
let resolvedDamage = secDmg;
if (!dontTriggerOut) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageOut', { engine, sourceCard, contextCard: targetCard }, resolvedDamage)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (!dontTriggerIn) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return false;
}
resolvedDamage = Math.max(0, resolvedDamage);
const secExceeded = resolvedDamage > targetCard.sec;
GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);
return secExceeded;
};
export const MemDmg = (memDmg: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.triggerMods('onMemDmgOut', { engine, sourceCard, contextCard: targetCard }, memDmg);
GameEngineUtils.triggerMods('onMemDmgIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, memDmg);
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return;
}
targetCard.mem -= memDmg;
engine.broadcast.push({
type: 'memDamage',
cardId: targetCard.id,
newMem: targetCard.mem,
value: -memDmg,
});
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, sourceCard.id);
player && (player.stats.memDmg += memDmg);
if (targetCard.mem <= 0) {
GameEngineUtils.removeCard(engine, targetCard, sourceCard);
}
};
export const ChangeCpu = (cpuDelta: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
};
export const RaiseMem = (memBonus: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
targetCard.mem += memBonus;
engine.broadcast.push({
type: 'memBonus',
cardId: targetCard.id,
newMem: targetCard.mem,
value: memBonus,
});
};
export const RaiseSec = (secBonus: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.changeSec(engine, targetCard, secBonus, false, sourceCard);
};
export const RedirectIntentRandom: IScriptPart =
(engine, _sourceCard, targetCard) => {
|
if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;
|
const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);
if (script.targetFinder === CardScript.TargetFinders.Self) return;
const targets = script.targetFinder(engine.gameData, targetCard);
if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;
const origTargetId = targetCard.intent.targetCardId;
while (targetCard.intent.targetCardId === origTargetId) {
targetCard.intent.targetCardId = targets.random().id;
}
engine.broadcast.push({
type: 'cardIntent',
cardId: targetCard.id,
intent: targetCard.intent,
});
};
export const RemoveMod = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modName: K, mustRemove = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (mustRemove) {
if (!targetCard.mods.find(x => x[0] === modName)) {
throw new Error(`Could not find [${modName}] to remove`);
}
}
CardMod.removeModByName(engine, targetCard, modName, sourceCard);
};
export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>
(engine, sourceCard, _targetCard) => {
let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);
switch (spawnPosition) {
case 'absLeft': spawnIndex = 0; break;
case 'absRight': spawnIndex = engine.gameData.enemies.length; break;
case 'relRight': spawnIndex++; break;
}
GameEngineUtils.spawnEnemy(engine, enemyClass, spawnIndex, generateIntent);
};
}
|
src/game/card-script-parts.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);\n const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);\n super(\n [minBonus, maxBonus],\n CardScript.TargetFinders.Self,\n [\n {\n targetResolver: CardScript.TargetResolvers.RandomAlly,\n parts: [\n CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),",
"score": 0.8954152464866638
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [memBonus],\n CardScript.TargetFinders.Any(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseMem(1),\n ],\n }\n ],",
"score": 0.8709584474563599
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [secBonus],\n TargetFinders.Any(),\n [\n {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseSec(secBonus),\n ],\n }\n ],",
"score": 0.8674157857894897
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " // Raise SEC\n bf_obfuscate: class extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);\n super(\n [secBonus],\n CardScript.TargetFinders.Any(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,",
"score": 0.8644304871559143
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Self,\n parts: [\n CardScriptParts.RaiseSec(secBonus),\n CardScriptParts.AddMod(\n new CardMod.Content.firewall(modDuration),\n ),\n ],\n }\n ],",
"score": 0.8631940484046936
}
] |
typescript
|
if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;
|
import { CoreScriptNames } from '../appraise';
import { IPlayerPushProvider } from '../dependencies';
import { randInt, round } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export class CardScript {
cooldownMax = -1;
cooldownCur = 0;
readonly scriptName: string;
constructor(
private _extraScriptData: unknown[],
public targetFinder: CardScript.ITargetFinder,
public targetScriptParts: { targetResolver: CardScript.ITargetResolver, parts: CardScriptParts.IScriptPart[] }[],
) {
this.scriptName = this.constructor.name;
}
serialize() {
const retVal = [this.scriptName, ...this._extraScriptData] as CardScript.ScriptData;
(this.cooldownCur > 0 || this.cooldownMax > 0) && retVal.push(CardScript.makeCooldownData(this.cooldownMax, this.cooldownCur));
return retVal;
}
static addScript(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptData: CardScript.ScriptData) {
card.scripts.push(scriptData);
engine.broadcast.push({
type: 'scriptAdded',
cardId: card.id,
scriptData,
});
}
static areEqual(left: CardScript.ScriptData, right: CardScript.ScriptData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptData: CardScript.ScriptData) {
const scriptCtor = engine.ruleset.cardScripts?.[scriptData[0]];
if (!scriptCtor) throw new Error('script not found: ' + scriptData.join());
const script = new scriptCtor(card, ...scriptData.slice(1));
const cooldownData = CardScript.findCooldownData(scriptData);
if (cooldownData) {
script.cooldownCur = cooldownData[1];
script.cooldownMax = cooldownData[2];
}
return script;
}
static execute(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, sourceCardScript: CardScript.ScriptData, targetCard: GameEngine.ICardState) {
engine.broadcast.push({
type: 'cardExecuting',
cardId: sourceCard.id,
targetCardId: targetCard.id,
scriptData: sourceCardScript,
});
if (this.isOnCooldown(sourceCardScript)) {
throw new Error('Script is on cooldown: ' + sourceCardScript.join());
}
const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript));
const isEnemy = GameEngineUtils.isEnemyCard(engine.gameData, sourceCard);
if (!isEnemy) {
if (!scriptDataFromCard) {
throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());
}
}
const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);
if (cooldownData) {
cooldownData[1] = cooldownData[2] + 1;
}
const script = this.deserialize(engine, sourceCard, sourceCardScript);
const targets = script.targetFinder(engine.gameData, sourceCard);
if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {
throw new Error('Invalid target ' + targets.map(x => x.id).join());
}
for (const pair of script.targetScriptParts) {
const resolvedTargets = pair.targetResolver(engine.gameData, sourceCard, targetCard);
for (const part of pair.parts) {
for (const resolvedTarget of resolvedTargets) {
if (resolvedTarget.isRemoved) continue;
part(engine, sourceCard, resolvedTarget);
}
}
}
engine.broadcast.push({
type: 'cardExecuted',
cardId: sourceCard.id,
targetCardId: targetCard.id,
scriptData: scriptDataFromCard || sourceCardScript,
});
}
static findCooldownData(data: CardScript.ScriptData) {
return data.find((x): x is CardScript.CooldownData => Array.isArray(x) && x[0] === '$cooldown');
}
static fromScriptName(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptName: string) {
return this.deserialize(engine, card, [scriptName]).serialize();
}
static isOnCooldown(data: CardScript.ScriptData) {
return (this.findCooldownData(data)?.[1] || 0) > 0;
}
static makeCooldownData(max: number, cur = 0): CardScript.CooldownData {
return ['$cooldown', cur, max];
}
static removeScript(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptType: CardScript.ScriptConstructor) {
const removed = card.scripts.findAndRemoveFirst(x => x[0] === scriptType.name);
if (!removed) throw new Error('script not found: ' + scriptType.name);
engine.broadcast.push({
type: 'scriptRemoved',
cardId: card.id,
removedScript: scriptType.name,
});
}
static tickCooldowns(card: GameEngine.ICardState, broadcast: IPlayerPushProvider.IPushMessage[]) {
for (const script of card.scripts) {
const cooldownData = CardScript.findCooldownData(script);
if (!cooldownData?.[1]) {
continue;
}
cooldownData[1]--;
broadcast.push({
type: 'scriptChanged',
cardId: card.id,
scriptData: script,
});
}
}
}
export namespace CardScript {
export type ScriptData = [string, ...unknown[]];
export type CooldownData = ['$cooldown', number, number];
export type ScriptConstructor = { new(card: GameEngine.ICardState, ...args: any[]): CardScript };
export type ScriptLibrary = Record<string, ScriptConstructor>;
export interface ITargetResolver {
(gameData: GameEngine.IGameData, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): GameEngine.ICardState[];
}
export interface ITargetFinder {
(gameData: GameEngine.IGameData, card: GameEngine.ICardState): GameEngine.ICardState[];
}
export namespace TargetResolvers {
export const Self: ITargetResolver = (_, sourceCard) => [sourceCard];
export const Target: ITargetResolver = (_, _2, targetCard) => [targetCard];
export const TargetAndAdjacents: ITargetResolver = (gameData, _, targetCard) => {
const cards = GameEngineUtils.isEnemyCard(gameData, targetCard) ? gameData.enemies : (GameEngineUtils.findPlayerByCardId(gameData, targetCard.id).cards);
const i = cards.findIndex(x => x.id === targetCard.id);
return [cards[i], cards[i - 1], cards[i + 1]].filter(Boolean);
};
export const AllAllies: ITargetResolver = (gameData, sourceCard) => {
if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {
return TargetFinders._excludeOffline(gameData.enemies);
} else {
return TargetFinders._excludeOffline(GameEngineUtils.getPlayerCards(gameData));
}
};
export const RandomAlly: ITargetResolver = (gameData, sourceCard, targetCard) => {
return [AllAllies(gameData, sourceCard, targetCard).random()];
};
export const AllOpponents: ITargetResolver = (gameData, sourceCard) => {
if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {
return TargetFinders._excludeImperviousAndOffline(GameEngineUtils.getPlayerCards(gameData));
} else {
return TargetFinders._excludeImperviousAndOffline(gameData.enemies);
}
};
export const RandomOpponent: ITargetResolver = (gameData, sourceCard, targetCard) => {
return TargetFinders._excludeImperviousAndOffline([AllOpponents(gameData, sourceCard, targetCard).random()]);
};
}
export namespace TargetFinders {
export const Self: ITargetFinder = (_gameData, card) => [card];
export const Allies = (excludeSelf = false): ITargetFinder =>
(gameData, card) => {
let targets: GameEngine.ICardState[] = GameEngineUtils.isEnemyCard(gameData, card) ? gameData.enemies : GameEngineUtils.getPlayerCards(gameData);
excludeSelf && (targets = targets.filter(x => x.id !== card.id));
return _excludeOffline(targets);
};
export const Opponents = (ignoreTaunt = false): ITargetFinder =>
(gameData, card) => {
const targets = GameEngineUtils.isEnemyCard(gameData, card) ? GameEngineUtils.getPlayerCards(gameData) : gameData.enemies;
const standardTargets = _excludeImperviousAndOffline(targets);
if (!ignoreTaunt) {
const taunts = _filterForFirewall(standardTargets);
if (taunts.length) {
return taunts;
}
}
return standardTargets;
};
export const Any = (ignoreTaunt = false): ITargetFinder =>
(gameData, card) => [
...Opponents(ignoreTaunt)(gameData, card),
...Allies()(gameData, card),
];
export const _ModFilter = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modFilter: K[], targetFinder: ITargetFinder): ITargetFinder =>
(gameData, card) => {
const targets = targetFinder(gameData, card);
const modMatches = targets.filter(target => target.mods.find(modData => modFilter.find(x => x === modData[0])));
return _excludeImperviousAndOffline(modMatches);
};
const _excludeImpervious = (cards: GameEngine.ICardState[]) => {
return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.impervious.name));
};
export const _excludeOffline = (cards: GameEngine.ICardState[]) => {
return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.offline.name));
};
export const _excludeImperviousAndOffline = (cards: GameEngine.ICardState[]) => _excludeImpervious(_excludeOffline(cards));
const _filterForFirewall = (cards: GameEngine.ICardState[]) => {
return cards.filter(x => x.mods.find(y => y[0] === CardMod.Content.firewall.name));
};
}
export namespace Content {
// Defines a card script - the class name is treated as the script name
export class bd_decode extends CardScript {
constructor(
// MUST always be the first parameter even if not used
card: GameEngine.ICardState,
// Not used but declared to show how the memo is passed back here, see first argument in super(...) below
_secDamage: number,
) {
const secDamage = GameEngineUtils.scaleByCpuMem(12, card.cpu);
const bdChance = round(GameEngineUtils.scaleByCpuMem(20, card.mem, 'high') / 100, 2);
const bdDamage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
// Any extra data to serialize into scriptData[1:] as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display potential card effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI scripts
[secDamage, bdChance, bdDamage],
// Which cards are valid targets for this card; AI will typically .random()
TargetFinders.Opponents(),
// A composition of CardScriptParts that get executed when this card is played; this allows for
// composition effects such as "((damage and debuff) to target) AND (chance to stun neighbors)":
// The first part would use the Target resolver and Attack and ApplyMod parts
// The second part would use the Neighbors resolver and curry Stun part into _Chance part
[
{
// Given a chosen target, which actual targets these parts will execute on; this allows
// a card to, for example, deal damage to the neighbors of the specified target
targetResolver: TargetResolvers.Target,
// CardScriptParts to execute on the resolved targets
parts: [
CardScriptParts.SecDmg(secDamage),
CardScriptParts._Chance(bdChance,
CardScriptParts.AddMod(
new CardMod.Content.backdoor(bdDamage),
)
),
],
}
],
);
}
}
export class bd_exploit extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const bdChance = round(GameEngineUtils.scaleByCpuMem(40, card.mem, 'more') / 100, 2);
super(
[damage, bdChance],
(gameData: GameEngine.IGameData, card: GameEngine.ICardState) => [
...TargetFinders.Opponents()(gameData, card),
...TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
TargetFinders.Opponents(true))(gameData, card),
],
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts._TargetHasMod<typeof CardMod.Content, 'backdoor'>('backdoor', mod => CardScriptParts.SecDmg(mod.stackingConfig.rank, true)),
CardScriptParts.Attack(damage),
CardScriptParts._Chance(bdChance,
CardScriptParts.AddMod(
new CardMod.Content.backdoor(damage),
)
),
],
}
],
);
}
}
export class bd_secure extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
TargetFinders.Any(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts
|
.RaiseSec(secBonus),
],
}
|
],
);
this.cooldownMax = 1;
}
}
export class bf_spam extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[damage],
TargetFinders.Opponents(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.Attack(damage),
],
}
]
);
}
}
export class bf_firewall extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const modDuration = Math.ceil(card.mem / 2);
super(
[secBonus, modDuration],
TargetFinders.Self,
[
{
targetResolver: TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secBonus),
CardScriptParts.AddMod(
new CardMod.Content.firewall(modDuration),
),
],
}
],
);
this.cooldownMax = 1;
}
}
export class bf_overclock extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(17, card.cpu);
const lagChance = round((100 - GameEngineUtils.scaleByCpuMem(30, card.mem)) / 100, 2);
const lagDuration = 2;
super(
[damage, lagChance, lagDuration],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts._Chance(lagChance,
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
),
],
}
],
);
}
}
export class mw_freeware extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(12, card.cpu, 'more');
super(
[minBonus, maxBonus],
TargetFinders.Any(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 1;
}
}
export class mw_redirect extends CardScript {
constructor(card: GameEngine.ICardState) {
const tempSecBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const duration = Math.ceil(card.mem / 2);
super(
[tempSecBonus, duration],
TargetFinders.Allies(true),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.secured(tempSecBonus, duration),
),
CardScriptParts.AddMod(
new CardMod.Content.firewall(duration),
),
],
}
],
);
this.cooldownMax = 1;
}
}
export class mw_worm extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(7, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(13, card.cpu);
super(
[minDamage, maxDamage],
TargetFinders.Opponents(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
}
}
export class _attack extends CardScript {
constructor(card: GameEngine.ICardState, difficulty: number, strength: 'weak' | 'normal' | 'strong' = 'normal', cooldown = 0) {
let minDmg = 0;
let maxDmg = 0;
switch (strength) {
case 'weak':
minDmg = GameEngineUtils.scaleByCpuMem(6, card.cpu);
maxDmg = GameEngineUtils.scaleByCpuMem(8, card.cpu);
break;
case 'normal':
minDmg = GameEngineUtils.scaleByCpuMem(8, card.cpu);
maxDmg = GameEngineUtils.scaleByCpuMem(12, card.cpu);
break;
case 'strong':
minDmg = GameEngineUtils.scaleByCpuMem(11, card.cpu);
maxDmg = GameEngineUtils.scaleByCpuMem(15, card.cpu);
break;
}
minDmg = GameEngineUtils.scaleByDifficulty(minDmg, difficulty);
maxDmg = GameEngineUtils.scaleByDifficulty(maxDmg, difficulty);
super(
[difficulty, strength, cooldown, minDmg, maxDmg],
TargetFinders.Opponents(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.Attack(randInt(minDmg, maxDmg)),
],
}
],
);
this.cooldownMax = cooldown;
}
}
export class _defend extends CardScript {
constructor(card: GameEngine.ICardState, difficulty: number, strength: 'weak' | 'normal' | 'strong' = 'normal', cooldown = 0) {
let minBonus = 0;
let maxBonus = 0;
switch (strength) {
case 'weak':
minBonus = GameEngineUtils.scaleByCpuMem(4, card.cpu);
maxBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
break;
case 'normal':
minBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
maxBonus = GameEngineUtils.scaleByCpuMem(8, card.cpu);
break;
case 'strong':
minBonus = GameEngineUtils.scaleByCpuMem(8, card.cpu);
maxBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
break;
}
minBonus = GameEngineUtils.scaleByDifficulty(minBonus, difficulty);
maxBonus = GameEngineUtils.scaleByDifficulty(maxBonus, difficulty);
super(
[difficulty, strength, cooldown, minBonus, maxBonus],
TargetFinders.Allies(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = cooldown;
}
}
export class _firewallSelf extends CardScript {
constructor(_card: GameEngine.ICardState, duration = 1, cooldown = 0, startingCooldown = 0) {
super(
[duration, cooldown],
TargetFinders.Self,
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.firewall(duration + 1),
),
],
}
],
);
this.cooldownCur = startingCooldown;
this.cooldownMax = cooldown;
}
}
export class _spawn extends CardScript {
constructor(_card: GameEngine.ICardState, enemyClass: string, spawnPosition: Parameters<typeof CardScriptParts['SpawnEnemy']>[1] = 'relLeft', generateIntent = false, cooldown = 0) {
super(
[enemyClass, spawnPosition, generateIntent, cooldown],
TargetFinders.Self,
[
{
targetResolver: TargetResolvers.Self,
parts: [
CardScriptParts.SpawnEnemy(enemyClass, spawnPosition, generateIntent),
],
}
],
);
this.cooldownMax = cooldown;
}
}
}
(Content as Record<CoreScriptNames, ScriptConstructor>);
}
|
src/game/card-scripts.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [secBonus, duration],\n CardScript.TargetFinders.Any(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new CardMod.Content.diagnostics(secBonus, duration)\n ),\n ],",
"score": 0.9018428325653076
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [memBonus],\n CardScript.TargetFinders.Any(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseMem(1),\n ],\n }\n ],",
"score": 0.8884729146957397
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " super(\n [secDelta],\n CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.SecDmg(secDelta),\n ],\n },",
"score": 0.8863707184791565
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n CardScriptParts.SecDmg(secDelta),\n CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),\n CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),\n ],\n },\n {\n targetResolver: CardScript.TargetResolvers.Self,\n parts: [\n CardScriptParts.RaiseSec(secDelta),",
"score": 0.8780152797698975
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " {\n targetResolver: CardScript.TargetResolvers.Self,\n parts: [\n CardScriptParts.RaiseSec(secDelta),\n ],\n },\n ],\n );\n this.cooldownMax = 1;\n }",
"score": 0.8724547028541565
}
] |
typescript
|
.RaiseSec(secBonus),
],
}
|
import { randInt } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
const _cardMods = {
// Increases incoming damage
exposed: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public stackCount: number) {
super(arguments);
this.stackingConfig.stackCount = stackCount;
}
override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return { secDmgBonus: this.stackingConfig.stackCount };
}
},
// Returns damage to attacker
feedback: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public damage: number) {
super(arguments);
this.stackingConfig.stackCount = damage;
}
override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);
}
},
// Increases CPU
optimized: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(cpuBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = cpuBonus;
}
override onInitMod(deps: CardMod.ICardModDeps) {
GameEngineUtils.changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);
}
override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {
deps.sourceCard.cpu += stackDelta;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils
|
.recalculateScripts(deps.engine, deps.sourceCard);
|
}
override onRemoveMod(deps: CardMod.ICardModDeps) {
deps.sourceCard.cpu -= this.stackingConfig.stackCount;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
},
// Damages on turn end
virus: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public dot: number) {
super(arguments);
this.stackingConfig.stackCount = dot;
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);
}
},
};
const _cardScripts = {
//
// Backdoor scripts
//
// Swap MEM for CPU
bd_caching: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(-1),
CardScriptParts.ChangeCpu(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise MEM
bd_defrag: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memBonus = 1;
super(
[memBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 4;
}
},
// Heal over time
bd_diagnostics: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const duration = 1 + Math.round(card.mem / 2);
super(
[secBonus, duration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.diagnostics(secBonus, duration)
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Attack and stun (Backdoor finisher)
bd_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const stunDuration = 1;
super(
[damage, stunDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.AddMod(
new CardMod.Content.lag(stunDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and raise CPU on kill
bd_extraction: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Opponents(true)(gameData, card)
.filter(target => !target.sec && target.mem === 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(1, true, true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.ChangeCpu(1),
],
},
],
);
}
},
// Raises CPU
bd_optimize: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Raises SEC
bd_patch: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 2;
}
},
// Steal SEC and remove Firewall (Backdoor finisher)
bd_proxy: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, card.cpu);
super(
[secDelta],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
}
},
// Steal SEC and causes offline (Backdoor finisher)
bd_reboot: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, _card.cpu);
const offlineDuration = 1;
super(
[secDelta, offlineDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 2;
}
},
// Cause Exposed (Backdoor finisher)
bd_trace: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(7, card.cpu);
super(
[stacks],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and remove 1 MEM
bd_tunnel: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memDmg = 1;
super(
[memDmg],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.MemDmg(memDmg),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 3;
}
},
//
// Bruteforce scripts
//
// Swap CPU for MEM
bf_compression: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.ChangeCpu(-1),
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Offline
bf_ddos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const offlineDuration = 1;
super(
[offlineDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Cause Lag
bf_dos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const lagDuration = 1;
super(
[lagDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Gain feedback
bf_feedback: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Triple SEC attack
bf_flood: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(3, card.cpu);
const numAttacks = 3;
super(
[damage, numAttacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
...Array.from(Array(numAttacks)).map(() => CardScriptParts.SecDmg(damage)),
],
}
],
);
this.cooldownMax = 2;
}
},
// AOE attack
bf_multicast: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.TargetAndAdjacents,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC
bf_obfuscate: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 3;
}
},
// Strong attack
bf_pod: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(16, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 2;
}
},
// Raises CPU
bf_precompute: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
//
// Malware scripts
//
// Causes Lag
mw_bloatware: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[1],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(1),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Swap for another card's secondary script
mw_copypaste: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, sourceCard, targetCard) => {
CardScript.removeScript(engine, sourceCard, _cardScripts.mw_copypaste);
if (!targetCard.scripts[1]) return;
CardScript.addScript(engine, sourceCard, CardScript.fromScriptName(engine, sourceCard, targetCard.scripts[1][0]));
},
],
}
],
);
}
},
// Grant Feedback
mw_honeypot: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Steal SEC
mw_leech: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[secDelta],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 1;
}
},
// Attack random target
mw_phishing: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(18, card.cpu);
super(
[minDamage, maxDamage],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomOpponent,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
this.cooldownMax = 1;
}
},
// Redistribute CPU/MEM
mw_reimage: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, _sourceCard, targetCard) => {
const totalStats = targetCard.cpu + targetCard.mem;
const newCpu = randInt(1, totalStats - 1);
const cpuDelta = newCpu - targetCard.cpu;
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
const newMem = totalStats - newCpu;
const memDelta = newMem - targetCard.mem;
GameEngineUtils.changeMem(engine, targetCard, memDelta);
},
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC on random ally
mw_shareware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);
super(
[minBonus, maxBonus],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomAlly,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 3;
}
},
// Redirect intent
mw_spoof: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RedirectIntentRandom,
],
}
],
);
}
},
// Cause Exposed
mw_spyware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[stacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Virus
mw_virus: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const dot = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[dot],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.virus(dot),
),
],
}
],
);
this.cooldownMax = 2;
}
},
};
export const GameContent_v1 = {
cardMods: _cardMods,
cardScripts: _cardScripts,
enemyCards: {},
initGame(_engine: GameEngine.IGameEngine) {
throw new Error('not a startable scenario');
},
addAdditionalScriptsFor(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState) {
if (card.card.tier < 2) return;
switch (card.card.faction) {
case 'backdoor':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bd_')).random()]).serialize());
return;
case 'bruteforce':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bf_')).random()]).serialize());
return;
case 'malware':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('mw_')).random()]).serialize());
return;
}
},
};
(GameContent_v1 as GameEngine.IRuleset);
|
src/game/game-content-v1.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " export function changeCpu(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, cpuDelta: number) {\n card.cpu += cpuDelta;\n engine.broadcast.push({\n type: 'cpuChanged',\n cardId: card.id,\n newCpu: card.cpu,\n cpuDelta,\n });\n GameEngineUtils.recalculateScripts(engine, card);\n }",
"score": 0.8898070454597473
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " engine.broadcast.push({\n type: 'modStackChanged',\n cardId: card.id,\n modData: existingModData,\n stackDelta: mod.stackingConfig.stackCount,\n newStackCount: existingStackingData[2],\n });\n this.trigger('onStackMod', existingModData, { engine, sourceCard: card, contextCard }, mod.stackingConfig.stackCount);\n return;\n }",
"score": 0.8758187890052795
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);\n }\n }\n override onRemoveMod(deps: ICardModDeps): void {\n if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {\n GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);\n } else {\n GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);\n }\n }",
"score": 0.8757087588310242
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (deps.sourceCard.mem - memDmg <= 0) return;\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n let secBonus = 100;\n const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);\n if (shieldBuff) {\n secBonus += CardMod.getStackCount(shieldBuff) * 100;\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);\n for (const enemy of [...deps.engine.gameData.enemies]) {\n if (enemy === boss) continue;",
"score": 0.869473934173584
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {\n CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);\n if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {\n GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n }\n }\n },\n },",
"score": 0.868596076965332
}
] |
typescript
|
.recalculateScripts(deps.engine, deps.sourceCard);
|
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export namespace CardScriptParts {
export interface IScriptPart {
(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): void;
}
export const _Chance = (chance: number, curriedPart: IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (Math.random() < chance) {
curriedPart(engine, sourceCard, targetCard);
}
};
export const _TargetHasMod = <T extends CardMod.ModLibrary, K extends keyof T>(modName: K, curry: (mod: InstanceType<T[K]>) => IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
const mod = targetCard.mods.find(x => x[0] === modName);
if (mod) {
curry(CardMod.deserialize(engine, mod) as InstanceType<T[K]>)(engine, sourceCard, targetCard);
}
};
export const AddMod = (mod: CardMod): IScriptPart =>
(engine, sourceCard, targetCard) => {
CardMod.addMod(engine, targetCard, mod, sourceCard);
};
export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;
if (secExceeded) {
MemDmg(1)(engine, sourceCard, targetCard);
}
};
export const SecDmg = (secDmg: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
let resolvedDamage = secDmg;
if (!dontTriggerOut) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageOut', { engine, sourceCard, contextCard: targetCard }, resolvedDamage)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (!dontTriggerIn) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return false;
}
resolvedDamage = Math.max(0, resolvedDamage);
const secExceeded = resolvedDamage > targetCard.sec;
GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);
return secExceeded;
};
export const MemDmg = (memDmg: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.triggerMods('onMemDmgOut', { engine, sourceCard, contextCard: targetCard }, memDmg);
GameEngineUtils.triggerMods('onMemDmgIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, memDmg);
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return;
}
targetCard.mem -= memDmg;
engine.broadcast.push({
type: 'memDamage',
cardId: targetCard.id,
newMem: targetCard.mem,
value: -memDmg,
});
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, sourceCard.id);
player && (player.stats.memDmg += memDmg);
if (targetCard.mem <= 0) {
GameEngineUtils.removeCard(engine, targetCard, sourceCard);
}
};
export const ChangeCpu = (cpuDelta: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
};
export const RaiseMem = (memBonus: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
targetCard.mem += memBonus;
engine.broadcast.push({
type: 'memBonus',
cardId: targetCard.id,
newMem: targetCard.mem,
value: memBonus,
});
};
export const RaiseSec = (secBonus: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.changeSec(engine, targetCard, secBonus, false, sourceCard);
};
export const RedirectIntentRandom: IScriptPart =
(engine, _sourceCard, targetCard) => {
if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;
const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);
if (script.targetFinder === CardScript.TargetFinders.Self) return;
const targets = script.targetFinder(engine.gameData, targetCard);
if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;
const origTargetId = targetCard.intent.targetCardId;
while (targetCard.intent.targetCardId === origTargetId) {
targetCard.intent.targetCardId = targets.random().id;
}
engine.broadcast.push({
type: 'cardIntent',
cardId: targetCard.id,
intent: targetCard.intent,
});
};
export const RemoveMod = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modName: K, mustRemove = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (mustRemove) {
if (!targetCard.mods.find(x => x[0] === modName)) {
throw new Error(`Could not find [${modName}] to remove`);
}
}
CardMod.removeModByName(engine, targetCard, modName, sourceCard);
};
export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>
(engine, sourceCard, _targetCard) => {
let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);
switch (spawnPosition) {
case 'absLeft': spawnIndex = 0; break;
case 'absRight': spawnIndex = engine.gameData.enemies.length; break;
case 'relRight': spawnIndex++; break;
}
GameEngineUtils
|
.spawnEnemy(engine, enemyClass, spawnIndex, generateIntent);
|
};
}
|
src/game/card-script-parts.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " this.cooldownCur = startingCooldown;\n this.cooldownMax = cooldown;\n }\n }\n export class _spawn extends CardScript {\n constructor(_card: GameEngine.ICardState, enemyClass: string, spawnPosition: Parameters<typeof CardScriptParts['SpawnEnemy']>[1] = 'relLeft', generateIntent = false, cooldown = 0) {\n super(\n [enemyClass, spawnPosition, generateIntent, cooldown],\n TargetFinders.Self,\n [",
"score": 0.8962253928184509
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": "import { clamp, round } from '../utils';\nimport { CardMod } from './card-mods';\nimport { CardScript } from './card-scripts';\nimport { GameEngine } from './game-engine';\nexport namespace GameEngineUtils {\n export function addEnemy(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, spawnIndex: number, generateIntent: boolean) {\n if (engine.gameData.enemies.length >= engine.gameData.maxEnemies) return;\n spawnIndex = clamp(spawnIndex, 0, engine.gameData.enemies.length);\n engine.gameData.enemies.splice(spawnIndex, 0, enemy);\n engine.broadcast.push({",
"score": 0.8916406631469727
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Self,\n parts: [\n CardScriptParts.SpawnEnemy(enemyClass, spawnPosition, generateIntent),\n ],\n }\n ],\n );\n this.cooldownMax = cooldown;\n }",
"score": 0.8882949352264404
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " type: 'cardAdded',\n enemy,\n position: spawnIndex,\n });\n GameEngineUtils.triggerMods('onInitMod', { engine, sourceCard: enemy });\n if (generateIntent) {\n GameEngineUtils.generateIntent(engine, enemy);\n }\n return enemy;\n }",
"score": 0.8793120384216309
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n );\n return enemy;\n },\n reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n enemyClass: 'reaper_lesser_guardian',\n cpu: 2,",
"score": 0.8649444580078125
}
] |
typescript
|
.spawnEnemy(engine, enemyClass, spawnIndex, generateIntent);
|
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export namespace CardScriptParts {
export interface IScriptPart {
(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): void;
}
export const _Chance = (chance: number, curriedPart: IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (Math.random() < chance) {
curriedPart(engine, sourceCard, targetCard);
}
};
export const _TargetHasMod = <T extends CardMod.ModLibrary, K extends keyof T>(modName: K, curry: (mod: InstanceType<T[K]>) => IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
const mod = targetCard.mods.find(x => x[0] === modName);
if (mod) {
curry(CardMod.deserialize(engine, mod) as InstanceType<T[K]>)(engine, sourceCard, targetCard);
}
};
export const AddMod = (mod: CardMod): IScriptPart =>
(engine, sourceCard, targetCard) => {
CardMod.addMod(engine, targetCard, mod, sourceCard);
};
export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;
if (secExceeded) {
MemDmg(1)(engine, sourceCard, targetCard);
}
};
export const SecDmg = (secDmg: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
let resolvedDamage = secDmg;
if (!dontTriggerOut) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageOut', { engine, sourceCard, contextCard: targetCard }, resolvedDamage)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (!dontTriggerIn) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return false;
}
resolvedDamage = Math.max(0, resolvedDamage);
const secExceeded = resolvedDamage > targetCard.sec;
GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);
return secExceeded;
};
export const MemDmg = (memDmg: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.triggerMods('onMemDmgOut', { engine, sourceCard, contextCard: targetCard }, memDmg);
GameEngineUtils.triggerMods('onMemDmgIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, memDmg);
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return;
}
targetCard.mem -= memDmg;
engine.broadcast.push({
type: 'memDamage',
cardId: targetCard.id,
newMem: targetCard.mem,
value: -memDmg,
});
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, sourceCard.id);
player && (player.stats.memDmg += memDmg);
if (targetCard.mem <= 0) {
GameEngineUtils.removeCard(engine, targetCard, sourceCard);
}
};
export const ChangeCpu = (cpuDelta: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
};
export const RaiseMem = (memBonus: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
targetCard.mem += memBonus;
engine.broadcast.push({
type: 'memBonus',
cardId: targetCard.id,
newMem: targetCard.mem,
value: memBonus,
});
};
export const RaiseSec = (secBonus: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.changeSec(engine, targetCard, secBonus, false, sourceCard);
};
export const RedirectIntentRandom: IScriptPart =
(engine, _sourceCard, targetCard) => {
if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;
const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);
|
if (script.targetFinder === CardScript.TargetFinders.Self) return;
|
const targets = script.targetFinder(engine.gameData, targetCard);
if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;
const origTargetId = targetCard.intent.targetCardId;
while (targetCard.intent.targetCardId === origTargetId) {
targetCard.intent.targetCardId = targets.random().id;
}
engine.broadcast.push({
type: 'cardIntent',
cardId: targetCard.id,
intent: targetCard.intent,
});
};
export const RemoveMod = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modName: K, mustRemove = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (mustRemove) {
if (!targetCard.mods.find(x => x[0] === modName)) {
throw new Error(`Could not find [${modName}] to remove`);
}
}
CardMod.removeModByName(engine, targetCard, modName, sourceCard);
};
export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>
(engine, sourceCard, _targetCard) => {
let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);
switch (spawnPosition) {
case 'absLeft': spawnIndex = 0; break;
case 'absRight': spawnIndex = engine.gameData.enemies.length; break;
case 'relRight': spawnIndex++; break;
}
GameEngineUtils.spawnEnemy(engine, enemyClass, spawnIndex, generateIntent);
};
}
|
src/game/card-script-parts.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);\n const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);\n super(\n [minBonus, maxBonus],\n CardScript.TargetFinders.Self,\n [\n {\n targetResolver: CardScript.TargetResolvers.RandomAlly,\n parts: [\n CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),",
"score": 0.8980620503425598
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [secBonus],\n TargetFinders.Any(),\n [\n {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseSec(secBonus),\n ],\n }\n ],",
"score": 0.885341227054596
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Self,\n parts: [\n CardScriptParts.RaiseSec(secBonus),\n CardScriptParts.AddMod(\n new CardMod.Content.firewall(modDuration),\n ),\n ],\n }\n ],",
"score": 0.8813399076461792
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n CardScriptParts.SecDmg(secDelta),\n CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),\n CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),\n ],\n },\n {\n targetResolver: CardScript.TargetResolvers.Self,\n parts: [\n CardScriptParts.RaiseSec(secDelta),",
"score": 0.8747225999832153
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " const script = CardScript.deserialize(engine, enemy, scriptData);\n const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();\n if (!target) {\n return;\n }\n enemy.intent = {\n scriptData,\n targetCardId: target.id,\n };\n engine.broadcast.push({",
"score": 0.8733681440353394
}
] |
typescript
|
if (script.targetFinder === CardScript.TargetFinders.Self) return;
|
import { randInt } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
const _cardMods = {
// Increases incoming damage
exposed: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public stackCount: number) {
super(arguments);
this.stackingConfig.stackCount = stackCount;
}
override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return { secDmgBonus: this.stackingConfig.stackCount };
}
},
// Returns damage to attacker
feedback: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public damage: number) {
super(arguments);
this.stackingConfig.stackCount = damage;
}
override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);
}
},
// Increases CPU
optimized: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(cpuBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = cpuBonus;
}
override onInitMod(deps: CardMod.ICardModDeps) {
GameEngineUtils.changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);
}
override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {
deps.sourceCard.cpu += stackDelta;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
override onRemoveMod(deps: CardMod.ICardModDeps) {
deps.sourceCard.cpu -= this.stackingConfig.stackCount;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
},
// Damages on turn end
virus: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public dot: number) {
super(arguments);
this.stackingConfig.stackCount = dot;
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);
}
},
};
const _cardScripts = {
//
// Backdoor scripts
//
// Swap MEM for CPU
bd_caching: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(-1),
CardScriptParts.ChangeCpu(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise MEM
bd_defrag: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memBonus = 1;
super(
[memBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 4;
}
},
// Heal over time
bd_diagnostics: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const duration = 1 + Math.round(card.mem / 2);
super(
[secBonus, duration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.diagnostics(secBonus, duration)
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Attack and stun (Backdoor finisher)
bd_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const stunDuration = 1;
super(
[damage, stunDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.AddMod(
new CardMod.Content.lag(stunDuration),
),
|
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
|
],
);
this.cooldownMax = 2;
}
},
// Attack and raise CPU on kill
bd_extraction: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Opponents(true)(gameData, card)
.filter(target => !target.sec && target.mem === 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(1, true, true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.ChangeCpu(1),
],
},
],
);
}
},
// Raises CPU
bd_optimize: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Raises SEC
bd_patch: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 2;
}
},
// Steal SEC and remove Firewall (Backdoor finisher)
bd_proxy: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, card.cpu);
super(
[secDelta],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
}
},
// Steal SEC and causes offline (Backdoor finisher)
bd_reboot: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, _card.cpu);
const offlineDuration = 1;
super(
[secDelta, offlineDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 2;
}
},
// Cause Exposed (Backdoor finisher)
bd_trace: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(7, card.cpu);
super(
[stacks],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and remove 1 MEM
bd_tunnel: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memDmg = 1;
super(
[memDmg],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.MemDmg(memDmg),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 3;
}
},
//
// Bruteforce scripts
//
// Swap CPU for MEM
bf_compression: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.ChangeCpu(-1),
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Offline
bf_ddos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const offlineDuration = 1;
super(
[offlineDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Cause Lag
bf_dos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const lagDuration = 1;
super(
[lagDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Gain feedback
bf_feedback: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Triple SEC attack
bf_flood: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(3, card.cpu);
const numAttacks = 3;
super(
[damage, numAttacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
...Array.from(Array(numAttacks)).map(() => CardScriptParts.SecDmg(damage)),
],
}
],
);
this.cooldownMax = 2;
}
},
// AOE attack
bf_multicast: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.TargetAndAdjacents,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC
bf_obfuscate: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 3;
}
},
// Strong attack
bf_pod: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(16, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 2;
}
},
// Raises CPU
bf_precompute: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
//
// Malware scripts
//
// Causes Lag
mw_bloatware: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[1],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(1),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Swap for another card's secondary script
mw_copypaste: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, sourceCard, targetCard) => {
CardScript.removeScript(engine, sourceCard, _cardScripts.mw_copypaste);
if (!targetCard.scripts[1]) return;
CardScript.addScript(engine, sourceCard, CardScript.fromScriptName(engine, sourceCard, targetCard.scripts[1][0]));
},
],
}
],
);
}
},
// Grant Feedback
mw_honeypot: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Steal SEC
mw_leech: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[secDelta],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 1;
}
},
// Attack random target
mw_phishing: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(18, card.cpu);
super(
[minDamage, maxDamage],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomOpponent,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
this.cooldownMax = 1;
}
},
// Redistribute CPU/MEM
mw_reimage: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, _sourceCard, targetCard) => {
const totalStats = targetCard.cpu + targetCard.mem;
const newCpu = randInt(1, totalStats - 1);
const cpuDelta = newCpu - targetCard.cpu;
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
const newMem = totalStats - newCpu;
const memDelta = newMem - targetCard.mem;
GameEngineUtils.changeMem(engine, targetCard, memDelta);
},
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC on random ally
mw_shareware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);
super(
[minBonus, maxBonus],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomAlly,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 3;
}
},
// Redirect intent
mw_spoof: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RedirectIntentRandom,
],
}
],
);
}
},
// Cause Exposed
mw_spyware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[stacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Virus
mw_virus: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const dot = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[dot],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.virus(dot),
),
],
}
],
);
this.cooldownMax = 2;
}
},
};
export const GameContent_v1 = {
cardMods: _cardMods,
cardScripts: _cardScripts,
enemyCards: {},
initGame(_engine: GameEngine.IGameEngine) {
throw new Error('not a startable scenario');
},
addAdditionalScriptsFor(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState) {
if (card.card.tier < 2) return;
switch (card.card.faction) {
case 'backdoor':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bd_')).random()]).serialize());
return;
case 'bruteforce':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bf_')).random()]).serialize());
return;
case 'malware':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('mw_')).random()]).serialize());
return;
}
},
};
(GameContent_v1 as GameEngine.IRuleset);
|
src/game/game-content-v1.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts._TargetHasMod<typeof CardMod.Content, 'backdoor'>('backdoor', mod => CardScriptParts.SecDmg(mod.stackingConfig.rank, true)),\n CardScriptParts.Attack(damage),\n CardScriptParts._Chance(bdChance,\n CardScriptParts.AddMod(\n new CardMod.Content.backdoor(damage),\n )\n ),",
"score": 0.9294671416282654
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [\n {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.Attack(damage),\n CardScriptParts.Attack(damage),\n ],\n }\n ]\n );",
"score": 0.9145592451095581
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " targetResolver: CardScript.TargetResolvers.Self,\n parts: [\n CardScriptParts._Chance(lagChance,\n CardScriptParts.AddMod(\n new CardMod.Content.lag(lagDuration),\n ),\n ),\n ],\n }\n ],",
"score": 0.9098027944564819
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new CardMod.Content.secured(tempSecBonus, duration),\n ),\n CardScriptParts.AddMod(\n new CardMod.Content.firewall(duration),\n ),\n ],",
"score": 0.9036681652069092
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new CardMod.Content.firewall(duration + 1),\n ),\n ],\n }\n ],\n );",
"score": 0.9004737734794617
}
] |
typescript
|
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
|
import { randInt } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
const _cardMods = {
// Increases incoming damage
exposed: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public stackCount: number) {
super(arguments);
this.stackingConfig.stackCount = stackCount;
}
override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return { secDmgBonus: this.stackingConfig.stackCount };
}
},
// Returns damage to attacker
feedback: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public damage: number) {
super(arguments);
this.stackingConfig.stackCount = damage;
}
override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);
}
},
// Increases CPU
optimized: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(cpuBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = cpuBonus;
}
override onInitMod(deps: CardMod.ICardModDeps) {
GameEngineUtils.
|
changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);
|
}
override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {
deps.sourceCard.cpu += stackDelta;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
override onRemoveMod(deps: CardMod.ICardModDeps) {
deps.sourceCard.cpu -= this.stackingConfig.stackCount;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
},
// Damages on turn end
virus: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public dot: number) {
super(arguments);
this.stackingConfig.stackCount = dot;
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);
}
},
};
const _cardScripts = {
//
// Backdoor scripts
//
// Swap MEM for CPU
bd_caching: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(-1),
CardScriptParts.ChangeCpu(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise MEM
bd_defrag: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memBonus = 1;
super(
[memBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 4;
}
},
// Heal over time
bd_diagnostics: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const duration = 1 + Math.round(card.mem / 2);
super(
[secBonus, duration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.diagnostics(secBonus, duration)
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Attack and stun (Backdoor finisher)
bd_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const stunDuration = 1;
super(
[damage, stunDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.AddMod(
new CardMod.Content.lag(stunDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and raise CPU on kill
bd_extraction: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Opponents(true)(gameData, card)
.filter(target => !target.sec && target.mem === 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(1, true, true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.ChangeCpu(1),
],
},
],
);
}
},
// Raises CPU
bd_optimize: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Raises SEC
bd_patch: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 2;
}
},
// Steal SEC and remove Firewall (Backdoor finisher)
bd_proxy: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, card.cpu);
super(
[secDelta],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
}
},
// Steal SEC and causes offline (Backdoor finisher)
bd_reboot: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, _card.cpu);
const offlineDuration = 1;
super(
[secDelta, offlineDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 2;
}
},
// Cause Exposed (Backdoor finisher)
bd_trace: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(7, card.cpu);
super(
[stacks],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and remove 1 MEM
bd_tunnel: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memDmg = 1;
super(
[memDmg],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.MemDmg(memDmg),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 3;
}
},
//
// Bruteforce scripts
//
// Swap CPU for MEM
bf_compression: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.ChangeCpu(-1),
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Offline
bf_ddos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const offlineDuration = 1;
super(
[offlineDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Cause Lag
bf_dos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const lagDuration = 1;
super(
[lagDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Gain feedback
bf_feedback: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Triple SEC attack
bf_flood: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(3, card.cpu);
const numAttacks = 3;
super(
[damage, numAttacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
...Array.from(Array(numAttacks)).map(() => CardScriptParts.SecDmg(damage)),
],
}
],
);
this.cooldownMax = 2;
}
},
// AOE attack
bf_multicast: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.TargetAndAdjacents,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC
bf_obfuscate: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 3;
}
},
// Strong attack
bf_pod: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(16, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 2;
}
},
// Raises CPU
bf_precompute: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
//
// Malware scripts
//
// Causes Lag
mw_bloatware: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[1],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(1),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Swap for another card's secondary script
mw_copypaste: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, sourceCard, targetCard) => {
CardScript.removeScript(engine, sourceCard, _cardScripts.mw_copypaste);
if (!targetCard.scripts[1]) return;
CardScript.addScript(engine, sourceCard, CardScript.fromScriptName(engine, sourceCard, targetCard.scripts[1][0]));
},
],
}
],
);
}
},
// Grant Feedback
mw_honeypot: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Steal SEC
mw_leech: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[secDelta],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 1;
}
},
// Attack random target
mw_phishing: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(18, card.cpu);
super(
[minDamage, maxDamage],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomOpponent,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
this.cooldownMax = 1;
}
},
// Redistribute CPU/MEM
mw_reimage: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, _sourceCard, targetCard) => {
const totalStats = targetCard.cpu + targetCard.mem;
const newCpu = randInt(1, totalStats - 1);
const cpuDelta = newCpu - targetCard.cpu;
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
const newMem = totalStats - newCpu;
const memDelta = newMem - targetCard.mem;
GameEngineUtils.changeMem(engine, targetCard, memDelta);
},
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC on random ally
mw_shareware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);
super(
[minBonus, maxBonus],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomAlly,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 3;
}
},
// Redirect intent
mw_spoof: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RedirectIntentRandom,
],
}
],
);
}
},
// Cause Exposed
mw_spyware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[stacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Virus
mw_virus: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const dot = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[dot],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.virus(dot),
),
],
}
],
);
this.cooldownMax = 2;
}
},
};
export const GameContent_v1 = {
cardMods: _cardMods,
cardScripts: _cardScripts,
enemyCards: {},
initGame(_engine: GameEngine.IGameEngine) {
throw new Error('not a startable scenario');
},
addAdditionalScriptsFor(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState) {
if (card.card.tier < 2) return;
switch (card.card.faction) {
case 'backdoor':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bd_')).random()]).serialize());
return;
case 'bruteforce':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bf_')).random()]).serialize());
return;
case 'malware':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('mw_')).random()]).serialize());
return;
}
},
};
(GameContent_v1 as GameEngine.IRuleset);
|
src/game/game-content-v1.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " };\n constructor(public tempSecBonus: number, override duration: number) {\n super(arguments);\n this.stackingConfig.stackCount = tempSecBonus;\n }\n override onInitMod(deps: ICardModDeps) {\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);\n }\n override onStackMod(deps: ICardModDeps, stackDelta: number): void {\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, stackDelta, false);",
"score": 0.9352520704269409
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " override stackingConfig = {\n behavior: CardMod.StackingBehavior.ranked as const,\n rank: 0,\n };\n constructor(override duration: number) {\n super(arguments);\n this.stackingConfig.rank = duration;\n }\n override onInitMod(deps: ICardModDeps) {\n if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {",
"score": 0.9289489984512329
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " };\n constructor(public secBonus: number, override duration: number) {\n super(arguments);\n this.stackingConfig.stackCount = secBonus;\n }\n override onTurnEnd(deps: ICardModDeps): void {\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);\n }\n }\n export class firewall extends CardMod {",
"score": 0.899732232093811
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": "import { CardScript } from './card-scripts';\nimport { GameEngine } from './game-engine';\nimport { GameEngineUtils } from './game-engine-utils';\nexport abstract class CardMod {\n duration = -1;\n stackingConfig: Parameters<typeof CardMod['makeStackingData']>[0] = { behavior: CardMod.StackingBehavior.neverReplace };\n readonly modName: string;\n constructor(\n private _extraModData?: IArguments,\n ) {",
"score": 0.8854792714118958
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " | { behavior: CardMod.StackingBehavior.replace }\n | { behavior: CardMod.StackingBehavior.stack, stackCount: number }\n ) {\n const stackingData = ['$stack', stackConfig.behavior];\n (stackConfig.behavior === CardMod.StackingBehavior.ranked) && stackingData.push(stackConfig.rank);\n (stackConfig.behavior === CardMod.StackingBehavior.stack) && stackingData.push(stackConfig.stackCount);\n return stackingData as CardMod.StackingData;\n }\n static removeMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modData: CardMod.ModData, contextCard?: GameEngine.ICardState) {\n engine.broadcast.push({",
"score": 0.8734970092773438
}
] |
typescript
|
changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);
|
import { CoreScriptNames } from '../appraise';
import { IPlayerPushProvider } from '../dependencies';
import { randInt, round } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export class CardScript {
cooldownMax = -1;
cooldownCur = 0;
readonly scriptName: string;
constructor(
private _extraScriptData: unknown[],
public targetFinder: CardScript.ITargetFinder,
public targetScriptParts: { targetResolver: CardScript.ITargetResolver, parts: CardScriptParts.IScriptPart[] }[],
) {
this.scriptName = this.constructor.name;
}
serialize() {
const retVal = [this.scriptName, ...this._extraScriptData] as CardScript.ScriptData;
(this.cooldownCur > 0 || this.cooldownMax > 0) && retVal.push(CardScript.makeCooldownData(this.cooldownMax, this.cooldownCur));
return retVal;
}
static addScript(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptData: CardScript.ScriptData) {
card.scripts.push(scriptData);
engine.broadcast.push({
type: 'scriptAdded',
cardId: card.id,
scriptData,
});
}
static areEqual(left: CardScript.ScriptData, right: CardScript.ScriptData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptData: CardScript.ScriptData) {
const scriptCtor = engine.ruleset.cardScripts?.[scriptData[0]];
if (!scriptCtor) throw new Error('script not found: ' + scriptData.join());
const script = new scriptCtor(card, ...scriptData.slice(1));
const cooldownData = CardScript.findCooldownData(scriptData);
if (cooldownData) {
script.cooldownCur = cooldownData[1];
script.cooldownMax = cooldownData[2];
}
return script;
}
static execute(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, sourceCardScript: CardScript.ScriptData, targetCard: GameEngine.ICardState) {
engine.broadcast.push({
type: 'cardExecuting',
cardId: sourceCard.id,
targetCardId: targetCard.id,
scriptData: sourceCardScript,
});
if (this.isOnCooldown(sourceCardScript)) {
throw new Error('Script is on cooldown: ' + sourceCardScript.join());
}
const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript));
const isEnemy = GameEngineUtils.isEnemyCard(engine.gameData, sourceCard);
if (!isEnemy) {
if (!scriptDataFromCard) {
throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());
}
}
const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);
if (cooldownData) {
cooldownData[1] = cooldownData[2] + 1;
}
const script = this.deserialize(engine, sourceCard, sourceCardScript);
const targets = script.targetFinder(engine.gameData, sourceCard);
if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {
throw new Error('Invalid target ' + targets.map(x => x.id).join());
}
for (const pair of script.targetScriptParts) {
const resolvedTargets = pair.targetResolver(engine.gameData, sourceCard, targetCard);
for (const part of pair.parts) {
for (const resolvedTarget of resolvedTargets) {
if (resolvedTarget.isRemoved) continue;
part(engine, sourceCard, resolvedTarget);
}
}
}
engine.broadcast.push({
type: 'cardExecuted',
cardId: sourceCard.id,
targetCardId: targetCard.id,
scriptData: scriptDataFromCard || sourceCardScript,
});
}
static findCooldownData(data: CardScript.ScriptData) {
return data.find((x): x is CardScript.CooldownData => Array.isArray(x) && x[0] === '$cooldown');
}
static fromScriptName(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptName: string) {
return this.deserialize(engine, card, [scriptName]).serialize();
}
static isOnCooldown(data: CardScript.ScriptData) {
return (this.findCooldownData(data)?.[1] || 0) > 0;
}
static makeCooldownData(max: number, cur = 0): CardScript.CooldownData {
return ['$cooldown', cur, max];
}
static removeScript(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptType: CardScript.ScriptConstructor) {
const removed = card.scripts.findAndRemoveFirst(x => x[0] === scriptType.name);
if (!removed) throw new Error('script not found: ' + scriptType.name);
engine.broadcast.push({
type: 'scriptRemoved',
cardId: card.id,
removedScript: scriptType.name,
});
}
static tickCooldowns(card: GameEngine.ICardState, broadcast: IPlayerPushProvider.IPushMessage[]) {
for (const script of card.scripts) {
const cooldownData = CardScript.findCooldownData(script);
if (!cooldownData?.[1]) {
continue;
}
cooldownData[1]--;
broadcast.push({
type: 'scriptChanged',
cardId: card.id,
scriptData: script,
});
}
}
}
export namespace CardScript {
export type ScriptData = [string, ...unknown[]];
export type CooldownData = ['$cooldown', number, number];
export type ScriptConstructor = { new(card: GameEngine.ICardState, ...args: any[]): CardScript };
export type ScriptLibrary = Record<string, ScriptConstructor>;
export interface ITargetResolver {
(gameData: GameEngine.IGameData, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): GameEngine.ICardState[];
}
export interface ITargetFinder {
(gameData: GameEngine.IGameData, card: GameEngine.ICardState): GameEngine.ICardState[];
}
export namespace TargetResolvers {
export const Self: ITargetResolver = (_, sourceCard) => [sourceCard];
export const Target: ITargetResolver = (_, _2, targetCard) => [targetCard];
export const TargetAndAdjacents: ITargetResolver = (gameData, _, targetCard) => {
const cards = GameEngineUtils.isEnemyCard(gameData, targetCard) ? gameData.enemies : (GameEngineUtils.findPlayerByCardId(gameData, targetCard.id).cards);
const i = cards.findIndex(x => x.id === targetCard.id);
return [cards[i], cards[i - 1], cards[i + 1]].filter(Boolean);
};
export const AllAllies: ITargetResolver = (gameData, sourceCard) => {
if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {
return TargetFinders._excludeOffline(gameData.enemies);
} else {
return TargetFinders._excludeOffline(GameEngineUtils.getPlayerCards(gameData));
}
};
export const RandomAlly: ITargetResolver = (gameData, sourceCard, targetCard) => {
return [AllAllies(gameData, sourceCard, targetCard).random()];
};
export const AllOpponents: ITargetResolver = (gameData, sourceCard) => {
if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {
return TargetFinders._excludeImperviousAndOffline(GameEngineUtils.getPlayerCards(gameData));
} else {
return TargetFinders._excludeImperviousAndOffline(gameData.enemies);
}
};
export const RandomOpponent: ITargetResolver = (gameData, sourceCard, targetCard) => {
return TargetFinders._excludeImperviousAndOffline([AllOpponents(gameData, sourceCard, targetCard).random()]);
};
}
export namespace TargetFinders {
export const Self: ITargetFinder = (_gameData, card) => [card];
export const Allies = (excludeSelf = false): ITargetFinder =>
(gameData, card) => {
let targets: GameEngine.ICardState[] = GameEngineUtils.isEnemyCard(gameData, card) ? gameData.enemies : GameEngineUtils.getPlayerCards(gameData);
excludeSelf && (targets = targets.filter(x => x.id !== card.id));
return _excludeOffline(targets);
};
export const Opponents = (ignoreTaunt = false): ITargetFinder =>
(gameData, card) => {
const targets = GameEngineUtils.isEnemyCard(gameData, card) ? GameEngineUtils.getPlayerCards(gameData) : gameData.enemies;
const standardTargets = _excludeImperviousAndOffline(targets);
if (!ignoreTaunt) {
const taunts = _filterForFirewall(standardTargets);
if (taunts.length) {
return taunts;
}
}
return standardTargets;
};
export const Any = (ignoreTaunt = false): ITargetFinder =>
(gameData, card) => [
...Opponents(ignoreTaunt)(gameData, card),
...Allies()(gameData, card),
];
export const _ModFilter = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modFilter: K[], targetFinder: ITargetFinder): ITargetFinder =>
(gameData, card) => {
const targets = targetFinder(gameData, card);
const modMatches = targets.filter(target => target.mods.find(modData => modFilter.find(x => x === modData[0])));
return _excludeImperviousAndOffline(modMatches);
};
const _excludeImpervious = (cards: GameEngine.ICardState[]) => {
return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.impervious.name));
};
export const _excludeOffline = (cards: GameEngine.ICardState[]) => {
return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.offline.name));
};
export const _excludeImperviousAndOffline = (cards: GameEngine.ICardState[]) => _excludeImpervious(_excludeOffline(cards));
const _filterForFirewall = (cards: GameEngine.ICardState[]) => {
return cards.filter(x => x.mods.find(y => y[0] === CardMod.Content.firewall.name));
};
}
export namespace Content {
// Defines a card script - the class name is treated as the script name
export class bd_decode extends CardScript {
constructor(
// MUST always be the first parameter even if not used
card: GameEngine.ICardState,
// Not used but declared to show how the memo is passed back here, see first argument in super(...) below
_secDamage: number,
) {
const secDamage = GameEngineUtils.scaleByCpuMem(12, card.cpu);
const bdChance = round(GameEngineUtils.scaleByCpuMem(20, card.mem, 'high') / 100, 2);
const bdDamage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
// Any extra data to serialize into scriptData[1:] as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display potential card effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI scripts
[secDamage, bdChance, bdDamage],
// Which cards are valid targets for this card; AI will typically .random()
TargetFinders.Opponents(),
// A composition of CardScriptParts that get executed when this card is played; this allows for
// composition effects such as "((damage and debuff) to target) AND (chance to stun neighbors)":
// The first part would use the Target resolver and Attack and ApplyMod parts
// The second part would use the Neighbors resolver and curry Stun part into _Chance part
[
{
// Given a chosen target, which actual targets these parts will execute on; this allows
// a card to, for example, deal damage to the neighbors of the specified target
targetResolver: TargetResolvers.Target,
// CardScriptParts to execute on the resolved targets
parts: [
CardScriptParts.SecDmg(secDamage),
CardScriptParts._Chance(bdChance,
CardScriptParts.AddMod(
new CardMod.Content.backdoor(bdDamage),
)
),
],
}
],
);
}
}
export class bd_exploit extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const bdChance = round(GameEngineUtils.scaleByCpuMem(40, card.mem, 'more') / 100, 2);
super(
[damage, bdChance],
(gameData: GameEngine.IGameData, card: GameEngine.ICardState) => [
...TargetFinders.Opponents()(gameData, card),
...TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
TargetFinders.Opponents(true))(gameData, card),
],
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts._TargetHasMod<typeof CardMod.Content, 'backdoor'>('backdoor', mod => CardScriptParts.SecDmg(mod.stackingConfig.rank, true)),
CardScriptParts.Attack(damage),
CardScriptParts._Chance(bdChance,
CardScriptParts.AddMod(
new CardMod.Content.backdoor(damage),
)
),
],
}
],
);
}
}
export class bd_secure extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
TargetFinders.Any(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 1;
}
}
export class bf_spam extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[damage],
TargetFinders.Opponents(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.Attack(damage),
],
}
]
);
}
}
export class bf_firewall extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const modDuration = Math.ceil(card.mem / 2);
super(
[secBonus, modDuration],
TargetFinders.Self,
[
{
targetResolver: TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secBonus),
CardScriptParts.AddMod(
new CardMod.Content.firewall(modDuration),
),
],
}
],
);
this.cooldownMax = 1;
}
}
export class bf_overclock extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(17, card.cpu);
const lagChance = round((100 - GameEngineUtils.scaleByCpuMem(30, card.mem)) / 100, 2);
const lagDuration = 2;
super(
[damage, lagChance, lagDuration],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts._Chance(lagChance,
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
),
],
}
],
);
}
}
export class mw_freeware extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(12, card.cpu, 'more');
super(
[minBonus, maxBonus],
TargetFinders.Any(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec
|
(randInt(minBonus, maxBonus)),
],
}
|
],
);
this.cooldownMax = 1;
}
}
export class mw_redirect extends CardScript {
constructor(card: GameEngine.ICardState) {
const tempSecBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const duration = Math.ceil(card.mem / 2);
super(
[tempSecBonus, duration],
TargetFinders.Allies(true),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.secured(tempSecBonus, duration),
),
CardScriptParts.AddMod(
new CardMod.Content.firewall(duration),
),
],
}
],
);
this.cooldownMax = 1;
}
}
export class mw_worm extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(7, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(13, card.cpu);
super(
[minDamage, maxDamage],
TargetFinders.Opponents(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
}
}
export class _attack extends CardScript {
constructor(card: GameEngine.ICardState, difficulty: number, strength: 'weak' | 'normal' | 'strong' = 'normal', cooldown = 0) {
let minDmg = 0;
let maxDmg = 0;
switch (strength) {
case 'weak':
minDmg = GameEngineUtils.scaleByCpuMem(6, card.cpu);
maxDmg = GameEngineUtils.scaleByCpuMem(8, card.cpu);
break;
case 'normal':
minDmg = GameEngineUtils.scaleByCpuMem(8, card.cpu);
maxDmg = GameEngineUtils.scaleByCpuMem(12, card.cpu);
break;
case 'strong':
minDmg = GameEngineUtils.scaleByCpuMem(11, card.cpu);
maxDmg = GameEngineUtils.scaleByCpuMem(15, card.cpu);
break;
}
minDmg = GameEngineUtils.scaleByDifficulty(minDmg, difficulty);
maxDmg = GameEngineUtils.scaleByDifficulty(maxDmg, difficulty);
super(
[difficulty, strength, cooldown, minDmg, maxDmg],
TargetFinders.Opponents(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.Attack(randInt(minDmg, maxDmg)),
],
}
],
);
this.cooldownMax = cooldown;
}
}
export class _defend extends CardScript {
constructor(card: GameEngine.ICardState, difficulty: number, strength: 'weak' | 'normal' | 'strong' = 'normal', cooldown = 0) {
let minBonus = 0;
let maxBonus = 0;
switch (strength) {
case 'weak':
minBonus = GameEngineUtils.scaleByCpuMem(4, card.cpu);
maxBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
break;
case 'normal':
minBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
maxBonus = GameEngineUtils.scaleByCpuMem(8, card.cpu);
break;
case 'strong':
minBonus = GameEngineUtils.scaleByCpuMem(8, card.cpu);
maxBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
break;
}
minBonus = GameEngineUtils.scaleByDifficulty(minBonus, difficulty);
maxBonus = GameEngineUtils.scaleByDifficulty(maxBonus, difficulty);
super(
[difficulty, strength, cooldown, minBonus, maxBonus],
TargetFinders.Allies(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = cooldown;
}
}
export class _firewallSelf extends CardScript {
constructor(_card: GameEngine.ICardState, duration = 1, cooldown = 0, startingCooldown = 0) {
super(
[duration, cooldown],
TargetFinders.Self,
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.firewall(duration + 1),
),
],
}
],
);
this.cooldownCur = startingCooldown;
this.cooldownMax = cooldown;
}
}
export class _spawn extends CardScript {
constructor(_card: GameEngine.ICardState, enemyClass: string, spawnPosition: Parameters<typeof CardScriptParts['SpawnEnemy']>[1] = 'relLeft', generateIntent = false, cooldown = 0) {
super(
[enemyClass, spawnPosition, generateIntent, cooldown],
TargetFinders.Self,
[
{
targetResolver: TargetResolvers.Self,
parts: [
CardScriptParts.SpawnEnemy(enemyClass, spawnPosition, generateIntent),
],
}
],
);
this.cooldownMax = cooldown;
}
}
}
(Content as Record<CoreScriptNames, ScriptConstructor>);
}
|
src/game/card-scripts.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);\n const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);\n super(\n [minBonus, maxBonus],\n CardScript.TargetFinders.Self,\n [\n {\n targetResolver: CardScript.TargetResolvers.RandomAlly,\n parts: [\n CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),",
"score": 0.8978840112686157
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [memBonus],\n CardScript.TargetFinders.Any(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseMem(1),\n ],\n }\n ],",
"score": 0.8856823444366455
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [secBonus, duration],\n CardScript.TargetFinders.Any(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new CardMod.Content.diagnostics(secBonus, duration)\n ),\n ],",
"score": 0.8730269074440002
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " cardId: targetCard.id,\n newMem: targetCard.mem,\n value: memBonus,\n });\n };\n export const RaiseSec = (secBonus: number): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n GameEngineUtils.changeSec(engine, targetCard, secBonus, false, sourceCard);\n };\n export const RedirectIntentRandom: IScriptPart =",
"score": 0.8614636063575745
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " super(\n [],\n CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.RedirectIntentRandom,\n ],\n }",
"score": 0.8580030202865601
}
] |
typescript
|
(randInt(minBonus, maxBonus)),
],
}
|
import { CoreScriptNames } from '../appraise';
import { IPlayerPushProvider } from '../dependencies';
import { randInt, round } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export class CardScript {
cooldownMax = -1;
cooldownCur = 0;
readonly scriptName: string;
constructor(
private _extraScriptData: unknown[],
public targetFinder: CardScript.ITargetFinder,
public targetScriptParts: { targetResolver: CardScript.ITargetResolver, parts: CardScriptParts.IScriptPart[] }[],
) {
this.scriptName = this.constructor.name;
}
serialize() {
const retVal = [this.scriptName, ...this._extraScriptData] as CardScript.ScriptData;
(this.cooldownCur > 0 || this.cooldownMax > 0) && retVal.push(CardScript.makeCooldownData(this.cooldownMax, this.cooldownCur));
return retVal;
}
static addScript(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptData: CardScript.ScriptData) {
card.scripts.push(scriptData);
engine.broadcast.push({
type: 'scriptAdded',
cardId: card.id,
scriptData,
});
}
static areEqual(left: CardScript.ScriptData, right: CardScript.ScriptData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptData: CardScript.ScriptData) {
const scriptCtor = engine.ruleset.cardScripts?.[scriptData[0]];
if (!scriptCtor) throw new Error('script not found: ' + scriptData.join());
const script = new scriptCtor(card, ...scriptData.slice(1));
const cooldownData = CardScript.findCooldownData(scriptData);
if (cooldownData) {
script.cooldownCur = cooldownData[1];
script.cooldownMax = cooldownData[2];
}
return script;
}
static execute(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, sourceCardScript: CardScript.ScriptData, targetCard: GameEngine.ICardState) {
engine.broadcast.push({
type: 'cardExecuting',
cardId: sourceCard.id,
targetCardId: targetCard.id,
scriptData: sourceCardScript,
});
if (this.isOnCooldown(sourceCardScript)) {
throw new Error('Script is on cooldown: ' + sourceCardScript.join());
}
const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript));
const isEnemy = GameEngineUtils.isEnemyCard(engine.gameData, sourceCard);
if (!isEnemy) {
if (!scriptDataFromCard) {
throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());
}
}
const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);
if (cooldownData) {
cooldownData[1] = cooldownData[2] + 1;
}
const script = this.deserialize(engine, sourceCard, sourceCardScript);
const targets = script.targetFinder(engine.gameData, sourceCard);
if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {
throw new Error('Invalid target ' + targets.map(x => x.id).join());
}
for (const pair of script.targetScriptParts) {
const resolvedTargets = pair.targetResolver(engine.gameData, sourceCard, targetCard);
for (const part of pair.parts) {
for (const resolvedTarget of resolvedTargets) {
if (resolvedTarget.isRemoved) continue;
part(engine, sourceCard, resolvedTarget);
}
}
}
engine.broadcast.push({
type: 'cardExecuted',
cardId: sourceCard.id,
targetCardId: targetCard.id,
scriptData: scriptDataFromCard || sourceCardScript,
});
}
static findCooldownData(data: CardScript.ScriptData) {
return data.find((x): x is CardScript.CooldownData => Array.isArray(x) && x[0] === '$cooldown');
}
static fromScriptName(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptName: string) {
return this.deserialize(engine, card, [scriptName]).serialize();
}
static isOnCooldown(data: CardScript.ScriptData) {
return (this.findCooldownData(data)?.[1] || 0) > 0;
}
static makeCooldownData(max: number, cur = 0): CardScript.CooldownData {
return ['$cooldown', cur, max];
}
static removeScript(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptType: CardScript.ScriptConstructor) {
const removed = card.scripts.findAndRemoveFirst(x => x[0] === scriptType.name);
if (!removed) throw new Error('script not found: ' + scriptType.name);
engine.broadcast.push({
type: 'scriptRemoved',
cardId: card.id,
removedScript: scriptType.name,
});
}
static tickCooldowns(card: GameEngine.ICardState, broadcast: IPlayerPushProvider.IPushMessage[]) {
for (const script of card.scripts) {
const cooldownData = CardScript.findCooldownData(script);
if (!cooldownData?.[1]) {
continue;
}
cooldownData[1]--;
broadcast.push({
type: 'scriptChanged',
cardId: card.id,
scriptData: script,
});
}
}
}
export namespace CardScript {
export type ScriptData = [string, ...unknown[]];
export type CooldownData = ['$cooldown', number, number];
export type ScriptConstructor = { new(card: GameEngine.ICardState, ...args: any[]): CardScript };
export type ScriptLibrary = Record<string, ScriptConstructor>;
export interface ITargetResolver {
(gameData: GameEngine.IGameData, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): GameEngine.ICardState[];
}
export interface ITargetFinder {
(gameData: GameEngine.IGameData, card: GameEngine.ICardState): GameEngine.ICardState[];
}
export namespace TargetResolvers {
export const Self: ITargetResolver = (_, sourceCard) => [sourceCard];
export const Target: ITargetResolver = (_, _2, targetCard) => [targetCard];
export const TargetAndAdjacents: ITargetResolver = (gameData, _, targetCard) => {
const cards = GameEngineUtils.isEnemyCard(gameData, targetCard) ? gameData.enemies : (GameEngineUtils.findPlayerByCardId(gameData, targetCard.id).cards);
const i = cards.findIndex(x => x.id === targetCard.id);
return [cards[i], cards[i - 1], cards[i + 1]].filter(Boolean);
};
export const AllAllies: ITargetResolver = (gameData, sourceCard) => {
if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {
return TargetFinders._excludeOffline(gameData.enemies);
} else {
return TargetFinders._excludeOffline(GameEngineUtils.getPlayerCards(gameData));
}
};
export const RandomAlly: ITargetResolver = (gameData, sourceCard, targetCard) => {
return [AllAllies(gameData, sourceCard, targetCard).random()];
};
export const AllOpponents: ITargetResolver = (gameData, sourceCard) => {
if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {
return TargetFinders._excludeImperviousAndOffline(GameEngineUtils.getPlayerCards(gameData));
} else {
return TargetFinders._excludeImperviousAndOffline(gameData.enemies);
}
};
export const RandomOpponent: ITargetResolver = (gameData, sourceCard, targetCard) => {
return TargetFinders._excludeImperviousAndOffline([AllOpponents(gameData, sourceCard, targetCard).random()]);
};
}
export namespace TargetFinders {
export const Self: ITargetFinder = (_gameData, card) => [card];
export const Allies = (excludeSelf = false): ITargetFinder =>
(gameData, card) => {
let targets: GameEngine.ICardState[] = GameEngineUtils.isEnemyCard(gameData, card) ? gameData.enemies : GameEngineUtils.getPlayerCards(gameData);
excludeSelf && (targets = targets.filter(x => x.id !== card.id));
return _excludeOffline(targets);
};
export const Opponents = (ignoreTaunt = false): ITargetFinder =>
(gameData, card) => {
const targets = GameEngineUtils.isEnemyCard(gameData, card) ? GameEngineUtils.getPlayerCards(gameData) : gameData.enemies;
const standardTargets = _excludeImperviousAndOffline(targets);
if (!ignoreTaunt) {
const taunts = _filterForFirewall(standardTargets);
if (taunts.length) {
return taunts;
}
}
return standardTargets;
};
export const Any = (ignoreTaunt = false): ITargetFinder =>
(gameData, card) => [
...Opponents(ignoreTaunt)(gameData, card),
...Allies()(gameData, card),
];
export const _ModFilter = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modFilter: K[], targetFinder: ITargetFinder): ITargetFinder =>
(gameData, card) => {
const targets = targetFinder(gameData, card);
const modMatches = targets
|
.filter(target => target.mods.find(modData => modFilter.find(x => x === modData[0])));
|
return _excludeImperviousAndOffline(modMatches);
};
const _excludeImpervious = (cards: GameEngine.ICardState[]) => {
return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.impervious.name));
};
export const _excludeOffline = (cards: GameEngine.ICardState[]) => {
return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.offline.name));
};
export const _excludeImperviousAndOffline = (cards: GameEngine.ICardState[]) => _excludeImpervious(_excludeOffline(cards));
const _filterForFirewall = (cards: GameEngine.ICardState[]) => {
return cards.filter(x => x.mods.find(y => y[0] === CardMod.Content.firewall.name));
};
}
export namespace Content {
// Defines a card script - the class name is treated as the script name
export class bd_decode extends CardScript {
constructor(
// MUST always be the first parameter even if not used
card: GameEngine.ICardState,
// Not used but declared to show how the memo is passed back here, see first argument in super(...) below
_secDamage: number,
) {
const secDamage = GameEngineUtils.scaleByCpuMem(12, card.cpu);
const bdChance = round(GameEngineUtils.scaleByCpuMem(20, card.mem, 'high') / 100, 2);
const bdDamage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
// Any extra data to serialize into scriptData[1:] as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display potential card effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI scripts
[secDamage, bdChance, bdDamage],
// Which cards are valid targets for this card; AI will typically .random()
TargetFinders.Opponents(),
// A composition of CardScriptParts that get executed when this card is played; this allows for
// composition effects such as "((damage and debuff) to target) AND (chance to stun neighbors)":
// The first part would use the Target resolver and Attack and ApplyMod parts
// The second part would use the Neighbors resolver and curry Stun part into _Chance part
[
{
// Given a chosen target, which actual targets these parts will execute on; this allows
// a card to, for example, deal damage to the neighbors of the specified target
targetResolver: TargetResolvers.Target,
// CardScriptParts to execute on the resolved targets
parts: [
CardScriptParts.SecDmg(secDamage),
CardScriptParts._Chance(bdChance,
CardScriptParts.AddMod(
new CardMod.Content.backdoor(bdDamage),
)
),
],
}
],
);
}
}
export class bd_exploit extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const bdChance = round(GameEngineUtils.scaleByCpuMem(40, card.mem, 'more') / 100, 2);
super(
[damage, bdChance],
(gameData: GameEngine.IGameData, card: GameEngine.ICardState) => [
...TargetFinders.Opponents()(gameData, card),
...TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
TargetFinders.Opponents(true))(gameData, card),
],
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts._TargetHasMod<typeof CardMod.Content, 'backdoor'>('backdoor', mod => CardScriptParts.SecDmg(mod.stackingConfig.rank, true)),
CardScriptParts.Attack(damage),
CardScriptParts._Chance(bdChance,
CardScriptParts.AddMod(
new CardMod.Content.backdoor(damage),
)
),
],
}
],
);
}
}
export class bd_secure extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
TargetFinders.Any(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 1;
}
}
export class bf_spam extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[damage],
TargetFinders.Opponents(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.Attack(damage),
],
}
]
);
}
}
export class bf_firewall extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const modDuration = Math.ceil(card.mem / 2);
super(
[secBonus, modDuration],
TargetFinders.Self,
[
{
targetResolver: TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secBonus),
CardScriptParts.AddMod(
new CardMod.Content.firewall(modDuration),
),
],
}
],
);
this.cooldownMax = 1;
}
}
export class bf_overclock extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(17, card.cpu);
const lagChance = round((100 - GameEngineUtils.scaleByCpuMem(30, card.mem)) / 100, 2);
const lagDuration = 2;
super(
[damage, lagChance, lagDuration],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts._Chance(lagChance,
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
),
],
}
],
);
}
}
export class mw_freeware extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(12, card.cpu, 'more');
super(
[minBonus, maxBonus],
TargetFinders.Any(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 1;
}
}
export class mw_redirect extends CardScript {
constructor(card: GameEngine.ICardState) {
const tempSecBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const duration = Math.ceil(card.mem / 2);
super(
[tempSecBonus, duration],
TargetFinders.Allies(true),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.secured(tempSecBonus, duration),
),
CardScriptParts.AddMod(
new CardMod.Content.firewall(duration),
),
],
}
],
);
this.cooldownMax = 1;
}
}
export class mw_worm extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(7, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(13, card.cpu);
super(
[minDamage, maxDamage],
TargetFinders.Opponents(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
}
}
export class _attack extends CardScript {
constructor(card: GameEngine.ICardState, difficulty: number, strength: 'weak' | 'normal' | 'strong' = 'normal', cooldown = 0) {
let minDmg = 0;
let maxDmg = 0;
switch (strength) {
case 'weak':
minDmg = GameEngineUtils.scaleByCpuMem(6, card.cpu);
maxDmg = GameEngineUtils.scaleByCpuMem(8, card.cpu);
break;
case 'normal':
minDmg = GameEngineUtils.scaleByCpuMem(8, card.cpu);
maxDmg = GameEngineUtils.scaleByCpuMem(12, card.cpu);
break;
case 'strong':
minDmg = GameEngineUtils.scaleByCpuMem(11, card.cpu);
maxDmg = GameEngineUtils.scaleByCpuMem(15, card.cpu);
break;
}
minDmg = GameEngineUtils.scaleByDifficulty(minDmg, difficulty);
maxDmg = GameEngineUtils.scaleByDifficulty(maxDmg, difficulty);
super(
[difficulty, strength, cooldown, minDmg, maxDmg],
TargetFinders.Opponents(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.Attack(randInt(minDmg, maxDmg)),
],
}
],
);
this.cooldownMax = cooldown;
}
}
export class _defend extends CardScript {
constructor(card: GameEngine.ICardState, difficulty: number, strength: 'weak' | 'normal' | 'strong' = 'normal', cooldown = 0) {
let minBonus = 0;
let maxBonus = 0;
switch (strength) {
case 'weak':
minBonus = GameEngineUtils.scaleByCpuMem(4, card.cpu);
maxBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
break;
case 'normal':
minBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
maxBonus = GameEngineUtils.scaleByCpuMem(8, card.cpu);
break;
case 'strong':
minBonus = GameEngineUtils.scaleByCpuMem(8, card.cpu);
maxBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
break;
}
minBonus = GameEngineUtils.scaleByDifficulty(minBonus, difficulty);
maxBonus = GameEngineUtils.scaleByDifficulty(maxBonus, difficulty);
super(
[difficulty, strength, cooldown, minBonus, maxBonus],
TargetFinders.Allies(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = cooldown;
}
}
export class _firewallSelf extends CardScript {
constructor(_card: GameEngine.ICardState, duration = 1, cooldown = 0, startingCooldown = 0) {
super(
[duration, cooldown],
TargetFinders.Self,
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.firewall(duration + 1),
),
],
}
],
);
this.cooldownCur = startingCooldown;
this.cooldownMax = cooldown;
}
}
export class _spawn extends CardScript {
constructor(_card: GameEngine.ICardState, enemyClass: string, spawnPosition: Parameters<typeof CardScriptParts['SpawnEnemy']>[1] = 'relLeft', generateIntent = false, cooldown = 0) {
super(
[enemyClass, spawnPosition, generateIntent, cooldown],
TargetFinders.Self,
[
{
targetResolver: TargetResolvers.Self,
parts: [
CardScriptParts.SpawnEnemy(enemyClass, spawnPosition, generateIntent),
],
}
],
);
this.cooldownMax = cooldown;
}
}
}
(Content as Record<CoreScriptNames, ScriptConstructor>);
}
|
src/game/card-scripts.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " if (Math.random() < chance) {\n curriedPart(engine, sourceCard, targetCard);\n }\n };\n export const _TargetHasMod = <T extends CardMod.ModLibrary, K extends keyof T>(modName: K, curry: (mod: InstanceType<T[K]>) => IScriptPart): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n const mod = targetCard.mods.find(x => x[0] === modName);\n if (mod) {\n curry(CardMod.deserialize(engine, mod) as InstanceType<T[K]>)(engine, sourceCard, targetCard);\n }",
"score": 0.8423953652381897
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " super(\n [],\n (gameData, card) =>\n CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.ChangeCpu(-1),\n CardScriptParts.RaiseMem(1),",
"score": 0.8332713842391968
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;\n export type ModLibrary = Record<string, ModConstructor>;\n export type AppendStackingData = ['$stack', StackingBehavior.append];\n export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];\n export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];\n export type ReplaceStackingData = ['$stack', StackingBehavior.replace];\n export type StackStackingData = ['$stack', StackingBehavior.stack, number];\n export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;\n export enum StackingBehavior {\n append,",
"score": 0.8328646421432495
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [],\n (gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseMem(-1),\n CardScriptParts.ChangeCpu(1),\n ],\n }",
"score": 0.8319288492202759
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " };\n export const AddMod = (mod: CardMod): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n CardMod.addMod(engine, targetCard, mod, sourceCard);\n };\n export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;\n if (secExceeded) {\n MemDmg(1)(engine, sourceCard, targetCard);",
"score": 0.8313989043235779
}
] |
typescript
|
.filter(target => target.mods.find(modData => modFilter.find(x => x === modData[0])));
|
import * as moment from 'moment';
import { IAppraisedCard, appraiseCard } from '../appraise';
import { IDataSource, IMetricsProvider, IPlayerPushProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { SECS_IN_MIN } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameContent_v1 } from './game-content-v1';
import { GameEngineUtils } from './game-engine-utils';
export namespace GameEngine {
interface _ICommonCardState {
id: number;
cpu: number;
mem: number;
sec: number;
mods: CardMod.ModData[];
scripts: CardScript.ScriptData[];
isRemoved?: boolean;
}
export interface IGameData {
id: string;
difficulty: number;
state: 'created' | 'started' | 'players_won' | 'players_lost' | 'abandoned';
enemies: IEnemyCardState[];
maxEnemies: number;
players: Map<string, IPlayerState>;
defaultMovesPerTurn: number;
turn: number;
nextId: number;
pendingPlayers: Map<string, string[]>;
rulesetIds: string[];
}
export interface IPlayerState {
id: string;
cards: IPlayerCardState[];
endedTurn: boolean;
idleKickTime: number;
movesLeft: number;
movesPerTurn: number;
score: number;
stats: {
kills: number;
secDmg: number;
memDmg: number;
secBonus: number;
};
}
export interface IPlayerCardState extends _ICommonCardState {
card: IAppraisedCard;
isUsed: boolean;
}
export interface IEnemyCardState extends _ICommonCardState {
enemyClass: string;
intent?: { scriptData: CardScript.ScriptData, targetCardId: number };
maxMem: number;
}
export type ICardState = IPlayerCardState | IEnemyCardState;
export abstract class GameEngineError extends Error {
constructor(
public gameId: string,
) {
super();
this.message = `${this.constructor.name} processing game ${gameId}`;
}
}
export class GameNotFoundError extends GameEngineError { }
export interface IRulesetContent {
cardMods?: CardMod.ModLibrary;
cardScripts?: CardScript.ScriptLibrary;
enemyCards?: Record<string, (engine: IGameEngine) => IEnemyCardState>;
}
export interface IRuleset extends IRulesetContent {
initGame(engine: IGameEngine): void;
addAdditionalScriptsFor?(engine: GameEngine.IGameEngine, card: IPlayerCardState): void;
}
export function mergeRulesetContents(...rulesets: IRulesetContent[]): IRulesetContent {
const modLibs = rulesets.map(x => x.cardMods).filter(Boolean);
const scriptLibs = rulesets.map(x => x.cardScripts).filter(Boolean);
const enemyLibs = rulesets.map(x => x.enemyCards).filter(Boolean);
return {
cardMods: Object.fromEntries(modLibs.map(modLib => Object.keys(modLib).map(modName => [modName, modLib[modName]!] as const)).flat()),
cardScripts: Object.fromEntries(scriptLibs.map(scriptLib => Object.keys(scriptLib).map(scriptName => [scriptName, scriptLib[scriptName]!] as const)).flat()),
enemyCards: Object.fromEntries(enemyLibs.map(enemyLib => Object.keys(enemyLib).map(enemyClass => [enemyClass, enemyLib[enemyClass]!] as const)).flat()),
};
}
export type IGameEngine = InstanceType<ReturnType<typeof createGameEngineProvider>>;
}
export const createGameEngineProvider = (rulesets: Record<string, GameEngine.IRuleset>, ds: IDataSource, playerPushProvider: IPlayerPushProvider, metrics?: IMetricsProvider) => {
return class _Engine {
readonly broadcast: IPlayerPushProvider.IPushMessage[] = [];
ruleset!: GameEngine.IRuleset;
constructor(
readonly gameData: GameEngine.IGameData,
) {
const currentRuleset = rulesets[gameData.rulesetIds.at(-1)!];
if (!currentRuleset) throw new Error('invalid initial ruleSet id: ' + gameData.rulesetIds[0]);
this._setRuleset(currentRuleset);
}
private static async _withEngine(gameId: string, stateAssertion: GameEngine.IGameData['state'][], func: (engine: _Engine) => Promise<void>): Promise<GameEngine.IGameData> {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
const engine = new _Engine(gameData);
try {
if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);
await func(engine);
await ds.GameData.update.exec(gameData);
} catch (e: any) {
e.broadcast = engine.broadcast;
throw e;
}
if (engine.broadcast.length) {
await Promise.all(
[...gameData.players.keys()].map(playerId => playerPushProvider.push(playerId, engine.broadcast)),
);
}
return gameData;
}
static async createGame(gameId: string, rulesetId: string, difficulty: number) {
const ruleset = rulesets[rulesetId];
if (!ruleset) throw new Error('invalid ruleSet id: ' + rulesetId);
const existingGameData = await ds.GameData.get(gameId);
if (existingGameData) throw new Error('game with id already exists: ' + gameId);
const gameData: GameEngine.IGameData = {
id: gameId,
difficulty: Math.max(1, difficulty),
state: 'created',
turn: 1,
players: new Map(),
defaultMovesPerTurn: 3,
enemies: [],
maxEnemies: 9,
nextId: 1,
pendingPlayers: new Map(),
rulesetIds: [rulesetId],
};
await ds.GameData.update.exec(gameData);
}
static async startGame(gameId: string) {
const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {
for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
engine.broadcast.push({ type: 'playerJoin', playerState });
}
engine.gameData.pendingPlayers.clear();
engine.gameData.state = 'started';
engine.broadcast.push({ type: 'gameStart' });
engine.ruleset.initGame(engine);
});
return gameData;
}
static async endGame(gameId: string) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
engine.gameData.state = 'abandoned';
engine.broadcast.push({ type: 'gameEnd' });
});
}
static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
if (engine.gameData.players.has(playerId)) throw new Error('player already in game');
if (engine.gameData.players.size >= 2) throw new Error('game is full: ' + gameId);
if (engine.gameData.state === 'started') {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
if (engine.gameData.turn >= 2) {
playerState.endedTurn = true;
playerState.movesLeft = 0;
}
engine.broadcast.push({
type: 'playerJoin',
playerState,
});
} else {
engine.gameData.pendingPlayers.set(playerId, cardIds);
}
});
}
static async removePlayer(gameId: string, playerId: string, reason: 'idle' | 'leave') {
return await _Engine._withEngine(gameId, [], async engine => {
if (!engine.gameData.players.delete(playerId)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId, reason });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
});
}
static async requestCardTargets(gameId: string, playerId: string, cardId: number, scriptName: string) {
const gameData = await _Engine.getGameData(gameId);
const card = GameEngineUtils.findPlayerCardById(gameData, cardId);
let targets = [] as number[];
try {
if (card.isUsed) {
return;
}
const scriptData =
|
card.scripts.find(x => x[0] === scriptName);
|
if (!scriptData) {
throw new Error(`Script [${scriptName}] not found in card [${cardId}]`);
}
if (CardScript.isOnCooldown(scriptData)) {
return;
}
const engine = new _Engine(gameData);
const script = CardScript.deserialize(engine, card, scriptData);
targets = script.targetFinder(gameData, card).map(x => x.id);
} finally {
await playerPushProvider.push(playerId, [{
type: 'cardTargets',
cardId,
scriptName,
targetCardIds: targets,
}]);
}
}
static async intent(gameId: string, playerId: string, sourceCardId?: string, sourceCardScript?: string, targetCardId?: string) {
const gameData = await _Engine.getGameData(gameId);
const pushMessage: IPlayerPushProvider.IPushMessage[] = [{
type: 'cardIntent',
cardId: sourceCardId,
intent: {
scriptData: sourceCardScript,
targetCardId,
},
playerId,
}];
await Promise.all(
[...gameData.players.keys()].filter(x => x !== playerId).map(x => playerPushProvider?.push(x, pushMessage)),
);
}
static async makeMove(gameId: string, playerId: string, sourceCardId: number, sourceCardScript: CardScript.ScriptData, targetCardId: number) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = GameEngineUtils.findPlayerByCardId(engine.gameData, sourceCardId);
if (playerState.id !== playerId) {
throw new Error(`Player ${playerId} cannot make move on card ${sourceCardId} from owner ${playerState.id}`);
}
if (!playerState.movesLeft) {
throw new Error(`No moves left`);
}
const sourceCard = playerState.cards.find(x => x.id === sourceCardId)!;
if (sourceCard.isUsed) {
throw new Error(`Card is used`);
}
const now = moment.now();
playerState.idleKickTime = now + 2 * SECS_IN_MIN * 1000;
playerState.movesLeft--;
const targetCard = GameEngineUtils.findCardById(engine.gameData, targetCardId);
CardScript.execute(engine, sourceCard, sourceCardScript, targetCard);
GameEngineUtils.changeCardIsUsed(engine, sourceCard, true);
metrics?.playerCardPlayed(gameId, engine.gameData.rulesetIds[0] || 'unknown', playerId, sourceCard, sourceCardScript[0]);
});
}
static async toggleEndTurn(gameId: string, playerId: string) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = engine.gameData.players.get(playerId);
if (!playerState) throw new Error('player not found');
if (playerState.endedTurn) {
playerState.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: false,
});
return;
}
playerState.endedTurn = true;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: true,
});
if (![...engine.gameData.players.values()].reduce((numNotReady, playerState) => playerState.endedTurn ? numNotReady : (numNotReady + 1), 0)) {
const now = moment.now();
[...engine.gameData.players.values()].forEach(x => x.idleKickTime = now + 2 * SECS_IN_MIN * 1000);
engine.onEndTurn();
if (engine.gameData.state !== 'started') {
// Stop if the game was won/lost due to an EndTurn effect
return;
}
engine.onTurnStart();
}
});
}
static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {
let kickedPlayerId = '';
await _Engine._withEngine(gameId, ['started'], async engine => {
const playerToKick = [...engine.gameData.players.values()].find(x => x.id !== kickRequestingPlayerId) || '';
if (!playerToKick) throw new Error('kickIfIdle: player not found');
if (playerToKick.idleKickTime < moment.now()) {
if (!engine.gameData.players.delete(playerToKick.id)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId: playerToKick.id, reason: 'idle' });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
kickedPlayerId = playerToKick.id;
}
});
return kickedPlayerId || null;
}
static async getGameData(gameId: string) {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
return gameData;
}
private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {
const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))
.filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)
.map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));
if (cards.length !== cardIds.length) {
throw `could not resolve all cards for player ${playerId}`;
}
const player: GameEngine.IPlayerState = {
id: playerId,
cards: cards.map(card => ({
id: this.nextId(),
card,
isUsed: false,
cpu: card.cpu,
mem: card.mem,
sec: card.mem * 6 + card.cpu * 3,
mods: [],
scripts: [],
})),
endedTurn: false,
movesLeft: this.gameData.defaultMovesPerTurn,
movesPerTurn: this.gameData.defaultMovesPerTurn,
stats: {
kills: 0,
memDmg: 0,
secBonus: 0,
secDmg: 0,
},
score: 0,
idleKickTime: moment.now() + 2 * SECS_IN_MIN * 1000,
};
for (const card of player.cards) {
card.scripts = [
CardScript.fromScriptName(this, card, card.card.coreScript),
];
this.ruleset.addAdditionalScriptsFor && this.ruleset.addAdditionalScriptsFor(this, card);
}
return player;
}
findRuleset(rulesetId: string) {
return rulesets[rulesetId];
}
onTurnStart() {
this.gameData.turn++;
this.broadcast.push({
type: 'newTurn',
turn: this.gameData.turn,
});
for (const player of this.gameData.players.values()) {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
}
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of playerCards) {
GameEngineUtils.changeCardIsUsed(this, playerCard, false);
}
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: playerCard });
}
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: enemy });
}
this._checkGameOver();
}
onEndTurn() {
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: playerCard });
CardScript.tickCooldowns(playerCard, this.broadcast);
}
this.broadcast.push({
type: 'playerTurnEnded',
});
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: enemy });
CardScript.tickCooldowns(enemy, this.broadcast);
}
this.broadcast.push({
type: 'enemyTurnEnded',
});
this._checkGameOver();
}
onNextWave(nextRulesetId: string) {
while (this.gameData.enemies[0]) {
GameEngineUtils.removeCard(this, this.gameData.enemies[0]);
}
[...this.gameData.players.values()].forEach(player => {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
player.cards.forEach(card => {
card.isUsed = false;
});
});
this.gameData.turn++;
this.broadcast.push({
type: 'nextWave',
turn: this.gameData.turn,
nextRulesetId,
});
const nextRuleset = this.findRuleset(nextRulesetId);
if (!nextRuleset) {
throw new Error('invalid rulesetId: ' + nextRulesetId);
}
this.gameData.rulesetIds.push(nextRulesetId);
this._setRuleset(nextRuleset);
nextRuleset.initGame(this);
}
onWinGame() {
this.gameData.state = 'players_won';
this.broadcast.push({
type: 'players_won',
stats: [...this.gameData.players.values()].map(player => {
let score =
player.cards.length * 50
+ player.stats.kills * 25
+ player.stats.memDmg * 50
+ player.stats.secDmg
+ player.stats.secBonus * 2
+ ((this.gameData.rulesetIds.length - 1) * 2000);
score = GameEngineUtils.scaleByDifficulty(score, this.gameData.difficulty + 1);
player.score = score;
return { playerId: player.id, stats: player.stats, score };
}),
});
}
nextId() {
return this.gameData.nextId++;
}
private _checkGameOver() {
if (!GameEngineUtils.getPlayerCards(this.gameData).length) {
this.gameData.state = 'players_lost';
this.broadcast.push({
type: 'players_lost',
});
}
}
private _setRuleset(nextRuleset: GameEngine.IRuleset) {
this.ruleset = {
addAdditionalScriptsFor: GameContent_v1.addAdditionalScriptsFor,
...nextRuleset,
...GameEngine.mergeRulesetContents(
nextRuleset,
{
cardMods: CardMod.Content,
cardScripts: CardScript.Content,
},
{
cardMods: GameContent_v1.cardMods,
cardScripts: GameContent_v1.cardScripts,
enemyCards: GameContent_v1.enemyCards,
}
),
};
}
}
}
export type GameEngineProvider = ReturnType<typeof createGameEngineProvider>;
|
src/game/game-engine.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " targetCard = enemy;\n }\n CardScript.execute(engine, enemy, intent.scriptData, targetCard);\n return true;\n }\n export function findCardById(gameData: GameEngine.IGameData, cardId: number) {\n const card = findCardByIdMaybe(gameData, cardId);\n if (card) return card;\n throw new Error('card not found');\n }",
"score": 0.8949883580207825
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " targetCardId: targetCard.id,\n scriptData: sourceCardScript,\n });\n if (this.isOnCooldown(sourceCardScript)) {\n throw new Error('Script is on cooldown: ' + sourceCardScript.join());\n }\n const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript));\n const isEnemy = GameEngineUtils.isEnemyCard(engine.gameData, sourceCard);\n if (!isEnemy) {\n if (!scriptDataFromCard) {",
"score": 0.8748588562011719
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " export function findCardByIdMaybe(gameData: GameEngine.IGameData, cardId: number) {\n const enemy = gameData.enemies.find(x => x.id === cardId);\n if (enemy) return enemy;\n const player = findPlayerByCardIdMaybe(gameData, cardId);\n if (player) {\n return player.cards.find(x => x.id === cardId);\n }\n return;\n }\n export function findPlayerCardById(gameData: GameEngine.IGameData, cardId: number) {",
"score": 0.8735487461090088
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());\n }\n }\n const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);\n if (cooldownData) {\n cooldownData[1] = cooldownData[2] + 1;\n }\n const script = this.deserialize(engine, sourceCard, sourceCardScript);\n const targets = script.targetFinder(engine.gameData, sourceCard);\n if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {",
"score": 0.8733294010162354
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " export function isPlayerCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IPlayerCardState {\n return !isEnemyCard(gameData, card);\n }\n export function recalculateScripts(engine: GameEngine.IGameEngine, card: GameEngine.ICardState) {\n if (card.isRemoved) return;\n card.scripts = card.scripts.map(x => CardScript.deserialize(engine, card, x).serialize());\n engine.broadcast.push(...card.scripts.map(x => ({\n type: 'scriptChanged',\n cardId: card.id,\n scriptData: x,",
"score": 0.8704813718795776
}
] |
typescript
|
card.scripts.find(x => x[0] === scriptName);
|
import { randInt } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
const _cardMods = {
// Increases incoming damage
exposed: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public stackCount: number) {
super(arguments);
this.stackingConfig.stackCount = stackCount;
}
override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return { secDmgBonus: this.stackingConfig.stackCount };
}
},
// Returns damage to attacker
feedback: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public damage: number) {
super(arguments);
this.stackingConfig.stackCount = damage;
}
override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);
}
},
// Increases CPU
optimized: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(cpuBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = cpuBonus;
}
override onInitMod(deps: CardMod.ICardModDeps) {
GameEngineUtils.changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);
}
override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {
deps.sourceCard.cpu += stackDelta;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
override onRemoveMod(deps: CardMod.ICardModDeps) {
deps.sourceCard.cpu -= this.stackingConfig.stackCount;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
},
// Damages on turn end
virus: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public dot: number) {
super(arguments);
this.stackingConfig.stackCount = dot;
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);
}
},
};
const _cardScripts = {
//
// Backdoor scripts
//
// Swap MEM for CPU
bd_caching: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(-1),
CardScriptParts.ChangeCpu(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise MEM
bd_defrag: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memBonus = 1;
super(
[memBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 4;
}
},
// Heal over time
bd_diagnostics: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const duration = 1 + Math.round(card.mem / 2);
super(
[secBonus, duration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
|
new CardMod.Content.diagnostics(secBonus, duration)
),
],
}
|
],
);
this.cooldownMax = 4;
}
},
// Attack and stun (Backdoor finisher)
bd_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const stunDuration = 1;
super(
[damage, stunDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.AddMod(
new CardMod.Content.lag(stunDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and raise CPU on kill
bd_extraction: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Opponents(true)(gameData, card)
.filter(target => !target.sec && target.mem === 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(1, true, true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.ChangeCpu(1),
],
},
],
);
}
},
// Raises CPU
bd_optimize: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Raises SEC
bd_patch: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 2;
}
},
// Steal SEC and remove Firewall (Backdoor finisher)
bd_proxy: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, card.cpu);
super(
[secDelta],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
}
},
// Steal SEC and causes offline (Backdoor finisher)
bd_reboot: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, _card.cpu);
const offlineDuration = 1;
super(
[secDelta, offlineDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 2;
}
},
// Cause Exposed (Backdoor finisher)
bd_trace: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(7, card.cpu);
super(
[stacks],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and remove 1 MEM
bd_tunnel: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memDmg = 1;
super(
[memDmg],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.MemDmg(memDmg),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 3;
}
},
//
// Bruteforce scripts
//
// Swap CPU for MEM
bf_compression: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.ChangeCpu(-1),
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Offline
bf_ddos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const offlineDuration = 1;
super(
[offlineDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Cause Lag
bf_dos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const lagDuration = 1;
super(
[lagDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Gain feedback
bf_feedback: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Triple SEC attack
bf_flood: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(3, card.cpu);
const numAttacks = 3;
super(
[damage, numAttacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
...Array.from(Array(numAttacks)).map(() => CardScriptParts.SecDmg(damage)),
],
}
],
);
this.cooldownMax = 2;
}
},
// AOE attack
bf_multicast: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.TargetAndAdjacents,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC
bf_obfuscate: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 3;
}
},
// Strong attack
bf_pod: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(16, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 2;
}
},
// Raises CPU
bf_precompute: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
//
// Malware scripts
//
// Causes Lag
mw_bloatware: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[1],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(1),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Swap for another card's secondary script
mw_copypaste: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, sourceCard, targetCard) => {
CardScript.removeScript(engine, sourceCard, _cardScripts.mw_copypaste);
if (!targetCard.scripts[1]) return;
CardScript.addScript(engine, sourceCard, CardScript.fromScriptName(engine, sourceCard, targetCard.scripts[1][0]));
},
],
}
],
);
}
},
// Grant Feedback
mw_honeypot: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Steal SEC
mw_leech: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[secDelta],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 1;
}
},
// Attack random target
mw_phishing: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(18, card.cpu);
super(
[minDamage, maxDamage],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomOpponent,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
this.cooldownMax = 1;
}
},
// Redistribute CPU/MEM
mw_reimage: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, _sourceCard, targetCard) => {
const totalStats = targetCard.cpu + targetCard.mem;
const newCpu = randInt(1, totalStats - 1);
const cpuDelta = newCpu - targetCard.cpu;
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
const newMem = totalStats - newCpu;
const memDelta = newMem - targetCard.mem;
GameEngineUtils.changeMem(engine, targetCard, memDelta);
},
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC on random ally
mw_shareware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);
super(
[minBonus, maxBonus],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomAlly,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 3;
}
},
// Redirect intent
mw_spoof: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RedirectIntentRandom,
],
}
],
);
}
},
// Cause Exposed
mw_spyware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[stacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Virus
mw_virus: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const dot = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[dot],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.virus(dot),
),
],
}
],
);
this.cooldownMax = 2;
}
},
};
export const GameContent_v1 = {
cardMods: _cardMods,
cardScripts: _cardScripts,
enemyCards: {},
initGame(_engine: GameEngine.IGameEngine) {
throw new Error('not a startable scenario');
},
addAdditionalScriptsFor(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState) {
if (card.card.tier < 2) return;
switch (card.card.faction) {
case 'backdoor':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bd_')).random()]).serialize());
return;
case 'bruteforce':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bf_')).random()]).serialize());
return;
case 'malware':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('mw_')).random()]).serialize());
return;
}
},
};
(GameContent_v1 as GameEngine.IRuleset);
|
src/game/game-content-v1.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new CardMod.Content.secured(tempSecBonus, duration),\n ),\n CardScriptParts.AddMod(\n new CardMod.Content.firewall(duration),\n ),\n ],",
"score": 0.9356763362884521
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Self,\n parts: [\n CardScriptParts.RaiseSec(secBonus),\n CardScriptParts.AddMod(\n new CardMod.Content.firewall(modDuration),\n ),\n ],\n }\n ],",
"score": 0.9246131181716919
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new CardMod.Content.firewall(duration + 1),\n ),\n ],\n }\n ],\n );",
"score": 0.9096018671989441
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [secBonus],\n TargetFinders.Any(),\n [\n {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseSec(secBonus),\n ],\n }\n ],",
"score": 0.8966459035873413
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts._TargetHasMod<typeof CardMod.Content, 'backdoor'>('backdoor', mod => CardScriptParts.SecDmg(mod.stackingConfig.rank, true)),\n CardScriptParts.Attack(damage),\n CardScriptParts._Chance(bdChance,\n CardScriptParts.AddMod(\n new CardMod.Content.backdoor(damage),\n )\n ),",
"score": 0.8915681838989258
}
] |
typescript
|
new CardMod.Content.diagnostics(secBonus, duration)
),
],
}
|
import { randInt } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
const _cardMods = {
// Increases incoming damage
exposed: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public stackCount: number) {
super(arguments);
this.stackingConfig.stackCount = stackCount;
}
override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return { secDmgBonus: this.stackingConfig.stackCount };
}
},
// Returns damage to attacker
feedback: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public damage: number) {
super(arguments);
this.stackingConfig.stackCount = damage;
}
override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);
}
},
// Increases CPU
optimized: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(cpuBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = cpuBonus;
}
override onInitMod(deps: CardMod.ICardModDeps) {
GameEngineUtils.changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);
}
override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {
deps.sourceCard.cpu += stackDelta;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
override onRemoveMod(deps: CardMod.ICardModDeps) {
deps.sourceCard.cpu -= this.stackingConfig.stackCount;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
},
// Damages on turn end
virus: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public dot: number) {
super(arguments);
this.stackingConfig.stackCount = dot;
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);
}
},
};
const _cardScripts = {
//
// Backdoor scripts
//
// Swap MEM for CPU
bd_caching: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(-1),
|
CardScriptParts.ChangeCpu(1),
],
}
|
],
);
this.cooldownMax = 1;
}
},
// Raise MEM
bd_defrag: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memBonus = 1;
super(
[memBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 4;
}
},
// Heal over time
bd_diagnostics: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const duration = 1 + Math.round(card.mem / 2);
super(
[secBonus, duration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.diagnostics(secBonus, duration)
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Attack and stun (Backdoor finisher)
bd_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const stunDuration = 1;
super(
[damage, stunDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.AddMod(
new CardMod.Content.lag(stunDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and raise CPU on kill
bd_extraction: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Opponents(true)(gameData, card)
.filter(target => !target.sec && target.mem === 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(1, true, true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.ChangeCpu(1),
],
},
],
);
}
},
// Raises CPU
bd_optimize: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Raises SEC
bd_patch: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 2;
}
},
// Steal SEC and remove Firewall (Backdoor finisher)
bd_proxy: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, card.cpu);
super(
[secDelta],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
}
},
// Steal SEC and causes offline (Backdoor finisher)
bd_reboot: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, _card.cpu);
const offlineDuration = 1;
super(
[secDelta, offlineDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 2;
}
},
// Cause Exposed (Backdoor finisher)
bd_trace: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(7, card.cpu);
super(
[stacks],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and remove 1 MEM
bd_tunnel: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memDmg = 1;
super(
[memDmg],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.MemDmg(memDmg),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 3;
}
},
//
// Bruteforce scripts
//
// Swap CPU for MEM
bf_compression: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.ChangeCpu(-1),
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Offline
bf_ddos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const offlineDuration = 1;
super(
[offlineDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Cause Lag
bf_dos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const lagDuration = 1;
super(
[lagDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Gain feedback
bf_feedback: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Triple SEC attack
bf_flood: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(3, card.cpu);
const numAttacks = 3;
super(
[damage, numAttacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
...Array.from(Array(numAttacks)).map(() => CardScriptParts.SecDmg(damage)),
],
}
],
);
this.cooldownMax = 2;
}
},
// AOE attack
bf_multicast: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.TargetAndAdjacents,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC
bf_obfuscate: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 3;
}
},
// Strong attack
bf_pod: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(16, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 2;
}
},
// Raises CPU
bf_precompute: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
//
// Malware scripts
//
// Causes Lag
mw_bloatware: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[1],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(1),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Swap for another card's secondary script
mw_copypaste: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, sourceCard, targetCard) => {
CardScript.removeScript(engine, sourceCard, _cardScripts.mw_copypaste);
if (!targetCard.scripts[1]) return;
CardScript.addScript(engine, sourceCard, CardScript.fromScriptName(engine, sourceCard, targetCard.scripts[1][0]));
},
],
}
],
);
}
},
// Grant Feedback
mw_honeypot: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Steal SEC
mw_leech: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[secDelta],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 1;
}
},
// Attack random target
mw_phishing: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(18, card.cpu);
super(
[minDamage, maxDamage],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomOpponent,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
this.cooldownMax = 1;
}
},
// Redistribute CPU/MEM
mw_reimage: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, _sourceCard, targetCard) => {
const totalStats = targetCard.cpu + targetCard.mem;
const newCpu = randInt(1, totalStats - 1);
const cpuDelta = newCpu - targetCard.cpu;
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
const newMem = totalStats - newCpu;
const memDelta = newMem - targetCard.mem;
GameEngineUtils.changeMem(engine, targetCard, memDelta);
},
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC on random ally
mw_shareware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);
super(
[minBonus, maxBonus],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomAlly,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 3;
}
},
// Redirect intent
mw_spoof: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RedirectIntentRandom,
],
}
],
);
}
},
// Cause Exposed
mw_spyware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[stacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Virus
mw_virus: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const dot = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[dot],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.virus(dot),
),
],
}
],
);
this.cooldownMax = 2;
}
},
};
export const GameContent_v1 = {
cardMods: _cardMods,
cardScripts: _cardScripts,
enemyCards: {},
initGame(_engine: GameEngine.IGameEngine) {
throw new Error('not a startable scenario');
},
addAdditionalScriptsFor(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState) {
if (card.card.tier < 2) return;
switch (card.card.faction) {
case 'backdoor':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bd_')).random()]).serialize());
return;
case 'bruteforce':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bf_')).random()]).serialize());
return;
case 'malware':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('mw_')).random()]).serialize());
return;
}
},
};
(GameContent_v1 as GameEngine.IRuleset);
|
src/game/game-content-v1.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n const bdChance = round(GameEngineUtils.scaleByCpuMem(40, card.mem, 'more') / 100, 2);\n super(\n [damage, bdChance],\n (gameData: GameEngine.IGameData, card: GameEngine.ICardState) => [\n ...TargetFinders.Opponents()(gameData, card),\n ...TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],\n TargetFinders.Opponents(true))(gameData, card),\n ],\n [",
"score": 0.8787883520126343
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " const i = cards.findIndex(x => x.id === targetCard.id);\n return [cards[i], cards[i - 1], cards[i + 1]].filter(Boolean);\n };\n export const AllAllies: ITargetResolver = (gameData, sourceCard) => {\n if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {\n return TargetFinders._excludeOffline(gameData.enemies);\n } else {\n return TargetFinders._excludeOffline(GameEngineUtils.getPlayerCards(gameData));\n }\n };",
"score": 0.8722083568572998
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " };\n export const ChangeCpu = (cpuDelta: number): IScriptPart =>\n (engine, _sourceCard, targetCard) => {\n GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);\n };\n export const RaiseMem = (memBonus: number): IScriptPart =>\n (engine, _sourceCard, targetCard) => {\n targetCard.mem += memBonus;\n engine.broadcast.push({\n type: 'memBonus',",
"score": 0.8689436316490173
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " export const RandomAlly: ITargetResolver = (gameData, sourceCard, targetCard) => {\n return [AllAllies(gameData, sourceCard, targetCard).random()];\n };\n export const AllOpponents: ITargetResolver = (gameData, sourceCard) => {\n if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {\n return TargetFinders._excludeImperviousAndOffline(GameEngineUtils.getPlayerCards(gameData));\n } else {\n return TargetFinders._excludeImperviousAndOffline(gameData.enemies);\n }\n };",
"score": 0.8685448169708252
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [difficulty, strength, cooldown, minBonus, maxBonus],\n TargetFinders.Allies(),\n [\n {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),\n ],\n }\n ],",
"score": 0.8596459031105042
}
] |
typescript
|
CardScriptParts.ChangeCpu(1),
],
}
|
import { clamp, round } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
export namespace GameEngineUtils {
export function addEnemy(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, spawnIndex: number, generateIntent: boolean) {
if (engine.gameData.enemies.length >= engine.gameData.maxEnemies) return;
spawnIndex = clamp(spawnIndex, 0, engine.gameData.enemies.length);
engine.gameData.enemies.splice(spawnIndex, 0, enemy);
engine.broadcast.push({
type: 'cardAdded',
enemy,
position: spawnIndex,
});
GameEngineUtils.triggerMods('onInitMod', { engine, sourceCard: enemy });
if (generateIntent) {
GameEngineUtils.generateIntent(engine, enemy);
}
return enemy;
}
export function changeCardIsUsed(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState, isUsed: boolean) {
card.isUsed = isUsed;
engine.broadcast.push({
type: 'cardIsUsedChanged',
cardId: card.id,
isUsed,
});
}
export function clearIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = undefined;
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
});
return true;
}
export function changeCpu(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, cpuDelta: number) {
card.cpu += cpuDelta;
engine.broadcast.push({
type: 'cpuChanged',
cardId: card.id,
newCpu: card.cpu,
cpuDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeMem(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, memDelta: number) {
card.mem += memDelta;
engine.broadcast.push({
type: 'memChanged',
cardId: card.id,
newMem: card.mem,
memDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeSec(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, secDelta: number, isPassive: boolean, contextCard?: GameEngine.ICardState) {
const clampedSecDelta = (card.sec < -secDelta) ? -card.sec : secDelta;
card.sec += clampedSecDelta;
engine.broadcast.push({
type: isPassive ? 'secChange' : (secDelta < 0 ? 'secDamage' : 'secBonus'),
cardId: card.id,
newSec: card.sec,
value: secDelta,
});
if (!isPassive && contextCard) {
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
if (player) {
(clampedSecDelta >= 0) ? (player.stats.secBonus += clampedSecDelta) : (player.stats.secDmg += -clampedSecDelta);
}
}
}
export function executeIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, dontClearIntent = false) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = dontClearIntent ? enemy.intent : undefined;
let targetCard: GameEngine.ICardState | undefined;
if (intent.targetCardId >= 0) {
targetCard = findCardByIdMaybe(engine.gameData, intent.targetCardId);
if (!targetCard) {
// Intent target could've been removed between intent generation and execution
return false;
}
} else {
targetCard = enemy;
}
CardScript.execute(engine, enemy, intent.scriptData, targetCard);
return true;
}
export function findCardById(gameData: GameEngine.IGameData, cardId: number) {
const card = findCardByIdMaybe(gameData, cardId);
if (card) return card;
throw new Error('card not found');
}
export function findCardByIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
|
const enemy = gameData.enemies.find(x => x.id === cardId);
|
if (enemy) return enemy;
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) {
return player.cards.find(x => x.id === cardId);
}
return;
}
export function findPlayerCardById(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (!player) throw new Error('player not found');
return player.cards.find(x => x.id === cardId)!;
}
export function findPlayerByCardId(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) return player;
throw new Error('player not found');
}
export function findPlayerByCardIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
return [...gameData.players.values()].find(x => x.cards.find(x => x.id === cardId));
}
export function generateIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
enemy.intent = undefined;
const isOffline = !!enemy.mods.find(x => x[0] === 'offline');
if (isOffline) return;
const scriptData = enemy.scripts.filter(x => !CardScript.isOnCooldown(x)).randomOrUndefined();
if (!scriptData) {
return;
}
const script = CardScript.deserialize(engine, enemy, scriptData);
const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();
if (!target) {
return;
}
enemy.intent = {
scriptData,
targetCardId: target.id,
};
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
intent: enemy.intent,
});
}
export function getEnemyIds(gameData: GameEngine.IGameData) {
return gameData.enemies.map(x => x.id);
}
export function getPlayerIds(gameData: GameEngine.IGameData, ...excludePlayer: string[]) {
return [...gameData.players.keys()].filter(x => !excludePlayer.includes(x));
}
export function getPlayerCards(gameData: GameEngine.IGameData) {
return [...gameData.players.values()].map(x => x.cards).flat();
}
export function getPlayerCardIds(gameData: GameEngine.IGameData) {
return getPlayerCards(gameData).map(x => x.id);
}
export function isEnemyCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IEnemyCardState {
return !!gameData.enemies.find(x => x.id === card.id);
}
export function isPlayerCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IPlayerCardState {
return !isEnemyCard(gameData, card);
}
export function recalculateScripts(engine: GameEngine.IGameEngine, card: GameEngine.ICardState) {
if (card.isRemoved) return;
card.scripts = card.scripts.map(x => CardScript.deserialize(engine, card, x).serialize());
engine.broadcast.push(...card.scripts.map(x => ({
type: 'scriptChanged',
cardId: card.id,
scriptData: x,
})));
if (isEnemyCard(engine.gameData, card) && card.intent?.scriptData) {
card.intent.scriptData = CardScript.deserialize(engine, card, card.intent.scriptData).serialize();
engine.broadcast.push({
type: 'cardIntent',
cardId: card.id,
intent: card.intent,
});
}
}
export function revalidateIntents(engine: GameEngine.IGameEngine, regenerateIfInvalid: boolean) {
for (const enemy of engine.gameData.enemies) {
if (!enemy.intent || enemy.intent.targetCardId === -1) {
continue;
}
const script = CardScript.deserialize(engine, enemy, enemy.intent.scriptData);
const validTargets = script.targetFinder(engine.gameData, enemy);
if (validTargets.find(x => x.id === enemy.intent?.targetCardId)) {
continue;
}
enemy.intent = undefined;
if (regenerateIfInvalid) {
generateIntent(engine, enemy);
}
}
}
export function removeCard(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, contextCard?: GameEngine.ICardState) {
if (card.isRemoved) {
return;
}
if (isEnemyCard(engine.gameData, card)) {
engine.gameData.enemies.removeFirst(card)
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
for (const enemy of [...engine.gameData.enemies]) {
if (enemy.isRemoved) continue;
triggerMods('onEnemyDestroyed', { engine, sourceCard: card, contextCard });
}
if (contextCard) {
const player = findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
player && player.stats.kills++;
}
GameEngineUtils.revalidateIntents(engine, true);
} else {
const player = GameEngineUtils.findPlayerByCardId(engine.gameData, card.id);
player.cards.removeFirst(card);
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
GameEngineUtils.revalidateIntents(engine, false);
}
}
export function scaleByCpuMem(baseValue: number, cpuMem: number, cpuMemScaling: 'normal' | 'less' | 'more' | 'minimal' | 'high' = 'normal') {
let valuePerCpu = baseValue / 2;
switch (cpuMemScaling) {
case 'high': valuePerCpu * 1.5; break;
case 'more': valuePerCpu * 1.25; break;
case 'less': valuePerCpu * .75; break;
case 'minimal': valuePerCpu * .5; break;
}
return Math.round(baseValue + ((cpuMem - 1) * valuePerCpu));
}
export function scaleByDifficulty(value: number, difficulty: number, decimals = 0) {
return round(value * Math.pow(1.1, difficulty - 1), decimals);
}
export function spawnEnemy(engine: GameEngine.IGameEngine, enemyClass: string, spawnIndex: number, generateIntent: boolean) {
const enemyFactory = engine.ruleset.enemyCards?.[enemyClass];
if (!enemyFactory) throw new Error('EnemyClass not found for spawning: ' + enemyClass);
const enemy = enemyFactory(engine);
enemy.enemyClass = enemyClass;
return addEnemy(engine, enemy, spawnIndex, generateIntent);
}
export function triggerMods<T extends CardMod.ModEvent>(ev: T, ...args: Parameters<NonNullable<CardMod[typeof ev]>>): ReturnType<NonNullable<CardMod[typeof ev]>>[] {
const deps = args[0];
const card = deps.sourceCard;
return [...card.mods]
.map(modData => (!card.isRemoved && card.mods.find(x => CardMod.areEqual(x, modData))) ? CardMod.trigger(ev, modData, ...args) : undefined)
.filter(Boolean);
}
}
|
src/game/game-engine-utils.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " });\n }\n static async requestCardTargets(gameId: string, playerId: string, cardId: number, scriptName: string) {\n const gameData = await _Engine.getGameData(gameId);\n const card = GameEngineUtils.findPlayerCardById(gameData, cardId);\n let targets = [] as number[];\n try {\n if (card.isUsed) {\n return;\n }",
"score": 0.8975968360900879
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " (engine, _sourceCard, targetCard) => {\n if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;\n const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);\n if (script.targetFinder === CardScript.TargetFinders.Self) return;\n const targets = script.targetFinder(engine.gameData, targetCard);\n if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;\n const origTargetId = targetCard.intent.targetCardId;\n while (targetCard.intent.targetCardId === origTargetId) {\n targetCard.intent.targetCardId = targets.random().id;\n }",
"score": 0.8890014886856079
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const scriptData = card.scripts.find(x => x[0] === scriptName);\n if (!scriptData) {\n throw new Error(`Script [${scriptName}] not found in card [${cardId}]`);\n }\n if (CardScript.isOnCooldown(scriptData)) {\n return;\n }\n const engine = new _Engine(gameData);\n const script = CardScript.deserialize(engine, card, scriptData);\n targets = script.targetFinder(gameData, card).map(x => x.id);",
"score": 0.8816360831260681
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " targetCardId: targetCard.id,\n scriptData: sourceCardScript,\n });\n if (this.isOnCooldown(sourceCardScript)) {\n throw new Error('Script is on cooldown: ' + sourceCardScript.join());\n }\n const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript));\n const isEnemy = GameEngineUtils.isEnemyCard(engine.gameData, sourceCard);\n if (!isEnemy) {\n if (!scriptDataFromCard) {",
"score": 0.8769189119338989
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());\n }\n }\n const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);\n if (cooldownData) {\n cooldownData[1] = cooldownData[2] + 1;\n }\n const script = this.deserialize(engine, sourceCard, sourceCardScript);\n const targets = script.targetFinder(engine.gameData, sourceCard);\n if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {",
"score": 0.8742970824241638
}
] |
typescript
|
const enemy = gameData.enemies.find(x => x.id === cardId);
|
import { randInt } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
const _cardMods = {
// Increases incoming damage
exposed: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public stackCount: number) {
super(arguments);
this.stackingConfig.stackCount = stackCount;
}
override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return { secDmgBonus: this.stackingConfig.stackCount };
}
},
// Returns damage to attacker
feedback: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public damage: number) {
super(arguments);
this.stackingConfig.stackCount = damage;
}
override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);
}
},
// Increases CPU
optimized: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(cpuBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = cpuBonus;
}
override onInitMod(deps: CardMod.ICardModDeps) {
GameEngineUtils.changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);
}
override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {
deps.sourceCard.cpu += stackDelta;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
override onRemoveMod(deps: CardMod.ICardModDeps) {
deps.sourceCard.cpu -= this.stackingConfig.stackCount;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
},
// Damages on turn end
virus: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public dot: number) {
super(arguments);
this.stackingConfig.stackCount = dot;
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);
}
},
};
const _cardScripts = {
//
// Backdoor scripts
//
// Swap MEM for CPU
bd_caching: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(-1),
CardScriptParts.ChangeCpu(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise MEM
bd_defrag: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memBonus = 1;
super(
[memBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 4;
}
},
// Heal over time
bd_diagnostics: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const duration = 1 + Math.round(card.mem / 2);
super(
[secBonus, duration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.diagnostics(secBonus, duration)
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Attack and stun (Backdoor finisher)
bd_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const stunDuration = 1;
super(
[damage, stunDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.AddMod(
new CardMod.Content.lag(stunDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and raise CPU on kill
bd_extraction: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Opponents(true)(gameData, card)
|
.filter(target => !target.sec && target.mem === 1),
[
{
|
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(1, true, true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.ChangeCpu(1),
],
},
],
);
}
},
// Raises CPU
bd_optimize: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Raises SEC
bd_patch: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 2;
}
},
// Steal SEC and remove Firewall (Backdoor finisher)
bd_proxy: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, card.cpu);
super(
[secDelta],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
}
},
// Steal SEC and causes offline (Backdoor finisher)
bd_reboot: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, _card.cpu);
const offlineDuration = 1;
super(
[secDelta, offlineDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 2;
}
},
// Cause Exposed (Backdoor finisher)
bd_trace: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(7, card.cpu);
super(
[stacks],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and remove 1 MEM
bd_tunnel: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memDmg = 1;
super(
[memDmg],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.MemDmg(memDmg),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 3;
}
},
//
// Bruteforce scripts
//
// Swap CPU for MEM
bf_compression: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.ChangeCpu(-1),
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Offline
bf_ddos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const offlineDuration = 1;
super(
[offlineDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Cause Lag
bf_dos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const lagDuration = 1;
super(
[lagDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Gain feedback
bf_feedback: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Triple SEC attack
bf_flood: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(3, card.cpu);
const numAttacks = 3;
super(
[damage, numAttacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
...Array.from(Array(numAttacks)).map(() => CardScriptParts.SecDmg(damage)),
],
}
],
);
this.cooldownMax = 2;
}
},
// AOE attack
bf_multicast: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.TargetAndAdjacents,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC
bf_obfuscate: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 3;
}
},
// Strong attack
bf_pod: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(16, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 2;
}
},
// Raises CPU
bf_precompute: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
//
// Malware scripts
//
// Causes Lag
mw_bloatware: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[1],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(1),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Swap for another card's secondary script
mw_copypaste: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, sourceCard, targetCard) => {
CardScript.removeScript(engine, sourceCard, _cardScripts.mw_copypaste);
if (!targetCard.scripts[1]) return;
CardScript.addScript(engine, sourceCard, CardScript.fromScriptName(engine, sourceCard, targetCard.scripts[1][0]));
},
],
}
],
);
}
},
// Grant Feedback
mw_honeypot: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Steal SEC
mw_leech: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[secDelta],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 1;
}
},
// Attack random target
mw_phishing: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(18, card.cpu);
super(
[minDamage, maxDamage],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomOpponent,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
this.cooldownMax = 1;
}
},
// Redistribute CPU/MEM
mw_reimage: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, _sourceCard, targetCard) => {
const totalStats = targetCard.cpu + targetCard.mem;
const newCpu = randInt(1, totalStats - 1);
const cpuDelta = newCpu - targetCard.cpu;
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
const newMem = totalStats - newCpu;
const memDelta = newMem - targetCard.mem;
GameEngineUtils.changeMem(engine, targetCard, memDelta);
},
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC on random ally
mw_shareware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);
super(
[minBonus, maxBonus],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomAlly,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 3;
}
},
// Redirect intent
mw_spoof: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RedirectIntentRandom,
],
}
],
);
}
},
// Cause Exposed
mw_spyware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[stacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Virus
mw_virus: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const dot = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[dot],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.virus(dot),
),
],
}
],
);
this.cooldownMax = 2;
}
},
};
export const GameContent_v1 = {
cardMods: _cardMods,
cardScripts: _cardScripts,
enemyCards: {},
initGame(_engine: GameEngine.IGameEngine) {
throw new Error('not a startable scenario');
},
addAdditionalScriptsFor(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState) {
if (card.card.tier < 2) return;
switch (card.card.faction) {
case 'backdoor':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bd_')).random()]).serialize());
return;
case 'bruteforce':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bf_')).random()]).serialize());
return;
case 'malware':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('mw_')).random()]).serialize());
return;
}
},
};
(GameContent_v1 as GameEngine.IRuleset);
|
src/game/game-content-v1.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n const bdChance = round(GameEngineUtils.scaleByCpuMem(40, card.mem, 'more') / 100, 2);\n super(\n [damage, bdChance],\n (gameData: GameEngine.IGameData, card: GameEngine.ICardState) => [\n ...TargetFinders.Opponents()(gameData, card),\n ...TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],\n TargetFinders.Opponents(true))(gameData, card),\n ],\n [",
"score": 0.8826591968536377
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " ],\n }\n ],\n );\n }\n }\n export class bd_secure extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);\n super(",
"score": 0.8755083084106445
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " )\n ),\n ],\n }\n ],\n );\n }\n }\n export class bd_exploit extends CardScript {\n constructor(card: GameEngine.ICardState) {",
"score": 0.867247998714447
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " // MUST always be the first parameter even if not used\n card: GameEngine.ICardState,\n // Not used but declared to show how the memo is passed back here, see first argument in super(...) below\n _secDamage: number,\n ) {\n const secDamage = GameEngineUtils.scaleByCpuMem(12, card.cpu);\n const bdChance = round(GameEngineUtils.scaleByCpuMem(20, card.mem, 'high') / 100, 2);\n const bdDamage = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n super(\n // Any extra data to serialize into scriptData[1:] as a 'memo' which can serve two purposes:",
"score": 0.861741304397583
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " );\n this.cooldownMax = 1;\n }\n }\n export class bf_spam extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n super(\n [damage],\n TargetFinders.Opponents(),",
"score": 0.8613052368164062
}
] |
typescript
|
.filter(target => !target.sec && target.mem === 1),
[
{
|
import { clamp, round } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
export namespace GameEngineUtils {
export function addEnemy(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, spawnIndex: number, generateIntent: boolean) {
if (engine.gameData.enemies.length >= engine.gameData.maxEnemies) return;
spawnIndex = clamp(spawnIndex, 0, engine.gameData.enemies.length);
engine.gameData.enemies.splice(spawnIndex, 0, enemy);
engine.broadcast.push({
type: 'cardAdded',
enemy,
position: spawnIndex,
});
GameEngineUtils.triggerMods('onInitMod', { engine, sourceCard: enemy });
if (generateIntent) {
GameEngineUtils.generateIntent(engine, enemy);
}
return enemy;
}
export function changeCardIsUsed(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState, isUsed: boolean) {
card.isUsed = isUsed;
engine.broadcast.push({
type: 'cardIsUsedChanged',
cardId: card.id,
isUsed,
});
}
export function clearIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = undefined;
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
});
return true;
}
export function changeCpu(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, cpuDelta: number) {
card.cpu += cpuDelta;
engine.broadcast.push({
type: 'cpuChanged',
cardId: card.id,
newCpu: card.cpu,
cpuDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeMem(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, memDelta: number) {
card.mem += memDelta;
engine.broadcast.push({
type: 'memChanged',
cardId: card.id,
newMem: card.mem,
memDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeSec(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, secDelta: number, isPassive: boolean, contextCard?: GameEngine.ICardState) {
const clampedSecDelta = (card.sec < -secDelta) ? -card.sec : secDelta;
card.sec += clampedSecDelta;
engine.broadcast.push({
type: isPassive ? 'secChange' : (secDelta < 0 ? 'secDamage' : 'secBonus'),
cardId: card.id,
newSec: card.sec,
value: secDelta,
});
if (!isPassive && contextCard) {
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
if (player) {
(clampedSecDelta >= 0) ? (player.stats.secBonus += clampedSecDelta) : (player.stats.secDmg += -clampedSecDelta);
}
}
}
export function executeIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, dontClearIntent = false) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = dontClearIntent ? enemy.intent : undefined;
let targetCard: GameEngine.ICardState | undefined;
if (intent.targetCardId >= 0) {
targetCard = findCardByIdMaybe(engine.gameData, intent.targetCardId);
if (!targetCard) {
// Intent target could've been removed between intent generation and execution
return false;
}
} else {
targetCard = enemy;
}
CardScript.execute(engine, enemy, intent.scriptData, targetCard);
return true;
}
export function findCardById(gameData: GameEngine.IGameData, cardId: number) {
const card = findCardByIdMaybe(gameData, cardId);
if (card) return card;
throw new Error('card not found');
}
export function findCardByIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
const enemy = gameData.enemies.find(x => x.id === cardId);
if (enemy) return enemy;
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) {
return player.cards.find(x => x.id === cardId);
}
return;
}
export function findPlayerCardById(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (!player) throw new Error('player not found');
return player.cards.find(x => x.id === cardId)!;
}
export function findPlayerByCardId(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) return player;
throw new Error('player not found');
}
export function findPlayerByCardIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
return [...gameData.players.values()].find(x => x.cards.find(x => x.id === cardId));
}
export function generateIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
enemy.intent = undefined;
const isOffline = !!enemy.mods.find(x => x[0] === 'offline');
if (isOffline) return;
const scriptData = enemy.scripts.filter(x => !CardScript.isOnCooldown(x)).randomOrUndefined();
if (!scriptData) {
return;
}
const script = CardScript.deserialize(engine, enemy, scriptData);
const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();
if (!target) {
return;
}
enemy.intent = {
scriptData,
targetCardId: target.id,
};
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
intent: enemy.intent,
});
}
export function getEnemyIds(gameData: GameEngine.IGameData) {
return gameData.enemies.map(x => x.id);
}
export function getPlayerIds(gameData: GameEngine.IGameData, ...excludePlayer: string[]) {
return [...gameData.players.keys()].filter(x => !excludePlayer.includes(x));
}
export function getPlayerCards(gameData: GameEngine.IGameData) {
return [...gameData.players.values()].map(x => x.cards).flat();
}
export function getPlayerCardIds(gameData: GameEngine.IGameData) {
return getPlayerCards(gameData).map(x => x.id);
}
export function isEnemyCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IEnemyCardState {
return !!gameData.enemies.find(x => x.id === card.id);
}
export function isPlayerCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IPlayerCardState {
return !isEnemyCard(gameData, card);
}
export function recalculateScripts(engine: GameEngine.IGameEngine, card: GameEngine.ICardState) {
if (card.isRemoved) return;
card.scripts = card.scripts.map(x => CardScript.deserialize(engine, card, x).serialize());
engine.broadcast.push(...card.scripts.map(x => ({
type: 'scriptChanged',
cardId: card.id,
scriptData: x,
})));
if (isEnemyCard(engine.gameData, card) && card.intent?.scriptData) {
card.intent.scriptData = CardScript.deserialize(engine, card, card.intent.scriptData).serialize();
engine.broadcast.push({
type: 'cardIntent',
cardId: card.id,
intent: card.intent,
});
}
}
export function revalidateIntents(engine: GameEngine.IGameEngine, regenerateIfInvalid: boolean) {
for (const enemy of engine.gameData.enemies) {
if (!enemy.intent || enemy.intent.targetCardId === -1) {
continue;
}
const script = CardScript.deserialize(engine, enemy, enemy.intent.scriptData);
const validTargets = script.targetFinder(engine.gameData, enemy);
if (validTargets.find(x => x.id === enemy.intent?.targetCardId)) {
continue;
}
enemy.intent = undefined;
if (regenerateIfInvalid) {
generateIntent(engine, enemy);
}
}
}
export function removeCard(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, contextCard?: GameEngine.ICardState) {
if (card.isRemoved) {
return;
}
if (isEnemyCard(engine.gameData, card)) {
engine.gameData.enemies.removeFirst(card)
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
for (const enemy of [...engine.gameData.enemies]) {
if (enemy.isRemoved) continue;
triggerMods('onEnemyDestroyed', { engine, sourceCard: card, contextCard });
}
if (contextCard) {
const player = findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
player && player.stats.kills++;
}
GameEngineUtils.revalidateIntents(engine, true);
} else {
const player = GameEngineUtils.findPlayerByCardId(engine.gameData, card.id);
player.cards.removeFirst(card);
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
GameEngineUtils.revalidateIntents(engine, false);
}
}
export function scaleByCpuMem(baseValue: number, cpuMem: number, cpuMemScaling: 'normal' | 'less' | 'more' | 'minimal' | 'high' = 'normal') {
let valuePerCpu = baseValue / 2;
switch (cpuMemScaling) {
case 'high': valuePerCpu * 1.5; break;
case 'more': valuePerCpu * 1.25; break;
case 'less': valuePerCpu * .75; break;
case 'minimal': valuePerCpu * .5; break;
}
return Math.round(baseValue + ((cpuMem - 1) * valuePerCpu));
}
export function scaleByDifficulty(value: number, difficulty: number, decimals = 0) {
return round(value * Math.pow(1.1, difficulty - 1), decimals);
}
export function spawnEnemy(engine: GameEngine.IGameEngine, enemyClass: string, spawnIndex: number, generateIntent: boolean) {
const enemyFactory = engine.ruleset.enemyCards?.[enemyClass];
if (!enemyFactory) throw new Error('EnemyClass not found for spawning: ' + enemyClass);
const enemy = enemyFactory(engine);
enemy.enemyClass = enemyClass;
return addEnemy(engine, enemy, spawnIndex, generateIntent);
}
export function triggerMods<T extends CardMod.ModEvent>(ev: T, ...args: Parameters<NonNullable<CardMod[typeof ev]>>): ReturnType<NonNullable<CardMod[typeof ev]>>[] {
const deps = args[0];
|
const card = deps.sourceCard;
|
return [...card.mods]
.map(modData => (!card.isRemoved && card.mods.find(x => CardMod.areEqual(x, modData))) ? CardMod.trigger(ev, modData, ...args) : undefined)
.filter(Boolean);
}
}
|
src/game/game-engine-utils.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " throw new Error(`Could not find [${modName}] to remove`);\n }\n }\n CardMod.removeModByName(engine, targetCard, modName, sourceCard);\n };\n export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>\n (engine, sourceCard, _targetCard) => {\n let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);\n switch (spawnPosition) {\n case 'absLeft': spawnIndex = 0; break;",
"score": 0.8980243802070618
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " case 'absRight': spawnIndex = engine.gameData.enemies.length; break;\n case 'relRight': spawnIndex++; break;\n }\n GameEngineUtils.spawnEnemy(engine, enemyClass, spawnIndex, generateIntent);\n };\n}",
"score": 0.86778724193573
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " this.cooldownCur = startingCooldown;\n this.cooldownMax = cooldown;\n }\n }\n export class _spawn extends CardScript {\n constructor(_card: GameEngine.ICardState, enemyClass: string, spawnPosition: Parameters<typeof CardScriptParts['SpawnEnemy']>[1] = 'relLeft', generateIntent = false, cooldown = 0) {\n super(\n [enemyClass, spawnPosition, generateIntent, cooldown],\n TargetFinders.Self,\n [",
"score": 0.8588560819625854
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {\n const mod = card.mods.find(x => x[0] === modName);\n mod && this.removeMod(engine, card, mod, contextCard);\n }\n static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {\n const deps = args[0];\n const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));\n if (!modDataFromCard) {\n throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);\n }",
"score": 0.8533143997192383
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Self,\n parts: [\n CardScriptParts.SpawnEnemy(enemyClass, spawnPosition, generateIntent),\n ],\n }\n ],\n );\n this.cooldownMax = cooldown;\n }",
"score": 0.8517571687698364
}
] |
typescript
|
const card = deps.sourceCard;
|
import * as moment from 'moment';
import { IAppraisedCard, appraiseCard } from '../appraise';
import { IDataSource, IMetricsProvider, IPlayerPushProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { SECS_IN_MIN } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameContent_v1 } from './game-content-v1';
import { GameEngineUtils } from './game-engine-utils';
export namespace GameEngine {
interface _ICommonCardState {
id: number;
cpu: number;
mem: number;
sec: number;
mods: CardMod.ModData[];
scripts: CardScript.ScriptData[];
isRemoved?: boolean;
}
export interface IGameData {
id: string;
difficulty: number;
state: 'created' | 'started' | 'players_won' | 'players_lost' | 'abandoned';
enemies: IEnemyCardState[];
maxEnemies: number;
players: Map<string, IPlayerState>;
defaultMovesPerTurn: number;
turn: number;
nextId: number;
pendingPlayers: Map<string, string[]>;
rulesetIds: string[];
}
export interface IPlayerState {
id: string;
cards: IPlayerCardState[];
endedTurn: boolean;
idleKickTime: number;
movesLeft: number;
movesPerTurn: number;
score: number;
stats: {
kills: number;
secDmg: number;
memDmg: number;
secBonus: number;
};
}
export interface IPlayerCardState extends _ICommonCardState {
card: IAppraisedCard;
isUsed: boolean;
}
export interface IEnemyCardState extends _ICommonCardState {
enemyClass: string;
intent?: { scriptData: CardScript.ScriptData, targetCardId: number };
maxMem: number;
}
export type ICardState = IPlayerCardState | IEnemyCardState;
export abstract class GameEngineError extends Error {
constructor(
public gameId: string,
) {
super();
this.message = `${this.constructor.name} processing game ${gameId}`;
}
}
export class GameNotFoundError extends GameEngineError { }
export interface IRulesetContent {
cardMods?: CardMod.ModLibrary;
cardScripts?: CardScript.ScriptLibrary;
enemyCards?: Record<string, (engine: IGameEngine) => IEnemyCardState>;
}
export interface IRuleset extends IRulesetContent {
initGame(engine: IGameEngine): void;
addAdditionalScriptsFor?(engine: GameEngine.IGameEngine, card: IPlayerCardState): void;
}
export function mergeRulesetContents(...rulesets: IRulesetContent[]): IRulesetContent {
const modLibs = rulesets.map(x => x.cardMods).filter(Boolean);
const scriptLibs = rulesets.map(x => x.cardScripts).filter(Boolean);
const enemyLibs = rulesets.map(x => x.enemyCards).filter(Boolean);
return {
cardMods: Object.fromEntries(modLibs.map(modLib => Object.keys(modLib).map(modName => [modName, modLib[modName]!] as const)).flat()),
cardScripts: Object.fromEntries(scriptLibs.map(scriptLib => Object.keys(scriptLib).map(scriptName => [scriptName, scriptLib[scriptName]!] as const)).flat()),
enemyCards: Object.fromEntries(enemyLibs.map(enemyLib => Object.keys(enemyLib).map(enemyClass => [enemyClass, enemyLib[enemyClass]!] as const)).flat()),
};
}
export type IGameEngine = InstanceType<ReturnType<typeof createGameEngineProvider>>;
}
export const createGameEngineProvider = (rulesets: Record<string, GameEngine.IRuleset>, ds: IDataSource, playerPushProvider: IPlayerPushProvider, metrics?: IMetricsProvider) => {
return class _Engine {
readonly broadcast: IPlayerPushProvider.IPushMessage[] = [];
ruleset!: GameEngine.IRuleset;
constructor(
readonly gameData: GameEngine.IGameData,
) {
const currentRuleset = rulesets[gameData.rulesetIds.at(-1)!];
if (!currentRuleset) throw new Error('invalid initial ruleSet id: ' + gameData.rulesetIds[0]);
this._setRuleset(currentRuleset);
}
private static async _withEngine(gameId: string, stateAssertion: GameEngine.IGameData['state'][], func: (engine: _Engine) => Promise<void>): Promise<GameEngine.IGameData> {
|
const gameData = await ds.GameData.get(gameId);
|
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
const engine = new _Engine(gameData);
try {
if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);
await func(engine);
await ds.GameData.update.exec(gameData);
} catch (e: any) {
e.broadcast = engine.broadcast;
throw e;
}
if (engine.broadcast.length) {
await Promise.all(
[...gameData.players.keys()].map(playerId => playerPushProvider.push(playerId, engine.broadcast)),
);
}
return gameData;
}
static async createGame(gameId: string, rulesetId: string, difficulty: number) {
const ruleset = rulesets[rulesetId];
if (!ruleset) throw new Error('invalid ruleSet id: ' + rulesetId);
const existingGameData = await ds.GameData.get(gameId);
if (existingGameData) throw new Error('game with id already exists: ' + gameId);
const gameData: GameEngine.IGameData = {
id: gameId,
difficulty: Math.max(1, difficulty),
state: 'created',
turn: 1,
players: new Map(),
defaultMovesPerTurn: 3,
enemies: [],
maxEnemies: 9,
nextId: 1,
pendingPlayers: new Map(),
rulesetIds: [rulesetId],
};
await ds.GameData.update.exec(gameData);
}
static async startGame(gameId: string) {
const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {
for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
engine.broadcast.push({ type: 'playerJoin', playerState });
}
engine.gameData.pendingPlayers.clear();
engine.gameData.state = 'started';
engine.broadcast.push({ type: 'gameStart' });
engine.ruleset.initGame(engine);
});
return gameData;
}
static async endGame(gameId: string) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
engine.gameData.state = 'abandoned';
engine.broadcast.push({ type: 'gameEnd' });
});
}
static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
if (engine.gameData.players.has(playerId)) throw new Error('player already in game');
if (engine.gameData.players.size >= 2) throw new Error('game is full: ' + gameId);
if (engine.gameData.state === 'started') {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
if (engine.gameData.turn >= 2) {
playerState.endedTurn = true;
playerState.movesLeft = 0;
}
engine.broadcast.push({
type: 'playerJoin',
playerState,
});
} else {
engine.gameData.pendingPlayers.set(playerId, cardIds);
}
});
}
static async removePlayer(gameId: string, playerId: string, reason: 'idle' | 'leave') {
return await _Engine._withEngine(gameId, [], async engine => {
if (!engine.gameData.players.delete(playerId)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId, reason });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
});
}
static async requestCardTargets(gameId: string, playerId: string, cardId: number, scriptName: string) {
const gameData = await _Engine.getGameData(gameId);
const card = GameEngineUtils.findPlayerCardById(gameData, cardId);
let targets = [] as number[];
try {
if (card.isUsed) {
return;
}
const scriptData = card.scripts.find(x => x[0] === scriptName);
if (!scriptData) {
throw new Error(`Script [${scriptName}] not found in card [${cardId}]`);
}
if (CardScript.isOnCooldown(scriptData)) {
return;
}
const engine = new _Engine(gameData);
const script = CardScript.deserialize(engine, card, scriptData);
targets = script.targetFinder(gameData, card).map(x => x.id);
} finally {
await playerPushProvider.push(playerId, [{
type: 'cardTargets',
cardId,
scriptName,
targetCardIds: targets,
}]);
}
}
static async intent(gameId: string, playerId: string, sourceCardId?: string, sourceCardScript?: string, targetCardId?: string) {
const gameData = await _Engine.getGameData(gameId);
const pushMessage: IPlayerPushProvider.IPushMessage[] = [{
type: 'cardIntent',
cardId: sourceCardId,
intent: {
scriptData: sourceCardScript,
targetCardId,
},
playerId,
}];
await Promise.all(
[...gameData.players.keys()].filter(x => x !== playerId).map(x => playerPushProvider?.push(x, pushMessage)),
);
}
static async makeMove(gameId: string, playerId: string, sourceCardId: number, sourceCardScript: CardScript.ScriptData, targetCardId: number) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = GameEngineUtils.findPlayerByCardId(engine.gameData, sourceCardId);
if (playerState.id !== playerId) {
throw new Error(`Player ${playerId} cannot make move on card ${sourceCardId} from owner ${playerState.id}`);
}
if (!playerState.movesLeft) {
throw new Error(`No moves left`);
}
const sourceCard = playerState.cards.find(x => x.id === sourceCardId)!;
if (sourceCard.isUsed) {
throw new Error(`Card is used`);
}
const now = moment.now();
playerState.idleKickTime = now + 2 * SECS_IN_MIN * 1000;
playerState.movesLeft--;
const targetCard = GameEngineUtils.findCardById(engine.gameData, targetCardId);
CardScript.execute(engine, sourceCard, sourceCardScript, targetCard);
GameEngineUtils.changeCardIsUsed(engine, sourceCard, true);
metrics?.playerCardPlayed(gameId, engine.gameData.rulesetIds[0] || 'unknown', playerId, sourceCard, sourceCardScript[0]);
});
}
static async toggleEndTurn(gameId: string, playerId: string) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = engine.gameData.players.get(playerId);
if (!playerState) throw new Error('player not found');
if (playerState.endedTurn) {
playerState.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: false,
});
return;
}
playerState.endedTurn = true;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: true,
});
if (![...engine.gameData.players.values()].reduce((numNotReady, playerState) => playerState.endedTurn ? numNotReady : (numNotReady + 1), 0)) {
const now = moment.now();
[...engine.gameData.players.values()].forEach(x => x.idleKickTime = now + 2 * SECS_IN_MIN * 1000);
engine.onEndTurn();
if (engine.gameData.state !== 'started') {
// Stop if the game was won/lost due to an EndTurn effect
return;
}
engine.onTurnStart();
}
});
}
static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {
let kickedPlayerId = '';
await _Engine._withEngine(gameId, ['started'], async engine => {
const playerToKick = [...engine.gameData.players.values()].find(x => x.id !== kickRequestingPlayerId) || '';
if (!playerToKick) throw new Error('kickIfIdle: player not found');
if (playerToKick.idleKickTime < moment.now()) {
if (!engine.gameData.players.delete(playerToKick.id)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId: playerToKick.id, reason: 'idle' });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
kickedPlayerId = playerToKick.id;
}
});
return kickedPlayerId || null;
}
static async getGameData(gameId: string) {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
return gameData;
}
private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {
const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))
.filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)
.map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));
if (cards.length !== cardIds.length) {
throw `could not resolve all cards for player ${playerId}`;
}
const player: GameEngine.IPlayerState = {
id: playerId,
cards: cards.map(card => ({
id: this.nextId(),
card,
isUsed: false,
cpu: card.cpu,
mem: card.mem,
sec: card.mem * 6 + card.cpu * 3,
mods: [],
scripts: [],
})),
endedTurn: false,
movesLeft: this.gameData.defaultMovesPerTurn,
movesPerTurn: this.gameData.defaultMovesPerTurn,
stats: {
kills: 0,
memDmg: 0,
secBonus: 0,
secDmg: 0,
},
score: 0,
idleKickTime: moment.now() + 2 * SECS_IN_MIN * 1000,
};
for (const card of player.cards) {
card.scripts = [
CardScript.fromScriptName(this, card, card.card.coreScript),
];
this.ruleset.addAdditionalScriptsFor && this.ruleset.addAdditionalScriptsFor(this, card);
}
return player;
}
findRuleset(rulesetId: string) {
return rulesets[rulesetId];
}
onTurnStart() {
this.gameData.turn++;
this.broadcast.push({
type: 'newTurn',
turn: this.gameData.turn,
});
for (const player of this.gameData.players.values()) {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
}
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of playerCards) {
GameEngineUtils.changeCardIsUsed(this, playerCard, false);
}
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: playerCard });
}
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: enemy });
}
this._checkGameOver();
}
onEndTurn() {
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: playerCard });
CardScript.tickCooldowns(playerCard, this.broadcast);
}
this.broadcast.push({
type: 'playerTurnEnded',
});
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: enemy });
CardScript.tickCooldowns(enemy, this.broadcast);
}
this.broadcast.push({
type: 'enemyTurnEnded',
});
this._checkGameOver();
}
onNextWave(nextRulesetId: string) {
while (this.gameData.enemies[0]) {
GameEngineUtils.removeCard(this, this.gameData.enemies[0]);
}
[...this.gameData.players.values()].forEach(player => {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
player.cards.forEach(card => {
card.isUsed = false;
});
});
this.gameData.turn++;
this.broadcast.push({
type: 'nextWave',
turn: this.gameData.turn,
nextRulesetId,
});
const nextRuleset = this.findRuleset(nextRulesetId);
if (!nextRuleset) {
throw new Error('invalid rulesetId: ' + nextRulesetId);
}
this.gameData.rulesetIds.push(nextRulesetId);
this._setRuleset(nextRuleset);
nextRuleset.initGame(this);
}
onWinGame() {
this.gameData.state = 'players_won';
this.broadcast.push({
type: 'players_won',
stats: [...this.gameData.players.values()].map(player => {
let score =
player.cards.length * 50
+ player.stats.kills * 25
+ player.stats.memDmg * 50
+ player.stats.secDmg
+ player.stats.secBonus * 2
+ ((this.gameData.rulesetIds.length - 1) * 2000);
score = GameEngineUtils.scaleByDifficulty(score, this.gameData.difficulty + 1);
player.score = score;
return { playerId: player.id, stats: player.stats, score };
}),
});
}
nextId() {
return this.gameData.nextId++;
}
private _checkGameOver() {
if (!GameEngineUtils.getPlayerCards(this.gameData).length) {
this.gameData.state = 'players_lost';
this.broadcast.push({
type: 'players_lost',
});
}
}
private _setRuleset(nextRuleset: GameEngine.IRuleset) {
this.ruleset = {
addAdditionalScriptsFor: GameContent_v1.addAdditionalScriptsFor,
...nextRuleset,
...GameEngine.mergeRulesetContents(
nextRuleset,
{
cardMods: CardMod.Content,
cardScripts: CardScript.Content,
},
{
cardMods: GameContent_v1.cardMods,
cardScripts: GameContent_v1.cardScripts,
enemyCards: GameContent_v1.enemyCards,
}
),
};
}
}
}
export type GameEngineProvider = ReturnType<typeof createGameEngineProvider>;
|
src/game/game-engine.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);\n await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));\n if (payload.gameVisibility === 'solo') {\n await _onGameStart(game, false);\n }\n player.activeGameId = game.id;\n await ds.execUpdates(\n ds.CoopGames.update.make(game),\n ds.Players.update.make(player),\n );",
"score": 0.8344691395759583
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " game.startedAt = now.format(FULL_DATETIME_FORMAT);\n game._dbTtl = 9999999999;\n await ds.CoopGames.update.exec(game);\n metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);\n }\n async function _expectAuthPlayerInGame(req: IHttpRequest) {\n const player = await authProvider.getPlayerFromRequest(req);\n if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');\n const game = await ds.CoopGames.get(player.activeGameId);\n if (game) {",
"score": 0.8213914632797241
},
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " nftOwnershipConflict(playerId: string): void;\n gameCreated(gameId: string, playerId: string, initialRulesetId: string, visibility: string, difficulty: number): void;\n gameStarted(gameId: string, initialRulesetId: string, players: string[], fromMatchmaking: boolean): void;\n gameJoined(gameId: string, midGame: boolean): void;\n gameEnded(gameId: string, result: string, rulesets: string[], players: string[], turns: number, totalScore: number): void;\n playerCardPlayed(gameId: string, currentRulesetId: string, playerId: string, card: GameEngine.IPlayerCardState, scriptName: string): void;\n idlePlayerRemoved(gameId: string, idlePlayerId: string): void;\n flush(): Promise<void>;\n}",
"score": 0.8167908191680908
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " gameData?.rulesetIds || [],\n [...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),\n );\n const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {\n const player = await ds.Players.get(playerId);\n if (!player) {\n console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);\n return;\n }\n if (player.activeGameId === game.id) {",
"score": 0.8150997161865234
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " },\n initGame(engine: GameEngine.IGameEngine) {\n const boss: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n enemyClass: 'intro_boss',\n cpu: 3,\n mem: 3,\n maxMem: 3,\n sec: GameEngineUtils.scaleByDifficulty(125, engine.gameData.difficulty),\n mods: [],",
"score": 0.8142483234405518
}
] |
typescript
|
const gameData = await ds.GameData.get(gameId);
|
import { randInt } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
const _cardMods = {
// Increases incoming damage
exposed: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public stackCount: number) {
super(arguments);
this.stackingConfig.stackCount = stackCount;
}
override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return { secDmgBonus: this.stackingConfig.stackCount };
}
},
// Returns damage to attacker
feedback: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public damage: number) {
super(arguments);
this.stackingConfig.stackCount = damage;
}
override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);
}
},
// Increases CPU
optimized: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(cpuBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = cpuBonus;
}
override onInitMod(deps: CardMod.ICardModDeps) {
GameEngineUtils.changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);
}
override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {
deps.sourceCard.cpu += stackDelta;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
override onRemoveMod(deps: CardMod.ICardModDeps) {
deps.sourceCard.cpu -= this.stackingConfig.stackCount;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
},
// Damages on turn end
virus: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public dot: number) {
super(arguments);
this.stackingConfig.stackCount = dot;
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);
}
},
};
const _cardScripts = {
//
// Backdoor scripts
//
// Swap MEM for CPU
bd_caching: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) => CardScript.
|
TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),
[
{
|
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(-1),
CardScriptParts.ChangeCpu(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise MEM
bd_defrag: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memBonus = 1;
super(
[memBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 4;
}
},
// Heal over time
bd_diagnostics: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const duration = 1 + Math.round(card.mem / 2);
super(
[secBonus, duration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.diagnostics(secBonus, duration)
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Attack and stun (Backdoor finisher)
bd_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const stunDuration = 1;
super(
[damage, stunDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.AddMod(
new CardMod.Content.lag(stunDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and raise CPU on kill
bd_extraction: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Opponents(true)(gameData, card)
.filter(target => !target.sec && target.mem === 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(1, true, true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.ChangeCpu(1),
],
},
],
);
}
},
// Raises CPU
bd_optimize: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Raises SEC
bd_patch: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 2;
}
},
// Steal SEC and remove Firewall (Backdoor finisher)
bd_proxy: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, card.cpu);
super(
[secDelta],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
}
},
// Steal SEC and causes offline (Backdoor finisher)
bd_reboot: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, _card.cpu);
const offlineDuration = 1;
super(
[secDelta, offlineDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 2;
}
},
// Cause Exposed (Backdoor finisher)
bd_trace: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(7, card.cpu);
super(
[stacks],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and remove 1 MEM
bd_tunnel: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memDmg = 1;
super(
[memDmg],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.MemDmg(memDmg),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 3;
}
},
//
// Bruteforce scripts
//
// Swap CPU for MEM
bf_compression: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.ChangeCpu(-1),
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Offline
bf_ddos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const offlineDuration = 1;
super(
[offlineDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Cause Lag
bf_dos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const lagDuration = 1;
super(
[lagDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Gain feedback
bf_feedback: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Triple SEC attack
bf_flood: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(3, card.cpu);
const numAttacks = 3;
super(
[damage, numAttacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
...Array.from(Array(numAttacks)).map(() => CardScriptParts.SecDmg(damage)),
],
}
],
);
this.cooldownMax = 2;
}
},
// AOE attack
bf_multicast: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.TargetAndAdjacents,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC
bf_obfuscate: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 3;
}
},
// Strong attack
bf_pod: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(16, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 2;
}
},
// Raises CPU
bf_precompute: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
//
// Malware scripts
//
// Causes Lag
mw_bloatware: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[1],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(1),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Swap for another card's secondary script
mw_copypaste: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, sourceCard, targetCard) => {
CardScript.removeScript(engine, sourceCard, _cardScripts.mw_copypaste);
if (!targetCard.scripts[1]) return;
CardScript.addScript(engine, sourceCard, CardScript.fromScriptName(engine, sourceCard, targetCard.scripts[1][0]));
},
],
}
],
);
}
},
// Grant Feedback
mw_honeypot: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Steal SEC
mw_leech: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[secDelta],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 1;
}
},
// Attack random target
mw_phishing: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(18, card.cpu);
super(
[minDamage, maxDamage],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomOpponent,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
this.cooldownMax = 1;
}
},
// Redistribute CPU/MEM
mw_reimage: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, _sourceCard, targetCard) => {
const totalStats = targetCard.cpu + targetCard.mem;
const newCpu = randInt(1, totalStats - 1);
const cpuDelta = newCpu - targetCard.cpu;
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
const newMem = totalStats - newCpu;
const memDelta = newMem - targetCard.mem;
GameEngineUtils.changeMem(engine, targetCard, memDelta);
},
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC on random ally
mw_shareware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);
super(
[minBonus, maxBonus],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomAlly,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 3;
}
},
// Redirect intent
mw_spoof: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RedirectIntentRandom,
],
}
],
);
}
},
// Cause Exposed
mw_spyware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[stacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Virus
mw_virus: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const dot = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[dot],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.virus(dot),
),
],
}
],
);
this.cooldownMax = 2;
}
},
};
export const GameContent_v1 = {
cardMods: _cardMods,
cardScripts: _cardScripts,
enemyCards: {},
initGame(_engine: GameEngine.IGameEngine) {
throw new Error('not a startable scenario');
},
addAdditionalScriptsFor(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState) {
if (card.card.tier < 2) return;
switch (card.card.faction) {
case 'backdoor':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bd_')).random()]).serialize());
return;
case 'bruteforce':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bf_')).random()]).serialize());
return;
case 'malware':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('mw_')).random()]).serialize());
return;
}
},
};
(GameContent_v1 as GameEngine.IRuleset);
|
src/game/game-content-v1.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " ],\n }\n ],\n );\n }\n }\n export class bd_secure extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);\n super(",
"score": 0.872357189655304
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n const bdChance = round(GameEngineUtils.scaleByCpuMem(40, card.mem, 'more') / 100, 2);\n super(\n [damage, bdChance],\n (gameData: GameEngine.IGameData, card: GameEngine.ICardState) => [\n ...TargetFinders.Opponents()(gameData, card),\n ...TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],\n TargetFinders.Opponents(true))(gameData, card),\n ],\n [",
"score": 0.8655152916908264
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " }\n }\n export class mw_redirect extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const tempSecBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);\n const duration = Math.ceil(card.mem / 2);\n super(\n [tempSecBonus, duration],\n TargetFinders.Allies(true),\n [",
"score": 0.8641084432601929
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " export function changeMem(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, memDelta: number) {\n card.mem += memDelta;\n engine.broadcast.push({\n type: 'memChanged',\n cardId: card.id,\n newMem: card.mem,\n memDelta,\n });\n GameEngineUtils.recalculateScripts(engine, card);\n }",
"score": 0.8599293231964111
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " };\n export const ChangeCpu = (cpuDelta: number): IScriptPart =>\n (engine, _sourceCard, targetCard) => {\n GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);\n };\n export const RaiseMem = (memBonus: number): IScriptPart =>\n (engine, _sourceCard, targetCard) => {\n targetCard.mem += memBonus;\n engine.broadcast.push({\n type: 'memBonus',",
"score": 0.8594309091567993
}
] |
typescript
|
TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),
[
{
|
import { clamp, round } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
export namespace GameEngineUtils {
export function addEnemy(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, spawnIndex: number, generateIntent: boolean) {
if (engine.gameData.enemies.length >= engine.gameData.maxEnemies) return;
spawnIndex = clamp(spawnIndex, 0, engine.gameData.enemies.length);
engine.gameData.enemies.splice(spawnIndex, 0, enemy);
engine.broadcast.push({
type: 'cardAdded',
enemy,
position: spawnIndex,
});
GameEngineUtils.triggerMods('onInitMod', { engine, sourceCard: enemy });
if (generateIntent) {
GameEngineUtils.generateIntent(engine, enemy);
}
return enemy;
}
export function changeCardIsUsed(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState, isUsed: boolean) {
card.isUsed = isUsed;
engine.broadcast.push({
type: 'cardIsUsedChanged',
cardId: card.id,
isUsed,
});
}
export function clearIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = undefined;
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
});
return true;
}
export function changeCpu(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, cpuDelta: number) {
card.cpu += cpuDelta;
engine.broadcast.push({
type: 'cpuChanged',
cardId: card.id,
newCpu: card.cpu,
cpuDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeMem(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, memDelta: number) {
card.mem += memDelta;
engine.broadcast.push({
type: 'memChanged',
cardId: card.id,
newMem: card.mem,
memDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeSec(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, secDelta: number, isPassive: boolean, contextCard?: GameEngine.ICardState) {
const clampedSecDelta = (card.sec < -secDelta) ? -card.sec : secDelta;
card.sec += clampedSecDelta;
engine.broadcast.push({
type: isPassive ? 'secChange' : (secDelta < 0 ? 'secDamage' : 'secBonus'),
cardId: card.id,
newSec: card.sec,
value: secDelta,
});
if (!isPassive && contextCard) {
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
if (player) {
(clampedSecDelta >= 0) ? (player.stats.secBonus += clampedSecDelta) : (player.stats.secDmg += -clampedSecDelta);
}
}
}
export function executeIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, dontClearIntent = false) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = dontClearIntent ? enemy.intent : undefined;
let targetCard: GameEngine.ICardState | undefined;
if (intent.targetCardId >= 0) {
targetCard = findCardByIdMaybe(engine.gameData, intent.targetCardId);
if (!targetCard) {
// Intent target could've been removed between intent generation and execution
return false;
}
} else {
targetCard = enemy;
}
CardScript.execute(engine, enemy, intent.scriptData, targetCard);
return true;
}
export function findCardById(gameData: GameEngine.IGameData, cardId: number) {
const card = findCardByIdMaybe(gameData, cardId);
if (card) return card;
throw new Error('card not found');
}
export function findCardByIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
const enemy = gameData.enemies.find(x => x.id === cardId);
if (enemy) return enemy;
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) {
return player.cards.find(x => x.id === cardId);
}
return;
}
export function findPlayerCardById(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (!player) throw new Error('player not found');
return player.cards.find(x => x.id === cardId)!;
}
export function findPlayerByCardId(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) return player;
throw new Error('player not found');
}
export function findPlayerByCardIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
return [...gameData.players.values()].find(x => x.cards.find(x => x.id === cardId));
}
export function generateIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
enemy.intent = undefined;
const isOffline = !!enemy.mods.find(x => x[0] === 'offline');
if (isOffline) return;
const scriptData = enemy.scripts.filter(x => !CardScript.isOnCooldown(x)).randomOrUndefined();
if (!scriptData) {
return;
}
const script = CardScript.deserialize(engine, enemy, scriptData);
const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();
if (!target) {
return;
}
enemy.intent = {
scriptData,
targetCardId: target.id,
};
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
intent: enemy.intent,
});
}
export function getEnemyIds(gameData: GameEngine.IGameData) {
return gameData.enemies.map(x => x.id);
}
export function getPlayerIds(gameData: GameEngine.IGameData, ...excludePlayer: string[]) {
return [...gameData.players.keys()].filter(x => !excludePlayer.includes(x));
}
export function getPlayerCards(gameData: GameEngine.IGameData) {
return [...gameData.players.values()].map(x => x.cards).flat();
}
export function getPlayerCardIds(gameData: GameEngine.IGameData) {
return getPlayerCards(gameData).map(x => x.id);
}
export function isEnemyCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IEnemyCardState {
return !!gameData.enemies.find(x => x.id === card.id);
}
export function isPlayerCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IPlayerCardState {
return !isEnemyCard(gameData, card);
}
export function recalculateScripts(engine: GameEngine.IGameEngine, card: GameEngine.ICardState) {
if (card.isRemoved) return;
card.scripts = card.scripts.map(x => CardScript.deserialize(engine, card, x).serialize());
engine.broadcast.push(...card.scripts.map(x => ({
type: 'scriptChanged',
cardId: card.id,
scriptData: x,
})));
if (isEnemyCard(engine.gameData, card) && card.intent?.scriptData) {
card.intent.scriptData = CardScript.deserialize(engine, card, card.intent.scriptData).serialize();
engine.broadcast.push({
type: 'cardIntent',
cardId: card.id,
intent: card.intent,
});
}
}
export function revalidateIntents(engine: GameEngine.IGameEngine, regenerateIfInvalid: boolean) {
for (const enemy of engine.gameData.enemies) {
if (!enemy.intent || enemy.intent.targetCardId === -1) {
continue;
}
const script = CardScript.deserialize(engine, enemy, enemy.intent.scriptData);
const validTargets = script.targetFinder(engine.gameData, enemy);
if (validTargets.find(x => x.id === enemy.intent?.targetCardId)) {
continue;
}
enemy.intent = undefined;
if (regenerateIfInvalid) {
generateIntent(engine, enemy);
}
}
}
export function removeCard(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, contextCard?: GameEngine.ICardState) {
if (card.isRemoved) {
return;
}
if (isEnemyCard(engine.gameData, card)) {
engine.gameData.enemies.removeFirst(card)
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
|
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
|
card.isRemoved = true;
for (const enemy of [...engine.gameData.enemies]) {
if (enemy.isRemoved) continue;
triggerMods('onEnemyDestroyed', { engine, sourceCard: card, contextCard });
}
if (contextCard) {
const player = findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
player && player.stats.kills++;
}
GameEngineUtils.revalidateIntents(engine, true);
} else {
const player = GameEngineUtils.findPlayerByCardId(engine.gameData, card.id);
player.cards.removeFirst(card);
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
GameEngineUtils.revalidateIntents(engine, false);
}
}
export function scaleByCpuMem(baseValue: number, cpuMem: number, cpuMemScaling: 'normal' | 'less' | 'more' | 'minimal' | 'high' = 'normal') {
let valuePerCpu = baseValue / 2;
switch (cpuMemScaling) {
case 'high': valuePerCpu * 1.5; break;
case 'more': valuePerCpu * 1.25; break;
case 'less': valuePerCpu * .75; break;
case 'minimal': valuePerCpu * .5; break;
}
return Math.round(baseValue + ((cpuMem - 1) * valuePerCpu));
}
export function scaleByDifficulty(value: number, difficulty: number, decimals = 0) {
return round(value * Math.pow(1.1, difficulty - 1), decimals);
}
export function spawnEnemy(engine: GameEngine.IGameEngine, enemyClass: string, spawnIndex: number, generateIntent: boolean) {
const enemyFactory = engine.ruleset.enemyCards?.[enemyClass];
if (!enemyFactory) throw new Error('EnemyClass not found for spawning: ' + enemyClass);
const enemy = enemyFactory(engine);
enemy.enemyClass = enemyClass;
return addEnemy(engine, enemy, spawnIndex, generateIntent);
}
export function triggerMods<T extends CardMod.ModEvent>(ev: T, ...args: Parameters<NonNullable<CardMod[typeof ev]>>): ReturnType<NonNullable<CardMod[typeof ev]>>[] {
const deps = args[0];
const card = deps.sourceCard;
return [...card.mods]
.map(modData => (!card.isRemoved && card.mods.find(x => CardMod.areEqual(x, modData))) ? CardMod.trigger(ev, modData, ...args) : undefined)
.filter(Boolean);
}
}
|
src/game/game-engine-utils.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " type: 'modRemoved',\n cardId: card.id,\n modData,\n });\n if (!card.mods.find(x => this.areEqual(x, modData))) {\n throw new Error('mod not found');\n }\n this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });\n card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));\n }",
"score": 0.9012342691421509
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);\n }\n }\n override onRemoveMod(deps: ICardModDeps): void {\n if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {\n GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);\n } else {\n GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);\n }\n }",
"score": 0.8796523809432983
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " card.mods.push(modData);\n break;\n }\n }\n engine.broadcast.push({\n type: 'modAdded',\n cardId: card.id,\n modData,\n });\n this.trigger('onInitMod', modData, { engine, sourceCard: card, contextCard });",
"score": 0.8701013922691345
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " deps.engine.broadcast.push({\n type: 'cpuChanged',\n cardId: deps.sourceCard.id,\n newCpu: deps.sourceCard.cpu,\n });\n GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);\n }\n override onRemoveMod(deps: CardMod.ICardModDeps) {\n deps.sourceCard.cpu -= this.stackingConfig.stackCount;\n deps.engine.broadcast.push({",
"score": 0.8611900806427002
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " (engine, _sourceCard, targetCard) => {\n if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;\n const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);\n if (script.targetFinder === CardScript.TargetFinders.Self) return;\n const targets = script.targetFinder(engine.gameData, targetCard);\n if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;\n const origTargetId = targetCard.intent.targetCardId;\n while (targetCard.intent.targetCardId === origTargetId) {\n targetCard.intent.targetCardId = targets.random().id;\n }",
"score": 0.857892632484436
}
] |
typescript
|
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
|
import * as moment from 'moment';
import { IAppraisedCard, appraiseCard } from '../appraise';
import { IDataSource, IMetricsProvider, IPlayerPushProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { SECS_IN_MIN } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameContent_v1 } from './game-content-v1';
import { GameEngineUtils } from './game-engine-utils';
export namespace GameEngine {
interface _ICommonCardState {
id: number;
cpu: number;
mem: number;
sec: number;
mods: CardMod.ModData[];
scripts: CardScript.ScriptData[];
isRemoved?: boolean;
}
export interface IGameData {
id: string;
difficulty: number;
state: 'created' | 'started' | 'players_won' | 'players_lost' | 'abandoned';
enemies: IEnemyCardState[];
maxEnemies: number;
players: Map<string, IPlayerState>;
defaultMovesPerTurn: number;
turn: number;
nextId: number;
pendingPlayers: Map<string, string[]>;
rulesetIds: string[];
}
export interface IPlayerState {
id: string;
cards: IPlayerCardState[];
endedTurn: boolean;
idleKickTime: number;
movesLeft: number;
movesPerTurn: number;
score: number;
stats: {
kills: number;
secDmg: number;
memDmg: number;
secBonus: number;
};
}
export interface IPlayerCardState extends _ICommonCardState {
card: IAppraisedCard;
isUsed: boolean;
}
export interface IEnemyCardState extends _ICommonCardState {
enemyClass: string;
intent?: { scriptData: CardScript.ScriptData, targetCardId: number };
maxMem: number;
}
export type ICardState = IPlayerCardState | IEnemyCardState;
export abstract class GameEngineError extends Error {
constructor(
public gameId: string,
) {
super();
this.message = `${this.constructor.name} processing game ${gameId}`;
}
}
export class GameNotFoundError extends GameEngineError { }
export interface IRulesetContent {
cardMods?: CardMod.ModLibrary;
cardScripts?: CardScript.ScriptLibrary;
enemyCards?: Record<string, (engine: IGameEngine) => IEnemyCardState>;
}
export interface IRuleset extends IRulesetContent {
initGame(engine: IGameEngine): void;
addAdditionalScriptsFor?(engine: GameEngine.IGameEngine, card: IPlayerCardState): void;
}
export function mergeRulesetContents(...rulesets: IRulesetContent[]): IRulesetContent {
const modLibs = rulesets.map(x => x.cardMods).filter(Boolean);
const scriptLibs = rulesets.map(x => x.cardScripts).filter(Boolean);
const enemyLibs = rulesets.map(x => x.enemyCards).filter(Boolean);
return {
cardMods: Object.fromEntries(modLibs.map(modLib => Object.keys(modLib).map(modName => [modName, modLib[modName]!] as const)).flat()),
cardScripts: Object.fromEntries(scriptLibs.map(scriptLib => Object.keys(scriptLib).map(scriptName => [scriptName, scriptLib[scriptName]!] as const)).flat()),
enemyCards: Object.fromEntries(enemyLibs.map(enemyLib => Object.keys(enemyLib).map(enemyClass => [enemyClass, enemyLib[enemyClass]!] as const)).flat()),
};
}
export type IGameEngine = InstanceType<ReturnType<typeof createGameEngineProvider>>;
}
export const createGameEngineProvider = (rulesets: Record<string, GameEngine.IRuleset>, ds: IDataSource, playerPushProvider: IPlayerPushProvider, metrics?: IMetricsProvider) => {
return class _Engine {
readonly broadcast: IPlayerPushProvider.IPushMessage[] = [];
ruleset!: GameEngine.IRuleset;
constructor(
readonly gameData: GameEngine.IGameData,
) {
const currentRuleset = rulesets[gameData.rulesetIds.at(-1)!];
if (!currentRuleset) throw new Error('invalid initial ruleSet id: ' + gameData.rulesetIds[0]);
this._setRuleset(currentRuleset);
}
private static async _withEngine(gameId: string, stateAssertion: GameEngine.IGameData['state'][], func: (engine: _Engine) => Promise<void>): Promise<GameEngine.IGameData> {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
const engine = new _Engine(gameData);
try {
if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);
await func(engine);
await ds.GameData.update.exec(gameData);
} catch (e: any) {
e.broadcast = engine.broadcast;
throw e;
}
if (engine.broadcast.length) {
await Promise.all(
[...gameData.players.keys()].map(playerId => playerPushProvider.push(playerId, engine.broadcast)),
);
}
return gameData;
}
static async createGame(gameId: string, rulesetId: string, difficulty: number) {
const ruleset = rulesets[rulesetId];
if (!ruleset) throw new Error('invalid ruleSet id: ' + rulesetId);
const existingGameData = await ds.GameData.get(gameId);
if (existingGameData) throw new Error('game with id already exists: ' + gameId);
const gameData: GameEngine.IGameData = {
id: gameId,
difficulty: Math.max(1, difficulty),
state: 'created',
turn: 1,
players: new Map(),
defaultMovesPerTurn: 3,
enemies: [],
maxEnemies: 9,
nextId: 1,
pendingPlayers: new Map(),
rulesetIds: [rulesetId],
};
await ds.GameData.update.exec(gameData);
}
static async startGame(gameId: string) {
const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {
for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
engine.broadcast.push({ type: 'playerJoin', playerState });
}
engine.gameData.pendingPlayers.clear();
engine.gameData.state = 'started';
engine.broadcast.push({ type: 'gameStart' });
engine.ruleset.initGame(engine);
});
return gameData;
}
static async endGame(gameId: string) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
engine.gameData.state = 'abandoned';
engine.broadcast.push({ type: 'gameEnd' });
});
}
static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
if (engine.gameData.players.has(playerId)) throw new Error('player already in game');
if (engine.gameData.players.size >= 2) throw new Error('game is full: ' + gameId);
if (engine.gameData.state === 'started') {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
if (engine.gameData.turn >= 2) {
playerState.endedTurn = true;
playerState.movesLeft = 0;
}
engine.broadcast.push({
type: 'playerJoin',
playerState,
});
} else {
engine.gameData.pendingPlayers.set(playerId, cardIds);
}
});
}
static async removePlayer(gameId: string, playerId: string, reason: 'idle' | 'leave') {
return await _Engine._withEngine(gameId, [], async engine => {
if (!engine.gameData.players.delete(playerId)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId, reason });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
});
}
static async requestCardTargets(gameId: string, playerId: string, cardId: number, scriptName: string) {
const gameData = await _Engine.getGameData(gameId);
const card = GameEngineUtils.findPlayerCardById(gameData, cardId);
let targets = [] as number[];
try {
if (card.isUsed) {
return;
}
const scriptData = card.scripts.find(x => x[0] === scriptName);
if (!scriptData) {
throw new Error(`Script [${scriptName}] not found in card [${cardId}]`);
}
if (CardScript.isOnCooldown(scriptData)) {
return;
}
const engine = new _Engine(gameData);
const script = CardScript.deserialize(engine, card, scriptData);
targets = script.targetFinder(gameData, card).map(x => x.id);
} finally {
await playerPushProvider.push(playerId, [{
type: 'cardTargets',
cardId,
scriptName,
targetCardIds: targets,
}]);
}
}
static async intent(gameId: string, playerId: string, sourceCardId?: string, sourceCardScript?: string, targetCardId?: string) {
const gameData = await _Engine.getGameData(gameId);
const pushMessage: IPlayerPushProvider.IPushMessage[] = [{
type: 'cardIntent',
cardId: sourceCardId,
intent: {
scriptData: sourceCardScript,
targetCardId,
},
playerId,
}];
await Promise.all(
[...gameData.players.keys()].filter(x => x !== playerId).map(x => playerPushProvider?.push(x, pushMessage)),
);
}
static async makeMove(gameId: string, playerId: string, sourceCardId: number, sourceCardScript: CardScript.ScriptData, targetCardId: number) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = GameEngineUtils.findPlayerByCardId(engine.gameData, sourceCardId);
if (playerState.id !== playerId) {
throw new Error(`Player ${playerId} cannot make move on card ${sourceCardId} from owner ${playerState.id}`);
}
if (!playerState.movesLeft) {
throw new Error(`No moves left`);
}
const sourceCard = playerState.cards.find(x => x.id === sourceCardId)!;
if (sourceCard.isUsed) {
throw new Error(`Card is used`);
}
const now = moment.now();
playerState.idleKickTime = now + 2 * SECS_IN_MIN * 1000;
playerState.movesLeft--;
const targetCard = GameEngineUtils.findCardById(engine.gameData, targetCardId);
CardScript.execute(engine, sourceCard, sourceCardScript, targetCard);
GameEngineUtils.changeCardIsUsed(engine, sourceCard, true);
metrics
|
?.playerCardPlayed(gameId, engine.gameData.rulesetIds[0] || 'unknown', playerId, sourceCard, sourceCardScript[0]);
|
});
}
static async toggleEndTurn(gameId: string, playerId: string) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = engine.gameData.players.get(playerId);
if (!playerState) throw new Error('player not found');
if (playerState.endedTurn) {
playerState.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: false,
});
return;
}
playerState.endedTurn = true;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: true,
});
if (![...engine.gameData.players.values()].reduce((numNotReady, playerState) => playerState.endedTurn ? numNotReady : (numNotReady + 1), 0)) {
const now = moment.now();
[...engine.gameData.players.values()].forEach(x => x.idleKickTime = now + 2 * SECS_IN_MIN * 1000);
engine.onEndTurn();
if (engine.gameData.state !== 'started') {
// Stop if the game was won/lost due to an EndTurn effect
return;
}
engine.onTurnStart();
}
});
}
static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {
let kickedPlayerId = '';
await _Engine._withEngine(gameId, ['started'], async engine => {
const playerToKick = [...engine.gameData.players.values()].find(x => x.id !== kickRequestingPlayerId) || '';
if (!playerToKick) throw new Error('kickIfIdle: player not found');
if (playerToKick.idleKickTime < moment.now()) {
if (!engine.gameData.players.delete(playerToKick.id)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId: playerToKick.id, reason: 'idle' });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
kickedPlayerId = playerToKick.id;
}
});
return kickedPlayerId || null;
}
static async getGameData(gameId: string) {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
return gameData;
}
private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {
const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))
.filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)
.map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));
if (cards.length !== cardIds.length) {
throw `could not resolve all cards for player ${playerId}`;
}
const player: GameEngine.IPlayerState = {
id: playerId,
cards: cards.map(card => ({
id: this.nextId(),
card,
isUsed: false,
cpu: card.cpu,
mem: card.mem,
sec: card.mem * 6 + card.cpu * 3,
mods: [],
scripts: [],
})),
endedTurn: false,
movesLeft: this.gameData.defaultMovesPerTurn,
movesPerTurn: this.gameData.defaultMovesPerTurn,
stats: {
kills: 0,
memDmg: 0,
secBonus: 0,
secDmg: 0,
},
score: 0,
idleKickTime: moment.now() + 2 * SECS_IN_MIN * 1000,
};
for (const card of player.cards) {
card.scripts = [
CardScript.fromScriptName(this, card, card.card.coreScript),
];
this.ruleset.addAdditionalScriptsFor && this.ruleset.addAdditionalScriptsFor(this, card);
}
return player;
}
findRuleset(rulesetId: string) {
return rulesets[rulesetId];
}
onTurnStart() {
this.gameData.turn++;
this.broadcast.push({
type: 'newTurn',
turn: this.gameData.turn,
});
for (const player of this.gameData.players.values()) {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
}
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of playerCards) {
GameEngineUtils.changeCardIsUsed(this, playerCard, false);
}
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: playerCard });
}
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: enemy });
}
this._checkGameOver();
}
onEndTurn() {
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: playerCard });
CardScript.tickCooldowns(playerCard, this.broadcast);
}
this.broadcast.push({
type: 'playerTurnEnded',
});
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: enemy });
CardScript.tickCooldowns(enemy, this.broadcast);
}
this.broadcast.push({
type: 'enemyTurnEnded',
});
this._checkGameOver();
}
onNextWave(nextRulesetId: string) {
while (this.gameData.enemies[0]) {
GameEngineUtils.removeCard(this, this.gameData.enemies[0]);
}
[...this.gameData.players.values()].forEach(player => {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
player.cards.forEach(card => {
card.isUsed = false;
});
});
this.gameData.turn++;
this.broadcast.push({
type: 'nextWave',
turn: this.gameData.turn,
nextRulesetId,
});
const nextRuleset = this.findRuleset(nextRulesetId);
if (!nextRuleset) {
throw new Error('invalid rulesetId: ' + nextRulesetId);
}
this.gameData.rulesetIds.push(nextRulesetId);
this._setRuleset(nextRuleset);
nextRuleset.initGame(this);
}
onWinGame() {
this.gameData.state = 'players_won';
this.broadcast.push({
type: 'players_won',
stats: [...this.gameData.players.values()].map(player => {
let score =
player.cards.length * 50
+ player.stats.kills * 25
+ player.stats.memDmg * 50
+ player.stats.secDmg
+ player.stats.secBonus * 2
+ ((this.gameData.rulesetIds.length - 1) * 2000);
score = GameEngineUtils.scaleByDifficulty(score, this.gameData.difficulty + 1);
player.score = score;
return { playerId: player.id, stats: player.stats, score };
}),
});
}
nextId() {
return this.gameData.nextId++;
}
private _checkGameOver() {
if (!GameEngineUtils.getPlayerCards(this.gameData).length) {
this.gameData.state = 'players_lost';
this.broadcast.push({
type: 'players_lost',
});
}
}
private _setRuleset(nextRuleset: GameEngine.IRuleset) {
this.ruleset = {
addAdditionalScriptsFor: GameContent_v1.addAdditionalScriptsFor,
...nextRuleset,
...GameEngine.mergeRulesetContents(
nextRuleset,
{
cardMods: CardMod.Content,
cardScripts: CardScript.Content,
},
{
cardMods: GameContent_v1.cardMods,
cardScripts: GameContent_v1.cardScripts,
enemyCards: GameContent_v1.enemyCards,
}
),
};
}
}
}
export type GameEngineProvider = ReturnType<typeof createGameEngineProvider>;
|
src/game/game-engine.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " targetCardId: targetCard.id,\n scriptData: sourceCardScript,\n });\n if (this.isOnCooldown(sourceCardScript)) {\n throw new Error('Script is on cooldown: ' + sourceCardScript.join());\n }\n const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript));\n const isEnemy = GameEngineUtils.isEnemyCard(engine.gameData, sourceCard);\n if (!isEnemy) {\n if (!scriptDataFromCard) {",
"score": 0.8820933103561401
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());\n }\n }\n const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);\n if (cooldownData) {\n cooldownData[1] = cooldownData[2] + 1;\n }\n const script = this.deserialize(engine, sourceCard, sourceCardScript);\n const targets = script.targetFinder(engine.gameData, sourceCard);\n if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {",
"score": 0.8791223764419556
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " if (cooldownData) {\n script.cooldownCur = cooldownData[1];\n script.cooldownMax = cooldownData[2];\n }\n return script;\n }\n static execute(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, sourceCardScript: CardScript.ScriptData, targetCard: GameEngine.ICardState) {\n engine.broadcast.push({\n type: 'cardExecuting',\n cardId: sourceCard.id,",
"score": 0.873454749584198
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " (engine, _sourceCard, targetCard) => {\n if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;\n const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);\n if (script.targetFinder === CardScript.TargetFinders.Self) return;\n const targets = script.targetFinder(engine.gameData, targetCard);\n if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;\n const origTargetId = targetCard.intent.targetCardId;\n while (targetCard.intent.targetCardId === origTargetId) {\n targetCard.intent.targetCardId = targets.random().id;\n }",
"score": 0.8647343516349792
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " if (source.sec <= 0) {\n GameEngineUtils.removeCard(engine, source);\n return;\n }\n } else {\n GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);\n GameEngineUtils.changeCpu(engine, source, 1);\n for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {\n CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));\n }",
"score": 0.8600490093231201
}
] |
typescript
|
?.playerCardPlayed(gameId, engine.gameData.rulesetIds[0] || 'unknown', playerId, sourceCard, sourceCardScript[0]);
|
import { randInt } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
const _cardMods = {
// Increases incoming damage
exposed: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public stackCount: number) {
super(arguments);
this.stackingConfig.stackCount = stackCount;
}
override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return { secDmgBonus: this.stackingConfig.stackCount };
}
},
// Returns damage to attacker
feedback: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public damage: number) {
super(arguments);
this.stackingConfig.stackCount = damage;
}
override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);
}
},
// Increases CPU
optimized: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(cpuBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = cpuBonus;
}
override onInitMod(deps: CardMod.ICardModDeps) {
GameEngineUtils.changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);
}
override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {
deps.sourceCard.cpu += stackDelta;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
override onRemoveMod(deps: CardMod.ICardModDeps) {
deps.sourceCard.cpu -= this.stackingConfig.stackCount;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
},
// Damages on turn end
virus: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public dot: number) {
super(arguments);
this.stackingConfig.stackCount = dot;
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);
}
},
};
const _cardScripts = {
//
// Backdoor scripts
//
// Swap MEM for CPU
bd_caching: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(-1),
CardScriptParts.ChangeCpu(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise MEM
bd_defrag: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memBonus = 1;
super(
[memBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 4;
}
},
// Heal over time
bd_diagnostics: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const duration = 1 + Math.round(card.mem / 2);
super(
[secBonus, duration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
|
CardScriptParts.AddMod(
new CardMod.Content.diagnostics(secBonus, duration)
),
],
}
|
],
);
this.cooldownMax = 4;
}
},
// Attack and stun (Backdoor finisher)
bd_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const stunDuration = 1;
super(
[damage, stunDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.AddMod(
new CardMod.Content.lag(stunDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and raise CPU on kill
bd_extraction: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Opponents(true)(gameData, card)
.filter(target => !target.sec && target.mem === 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(1, true, true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.ChangeCpu(1),
],
},
],
);
}
},
// Raises CPU
bd_optimize: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Raises SEC
bd_patch: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 2;
}
},
// Steal SEC and remove Firewall (Backdoor finisher)
bd_proxy: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, card.cpu);
super(
[secDelta],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
}
},
// Steal SEC and causes offline (Backdoor finisher)
bd_reboot: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, _card.cpu);
const offlineDuration = 1;
super(
[secDelta, offlineDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 2;
}
},
// Cause Exposed (Backdoor finisher)
bd_trace: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(7, card.cpu);
super(
[stacks],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and remove 1 MEM
bd_tunnel: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memDmg = 1;
super(
[memDmg],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.MemDmg(memDmg),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 3;
}
},
//
// Bruteforce scripts
//
// Swap CPU for MEM
bf_compression: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.ChangeCpu(-1),
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Offline
bf_ddos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const offlineDuration = 1;
super(
[offlineDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Cause Lag
bf_dos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const lagDuration = 1;
super(
[lagDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Gain feedback
bf_feedback: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Triple SEC attack
bf_flood: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(3, card.cpu);
const numAttacks = 3;
super(
[damage, numAttacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
...Array.from(Array(numAttacks)).map(() => CardScriptParts.SecDmg(damage)),
],
}
],
);
this.cooldownMax = 2;
}
},
// AOE attack
bf_multicast: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.TargetAndAdjacents,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC
bf_obfuscate: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 3;
}
},
// Strong attack
bf_pod: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(16, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 2;
}
},
// Raises CPU
bf_precompute: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
//
// Malware scripts
//
// Causes Lag
mw_bloatware: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[1],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(1),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Swap for another card's secondary script
mw_copypaste: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, sourceCard, targetCard) => {
CardScript.removeScript(engine, sourceCard, _cardScripts.mw_copypaste);
if (!targetCard.scripts[1]) return;
CardScript.addScript(engine, sourceCard, CardScript.fromScriptName(engine, sourceCard, targetCard.scripts[1][0]));
},
],
}
],
);
}
},
// Grant Feedback
mw_honeypot: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Steal SEC
mw_leech: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[secDelta],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 1;
}
},
// Attack random target
mw_phishing: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(18, card.cpu);
super(
[minDamage, maxDamage],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomOpponent,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
this.cooldownMax = 1;
}
},
// Redistribute CPU/MEM
mw_reimage: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, _sourceCard, targetCard) => {
const totalStats = targetCard.cpu + targetCard.mem;
const newCpu = randInt(1, totalStats - 1);
const cpuDelta = newCpu - targetCard.cpu;
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
const newMem = totalStats - newCpu;
const memDelta = newMem - targetCard.mem;
GameEngineUtils.changeMem(engine, targetCard, memDelta);
},
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC on random ally
mw_shareware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);
super(
[minBonus, maxBonus],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomAlly,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 3;
}
},
// Redirect intent
mw_spoof: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RedirectIntentRandom,
],
}
],
);
}
},
// Cause Exposed
mw_spyware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[stacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Virus
mw_virus: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const dot = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[dot],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.virus(dot),
),
],
}
],
);
this.cooldownMax = 2;
}
},
};
export const GameContent_v1 = {
cardMods: _cardMods,
cardScripts: _cardScripts,
enemyCards: {},
initGame(_engine: GameEngine.IGameEngine) {
throw new Error('not a startable scenario');
},
addAdditionalScriptsFor(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState) {
if (card.card.tier < 2) return;
switch (card.card.faction) {
case 'backdoor':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bd_')).random()]).serialize());
return;
case 'bruteforce':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bf_')).random()]).serialize());
return;
case 'malware':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('mw_')).random()]).serialize());
return;
}
},
};
(GameContent_v1 as GameEngine.IRuleset);
|
src/game/game-content-v1.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new CardMod.Content.secured(tempSecBonus, duration),\n ),\n CardScriptParts.AddMod(\n new CardMod.Content.firewall(duration),\n ),\n ],",
"score": 0.9356728792190552
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Self,\n parts: [\n CardScriptParts.RaiseSec(secBonus),\n CardScriptParts.AddMod(\n new CardMod.Content.firewall(modDuration),\n ),\n ],\n }\n ],",
"score": 0.9245591759681702
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new CardMod.Content.firewall(duration + 1),\n ),\n ],\n }\n ],\n );",
"score": 0.9095921516418457
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [secBonus],\n TargetFinders.Any(),\n [\n {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseSec(secBonus),\n ],\n }\n ],",
"score": 0.8966631293296814
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts._TargetHasMod<typeof CardMod.Content, 'backdoor'>('backdoor', mod => CardScriptParts.SecDmg(mod.stackingConfig.rank, true)),\n CardScriptParts.Attack(damage),\n CardScriptParts._Chance(bdChance,\n CardScriptParts.AddMod(\n new CardMod.Content.backdoor(damage),\n )\n ),",
"score": 0.891503095626831
}
] |
typescript
|
CardScriptParts.AddMod(
new CardMod.Content.diagnostics(secBonus, duration)
),
],
}
|
import { clamp, round } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
export namespace GameEngineUtils {
export function addEnemy(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, spawnIndex: number, generateIntent: boolean) {
if (engine.gameData.enemies.length >= engine.gameData.maxEnemies) return;
spawnIndex = clamp(spawnIndex, 0, engine.gameData.enemies.length);
engine.gameData.enemies.splice(spawnIndex, 0, enemy);
engine.broadcast.push({
type: 'cardAdded',
enemy,
position: spawnIndex,
});
GameEngineUtils.triggerMods('onInitMod', { engine, sourceCard: enemy });
if (generateIntent) {
GameEngineUtils.generateIntent(engine, enemy);
}
return enemy;
}
export function changeCardIsUsed(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState, isUsed: boolean) {
card.isUsed = isUsed;
engine.broadcast.push({
type: 'cardIsUsedChanged',
cardId: card.id,
isUsed,
});
}
export function clearIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = undefined;
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
});
return true;
}
export function changeCpu(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, cpuDelta: number) {
card.cpu += cpuDelta;
engine.broadcast.push({
type: 'cpuChanged',
cardId: card.id,
newCpu: card.cpu,
cpuDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeMem(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, memDelta: number) {
card.mem += memDelta;
engine.broadcast.push({
type: 'memChanged',
cardId: card.id,
newMem: card.mem,
memDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeSec(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, secDelta: number, isPassive: boolean, contextCard?: GameEngine.ICardState) {
const clampedSecDelta = (card.sec < -secDelta) ? -card.sec : secDelta;
card.sec += clampedSecDelta;
engine.broadcast.push({
type: isPassive ? 'secChange' : (secDelta < 0 ? 'secDamage' : 'secBonus'),
cardId: card.id,
newSec: card.sec,
value: secDelta,
});
if (!isPassive && contextCard) {
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
if (player) {
(clampedSecDelta >= 0) ? (player.stats.secBonus += clampedSecDelta) : (player.stats.secDmg += -clampedSecDelta);
}
}
}
export function executeIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, dontClearIntent = false) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = dontClearIntent ? enemy.intent : undefined;
let targetCard: GameEngine.ICardState | undefined;
if (intent.targetCardId >= 0) {
targetCard = findCardByIdMaybe(engine.gameData, intent.targetCardId);
if (!targetCard) {
// Intent target could've been removed between intent generation and execution
return false;
}
} else {
targetCard = enemy;
}
CardScript.execute(engine, enemy, intent.scriptData, targetCard);
return true;
}
export function findCardById(gameData: GameEngine.IGameData, cardId: number) {
const card = findCardByIdMaybe(gameData, cardId);
if (card) return card;
throw new Error('card not found');
}
export function findCardByIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
const enemy = gameData.enemies.find(x => x.id === cardId);
if (enemy) return enemy;
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) {
return player.cards.find(x => x.id === cardId);
}
return;
}
export function findPlayerCardById(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (!player) throw new Error('player not found');
return player.cards.find(x => x.id === cardId)!;
}
export function findPlayerByCardId(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) return player;
throw new Error('player not found');
}
export function findPlayerByCardIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
return [...gameData.players.values()].find(x => x.cards.find(x => x.id === cardId));
}
export function generateIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
enemy.intent = undefined;
const isOffline = !!enemy.mods.find(x => x[0] === 'offline');
if (isOffline) return;
const scriptData = enemy.scripts.filter(
|
x => !CardScript.isOnCooldown(x)).randomOrUndefined();
|
if (!scriptData) {
return;
}
const script = CardScript.deserialize(engine, enemy, scriptData);
const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();
if (!target) {
return;
}
enemy.intent = {
scriptData,
targetCardId: target.id,
};
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
intent: enemy.intent,
});
}
export function getEnemyIds(gameData: GameEngine.IGameData) {
return gameData.enemies.map(x => x.id);
}
export function getPlayerIds(gameData: GameEngine.IGameData, ...excludePlayer: string[]) {
return [...gameData.players.keys()].filter(x => !excludePlayer.includes(x));
}
export function getPlayerCards(gameData: GameEngine.IGameData) {
return [...gameData.players.values()].map(x => x.cards).flat();
}
export function getPlayerCardIds(gameData: GameEngine.IGameData) {
return getPlayerCards(gameData).map(x => x.id);
}
export function isEnemyCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IEnemyCardState {
return !!gameData.enemies.find(x => x.id === card.id);
}
export function isPlayerCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IPlayerCardState {
return !isEnemyCard(gameData, card);
}
export function recalculateScripts(engine: GameEngine.IGameEngine, card: GameEngine.ICardState) {
if (card.isRemoved) return;
card.scripts = card.scripts.map(x => CardScript.deserialize(engine, card, x).serialize());
engine.broadcast.push(...card.scripts.map(x => ({
type: 'scriptChanged',
cardId: card.id,
scriptData: x,
})));
if (isEnemyCard(engine.gameData, card) && card.intent?.scriptData) {
card.intent.scriptData = CardScript.deserialize(engine, card, card.intent.scriptData).serialize();
engine.broadcast.push({
type: 'cardIntent',
cardId: card.id,
intent: card.intent,
});
}
}
export function revalidateIntents(engine: GameEngine.IGameEngine, regenerateIfInvalid: boolean) {
for (const enemy of engine.gameData.enemies) {
if (!enemy.intent || enemy.intent.targetCardId === -1) {
continue;
}
const script = CardScript.deserialize(engine, enemy, enemy.intent.scriptData);
const validTargets = script.targetFinder(engine.gameData, enemy);
if (validTargets.find(x => x.id === enemy.intent?.targetCardId)) {
continue;
}
enemy.intent = undefined;
if (regenerateIfInvalid) {
generateIntent(engine, enemy);
}
}
}
export function removeCard(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, contextCard?: GameEngine.ICardState) {
if (card.isRemoved) {
return;
}
if (isEnemyCard(engine.gameData, card)) {
engine.gameData.enemies.removeFirst(card)
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
for (const enemy of [...engine.gameData.enemies]) {
if (enemy.isRemoved) continue;
triggerMods('onEnemyDestroyed', { engine, sourceCard: card, contextCard });
}
if (contextCard) {
const player = findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
player && player.stats.kills++;
}
GameEngineUtils.revalidateIntents(engine, true);
} else {
const player = GameEngineUtils.findPlayerByCardId(engine.gameData, card.id);
player.cards.removeFirst(card);
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
GameEngineUtils.revalidateIntents(engine, false);
}
}
export function scaleByCpuMem(baseValue: number, cpuMem: number, cpuMemScaling: 'normal' | 'less' | 'more' | 'minimal' | 'high' = 'normal') {
let valuePerCpu = baseValue / 2;
switch (cpuMemScaling) {
case 'high': valuePerCpu * 1.5; break;
case 'more': valuePerCpu * 1.25; break;
case 'less': valuePerCpu * .75; break;
case 'minimal': valuePerCpu * .5; break;
}
return Math.round(baseValue + ((cpuMem - 1) * valuePerCpu));
}
export function scaleByDifficulty(value: number, difficulty: number, decimals = 0) {
return round(value * Math.pow(1.1, difficulty - 1), decimals);
}
export function spawnEnemy(engine: GameEngine.IGameEngine, enemyClass: string, spawnIndex: number, generateIntent: boolean) {
const enemyFactory = engine.ruleset.enemyCards?.[enemyClass];
if (!enemyFactory) throw new Error('EnemyClass not found for spawning: ' + enemyClass);
const enemy = enemyFactory(engine);
enemy.enemyClass = enemyClass;
return addEnemy(engine, enemy, spawnIndex, generateIntent);
}
export function triggerMods<T extends CardMod.ModEvent>(ev: T, ...args: Parameters<NonNullable<CardMod[typeof ev]>>): ReturnType<NonNullable<CardMod[typeof ev]>>[] {
const deps = args[0];
const card = deps.sourceCard;
return [...card.mods]
.map(modData => (!card.isRemoved && card.mods.find(x => CardMod.areEqual(x, modData))) ? CardMod.trigger(ev, modData, ...args) : undefined)
.filter(Boolean);
}
}
|
src/game/game-engine-utils.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " (engine, _sourceCard, targetCard) => {\n if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;\n const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);\n if (script.targetFinder === CardScript.TargetFinders.Self) return;\n const targets = script.targetFinder(engine.gameData, targetCard);\n if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;\n const origTargetId = targetCard.intent.targetCardId;\n while (targetCard.intent.targetCardId === origTargetId) {\n targetCard.intent.targetCardId = targets.random().id;\n }",
"score": 0.9050160050392151
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " });\n }\n static async requestCardTargets(gameId: string, playerId: string, cardId: number, scriptName: string) {\n const gameData = await _Engine.getGameData(gameId);\n const card = GameEngineUtils.findPlayerCardById(gameData, cardId);\n let targets = [] as number[];\n try {\n if (card.isUsed) {\n return;\n }",
"score": 0.8898491263389587
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const scriptData = card.scripts.find(x => x[0] === scriptName);\n if (!scriptData) {\n throw new Error(`Script [${scriptName}] not found in card [${cardId}]`);\n }\n if (CardScript.isOnCooldown(scriptData)) {\n return;\n }\n const engine = new _Engine(gameData);\n const script = CardScript.deserialize(engine, card, scriptData);\n targets = script.targetFinder(gameData, card).map(x => x.id);",
"score": 0.8742247223854065
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());\n }\n }\n const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);\n if (cooldownData) {\n cooldownData[1] = cooldownData[2] + 1;\n }\n const script = this.deserialize(engine, sourceCard, sourceCardScript);\n const targets = script.targetFinder(engine.gameData, sourceCard);\n if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {",
"score": 0.8706730604171753
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " export const RandomOpponent: ITargetResolver = (gameData, sourceCard, targetCard) => {\n return TargetFinders._excludeImperviousAndOffline([AllOpponents(gameData, sourceCard, targetCard).random()]);\n };\n }\n export namespace TargetFinders {\n export const Self: ITargetFinder = (_gameData, card) => [card];\n export const Allies = (excludeSelf = false): ITargetFinder =>\n (gameData, card) => {\n let targets: GameEngine.ICardState[] = GameEngineUtils.isEnemyCard(gameData, card) ? gameData.enemies : GameEngineUtils.getPlayerCards(gameData);\n excludeSelf && (targets = targets.filter(x => x.id !== card.id));",
"score": 0.8702442646026611
}
] |
typescript
|
x => !CardScript.isOnCooldown(x)).randomOrUndefined();
|
import { clamp, round } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
export namespace GameEngineUtils {
export function addEnemy(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, spawnIndex: number, generateIntent: boolean) {
if (engine.gameData.enemies.length >= engine.gameData.maxEnemies) return;
spawnIndex = clamp(spawnIndex, 0, engine.gameData.enemies.length);
engine.gameData.enemies.splice(spawnIndex, 0, enemy);
engine.broadcast.push({
type: 'cardAdded',
enemy,
position: spawnIndex,
});
GameEngineUtils.triggerMods('onInitMod', { engine, sourceCard: enemy });
if (generateIntent) {
GameEngineUtils.generateIntent(engine, enemy);
}
return enemy;
}
export function changeCardIsUsed(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState, isUsed: boolean) {
card.isUsed = isUsed;
engine.broadcast.push({
type: 'cardIsUsedChanged',
cardId: card.id,
isUsed,
});
}
export function clearIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = undefined;
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
});
return true;
}
export function changeCpu(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, cpuDelta: number) {
card.cpu += cpuDelta;
engine.broadcast.push({
type: 'cpuChanged',
cardId: card.id,
newCpu: card.cpu,
cpuDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeMem(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, memDelta: number) {
card.mem += memDelta;
engine.broadcast.push({
type: 'memChanged',
cardId: card.id,
newMem: card.mem,
memDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeSec(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, secDelta: number, isPassive: boolean, contextCard?: GameEngine.ICardState) {
const clampedSecDelta = (card.sec < -secDelta) ? -card.sec : secDelta;
card.sec += clampedSecDelta;
engine.broadcast.push({
type: isPassive ? 'secChange' : (secDelta < 0 ? 'secDamage' : 'secBonus'),
cardId: card.id,
newSec: card.sec,
value: secDelta,
});
if (!isPassive && contextCard) {
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
if (player) {
(clampedSecDelta >= 0) ? (player.stats.secBonus += clampedSecDelta) : (player.stats.secDmg += -clampedSecDelta);
}
}
}
export function executeIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, dontClearIntent = false) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = dontClearIntent ? enemy.intent : undefined;
let targetCard: GameEngine.ICardState | undefined;
if (intent.targetCardId >= 0) {
targetCard = findCardByIdMaybe(engine.gameData, intent.targetCardId);
if (!targetCard) {
// Intent target could've been removed between intent generation and execution
return false;
}
} else {
targetCard = enemy;
}
|
CardScript.execute(engine, enemy, intent.scriptData, targetCard);
|
return true;
}
export function findCardById(gameData: GameEngine.IGameData, cardId: number) {
const card = findCardByIdMaybe(gameData, cardId);
if (card) return card;
throw new Error('card not found');
}
export function findCardByIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
const enemy = gameData.enemies.find(x => x.id === cardId);
if (enemy) return enemy;
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) {
return player.cards.find(x => x.id === cardId);
}
return;
}
export function findPlayerCardById(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (!player) throw new Error('player not found');
return player.cards.find(x => x.id === cardId)!;
}
export function findPlayerByCardId(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) return player;
throw new Error('player not found');
}
export function findPlayerByCardIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
return [...gameData.players.values()].find(x => x.cards.find(x => x.id === cardId));
}
export function generateIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
enemy.intent = undefined;
const isOffline = !!enemy.mods.find(x => x[0] === 'offline');
if (isOffline) return;
const scriptData = enemy.scripts.filter(x => !CardScript.isOnCooldown(x)).randomOrUndefined();
if (!scriptData) {
return;
}
const script = CardScript.deserialize(engine, enemy, scriptData);
const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();
if (!target) {
return;
}
enemy.intent = {
scriptData,
targetCardId: target.id,
};
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
intent: enemy.intent,
});
}
export function getEnemyIds(gameData: GameEngine.IGameData) {
return gameData.enemies.map(x => x.id);
}
export function getPlayerIds(gameData: GameEngine.IGameData, ...excludePlayer: string[]) {
return [...gameData.players.keys()].filter(x => !excludePlayer.includes(x));
}
export function getPlayerCards(gameData: GameEngine.IGameData) {
return [...gameData.players.values()].map(x => x.cards).flat();
}
export function getPlayerCardIds(gameData: GameEngine.IGameData) {
return getPlayerCards(gameData).map(x => x.id);
}
export function isEnemyCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IEnemyCardState {
return !!gameData.enemies.find(x => x.id === card.id);
}
export function isPlayerCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IPlayerCardState {
return !isEnemyCard(gameData, card);
}
export function recalculateScripts(engine: GameEngine.IGameEngine, card: GameEngine.ICardState) {
if (card.isRemoved) return;
card.scripts = card.scripts.map(x => CardScript.deserialize(engine, card, x).serialize());
engine.broadcast.push(...card.scripts.map(x => ({
type: 'scriptChanged',
cardId: card.id,
scriptData: x,
})));
if (isEnemyCard(engine.gameData, card) && card.intent?.scriptData) {
card.intent.scriptData = CardScript.deserialize(engine, card, card.intent.scriptData).serialize();
engine.broadcast.push({
type: 'cardIntent',
cardId: card.id,
intent: card.intent,
});
}
}
export function revalidateIntents(engine: GameEngine.IGameEngine, regenerateIfInvalid: boolean) {
for (const enemy of engine.gameData.enemies) {
if (!enemy.intent || enemy.intent.targetCardId === -1) {
continue;
}
const script = CardScript.deserialize(engine, enemy, enemy.intent.scriptData);
const validTargets = script.targetFinder(engine.gameData, enemy);
if (validTargets.find(x => x.id === enemy.intent?.targetCardId)) {
continue;
}
enemy.intent = undefined;
if (regenerateIfInvalid) {
generateIntent(engine, enemy);
}
}
}
export function removeCard(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, contextCard?: GameEngine.ICardState) {
if (card.isRemoved) {
return;
}
if (isEnemyCard(engine.gameData, card)) {
engine.gameData.enemies.removeFirst(card)
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
for (const enemy of [...engine.gameData.enemies]) {
if (enemy.isRemoved) continue;
triggerMods('onEnemyDestroyed', { engine, sourceCard: card, contextCard });
}
if (contextCard) {
const player = findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
player && player.stats.kills++;
}
GameEngineUtils.revalidateIntents(engine, true);
} else {
const player = GameEngineUtils.findPlayerByCardId(engine.gameData, card.id);
player.cards.removeFirst(card);
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
GameEngineUtils.revalidateIntents(engine, false);
}
}
export function scaleByCpuMem(baseValue: number, cpuMem: number, cpuMemScaling: 'normal' | 'less' | 'more' | 'minimal' | 'high' = 'normal') {
let valuePerCpu = baseValue / 2;
switch (cpuMemScaling) {
case 'high': valuePerCpu * 1.5; break;
case 'more': valuePerCpu * 1.25; break;
case 'less': valuePerCpu * .75; break;
case 'minimal': valuePerCpu * .5; break;
}
return Math.round(baseValue + ((cpuMem - 1) * valuePerCpu));
}
export function scaleByDifficulty(value: number, difficulty: number, decimals = 0) {
return round(value * Math.pow(1.1, difficulty - 1), decimals);
}
export function spawnEnemy(engine: GameEngine.IGameEngine, enemyClass: string, spawnIndex: number, generateIntent: boolean) {
const enemyFactory = engine.ruleset.enemyCards?.[enemyClass];
if (!enemyFactory) throw new Error('EnemyClass not found for spawning: ' + enemyClass);
const enemy = enemyFactory(engine);
enemy.enemyClass = enemyClass;
return addEnemy(engine, enemy, spawnIndex, generateIntent);
}
export function triggerMods<T extends CardMod.ModEvent>(ev: T, ...args: Parameters<NonNullable<CardMod[typeof ev]>>): ReturnType<NonNullable<CardMod[typeof ev]>>[] {
const deps = args[0];
const card = deps.sourceCard;
return [...card.mods]
.map(modData => (!card.isRemoved && card.mods.find(x => CardMod.areEqual(x, modData))) ? CardMod.trigger(ev, modData, ...args) : undefined)
.filter(Boolean);
}
}
|
src/game/game-engine-utils.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " (engine, _sourceCard, targetCard) => {\n if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;\n const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);\n if (script.targetFinder === CardScript.TargetFinders.Self) return;\n const targets = script.targetFinder(engine.gameData, targetCard);\n if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;\n const origTargetId = targetCard.intent.targetCardId;\n while (targetCard.intent.targetCardId === origTargetId) {\n targetCard.intent.targetCardId = targets.random().id;\n }",
"score": 0.9155824184417725
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " }\n GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);\n }\n override onTurnEnd(deps: ICardModDeps) {\n if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {\n throw new Error('not an enemy card');\n }\n GameEngineUtils.executeIntent(deps.engine, deps.sourceCard);\n }\n }",
"score": 0.8605625033378601
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " targetCardId: targetCard.id,\n scriptData: sourceCardScript,\n });\n if (this.isOnCooldown(sourceCardScript)) {\n throw new Error('Script is on cooldown: ' + sourceCardScript.join());\n }\n const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript));\n const isEnemy = GameEngineUtils.isEnemyCard(engine.gameData, sourceCard);\n if (!isEnemy) {\n if (!scriptDataFromCard) {",
"score": 0.8550078272819519
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {\n GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);\n } else {\n GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);\n }\n }\n override onTurnStart(deps: CardMod.ICardModDeps) {\n if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {\n GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);\n } else {",
"score": 0.8525840640068054
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " } finally {\n await playerPushProvider.push(playerId, [{\n type: 'cardTargets',\n cardId,\n scriptName,\n targetCardIds: targets,\n }]);\n }\n }\n static async intent(gameId: string, playerId: string, sourceCardId?: string, sourceCardScript?: string, targetCardId?: string) {",
"score": 0.8490636944770813
}
] |
typescript
|
CardScript.execute(engine, enemy, intent.scriptData, targetCard);
|
import { clamp, round } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
export namespace GameEngineUtils {
export function addEnemy(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, spawnIndex: number, generateIntent: boolean) {
if (engine.gameData.enemies.length >= engine.gameData.maxEnemies) return;
spawnIndex = clamp(spawnIndex, 0, engine.gameData.enemies.length);
engine.gameData.enemies.splice(spawnIndex, 0, enemy);
engine.broadcast.push({
type: 'cardAdded',
enemy,
position: spawnIndex,
});
GameEngineUtils.triggerMods('onInitMod', { engine, sourceCard: enemy });
if (generateIntent) {
GameEngineUtils.generateIntent(engine, enemy);
}
return enemy;
}
export function changeCardIsUsed(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState, isUsed: boolean) {
card.isUsed = isUsed;
engine.broadcast.push({
type: 'cardIsUsedChanged',
cardId: card.id,
isUsed,
});
}
export function clearIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = undefined;
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
});
return true;
}
export function changeCpu(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, cpuDelta: number) {
card.cpu += cpuDelta;
engine.broadcast.push({
type: 'cpuChanged',
cardId: card.id,
newCpu: card.cpu,
cpuDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeMem(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, memDelta: number) {
card.mem += memDelta;
engine.broadcast.push({
type: 'memChanged',
cardId: card.id,
newMem: card.mem,
memDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeSec(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, secDelta: number, isPassive: boolean, contextCard?: GameEngine.ICardState) {
const clampedSecDelta = (card.sec < -secDelta) ? -card.sec : secDelta;
card.sec += clampedSecDelta;
engine.broadcast.push({
type: isPassive ? 'secChange' : (secDelta < 0 ? 'secDamage' : 'secBonus'),
cardId: card.id,
newSec: card.sec,
value: secDelta,
});
if (!isPassive && contextCard) {
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
if (player) {
(clampedSecDelta >= 0) ? (player.stats.secBonus += clampedSecDelta) : (player.stats.secDmg += -clampedSecDelta);
}
}
}
export function executeIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, dontClearIntent = false) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = dontClearIntent ? enemy.intent : undefined;
let targetCard: GameEngine.ICardState | undefined;
if (intent.targetCardId >= 0) {
targetCard = findCardByIdMaybe(engine.gameData, intent.targetCardId);
if (!targetCard) {
// Intent target could've been removed between intent generation and execution
return false;
}
} else {
targetCard = enemy;
}
CardScript.execute(engine, enemy, intent.scriptData, targetCard);
return true;
}
export function findCardById(gameData: GameEngine.IGameData, cardId: number) {
const card = findCardByIdMaybe(gameData, cardId);
if (card) return card;
throw new Error('card not found');
}
export function findCardByIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
const enemy = gameData.enemies.find(x => x.id === cardId);
if (enemy) return enemy;
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) {
return player.cards.find(x => x.id === cardId);
}
return;
}
export function findPlayerCardById(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (!player) throw new Error('player not found');
return player.cards.find(x => x.id === cardId)!;
}
export function findPlayerByCardId(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) return player;
throw new Error('player not found');
}
export function findPlayerByCardIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
return [...gameData.players.values()].find(x => x.cards.find(x => x.id === cardId));
}
export function generateIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
enemy.intent = undefined;
const isOffline = !!enemy.mods.find(x => x[0] === 'offline');
if (isOffline) return;
const scriptData = enemy.scripts.filter(x => !CardScript.isOnCooldown(x)).randomOrUndefined();
if (!scriptData) {
return;
}
const script = CardScript
|
.deserialize(engine, enemy, scriptData);
|
const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();
if (!target) {
return;
}
enemy.intent = {
scriptData,
targetCardId: target.id,
};
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
intent: enemy.intent,
});
}
export function getEnemyIds(gameData: GameEngine.IGameData) {
return gameData.enemies.map(x => x.id);
}
export function getPlayerIds(gameData: GameEngine.IGameData, ...excludePlayer: string[]) {
return [...gameData.players.keys()].filter(x => !excludePlayer.includes(x));
}
export function getPlayerCards(gameData: GameEngine.IGameData) {
return [...gameData.players.values()].map(x => x.cards).flat();
}
export function getPlayerCardIds(gameData: GameEngine.IGameData) {
return getPlayerCards(gameData).map(x => x.id);
}
export function isEnemyCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IEnemyCardState {
return !!gameData.enemies.find(x => x.id === card.id);
}
export function isPlayerCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IPlayerCardState {
return !isEnemyCard(gameData, card);
}
export function recalculateScripts(engine: GameEngine.IGameEngine, card: GameEngine.ICardState) {
if (card.isRemoved) return;
card.scripts = card.scripts.map(x => CardScript.deserialize(engine, card, x).serialize());
engine.broadcast.push(...card.scripts.map(x => ({
type: 'scriptChanged',
cardId: card.id,
scriptData: x,
})));
if (isEnemyCard(engine.gameData, card) && card.intent?.scriptData) {
card.intent.scriptData = CardScript.deserialize(engine, card, card.intent.scriptData).serialize();
engine.broadcast.push({
type: 'cardIntent',
cardId: card.id,
intent: card.intent,
});
}
}
export function revalidateIntents(engine: GameEngine.IGameEngine, regenerateIfInvalid: boolean) {
for (const enemy of engine.gameData.enemies) {
if (!enemy.intent || enemy.intent.targetCardId === -1) {
continue;
}
const script = CardScript.deserialize(engine, enemy, enemy.intent.scriptData);
const validTargets = script.targetFinder(engine.gameData, enemy);
if (validTargets.find(x => x.id === enemy.intent?.targetCardId)) {
continue;
}
enemy.intent = undefined;
if (regenerateIfInvalid) {
generateIntent(engine, enemy);
}
}
}
export function removeCard(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, contextCard?: GameEngine.ICardState) {
if (card.isRemoved) {
return;
}
if (isEnemyCard(engine.gameData, card)) {
engine.gameData.enemies.removeFirst(card)
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
for (const enemy of [...engine.gameData.enemies]) {
if (enemy.isRemoved) continue;
triggerMods('onEnemyDestroyed', { engine, sourceCard: card, contextCard });
}
if (contextCard) {
const player = findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
player && player.stats.kills++;
}
GameEngineUtils.revalidateIntents(engine, true);
} else {
const player = GameEngineUtils.findPlayerByCardId(engine.gameData, card.id);
player.cards.removeFirst(card);
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
GameEngineUtils.revalidateIntents(engine, false);
}
}
export function scaleByCpuMem(baseValue: number, cpuMem: number, cpuMemScaling: 'normal' | 'less' | 'more' | 'minimal' | 'high' = 'normal') {
let valuePerCpu = baseValue / 2;
switch (cpuMemScaling) {
case 'high': valuePerCpu * 1.5; break;
case 'more': valuePerCpu * 1.25; break;
case 'less': valuePerCpu * .75; break;
case 'minimal': valuePerCpu * .5; break;
}
return Math.round(baseValue + ((cpuMem - 1) * valuePerCpu));
}
export function scaleByDifficulty(value: number, difficulty: number, decimals = 0) {
return round(value * Math.pow(1.1, difficulty - 1), decimals);
}
export function spawnEnemy(engine: GameEngine.IGameEngine, enemyClass: string, spawnIndex: number, generateIntent: boolean) {
const enemyFactory = engine.ruleset.enemyCards?.[enemyClass];
if (!enemyFactory) throw new Error('EnemyClass not found for spawning: ' + enemyClass);
const enemy = enemyFactory(engine);
enemy.enemyClass = enemyClass;
return addEnemy(engine, enemy, spawnIndex, generateIntent);
}
export function triggerMods<T extends CardMod.ModEvent>(ev: T, ...args: Parameters<NonNullable<CardMod[typeof ev]>>): ReturnType<NonNullable<CardMod[typeof ev]>>[] {
const deps = args[0];
const card = deps.sourceCard;
return [...card.mods]
.map(modData => (!card.isRemoved && card.mods.find(x => CardMod.areEqual(x, modData))) ? CardMod.trigger(ev, modData, ...args) : undefined)
.filter(Boolean);
}
}
|
src/game/game-engine-utils.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " (engine, _sourceCard, targetCard) => {\n if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;\n const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);\n if (script.targetFinder === CardScript.TargetFinders.Self) return;\n const targets = script.targetFinder(engine.gameData, targetCard);\n if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;\n const origTargetId = targetCard.intent.targetCardId;\n while (targetCard.intent.targetCardId === origTargetId) {\n targetCard.intent.targetCardId = targets.random().id;\n }",
"score": 0.9065139293670654
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new CardScript.Content._defend(enemy, engine.gameData.difficulty).serialize(),",
"score": 0.8810470104217529
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " ],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n );\n return enemy;\n },\n },\n cardScripts: {",
"score": 0.874737024307251
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " maxMem: 1,\n sec: GameEngineUtils.scaleByDifficulty(30, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },",
"score": 0.8738276958465576
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " }\n export class offline extends CardMod {\n constructor(override duration: number) {\n super(arguments);\n }\n override onInitMod(deps: CardMod.ICardModDeps) {\n if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {\n GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);\n }\n GameEngineUtils.revalidateIntents(deps.engine, GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard));",
"score": 0.8726888298988342
}
] |
typescript
|
.deserialize(engine, enemy, scriptData);
|
import { randInt } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
const _cardMods = {
// Increases incoming damage
exposed: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public stackCount: number) {
super(arguments);
this.stackingConfig.stackCount = stackCount;
}
override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return { secDmgBonus: this.stackingConfig.stackCount };
}
},
// Returns damage to attacker
feedback: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public damage: number) {
super(arguments);
this.stackingConfig.stackCount = damage;
}
override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);
}
},
// Increases CPU
optimized: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(cpuBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = cpuBonus;
}
override onInitMod(deps: CardMod.ICardModDeps) {
GameEngineUtils.changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);
}
override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {
deps.sourceCard.cpu += stackDelta;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
override onRemoveMod(deps: CardMod.ICardModDeps) {
deps.sourceCard.cpu -= this.stackingConfig.stackCount;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
},
// Damages on turn end
virus: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public dot: number) {
super(arguments);
this.stackingConfig.stackCount = dot;
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);
}
},
};
const _cardScripts = {
//
// Backdoor scripts
//
// Swap MEM for CPU
bd_caching: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(-1),
CardScriptParts.ChangeCpu(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise MEM
bd_defrag: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memBonus = 1;
super(
[memBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 4;
}
},
// Heal over time
bd_diagnostics: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const duration = 1 + Math.round(card.mem / 2);
super(
[secBonus, duration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.diagnostics(secBonus, duration)
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Attack and stun (Backdoor finisher)
bd_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const stunDuration = 1;
super(
[damage, stunDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.AddMod(
new CardMod.Content.lag(stunDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and raise CPU on kill
bd_extraction: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Opponents(true)(gameData, card)
.filter(target => !target.sec && target.mem === 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(1, true, true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.ChangeCpu(1),
],
},
],
);
}
},
// Raises CPU
bd_optimize: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Raises SEC
bd_patch: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.
|
RaiseSec(secBonus),
],
}
|
],
);
this.cooldownMax = 2;
}
},
// Steal SEC and remove Firewall (Backdoor finisher)
bd_proxy: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, card.cpu);
super(
[secDelta],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
}
},
// Steal SEC and causes offline (Backdoor finisher)
bd_reboot: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, _card.cpu);
const offlineDuration = 1;
super(
[secDelta, offlineDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 2;
}
},
// Cause Exposed (Backdoor finisher)
bd_trace: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(7, card.cpu);
super(
[stacks],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and remove 1 MEM
bd_tunnel: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memDmg = 1;
super(
[memDmg],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.MemDmg(memDmg),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 3;
}
},
//
// Bruteforce scripts
//
// Swap CPU for MEM
bf_compression: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.ChangeCpu(-1),
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Offline
bf_ddos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const offlineDuration = 1;
super(
[offlineDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Cause Lag
bf_dos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const lagDuration = 1;
super(
[lagDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Gain feedback
bf_feedback: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Triple SEC attack
bf_flood: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(3, card.cpu);
const numAttacks = 3;
super(
[damage, numAttacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
...Array.from(Array(numAttacks)).map(() => CardScriptParts.SecDmg(damage)),
],
}
],
);
this.cooldownMax = 2;
}
},
// AOE attack
bf_multicast: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.TargetAndAdjacents,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC
bf_obfuscate: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 3;
}
},
// Strong attack
bf_pod: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(16, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 2;
}
},
// Raises CPU
bf_precompute: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
//
// Malware scripts
//
// Causes Lag
mw_bloatware: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[1],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(1),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Swap for another card's secondary script
mw_copypaste: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, sourceCard, targetCard) => {
CardScript.removeScript(engine, sourceCard, _cardScripts.mw_copypaste);
if (!targetCard.scripts[1]) return;
CardScript.addScript(engine, sourceCard, CardScript.fromScriptName(engine, sourceCard, targetCard.scripts[1][0]));
},
],
}
],
);
}
},
// Grant Feedback
mw_honeypot: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Steal SEC
mw_leech: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[secDelta],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 1;
}
},
// Attack random target
mw_phishing: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(18, card.cpu);
super(
[minDamage, maxDamage],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomOpponent,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
this.cooldownMax = 1;
}
},
// Redistribute CPU/MEM
mw_reimage: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, _sourceCard, targetCard) => {
const totalStats = targetCard.cpu + targetCard.mem;
const newCpu = randInt(1, totalStats - 1);
const cpuDelta = newCpu - targetCard.cpu;
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
const newMem = totalStats - newCpu;
const memDelta = newMem - targetCard.mem;
GameEngineUtils.changeMem(engine, targetCard, memDelta);
},
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC on random ally
mw_shareware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);
super(
[minBonus, maxBonus],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomAlly,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 3;
}
},
// Redirect intent
mw_spoof: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RedirectIntentRandom,
],
}
],
);
}
},
// Cause Exposed
mw_spyware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[stacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Virus
mw_virus: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const dot = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[dot],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.virus(dot),
),
],
}
],
);
this.cooldownMax = 2;
}
},
};
export const GameContent_v1 = {
cardMods: _cardMods,
cardScripts: _cardScripts,
enemyCards: {},
initGame(_engine: GameEngine.IGameEngine) {
throw new Error('not a startable scenario');
},
addAdditionalScriptsFor(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState) {
if (card.card.tier < 2) return;
switch (card.card.faction) {
case 'backdoor':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bd_')).random()]).serialize());
return;
case 'bruteforce':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bf_')).random()]).serialize());
return;
case 'malware':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('mw_')).random()]).serialize());
return;
}
},
};
(GameContent_v1 as GameEngine.IRuleset);
|
src/game/game-content-v1.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [secBonus],\n TargetFinders.Any(),\n [\n {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseSec(secBonus),\n ],\n }\n ],",
"score": 0.9744857549667358
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Self,\n parts: [\n CardScriptParts.RaiseSec(secBonus),\n CardScriptParts.AddMod(\n new CardMod.Content.firewall(modDuration),\n ),\n ],\n }\n ],",
"score": 0.9191373586654663
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [difficulty, strength, cooldown, minBonus, maxBonus],\n TargetFinders.Allies(),\n [\n {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),\n ],\n }\n ],",
"score": 0.9000385403633118
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new CardMod.Content.secured(tempSecBonus, duration),\n ),\n CardScriptParts.AddMod(\n new CardMod.Content.firewall(duration),\n ),\n ],",
"score": 0.8953615427017212
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " cardId: targetCard.id,\n newMem: targetCard.mem,\n value: memBonus,\n });\n };\n export const RaiseSec = (secBonus: number): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n GameEngineUtils.changeSec(engine, targetCard, secBonus, false, sourceCard);\n };\n export const RedirectIntentRandom: IScriptPart =",
"score": 0.889426589012146
}
] |
typescript
|
RaiseSec(secBonus),
],
}
|
import { randInt } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
const _cardMods = {
// Increases incoming damage
exposed: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public stackCount: number) {
super(arguments);
this.stackingConfig.stackCount = stackCount;
}
override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return { secDmgBonus: this.stackingConfig.stackCount };
}
},
// Returns damage to attacker
feedback: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public damage: number) {
super(arguments);
this.stackingConfig.stackCount = damage;
}
override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);
}
},
// Increases CPU
optimized: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(cpuBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = cpuBonus;
}
override onInitMod(deps: CardMod.ICardModDeps) {
GameEngineUtils.changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);
}
override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {
deps.sourceCard.cpu += stackDelta;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
override onRemoveMod(deps: CardMod.ICardModDeps) {
deps.sourceCard.cpu -= this.stackingConfig.stackCount;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
},
// Damages on turn end
virus: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public dot: number) {
super(arguments);
this.stackingConfig.stackCount = dot;
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);
}
},
};
const _cardScripts = {
//
// Backdoor scripts
//
// Swap MEM for CPU
bd_caching: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts
|
.RaiseMem(-1),
CardScriptParts.ChangeCpu(1),
],
}
|
],
);
this.cooldownMax = 1;
}
},
// Raise MEM
bd_defrag: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memBonus = 1;
super(
[memBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 4;
}
},
// Heal over time
bd_diagnostics: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const duration = 1 + Math.round(card.mem / 2);
super(
[secBonus, duration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.diagnostics(secBonus, duration)
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Attack and stun (Backdoor finisher)
bd_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const stunDuration = 1;
super(
[damage, stunDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.AddMod(
new CardMod.Content.lag(stunDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and raise CPU on kill
bd_extraction: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Opponents(true)(gameData, card)
.filter(target => !target.sec && target.mem === 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(1, true, true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.ChangeCpu(1),
],
},
],
);
}
},
// Raises CPU
bd_optimize: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Raises SEC
bd_patch: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 2;
}
},
// Steal SEC and remove Firewall (Backdoor finisher)
bd_proxy: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, card.cpu);
super(
[secDelta],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
}
},
// Steal SEC and causes offline (Backdoor finisher)
bd_reboot: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, _card.cpu);
const offlineDuration = 1;
super(
[secDelta, offlineDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 2;
}
},
// Cause Exposed (Backdoor finisher)
bd_trace: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(7, card.cpu);
super(
[stacks],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and remove 1 MEM
bd_tunnel: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memDmg = 1;
super(
[memDmg],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.MemDmg(memDmg),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 3;
}
},
//
// Bruteforce scripts
//
// Swap CPU for MEM
bf_compression: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.ChangeCpu(-1),
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Offline
bf_ddos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const offlineDuration = 1;
super(
[offlineDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Cause Lag
bf_dos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const lagDuration = 1;
super(
[lagDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Gain feedback
bf_feedback: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Triple SEC attack
bf_flood: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(3, card.cpu);
const numAttacks = 3;
super(
[damage, numAttacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
...Array.from(Array(numAttacks)).map(() => CardScriptParts.SecDmg(damage)),
],
}
],
);
this.cooldownMax = 2;
}
},
// AOE attack
bf_multicast: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.TargetAndAdjacents,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC
bf_obfuscate: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 3;
}
},
// Strong attack
bf_pod: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(16, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 2;
}
},
// Raises CPU
bf_precompute: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
//
// Malware scripts
//
// Causes Lag
mw_bloatware: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[1],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(1),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Swap for another card's secondary script
mw_copypaste: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, sourceCard, targetCard) => {
CardScript.removeScript(engine, sourceCard, _cardScripts.mw_copypaste);
if (!targetCard.scripts[1]) return;
CardScript.addScript(engine, sourceCard, CardScript.fromScriptName(engine, sourceCard, targetCard.scripts[1][0]));
},
],
}
],
);
}
},
// Grant Feedback
mw_honeypot: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Steal SEC
mw_leech: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[secDelta],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 1;
}
},
// Attack random target
mw_phishing: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(18, card.cpu);
super(
[minDamage, maxDamage],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomOpponent,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
this.cooldownMax = 1;
}
},
// Redistribute CPU/MEM
mw_reimage: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, _sourceCard, targetCard) => {
const totalStats = targetCard.cpu + targetCard.mem;
const newCpu = randInt(1, totalStats - 1);
const cpuDelta = newCpu - targetCard.cpu;
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
const newMem = totalStats - newCpu;
const memDelta = newMem - targetCard.mem;
GameEngineUtils.changeMem(engine, targetCard, memDelta);
},
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC on random ally
mw_shareware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);
super(
[minBonus, maxBonus],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomAlly,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 3;
}
},
// Redirect intent
mw_spoof: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RedirectIntentRandom,
],
}
],
);
}
},
// Cause Exposed
mw_spyware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[stacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Virus
mw_virus: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const dot = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[dot],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.virus(dot),
),
],
}
],
);
this.cooldownMax = 2;
}
},
};
export const GameContent_v1 = {
cardMods: _cardMods,
cardScripts: _cardScripts,
enemyCards: {},
initGame(_engine: GameEngine.IGameEngine) {
throw new Error('not a startable scenario');
},
addAdditionalScriptsFor(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState) {
if (card.card.tier < 2) return;
switch (card.card.faction) {
case 'backdoor':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bd_')).random()]).serialize());
return;
case 'bruteforce':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bf_')).random()]).serialize());
return;
case 'malware':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('mw_')).random()]).serialize());
return;
}
},
};
(GameContent_v1 as GameEngine.IRuleset);
|
src/game/game-content-v1.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n const bdChance = round(GameEngineUtils.scaleByCpuMem(40, card.mem, 'more') / 100, 2);\n super(\n [damage, bdChance],\n (gameData: GameEngine.IGameData, card: GameEngine.ICardState) => [\n ...TargetFinders.Opponents()(gameData, card),\n ...TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],\n TargetFinders.Opponents(true))(gameData, card),\n ],\n [",
"score": 0.8781858682632446
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " const i = cards.findIndex(x => x.id === targetCard.id);\n return [cards[i], cards[i - 1], cards[i + 1]].filter(Boolean);\n };\n export const AllAllies: ITargetResolver = (gameData, sourceCard) => {\n if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {\n return TargetFinders._excludeOffline(gameData.enemies);\n } else {\n return TargetFinders._excludeOffline(GameEngineUtils.getPlayerCards(gameData));\n }\n };",
"score": 0.8687219619750977
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " };\n export const ChangeCpu = (cpuDelta: number): IScriptPart =>\n (engine, _sourceCard, targetCard) => {\n GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);\n };\n export const RaiseMem = (memBonus: number): IScriptPart =>\n (engine, _sourceCard, targetCard) => {\n targetCard.mem += memBonus;\n engine.broadcast.push({\n type: 'memBonus',",
"score": 0.8634214401245117
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " export const RandomAlly: ITargetResolver = (gameData, sourceCard, targetCard) => {\n return [AllAllies(gameData, sourceCard, targetCard).random()];\n };\n export const AllOpponents: ITargetResolver = (gameData, sourceCard) => {\n if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {\n return TargetFinders._excludeImperviousAndOffline(GameEngineUtils.getPlayerCards(gameData));\n } else {\n return TargetFinders._excludeImperviousAndOffline(gameData.enemies);\n }\n };",
"score": 0.860930323600769
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " export const RandomOpponent: ITargetResolver = (gameData, sourceCard, targetCard) => {\n return TargetFinders._excludeImperviousAndOffline([AllOpponents(gameData, sourceCard, targetCard).random()]);\n };\n }\n export namespace TargetFinders {\n export const Self: ITargetFinder = (_gameData, card) => [card];\n export const Allies = (excludeSelf = false): ITargetFinder =>\n (gameData, card) => {\n let targets: GameEngine.ICardState[] = GameEngineUtils.isEnemyCard(gameData, card) ? gameData.enemies : GameEngineUtils.getPlayerCards(gameData);\n excludeSelf && (targets = targets.filter(x => x.id !== card.id));",
"score": 0.8525933027267456
}
] |
typescript
|
.RaiseMem(-1),
CardScriptParts.ChangeCpu(1),
],
}
|
import * as moment from 'moment';
import { IAppraisedCard, appraiseCard } from '../appraise';
import { IDataSource, IMetricsProvider, IPlayerPushProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { SECS_IN_MIN } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameContent_v1 } from './game-content-v1';
import { GameEngineUtils } from './game-engine-utils';
export namespace GameEngine {
interface _ICommonCardState {
id: number;
cpu: number;
mem: number;
sec: number;
mods: CardMod.ModData[];
scripts: CardScript.ScriptData[];
isRemoved?: boolean;
}
export interface IGameData {
id: string;
difficulty: number;
state: 'created' | 'started' | 'players_won' | 'players_lost' | 'abandoned';
enemies: IEnemyCardState[];
maxEnemies: number;
players: Map<string, IPlayerState>;
defaultMovesPerTurn: number;
turn: number;
nextId: number;
pendingPlayers: Map<string, string[]>;
rulesetIds: string[];
}
export interface IPlayerState {
id: string;
cards: IPlayerCardState[];
endedTurn: boolean;
idleKickTime: number;
movesLeft: number;
movesPerTurn: number;
score: number;
stats: {
kills: number;
secDmg: number;
memDmg: number;
secBonus: number;
};
}
export interface IPlayerCardState extends _ICommonCardState {
card: IAppraisedCard;
isUsed: boolean;
}
export interface IEnemyCardState extends _ICommonCardState {
enemyClass: string;
intent?: { scriptData: CardScript.ScriptData, targetCardId: number };
maxMem: number;
}
export type ICardState = IPlayerCardState | IEnemyCardState;
export abstract class GameEngineError extends Error {
constructor(
public gameId: string,
) {
super();
this.message = `${this.constructor.name} processing game ${gameId}`;
}
}
export class GameNotFoundError extends GameEngineError { }
export interface IRulesetContent {
cardMods?: CardMod.ModLibrary;
cardScripts?: CardScript.ScriptLibrary;
enemyCards?: Record<string, (engine: IGameEngine) => IEnemyCardState>;
}
export interface IRuleset extends IRulesetContent {
initGame(engine: IGameEngine): void;
addAdditionalScriptsFor?(engine: GameEngine.IGameEngine, card: IPlayerCardState): void;
}
export function mergeRulesetContents(...rulesets: IRulesetContent[]): IRulesetContent {
const modLibs = rulesets.map(x => x.cardMods).filter(Boolean);
const scriptLibs = rulesets.map(x => x.cardScripts).filter(Boolean);
const enemyLibs = rulesets.map(x => x.enemyCards).filter(Boolean);
return {
cardMods: Object.fromEntries(modLibs.map(modLib => Object.keys(modLib).map(modName => [modName, modLib[modName]!] as const)).flat()),
cardScripts: Object.fromEntries(scriptLibs.map(scriptLib => Object.keys(scriptLib).map(scriptName => [scriptName, scriptLib[scriptName]!] as const)).flat()),
enemyCards: Object.fromEntries(enemyLibs.map(enemyLib => Object.keys(enemyLib).map(enemyClass => [enemyClass, enemyLib[enemyClass]!] as const)).flat()),
};
}
export type IGameEngine = InstanceType<ReturnType<typeof createGameEngineProvider>>;
}
export const createGameEngineProvider = (rulesets: Record<string, GameEngine.IRuleset>, ds: IDataSource, playerPushProvider: IPlayerPushProvider, metrics?: IMetricsProvider) => {
return class _Engine {
readonly broadcast: IPlayerPushProvider.IPushMessage[] = [];
ruleset!: GameEngine.IRuleset;
constructor(
readonly gameData: GameEngine.IGameData,
) {
const currentRuleset = rulesets[gameData.rulesetIds.at(-1)!];
if (!currentRuleset) throw new Error('invalid initial ruleSet id: ' + gameData.rulesetIds[0]);
this._setRuleset(currentRuleset);
}
private static async _withEngine(gameId: string, stateAssertion: GameEngine.IGameData['state'][], func: (engine: _Engine) => Promise<void>): Promise<GameEngine.IGameData> {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
const engine = new _Engine(gameData);
try {
if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);
await func(engine);
await ds.GameData.update.exec(gameData);
} catch (e: any) {
e.broadcast = engine.broadcast;
throw e;
}
if (engine.broadcast.length) {
await Promise.all(
[...gameData.players.keys()].map(playerId => playerPushProvider.push(playerId, engine.broadcast)),
);
}
return gameData;
}
static async createGame(gameId: string, rulesetId: string, difficulty: number) {
const ruleset = rulesets[rulesetId];
if (!ruleset) throw new Error('invalid ruleSet id: ' + rulesetId);
const existingGameData = await ds.GameData.get(gameId);
if (existingGameData) throw new Error('game with id already exists: ' + gameId);
const gameData: GameEngine.IGameData = {
id: gameId,
difficulty: Math.max(1, difficulty),
state: 'created',
turn: 1,
players: new Map(),
defaultMovesPerTurn: 3,
enemies: [],
maxEnemies: 9,
nextId: 1,
pendingPlayers: new Map(),
rulesetIds: [rulesetId],
};
await ds.GameData.update.exec(gameData);
}
static async startGame(gameId: string) {
const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {
for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
engine.broadcast.push({ type: 'playerJoin', playerState });
}
engine.gameData.pendingPlayers.clear();
engine.gameData.state = 'started';
engine.broadcast.push({ type: 'gameStart' });
engine.ruleset.initGame(engine);
});
return gameData;
}
static async endGame(gameId: string) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
engine.gameData.state = 'abandoned';
engine.broadcast.push({ type: 'gameEnd' });
});
}
static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
if (engine.gameData.players.has(playerId)) throw new Error('player already in game');
if (engine.gameData.players.size >= 2) throw new Error('game is full: ' + gameId);
if (engine.gameData.state === 'started') {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
if (engine.gameData.turn >= 2) {
playerState.endedTurn = true;
playerState.movesLeft = 0;
}
engine.broadcast.push({
type: 'playerJoin',
playerState,
});
} else {
engine.gameData.pendingPlayers.set(playerId, cardIds);
}
});
}
static async removePlayer(gameId: string, playerId: string, reason: 'idle' | 'leave') {
return await _Engine._withEngine(gameId, [], async engine => {
if (!engine.gameData.players.delete(playerId)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId, reason });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
});
}
static async requestCardTargets(gameId: string, playerId: string, cardId: number, scriptName: string) {
const gameData = await _Engine.getGameData(gameId);
const card = GameEngineUtils.findPlayerCardById(gameData, cardId);
let targets = [] as number[];
try {
if (card.isUsed) {
return;
}
const scriptData = card.scripts.find(x => x[0] === scriptName);
if (!scriptData) {
throw new Error(`Script [${scriptName}] not found in card [${cardId}]`);
}
if
|
(CardScript.isOnCooldown(scriptData)) {
|
return;
}
const engine = new _Engine(gameData);
const script = CardScript.deserialize(engine, card, scriptData);
targets = script.targetFinder(gameData, card).map(x => x.id);
} finally {
await playerPushProvider.push(playerId, [{
type: 'cardTargets',
cardId,
scriptName,
targetCardIds: targets,
}]);
}
}
static async intent(gameId: string, playerId: string, sourceCardId?: string, sourceCardScript?: string, targetCardId?: string) {
const gameData = await _Engine.getGameData(gameId);
const pushMessage: IPlayerPushProvider.IPushMessage[] = [{
type: 'cardIntent',
cardId: sourceCardId,
intent: {
scriptData: sourceCardScript,
targetCardId,
},
playerId,
}];
await Promise.all(
[...gameData.players.keys()].filter(x => x !== playerId).map(x => playerPushProvider?.push(x, pushMessage)),
);
}
static async makeMove(gameId: string, playerId: string, sourceCardId: number, sourceCardScript: CardScript.ScriptData, targetCardId: number) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = GameEngineUtils.findPlayerByCardId(engine.gameData, sourceCardId);
if (playerState.id !== playerId) {
throw new Error(`Player ${playerId} cannot make move on card ${sourceCardId} from owner ${playerState.id}`);
}
if (!playerState.movesLeft) {
throw new Error(`No moves left`);
}
const sourceCard = playerState.cards.find(x => x.id === sourceCardId)!;
if (sourceCard.isUsed) {
throw new Error(`Card is used`);
}
const now = moment.now();
playerState.idleKickTime = now + 2 * SECS_IN_MIN * 1000;
playerState.movesLeft--;
const targetCard = GameEngineUtils.findCardById(engine.gameData, targetCardId);
CardScript.execute(engine, sourceCard, sourceCardScript, targetCard);
GameEngineUtils.changeCardIsUsed(engine, sourceCard, true);
metrics?.playerCardPlayed(gameId, engine.gameData.rulesetIds[0] || 'unknown', playerId, sourceCard, sourceCardScript[0]);
});
}
static async toggleEndTurn(gameId: string, playerId: string) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = engine.gameData.players.get(playerId);
if (!playerState) throw new Error('player not found');
if (playerState.endedTurn) {
playerState.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: false,
});
return;
}
playerState.endedTurn = true;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: true,
});
if (![...engine.gameData.players.values()].reduce((numNotReady, playerState) => playerState.endedTurn ? numNotReady : (numNotReady + 1), 0)) {
const now = moment.now();
[...engine.gameData.players.values()].forEach(x => x.idleKickTime = now + 2 * SECS_IN_MIN * 1000);
engine.onEndTurn();
if (engine.gameData.state !== 'started') {
// Stop if the game was won/lost due to an EndTurn effect
return;
}
engine.onTurnStart();
}
});
}
static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {
let kickedPlayerId = '';
await _Engine._withEngine(gameId, ['started'], async engine => {
const playerToKick = [...engine.gameData.players.values()].find(x => x.id !== kickRequestingPlayerId) || '';
if (!playerToKick) throw new Error('kickIfIdle: player not found');
if (playerToKick.idleKickTime < moment.now()) {
if (!engine.gameData.players.delete(playerToKick.id)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId: playerToKick.id, reason: 'idle' });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
kickedPlayerId = playerToKick.id;
}
});
return kickedPlayerId || null;
}
static async getGameData(gameId: string) {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
return gameData;
}
private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {
const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))
.filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)
.map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));
if (cards.length !== cardIds.length) {
throw `could not resolve all cards for player ${playerId}`;
}
const player: GameEngine.IPlayerState = {
id: playerId,
cards: cards.map(card => ({
id: this.nextId(),
card,
isUsed: false,
cpu: card.cpu,
mem: card.mem,
sec: card.mem * 6 + card.cpu * 3,
mods: [],
scripts: [],
})),
endedTurn: false,
movesLeft: this.gameData.defaultMovesPerTurn,
movesPerTurn: this.gameData.defaultMovesPerTurn,
stats: {
kills: 0,
memDmg: 0,
secBonus: 0,
secDmg: 0,
},
score: 0,
idleKickTime: moment.now() + 2 * SECS_IN_MIN * 1000,
};
for (const card of player.cards) {
card.scripts = [
CardScript.fromScriptName(this, card, card.card.coreScript),
];
this.ruleset.addAdditionalScriptsFor && this.ruleset.addAdditionalScriptsFor(this, card);
}
return player;
}
findRuleset(rulesetId: string) {
return rulesets[rulesetId];
}
onTurnStart() {
this.gameData.turn++;
this.broadcast.push({
type: 'newTurn',
turn: this.gameData.turn,
});
for (const player of this.gameData.players.values()) {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
}
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of playerCards) {
GameEngineUtils.changeCardIsUsed(this, playerCard, false);
}
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: playerCard });
}
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: enemy });
}
this._checkGameOver();
}
onEndTurn() {
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: playerCard });
CardScript.tickCooldowns(playerCard, this.broadcast);
}
this.broadcast.push({
type: 'playerTurnEnded',
});
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: enemy });
CardScript.tickCooldowns(enemy, this.broadcast);
}
this.broadcast.push({
type: 'enemyTurnEnded',
});
this._checkGameOver();
}
onNextWave(nextRulesetId: string) {
while (this.gameData.enemies[0]) {
GameEngineUtils.removeCard(this, this.gameData.enemies[0]);
}
[...this.gameData.players.values()].forEach(player => {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
player.cards.forEach(card => {
card.isUsed = false;
});
});
this.gameData.turn++;
this.broadcast.push({
type: 'nextWave',
turn: this.gameData.turn,
nextRulesetId,
});
const nextRuleset = this.findRuleset(nextRulesetId);
if (!nextRuleset) {
throw new Error('invalid rulesetId: ' + nextRulesetId);
}
this.gameData.rulesetIds.push(nextRulesetId);
this._setRuleset(nextRuleset);
nextRuleset.initGame(this);
}
onWinGame() {
this.gameData.state = 'players_won';
this.broadcast.push({
type: 'players_won',
stats: [...this.gameData.players.values()].map(player => {
let score =
player.cards.length * 50
+ player.stats.kills * 25
+ player.stats.memDmg * 50
+ player.stats.secDmg
+ player.stats.secBonus * 2
+ ((this.gameData.rulesetIds.length - 1) * 2000);
score = GameEngineUtils.scaleByDifficulty(score, this.gameData.difficulty + 1);
player.score = score;
return { playerId: player.id, stats: player.stats, score };
}),
});
}
nextId() {
return this.gameData.nextId++;
}
private _checkGameOver() {
if (!GameEngineUtils.getPlayerCards(this.gameData).length) {
this.gameData.state = 'players_lost';
this.broadcast.push({
type: 'players_lost',
});
}
}
private _setRuleset(nextRuleset: GameEngine.IRuleset) {
this.ruleset = {
addAdditionalScriptsFor: GameContent_v1.addAdditionalScriptsFor,
...nextRuleset,
...GameEngine.mergeRulesetContents(
nextRuleset,
{
cardMods: CardMod.Content,
cardScripts: CardScript.Content,
},
{
cardMods: GameContent_v1.cardMods,
cardScripts: GameContent_v1.cardScripts,
enemyCards: GameContent_v1.enemyCards,
}
),
};
}
}
}
export type GameEngineProvider = ReturnType<typeof createGameEngineProvider>;
|
src/game/game-engine.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " for (const script of card.scripts) {\n const cooldownData = CardScript.findCooldownData(script);\n if (!cooldownData?.[1]) {\n continue;\n }\n cooldownData[1]--;\n broadcast.push({\n type: 'scriptChanged',\n cardId: card.id,\n scriptData: script,",
"score": 0.894476056098938
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " targetCardId: targetCard.id,\n scriptData: sourceCardScript,\n });\n if (this.isOnCooldown(sourceCardScript)) {\n throw new Error('Script is on cooldown: ' + sourceCardScript.join());\n }\n const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript));\n const isEnemy = GameEngineUtils.isEnemyCard(engine.gameData, sourceCard);\n if (!isEnemy) {\n if (!scriptDataFromCard) {",
"score": 0.8937891721725464
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());\n }\n }\n const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);\n if (cooldownData) {\n cooldownData[1] = cooldownData[2] + 1;\n }\n const script = this.deserialize(engine, sourceCard, sourceCardScript);\n const targets = script.targetFinder(engine.gameData, sourceCard);\n if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {",
"score": 0.8902727365493774
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " static removeScript(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptType: CardScript.ScriptConstructor) {\n const removed = card.scripts.findAndRemoveFirst(x => x[0] === scriptType.name);\n if (!removed) throw new Error('script not found: ' + scriptType.name);\n engine.broadcast.push({\n type: 'scriptRemoved',\n cardId: card.id,\n removedScript: scriptType.name,\n });\n }\n static tickCooldowns(card: GameEngine.ICardState, broadcast: IPlayerPushProvider.IPushMessage[]) {",
"score": 0.8663409948348999
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " }\n static fromScriptName(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptName: string) {\n return this.deserialize(engine, card, [scriptName]).serialize();\n }\n static isOnCooldown(data: CardScript.ScriptData) {\n return (this.findCooldownData(data)?.[1] || 0) > 0;\n }\n static makeCooldownData(max: number, cur = 0): CardScript.CooldownData {\n return ['$cooldown', cur, max];\n }",
"score": 0.864239513874054
}
] |
typescript
|
(CardScript.isOnCooldown(scriptData)) {
|
import * as moment from 'moment';
import { IAppraisedCard, appraiseCard } from '../appraise';
import { IDataSource, IMetricsProvider, IPlayerPushProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { SECS_IN_MIN } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameContent_v1 } from './game-content-v1';
import { GameEngineUtils } from './game-engine-utils';
export namespace GameEngine {
interface _ICommonCardState {
id: number;
cpu: number;
mem: number;
sec: number;
mods: CardMod.ModData[];
scripts: CardScript.ScriptData[];
isRemoved?: boolean;
}
export interface IGameData {
id: string;
difficulty: number;
state: 'created' | 'started' | 'players_won' | 'players_lost' | 'abandoned';
enemies: IEnemyCardState[];
maxEnemies: number;
players: Map<string, IPlayerState>;
defaultMovesPerTurn: number;
turn: number;
nextId: number;
pendingPlayers: Map<string, string[]>;
rulesetIds: string[];
}
export interface IPlayerState {
id: string;
cards: IPlayerCardState[];
endedTurn: boolean;
idleKickTime: number;
movesLeft: number;
movesPerTurn: number;
score: number;
stats: {
kills: number;
secDmg: number;
memDmg: number;
secBonus: number;
};
}
export interface IPlayerCardState extends _ICommonCardState {
card: IAppraisedCard;
isUsed: boolean;
}
export interface IEnemyCardState extends _ICommonCardState {
enemyClass: string;
intent?: { scriptData: CardScript.ScriptData, targetCardId: number };
maxMem: number;
}
export type ICardState = IPlayerCardState | IEnemyCardState;
export abstract class GameEngineError extends Error {
constructor(
public gameId: string,
) {
super();
this.message = `${this.constructor.name} processing game ${gameId}`;
}
}
export class GameNotFoundError extends GameEngineError { }
export interface IRulesetContent {
cardMods?: CardMod.ModLibrary;
cardScripts?: CardScript.ScriptLibrary;
enemyCards?: Record<string, (engine: IGameEngine) => IEnemyCardState>;
}
export interface IRuleset extends IRulesetContent {
initGame(engine: IGameEngine): void;
addAdditionalScriptsFor?(engine: GameEngine.IGameEngine, card: IPlayerCardState): void;
}
export function mergeRulesetContents(...rulesets: IRulesetContent[]): IRulesetContent {
const modLibs = rulesets.map(x => x.cardMods).filter(Boolean);
const scriptLibs = rulesets.map(x => x.cardScripts).filter(Boolean);
const enemyLibs = rulesets.map(x => x.enemyCards).filter(Boolean);
return {
cardMods: Object.fromEntries(modLibs.map(modLib => Object.keys(modLib).map(modName => [modName, modLib[modName]!] as const)).flat()),
cardScripts: Object.fromEntries(scriptLibs.map(scriptLib => Object.keys(scriptLib).map(scriptName => [scriptName, scriptLib[scriptName]!] as const)).flat()),
enemyCards: Object.fromEntries(enemyLibs.map(enemyLib => Object.keys(enemyLib).map(enemyClass => [enemyClass, enemyLib[enemyClass]!] as const)).flat()),
};
}
export type IGameEngine = InstanceType<ReturnType<typeof createGameEngineProvider>>;
}
export const createGameEngineProvider = (rulesets: Record<string, GameEngine.IRuleset>, ds: IDataSource, playerPushProvider: IPlayerPushProvider, metrics?: IMetricsProvider) => {
return class _Engine {
readonly broadcast: IPlayerPushProvider.IPushMessage[] = [];
ruleset!: GameEngine.IRuleset;
constructor(
readonly gameData: GameEngine.IGameData,
) {
const currentRuleset = rulesets[gameData.rulesetIds.at(-1)!];
if (!currentRuleset) throw new Error('invalid initial ruleSet id: ' + gameData.rulesetIds[0]);
this._setRuleset(currentRuleset);
}
private static async _withEngine(gameId: string, stateAssertion: GameEngine.IGameData['state'][], func: (engine: _Engine) => Promise<void>): Promise<GameEngine.IGameData> {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
const engine = new _Engine(gameData);
try {
if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);
await func(engine);
await ds.GameData.update.exec(gameData);
} catch (e: any) {
e.broadcast = engine.broadcast;
throw e;
}
if (engine.broadcast.length) {
await Promise.all(
[...gameData.players.keys()].map(playerId => playerPushProvider.push(playerId, engine.broadcast)),
);
}
return gameData;
}
static async createGame(gameId: string, rulesetId: string, difficulty: number) {
const ruleset = rulesets[rulesetId];
if (!ruleset) throw new Error('invalid ruleSet id: ' + rulesetId);
const existingGameData = await ds.GameData.get(gameId);
if (existingGameData) throw new Error('game with id already exists: ' + gameId);
const gameData: GameEngine.IGameData = {
id: gameId,
difficulty: Math.max(1, difficulty),
state: 'created',
turn: 1,
players: new Map(),
defaultMovesPerTurn: 3,
enemies: [],
maxEnemies: 9,
nextId: 1,
pendingPlayers: new Map(),
rulesetIds: [rulesetId],
};
await ds.GameData.update.exec(gameData);
}
static async startGame(gameId: string) {
const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {
for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
engine.broadcast.push({ type: 'playerJoin', playerState });
}
engine.gameData.pendingPlayers.clear();
engine.gameData.state = 'started';
engine.broadcast.push({ type: 'gameStart' });
engine.ruleset.initGame(engine);
});
return gameData;
}
static async endGame(gameId: string) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
engine.gameData.state = 'abandoned';
engine.broadcast.push({ type: 'gameEnd' });
});
}
static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
if (engine.gameData.players.has(playerId)) throw new Error('player already in game');
if (engine.gameData.players.size >= 2) throw new Error('game is full: ' + gameId);
if (engine.gameData.state === 'started') {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
if (engine.gameData.turn >= 2) {
playerState.endedTurn = true;
playerState.movesLeft = 0;
}
engine.broadcast.push({
type: 'playerJoin',
playerState,
});
} else {
engine.gameData.pendingPlayers.set(playerId, cardIds);
}
});
}
static async removePlayer(gameId: string, playerId: string, reason: 'idle' | 'leave') {
return await _Engine._withEngine(gameId, [], async engine => {
if (!engine.gameData.players.delete(playerId)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId, reason });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
});
}
static async requestCardTargets(gameId: string, playerId: string, cardId: number, scriptName: string) {
const gameData = await _Engine.getGameData(gameId);
const card = GameEngineUtils.findPlayerCardById(gameData, cardId);
let targets = [] as number[];
try {
if (card.isUsed) {
return;
}
const scriptData = card.scripts.find(x => x[0] === scriptName);
if (!scriptData) {
throw new Error(`Script [${scriptName}] not found in card [${cardId}]`);
}
if (CardScript.isOnCooldown(scriptData)) {
return;
}
const engine = new _Engine(gameData);
const script = CardScript.deserialize(engine, card, scriptData);
targets = script.targetFinder(gameData, card).map(x => x.id);
} finally {
await playerPushProvider.push(playerId, [{
type: 'cardTargets',
cardId,
scriptName,
targetCardIds: targets,
}]);
}
}
static async intent(gameId: string, playerId: string, sourceCardId?: string, sourceCardScript?: string, targetCardId?: string) {
const gameData = await _Engine.getGameData(gameId);
const pushMessage: IPlayerPushProvider.IPushMessage[] = [{
type: 'cardIntent',
cardId: sourceCardId,
intent: {
scriptData: sourceCardScript,
targetCardId,
},
playerId,
}];
await Promise.all(
[...gameData.players.keys()].filter(x => x !== playerId).map(x => playerPushProvider?.push(x, pushMessage)),
);
}
static async makeMove(gameId: string, playerId: string, sourceCardId: number, sourceCardScript: CardScript.ScriptData, targetCardId: number) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = GameEngineUtils.findPlayerByCardId(engine.gameData, sourceCardId);
if (playerState.id !== playerId) {
throw new Error(`Player ${playerId} cannot make move on card ${sourceCardId} from owner ${playerState.id}`);
}
if (!playerState.movesLeft) {
throw new Error(`No moves left`);
}
const sourceCard = playerState.cards.find(x => x.id === sourceCardId)!;
if (sourceCard.isUsed) {
throw new Error(`Card is used`);
}
const now = moment.now();
playerState
|
.idleKickTime = now + 2 * SECS_IN_MIN * 1000;
|
playerState.movesLeft--;
const targetCard = GameEngineUtils.findCardById(engine.gameData, targetCardId);
CardScript.execute(engine, sourceCard, sourceCardScript, targetCard);
GameEngineUtils.changeCardIsUsed(engine, sourceCard, true);
metrics?.playerCardPlayed(gameId, engine.gameData.rulesetIds[0] || 'unknown', playerId, sourceCard, sourceCardScript[0]);
});
}
static async toggleEndTurn(gameId: string, playerId: string) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = engine.gameData.players.get(playerId);
if (!playerState) throw new Error('player not found');
if (playerState.endedTurn) {
playerState.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: false,
});
return;
}
playerState.endedTurn = true;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: true,
});
if (![...engine.gameData.players.values()].reduce((numNotReady, playerState) => playerState.endedTurn ? numNotReady : (numNotReady + 1), 0)) {
const now = moment.now();
[...engine.gameData.players.values()].forEach(x => x.idleKickTime = now + 2 * SECS_IN_MIN * 1000);
engine.onEndTurn();
if (engine.gameData.state !== 'started') {
// Stop if the game was won/lost due to an EndTurn effect
return;
}
engine.onTurnStart();
}
});
}
static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {
let kickedPlayerId = '';
await _Engine._withEngine(gameId, ['started'], async engine => {
const playerToKick = [...engine.gameData.players.values()].find(x => x.id !== kickRequestingPlayerId) || '';
if (!playerToKick) throw new Error('kickIfIdle: player not found');
if (playerToKick.idleKickTime < moment.now()) {
if (!engine.gameData.players.delete(playerToKick.id)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId: playerToKick.id, reason: 'idle' });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
kickedPlayerId = playerToKick.id;
}
});
return kickedPlayerId || null;
}
static async getGameData(gameId: string) {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
return gameData;
}
private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {
const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))
.filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)
.map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));
if (cards.length !== cardIds.length) {
throw `could not resolve all cards for player ${playerId}`;
}
const player: GameEngine.IPlayerState = {
id: playerId,
cards: cards.map(card => ({
id: this.nextId(),
card,
isUsed: false,
cpu: card.cpu,
mem: card.mem,
sec: card.mem * 6 + card.cpu * 3,
mods: [],
scripts: [],
})),
endedTurn: false,
movesLeft: this.gameData.defaultMovesPerTurn,
movesPerTurn: this.gameData.defaultMovesPerTurn,
stats: {
kills: 0,
memDmg: 0,
secBonus: 0,
secDmg: 0,
},
score: 0,
idleKickTime: moment.now() + 2 * SECS_IN_MIN * 1000,
};
for (const card of player.cards) {
card.scripts = [
CardScript.fromScriptName(this, card, card.card.coreScript),
];
this.ruleset.addAdditionalScriptsFor && this.ruleset.addAdditionalScriptsFor(this, card);
}
return player;
}
findRuleset(rulesetId: string) {
return rulesets[rulesetId];
}
onTurnStart() {
this.gameData.turn++;
this.broadcast.push({
type: 'newTurn',
turn: this.gameData.turn,
});
for (const player of this.gameData.players.values()) {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
}
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of playerCards) {
GameEngineUtils.changeCardIsUsed(this, playerCard, false);
}
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: playerCard });
}
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: enemy });
}
this._checkGameOver();
}
onEndTurn() {
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: playerCard });
CardScript.tickCooldowns(playerCard, this.broadcast);
}
this.broadcast.push({
type: 'playerTurnEnded',
});
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: enemy });
CardScript.tickCooldowns(enemy, this.broadcast);
}
this.broadcast.push({
type: 'enemyTurnEnded',
});
this._checkGameOver();
}
onNextWave(nextRulesetId: string) {
while (this.gameData.enemies[0]) {
GameEngineUtils.removeCard(this, this.gameData.enemies[0]);
}
[...this.gameData.players.values()].forEach(player => {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
player.cards.forEach(card => {
card.isUsed = false;
});
});
this.gameData.turn++;
this.broadcast.push({
type: 'nextWave',
turn: this.gameData.turn,
nextRulesetId,
});
const nextRuleset = this.findRuleset(nextRulesetId);
if (!nextRuleset) {
throw new Error('invalid rulesetId: ' + nextRulesetId);
}
this.gameData.rulesetIds.push(nextRulesetId);
this._setRuleset(nextRuleset);
nextRuleset.initGame(this);
}
onWinGame() {
this.gameData.state = 'players_won';
this.broadcast.push({
type: 'players_won',
stats: [...this.gameData.players.values()].map(player => {
let score =
player.cards.length * 50
+ player.stats.kills * 25
+ player.stats.memDmg * 50
+ player.stats.secDmg
+ player.stats.secBonus * 2
+ ((this.gameData.rulesetIds.length - 1) * 2000);
score = GameEngineUtils.scaleByDifficulty(score, this.gameData.difficulty + 1);
player.score = score;
return { playerId: player.id, stats: player.stats, score };
}),
});
}
nextId() {
return this.gameData.nextId++;
}
private _checkGameOver() {
if (!GameEngineUtils.getPlayerCards(this.gameData).length) {
this.gameData.state = 'players_lost';
this.broadcast.push({
type: 'players_lost',
});
}
}
private _setRuleset(nextRuleset: GameEngine.IRuleset) {
this.ruleset = {
addAdditionalScriptsFor: GameContent_v1.addAdditionalScriptsFor,
...nextRuleset,
...GameEngine.mergeRulesetContents(
nextRuleset,
{
cardMods: CardMod.Content,
cardScripts: CardScript.Content,
},
{
cardMods: GameContent_v1.cardMods,
cardScripts: GameContent_v1.cardScripts,
enemyCards: GameContent_v1.enemyCards,
}
),
};
}
}
}
export type GameEngineProvider = ReturnType<typeof createGameEngineProvider>;
|
src/game/game-engine.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());\n }\n }\n const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);\n if (cooldownData) {\n cooldownData[1] = cooldownData[2] + 1;\n }\n const script = this.deserialize(engine, sourceCard, sourceCardScript);\n const targets = script.targetFinder(engine.gameData, sourceCard);\n if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {",
"score": 0.8352410793304443
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " if (source.sec <= 0) {\n GameEngineUtils.removeCard(engine, source);\n return;\n }\n } else {\n GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);\n GameEngineUtils.changeCpu(engine, source, 1);\n for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {\n CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));\n }",
"score": 0.834755539894104
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " targetCardId: targetCard.id,\n scriptData: sourceCardScript,\n });\n if (this.isOnCooldown(sourceCardScript)) {\n throw new Error('Script is on cooldown: ' + sourceCardScript.join());\n }\n const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript));\n const isEnemy = GameEngineUtils.isEnemyCard(engine.gameData, sourceCard);\n if (!isEnemy) {\n if (!scriptDataFromCard) {",
"score": 0.8315963745117188
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " if (cooldownData) {\n script.cooldownCur = cooldownData[1];\n script.cooldownMax = cooldownData[2];\n }\n return script;\n }\n static execute(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, sourceCardScript: CardScript.ScriptData, targetCard: GameEngine.ICardState) {\n engine.broadcast.push({\n type: 'cardExecuting',\n cardId: sourceCard.id,",
"score": 0.8221359252929688
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n (engine, _sourceCard, targetCard) => {\n const totalStats = targetCard.cpu + targetCard.mem;\n const newCpu = randInt(1, totalStats - 1);\n const cpuDelta = newCpu - targetCard.cpu;\n GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);\n const newMem = totalStats - newCpu;\n const memDelta = newMem - targetCard.mem;\n GameEngineUtils.changeMem(engine, targetCard, memDelta);\n },",
"score": 0.817546010017395
}
] |
typescript
|
.idleKickTime = now + 2 * SECS_IN_MIN * 1000;
|
import { CardMod } from '../card-mods';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
const GOLIATH_ID = 9999;
export const RulesetGoliath = {
cardMods: {
goliath_power_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_power(), deps.sourceCard);
}
},
goliath_shield_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_shield(), deps.sourceCard);
}
},
goliath_boss_ai: class extends CardMod {
override onTurnStart(deps: CardMod.ICardModDeps) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard as GameEngine.IEnemyCardState);
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
const targetId = boss.intent?.targetCardId;
if (!targetId) return;
let numAttacks = 1;
const powerBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_power);
if (powerBuff) {
const powerStacks = CardMod.getStackCount(powerBuff);
numAttacks += powerStacks;
}
for (let i = 0; i < numAttacks - 1; i++) {
|
GameEngineUtils.executeIntent(deps.engine, boss, true);
|
}
GameEngineUtils.executeIntent(deps.engine, boss);
}
override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {
if (deps.sourceCard.mem - memDmg <= 0) return;
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
let secBonus = 100;
const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);
if (shieldBuff) {
secBonus += CardMod.getStackCount(shieldBuff) * 100;
}
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);
for (const enemy of [...deps.engine.gameData.enemies]) {
if (enemy === boss) continue;
CardMod.addMod(deps.engine, enemy, new GameContent_v1.cardMods.optimized(1, -1), boss);
}
}
},
goliath_boss_power: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
},
goliath_boss_shield: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
},
},
enemyCards: {
goliath_power_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 2,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_power_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),
);
return enemy;
},
goliath_shield_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_shield_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._defend(enemy, engine.gameData.difficulty, 'weak').serialize(),
new CardScript.Content._firewallSelf(enemy, 1, 2).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: GOLIATH_ID,
enemyClass: 'goliath_boss',
cpu: 2,
mem: 4,
maxMem: 4,
sec: GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
mods: [
new RulesetGoliath.cardMods.goliath_boss_ai().serialize(),
new CardMod.Content._winOnDeath().serialize(),
],
scripts: [],
};
boss.scripts.push(
new CardScript.Content._attack(boss, engine.gameData.difficulty).serialize(),
);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
},
};
|
src/game/rulesets/goliath.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " (engine, _sourceCard, targetCard) => {\n if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;\n const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);\n if (script.targetFinder === CardScript.TargetFinders.Self) return;\n const targets = script.targetFinder(engine.gameData, targetCard);\n if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;\n const origTargetId = targetCard.intent.targetCardId;\n while (targetCard.intent.targetCardId === origTargetId) {\n targetCard.intent.targetCardId = targets.random().id;\n }",
"score": 0.8621382117271423
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " ],\n scripts: [],\n };\n boss.scripts.push(\n new CardScript.Content._attack(boss, engine.gameData.difficulty, 'strong').serialize(),\n new RulesetStasis.cardScripts.stasis_disrupt(boss, engine.gameData.difficulty).serialize(),\n );\n engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);",
"score": 0.8534451723098755
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " const script = CardScript.deserialize(engine, enemy, scriptData);\n const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();\n if (!target) {\n return;\n }\n enemy.intent = {\n scriptData,\n targetCardId: target.id,\n };\n engine.broadcast.push({",
"score": 0.8522592782974243
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " scripts: [],\n };\n boss.mods.push(\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content._waveTrigger(['reaper', 'goliath', 'stasis', 'stasis'], 12).serialize(),\n new CardMod.Content._yieldScript(new CardScript.Content._spawn(boss, RulesetMfrm.enemyCards.intro_perimeter.name, undefined, undefined, 2).serialize(), 2).serialize(),\n );\n boss.scripts.push(\n new CardScript.Content._defend(boss, engine.gameData.difficulty).serialize(),\n );",
"score": 0.8502916097640991
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, contextCard.id);\n if (player) {\n (clampedSecDelta >= 0) ? (player.stats.secBonus += clampedSecDelta) : (player.stats.secDmg += -clampedSecDelta);\n }\n }\n }\n export function executeIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, dontClearIntent = false) {\n const intent = enemy.intent;\n if (!intent) {\n return false;",
"score": 0.8493108749389648
}
] |
typescript
|
GameEngineUtils.executeIntent(deps.engine, boss, true);
|
import * as moment from 'moment';
import { IAppraisedCard, appraiseCard } from '../appraise';
import { IDataSource, IMetricsProvider, IPlayerPushProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { SECS_IN_MIN } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameContent_v1 } from './game-content-v1';
import { GameEngineUtils } from './game-engine-utils';
export namespace GameEngine {
interface _ICommonCardState {
id: number;
cpu: number;
mem: number;
sec: number;
mods: CardMod.ModData[];
scripts: CardScript.ScriptData[];
isRemoved?: boolean;
}
export interface IGameData {
id: string;
difficulty: number;
state: 'created' | 'started' | 'players_won' | 'players_lost' | 'abandoned';
enemies: IEnemyCardState[];
maxEnemies: number;
players: Map<string, IPlayerState>;
defaultMovesPerTurn: number;
turn: number;
nextId: number;
pendingPlayers: Map<string, string[]>;
rulesetIds: string[];
}
export interface IPlayerState {
id: string;
cards: IPlayerCardState[];
endedTurn: boolean;
idleKickTime: number;
movesLeft: number;
movesPerTurn: number;
score: number;
stats: {
kills: number;
secDmg: number;
memDmg: number;
secBonus: number;
};
}
export interface IPlayerCardState extends _ICommonCardState {
card: IAppraisedCard;
isUsed: boolean;
}
export interface IEnemyCardState extends _ICommonCardState {
enemyClass: string;
intent?: { scriptData: CardScript.ScriptData, targetCardId: number };
maxMem: number;
}
export type ICardState = IPlayerCardState | IEnemyCardState;
export abstract class GameEngineError extends Error {
constructor(
public gameId: string,
) {
super();
this.message = `${this.constructor.name} processing game ${gameId}`;
}
}
export class GameNotFoundError extends GameEngineError { }
export interface IRulesetContent {
cardMods?: CardMod.ModLibrary;
cardScripts?: CardScript.ScriptLibrary;
enemyCards?: Record<string, (engine: IGameEngine) => IEnemyCardState>;
}
export interface IRuleset extends IRulesetContent {
initGame(engine: IGameEngine): void;
addAdditionalScriptsFor?(engine: GameEngine.IGameEngine, card: IPlayerCardState): void;
}
export function mergeRulesetContents(...rulesets: IRulesetContent[]): IRulesetContent {
const modLibs = rulesets.map(x => x.cardMods).filter(Boolean);
const scriptLibs = rulesets.map(x => x.cardScripts).filter(Boolean);
const enemyLibs = rulesets.map(x => x.enemyCards).filter(Boolean);
return {
cardMods: Object.fromEntries(modLibs.map(modLib => Object.keys(modLib).map(modName => [modName, modLib[modName]!] as const)).flat()),
cardScripts: Object.fromEntries(scriptLibs.map(scriptLib => Object.keys(scriptLib).map(scriptName => [scriptName, scriptLib[scriptName]!] as const)).flat()),
enemyCards: Object.fromEntries(enemyLibs.map(enemyLib => Object.keys(enemyLib).map(enemyClass => [enemyClass, enemyLib[enemyClass]!] as const)).flat()),
};
}
export type IGameEngine = InstanceType<ReturnType<typeof createGameEngineProvider>>;
}
export const createGameEngineProvider = (rulesets: Record<string, GameEngine.IRuleset>, ds: IDataSource, playerPushProvider: IPlayerPushProvider, metrics?: IMetricsProvider) => {
return class _Engine {
readonly broadcast: IPlayerPushProvider.IPushMessage[] = [];
ruleset!: GameEngine.IRuleset;
constructor(
readonly gameData: GameEngine.IGameData,
) {
const currentRuleset = rulesets[gameData.rulesetIds.at(-1)!];
if (!currentRuleset) throw new Error('invalid initial ruleSet id: ' + gameData.rulesetIds[0]);
this._setRuleset(currentRuleset);
}
private static async _withEngine(gameId: string, stateAssertion: GameEngine.IGameData['state'][], func: (engine: _Engine) => Promise<void>): Promise<GameEngine.IGameData> {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
const engine = new _Engine(gameData);
try {
if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);
await func(engine);
await ds.GameData.update.exec(gameData);
} catch (e: any) {
e.broadcast = engine.broadcast;
throw e;
}
if (engine.broadcast.length) {
await Promise.all(
[...gameData.players.keys()].map(playerId => playerPushProvider.push(playerId, engine.broadcast)),
);
}
return gameData;
}
static async createGame(gameId: string, rulesetId: string, difficulty: number) {
const ruleset = rulesets[rulesetId];
if (!ruleset) throw new Error('invalid ruleSet id: ' + rulesetId);
const existingGameData = await ds.GameData.get(gameId);
if (existingGameData) throw new Error('game with id already exists: ' + gameId);
const gameData: GameEngine.IGameData = {
id: gameId,
difficulty: Math.max(1, difficulty),
state: 'created',
turn: 1,
players: new Map(),
defaultMovesPerTurn: 3,
enemies: [],
maxEnemies: 9,
nextId: 1,
pendingPlayers: new Map(),
rulesetIds: [rulesetId],
};
await ds.GameData.update.exec(gameData);
}
static async startGame(gameId: string) {
const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {
for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
engine.broadcast.push({ type: 'playerJoin', playerState });
}
engine.gameData.pendingPlayers.clear();
engine.gameData.state = 'started';
engine.broadcast.push({ type: 'gameStart' });
engine.ruleset.initGame(engine);
});
return gameData;
}
static async endGame(gameId: string) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
engine.gameData.state = 'abandoned';
engine.broadcast.push({ type: 'gameEnd' });
});
}
static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
if (engine.gameData.players.has(playerId)) throw new Error('player already in game');
if (engine.gameData.players.size >= 2) throw new Error('game is full: ' + gameId);
if (engine.gameData.state === 'started') {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
if (engine.gameData.turn >= 2) {
playerState.endedTurn = true;
playerState.movesLeft = 0;
}
engine.broadcast.push({
type: 'playerJoin',
playerState,
});
} else {
engine.gameData.pendingPlayers.set(playerId, cardIds);
}
});
}
static async removePlayer(gameId: string, playerId: string, reason: 'idle' | 'leave') {
return await _Engine._withEngine(gameId, [], async engine => {
if (!engine.gameData.players.delete(playerId)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId, reason });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
});
}
static async requestCardTargets(gameId: string, playerId: string, cardId: number, scriptName: string) {
const gameData = await _Engine.getGameData(gameId);
const card = GameEngineUtils.findPlayerCardById(gameData, cardId);
let targets = [] as number[];
try {
if (card.isUsed) {
return;
}
const scriptData = card.scripts.find(x => x[0] === scriptName);
if (!scriptData) {
throw new Error(`Script [${scriptName}] not found in card [${cardId}]`);
}
if (CardScript.isOnCooldown(scriptData)) {
return;
}
const engine = new _Engine(gameData);
const script = CardScript.deserialize(engine, card, scriptData);
targets = script.targetFinder(gameData, card).map(x => x.id);
} finally {
await playerPushProvider.push(playerId, [{
type: 'cardTargets',
cardId,
scriptName,
targetCardIds: targets,
}]);
}
}
static async intent(gameId: string, playerId: string, sourceCardId?: string, sourceCardScript?: string, targetCardId?: string) {
const gameData = await _Engine.getGameData(gameId);
const pushMessage: IPlayerPushProvider.IPushMessage[] = [{
type: 'cardIntent',
cardId: sourceCardId,
intent: {
scriptData: sourceCardScript,
targetCardId,
},
playerId,
}];
await Promise.all(
[...gameData.players.keys()].filter(x => x !== playerId).map(x => playerPushProvider?.push(x, pushMessage)),
);
}
static async makeMove(gameId: string, playerId: string, sourceCardId: number, sourceCardScript: CardScript.ScriptData, targetCardId: number) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = GameEngineUtils.findPlayerByCardId(engine.gameData, sourceCardId);
if (playerState.id !== playerId) {
throw new Error(`Player ${playerId} cannot make move on card ${sourceCardId} from owner ${playerState.id}`);
}
if (!playerState.movesLeft) {
throw new Error(`No moves left`);
}
const sourceCard = playerState.cards.find(x => x.id === sourceCardId)!;
if (sourceCard.isUsed) {
throw new Error(`Card is used`);
}
const now = moment.now();
playerState.idleKickTime = now + 2 * SECS_IN_MIN * 1000;
playerState.movesLeft--;
const targetCard = GameEngineUtils.findCardById(engine.gameData, targetCardId);
CardScript.execute(engine, sourceCard, sourceCardScript, targetCard);
GameEngineUtils.changeCardIsUsed(engine, sourceCard, true);
metrics?.playerCardPlayed(gameId, engine.gameData.rulesetIds[0] || 'unknown', playerId, sourceCard, sourceCardScript[0]);
});
}
static async toggleEndTurn(gameId: string, playerId: string) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = engine.gameData.players.get(playerId);
if (!playerState) throw new Error('player not found');
if (playerState.endedTurn) {
playerState.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: false,
});
return;
}
playerState.endedTurn = true;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: true,
});
if (![...engine.gameData.players.values()].reduce((numNotReady, playerState) => playerState.endedTurn ? numNotReady : (numNotReady + 1), 0)) {
const now = moment.now();
[...engine.gameData.players.values()].forEach(x => x.idleKickTime = now + 2 * SECS_IN_MIN * 1000);
engine.onEndTurn();
if (engine.gameData.state !== 'started') {
// Stop if the game was won/lost due to an EndTurn effect
return;
}
engine.onTurnStart();
}
});
}
static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {
let kickedPlayerId = '';
await _Engine._withEngine(gameId, ['started'], async engine => {
const playerToKick = [...engine.gameData.players.values()].find(x => x.id !== kickRequestingPlayerId) || '';
if (!playerToKick) throw new Error('kickIfIdle: player not found');
if (playerToKick.idleKickTime < moment.now()) {
if (!engine.gameData.players.delete(playerToKick.id)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId: playerToKick.id, reason: 'idle' });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
kickedPlayerId = playerToKick.id;
}
});
return kickedPlayerId || null;
}
static async getGameData(gameId: string) {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
return gameData;
}
private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {
const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))
.filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)
.map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));
if (cards.length !== cardIds.length) {
throw `could not resolve all cards for player ${playerId}`;
}
const player: GameEngine.IPlayerState = {
id: playerId,
cards: cards.map(card => ({
id: this.nextId(),
card,
isUsed: false,
cpu: card.cpu,
mem: card.mem,
sec: card.mem * 6 + card.cpu * 3,
mods: [],
scripts: [],
})),
endedTurn: false,
movesLeft: this.gameData.defaultMovesPerTurn,
movesPerTurn: this.gameData.defaultMovesPerTurn,
stats: {
kills: 0,
memDmg: 0,
secBonus: 0,
secDmg: 0,
},
score: 0,
idleKickTime: moment.now() + 2 * SECS_IN_MIN * 1000,
};
for (const card of player.cards) {
card.scripts = [
CardScript.fromScriptName(
|
this, card, card.card.coreScript),
];
|
this.ruleset.addAdditionalScriptsFor && this.ruleset.addAdditionalScriptsFor(this, card);
}
return player;
}
findRuleset(rulesetId: string) {
return rulesets[rulesetId];
}
onTurnStart() {
this.gameData.turn++;
this.broadcast.push({
type: 'newTurn',
turn: this.gameData.turn,
});
for (const player of this.gameData.players.values()) {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
}
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of playerCards) {
GameEngineUtils.changeCardIsUsed(this, playerCard, false);
}
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: playerCard });
}
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: enemy });
}
this._checkGameOver();
}
onEndTurn() {
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: playerCard });
CardScript.tickCooldowns(playerCard, this.broadcast);
}
this.broadcast.push({
type: 'playerTurnEnded',
});
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: enemy });
CardScript.tickCooldowns(enemy, this.broadcast);
}
this.broadcast.push({
type: 'enemyTurnEnded',
});
this._checkGameOver();
}
onNextWave(nextRulesetId: string) {
while (this.gameData.enemies[0]) {
GameEngineUtils.removeCard(this, this.gameData.enemies[0]);
}
[...this.gameData.players.values()].forEach(player => {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
player.cards.forEach(card => {
card.isUsed = false;
});
});
this.gameData.turn++;
this.broadcast.push({
type: 'nextWave',
turn: this.gameData.turn,
nextRulesetId,
});
const nextRuleset = this.findRuleset(nextRulesetId);
if (!nextRuleset) {
throw new Error('invalid rulesetId: ' + nextRulesetId);
}
this.gameData.rulesetIds.push(nextRulesetId);
this._setRuleset(nextRuleset);
nextRuleset.initGame(this);
}
onWinGame() {
this.gameData.state = 'players_won';
this.broadcast.push({
type: 'players_won',
stats: [...this.gameData.players.values()].map(player => {
let score =
player.cards.length * 50
+ player.stats.kills * 25
+ player.stats.memDmg * 50
+ player.stats.secDmg
+ player.stats.secBonus * 2
+ ((this.gameData.rulesetIds.length - 1) * 2000);
score = GameEngineUtils.scaleByDifficulty(score, this.gameData.difficulty + 1);
player.score = score;
return { playerId: player.id, stats: player.stats, score };
}),
});
}
nextId() {
return this.gameData.nextId++;
}
private _checkGameOver() {
if (!GameEngineUtils.getPlayerCards(this.gameData).length) {
this.gameData.state = 'players_lost';
this.broadcast.push({
type: 'players_lost',
});
}
}
private _setRuleset(nextRuleset: GameEngine.IRuleset) {
this.ruleset = {
addAdditionalScriptsFor: GameContent_v1.addAdditionalScriptsFor,
...nextRuleset,
...GameEngine.mergeRulesetContents(
nextRuleset,
{
cardMods: CardMod.Content,
cardScripts: CardScript.Content,
},
{
cardMods: GameContent_v1.cardMods,
cardScripts: GameContent_v1.cardScripts,
enemyCards: GameContent_v1.enemyCards,
}
),
};
}
}
}
export type GameEngineProvider = ReturnType<typeof createGameEngineProvider>;
|
src/game/game-engine.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new CardScript.Content._defend(enemy, engine.gameData.difficulty).serialize(),",
"score": 0.8730592727661133
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " mem: 0,\n maxMem: 0,\n sec: 1,\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };\n enemy.scripts.push(",
"score": 0.8715941905975342
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " ],\n scripts: [],\n };\n boss.scripts.push(\n new CardScript.Content._attack(boss, engine.gameData.difficulty, 'strong').serialize(),\n new RulesetStasis.cardScripts.stasis_disrupt(boss, engine.gameData.difficulty).serialize(),\n );\n engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);",
"score": 0.86809241771698
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " cpu: 2,\n mem: 0,\n maxMem: 0,\n sec: 1,\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };",
"score": 0.8638663291931152
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " maxMem: 1,\n sec: GameEngineUtils.scaleByDifficulty(30, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },",
"score": 0.8631374835968018
}
] |
typescript
|
this, card, card.card.coreScript),
];
|
import { CardMod } from '../card-mods';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
const GOLIATH_ID = 9999;
export const RulesetGoliath = {
cardMods: {
goliath_power_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_power(), deps.sourceCard);
}
},
goliath_shield_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_shield(), deps.sourceCard);
}
},
goliath_boss_ai: class extends CardMod {
override onTurnStart(deps: CardMod.ICardModDeps) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard as GameEngine.IEnemyCardState);
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
const targetId = boss.intent?.targetCardId;
if (!targetId) return;
let numAttacks = 1;
const powerBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_power);
if (powerBuff) {
const powerStacks = CardMod.getStackCount(powerBuff);
numAttacks += powerStacks;
}
for (let i = 0; i < numAttacks - 1; i++) {
GameEngineUtils.executeIntent(deps.engine, boss, true);
}
GameEngineUtils.executeIntent(deps.engine, boss);
}
override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {
if (deps.sourceCard.mem - memDmg <= 0) return;
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
let secBonus = 100;
const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);
if (shieldBuff) {
secBonus += CardMod.getStackCount(shieldBuff) * 100;
}
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);
for (const enemy of [...deps.engine.gameData.enemies]) {
if (enemy === boss) continue;
CardMod.addMod(deps.engine, enemy, new GameContent_v1.cardMods.optimized(1, -1), boss);
}
}
},
goliath_boss_power: class extends CardMod {
override stackingConfig = {
behavior:
|
CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
|
},
goliath_boss_shield: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
},
},
enemyCards: {
goliath_power_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 2,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_power_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),
);
return enemy;
},
goliath_shield_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_shield_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._defend(enemy, engine.gameData.difficulty, 'weak').serialize(),
new CardScript.Content._firewallSelf(enemy, 1, 2).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: GOLIATH_ID,
enemyClass: 'goliath_boss',
cpu: 2,
mem: 4,
maxMem: 4,
sec: GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
mods: [
new RulesetGoliath.cardMods.goliath_boss_ai().serialize(),
new CardMod.Content._winOnDeath().serialize(),
],
scripts: [],
};
boss.scripts.push(
new CardScript.Content._attack(boss, engine.gameData.difficulty).serialize(),
);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
},
};
|
src/game/rulesets/goliath.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " scripts: [],\n };\n boss.mods.push(\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content._waveTrigger(['reaper', 'goliath', 'stasis', 'stasis'], 12).serialize(),\n new CardMod.Content._yieldScript(new CardScript.Content._spawn(boss, RulesetMfrm.enemyCards.intro_perimeter.name, undefined, undefined, 2).serialize(), 2).serialize(),\n );\n boss.scripts.push(\n new CardScript.Content._defend(boss, engine.gameData.difficulty).serialize(),\n );",
"score": 0.8632882237434387
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " maxMem: 1,\n sec: GameEngineUtils.scaleByDifficulty(30, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },",
"score": 0.8629711270332336
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {\n CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);\n if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {\n GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n }\n }\n },\n },",
"score": 0.8629007339477539
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);\n }\n }\n override onRemoveMod(deps: ICardModDeps): void {\n if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {\n GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);\n } else {\n GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);\n }\n }",
"score": 0.8601647615432739
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);\n } else {\n GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);\n }\n }\n }\n export class secured extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,",
"score": 0.8599029183387756
}
] |
typescript
|
CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
|
import { CardMod } from '../card-mods';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
const GOLIATH_ID = 9999;
export const RulesetGoliath = {
cardMods: {
goliath_power_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_power(), deps.sourceCard);
}
},
goliath_shield_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_shield(), deps.sourceCard);
}
},
goliath_boss_ai: class extends CardMod {
override onTurnStart(deps: CardMod.ICardModDeps) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard as GameEngine.IEnemyCardState);
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
const targetId = boss.intent?.targetCardId;
if (!targetId) return;
let numAttacks = 1;
const powerBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_power);
if (powerBuff) {
const powerStacks = CardMod.getStackCount(powerBuff);
numAttacks += powerStacks;
}
for (let i = 0; i < numAttacks - 1; i++) {
GameEngineUtils.executeIntent(deps.engine, boss, true);
}
GameEngineUtils.executeIntent(deps.engine, boss);
}
override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {
if (deps.sourceCard.mem - memDmg <= 0) return;
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
let secBonus = 100;
const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);
if (shieldBuff) {
secBonus += CardMod.getStackCount(shieldBuff) * 100;
}
GameEngineUtils.changeSec(deps.engine, deps.
|
sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);
|
for (const enemy of [...deps.engine.gameData.enemies]) {
if (enemy === boss) continue;
CardMod.addMod(deps.engine, enemy, new GameContent_v1.cardMods.optimized(1, -1), boss);
}
}
},
goliath_boss_power: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
},
goliath_boss_shield: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
},
},
enemyCards: {
goliath_power_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 2,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_power_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),
);
return enemy;
},
goliath_shield_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_shield_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._defend(enemy, engine.gameData.difficulty, 'weak').serialize(),
new CardScript.Content._firewallSelf(enemy, 1, 2).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: GOLIATH_ID,
enemyClass: 'goliath_boss',
cpu: 2,
mem: 4,
maxMem: 4,
sec: GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
mods: [
new RulesetGoliath.cardMods.goliath_boss_ai().serialize(),
new CardMod.Content._winOnDeath().serialize(),
],
scripts: [],
};
boss.scripts.push(
new CardScript.Content._attack(boss, engine.gameData.difficulty).serialize(),
);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
},
};
|
src/game/rulesets/goliath.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " };\n export const MemDmg = (memDmg: number): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n GameEngineUtils.triggerMods('onMemDmgOut', { engine, sourceCard, contextCard: targetCard }, memDmg);\n GameEngineUtils.triggerMods('onMemDmgIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, memDmg);\n if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {\n return;\n }\n targetCard.mem -= memDmg;\n engine.broadcast.push({",
"score": 0.912738561630249
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " type: 'memDamage',\n cardId: targetCard.id,\n newMem: targetCard.mem,\n value: -memDmg,\n });\n const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, sourceCard.id);\n player && (player.stats.memDmg += memDmg);\n if (targetCard.mem <= 0) {\n GameEngineUtils.removeCard(engine, targetCard, sourceCard);\n }",
"score": 0.8959633111953735
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " }\n override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {\n CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);\n }\n },\n // Increases CPU\n optimized: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,",
"score": 0.8799196481704712
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);\n }\n }\n override onRemoveMod(deps: ICardModDeps): void {\n if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {\n GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);\n } else {\n GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);\n }\n }",
"score": 0.8777117729187012
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {\n CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);\n if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {\n GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n }\n }\n },\n },",
"score": 0.875157356262207
}
] |
typescript
|
sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);
|
import { CardMod } from '../card-mods';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
const GOLIATH_ID = 9999;
export const RulesetGoliath = {
cardMods: {
goliath_power_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_power(), deps.sourceCard);
}
},
goliath_shield_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_shield(), deps.sourceCard);
}
},
goliath_boss_ai: class extends CardMod {
override onTurnStart(deps: CardMod.ICardModDeps) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard as GameEngine.IEnemyCardState);
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
const targetId = boss.intent?.targetCardId;
if (!targetId) return;
let numAttacks = 1;
const powerBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_power);
if (powerBuff) {
const powerStacks = CardMod.getStackCount(powerBuff);
numAttacks += powerStacks;
}
for (let i = 0; i < numAttacks - 1; i++) {
GameEngineUtils.executeIntent(deps.engine, boss, true);
}
GameEngineUtils.executeIntent(deps.engine, boss);
}
override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {
if (deps.sourceCard.mem - memDmg <= 0) return;
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
let secBonus = 100;
const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);
if (shieldBuff) {
secBonus += CardMod.getStackCount(shieldBuff) * 100;
}
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);
for (const enemy of [...deps.engine.gameData.enemies]) {
if (enemy === boss) continue;
CardMod.addMod(deps.engine, enemy, new GameContent_v1.
|
cardMods.optimized(1, -1), boss);
|
}
}
},
goliath_boss_power: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
},
goliath_boss_shield: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
},
},
enemyCards: {
goliath_power_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 2,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_power_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),
);
return enemy;
},
goliath_shield_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_shield_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._defend(enemy, engine.gameData.difficulty, 'weak').serialize(),
new CardScript.Content._firewallSelf(enemy, 1, 2).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: GOLIATH_ID,
enemyClass: 'goliath_boss',
cpu: 2,
mem: 4,
maxMem: 4,
sec: GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
mods: [
new RulesetGoliath.cardMods.goliath_boss_ai().serialize(),
new CardMod.Content._winOnDeath().serialize(),
],
scripts: [],
};
boss.scripts.push(
new CardScript.Content._attack(boss, engine.gameData.difficulty).serialize(),
);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
},
};
|
src/game/rulesets/goliath.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {\n CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);\n if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {\n GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n }\n }\n },\n },",
"score": 0.8859478235244751
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " scripts: [],\n };\n boss.mods.push(\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content._waveTrigger(['reaper', 'goliath', 'stasis', 'stasis'], 12).serialize(),\n new CardMod.Content._yieldScript(new CardScript.Content._spawn(boss, RulesetMfrm.enemyCards.intro_perimeter.name, undefined, undefined, 2).serialize(), 2).serialize(),\n );\n boss.scripts.push(\n new CardScript.Content._defend(boss, engine.gameData.difficulty).serialize(),\n );",
"score": 0.8735997676849365
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)\n .reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);\n }\n if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {\n return false;\n }\n resolvedDamage = Math.max(0, resolvedDamage);\n const secExceeded = resolvedDamage > targetCard.sec;\n GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);\n return secExceeded;",
"score": 0.8711674809455872
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " ],\n scripts: [],\n };\n boss.scripts.push(\n new CardScript.Content._attack(boss, engine.gameData.difficulty, 'strong').serialize(),\n new RulesetStasis.cardScripts.stasis_disrupt(boss, engine.gameData.difficulty).serialize(),\n );\n engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);",
"score": 0.8699856996536255
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " if (source.sec <= 0) {\n GameEngineUtils.removeCard(engine, source);\n return;\n }\n } else {\n GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);\n GameEngineUtils.changeCpu(engine, source, 1);\n for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {\n CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));\n }",
"score": 0.8685582876205444
}
] |
typescript
|
cardMods.optimized(1, -1), boss);
|
import { clamp, round } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
export namespace GameEngineUtils {
export function addEnemy(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, spawnIndex: number, generateIntent: boolean) {
if (engine.gameData.enemies.length >= engine.gameData.maxEnemies) return;
spawnIndex = clamp(spawnIndex, 0, engine.gameData.enemies.length);
engine.gameData.enemies.splice(spawnIndex, 0, enemy);
engine.broadcast.push({
type: 'cardAdded',
enemy,
position: spawnIndex,
});
GameEngineUtils.triggerMods('onInitMod', { engine, sourceCard: enemy });
if (generateIntent) {
GameEngineUtils.generateIntent(engine, enemy);
}
return enemy;
}
export function changeCardIsUsed(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState, isUsed: boolean) {
card.isUsed = isUsed;
engine.broadcast.push({
type: 'cardIsUsedChanged',
cardId: card.id,
isUsed,
});
}
export function clearIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = undefined;
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
});
return true;
}
export function changeCpu(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, cpuDelta: number) {
card.cpu += cpuDelta;
engine.broadcast.push({
type: 'cpuChanged',
cardId: card.id,
newCpu: card.cpu,
cpuDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeMem(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, memDelta: number) {
card.mem += memDelta;
engine.broadcast.push({
type: 'memChanged',
cardId: card.id,
newMem: card.mem,
memDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeSec(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, secDelta: number, isPassive: boolean, contextCard?: GameEngine.ICardState) {
const clampedSecDelta = (card.sec < -secDelta) ? -card.sec : secDelta;
card.sec += clampedSecDelta;
engine.broadcast.push({
type: isPassive ? 'secChange' : (secDelta < 0 ? 'secDamage' : 'secBonus'),
cardId: card.id,
newSec: card.sec,
value: secDelta,
});
if (!isPassive && contextCard) {
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
if (player) {
(clampedSecDelta >= 0) ? (player.stats.secBonus += clampedSecDelta) : (player.stats.secDmg += -clampedSecDelta);
}
}
}
export function executeIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, dontClearIntent = false) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = dontClearIntent ? enemy.intent : undefined;
let targetCard: GameEngine.ICardState | undefined;
if (intent.targetCardId >= 0) {
targetCard = findCardByIdMaybe(engine.gameData, intent.targetCardId);
if (!targetCard) {
// Intent target could've been removed between intent generation and execution
return false;
}
} else {
targetCard = enemy;
}
CardScript.execute(engine, enemy, intent.scriptData, targetCard);
return true;
}
export function findCardById(gameData: GameEngine.IGameData, cardId: number) {
const card = findCardByIdMaybe(gameData, cardId);
if (card) return card;
throw new Error('card not found');
}
export function findCardByIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
const enemy = gameData.enemies.find(x => x.id === cardId);
if (enemy) return enemy;
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) {
return player.cards.find(x => x.id === cardId);
}
return;
}
export function findPlayerCardById(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (!player) throw new Error('player not found');
return player.cards.find(x => x.id === cardId)!;
}
export function findPlayerByCardId(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) return player;
throw new Error('player not found');
}
export function findPlayerByCardIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
return [...gameData.players.values()].find(x => x.cards.find(x => x.id === cardId));
}
export function generateIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
enemy.intent = undefined;
const isOffline = !!enemy.mods.find(x => x[0] === 'offline');
if (isOffline) return;
const scriptData = enemy.scripts.filter(x => !CardScript.isOnCooldown(x)).randomOrUndefined();
if (!scriptData) {
return;
}
const script = CardScript.deserialize(engine, enemy, scriptData);
const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();
if (!target) {
return;
}
enemy.intent = {
scriptData,
targetCardId: target.id,
};
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
intent: enemy.intent,
});
}
export function getEnemyIds(gameData: GameEngine.IGameData) {
return gameData.enemies.map(x => x.id);
}
export function getPlayerIds(gameData: GameEngine.IGameData, ...excludePlayer: string[]) {
return [...gameData.players.keys()].filter(x => !excludePlayer.includes(x));
}
export function getPlayerCards(gameData: GameEngine.IGameData) {
return [...gameData.players.values()].map(x => x.cards).flat();
}
export function getPlayerCardIds(gameData: GameEngine.IGameData) {
return getPlayerCards(gameData).map(x => x.id);
}
export function isEnemyCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IEnemyCardState {
return !!gameData.enemies.find(x => x.id === card.id);
}
export function isPlayerCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IPlayerCardState {
return !isEnemyCard(gameData, card);
}
export function recalculateScripts(engine: GameEngine.IGameEngine, card: GameEngine.ICardState) {
if (card.isRemoved) return;
card.scripts = card.scripts.map(x => CardScript.deserialize(engine, card, x).serialize());
engine.broadcast.push(...card.scripts.map(x => ({
type: 'scriptChanged',
cardId: card.id,
scriptData: x,
})));
if (isEnemyCard(engine.gameData, card) && card.intent?.scriptData) {
card.intent.scriptData = CardScript.deserialize(engine, card, card.intent.scriptData).serialize();
engine.broadcast.push({
type: 'cardIntent',
cardId: card.id,
intent: card.intent,
});
}
}
export function revalidateIntents(engine: GameEngine.IGameEngine, regenerateIfInvalid: boolean) {
for (const enemy of engine.gameData.enemies) {
if (!enemy.intent || enemy.intent.targetCardId === -1) {
continue;
}
const script = CardScript.deserialize(engine, enemy, enemy.intent.scriptData);
const validTargets = script.targetFinder(engine.gameData, enemy);
if (validTargets.find(x => x.id === enemy.intent?.targetCardId)) {
continue;
}
enemy.intent = undefined;
if (regenerateIfInvalid) {
generateIntent(engine, enemy);
}
}
}
export function removeCard(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, contextCard?: GameEngine.ICardState) {
if (card.isRemoved) {
return;
}
if (isEnemyCard(engine.gameData, card)) {
engine.gameData.enemies.removeFirst(card)
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
for (const enemy of [...engine.gameData.enemies]) {
if (enemy.isRemoved) continue;
triggerMods('onEnemyDestroyed', { engine, sourceCard: card, contextCard });
}
if (contextCard) {
const player = findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
player && player.stats.kills++;
}
GameEngineUtils.revalidateIntents(engine, true);
} else {
const player = GameEngineUtils.findPlayerByCardId(engine.gameData, card.id);
player.cards.removeFirst(card);
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed',
|
{ engine, contextCard, sourceCard: card });
|
card.isRemoved = true;
GameEngineUtils.revalidateIntents(engine, false);
}
}
export function scaleByCpuMem(baseValue: number, cpuMem: number, cpuMemScaling: 'normal' | 'less' | 'more' | 'minimal' | 'high' = 'normal') {
let valuePerCpu = baseValue / 2;
switch (cpuMemScaling) {
case 'high': valuePerCpu * 1.5; break;
case 'more': valuePerCpu * 1.25; break;
case 'less': valuePerCpu * .75; break;
case 'minimal': valuePerCpu * .5; break;
}
return Math.round(baseValue + ((cpuMem - 1) * valuePerCpu));
}
export function scaleByDifficulty(value: number, difficulty: number, decimals = 0) {
return round(value * Math.pow(1.1, difficulty - 1), decimals);
}
export function spawnEnemy(engine: GameEngine.IGameEngine, enemyClass: string, spawnIndex: number, generateIntent: boolean) {
const enemyFactory = engine.ruleset.enemyCards?.[enemyClass];
if (!enemyFactory) throw new Error('EnemyClass not found for spawning: ' + enemyClass);
const enemy = enemyFactory(engine);
enemy.enemyClass = enemyClass;
return addEnemy(engine, enemy, spawnIndex, generateIntent);
}
export function triggerMods<T extends CardMod.ModEvent>(ev: T, ...args: Parameters<NonNullable<CardMod[typeof ev]>>): ReturnType<NonNullable<CardMod[typeof ev]>>[] {
const deps = args[0];
const card = deps.sourceCard;
return [...card.mods]
.map(modData => (!card.isRemoved && card.mods.find(x => CardMod.areEqual(x, modData))) ? CardMod.trigger(ev, modData, ...args) : undefined)
.filter(Boolean);
}
}
|
src/game/game-engine-utils.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " type: 'modRemoved',\n cardId: card.id,\n modData,\n });\n if (!card.mods.find(x => this.areEqual(x, modData))) {\n throw new Error('mod not found');\n }\n this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });\n card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));\n }",
"score": 0.8838266134262085
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " (engine, _sourceCard, targetCard) => {\n if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;\n const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);\n if (script.targetFinder === CardScript.TargetFinders.Self) return;\n const targets = script.targetFinder(engine.gameData, targetCard);\n if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;\n const origTargetId = targetCard.intent.targetCardId;\n while (targetCard.intent.targetCardId === origTargetId) {\n targetCard.intent.targetCardId = targets.random().id;\n }",
"score": 0.8775287866592407
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);\n }\n }\n override onRemoveMod(deps: ICardModDeps): void {\n if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {\n GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);\n } else {\n GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);\n }\n }",
"score": 0.8710014224052429
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " card.mods.push(modData);\n break;\n }\n }\n engine.broadcast.push({\n type: 'modAdded',\n cardId: card.id,\n modData,\n });\n this.trigger('onInitMod', modData, { engine, sourceCard: card, contextCard });",
"score": 0.8700228929519653
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " engine.broadcast.push({\n type: 'modStackChanged',\n cardId: card.id,\n modData: existingModData,\n stackDelta: mod.stackingConfig.stackCount,\n newStackCount: existingStackingData[2],\n });\n this.trigger('onStackMod', existingModData, { engine, sourceCard: card, contextCard }, mod.stackingConfig.stackCount);\n return;\n }",
"score": 0.8613480925559998
}
] |
typescript
|
{ engine, contextCard, sourceCard: card });
|
import { CardMod } from '../card-mods';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
const GOLIATH_ID = 9999;
export const RulesetGoliath = {
cardMods: {
goliath_power_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_power(), deps.sourceCard);
}
},
goliath_shield_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_shield(), deps.sourceCard);
}
},
goliath_boss_ai: class extends CardMod {
override onTurnStart(deps: CardMod.ICardModDeps) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard as GameEngine.IEnemyCardState);
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
const targetId = boss.intent?.targetCardId;
if (!targetId) return;
let numAttacks = 1;
const powerBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_power);
if (powerBuff) {
const powerStacks = CardMod.getStackCount(powerBuff);
numAttacks += powerStacks;
}
for (let i = 0; i < numAttacks - 1; i++) {
GameEngineUtils.executeIntent(deps.engine, boss, true);
}
GameEngineUtils.executeIntent(deps.engine, boss);
}
override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {
if (deps.sourceCard.mem - memDmg <= 0) return;
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
let secBonus = 100;
const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);
if (shieldBuff) {
secBonus += CardMod.getStackCount(shieldBuff) * 100;
}
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);
for (const enemy of [...deps.engine.gameData.enemies]) {
if (enemy === boss) continue;
CardMod.addMod(deps.engine, enemy, new GameContent_v1.cardMods.optimized(1, -1), boss);
}
}
},
goliath_boss_power: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
},
goliath_boss_shield: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
},
},
enemyCards: {
goliath_power_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 2,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_power_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),
);
return enemy;
},
goliath_shield_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_shield_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._defend(enemy, engine.gameData.difficulty, 'weak').serialize(),
new CardScript.Content._firewallSelf(enemy, 1, 2).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: GOLIATH_ID,
enemyClass: 'goliath_boss',
cpu: 2,
mem: 4,
maxMem: 4,
sec: GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
mods: [
new RulesetGoliath.cardMods.goliath_boss_ai().serialize(),
new CardMod.Content._winOnDeath().serialize(),
],
scripts: [],
};
boss.scripts.push(
new CardScript.Content._attack(boss, engine.gameData.difficulty).serialize(),
);
|
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
|
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
},
};
|
src/game/rulesets/goliath.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " scripts: [],\n };\n boss.mods.push(\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content._waveTrigger(['reaper', 'goliath', 'stasis', 'stasis'], 12).serialize(),\n new CardMod.Content._yieldScript(new CardScript.Content._spawn(boss, RulesetMfrm.enemyCards.intro_perimeter.name, undefined, undefined, 2).serialize(), 2).serialize(),\n );\n boss.scripts.push(\n new CardScript.Content._defend(boss, engine.gameData.difficulty).serialize(),\n );",
"score": 0.9452558755874634
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " ],\n scripts: [],\n };\n boss.scripts.push(\n new CardScript.Content._attack(boss, engine.gameData.difficulty, 'strong').serialize(),\n new RulesetStasis.cardScripts.stasis_disrupt(boss, engine.gameData.difficulty).serialize(),\n );\n engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);",
"score": 0.9341784715652466
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new CardScript.Content._defend(enemy, engine.gameData.difficulty).serialize(),",
"score": 0.9181771278381348
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " boss.scripts.push(\n new RulesetReaper.cardScripts.reaper_bossEat(boss).serialize(),\n );\n GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);\n engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);\n GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);\n GameEngineUtils.addEnemy(engine, boss, 0, true);\n GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);\n engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);\n GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);",
"score": 0.9114493727684021
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " maxMem: 1,\n sec: GameEngineUtils.scaleByDifficulty(30, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },",
"score": 0.9107058644294739
}
] |
typescript
|
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
|
import { randInt } from '../../utils';
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetReaper = {
cardMods: {
reaper_feederCorrupted: class extends CardMod {
},
reaper_feederPower: class extends CardMod {
override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {
if (deps.sourceCard.sec - damage > 0) return;
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);
CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);
const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);
player && player.stats.kills++;
return { secDmgBonus: -9999 };
}
},
},
cardScripts: {
reaper_bossEat: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, _card) => {
return gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_feeder.name);
},
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, source, target) => {
GameEngineUtils.
|
removeCard(engine, target, source);
|
if (target.mods.find(x => x[0] === RulesetReaper.cardMods.reaper_feederCorrupted.name)) {
GameEngineUtils.changeSec(engine, source, -50, false);
if (source.sec <= 0) {
GameEngineUtils.removeCard(engine, source);
return;
}
} else {
GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);
GameEngineUtils.changeCpu(engine, source, 1);
for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {
CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));
}
}
const highDiff = engine.gameData.difficulty >= 7;
if (engine.gameData.enemies.length <= (highDiff ? 6 : 4)) {
while (engine.gameData.enemies.findIndex(x => x.id === source.id) < (highDiff ? 4 : 3)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absLeft')(engine, source, target);
}
while (engine.gameData.enemies.length < (highDiff ? 9 : 7)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absRight')(engine, source, target);
}
}
},
],
}
],
);
}
},
},
enemyCards: {
reaper_feeder: (engine: GameEngine.IGameEngine): GameEngine.IEnemyCardState => {
return {
id: engine.nextId(),
enemyClass: 'reaper_feeder',
cpu: 0,
mem: 0,
maxMem: 0,
sec: randInt(
GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),
GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
),
mods: [
new RulesetReaper.cardMods.reaper_feederPower().serialize(),
],
scripts: [],
};
},
reaper_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_lesser_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak', 1).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_boss',
cpu: 0,
mem: 0,
maxMem: 0,
sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content._winOnDeath().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
boss.scripts.push(
new RulesetReaper.cardScripts.reaper_bossEat(boss).serialize(),
);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
},
};
|
src/game/rulesets/reaper.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " (engine, _sourceCard, targetCard) => {\n if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;\n const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);\n if (script.targetFinder === CardScript.TargetFinders.Self) return;\n const targets = script.targetFinder(engine.gameData, targetCard);\n if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;\n const origTargetId = targetCard.intent.targetCardId;\n while (targetCard.intent.targetCardId === origTargetId) {\n targetCard.intent.targetCardId = targets.random().id;\n }",
"score": 0.8757139444351196
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " super(\n [],\n (gameData, card) =>\n CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.ChangeCpu(-1),\n CardScriptParts.RaiseMem(1),",
"score": 0.8676957488059998
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [],\n (gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseMem(-1),\n CardScriptParts.ChangeCpu(1),\n ],\n }",
"score": 0.8670122623443604
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " const i = cards.findIndex(x => x.id === targetCard.id);\n return [cards[i], cards[i - 1], cards[i + 1]].filter(Boolean);\n };\n export const AllAllies: ITargetResolver = (gameData, sourceCard) => {\n if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {\n return TargetFinders._excludeOffline(gameData.enemies);\n } else {\n return TargetFinders._excludeOffline(GameEngineUtils.getPlayerCards(gameData));\n }\n };",
"score": 0.865675151348114
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " if (isEnemyCard(engine.gameData, card)) {\n engine.gameData.enemies.removeFirst(card)\n engine.broadcast.push({\n type: 'cardRemoved',\n cardId: card.id,\n });\n GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });\n card.isRemoved = true;\n for (const enemy of [...engine.gameData.enemies]) {\n if (enemy.isRemoved) continue;",
"score": 0.864113986492157
}
] |
typescript
|
removeCard(engine, target, source);
|
import { randInt } from '../../utils';
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetReaper = {
cardMods: {
reaper_feederCorrupted: class extends CardMod {
},
reaper_feederPower: class extends CardMod {
override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {
if (deps.sourceCard.sec - damage > 0) return;
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);
CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);
const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);
player && player.stats.kills++;
return { secDmgBonus: -9999 };
}
},
},
cardScripts: {
reaper_bossEat: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, _card) => {
return gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_feeder.name);
},
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, source, target) => {
GameEngineUtils.removeCard(engine, target, source);
if (target.mods.find(x => x[0] === RulesetReaper.cardMods.reaper_feederCorrupted.name)) {
GameEngineUtils.changeSec(engine, source, -50, false);
if (source.sec <= 0) {
GameEngineUtils.removeCard(engine, source);
return;
}
} else {
GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);
|
GameEngineUtils.changeCpu(engine, source, 1);
|
for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {
CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));
}
}
const highDiff = engine.gameData.difficulty >= 7;
if (engine.gameData.enemies.length <= (highDiff ? 6 : 4)) {
while (engine.gameData.enemies.findIndex(x => x.id === source.id) < (highDiff ? 4 : 3)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absLeft')(engine, source, target);
}
while (engine.gameData.enemies.length < (highDiff ? 9 : 7)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absRight')(engine, source, target);
}
}
},
],
}
],
);
}
},
},
enemyCards: {
reaper_feeder: (engine: GameEngine.IGameEngine): GameEngine.IEnemyCardState => {
return {
id: engine.nextId(),
enemyClass: 'reaper_feeder',
cpu: 0,
mem: 0,
maxMem: 0,
sec: randInt(
GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),
GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
),
mods: [
new RulesetReaper.cardMods.reaper_feederPower().serialize(),
],
scripts: [],
};
},
reaper_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_lesser_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak', 1).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_boss',
cpu: 0,
mem: 0,
maxMem: 0,
sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content._winOnDeath().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
boss.scripts.push(
new RulesetReaper.cardScripts.reaper_bossEat(boss).serialize(),
);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
},
};
|
src/game/rulesets/reaper.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n (engine, _sourceCard, targetCard) => {\n const totalStats = targetCard.cpu + targetCard.mem;\n const newCpu = randInt(1, totalStats - 1);\n const cpuDelta = newCpu - targetCard.cpu;\n GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);\n const newMem = totalStats - newCpu;\n const memDelta = newMem - targetCard.mem;\n GameEngineUtils.changeMem(engine, targetCard, memDelta);\n },",
"score": 0.8718958497047424
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)\n .reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);\n }\n if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {\n return false;\n }\n resolvedDamage = Math.max(0, resolvedDamage);\n const secExceeded = resolvedDamage > targetCard.sec;\n GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);\n return secExceeded;",
"score": 0.8584793210029602
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " (engine, _sourceCard, targetCard) => {\n if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;\n const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);\n if (script.targetFinder === CardScript.TargetFinders.Self) return;\n const targets = script.targetFinder(engine.gameData, targetCard);\n if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;\n const origTargetId = targetCard.intent.targetCardId;\n while (targetCard.intent.targetCardId === origTargetId) {\n targetCard.intent.targetCardId = targets.random().id;\n }",
"score": 0.8578793406486511
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (deps.sourceCard.mem - memDmg <= 0) return;\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n let secBonus = 100;\n const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);\n if (shieldBuff) {\n secBonus += CardMod.getStackCount(shieldBuff) * 100;\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);\n for (const enemy of [...deps.engine.gameData.enemies]) {\n if (enemy === boss) continue;",
"score": 0.8545658588409424
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " type: 'memDamage',\n cardId: targetCard.id,\n newMem: targetCard.mem,\n value: -memDmg,\n });\n const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, sourceCard.id);\n player && (player.stats.memDmg += memDmg);\n if (targetCard.mem <= 0) {\n GameEngineUtils.removeCard(engine, targetCard, sourceCard);\n }",
"score": 0.8504263162612915
}
] |
typescript
|
GameEngineUtils.changeCpu(engine, source, 1);
|
import { randInt } from '../../utils';
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetReaper = {
cardMods: {
reaper_feederCorrupted: class extends CardMod {
},
reaper_feederPower: class extends CardMod {
override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {
if (deps.sourceCard.sec - damage > 0) return;
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);
CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);
const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);
player && player.stats.kills++;
return { secDmgBonus: -9999 };
}
},
},
cardScripts: {
reaper_bossEat: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, _card) => {
return gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_feeder.name);
},
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, source, target) => {
GameEngineUtils.removeCard(engine, target, source);
if (target.mods.find(x => x[0] === RulesetReaper.cardMods.reaper_feederCorrupted.name)) {
GameEngineUtils.changeSec(engine, source, -50, false);
if (source.sec <= 0) {
GameEngineUtils.removeCard(engine, source);
return;
}
} else {
GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);
GameEngineUtils.changeCpu(engine, source, 1);
for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {
CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));
}
}
const highDiff = engine.gameData.difficulty >= 7;
if (engine.gameData.enemies.length <= (highDiff ? 6 : 4)) {
while (engine.gameData.enemies.findIndex(x => x.id === source.id) < (highDiff ? 4 : 3)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absLeft')(engine, source, target);
}
while (engine.gameData.enemies.length < (highDiff ? 9 : 7)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absRight')(engine, source, target);
}
}
},
],
}
],
);
}
},
},
enemyCards: {
reaper_feeder: (engine: GameEngine.IGameEngine): GameEngine.IEnemyCardState => {
return {
id: engine.nextId(),
enemyClass: 'reaper_feeder',
cpu: 0,
mem: 0,
maxMem: 0,
sec: randInt(
GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),
GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
),
mods: [
new RulesetReaper.cardMods.reaper_feederPower().serialize(),
],
scripts: [],
};
},
reaper_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_lesser_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak', 1).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_boss',
cpu: 0,
mem: 0,
maxMem: 0,
sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content._winOnDeath().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
boss.scripts.push(
new RulesetReaper.cardScripts.reaper_bossEat(boss).serialize(),
);
|
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
|
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
},
};
|
src/game/rulesets/reaper.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " scripts: [],\n };\n boss.mods.push(\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content._waveTrigger(['reaper', 'goliath', 'stasis', 'stasis'], 12).serialize(),\n new CardMod.Content._yieldScript(new CardScript.Content._spawn(boss, RulesetMfrm.enemyCards.intro_perimeter.name, undefined, undefined, 2).serialize(), 2).serialize(),\n );\n boss.scripts.push(\n new CardScript.Content._defend(boss, engine.gameData.difficulty).serialize(),\n );",
"score": 0.9480718970298767
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " ],\n scripts: [],\n };\n boss.scripts.push(\n new CardScript.Content._attack(boss, engine.gameData.difficulty, 'strong').serialize(),\n new RulesetStasis.cardScripts.stasis_disrupt(boss, engine.gameData.difficulty).serialize(),\n );\n engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);",
"score": 0.9178440570831299
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new CardScript.Content._defend(enemy, engine.gameData.difficulty).serialize(),",
"score": 0.9129506349563599
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " scripts: [],\n };\n boss.scripts.push(\n new CardScript.Content._attack(boss, engine.gameData.difficulty).serialize(),\n );\n engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);\n GameEngineUtils.addEnemy(engine, boss, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);",
"score": 0.9089869856834412
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " new CardMod.Content._standardAi().serialize(),\n ],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new RulesetStasis.cardScripts.stasis_disrupt(enemy, engine.gameData.difficulty).serialize(),\n );\n return enemy;\n },",
"score": 0.901240348815918
}
] |
typescript
|
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
|
import { randInt } from '../../utils';
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetReaper = {
cardMods: {
reaper_feederCorrupted: class extends CardMod {
},
reaper_feederPower: class extends CardMod {
override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {
if (deps.sourceCard.sec - damage > 0) return;
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);
CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);
const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);
player && player.stats.kills++;
return { secDmgBonus: -9999 };
}
},
},
cardScripts: {
reaper_bossEat: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, _card) => {
return gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_feeder.name);
},
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, source, target) => {
GameEngineUtils.removeCard(engine, target, source);
if (target.mods.find(x => x[0] === RulesetReaper.cardMods.reaper_feederCorrupted.name)) {
GameEngineUtils.changeSec(engine, source, -50, false);
if (source.sec <= 0) {
GameEngineUtils.removeCard(engine, source);
return;
}
} else {
GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);
GameEngineUtils.changeCpu(engine, source, 1);
for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {
CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));
}
}
const highDiff = engine.gameData.difficulty >= 7;
if (engine.gameData.enemies.length <= (highDiff ? 6 : 4)) {
while (engine.gameData.enemies.findIndex(x => x.id === source.id) < (highDiff ? 4 : 3)) {
|
CardScriptParts.SpawnEnemy('reaper_feeder', 'absLeft')(engine, source, target);
|
}
while (engine.gameData.enemies.length < (highDiff ? 9 : 7)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absRight')(engine, source, target);
}
}
},
],
}
],
);
}
},
},
enemyCards: {
reaper_feeder: (engine: GameEngine.IGameEngine): GameEngine.IEnemyCardState => {
return {
id: engine.nextId(),
enemyClass: 'reaper_feeder',
cpu: 0,
mem: 0,
maxMem: 0,
sec: randInt(
GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),
GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
),
mods: [
new RulesetReaper.cardMods.reaper_feederPower().serialize(),
],
scripts: [],
};
},
reaper_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_lesser_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak', 1).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_boss',
cpu: 0,
mem: 0,
maxMem: 0,
sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content._winOnDeath().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
boss.scripts.push(
new RulesetReaper.cardScripts.reaper_bossEat(boss).serialize(),
);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
},
};
|
src/game/rulesets/reaper.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (deps.sourceCard.mem - memDmg <= 0) return;\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n let secBonus = 100;\n const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);\n if (shieldBuff) {\n secBonus += CardMod.getStackCount(shieldBuff) * 100;\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);\n for (const enemy of [...deps.engine.gameData.enemies]) {\n if (enemy === boss) continue;",
"score": 0.8830349445343018
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n (engine, _sourceCard, targetCard) => {\n const totalStats = targetCard.cpu + targetCard.mem;\n const newCpu = randInt(1, totalStats - 1);\n const cpuDelta = newCpu - targetCard.cpu;\n GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);\n const newMem = totalStats - newCpu;\n const memDelta = newMem - targetCard.mem;\n GameEngineUtils.changeMem(engine, targetCard, memDelta);\n },",
"score": 0.8818768262863159
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {\n CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);\n if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {\n GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n }\n }\n },\n },",
"score": 0.8802785873413086
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new CardScript.Content._defend(enemy, engine.gameData.difficulty).serialize(),",
"score": 0.8749365210533142
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " (engine, _sourceCard, targetCard) => {\n if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;\n const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);\n if (script.targetFinder === CardScript.TargetFinders.Self) return;\n const targets = script.targetFinder(engine.gameData, targetCard);\n if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;\n const origTargetId = targetCard.intent.targetCardId;\n while (targetCard.intent.targetCardId === origTargetId) {\n targetCard.intent.targetCardId = targets.random().id;\n }",
"score": 0.8745943307876587
}
] |
typescript
|
CardScriptParts.SpawnEnemy('reaper_feeder', 'absLeft')(engine, source, target);
|
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetStasis = {
cardMods: {
stasis_boss_ai: class extends CardMod.Content._standardAi {
override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {
if (deps.sourceCard.mem - memDmg <= 0) return;
for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {
CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);
}
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);
if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {
GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
}
}
},
},
enemyCards: {
stasis_disruptor: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 3,
maxMem: 3,
sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
new RulesetStasis.cardScripts.stasis_disrupt(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
stasis_shocker: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
},
cardScripts: {
stasis_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState, difficulty: number) {
const
|
dmg = GameEngineUtils.scaleByDifficulty(GameEngineUtils.scaleByCpuMem(5, card.cpu), difficulty);
|
super(
[difficulty, dmg],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(dmg),
CardScriptParts.AddMod(new CardMod.Content.lag(2)),
],
}
],
);
}
}
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'stasis_boss',
cpu: 3,
mem: 3,
maxMem: 3,
sec: GameEngineUtils.scaleByDifficulty(125, engine.gameData.difficulty),
mods: [
new RulesetStasis.cardMods.stasis_boss_ai().serialize(),
new CardMod.Content._winOnDeath().serialize(),
],
scripts: [],
};
boss.scripts.push(
new CardScript.Content._attack(boss, engine.gameData.difficulty, 'strong').serialize(),
new RulesetStasis.cardScripts.stasis_disrupt(boss, engine.gameData.difficulty).serialize(),
);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
},
};
|
src/game/rulesets/stasis.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },\n goliath_shield_node: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),",
"score": 0.8842244148254395
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " maxMem: 1,\n sec: GameEngineUtils.scaleByDifficulty(30, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },",
"score": 0.8837835788726807
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak', 1).serialize(),\n );\n return enemy;\n },\n },\n initGame(engine: GameEngine.IGameEngine) {\n const boss: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n enemyClass: 'reaper_boss',\n cpu: 0,",
"score": 0.8817667961120605
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n );\n return enemy;\n },\n reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n enemyClass: 'reaper_lesser_guardian',\n cpu: 2,",
"score": 0.8809638023376465
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new CardScript.Content._defend(enemy, engine.gameData.difficulty).serialize(),",
"score": 0.8777352571487427
}
] |
typescript
|
dmg = GameEngineUtils.scaleByDifficulty(GameEngineUtils.scaleByCpuMem(5, card.cpu), difficulty);
|
import { randInt } from '../../utils';
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetReaper = {
cardMods: {
reaper_feederCorrupted: class extends CardMod {
},
reaper_feederPower: class extends CardMod {
override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {
if (deps.sourceCard.sec - damage > 0) return;
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);
CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);
const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);
player && player.stats.kills++;
return { secDmgBonus: -9999 };
}
},
},
cardScripts: {
reaper_bossEat: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, _card) => {
return gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_feeder.name);
},
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, source, target) => {
GameEngineUtils.removeCard(engine, target, source);
if (target.mods.find(x => x[0] === RulesetReaper.cardMods.reaper_feederCorrupted.name)) {
GameEngineUtils.changeSec(engine, source, -50, false);
if (source.sec <= 0) {
GameEngineUtils.removeCard(engine, source);
return;
}
} else {
GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);
GameEngineUtils.changeCpu(engine, source, 1);
for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {
CardMod.addMod(engine, guardian
|
, new GameContent_v1.cardMods.optimized(1, -1));
|
}
}
const highDiff = engine.gameData.difficulty >= 7;
if (engine.gameData.enemies.length <= (highDiff ? 6 : 4)) {
while (engine.gameData.enemies.findIndex(x => x.id === source.id) < (highDiff ? 4 : 3)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absLeft')(engine, source, target);
}
while (engine.gameData.enemies.length < (highDiff ? 9 : 7)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absRight')(engine, source, target);
}
}
},
],
}
],
);
}
},
},
enemyCards: {
reaper_feeder: (engine: GameEngine.IGameEngine): GameEngine.IEnemyCardState => {
return {
id: engine.nextId(),
enemyClass: 'reaper_feeder',
cpu: 0,
mem: 0,
maxMem: 0,
sec: randInt(
GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),
GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
),
mods: [
new RulesetReaper.cardMods.reaper_feederPower().serialize(),
],
scripts: [],
};
},
reaper_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_lesser_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak', 1).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_boss',
cpu: 0,
mem: 0,
maxMem: 0,
sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content._winOnDeath().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
boss.scripts.push(
new RulesetReaper.cardScripts.reaper_bossEat(boss).serialize(),
);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
},
};
|
src/game/rulesets/reaper.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (deps.sourceCard.mem - memDmg <= 0) return;\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n let secBonus = 100;\n const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);\n if (shieldBuff) {\n secBonus += CardMod.getStackCount(shieldBuff) * 100;\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);\n for (const enemy of [...deps.engine.gameData.enemies]) {\n if (enemy === boss) continue;",
"score": 0.8849524259567261
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n (engine, _sourceCard, targetCard) => {\n const totalStats = targetCard.cpu + targetCard.mem;\n const newCpu = randInt(1, totalStats - 1);\n const cpuDelta = newCpu - targetCard.cpu;\n GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);\n const newMem = totalStats - newCpu;\n const memDelta = newMem - targetCard.mem;\n GameEngineUtils.changeMem(engine, targetCard, memDelta);\n },",
"score": 0.8756663799285889
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)\n .reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);\n }\n if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {\n return false;\n }\n resolvedDamage = Math.max(0, resolvedDamage);\n const secExceeded = resolvedDamage > targetCard.sec;\n GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);\n return secExceeded;",
"score": 0.8746683597564697
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {\n CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);\n if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {\n GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n }\n }\n },\n },",
"score": 0.8720322847366333
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " (engine, _sourceCard, targetCard) => {\n if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;\n const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);\n if (script.targetFinder === CardScript.TargetFinders.Self) return;\n const targets = script.targetFinder(engine.gameData, targetCard);\n if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;\n const origTargetId = targetCard.intent.targetCardId;\n while (targetCard.intent.targetCardId === origTargetId) {\n targetCard.intent.targetCardId = targets.random().id;\n }",
"score": 0.8655692338943481
}
] |
typescript
|
, new GameContent_v1.cardMods.optimized(1, -1));
|
import * as moment from 'moment';
import { createCoopHandler } from './apis/coop.api';
import { IAuthProvider, IDataSource, IPlayerPushProvider, IRateLimitProvider } from './dependencies';
import { CardMod } from './game/card-mods';
import { CardScript } from './game/card-scripts';
import { GameEngine, createGameEngineProvider } from './game/game-engine';
import { GameEngineUtils } from './game/game-engine-utils';
import { IHttpRequest, IHttpRouteHandler, StatusCodes } from './net-utils';
import { FULL_DATETIME_FORMAT } from './utils';
/**
* Main entry point
*/
// TODO: this should be replaced with node:http or expressjs
export const handleRequest = async (req: IHttpRequest) => {
const split = req.path.split('/').filter(Boolean);
const subPath = split.slice(1);
const body = req.body ? JSON.parse(req.body) : null;
const query = req.queryStringParameters || {};
let handler: IHttpRouteHandler | undefined = undefined;
switch (split[0]) {
case 'coop':
handler = coopHandler;
// ... Note: implement remaining route handlers
}
const result = handler ? (await handler(subPath, query, body, req)) : null;
return result || [StatusCodes.badRequest, { reason: 'invalid api' }];
};
/**
* Dependencies
*/
// Note: replace with an actual database
const cardDecksTable = createMockTableDualKey<IDataSource.ICardDeck>('playerId', 'createdAt');
const coopGamesTable = createMockTableSingleKey<IDataSource.ICoopGame>('id');
const playersTable = createMockTableSingleKey<IDataSource.IPlayer>('id');
const playerCoopGamesTable = createMockTableSingleKey<IDataSource.IPlayerCoopGame>('playerId');
const dataSource: IDataSource = {
CardDecks: {
...cardDecksTable,
async queryByDid(did) {
return { items: [...cardDecksTable._db.values()].filter(x => x.playerId === did) };
},
},
CoopGames: {
...coopGamesTable,
async queryByGameState(gameState) {
return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };
},
},
GameData: {
...createMockTableSingleKey<GameEngine.IGameData>('id'),
},
Players: {
...playersTable,
},
PlayerCoopGames: {
...playerCoopGamesTable,
async queryByPlayerId(playerId: string) {
return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };
},
},
Leaderboard: {
getTopN(_n) { return [] as any; },
async set(_playerId, _score) { },
},
async execUpdates(...updateRequests) {
updateRequests.forEach(x => x());
},
};
// Note: replace with an actual auth provider
const authProvider: IAuthProvider = {
generateNewSecret: () => `${Math.random()}`,
getAuthTokenForPlayer: player => player.secret,
getPlayerFromRequest: async () => [...playersTable._db.values()][0]!,
getPlayerIdFromRequest: () => [...playersTable._db.values()][0]?.id!,
};
// Note: replace with an actual push provider
const pushProvider: IPlayerPushProvider = {
async push(playerId, messages) {
console.log(`Push messages for player [${playerId}]:`);
messages.forEach(x => console.log(x));
}
};
const rateLimitProvider: IRateLimitProvider = {
async shouldRateLimitCreateGame(_playerId) {
return false;
},
async shouldRateLimitSearchGame(_playerId) {
return false;
},
};
// Note: replace with custom game content
const gameContent: GameEngine.IRuleset = {
cardMods: { /** Custom card modifiers **/ },
cardScripts: { /** Custom card scripts **/ },
initGame(engine) {
const testEnemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'testEnemy',
cpu: 1,
mem: 1,
maxMem: 1,
mods: [],
scripts: [],
sec: 10,
};
testEnemy.mods.push(new CardMod.Content._standardAi().serialize());
testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());
GameEngineUtils.addEnemy(engine, testEnemy, 0, true);
},
addAdditionalScriptsFor(_card) {
// Note: Called by GameEngine when a player is joined; this hook allows for dynamic scripts for a given card
},
};
|
const gameEngine = createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
|
const coopHandler = createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider);
/**
* Example
*/
(async () => {
/**
* Players are normally created via /players/connectDid; to keep this example concise,
* we'll inject one with CO8's DID into the mock database.
*/
const mockPlayer = {
id: 'did:chia:1sc5hxvcs26e4zsc7uvlfuc7x9sjj5aw6cu0g8vcyvscy49ffp8zqwh63tq',
activeDeckId: '',
activeGameId: '',
secret: '',
authExpiresAt: '2100-01-01',
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),
score: 0,
}
playersTable._db.set(mockPlayer.id, mockPlayer);
/**
* This calls into /coop/create which is a complex API.
* Step thru this to learn about how the route handlers work.
*/
console.log('Creating game...');
await handleRequest({
httpMethod: 'POST',
path: '/coop/create',
body: JSON.stringify({
gameVisibility: 'private',
difficulty: 1,
}),
});
console.log('Game created, gameId: ' + mockPlayer.activeGameId);
/**
* Games normally start automatically when enough players join via /coop/join or /coop/search,
* to keep this example concise, we'll start it directly via the gameEngine reference.
* Step thru this to learn about how the game engine works.
*/
console.log('Starting game...');
await gameEngine.startGame(mockPlayer.activeGameId);
})();
/**
* In-memory DB helpers
* Note: this is a mock database that only satisfies the example above and is
* not meant to be starting point for production.
*/
function createMockTableSingleKey<T extends Record<string, any>>(idKey: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id: string) {
return _db.get(id) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(item[idKey], item);
return item;
},
},
};
}
function createMockTableDualKey<T extends Record<string, any>>(id1Key: keyof T, id2Key: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id1: string, id2: string) {
return _db.get(`${id1}_${id2}`) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(`${item[id1Key]}_${item[id2Key]}`, item);
return item;
},
},
};
}
|
src/reference-example.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new CardScript.Content._defend(enemy, engine.gameData.difficulty).serialize(),",
"score": 0.9127936363220215
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " ],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n );\n return enemy;\n },\n },\n cardScripts: {",
"score": 0.912470281124115
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " maxMem: 1,\n sec: GameEngineUtils.scaleByDifficulty(30, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },",
"score": 0.909450888633728
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " scripts: [],\n };\n boss.mods.push(\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content._waveTrigger(['reaper', 'goliath', 'stasis', 'stasis'], 12).serialize(),\n new CardMod.Content._yieldScript(new CardScript.Content._spawn(boss, RulesetMfrm.enemyCards.intro_perimeter.name, undefined, undefined, 2).serialize(), 2).serialize(),\n );\n boss.scripts.push(\n new CardScript.Content._defend(boss, engine.gameData.difficulty).serialize(),\n );",
"score": 0.8966649770736694
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " new CardMod.Content._standardAi().serialize(),\n ],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new RulesetStasis.cardScripts.stasis_disrupt(enemy, engine.gameData.difficulty).serialize(),\n );\n return enemy;\n },",
"score": 0.8937896490097046
}
] |
typescript
|
const gameEngine = createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
|
import * as moment from 'moment';
import { createCoopHandler } from './apis/coop.api';
import { IAuthProvider, IDataSource, IPlayerPushProvider, IRateLimitProvider } from './dependencies';
import { CardMod } from './game/card-mods';
import { CardScript } from './game/card-scripts';
import { GameEngine, createGameEngineProvider } from './game/game-engine';
import { GameEngineUtils } from './game/game-engine-utils';
import { IHttpRequest, IHttpRouteHandler, StatusCodes } from './net-utils';
import { FULL_DATETIME_FORMAT } from './utils';
/**
* Main entry point
*/
// TODO: this should be replaced with node:http or expressjs
export const handleRequest = async (req: IHttpRequest) => {
const split = req.path.split('/').filter(Boolean);
const subPath = split.slice(1);
const body = req.body ? JSON.parse(req.body) : null;
const query = req.queryStringParameters || {};
let handler: IHttpRouteHandler | undefined = undefined;
switch (split[0]) {
case 'coop':
handler = coopHandler;
// ... Note: implement remaining route handlers
}
const result = handler ? (await handler(subPath, query, body, req)) : null;
return result || [StatusCodes.badRequest, { reason: 'invalid api' }];
};
/**
* Dependencies
*/
// Note: replace with an actual database
const cardDecksTable = createMockTableDualKey<IDataSource.ICardDeck>('playerId', 'createdAt');
const coopGamesTable = createMockTableSingleKey<IDataSource.ICoopGame>('id');
const playersTable = createMockTableSingleKey<IDataSource.IPlayer>('id');
const playerCoopGamesTable = createMockTableSingleKey<IDataSource.IPlayerCoopGame>('playerId');
const dataSource: IDataSource = {
CardDecks: {
...cardDecksTable,
async queryByDid(did) {
return { items: [...cardDecksTable._db.values()].filter(x => x.playerId === did) };
},
},
CoopGames: {
...coopGamesTable,
async queryByGameState(gameState) {
return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };
},
},
GameData: {
...createMockTableSingleKey<GameEngine.IGameData>('id'),
},
Players: {
...playersTable,
},
PlayerCoopGames: {
...playerCoopGamesTable,
async queryByPlayerId(playerId: string) {
return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };
},
},
Leaderboard: {
getTopN(_n) { return [] as any; },
async set(_playerId, _score) { },
},
async execUpdates(...updateRequests) {
updateRequests.forEach(x => x());
},
};
// Note: replace with an actual auth provider
const authProvider: IAuthProvider = {
generateNewSecret: () => `${Math.random()}`,
getAuthTokenForPlayer: player => player.secret,
getPlayerFromRequest: async () => [...playersTable._db.values()][0]!,
getPlayerIdFromRequest: () => [...playersTable._db.values()][0]?.id!,
};
// Note: replace with an actual push provider
const pushProvider: IPlayerPushProvider = {
async push(playerId, messages) {
console.log(`Push messages for player [${playerId}]:`);
messages.forEach(x => console.log(x));
}
};
const rateLimitProvider: IRateLimitProvider = {
async shouldRateLimitCreateGame(_playerId) {
return false;
},
async shouldRateLimitSearchGame(_playerId) {
return false;
},
};
// Note: replace with custom game content
const gameContent: GameEngine.IRuleset = {
cardMods: { /** Custom card modifiers **/ },
cardScripts: { /** Custom card scripts **/ },
|
initGame(engine) {
|
const testEnemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'testEnemy',
cpu: 1,
mem: 1,
maxMem: 1,
mods: [],
scripts: [],
sec: 10,
};
testEnemy.mods.push(new CardMod.Content._standardAi().serialize());
testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());
GameEngineUtils.addEnemy(engine, testEnemy, 0, true);
},
addAdditionalScriptsFor(_card) {
// Note: Called by GameEngine when a player is joined; this hook allows for dynamic scripts for a given card
},
};
const gameEngine = createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
const coopHandler = createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider);
/**
* Example
*/
(async () => {
/**
* Players are normally created via /players/connectDid; to keep this example concise,
* we'll inject one with CO8's DID into the mock database.
*/
const mockPlayer = {
id: 'did:chia:1sc5hxvcs26e4zsc7uvlfuc7x9sjj5aw6cu0g8vcyvscy49ffp8zqwh63tq',
activeDeckId: '',
activeGameId: '',
secret: '',
authExpiresAt: '2100-01-01',
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),
score: 0,
}
playersTable._db.set(mockPlayer.id, mockPlayer);
/**
* This calls into /coop/create which is a complex API.
* Step thru this to learn about how the route handlers work.
*/
console.log('Creating game...');
await handleRequest({
httpMethod: 'POST',
path: '/coop/create',
body: JSON.stringify({
gameVisibility: 'private',
difficulty: 1,
}),
});
console.log('Game created, gameId: ' + mockPlayer.activeGameId);
/**
* Games normally start automatically when enough players join via /coop/join or /coop/search,
* to keep this example concise, we'll start it directly via the gameEngine reference.
* Step thru this to learn about how the game engine works.
*/
console.log('Starting game...');
await gameEngine.startGame(mockPlayer.activeGameId);
})();
/**
* In-memory DB helpers
* Note: this is a mock database that only satisfies the example above and is
* not meant to be starting point for production.
*/
function createMockTableSingleKey<T extends Record<string, any>>(idKey: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id: string) {
return _db.get(id) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(item[idKey], item);
return item;
},
},
};
}
function createMockTableDualKey<T extends Record<string, any>>(id1Key: keyof T, id2Key: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id1: string, id2: string) {
return _db.get(`${id1}_${id2}`) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(`${item[id1Key]}_${item[id2Key]}`, item);
return item;
},
},
};
}
|
src/reference-example.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " ) {\n super();\n this.message = `${this.constructor.name} processing game ${gameId}`;\n }\n }\n export class GameNotFoundError extends GameEngineError { }\n export interface IRulesetContent {\n cardMods?: CardMod.ModLibrary;\n cardScripts?: CardScript.ScriptLibrary;\n enemyCards?: Record<string, (engine: IGameEngine) => IEnemyCardState>;",
"score": 0.8640891313552856
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " },\n initGame(engine: GameEngine.IGameEngine) {\n const boss: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n enemyClass: 'intro_boss',\n cpu: 3,\n mem: 3,\n maxMem: 3,\n sec: GameEngineUtils.scaleByDifficulty(125, engine.gameData.difficulty),\n mods: [],",
"score": 0.8575446605682373
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " mem: 0,\n maxMem: 0,\n sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content._winOnDeath().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };",
"score": 0.8570886850357056
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8539922833442688
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " mods: [\n new RulesetReaper.cardMods.reaper_feederPower().serialize(),\n ],\n scripts: [],\n };\n },\n reaper_guardian: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n enemyClass: 'reaper_guardian',",
"score": 0.8512186408042908
}
] |
typescript
|
initGame(engine) {
|
import * as moment from 'moment';
import { createCoopHandler } from './apis/coop.api';
import { IAuthProvider, IDataSource, IPlayerPushProvider, IRateLimitProvider } from './dependencies';
import { CardMod } from './game/card-mods';
import { CardScript } from './game/card-scripts';
import { GameEngine, createGameEngineProvider } from './game/game-engine';
import { GameEngineUtils } from './game/game-engine-utils';
import { IHttpRequest, IHttpRouteHandler, StatusCodes } from './net-utils';
import { FULL_DATETIME_FORMAT } from './utils';
/**
* Main entry point
*/
// TODO: this should be replaced with node:http or expressjs
export const handleRequest = async (req: IHttpRequest) => {
const split = req.path.split('/').filter(Boolean);
const subPath = split.slice(1);
const body = req.body ? JSON.parse(req.body) : null;
const query = req.queryStringParameters || {};
let handler: IHttpRouteHandler | undefined = undefined;
switch (split[0]) {
case 'coop':
handler = coopHandler;
// ... Note: implement remaining route handlers
}
const result = handler ? (await handler(subPath, query, body, req)) : null;
return result || [StatusCodes.badRequest, { reason: 'invalid api' }];
};
/**
* Dependencies
*/
// Note: replace with an actual database
const cardDecksTable = createMockTableDualKey<IDataSource.ICardDeck>('playerId', 'createdAt');
const coopGamesTable = createMockTableSingleKey<IDataSource.ICoopGame>('id');
const playersTable = createMockTableSingleKey<IDataSource.IPlayer>('id');
const playerCoopGamesTable = createMockTableSingleKey<IDataSource.IPlayerCoopGame>('playerId');
const dataSource: IDataSource = {
CardDecks: {
...cardDecksTable,
async queryByDid(did) {
return { items: [...cardDecksTable._db.values()].filter(x => x.playerId === did) };
},
},
CoopGames: {
...coopGamesTable,
async queryByGameState
|
(gameState) {
|
return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };
},
},
GameData: {
...createMockTableSingleKey<GameEngine.IGameData>('id'),
},
Players: {
...playersTable,
},
PlayerCoopGames: {
...playerCoopGamesTable,
async queryByPlayerId(playerId: string) {
return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };
},
},
Leaderboard: {
getTopN(_n) { return [] as any; },
async set(_playerId, _score) { },
},
async execUpdates(...updateRequests) {
updateRequests.forEach(x => x());
},
};
// Note: replace with an actual auth provider
const authProvider: IAuthProvider = {
generateNewSecret: () => `${Math.random()}`,
getAuthTokenForPlayer: player => player.secret,
getPlayerFromRequest: async () => [...playersTable._db.values()][0]!,
getPlayerIdFromRequest: () => [...playersTable._db.values()][0]?.id!,
};
// Note: replace with an actual push provider
const pushProvider: IPlayerPushProvider = {
async push(playerId, messages) {
console.log(`Push messages for player [${playerId}]:`);
messages.forEach(x => console.log(x));
}
};
const rateLimitProvider: IRateLimitProvider = {
async shouldRateLimitCreateGame(_playerId) {
return false;
},
async shouldRateLimitSearchGame(_playerId) {
return false;
},
};
// Note: replace with custom game content
const gameContent: GameEngine.IRuleset = {
cardMods: { /** Custom card modifiers **/ },
cardScripts: { /** Custom card scripts **/ },
initGame(engine) {
const testEnemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'testEnemy',
cpu: 1,
mem: 1,
maxMem: 1,
mods: [],
scripts: [],
sec: 10,
};
testEnemy.mods.push(new CardMod.Content._standardAi().serialize());
testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());
GameEngineUtils.addEnemy(engine, testEnemy, 0, true);
},
addAdditionalScriptsFor(_card) {
// Note: Called by GameEngine when a player is joined; this hook allows for dynamic scripts for a given card
},
};
const gameEngine = createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
const coopHandler = createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider);
/**
* Example
*/
(async () => {
/**
* Players are normally created via /players/connectDid; to keep this example concise,
* we'll inject one with CO8's DID into the mock database.
*/
const mockPlayer = {
id: 'did:chia:1sc5hxvcs26e4zsc7uvlfuc7x9sjj5aw6cu0g8vcyvscy49ffp8zqwh63tq',
activeDeckId: '',
activeGameId: '',
secret: '',
authExpiresAt: '2100-01-01',
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),
score: 0,
}
playersTable._db.set(mockPlayer.id, mockPlayer);
/**
* This calls into /coop/create which is a complex API.
* Step thru this to learn about how the route handlers work.
*/
console.log('Creating game...');
await handleRequest({
httpMethod: 'POST',
path: '/coop/create',
body: JSON.stringify({
gameVisibility: 'private',
difficulty: 1,
}),
});
console.log('Game created, gameId: ' + mockPlayer.activeGameId);
/**
* Games normally start automatically when enough players join via /coop/join or /coop/search,
* to keep this example concise, we'll start it directly via the gameEngine reference.
* Step thru this to learn about how the game engine works.
*/
console.log('Starting game...');
await gameEngine.startGame(mockPlayer.activeGameId);
})();
/**
* In-memory DB helpers
* Note: this is a mock database that only satisfies the example above and is
* not meant to be starting point for production.
*/
function createMockTableSingleKey<T extends Record<string, any>>(idKey: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id: string) {
return _db.get(id) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(item[idKey], item);
return item;
},
},
};
}
function createMockTableDualKey<T extends Record<string, any>>(id1Key: keyof T, id2Key: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id1: string, id2: string) {
return _db.get(`${id1}_${id2}`) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(`${item[id1Key]}_${item[id2Key]}`, item);
return item;
},
},
};
}
|
src/reference-example.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " cards: { nftId: string, mintHeight: number, url: string }[];\n label: string;\n }\n export type CardDecks = {\n get: GetterPair<ICardDeck>;\n update: Updater<ICardDeck>;\n queryByDid: Query<ICardDeck['playerId'], ICardDeck>;\n };\n export interface ICoopGame {\n id: string;",
"score": 0.8454203605651855
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const gameData = await ds.GameData.get(gameId);\n if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n return gameData;\n }\n private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {\n const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))\n .filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)\n .map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));\n if (cards.length !== cardIds.length) {\n throw `could not resolve all cards for player ${playerId}`;",
"score": 0.8416693210601807
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " playerId: player.id,\n createdAt: nowStr,\n cards: cards.map(x => ({ nftId: x.nftId, mintHeight: x.firstBlock, url: x.urls[0] || '' })),\n label: 'default',\n };\n await ds.execUpdates(\n ds.Players.update.make(player, true),\n ds.CardDecks.update.make(deck, true),\n );\n return deck;",
"score": 0.8255683183670044
},
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " export type PlayerCoopGame = {\n update: Updater<IPlayerCoopGame>;\n queryByPlayerId: Query<string, IPlayerCoopGame>;\n }\n export type GameData = {\n get: GetterSingle<GameEngine.IGameData>;\n update: Updater<GameEngine.IGameData>;\n };\n export type Leaderboard = {\n getTopN(n: number): Promise<[string, number][]>;",
"score": 0.8244418501853943
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];\n }\n case 'list': {\n const schema = z.object({\n ct: z.string().optional(),\n });\n const q = schema.parse(query);\n const player = await authProvider.getPlayerFromRequest(req);\n const decks = await Promise.all((await ds.CardDecks.queryByDid(player.id, 10, q.ct)).items);\n if (!decks.length) {",
"score": 0.8244165182113647
}
] |
typescript
|
(gameState) {
|
import * as moment from 'moment';
import { createCoopHandler } from './apis/coop.api';
import { IAuthProvider, IDataSource, IPlayerPushProvider, IRateLimitProvider } from './dependencies';
import { CardMod } from './game/card-mods';
import { CardScript } from './game/card-scripts';
import { GameEngine, createGameEngineProvider } from './game/game-engine';
import { GameEngineUtils } from './game/game-engine-utils';
import { IHttpRequest, IHttpRouteHandler, StatusCodes } from './net-utils';
import { FULL_DATETIME_FORMAT } from './utils';
/**
* Main entry point
*/
// TODO: this should be replaced with node:http or expressjs
export const handleRequest = async (req: IHttpRequest) => {
const split = req.path.split('/').filter(Boolean);
const subPath = split.slice(1);
const body = req.body ? JSON.parse(req.body) : null;
const query = req.queryStringParameters || {};
let handler: IHttpRouteHandler | undefined = undefined;
switch (split[0]) {
case 'coop':
handler = coopHandler;
// ... Note: implement remaining route handlers
}
const result = handler ? (await handler(subPath, query, body, req)) : null;
return result || [StatusCodes.badRequest, { reason: 'invalid api' }];
};
/**
* Dependencies
*/
// Note: replace with an actual database
const cardDecksTable = createMockTableDualKey<IDataSource.ICardDeck>('playerId', 'createdAt');
const coopGamesTable = createMockTableSingleKey<IDataSource.ICoopGame>('id');
const playersTable = createMockTableSingleKey<IDataSource.IPlayer>('id');
const playerCoopGamesTable = createMockTableSingleKey<IDataSource.IPlayerCoopGame>('playerId');
const dataSource: IDataSource = {
CardDecks: {
...cardDecksTable,
async queryByDid(did) {
return { items: [...cardDecksTable._db.values()].filter(x => x.playerId === did) };
},
},
CoopGames: {
...coopGamesTable,
async queryByGameState(gameState) {
return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };
},
},
GameData: {
...createMockTableSingleKey
|
<GameEngine.IGameData>('id'),
},
Players: {
|
...playersTable,
},
PlayerCoopGames: {
...playerCoopGamesTable,
async queryByPlayerId(playerId: string) {
return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };
},
},
Leaderboard: {
getTopN(_n) { return [] as any; },
async set(_playerId, _score) { },
},
async execUpdates(...updateRequests) {
updateRequests.forEach(x => x());
},
};
// Note: replace with an actual auth provider
const authProvider: IAuthProvider = {
generateNewSecret: () => `${Math.random()}`,
getAuthTokenForPlayer: player => player.secret,
getPlayerFromRequest: async () => [...playersTable._db.values()][0]!,
getPlayerIdFromRequest: () => [...playersTable._db.values()][0]?.id!,
};
// Note: replace with an actual push provider
const pushProvider: IPlayerPushProvider = {
async push(playerId, messages) {
console.log(`Push messages for player [${playerId}]:`);
messages.forEach(x => console.log(x));
}
};
const rateLimitProvider: IRateLimitProvider = {
async shouldRateLimitCreateGame(_playerId) {
return false;
},
async shouldRateLimitSearchGame(_playerId) {
return false;
},
};
// Note: replace with custom game content
const gameContent: GameEngine.IRuleset = {
cardMods: { /** Custom card modifiers **/ },
cardScripts: { /** Custom card scripts **/ },
initGame(engine) {
const testEnemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'testEnemy',
cpu: 1,
mem: 1,
maxMem: 1,
mods: [],
scripts: [],
sec: 10,
};
testEnemy.mods.push(new CardMod.Content._standardAi().serialize());
testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());
GameEngineUtils.addEnemy(engine, testEnemy, 0, true);
},
addAdditionalScriptsFor(_card) {
// Note: Called by GameEngine when a player is joined; this hook allows for dynamic scripts for a given card
},
};
const gameEngine = createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
const coopHandler = createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider);
/**
* Example
*/
(async () => {
/**
* Players are normally created via /players/connectDid; to keep this example concise,
* we'll inject one with CO8's DID into the mock database.
*/
const mockPlayer = {
id: 'did:chia:1sc5hxvcs26e4zsc7uvlfuc7x9sjj5aw6cu0g8vcyvscy49ffp8zqwh63tq',
activeDeckId: '',
activeGameId: '',
secret: '',
authExpiresAt: '2100-01-01',
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),
score: 0,
}
playersTable._db.set(mockPlayer.id, mockPlayer);
/**
* This calls into /coop/create which is a complex API.
* Step thru this to learn about how the route handlers work.
*/
console.log('Creating game...');
await handleRequest({
httpMethod: 'POST',
path: '/coop/create',
body: JSON.stringify({
gameVisibility: 'private',
difficulty: 1,
}),
});
console.log('Game created, gameId: ' + mockPlayer.activeGameId);
/**
* Games normally start automatically when enough players join via /coop/join or /coop/search,
* to keep this example concise, we'll start it directly via the gameEngine reference.
* Step thru this to learn about how the game engine works.
*/
console.log('Starting game...');
await gameEngine.startGame(mockPlayer.activeGameId);
})();
/**
* In-memory DB helpers
* Note: this is a mock database that only satisfies the example above and is
* not meant to be starting point for production.
*/
function createMockTableSingleKey<T extends Record<string, any>>(idKey: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id: string) {
return _db.get(id) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(item[idKey], item);
return item;
},
},
};
}
function createMockTableDualKey<T extends Record<string, any>>(id1Key: keyof T, id2Key: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id1: string, id2: string) {
return _db.get(`${id1}_${id2}`) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(`${item[id1Key]}_${item[id2Key]}`, item);
return item;
},
},
};
}
|
src/reference-example.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " export type PlayerCoopGame = {\n update: Updater<IPlayerCoopGame>;\n queryByPlayerId: Query<string, IPlayerCoopGame>;\n }\n export type GameData = {\n get: GetterSingle<GameEngine.IGameData>;\n update: Updater<GameEngine.IGameData>;\n };\n export type Leaderboard = {\n getTopN(n: number): Promise<[string, number][]>;",
"score": 0.869087815284729
},
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " export type CoopGames = {\n get: GetterSingle<ICoopGame>;\n update: Updater<ICoopGame>;\n queryByGameState: Query<ICoopGame['gameState'], ICoopGame>;\n };\n export interface IPlayer {\n id: string;\n createdAt: string;\n lastSeenAt: string;\n secret: string;",
"score": 0.8669900298118591
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const existingGameData = await ds.GameData.get(gameId);\n if (existingGameData) throw new Error('game with id already exists: ' + gameId);\n const gameData: GameEngine.IGameData = {\n id: gameId,\n difficulty: Math.max(1, difficulty),\n state: 'created',\n turn: 1,\n players: new Map(),\n defaultMovesPerTurn: 3,\n enemies: [],",
"score": 0.8416032195091248
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const gameData = await ds.GameData.get(gameId);\n if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n return gameData;\n }\n private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {\n const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))\n .filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)\n .map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));\n if (cards.length !== cardIds.length) {\n throw `could not resolve all cards for player ${playerId}`;",
"score": 0.8365529179573059
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];\n }\n case 'history': {\n const playerId = authProvider.getPlayerIdFromRequest(req);\n const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);\n return [StatusCodes.ok, games];\n }\n case 'join': {\n const schema = z.object({\n teammateDid: z.string().nonempty(),",
"score": 0.8329814076423645
}
] |
typescript
|
<GameEngine.IGameData>('id'),
},
Players: {
|
import * as moment from 'moment';
import { createCoopHandler } from './apis/coop.api';
import { IAuthProvider, IDataSource, IPlayerPushProvider, IRateLimitProvider } from './dependencies';
import { CardMod } from './game/card-mods';
import { CardScript } from './game/card-scripts';
import { GameEngine, createGameEngineProvider } from './game/game-engine';
import { GameEngineUtils } from './game/game-engine-utils';
import { IHttpRequest, IHttpRouteHandler, StatusCodes } from './net-utils';
import { FULL_DATETIME_FORMAT } from './utils';
/**
* Main entry point
*/
// TODO: this should be replaced with node:http or expressjs
export const handleRequest = async (req: IHttpRequest) => {
const split = req.path.split('/').filter(Boolean);
const subPath = split.slice(1);
const body = req.body ? JSON.parse(req.body) : null;
const query = req.queryStringParameters || {};
let handler: IHttpRouteHandler | undefined = undefined;
switch (split[0]) {
case 'coop':
handler = coopHandler;
// ... Note: implement remaining route handlers
}
const result = handler ? (await handler(subPath, query, body, req)) : null;
return result || [StatusCodes.badRequest, { reason: 'invalid api' }];
};
/**
* Dependencies
*/
// Note: replace with an actual database
const cardDecksTable = createMockTableDualKey<IDataSource.ICardDeck>('playerId', 'createdAt');
const coopGamesTable = createMockTableSingleKey<IDataSource.ICoopGame>('id');
const playersTable = createMockTableSingleKey<IDataSource.IPlayer>('id');
const playerCoopGamesTable = createMockTableSingleKey<IDataSource.IPlayerCoopGame>('playerId');
const dataSource: IDataSource = {
CardDecks: {
...cardDecksTable,
async queryByDid(did) {
return { items: [...cardDecksTable._db.values()].filter(x => x.playerId === did) };
},
},
CoopGames: {
...coopGamesTable,
async queryByGameState(gameState) {
return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };
},
},
GameData: {
...createMockTableSingleKey<GameEngine.IGameData>('id'),
},
Players: {
...playersTable,
},
PlayerCoopGames: {
...playerCoopGamesTable,
async queryByPlayerId(playerId: string) {
return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };
},
},
Leaderboard: {
getTopN(_n) { return [] as any; },
async set(_playerId, _score) { },
},
async execUpdates(...updateRequests) {
updateRequests.forEach(x => x());
},
};
// Note: replace with an actual auth provider
const authProvider: IAuthProvider = {
generateNewSecret: () => `${Math.random()}`,
getAuthTokenForPlayer: player => player.secret,
getPlayerFromRequest: async () => [...playersTable._db.values()][0]!,
getPlayerIdFromRequest: () => [...playersTable._db.values()][0]?.id!,
};
// Note: replace with an actual push provider
const pushProvider: IPlayerPushProvider = {
async push(playerId, messages) {
console.log(`Push messages for player [${playerId}]:`);
messages.forEach(x => console.log(x));
}
};
const rateLimitProvider: IRateLimitProvider = {
async shouldRateLimitCreateGame(_playerId) {
return false;
},
async shouldRateLimitSearchGame(_playerId) {
return false;
},
};
// Note: replace with custom game content
const gameContent: GameEngine.IRuleset = {
cardMods: { /** Custom card modifiers **/ },
cardScripts: { /** Custom card scripts **/ },
initGame(engine) {
const testEnemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'testEnemy',
cpu: 1,
mem: 1,
maxMem: 1,
mods: [],
scripts: [],
sec: 10,
};
testEnemy.mods.push(new CardMod.Content._standardAi().serialize());
testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());
GameEngineUtils.addEnemy(engine, testEnemy, 0, true);
},
addAdditionalScriptsFor(_card) {
// Note: Called by GameEngine when a player is joined; this hook allows for dynamic scripts for a given card
},
};
const gameEngine = createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
const coopHandler =
|
createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider);
|
/**
* Example
*/
(async () => {
/**
* Players are normally created via /players/connectDid; to keep this example concise,
* we'll inject one with CO8's DID into the mock database.
*/
const mockPlayer = {
id: 'did:chia:1sc5hxvcs26e4zsc7uvlfuc7x9sjj5aw6cu0g8vcyvscy49ffp8zqwh63tq',
activeDeckId: '',
activeGameId: '',
secret: '',
authExpiresAt: '2100-01-01',
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),
score: 0,
}
playersTable._db.set(mockPlayer.id, mockPlayer);
/**
* This calls into /coop/create which is a complex API.
* Step thru this to learn about how the route handlers work.
*/
console.log('Creating game...');
await handleRequest({
httpMethod: 'POST',
path: '/coop/create',
body: JSON.stringify({
gameVisibility: 'private',
difficulty: 1,
}),
});
console.log('Game created, gameId: ' + mockPlayer.activeGameId);
/**
* Games normally start automatically when enough players join via /coop/join or /coop/search,
* to keep this example concise, we'll start it directly via the gameEngine reference.
* Step thru this to learn about how the game engine works.
*/
console.log('Starting game...');
await gameEngine.startGame(mockPlayer.activeGameId);
})();
/**
* In-memory DB helpers
* Note: this is a mock database that only satisfies the example above and is
* not meant to be starting point for production.
*/
function createMockTableSingleKey<T extends Record<string, any>>(idKey: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id: string) {
return _db.get(id) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(item[idKey], item);
return item;
},
},
};
}
function createMockTableDualKey<T extends Record<string, any>>(id1Key: keyof T, id2Key: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id1: string, id2: string) {
return _db.get(`${id1}_${id2}`) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(`${item[id1Key]}_${item[id2Key]}`, item);
return item;
},
},
};
}
|
src/reference-example.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " ],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n );\n return enemy;\n },\n },\n cardScripts: {",
"score": 0.9073930382728577
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new CardScript.Content._defend(enemy, engine.gameData.difficulty).serialize(),",
"score": 0.894378662109375
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n );\n return enemy;\n },\n reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n enemyClass: 'reaper_lesser_guardian',\n cpu: 2,",
"score": 0.8910255432128906
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " maxMem: 1,\n sec: GameEngineUtils.scaleByDifficulty(30, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },",
"score": 0.889238715171814
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },\n goliath_shield_node: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),",
"score": 0.8795587420463562
}
] |
typescript
|
createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider);
|
import * as moment from 'moment';
import { createCoopHandler } from './apis/coop.api';
import { IAuthProvider, IDataSource, IPlayerPushProvider, IRateLimitProvider } from './dependencies';
import { CardMod } from './game/card-mods';
import { CardScript } from './game/card-scripts';
import { GameEngine, createGameEngineProvider } from './game/game-engine';
import { GameEngineUtils } from './game/game-engine-utils';
import { IHttpRequest, IHttpRouteHandler, StatusCodes } from './net-utils';
import { FULL_DATETIME_FORMAT } from './utils';
/**
* Main entry point
*/
// TODO: this should be replaced with node:http or expressjs
export const handleRequest = async (req: IHttpRequest) => {
const split = req.path.split('/').filter(Boolean);
const subPath = split.slice(1);
const body = req.body ? JSON.parse(req.body) : null;
const query = req.queryStringParameters || {};
let handler: IHttpRouteHandler | undefined = undefined;
switch (split[0]) {
case 'coop':
handler = coopHandler;
// ... Note: implement remaining route handlers
}
const result = handler ? (await handler(subPath, query, body, req)) : null;
return result || [StatusCodes.badRequest, { reason: 'invalid api' }];
};
/**
* Dependencies
*/
// Note: replace with an actual database
const cardDecksTable = createMockTableDualKey<IDataSource.ICardDeck>('playerId', 'createdAt');
const coopGamesTable = createMockTableSingleKey<IDataSource.ICoopGame>('id');
const playersTable = createMockTableSingleKey<IDataSource.IPlayer>('id');
const playerCoopGamesTable = createMockTableSingleKey<IDataSource.IPlayerCoopGame>('playerId');
const dataSource: IDataSource = {
CardDecks: {
...cardDecksTable,
async queryByDid(did) {
return { items: [...cardDecksTable._db.values()].filter(x => x.playerId === did) };
},
},
CoopGames: {
...coopGamesTable,
async queryByGameState(gameState) {
return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };
},
},
GameData: {
...createMockTableSingleKey<GameEngine.IGameData>('id'),
},
Players: {
...playersTable,
},
PlayerCoopGames: {
...playerCoopGamesTable,
async queryByPlayerId(playerId: string) {
return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };
},
},
Leaderboard: {
getTopN(_n) { return [] as any; },
async set(_playerId, _score) { },
},
async execUpdates(...updateRequests) {
updateRequests.forEach(x => x());
},
};
// Note: replace with an actual auth provider
const authProvider: IAuthProvider = {
generateNewSecret: () => `${Math.random()}`,
getAuthTokenForPlayer: player => player.secret,
getPlayerFromRequest: async () => [...playersTable._db.values()][0]!,
getPlayerIdFromRequest: () => [...playersTable._db.values()][0]?.id!,
};
// Note: replace with an actual push provider
const pushProvider: IPlayerPushProvider = {
async push(playerId, messages) {
console.log(`Push messages for player [${playerId}]:`);
messages.forEach(x => console.log(x));
}
};
const rateLimitProvider: IRateLimitProvider = {
async shouldRateLimitCreateGame(_playerId) {
return false;
},
async shouldRateLimitSearchGame(_playerId) {
return false;
},
};
// Note: replace with custom game content
const gameContent: GameEngine.IRuleset = {
cardMods: { /** Custom card modifiers **/ },
cardScripts: { /** Custom card scripts **/ },
initGame(engine) {
const testEnemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'testEnemy',
cpu: 1,
mem: 1,
maxMem: 1,
mods: [],
scripts: [],
sec: 10,
};
testEnemy.mods.push(new CardMod.Content._standardAi().serialize());
testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());
GameEngineUtils.addEnemy(engine, testEnemy, 0, true);
},
addAdditionalScriptsFor(_card) {
// Note: Called by GameEngine when a player is joined; this hook allows for dynamic scripts for a given card
},
};
const gameEngine = createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
const coopHandler = createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider);
/**
* Example
*/
(async () => {
/**
* Players are normally created via /players/connectDid; to keep this example concise,
* we'll inject one with CO8's DID into the mock database.
*/
const mockPlayer = {
id: 'did:chia:1sc5hxvcs26e4zsc7uvlfuc7x9sjj5aw6cu0g8vcyvscy49ffp8zqwh63tq',
activeDeckId: '',
activeGameId: '',
secret: '',
authExpiresAt: '2100-01-01',
createdAt: moment.
|
utc().format(FULL_DATETIME_FORMAT),
lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),
score: 0,
}
|
playersTable._db.set(mockPlayer.id, mockPlayer);
/**
* This calls into /coop/create which is a complex API.
* Step thru this to learn about how the route handlers work.
*/
console.log('Creating game...');
await handleRequest({
httpMethod: 'POST',
path: '/coop/create',
body: JSON.stringify({
gameVisibility: 'private',
difficulty: 1,
}),
});
console.log('Game created, gameId: ' + mockPlayer.activeGameId);
/**
* Games normally start automatically when enough players join via /coop/join or /coop/search,
* to keep this example concise, we'll start it directly via the gameEngine reference.
* Step thru this to learn about how the game engine works.
*/
console.log('Starting game...');
await gameEngine.startGame(mockPlayer.activeGameId);
})();
/**
* In-memory DB helpers
* Note: this is a mock database that only satisfies the example above and is
* not meant to be starting point for production.
*/
function createMockTableSingleKey<T extends Record<string, any>>(idKey: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id: string) {
return _db.get(id) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(item[idKey], item);
return item;
},
},
};
}
function createMockTableDualKey<T extends Record<string, any>>(id1Key: keyof T, id2Key: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id1: string, id2: string) {
return _db.get(`${id1}_${id2}`) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(`${item[id1Key]}_${item[id2Key]}`, item);
return item;
},
},
};
}
|
src/reference-example.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " playerId: string;\n endedAt: string;\n gameId: string;\n gameResult: 'win' | 'loss' | 'abandoned' | 'unknown';\n teammates: string[];\n score: number;\n turns: number;\n difficulty: number;\n rulesetIds: string[];\n }",
"score": 0.850489616394043
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " const newAuthExpireAt = moment.utc(now).add({ days: 14 }).format(FULL_DATETIME_FORMAT);\n if (!player) {\n const nowStr = now.format(FULL_DATETIME_FORMAT);\n player = await ds.Players.update.exec({\n id: did,\n createdAt: nowStr,\n lastSeenAt: nowStr,\n secret: newSecret,\n authExpiresAt: newAuthExpireAt,\n activeGameId: '',",
"score": 0.8483690619468689
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " if (deck) {\n return deck;\n }\n const cards = (await ExtDeps.getNftsByDidOrWallet(player.id, 6))?.nfts.filter(Boolean) || [];\n if (cards.length < 6) {\n return null;\n }\n const nowStr = moment.utc().format(FULL_DATETIME_FORMAT);\n player.activeDeckId = nowStr;\n deck = {",
"score": 0.8472154140472412
},
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " difficulty: number;\n createdAt: string;\n gameState: 'open' | 'private' | `ended_${string}`;\n playersIds: Set<string>;\n ingorePlayerIds: Set<string>;\n startedAt: string;\n endedAt: string;\n isCompleted: boolean;\n _dbTtl?: number;\n }",
"score": 0.8466562032699585
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " mem: 0,\n maxMem: 0,\n sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content._winOnDeath().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };",
"score": 0.8403096795082092
}
] |
typescript
|
utc().format(FULL_DATETIME_FORMAT),
lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),
score: 0,
}
|
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetStasis = {
cardMods: {
stasis_boss_ai: class extends CardMod.Content._standardAi {
override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {
if (deps.sourceCard.mem - memDmg <= 0) return;
for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {
CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);
}
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);
if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {
GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
}
}
},
},
enemyCards: {
stasis_disruptor: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 3,
maxMem: 3,
sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
|
new RulesetStasis.cardScripts.stasis_disrupt(enemy, engine.gameData.difficulty).serialize(),
);
|
return enemy;
},
stasis_shocker: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
},
cardScripts: {
stasis_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState, difficulty: number) {
const dmg = GameEngineUtils.scaleByDifficulty(GameEngineUtils.scaleByCpuMem(5, card.cpu), difficulty);
super(
[difficulty, dmg],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(dmg),
CardScriptParts.AddMod(new CardMod.Content.lag(2)),
],
}
],
);
}
}
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'stasis_boss',
cpu: 3,
mem: 3,
maxMem: 3,
sec: GameEngineUtils.scaleByDifficulty(125, engine.gameData.difficulty),
mods: [
new RulesetStasis.cardMods.stasis_boss_ai().serialize(),
new CardMod.Content._winOnDeath().serialize(),
],
scripts: [],
};
boss.scripts.push(
new CardScript.Content._attack(boss, engine.gameData.difficulty, 'strong').serialize(),
new RulesetStasis.cardScripts.stasis_disrupt(boss, engine.gameData.difficulty).serialize(),
);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
},
};
|
src/game/rulesets/stasis.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new CardScript.Content._defend(enemy, engine.gameData.difficulty).serialize(),",
"score": 0.9517862796783447
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " maxMem: 1,\n sec: GameEngineUtils.scaleByDifficulty(30, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },",
"score": 0.9461466073989868
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " scripts: [],\n };\n boss.mods.push(\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content._waveTrigger(['reaper', 'goliath', 'stasis', 'stasis'], 12).serialize(),\n new CardMod.Content._yieldScript(new CardScript.Content._spawn(boss, RulesetMfrm.enemyCards.intro_perimeter.name, undefined, undefined, 2).serialize(), 2).serialize(),\n );\n boss.scripts.push(\n new CardScript.Content._defend(boss, engine.gameData.difficulty).serialize(),\n );",
"score": 0.925925076007843
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " enemyClass: '',\n cpu: 1,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new RulesetGoliath.cardMods.goliath_shield_supply().serialize(),\n ],\n scripts: [],",
"score": 0.9253347516059875
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " mem: 0,\n maxMem: 0,\n sec: 1,\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };\n enemy.scripts.push(",
"score": 0.9236918091773987
}
] |
typescript
|
new RulesetStasis.cardScripts.stasis_disrupt(enemy, engine.gameData.difficulty).serialize(),
);
|
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetStasis = {
cardMods: {
stasis_boss_ai: class extends CardMod.Content._standardAi {
override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {
if (deps.sourceCard.mem - memDmg <= 0) return;
for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {
CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);
}
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);
if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {
GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
}
}
},
},
enemyCards: {
stasis_disruptor: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 3,
maxMem: 3,
sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
new RulesetStasis.cardScripts.stasis_disrupt(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
stasis_shocker: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
},
cardScripts: {
stasis_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState, difficulty: number) {
const dmg = GameEngineUtils.scaleByDifficulty(GameEngineUtils.scaleByCpuMem(5, card.cpu), difficulty);
super(
[difficulty, dmg],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
|
CardScriptParts.Attack(dmg),
CardScriptParts.AddMod(new CardMod.Content.lag(2)),
],
}
|
],
);
}
}
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'stasis_boss',
cpu: 3,
mem: 3,
maxMem: 3,
sec: GameEngineUtils.scaleByDifficulty(125, engine.gameData.difficulty),
mods: [
new RulesetStasis.cardMods.stasis_boss_ai().serialize(),
new CardMod.Content._winOnDeath().serialize(),
],
scripts: [],
};
boss.scripts.push(
new CardScript.Content._attack(boss, engine.gameData.difficulty, 'strong').serialize(),
new RulesetStasis.cardScripts.stasis_disrupt(boss, engine.gameData.difficulty).serialize(),
);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
},
};
|
src/game/rulesets/stasis.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [damage, lagChance, lagDuration],\n CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.Attack(damage),\n ],\n },\n {",
"score": 0.9356342554092407
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new CardMod.Content.lag(1),\n ),\n ],\n }\n ],\n );",
"score": 0.9134467244148254
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [damage, cooldown],\n CardScript.TargetFinders.Allies(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new GameContent_v1.cardMods.feedback(damage),\n ),\n ],",
"score": 0.8994967341423035
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " targetResolver: CardScript.TargetResolvers.Self,\n parts: [\n CardScriptParts._Chance(lagChance,\n CardScriptParts.AddMod(\n new CardMod.Content.lag(lagDuration),\n ),\n ),\n ],\n }\n ],",
"score": 0.8916383385658264
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [\n {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.Attack(damage),\n CardScriptParts.Attack(damage),\n ],\n }\n ]\n );",
"score": 0.8885919451713562
}
] |
typescript
|
CardScriptParts.Attack(dmg),
CardScriptParts.AddMod(new CardMod.Content.lag(2)),
],
}
|
import { randomInt } from 'crypto';
import { appraiseCard } from '../appraise';
const excludedChars = ['1', 'b', 'i', 'o'];
const testSize = 1000000;
function generateId() {
let id = 'nft1'.padEnd(54, '_');
while (id.length < 62) {
const i = randomInt(0, 36);
let c: string;
if (i >= 10) {
c = String.fromCharCode(97 + i - 10);
} else {
c = String.fromCharCode(48 + i);
}
if (!excludedChars.includes(c)) {
id += c;
}
}
id = id.substring(0, 55) + (Math.random() < 0.5 ? 's' : 'q') + id.substring(56);
return id;
}
test('appraiseCard', () => {
const results = {
factions: {
backdoor: 0,
bruteforce: 0,
malware: 0,
},
scripts: {
bd_exploit: 0,
bd_decode: 0,
bd_secure: 0,
bf_firewall: 0,
bf_overclock: 0,
bf_spam: 0,
mw_redirect: 0,
mw_freeware: 0,
mw_worm: 0,
},
tiers: [0, 0, 0, 0, 0, 0, 0],
cpu: 0,
mem: 0,
};
for (let i = 0; i < testSize; i++) {
const
|
card = appraiseCard({ nftId: generateId(), mintHeight: 1, url: '' });
|
results.factions[card.faction]++;
results.tiers[card.tier]++;
results.cpu += card.cpu;
results.mem += card.mem;
results.scripts[card.coreScript]++;
if (card.cpu + card.mem !== card.tier + 2) {
// This assertion is not done using expect() as it would slow down the test too much
throw new Error('CPU + MEM is expected to be Tier + 2');
}
}
expect(results.factions.bruteforce / results.factions.malware).toBeCloseTo(1, 1);
expect(results.factions.bruteforce / results.factions.backdoor).toBeCloseTo(1.1, 1);
expect(results.cpu / results.mem).toBeCloseTo(1);
expect(results.scripts.bd_decode / results.scripts.bd_exploit).toBeCloseTo(1, 1);
expect(results.scripts.bd_decode / results.scripts.bd_secure).toBeCloseTo(1, 1);
expect(results.scripts.bf_firewall / results.scripts.bf_overclock).toBeCloseTo(1, 1);
expect(results.scripts.bf_firewall / results.scripts.bf_spam).toBeCloseTo(1, 1);
expect(results.scripts.mw_redirect / results.scripts.mw_freeware).toBeCloseTo(1, 1);
expect(results.scripts.mw_redirect / results.scripts.mw_worm).toBeCloseTo(1, 1);
expect(results.tiers[1]! / testSize).toBeCloseTo(.46156);
expect(results.tiers[2]! / testSize).toBeCloseTo(.31667);
expect(results.tiers[3]! / testSize).toBeCloseTo(.16521);
expect(results.tiers[4]! / testSize).toBeCloseTo(.04849);
expect(results.tiers[5]! / testSize).toBeCloseTo(.00759, 3);
// Cannot reliably test T6 as the numbers are so small but if T1-T5 pass then by process of elimination we can assert T6 is correct
});
|
src/tests/appraise.test.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/appraise.ts",
"retrieved_chunk": "const MINT_HEIGHT_THRESHOLD = 3200000;\nexport type CoreScriptNames = typeof _CoreScriptNames[IAppraisedCard['faction']][number];\nexport interface IAppraisedCard {\n nftId: string;\n faction: 'backdoor' | 'bruteforce' | 'malware';\n coreScript: CoreScriptNames;\n tier: number;\n cpu: number;\n mem: number;\n url: string;",
"score": 0.8309859037399292
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " cpu: 2,\n mem: 0,\n maxMem: 0,\n sec: 1,\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };",
"score": 0.8278202414512634
},
{
"filename": "src/appraise.ts",
"retrieved_chunk": "}\n/**\n * Generates card stats based on the number of digits in the last 9 chars of the nftId,\n */\nexport const appraiseCard = ({ nftId, mintHeight, url }: { nftId: string, mintHeight: number, url: string }): IAppraisedCard => {\n // Last 9 chars of the nftId determine the card qualifier, Q\n const Q = nftId.substring(nftId.length - 8).split('');\n // Q[0] determines faction\n // Since 34 potential characters does not divide cleanly by 3 factions,\n // distribution will not come out even - Backdoor will appear 10% less than other factions",
"score": 0.8267099261283875
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " mem: 0,\n maxMem: 0,\n sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content._winOnDeath().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };",
"score": 0.818639874458313
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\n const player: GameEngine.IPlayerState = {\n id: playerId,\n cards: cards.map(card => ({\n id: this.nextId(),\n card,\n isUsed: false,\n cpu: card.cpu,\n mem: card.mem,\n sec: card.mem * 6 + card.cpu * 3,",
"score": 0.8094789981842041
}
] |
typescript
|
card = appraiseCard({ nftId: generateId(), mintHeight: 1, url: '' });
|
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetStasis = {
cardMods: {
stasis_boss_ai: class extends CardMod.Content._standardAi {
override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {
if (deps.sourceCard.mem - memDmg <= 0) return;
for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {
CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);
}
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);
if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {
GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
}
}
},
},
enemyCards: {
stasis_disruptor: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 3,
maxMem: 3,
sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
new RulesetStasis.cardScripts.stasis_disrupt(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
stasis_shocker: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
},
cardScripts: {
stasis_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState, difficulty: number) {
const dmg = GameEngineUtils.scaleByDifficulty(GameEngineUtils.scaleByCpuMem(5, card.cpu), difficulty);
super(
[difficulty, dmg],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(dmg),
|
CardScriptParts.AddMod(new CardMod.Content.lag(2)),
],
}
|
],
);
}
}
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'stasis_boss',
cpu: 3,
mem: 3,
maxMem: 3,
sec: GameEngineUtils.scaleByDifficulty(125, engine.gameData.difficulty),
mods: [
new RulesetStasis.cardMods.stasis_boss_ai().serialize(),
new CardMod.Content._winOnDeath().serialize(),
],
scripts: [],
};
boss.scripts.push(
new CardScript.Content._attack(boss, engine.gameData.difficulty, 'strong').serialize(),
new RulesetStasis.cardScripts.stasis_disrupt(boss, engine.gameData.difficulty).serialize(),
);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
},
};
|
src/game/rulesets/stasis.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [damage, lagChance, lagDuration],\n CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.Attack(damage),\n ],\n },\n {",
"score": 0.9356342554092407
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new CardMod.Content.lag(1),\n ),\n ],\n }\n ],\n );",
"score": 0.9134467244148254
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [damage, cooldown],\n CardScript.TargetFinders.Allies(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new GameContent_v1.cardMods.feedback(damage),\n ),\n ],",
"score": 0.8994967341423035
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " targetResolver: CardScript.TargetResolvers.Self,\n parts: [\n CardScriptParts._Chance(lagChance,\n CardScriptParts.AddMod(\n new CardMod.Content.lag(lagDuration),\n ),\n ),\n ],\n }\n ],",
"score": 0.8916383385658264
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [\n {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.Attack(damage),\n CardScriptParts.Attack(damage),\n ],\n }\n ]\n );",
"score": 0.8885919451713562
}
] |
typescript
|
CardScriptParts.AddMod(new CardMod.Content.lag(2)),
],
}
|
import * as moment from 'moment';
import { createCoopHandler } from './apis/coop.api';
import { IAuthProvider, IDataSource, IPlayerPushProvider, IRateLimitProvider } from './dependencies';
import { CardMod } from './game/card-mods';
import { CardScript } from './game/card-scripts';
import { GameEngine, createGameEngineProvider } from './game/game-engine';
import { GameEngineUtils } from './game/game-engine-utils';
import { IHttpRequest, IHttpRouteHandler, StatusCodes } from './net-utils';
import { FULL_DATETIME_FORMAT } from './utils';
/**
* Main entry point
*/
// TODO: this should be replaced with node:http or expressjs
export const handleRequest = async (req: IHttpRequest) => {
const split = req.path.split('/').filter(Boolean);
const subPath = split.slice(1);
const body = req.body ? JSON.parse(req.body) : null;
const query = req.queryStringParameters || {};
let handler: IHttpRouteHandler | undefined = undefined;
switch (split[0]) {
case 'coop':
handler = coopHandler;
// ... Note: implement remaining route handlers
}
const result = handler ? (await handler(subPath, query, body, req)) : null;
return result || [StatusCodes.badRequest, { reason: 'invalid api' }];
};
/**
* Dependencies
*/
// Note: replace with an actual database
const cardDecksTable = createMockTableDualKey<IDataSource.ICardDeck>('playerId', 'createdAt');
const coopGamesTable = createMockTableSingleKey<IDataSource.ICoopGame>('id');
const playersTable = createMockTableSingleKey<IDataSource.IPlayer>('id');
const playerCoopGamesTable = createMockTableSingleKey<IDataSource.IPlayerCoopGame>('playerId');
const dataSource: IDataSource = {
CardDecks: {
...cardDecksTable,
async queryByDid(did) {
return { items: [...cardDecksTable._db.values()].filter(x => x.playerId === did) };
},
},
CoopGames: {
...coopGamesTable,
async queryByGameState(gameState) {
return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };
},
},
GameData: {
...createMockTableSingleKey<GameEngine.IGameData>('id'),
},
Players: {
...playersTable,
},
PlayerCoopGames: {
...playerCoopGamesTable,
async queryByPlayerId(playerId: string) {
return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };
},
},
Leaderboard: {
getTopN(_n) { return [] as any; },
|
async set(_playerId, _score) { },
},
async execUpdates(...updateRequests) {
|
updateRequests.forEach(x => x());
},
};
// Note: replace with an actual auth provider
const authProvider: IAuthProvider = {
generateNewSecret: () => `${Math.random()}`,
getAuthTokenForPlayer: player => player.secret,
getPlayerFromRequest: async () => [...playersTable._db.values()][0]!,
getPlayerIdFromRequest: () => [...playersTable._db.values()][0]?.id!,
};
// Note: replace with an actual push provider
const pushProvider: IPlayerPushProvider = {
async push(playerId, messages) {
console.log(`Push messages for player [${playerId}]:`);
messages.forEach(x => console.log(x));
}
};
const rateLimitProvider: IRateLimitProvider = {
async shouldRateLimitCreateGame(_playerId) {
return false;
},
async shouldRateLimitSearchGame(_playerId) {
return false;
},
};
// Note: replace with custom game content
const gameContent: GameEngine.IRuleset = {
cardMods: { /** Custom card modifiers **/ },
cardScripts: { /** Custom card scripts **/ },
initGame(engine) {
const testEnemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'testEnemy',
cpu: 1,
mem: 1,
maxMem: 1,
mods: [],
scripts: [],
sec: 10,
};
testEnemy.mods.push(new CardMod.Content._standardAi().serialize());
testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());
GameEngineUtils.addEnemy(engine, testEnemy, 0, true);
},
addAdditionalScriptsFor(_card) {
// Note: Called by GameEngine when a player is joined; this hook allows for dynamic scripts for a given card
},
};
const gameEngine = createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
const coopHandler = createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider);
/**
* Example
*/
(async () => {
/**
* Players are normally created via /players/connectDid; to keep this example concise,
* we'll inject one with CO8's DID into the mock database.
*/
const mockPlayer = {
id: 'did:chia:1sc5hxvcs26e4zsc7uvlfuc7x9sjj5aw6cu0g8vcyvscy49ffp8zqwh63tq',
activeDeckId: '',
activeGameId: '',
secret: '',
authExpiresAt: '2100-01-01',
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),
score: 0,
}
playersTable._db.set(mockPlayer.id, mockPlayer);
/**
* This calls into /coop/create which is a complex API.
* Step thru this to learn about how the route handlers work.
*/
console.log('Creating game...');
await handleRequest({
httpMethod: 'POST',
path: '/coop/create',
body: JSON.stringify({
gameVisibility: 'private',
difficulty: 1,
}),
});
console.log('Game created, gameId: ' + mockPlayer.activeGameId);
/**
* Games normally start automatically when enough players join via /coop/join or /coop/search,
* to keep this example concise, we'll start it directly via the gameEngine reference.
* Step thru this to learn about how the game engine works.
*/
console.log('Starting game...');
await gameEngine.startGame(mockPlayer.activeGameId);
})();
/**
* In-memory DB helpers
* Note: this is a mock database that only satisfies the example above and is
* not meant to be starting point for production.
*/
function createMockTableSingleKey<T extends Record<string, any>>(idKey: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id: string) {
return _db.get(id) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(item[idKey], item);
return item;
},
},
};
}
function createMockTableDualKey<T extends Record<string, any>>(id1Key: keyof T, id2Key: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id1: string, id2: string) {
return _db.get(`${id1}_${id2}`) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(`${item[id1Key]}_${item[id2Key]}`, item);
return item;
},
},
};
}
|
src/reference-example.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " export type PlayerCoopGame = {\n update: Updater<IPlayerCoopGame>;\n queryByPlayerId: Query<string, IPlayerCoopGame>;\n }\n export type GameData = {\n get: GetterSingle<GameEngine.IGameData>;\n update: Updater<GameEngine.IGameData>;\n };\n export type Leaderboard = {\n getTopN(n: number): Promise<[string, number][]>;",
"score": 0.88585364818573
},
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " set(playerId: string, score: number): Promise<void>;\n };\n}\ndeclare interface IDataSource {\n CardDecks: IDataSource.CardDecks;\n CoopGames: IDataSource.CoopGames;\n GameData: IDataSource.GameData;\n Leaderboard: IDataSource.Leaderboard;\n PlayerCoopGames: IDataSource.PlayerCoopGame;\n Players: IDataSource.Players;",
"score": 0.8523112535476685
},
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " export type CoopGames = {\n get: GetterSingle<ICoopGame>;\n update: Updater<ICoopGame>;\n queryByGameState: Query<ICoopGame['gameState'], ICoopGame>;\n };\n export interface IPlayer {\n id: string;\n createdAt: string;\n lastSeenAt: string;\n secret: string;",
"score": 0.8512052893638611
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];\n }\n case 'history': {\n const playerId = authProvider.getPlayerIdFromRequest(req);\n const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);\n return [StatusCodes.ok, games];\n }\n case 'join': {\n const schema = z.object({\n teammateDid: z.string().nonempty(),",
"score": 0.8484296798706055
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " const rankings = await ds.Leaderboard.getTopN(20);\n return [StatusCodes.ok, { rankings }];\n }\n case 'search': {\n const player = await _expectAuthPlayerNotInGame(req);\n // Don't need to validate nft ownership yet, either join() or create() will do this\n const deck = await _expectValidActiveDeck(player, false);\n let ct: any = undefined;\n do {\n const result = await ds.CoopGames.queryByGameState('open', 10, ct);",
"score": 0.8462808132171631
}
] |
typescript
|
async set(_playerId, _score) { },
},
async execUpdates(...updateRequests) {
|
import * as moment from 'moment';
import { createCoopHandler } from './apis/coop.api';
import { IAuthProvider, IDataSource, IPlayerPushProvider, IRateLimitProvider } from './dependencies';
import { CardMod } from './game/card-mods';
import { CardScript } from './game/card-scripts';
import { GameEngine, createGameEngineProvider } from './game/game-engine';
import { GameEngineUtils } from './game/game-engine-utils';
import { IHttpRequest, IHttpRouteHandler, StatusCodes } from './net-utils';
import { FULL_DATETIME_FORMAT } from './utils';
/**
* Main entry point
*/
// TODO: this should be replaced with node:http or expressjs
export const handleRequest = async (req: IHttpRequest) => {
const split = req.path.split('/').filter(Boolean);
const subPath = split.slice(1);
const body = req.body ? JSON.parse(req.body) : null;
const query = req.queryStringParameters || {};
let handler: IHttpRouteHandler | undefined = undefined;
switch (split[0]) {
case 'coop':
handler = coopHandler;
// ... Note: implement remaining route handlers
}
const result = handler ? (await handler(subPath, query, body, req)) : null;
return result || [StatusCodes.badRequest, { reason: 'invalid api' }];
};
/**
* Dependencies
*/
// Note: replace with an actual database
const cardDecksTable = createMockTableDualKey<IDataSource.ICardDeck>('playerId', 'createdAt');
const coopGamesTable = createMockTableSingleKey<IDataSource.ICoopGame>('id');
const playersTable = createMockTableSingleKey<IDataSource.IPlayer>('id');
const playerCoopGamesTable = createMockTableSingleKey<IDataSource.IPlayerCoopGame>('playerId');
const dataSource: IDataSource = {
CardDecks: {
...cardDecksTable,
async queryByDid(did) {
return { items: [...cardDecksTable._db.values()].filter(x => x.playerId === did) };
},
},
CoopGames: {
...coopGamesTable,
async queryByGameState(gameState) {
return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };
},
},
GameData: {
...createMockTableSingleKey<GameEngine.IGameData>('id'),
},
Players: {
...playersTable,
},
PlayerCoopGames: {
...playerCoopGamesTable,
async queryByPlayerId(playerId: string) {
return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };
},
},
Leaderboard: {
getTopN(_n) { return [] as any; },
async set(_playerId, _score) { },
},
async execUpdates(...updateRequests) {
updateRequests.forEach(x => x());
},
};
// Note: replace with an actual auth provider
const authProvider: IAuthProvider = {
generateNewSecret: () => `${Math.random()}`,
getAuthTokenForPlayer: player => player.secret,
getPlayerFromRequest: async () => [...playersTable._db.values()][0]!,
getPlayerIdFromRequest: () => [...playersTable._db.values()][0]?.id!,
};
// Note: replace with an actual push provider
const pushProvider: IPlayerPushProvider = {
|
async push(playerId, messages) {
|
console.log(`Push messages for player [${playerId}]:`);
messages.forEach(x => console.log(x));
}
};
const rateLimitProvider: IRateLimitProvider = {
async shouldRateLimitCreateGame(_playerId) {
return false;
},
async shouldRateLimitSearchGame(_playerId) {
return false;
},
};
// Note: replace with custom game content
const gameContent: GameEngine.IRuleset = {
cardMods: { /** Custom card modifiers **/ },
cardScripts: { /** Custom card scripts **/ },
initGame(engine) {
const testEnemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'testEnemy',
cpu: 1,
mem: 1,
maxMem: 1,
mods: [],
scripts: [],
sec: 10,
};
testEnemy.mods.push(new CardMod.Content._standardAi().serialize());
testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());
GameEngineUtils.addEnemy(engine, testEnemy, 0, true);
},
addAdditionalScriptsFor(_card) {
// Note: Called by GameEngine when a player is joined; this hook allows for dynamic scripts for a given card
},
};
const gameEngine = createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
const coopHandler = createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider);
/**
* Example
*/
(async () => {
/**
* Players are normally created via /players/connectDid; to keep this example concise,
* we'll inject one with CO8's DID into the mock database.
*/
const mockPlayer = {
id: 'did:chia:1sc5hxvcs26e4zsc7uvlfuc7x9sjj5aw6cu0g8vcyvscy49ffp8zqwh63tq',
activeDeckId: '',
activeGameId: '',
secret: '',
authExpiresAt: '2100-01-01',
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),
score: 0,
}
playersTable._db.set(mockPlayer.id, mockPlayer);
/**
* This calls into /coop/create which is a complex API.
* Step thru this to learn about how the route handlers work.
*/
console.log('Creating game...');
await handleRequest({
httpMethod: 'POST',
path: '/coop/create',
body: JSON.stringify({
gameVisibility: 'private',
difficulty: 1,
}),
});
console.log('Game created, gameId: ' + mockPlayer.activeGameId);
/**
* Games normally start automatically when enough players join via /coop/join or /coop/search,
* to keep this example concise, we'll start it directly via the gameEngine reference.
* Step thru this to learn about how the game engine works.
*/
console.log('Starting game...');
await gameEngine.startGame(mockPlayer.activeGameId);
})();
/**
* In-memory DB helpers
* Note: this is a mock database that only satisfies the example above and is
* not meant to be starting point for production.
*/
function createMockTableSingleKey<T extends Record<string, any>>(idKey: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id: string) {
return _db.get(id) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(item[idKey], item);
return item;
},
},
};
}
function createMockTableDualKey<T extends Record<string, any>>(id1Key: keyof T, id2Key: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id1: string, id2: string) {
return _db.get(`${id1}_${id2}`) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(`${item[id1Key]}_${item[id2Key]}`, item);
return item;
},
},
};
}
|
src/reference-example.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": "}\ndeclare namespace IPlayerPushProvider {\n export interface IPushMessage {\n [key: string]: any;\n type: string;\n }\n}\ndeclare interface IPlayerPushProvider {\n push(playerId: string, messages: IPlayerPushProvider.IPushMessage[]): Promise<void>;\n}",
"score": 0.8453301191329956
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 0.8055289387702942
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const gameData = await _Engine.getGameData(gameId);\n const pushMessage: IPlayerPushProvider.IPushMessage[] = [{\n type: 'cardIntent',\n cardId: sourceCardId,\n intent: {\n scriptData: sourceCardScript,\n targetCardId,\n },\n playerId,\n }];",
"score": 0.8049426078796387
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " return [StatusCodes.ok, {\n player: toClientPlayer(player, authProvider),\n status: isNew ? 'new' : 'existing',\n }];\n }\n case 'me': {\n const player = await authProvider.getPlayerFromRequest(req);\n return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];\n }\n }",
"score": 0.8028783798217773
},
{
"filename": "src/models.ts",
"retrieved_chunk": "import { appraiseCard } from './appraise';\nimport { IAuthProvider, IDataSource } from './dependencies';\nexport const toClientPlayer = (player: IDataSource.IPlayer, authProvider: IAuthProvider) => {\n return {\n ...player,\n authToken: authProvider.getAuthTokenForPlayer(player),\n };\n}\nexport const toClientDeck = (player: IDataSource.IPlayer, deck: IDataSource.ICardDeck | null) => {\n if (!deck) return null;",
"score": 0.8021079301834106
}
] |
typescript
|
async push(playerId, messages) {
|
import * as moment from 'moment';
import { createCoopHandler } from './apis/coop.api';
import { IAuthProvider, IDataSource, IPlayerPushProvider, IRateLimitProvider } from './dependencies';
import { CardMod } from './game/card-mods';
import { CardScript } from './game/card-scripts';
import { GameEngine, createGameEngineProvider } from './game/game-engine';
import { GameEngineUtils } from './game/game-engine-utils';
import { IHttpRequest, IHttpRouteHandler, StatusCodes } from './net-utils';
import { FULL_DATETIME_FORMAT } from './utils';
/**
* Main entry point
*/
// TODO: this should be replaced with node:http or expressjs
export const handleRequest = async (req: IHttpRequest) => {
const split = req.path.split('/').filter(Boolean);
const subPath = split.slice(1);
const body = req.body ? JSON.parse(req.body) : null;
const query = req.queryStringParameters || {};
let handler: IHttpRouteHandler | undefined = undefined;
switch (split[0]) {
case 'coop':
handler = coopHandler;
// ... Note: implement remaining route handlers
}
const result = handler ? (await handler(subPath, query, body, req)) : null;
return result || [StatusCodes.badRequest, { reason: 'invalid api' }];
};
/**
* Dependencies
*/
// Note: replace with an actual database
const cardDecksTable = createMockTableDualKey<IDataSource.ICardDeck>('playerId', 'createdAt');
const coopGamesTable = createMockTableSingleKey<IDataSource.ICoopGame>('id');
const playersTable = createMockTableSingleKey<IDataSource.IPlayer>('id');
const playerCoopGamesTable = createMockTableSingleKey<IDataSource.IPlayerCoopGame>('playerId');
const dataSource: IDataSource = {
CardDecks: {
...cardDecksTable,
async queryByDid(did) {
return { items: [...cardDecksTable._db.values()].filter(x => x.playerId === did) };
},
},
CoopGames: {
...coopGamesTable,
async queryByGameState(gameState) {
return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };
},
},
GameData: {
...createMockTableSingleKey<GameEngine.IGameData>('id'),
},
Players: {
...playersTable,
},
PlayerCoopGames: {
...playerCoopGamesTable,
async queryByPlayerId(playerId: string) {
return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };
},
},
Leaderboard: {
getTopN(_n) { return [] as any; },
async set(_playerId, _score) { },
},
|
async execUpdates(...updateRequests) {
|
updateRequests.forEach(x => x());
},
};
// Note: replace with an actual auth provider
const authProvider: IAuthProvider = {
generateNewSecret: () => `${Math.random()}`,
getAuthTokenForPlayer: player => player.secret,
getPlayerFromRequest: async () => [...playersTable._db.values()][0]!,
getPlayerIdFromRequest: () => [...playersTable._db.values()][0]?.id!,
};
// Note: replace with an actual push provider
const pushProvider: IPlayerPushProvider = {
async push(playerId, messages) {
console.log(`Push messages for player [${playerId}]:`);
messages.forEach(x => console.log(x));
}
};
const rateLimitProvider: IRateLimitProvider = {
async shouldRateLimitCreateGame(_playerId) {
return false;
},
async shouldRateLimitSearchGame(_playerId) {
return false;
},
};
// Note: replace with custom game content
const gameContent: GameEngine.IRuleset = {
cardMods: { /** Custom card modifiers **/ },
cardScripts: { /** Custom card scripts **/ },
initGame(engine) {
const testEnemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'testEnemy',
cpu: 1,
mem: 1,
maxMem: 1,
mods: [],
scripts: [],
sec: 10,
};
testEnemy.mods.push(new CardMod.Content._standardAi().serialize());
testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());
GameEngineUtils.addEnemy(engine, testEnemy, 0, true);
},
addAdditionalScriptsFor(_card) {
// Note: Called by GameEngine when a player is joined; this hook allows for dynamic scripts for a given card
},
};
const gameEngine = createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
const coopHandler = createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider);
/**
* Example
*/
(async () => {
/**
* Players are normally created via /players/connectDid; to keep this example concise,
* we'll inject one with CO8's DID into the mock database.
*/
const mockPlayer = {
id: 'did:chia:1sc5hxvcs26e4zsc7uvlfuc7x9sjj5aw6cu0g8vcyvscy49ffp8zqwh63tq',
activeDeckId: '',
activeGameId: '',
secret: '',
authExpiresAt: '2100-01-01',
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),
score: 0,
}
playersTable._db.set(mockPlayer.id, mockPlayer);
/**
* This calls into /coop/create which is a complex API.
* Step thru this to learn about how the route handlers work.
*/
console.log('Creating game...');
await handleRequest({
httpMethod: 'POST',
path: '/coop/create',
body: JSON.stringify({
gameVisibility: 'private',
difficulty: 1,
}),
});
console.log('Game created, gameId: ' + mockPlayer.activeGameId);
/**
* Games normally start automatically when enough players join via /coop/join or /coop/search,
* to keep this example concise, we'll start it directly via the gameEngine reference.
* Step thru this to learn about how the game engine works.
*/
console.log('Starting game...');
await gameEngine.startGame(mockPlayer.activeGameId);
})();
/**
* In-memory DB helpers
* Note: this is a mock database that only satisfies the example above and is
* not meant to be starting point for production.
*/
function createMockTableSingleKey<T extends Record<string, any>>(idKey: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id: string) {
return _db.get(id) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(item[idKey], item);
return item;
},
},
};
}
function createMockTableDualKey<T extends Record<string, any>>(id1Key: keyof T, id2Key: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id1: string, id2: string) {
return _db.get(`${id1}_${id2}`) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(`${item[id1Key]}_${item[id2Key]}`, item);
return item;
},
},
};
}
|
src/reference-example.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " export type PlayerCoopGame = {\n update: Updater<IPlayerCoopGame>;\n queryByPlayerId: Query<string, IPlayerCoopGame>;\n }\n export type GameData = {\n get: GetterSingle<GameEngine.IGameData>;\n update: Updater<GameEngine.IGameData>;\n };\n export type Leaderboard = {\n getTopN(n: number): Promise<[string, number][]>;",
"score": 0.8860061168670654
},
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " set(playerId: string, score: number): Promise<void>;\n };\n}\ndeclare interface IDataSource {\n CardDecks: IDataSource.CardDecks;\n CoopGames: IDataSource.CoopGames;\n GameData: IDataSource.GameData;\n Leaderboard: IDataSource.Leaderboard;\n PlayerCoopGames: IDataSource.PlayerCoopGame;\n Players: IDataSource.Players;",
"score": 0.8524765968322754
},
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " export type CoopGames = {\n get: GetterSingle<ICoopGame>;\n update: Updater<ICoopGame>;\n queryByGameState: Query<ICoopGame['gameState'], ICoopGame>;\n };\n export interface IPlayer {\n id: string;\n createdAt: string;\n lastSeenAt: string;\n secret: string;",
"score": 0.8513628244400024
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];\n }\n case 'history': {\n const playerId = authProvider.getPlayerIdFromRequest(req);\n const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);\n return [StatusCodes.ok, games];\n }\n case 'join': {\n const schema = z.object({\n teammateDid: z.string().nonempty(),",
"score": 0.848471462726593
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " const rankings = await ds.Leaderboard.getTopN(20);\n return [StatusCodes.ok, { rankings }];\n }\n case 'search': {\n const player = await _expectAuthPlayerNotInGame(req);\n // Don't need to validate nft ownership yet, either join() or create() will do this\n const deck = await _expectValidActiveDeck(player, false);\n let ct: any = undefined;\n do {\n const result = await ds.CoopGames.queryByGameState('open', 10, ct);",
"score": 0.8463624715805054
}
] |
typescript
|
async execUpdates(...updateRequests) {
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import { E_VALIDATION_ERROR } from '../errors/main.js'
import { ValidationError } from '../errors/validation_error.js'
import type { ErrorReporterContract, FieldContext } from '../types.js'
/**
* Shape of the error message collected by the SimpleErrorReporter
*/
type SimpleError = {
message: string
field: string
rule: string
index?: number
meta?: Record<string, any>
}
/**
* Simple error reporter collects error messages as an array of object.
* Each object has following properties.
*
* - message: string
* - field: string
* - rule: string
* - index?: number (in case of an array member)
* - args?: Record<string, any>
*/
export class SimpleErrorReporter implements ErrorReporterContract {
/**
* Boolean to know one or more errors have been reported
*/
hasErrors: boolean = false
/**
* Collection of errors
*/
errors: SimpleError[] = []
/**
* Report an error.
*/
report(
message: string,
rule: string,
field: FieldContext,
meta?: Record<string, any> | undefined
) {
const error: SimpleError = {
message,
rule,
field: field.wildCardPath,
}
if (meta) {
error.meta = meta
}
if (field.isArrayMember) {
error.index = field.name as number
}
this.hasErrors = true
this.errors.push(error)
}
/**
* Returns an instance of the validation error
*/
createError
|
(): ValidationError {
|
return new E_VALIDATION_ERROR(this.errors)
}
}
|
src/reporters/simple_error_reporter.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/errors/main.ts",
"retrieved_chunk": " * Create an instance of validation error\n */\nexport const E_VALIDATION_ERROR = ValidationError",
"score": 0.798521101474762
},
{
"filename": "src/errors/validation_error.ts",
"retrieved_chunk": " * error messages\n */\nexport class ValidationError extends Error {\n /**\n * Http status code for the validation error\n */\n status: number = 422\n /**\n * Internal code for handling the validation error\n * exception",
"score": 0.7972216606140137
},
{
"filename": "src/errors/validation_error.ts",
"retrieved_chunk": " */\n code: string = 'E_VALIDATION_ERROR'\n constructor(\n public messages: any,\n options?: ErrorOptions\n ) {\n super('Validation failure', options)\n const ErrorConstructor = this.constructor as typeof ValidationError\n Error.captureStackTrace(this, ErrorConstructor)\n }",
"score": 0.7949851155281067
},
{
"filename": "src/schema/base/literal.ts",
"retrieved_chunk": " /**\n * The child class must implement the clone method\n */\n abstract clone(): this\n /**\n * Field options\n */\n protected options: FieldOptions\n /**\n * Set of validations to run",
"score": 0.7851144075393677
},
{
"filename": "src/errors/main.ts",
"retrieved_chunk": "/*\n * @vinejs/vine\n *\n * (c) VineJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\nimport { ValidationError } from './validation_error.js'\n/**",
"score": 0.7808114290237427
}
] |
typescript
|
(): ValidationError {
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import { E_VALIDATION_ERROR } from '../errors/main.js'
import { ValidationError } from '../errors/validation_error.js'
import type { ErrorReporterContract, FieldContext } from '../types.js'
/**
* Shape of the error message collected by the SimpleErrorReporter
*/
type SimpleError = {
message: string
field: string
rule: string
index?: number
meta?: Record<string, any>
}
/**
* Simple error reporter collects error messages as an array of object.
* Each object has following properties.
*
* - message: string
* - field: string
* - rule: string
* - index?: number (in case of an array member)
* - args?: Record<string, any>
*/
export class SimpleErrorReporter implements ErrorReporterContract {
/**
* Boolean to know one or more errors have been reported
*/
hasErrors: boolean = false
/**
* Collection of errors
*/
errors: SimpleError[] = []
/**
* Report an error.
*/
report(
message: string,
rule: string,
field:
|
FieldContext,
meta?: Record<string, any> | undefined
) {
|
const error: SimpleError = {
message,
rule,
field: field.wildCardPath,
}
if (meta) {
error.meta = meta
}
if (field.isArrayMember) {
error.index = field.name as number
}
this.hasErrors = true
this.errors.push(error)
}
/**
* Returns an instance of the validation error
*/
createError(): ValidationError {
return new E_VALIDATION_ERROR(this.errors)
}
}
|
src/reporters/simple_error_reporter.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/types.ts",
"retrieved_chunk": " */\n errorReporter?: () => ErrorReporterContract\n} & ([undefined] extends MetaData\n ? {\n meta?: MetaData\n }\n : {\n meta: MetaData\n })\n/**",
"score": 0.8025004267692566
},
{
"filename": "src/types.ts",
"retrieved_chunk": " field: FieldContext\n) => any | Promise<any>\n/**\n * A validation rule is a combination of a validator and\n * some metadata required at the time of compiling the\n * rule.\n *\n * Think of this type as \"Validator\" + \"metaData\"\n */\nexport type ValidationRule<Options extends any> = {",
"score": 0.798450231552124
},
{
"filename": "src/types.ts",
"retrieved_chunk": "export interface ErrorReporterContract extends BaseReporter {\n createError(): ValidationError\n}\n/**\n * The validator function to validate metadata given to a validation\n * pipeline\n */\nexport type MetaDataValidator = (meta: Record<string, any>) => void\n/**\n * Options accepted during the validate call.",
"score": 0.7957631349563599
},
{
"filename": "src/schema/string/rules.ts",
"retrieved_chunk": " }\n if (!helpers.isHexColor(value as string)) {\n field.report(messages.hexCode, 'hexCode', field)\n }\n})\n/**\n * Validates the value to be a valid URL\n */\nexport const urlRule = createRule<URLOptions | undefined>((value, options, field) => {\n if (!field.isValid) {",
"score": 0.7953236103057861
},
{
"filename": "src/schema/string/rules.ts",
"retrieved_chunk": "export const uuidRule = createRule<{ version?: (1 | 2 | 3 | 4 | 5)[] } | undefined>(\n (value, options, field) => {\n if (!field.isValid) {\n return\n }\n if (!options || !options.version) {\n if (!helpers.isUUID(value as string)) {\n field.report(messages.uuid, 'uuid', field)\n }\n } else {",
"score": 0.7927492260932922
}
] |
typescript
|
FieldContext,
meta?: Record<string, any> | undefined
) {
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import { E_VALIDATION_ERROR } from '../errors/main.js'
import { ValidationError } from '../errors/validation_error.js'
import type { ErrorReporterContract, FieldContext } from '../types.js'
/**
* Shape of the error message collected by the SimpleErrorReporter
*/
type SimpleError = {
message: string
field: string
rule: string
index?: number
meta?: Record<string, any>
}
/**
* Simple error reporter collects error messages as an array of object.
* Each object has following properties.
*
* - message: string
* - field: string
* - rule: string
* - index?: number (in case of an array member)
* - args?: Record<string, any>
*/
export class SimpleErrorReporter implements ErrorReporterContract {
/**
* Boolean to know one or more errors have been reported
*/
hasErrors: boolean = false
/**
* Collection of errors
*/
errors: SimpleError[] = []
/**
* Report an error.
*/
report(
message: string,
rule: string,
field: FieldContext,
meta?: Record<string, any> | undefined
) {
const error: SimpleError = {
message,
rule,
field: field.wildCardPath,
}
if (meta) {
error.meta = meta
}
if (field.isArrayMember) {
error.index = field.name as number
}
this.hasErrors = true
this.errors.push(error)
}
/**
* Returns an instance of the validation error
*/
|
createError(): ValidationError {
|
return new E_VALIDATION_ERROR(this.errors)
}
}
|
src/reporters/simple_error_reporter.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/tuple/main.ts",
"retrieved_chunk": " [UNIQUE_NAME] = 'vine.array';\n /**\n * Checks if the value is of array type. The method must be\n * implemented for \"unionOfTypes\"\n */\n [IS_OF_TYPE] = (value: unknown) => {\n return Array.isArray(value)\n }\n constructor(schemas: [...Schema], options?: FieldOptions, validations?: Validation<any>[]) {\n super(options, validations)",
"score": 0.7915255427360535
},
{
"filename": "src/schema/array/rules.ts",
"retrieved_chunk": " }\n})\n/**\n * Ensure the array is not empty\n */\nexport const notEmptyRule = createRule<undefined>((value, _, field) => {\n /**\n * Skip if the field is not valid.\n */\n if (!field.isValid) {",
"score": 0.7890167236328125
},
{
"filename": "src/schema/array/rules.ts",
"retrieved_chunk": " * Skip if the field is not valid.\n */\n if (!field.isValid) {\n return\n }\n /**\n * Value will always be an array if the field is valid.\n */\n if ((value as unknown[]).length !== options.size) {\n field.report(messages['array.fixedLength'], 'array.fixedLength', field, options)",
"score": 0.7888683080673218
},
{
"filename": "src/errors/main.ts",
"retrieved_chunk": " * Create an instance of validation error\n */\nexport const E_VALIDATION_ERROR = ValidationError",
"score": 0.7871068716049194
},
{
"filename": "src/schema/array/rules.ts",
"retrieved_chunk": " return\n }\n /**\n * Value will always be an array if the field is valid.\n */\n if ((value as unknown[]).length <= 0) {\n field.report(messages.notEmpty, 'notEmpty', field)\n }\n})\n/**",
"score": 0.7865095138549805
}
] |
typescript
|
createError(): ValidationError {
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import { E_VALIDATION_ERROR } from '../errors/main.js'
import { ValidationError } from '../errors/validation_error.js'
import type { ErrorReporterContract, FieldContext } from '../types.js'
/**
* Shape of the error message collected by the SimpleErrorReporter
*/
type SimpleError = {
message: string
field: string
rule: string
index?: number
meta?: Record<string, any>
}
/**
* Simple error reporter collects error messages as an array of object.
* Each object has following properties.
*
* - message: string
* - field: string
* - rule: string
* - index?: number (in case of an array member)
* - args?: Record<string, any>
*/
export class SimpleErrorReporter implements ErrorReporterContract {
/**
* Boolean to know one or more errors have been reported
*/
hasErrors: boolean = false
/**
* Collection of errors
*/
errors: SimpleError[] = []
/**
* Report an error.
*/
report(
message: string,
rule: string,
field: FieldContext,
meta?: Record<string, any> | undefined
) {
const error: SimpleError = {
message,
rule,
field: field.wildCardPath,
}
if (meta) {
error.meta = meta
}
if (field.isArrayMember) {
error.index = field.name as number
}
this.hasErrors = true
this.errors.push(error)
}
/**
* Returns an instance of the validation error
*/
createError(): ValidationError {
|
return new E_VALIDATION_ERROR(this.errors)
}
|
}
|
src/reporters/simple_error_reporter.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/errors/main.ts",
"retrieved_chunk": " * Create an instance of validation error\n */\nexport const E_VALIDATION_ERROR = ValidationError",
"score": 0.868643045425415
},
{
"filename": "src/errors/validation_error.ts",
"retrieved_chunk": " */\n code: string = 'E_VALIDATION_ERROR'\n constructor(\n public messages: any,\n options?: ErrorOptions\n ) {\n super('Validation failure', options)\n const ErrorConstructor = this.constructor as typeof ValidationError\n Error.captureStackTrace(this, ErrorConstructor)\n }",
"score": 0.8424749374389648
},
{
"filename": "src/errors/validation_error.ts",
"retrieved_chunk": " * error messages\n */\nexport class ValidationError extends Error {\n /**\n * Http status code for the validation error\n */\n status: number = 422\n /**\n * Internal code for handling the validation error\n * exception",
"score": 0.8109481334686279
},
{
"filename": "src/errors/validation_error.ts",
"retrieved_chunk": "/*\n * @vinejs/vine\n *\n * (c) VineJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n/**\n * Validation error is a superset of Error class with validation",
"score": 0.8071688413619995
},
{
"filename": "src/errors/main.ts",
"retrieved_chunk": "/*\n * @vinejs/vine\n *\n * (c) VineJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\nimport { ValidationError } from './validation_error.js'\n/**",
"score": 0.8058542013168335
}
] |
typescript
|
return new E_VALIDATION_ERROR(this.errors)
}
|
/*
* vinejs
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import camelcase from 'camelcase'
import { RefsStore, ArrayNode } from '@vinejs/compiler/types'
import { BaseType } from '../base/main.js'
import { OTYPE, COTYPE, PARSE, UNIQUE_NAME, IS_OF_TYPE } from '../../symbols.js'
import type { FieldOptions, ParserOptions, SchemaTypes, Validation } from '../../types.js'
import {
compactRule,
notEmptyRule,
distinctRule,
minLengthRule,
maxLengthRule,
fixedLengthRule,
} from './rules.js'
/**
* VineArray represents an array schema type in the validation
* pipeline
*/
export class VineArray<Schema extends SchemaTypes> extends BaseType<
Schema[typeof OTYPE][],
Schema[typeof COTYPE][]
> {
/**
* Default collection of array rules
*/
static rules = {
compact: compactRule,
notEmpty: notEmptyRule,
distinct: distinctRule,
minLength: minLengthRule,
maxLength: maxLengthRule,
fixedLength: fixedLengthRule,
}
#schema: Schema;
/**
* The property must be implemented for "unionOfTypes"
*/
[UNIQUE_NAME] = 'vine.array';
/**
* Checks if the value is of array type. The method must be
* implemented for "unionOfTypes"
*/
[IS_OF_TYPE] = (value: unknown) => {
return Array.isArray(value)
}
constructor(schema: Schema, options?: FieldOptions, validations?: Validation<any>[]) {
super(options, validations)
this.#schema = schema
}
/**
* Enforce a minimum length on an array field
*/
minLength(expectedLength: number) {
return this.use(minLengthRule({ min: expectedLength }))
}
/**
* Enforce a maximum length on an array field
*/
maxLength(expectedLength: number) {
return this.use(maxLengthRule({ max: expectedLength }))
}
/**
* Enforce a fixed length on an array field
*/
fixedLength(expectedLength: number) {
return this.use(fixedLengthRule({ size: expectedLength }))
}
/**
* Ensure the array is not empty
*/
notEmpty() {
return this.use(notEmptyRule())
}
/**
* Ensure array elements are distinct/unique
*/
distinct(fields?: string | string[]) {
return this.use(distinctRule({ fields }))
}
/**
* Removes empty strings, null and undefined values from the array
*/
compact() {
return this.use(compactRule())
}
/**
* Clones the VineArray schema type. The applied options
* and validations are copied to the new instance
*/
clone(): this {
return new VineArray(this.#schema.clone(), this.cloneOptions(), this.cloneValidations()) as this
}
/**
* Compiles to array data type
*/
|
[PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): ArrayNode {
|
return {
type: 'array',
fieldName: propertyName,
propertyName: options.toCamelCase ? camelcase(propertyName) : propertyName,
bail: this.options.bail,
allowNull: this.options.allowNull,
isOptional: this.options.isOptional,
each: this.#schema[PARSE]('*', refs, options),
parseFnId: this.options.parse ? refs.trackParser(this.options.parse) : undefined,
validations: this.compileValidations(refs),
}
}
}
|
src/schema/array/main.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": " clone(): this {\n return new VineCamelCaseObject<Schema>(this.#schema.clone()) as this\n }\n /**\n * Compiles the schema type to a compiler node\n */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): ObjectNode {\n options.toCamelCase = true\n return this.#schema[PARSE](propertyName, refs, options)\n }",
"score": 0.9136086702346802
},
{
"filename": "src/schema/tuple/main.ts",
"retrieved_chunk": " }\n /**\n * Compiles to array data type\n */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): TupleNode {\n return {\n type: 'tuple',\n fieldName: propertyName,\n propertyName: options.toCamelCase ? camelcase(propertyName) : propertyName,\n bail: this.options.bail,",
"score": 0.8994742631912231
},
{
"filename": "src/schema/record/main.ts",
"retrieved_chunk": " ) as this\n }\n /**\n * Compiles to record data type\n */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): RecordNode {\n return {\n type: 'record',\n fieldName: propertyName,\n propertyName: options.toCamelCase ? camelcase(propertyName) : propertyName,",
"score": 0.8747254610061646
},
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": " /**\n * Compiles the schema type to a compiler node\n */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): ObjectNode {\n return {\n type: 'object',\n fieldName: propertyName,\n propertyName: options.toCamelCase ? camelcase(propertyName) : propertyName,\n bail: this.options.bail,\n allowNull: this.options.allowNull,",
"score": 0.8715094327926636
},
{
"filename": "src/schema/base/literal.ts",
"retrieved_chunk": " * one of the known compiler nodes\n */\n abstract [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): LiteralNode\n /**\n * The child class must implement the clone method\n */\n abstract clone(): this\n /**\n * The output value of the field. The property points to a type only\n * and not the real value.",
"score": 0.8704172968864441
}
] |
typescript
|
[PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): ArrayNode {
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import { helpers } from '../../vine/helpers.js'
import { messages } from '../../defaults.js'
import { createRule } from '../../vine/create_rule.js'
/**
* Enforce a minimum length on an array field
*/
export const minLengthRule = createRule<{ min: number }>((value, options, field) => {
/**
* Skip if the field is not valid.
*/
if (!field.isValid) {
return
}
/**
* Value will always be an array if the field is valid.
*/
if ((value as unknown[]).length < options.min) {
field.report(messages['array.minLength'], 'array.minLength', field, options)
}
})
/**
* Enforce a maximum length on an array field
*/
export const maxLengthRule = createRule<{ max: number }>((value, options, field) => {
/**
* Skip if the field is not valid.
*/
if (!field.isValid) {
return
}
/**
* Value will always be an array if the field is valid.
*/
if ((value as unknown[]).length > options.max) {
field.report(messages['array.maxLength'], 'array.maxLength', field, options)
}
})
/**
* Enforce a fixed length on an array field
*/
export const fixedLengthRule = createRule<{ size: number }>((value, options, field) => {
/**
* Skip if the field is not valid.
*/
if (!field.isValid) {
return
}
/**
* Value will always be an array if the field is valid.
*/
if ((value as unknown[]).length !== options.size) {
field.report(messages['array.fixedLength'], 'array.fixedLength', field, options)
}
})
/**
* Ensure the array is not empty
*/
export const notEmptyRule = createRule<undefined>((value, _, field) => {
/**
* Skip if the field is not valid.
*/
if (!field.isValid) {
return
}
/**
* Value will always be an array if the field is valid.
*/
if ((value as unknown[]).length <= 0) {
field.report(messages.notEmpty, 'notEmpty', field)
}
})
/**
* Ensure array elements are distinct/unique
*/
export const distinctRule = createRule<{ fields?: string | string[] }>((value, options, field) => {
/**
* Skip if the field is not valid.
*/
if (!field.isValid) {
return
}
/**
* Value will always be an array if the field is valid.
*/
|
if (!helpers.isDistinct(value as any[], options.fields)) {
|
field.report(messages.distinct, 'distinct', field, options)
}
})
/**
* Removes empty strings, null and undefined values from the array
*/
export const compactRule = createRule<undefined>((value, _, field) => {
/**
* Skip if the field is not valid.
*/
if (!field.isValid) {
return
}
field.mutate(
(value as unknown[]).filter((item) => helpers.exists(item) && item !== ''),
field
)
})
|
src/schema/array/rules.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/record/rules.ts",
"retrieved_chunk": " * Skip if the field is not valid.\n */\n if (!field.isValid) {\n return\n }\n /**\n * Value will always be an object if the field is valid.\n */\n if (Object.keys(value as Record<string, any>).length !== options.size) {\n field.report(messages['record.fixedLength'], 'record.fixedLength', field, options)",
"score": 0.9067844748497009
},
{
"filename": "src/schema/number/rules.ts",
"retrieved_chunk": " /**\n * Skip if the field is not valid.\n */\n if (!field.isValid) {\n return\n }\n if ((value as number) < options.min || (value as number) > options.max) {\n field.report(messages.range, 'range', field, options)\n }\n})",
"score": 0.8948767185211182
},
{
"filename": "src/schema/string/rules.ts",
"retrieved_chunk": " /**\n * Skip if the field is not valid.\n */\n if (!field.isValid) {\n return\n }\n const input = field.parent[options.otherField]\n /**\n * Performing validation and reporting error\n */",
"score": 0.8931382298469543
},
{
"filename": "src/schema/string/rules.ts",
"retrieved_chunk": " * Skip if the field is not valid.\n */\n if (!field.isValid) {\n return\n }\n if ((value as string).length !== options.size) {\n field.report(messages.fixedLength, 'fixedLength', field, options)\n }\n})\n/**",
"score": 0.8796097040176392
},
{
"filename": "src/schema/string/rules.ts",
"retrieved_chunk": " if (!field.isValid) {\n return\n }\n const providers = options\n ? typeof options === 'function'\n ? options(field)?.provider || []\n : options.provider\n : []\n if (!providers.length) {\n if (!helpers.isCreditCard(value as string)) {",
"score": 0.8621017932891846
}
] |
typescript
|
if (!helpers.isDistinct(value as any[], options.fields)) {
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import { E_VALIDATION_ERROR } from '../errors/main.js'
import { ValidationError } from '../errors/validation_error.js'
import type { ErrorReporterContract, FieldContext } from '../types.js'
/**
* Shape of the error message collected by the SimpleErrorReporter
*/
type SimpleError = {
message: string
field: string
rule: string
index?: number
meta?: Record<string, any>
}
/**
* Simple error reporter collects error messages as an array of object.
* Each object has following properties.
*
* - message: string
* - field: string
* - rule: string
* - index?: number (in case of an array member)
* - args?: Record<string, any>
*/
export class SimpleErrorReporter implements ErrorReporterContract {
/**
* Boolean to know one or more errors have been reported
*/
hasErrors: boolean = false
/**
* Collection of errors
*/
errors: SimpleError[] = []
/**
* Report an error.
*/
report(
message: string,
rule: string,
|
field: FieldContext,
meta?: Record<string, any> | undefined
) {
|
const error: SimpleError = {
message,
rule,
field: field.wildCardPath,
}
if (meta) {
error.meta = meta
}
if (field.isArrayMember) {
error.index = field.name as number
}
this.hasErrors = true
this.errors.push(error)
}
/**
* Returns an instance of the validation error
*/
createError(): ValidationError {
return new E_VALIDATION_ERROR(this.errors)
}
}
|
src/reporters/simple_error_reporter.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/types.ts",
"retrieved_chunk": " */\n errorReporter?: () => ErrorReporterContract\n} & ([undefined] extends MetaData\n ? {\n meta?: MetaData\n }\n : {\n meta: MetaData\n })\n/**",
"score": 0.8033609986305237
},
{
"filename": "src/types.ts",
"retrieved_chunk": "export interface ErrorReporterContract extends BaseReporter {\n createError(): ValidationError\n}\n/**\n * The validator function to validate metadata given to a validation\n * pipeline\n */\nexport type MetaDataValidator = (meta: Record<string, any>) => void\n/**\n * Options accepted during the validate call.",
"score": 0.8015638589859009
},
{
"filename": "src/schema/array/rules.ts",
"retrieved_chunk": " * Value will always be an array if the field is valid.\n */\n if (!helpers.isDistinct(value as any[], options.fields)) {\n field.report(messages.distinct, 'distinct', field, options)\n }\n})\n/**\n * Removes empty strings, null and undefined values from the array\n */\nexport const compactRule = createRule<undefined>((value, _, field) => {",
"score": 0.789939284324646
},
{
"filename": "src/schema/string/rules.ts",
"retrieved_chunk": " */\nexport const stringRule = createRule((value, _, field) => {\n if (typeof value !== 'string') {\n field.report(messages.string, 'string', field)\n }\n})\n/**\n * Validates the value to be a valid email address\n */\nexport const emailRule = createRule<EmailOptions | undefined>((value, options, field) => {",
"score": 0.7896206378936768
},
{
"filename": "src/types.ts",
"retrieved_chunk": " field: FieldContext\n) => any | Promise<any>\n/**\n * A validation rule is a combination of a validator and\n * some metadata required at the time of compiling the\n * rule.\n *\n * Think of this type as \"Validator\" + \"metaData\"\n */\nexport type ValidationRule<Options extends any> = {",
"score": 0.7881597876548767
}
] |
typescript
|
field: FieldContext,
meta?: Record<string, any> | undefined
) {
|
/*
* vinejs
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import camelcase from 'camelcase'
import { RefsStore, ArrayNode } from '@vinejs/compiler/types'
import { BaseType } from '../base/main.js'
import { OTYPE, COTYPE, PARSE, UNIQUE_NAME, IS_OF_TYPE } from '../../symbols.js'
import type { FieldOptions, ParserOptions, SchemaTypes, Validation } from '../../types.js'
import {
compactRule,
notEmptyRule,
distinctRule,
minLengthRule,
maxLengthRule,
fixedLengthRule,
} from './rules.js'
/**
* VineArray represents an array schema type in the validation
* pipeline
*/
export class VineArray<Schema extends SchemaTypes> extends BaseType<
Schema[typeof OTYPE][],
Schema[typeof COTYPE][]
> {
/**
* Default collection of array rules
*/
static rules = {
compact: compactRule,
notEmpty: notEmptyRule,
distinct: distinctRule,
minLength: minLengthRule,
maxLength: maxLengthRule,
fixedLength: fixedLengthRule,
}
#schema: Schema;
/**
* The property must be implemented for "unionOfTypes"
*/
[UNIQUE_NAME] = 'vine.array';
/**
* Checks if the value is of array type. The method must be
* implemented for "unionOfTypes"
*/
[IS_OF_TYPE] = (value: unknown) => {
return Array.isArray(value)
}
constructor(schema: Schema, options?: FieldOptions, validations?: Validation<any>[]) {
super(options, validations)
this.#schema = schema
}
/**
* Enforce a minimum length on an array field
*/
minLength(expectedLength: number) {
return this.use(minLengthRule({ min: expectedLength }))
}
/**
* Enforce a maximum length on an array field
*/
maxLength(expectedLength: number) {
return this.use(maxLengthRule({ max: expectedLength }))
}
/**
* Enforce a fixed length on an array field
*/
fixedLength(expectedLength: number) {
return this.use(fixedLengthRule({ size: expectedLength }))
}
/**
* Ensure the array is not empty
*/
notEmpty() {
return this.use(notEmptyRule())
}
/**
* Ensure array elements are distinct/unique
*/
distinct(fields?: string | string[]) {
return this.use(distinctRule({ fields }))
}
/**
* Removes empty strings, null and undefined values from the array
*/
compact() {
return this.use(compactRule())
}
/**
* Clones the VineArray schema type. The applied options
* and validations are copied to the new instance
*/
clone(): this {
return new VineArray(this.#schema.clone(), this.cloneOptions(), this.cloneValidations()) as this
}
/**
* Compiles to array data type
*/
[
|
PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): ArrayNode {
|
return {
type: 'array',
fieldName: propertyName,
propertyName: options.toCamelCase ? camelcase(propertyName) : propertyName,
bail: this.options.bail,
allowNull: this.options.allowNull,
isOptional: this.options.isOptional,
each: this.#schema[PARSE]('*', refs, options),
parseFnId: this.options.parse ? refs.trackParser(this.options.parse) : undefined,
validations: this.compileValidations(refs),
}
}
}
|
src/schema/array/main.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": " clone(): this {\n return new VineCamelCaseObject<Schema>(this.#schema.clone()) as this\n }\n /**\n * Compiles the schema type to a compiler node\n */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): ObjectNode {\n options.toCamelCase = true\n return this.#schema[PARSE](propertyName, refs, options)\n }",
"score": 0.9093783497810364
},
{
"filename": "src/schema/tuple/main.ts",
"retrieved_chunk": " }\n /**\n * Compiles to array data type\n */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): TupleNode {\n return {\n type: 'tuple',\n fieldName: propertyName,\n propertyName: options.toCamelCase ? camelcase(propertyName) : propertyName,\n bail: this.options.bail,",
"score": 0.9017425179481506
},
{
"filename": "src/schema/record/main.ts",
"retrieved_chunk": " ) as this\n }\n /**\n * Compiles to record data type\n */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): RecordNode {\n return {\n type: 'record',\n fieldName: propertyName,\n propertyName: options.toCamelCase ? camelcase(propertyName) : propertyName,",
"score": 0.8752214908599854
},
{
"filename": "src/schema/base/literal.ts",
"retrieved_chunk": " * one of the known compiler nodes\n */\n abstract [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): LiteralNode\n /**\n * The child class must implement the clone method\n */\n abstract clone(): this\n /**\n * The output value of the field. The property points to a type only\n * and not the real value.",
"score": 0.8695588707923889
},
{
"filename": "src/schema/base/main.ts",
"retrieved_chunk": " abstract [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): CompilerNodes\n /**\n * The child class must implement the clone method\n */\n abstract clone(): this\n /**\n * The output value of the field. The property points to a type only\n * and not the real value.\n */\n declare [OTYPE]: Output;",
"score": 0.866206705570221
}
] |
typescript
|
PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): ArrayNode {
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import { helpers } from '../../vine/helpers.js'
import { messages } from '../../defaults.js'
import { createRule } from '../../vine/create_rule.js'
/**
* Enforce a minimum length on an array field
*/
export const minLengthRule = createRule<{ min: number }>((value, options, field) => {
/**
* Skip if the field is not valid.
*/
if (!field.isValid) {
return
}
/**
* Value will always be an array if the field is valid.
*/
if ((value as unknown[]).length < options.min) {
field.report(messages['array.minLength'], 'array.minLength', field, options)
}
})
/**
* Enforce a maximum length on an array field
*/
export const maxLengthRule = createRule<{ max: number }>((value, options, field) => {
/**
* Skip if the field is not valid.
*/
if (!field.isValid) {
return
}
/**
* Value will always be an array if the field is valid.
*/
if ((value as unknown[]).length > options.max) {
field.report(messages['array.maxLength'], 'array.maxLength', field, options)
}
})
/**
* Enforce a fixed length on an array field
*/
export const fixedLengthRule = createRule<{ size: number }>((value, options, field) => {
/**
* Skip if the field is not valid.
*/
if (!field.isValid) {
return
}
/**
* Value will always be an array if the field is valid.
*/
if ((value as unknown[]).length !== options.size) {
field.report(messages['array.fixedLength'], 'array.fixedLength', field, options)
}
})
/**
* Ensure the array is not empty
*/
|
export const notEmptyRule = createRule<undefined>((value, _, field) => {
|
/**
* Skip if the field is not valid.
*/
if (!field.isValid) {
return
}
/**
* Value will always be an array if the field is valid.
*/
if ((value as unknown[]).length <= 0) {
field.report(messages.notEmpty, 'notEmpty', field)
}
})
/**
* Ensure array elements are distinct/unique
*/
export const distinctRule = createRule<{ fields?: string | string[] }>((value, options, field) => {
/**
* Skip if the field is not valid.
*/
if (!field.isValid) {
return
}
/**
* Value will always be an array if the field is valid.
*/
if (!helpers.isDistinct(value as any[], options.fields)) {
field.report(messages.distinct, 'distinct', field, options)
}
})
/**
* Removes empty strings, null and undefined values from the array
*/
export const compactRule = createRule<undefined>((value, _, field) => {
/**
* Skip if the field is not valid.
*/
if (!field.isValid) {
return
}
field.mutate(
(value as unknown[]).filter((item) => helpers.exists(item) && item !== ''),
field
)
})
|
src/schema/array/rules.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/number/rules.ts",
"retrieved_chunk": " return\n }\n if ((value as number) > options.max) {\n field.report(messages.max, 'max', field, options)\n }\n})\n/**\n * Enforce a range of values on a number field.\n */\nexport const rangeRule = createRule<{ min: number; max: number }>((value, options, field) => {",
"score": 0.8790554404258728
},
{
"filename": "src/schema/string/rules.ts",
"retrieved_chunk": " }\n if ((value as string).length > options.max) {\n field.report(messages.maxLength, 'maxLength', field, options)\n }\n})\n/**\n * Enforce a fixed length on a string field\n */\nexport const fixedLengthRule = createRule<{ size: number }>((value, options, field) => {\n /**",
"score": 0.8786916732788086
},
{
"filename": "src/schema/record/rules.ts",
"retrieved_chunk": " * Skip if the field is not valid.\n */\n if (!field.isValid) {\n return\n }\n /**\n * Value will always be an object if the field is valid.\n */\n if (Object.keys(value as Record<string, any>).length !== options.size) {\n field.report(messages['record.fixedLength'], 'record.fixedLength', field, options)",
"score": 0.8784307837486267
},
{
"filename": "src/schema/record/rules.ts",
"retrieved_chunk": " */\n if (Object.keys(value as Record<string, any>).length > options.max) {\n field.report(messages['record.maxLength'], 'record.maxLength', field, options)\n }\n})\n/**\n * Enforce a fixed length on an object field\n */\nexport const fixedLengthRule = createRule<{ size: number }>((value, options, field) => {\n /**",
"score": 0.8767324686050415
},
{
"filename": "src/schema/string/rules.ts",
"retrieved_chunk": " */\n if (input !== value) {\n field.report(messages.sameAs, 'sameAs', field, options)\n return\n }\n})\n/**\n * Ensure the field's value under validation is different from another field's value\n */\nexport const notSameAsRule = createRule<{ otherField: string }>((value, options, field) => {",
"score": 0.8765508532524109
}
] |
typescript
|
export const notEmptyRule = createRule<undefined>((value, _, field) => {
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import type { CompilerNodes, RefsStore } from '@vinejs/compiler/types'
import { OTYPE, COTYPE, PARSE, VALIDATION } from '../../symbols.js'
import type {
Parser,
Validation,
RuleBuilder,
FieldOptions,
ParserOptions,
ConstructableSchema,
} from '../../types.js'
import Macroable from '@poppinss/macroable'
/**
* Base schema type with only modifiers applicable on all the schema types.
*/
export abstract class BaseModifiersType<Output, CamelCaseOutput>
extends Macroable
implements ConstructableSchema<Output, CamelCaseOutput>
{
/**
* Each subtype should implement the compile method that returns
* one of the known compiler nodes
*/
abstract [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): CompilerNodes
/**
* The child class must implement the clone method
*/
abstract clone(): this
/**
* The output value of the field. The property points to a type only
* and not the real value.
*/
declare [OTYPE]: Output;
declare [COTYPE]: CamelCaseOutput
/**
* Mark the field under validation as optional. An optional
* field allows both null and undefined values.
*/
optional(): OptionalModifier<this> {
return new OptionalModifier(this)
}
/**
* Mark the field under validation to be null. The null value will
* be written to the output as well.
*
* If `optional` and `nullable` are used together, then both undefined
* and null values will be allowed.
*/
nullable(): NullableModifier<this> {
return new NullableModifier(this)
}
}
/**
* Modifies the schema type to allow null values
*/
class NullableModifier<Schema extends BaseModifiersType<any, any>> extends BaseModifiersType<
Schema[typeof OTYPE] | null,
Schema[typeof COTYPE] | null
> {
#parent: Schema
constructor(parent: Schema) {
super()
this.#parent = parent
}
/**
* Creates a fresh instance of the underlying schema type
* and wraps it inside the nullable modifier
*/
clone(): this {
return new NullableModifier(this.#parent.clone()) as this
}
/**
* Compiles to compiler node
*/
[PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): CompilerNodes {
|
const output = this.#parent[PARSE](propertyName, refs, options)
if (output.type !== 'union') {
|
output.allowNull = true
}
return output
}
}
/**
* Modifies the schema type to allow undefined values
*/
class OptionalModifier<Schema extends BaseModifiersType<any, any>> extends BaseModifiersType<
Schema[typeof OTYPE] | undefined,
Schema[typeof COTYPE] | undefined
> {
#parent: Schema
constructor(parent: Schema) {
super()
this.#parent = parent
}
/**
* Creates a fresh instance of the underlying schema type
* and wraps it inside the optional modifier
*/
clone(): this {
return new OptionalModifier(this.#parent.clone()) as this
}
/**
* Compiles to compiler node
*/
[PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): CompilerNodes {
const output = this.#parent[PARSE](propertyName, refs, options)
if (output.type !== 'union') {
output.isOptional = true
}
return output
}
}
/**
* The BaseSchema class abstracts the repetitive parts of creating
* a custom schema type.
*/
export abstract class BaseType<Output, CamelCaseOutput> extends BaseModifiersType<
Output,
CamelCaseOutput
> {
/**
* Field options
*/
protected options: FieldOptions
/**
* Set of validations to run
*/
protected validations: Validation<any>[]
constructor(options?: FieldOptions, validations?: Validation<any>[]) {
super()
this.options = options || {
bail: true,
allowNull: false,
isOptional: false,
}
this.validations = validations || []
}
/**
* Shallow clones the validations. Since, there are no API's to mutate
* the validation options, we can safely copy them by reference.
*/
protected cloneValidations(): Validation<any>[] {
return this.validations.map((validation) => {
return {
options: validation.options,
rule: validation.rule,
}
})
}
/**
* Shallow clones the options
*/
protected cloneOptions(): FieldOptions {
return { ...this.options }
}
/**
* Compiles validations
*/
protected compileValidations(refs: RefsStore) {
return this.validations.map((validation) => {
return {
ruleFnId: refs.track({
validator: validation.rule.validator,
options: validation.options,
}),
implicit: validation.rule.implicit,
isAsync: validation.rule.isAsync,
}
})
}
/**
* Define a method to parse the input value. The method
* is invoked before any validation and hence you must
* perform type-checking to know the value you are
* working it.
*/
parse(callback: Parser): this {
this.options.parse = callback
return this
}
/**
* Push a validation to the validations chain.
*/
use(validation: Validation<any> | RuleBuilder): this {
this.validations.push(VALIDATION in validation ? validation[VALIDATION]() : validation)
return this
}
/**
* Enable/disable the bail mode. In bail mode, the field validations
* are stopped after the first error.
*/
bail(state: boolean) {
this.options.bail = state
return this
}
}
|
src/schema/base/main.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/base/literal.ts",
"retrieved_chunk": " clone(): this {\n return new TransformModifier(this.#transform, this.#parent.clone()) as this\n }\n /**\n * Compiles to compiler node\n */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): LiteralNode {\n const output = this.#parent[PARSE](propertyName, refs, options)\n output.transformFnId = refs.trackTransformer(this.#transform)\n return output",
"score": 0.9206710457801819
},
{
"filename": "src/schema/base/literal.ts",
"retrieved_chunk": " * Compiles to compiler node\n */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): LiteralNode {\n const output = this.#parent[PARSE](propertyName, refs, options)\n output.allowNull = true\n return output\n }\n}\n/**\n * Modifies the schema type to allow undefined values",
"score": 0.8990834355354309
},
{
"filename": "src/schema/union/main.ts",
"retrieved_chunk": " }\n /**\n * Compiles to a union\n */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): UnionNode {\n return {\n type: 'union',\n fieldName: propertyName,\n propertyName: options.toCamelCase ? camelcase(propertyName) : propertyName,\n elseConditionalFnRefId: refs.trackConditional(this.#otherwiseCallback),",
"score": 0.8940061330795288
},
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": " clone(): this {\n return new VineCamelCaseObject<Schema>(this.#schema.clone()) as this\n }\n /**\n * Compiles the schema type to a compiler node\n */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): ObjectNode {\n options.toCamelCase = true\n return this.#schema[PARSE](propertyName, refs, options)\n }",
"score": 0.8935307264328003
},
{
"filename": "src/schema/base/literal.ts",
"retrieved_chunk": " * one of the known compiler nodes\n */\n abstract [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): LiteralNode\n /**\n * The child class must implement the clone method\n */\n abstract clone(): this\n /**\n * The output value of the field. The property points to a type only\n * and not the real value.",
"score": 0.8880295753479004
}
] |
typescript
|
const output = this.#parent[PARSE](propertyName, refs, options)
if (output.type !== 'union') {
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import Macroable from '@poppinss/macroable'
import { VineAny } from './any/main.js'
import { VineEnum } from './enum/main.js'
import { union } from './union/builder.js'
import { VineTuple } from './tuple/main.js'
import { VineArray } from './array/main.js'
import { VineObject } from './object/main.js'
import { VineRecord } from './record/main.js'
import { VineString } from './string/main.js'
import { VineNumber } from './number/main.js'
import { VineBoolean } from './boolean/main.js'
import { VineLiteral } from './literal/main.js'
import { CamelCase } from './camelcase_types.js'
import { VineAccepted } from './accepted/main.js'
import { group } from './object/group_builder.js'
import { VineNativeEnum } from './enum/native_enum.js'
import { VineUnionOfTypes } from './union_of_types/main.js'
import { OTYPE, COTYPE, IS_OF_TYPE, UNIQUE_NAME } from '../symbols.js'
import type { EnumLike, FieldContext, SchemaTypes } from '../types.js'
/**
* Schema builder exposes methods to construct a Vine schema. You may
* add custom methods to it using macros.
*/
export class SchemaBuilder extends Macroable {
/**
* Define a sub-object as a union
*/
group = group
/**
* Define a union value
*/
union = union
/**
* Define a string value
*/
string() {
return new VineString()
}
/**
* Define a boolean value
*/
boolean(options?: { strict: boolean }) {
return new VineBoolean(options)
}
/**
* Validate a checkbox to be checked
*/
accepted() {
return new VineAccepted()
}
/**
* Define a number value
*/
number(options?: { strict: boolean }) {
return new VineNumber(options)
}
/**
* Define a schema type in which the input value
* matches the pre-defined value
*/
literal<const Value>(value: Value) {
return new VineLiteral<Value>(value)
}
/**
* Define an object with known properties. You may call "allowUnknownProperties"
* to merge unknown properties.
*/
|
object<Properties extends Record<string, SchemaTypes>>(properties: Properties) {
|
return new VineObject<
Properties,
{
[K in keyof Properties]: Properties[K][typeof OTYPE]
},
{
[K in keyof Properties as CamelCase<K & string>]: Properties[K][typeof COTYPE]
}
>(properties)
}
/**
* Define an array field and validate its children elements.
*/
array<Schema extends SchemaTypes>(schema: Schema) {
return new VineArray<Schema>(schema)
}
/**
* Define an array field with known length and each children
* element may have its own schema.
*/
tuple<Schema extends SchemaTypes[]>(schemas: [...Schema]) {
return new VineTuple<
Schema,
{ [K in keyof Schema]: Schema[K][typeof OTYPE] },
{ [K in keyof Schema]: Schema[K][typeof COTYPE] }
>(schemas)
}
/**
* Define an object field with key-value pair. The keys in
* a record are unknown and values can be of a specific
* schema type.
*/
record<Schema extends SchemaTypes>(schema: Schema) {
return new VineRecord<Schema>(schema)
}
/**
* Define a field whose value matches the enum choices.
*/
enum<const Values extends readonly unknown[]>(
values: Values | ((field: FieldContext) => Values)
): VineEnum<Values>
enum<Values extends EnumLike>(values: Values): VineNativeEnum<Values>
enum<Values extends readonly unknown[] | EnumLike>(values: Values): any {
if (Array.isArray(values) || typeof values === 'function') {
return new VineEnum(values)
}
return new VineNativeEnum(values as EnumLike)
}
/**
* Allow the field value to be anything
*/
any() {
return new VineAny()
}
/**
* Define a union of unique schema types.
*/
unionOfTypes<Schema extends SchemaTypes>(schemas: Schema[]) {
const schemasInUse: Set<string> = new Set()
schemas.forEach((schema) => {
if (!schema[IS_OF_TYPE] || !schema[UNIQUE_NAME]) {
throw new Error(
`Cannot use "${schema.constructor.name}". The schema type is not compatible for use with "vine.unionOfTypes"`
)
}
if (schemasInUse.has(schema[UNIQUE_NAME])) {
throw new Error(
`Cannot use duplicate schema "${schema[UNIQUE_NAME]}". "vine.unionOfTypes" needs distinct schema types only`
)
}
schemasInUse.add(schema[UNIQUE_NAME])
})
schemasInUse.clear()
return new VineUnionOfTypes(schemas)
}
}
|
src/schema/builder.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/literal/main.ts",
"retrieved_chunk": " }\n #value: Value\n constructor(value: Value, options?: FieldOptions, validations?: Validation<any>[]) {\n super(options, validations || [equalsRule({ expectedValue: value })])\n this.#value = value\n }\n /**\n * Clones the VineLiteral schema type. The applied options\n * and validations are copied to the new instance\n */",
"score": 0.8646387457847595
},
{
"filename": "src/schema/literal/main.ts",
"retrieved_chunk": "import type { FieldOptions, Validation } from '../../types.js'\n/**\n * VineLiteral represents a type that matches an exact value\n */\nexport class VineLiteral<Value> extends BaseLiteralType<Value, Value> {\n /**\n * Default collection of literal rules\n */\n static rules = {\n equals: equalsRule,",
"score": 0.8514704704284668
},
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": "}\n/**\n * VineObject represents an object value in the validation\n * schema.\n */\nexport class VineObject<\n Properties extends Record<string, SchemaTypes>,\n Output,\n CamelCaseOutput,\n> extends BaseType<Output, CamelCaseOutput> {",
"score": 0.8497581481933594
},
{
"filename": "src/schema/literal/main.ts",
"retrieved_chunk": " clone(): this {\n return new VineLiteral(this.#value, this.cloneOptions(), this.cloneValidations()) as this\n }\n}",
"score": 0.8367170691490173
},
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": " /**\n * Copy unknown properties to the final output.\n */\n allowUnknownProperties<Value>(): VineObject<\n Properties,\n Output & { [K: string]: Value },\n CamelCaseOutput & { [K: string]: Value }\n > {\n this.#allowUnknownProperties = true\n return this as VineObject<",
"score": 0.8267894387245178
}
] |
typescript
|
object<Properties extends Record<string, SchemaTypes>>(properties: Properties) {
|
/*
* vinejs
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import camelcase from 'camelcase'
import Macroable from '@poppinss/macroable'
import type { LiteralNode, RefsStore } from '@vinejs/compiler/types'
import { OTYPE, COTYPE, PARSE, VALIDATION } from '../../symbols.js'
import type {
Parser,
Validation,
RuleBuilder,
Transformer,
FieldOptions,
ParserOptions,
ConstructableSchema,
} from '../../types.js'
/**
* Base schema type with only modifiers applicable on all the schema types.
*/
abstract class BaseModifiersType<Output, CamelCaseOutput>
extends Macroable
implements ConstructableSchema<Output, CamelCaseOutput>
{
/**
* Each subtype should implement the compile method that returns
* one of the known compiler nodes
*/
abstract [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): LiteralNode
/**
* The child class must implement the clone method
*/
abstract clone(): this
/**
* The output value of the field. The property points to a type only
* and not the real value.
*/
declare [OTYPE]: Output;
declare [COTYPE]: CamelCaseOutput
/**
* Mark the field under validation as optional. An optional
* field allows both null and undefined values.
*/
optional(): OptionalModifier<this> {
return new OptionalModifier(this)
}
/**
* Mark the field under validation to be null. The null value will
* be written to the output as well.
*
* If `optional` and `nullable` are used together, then both undefined
* and null values will be allowed.
*/
nullable(): NullableModifier<this> {
return new NullableModifier(this)
}
/**
* Apply transform on the final validated value. The transform method may
* convert the value to any new datatype.
*/
transform<TransformedOutput>(
transformer: Transformer<this, TransformedOutput>
): TransformModifier<this, TransformedOutput> {
return new TransformModifier(transformer, this)
}
}
/**
* Modifies the schema type to allow null values
*/
class NullableModifier<Schema extends BaseModifiersType<any, any>> extends BaseModifiersType<
Schema[typeof OTYPE] | null,
Schema[typeof COTYPE] | null
> {
#parent: Schema
constructor(parent: Schema) {
super()
this.#parent = parent
}
/**
* Creates a fresh instance of the underlying schema type
* and wraps it inside the nullable modifier
*/
clone(): this {
return new NullableModifier(this.#parent.clone()) as this
}
/**
* Compiles to compiler node
*/
[PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): LiteralNode {
const
|
output = this.#parent[PARSE](propertyName, refs, options)
output.allowNull = true
return output
}
|
}
/**
* Modifies the schema type to allow undefined values
*/
class OptionalModifier<Schema extends BaseModifiersType<any, any>> extends BaseModifiersType<
Schema[typeof OTYPE] | undefined,
Schema[typeof COTYPE] | undefined
> {
#parent: Schema
constructor(parent: Schema) {
super()
this.#parent = parent
}
/**
* Creates a fresh instance of the underlying schema type
* and wraps it inside the optional modifier
*/
clone(): this {
return new OptionalModifier(this.#parent.clone()) as this
}
/**
* Compiles to compiler node
*/
[PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): LiteralNode {
const output = this.#parent[PARSE](propertyName, refs, options)
output.isOptional = true
return output
}
}
/**
* Modifies the schema type to allow custom transformed values
*/
class TransformModifier<
Schema extends BaseModifiersType<any, any>,
Output,
> extends BaseModifiersType<Output, Output> {
/**
* The output value of the field. The property points to a type only
* and not the real value.
*/
declare [OTYPE]: Output;
declare [COTYPE]: Output
#parent: Schema
#transform: Transformer<Schema, Output>
constructor(transform: Transformer<Schema, Output>, parent: Schema) {
super()
this.#transform = transform
this.#parent = parent
}
/**
* Creates a fresh instance of the underlying schema type
* and wraps it inside the transform modifier.
*/
clone(): this {
return new TransformModifier(this.#transform, this.#parent.clone()) as this
}
/**
* Compiles to compiler node
*/
[PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): LiteralNode {
const output = this.#parent[PARSE](propertyName, refs, options)
output.transformFnId = refs.trackTransformer(this.#transform)
return output
}
}
/**
* The base type for creating a custom literal type. Literal type
* is a schema type that has no children elements.
*/
export abstract class BaseLiteralType<Output, CamelCaseOutput> extends BaseModifiersType<
Output,
CamelCaseOutput
> {
/**
* The child class must implement the clone method
*/
abstract clone(): this
/**
* Field options
*/
protected options: FieldOptions
/**
* Set of validations to run
*/
protected validations: Validation<any>[]
constructor(options?: Partial<FieldOptions>, validations?: Validation<any>[]) {
super()
this.options = {
bail: true,
allowNull: false,
isOptional: false,
...options,
}
this.validations = validations || []
}
/**
* Shallow clones the validations. Since, there are no API's to mutate
* the validation options, we can safely copy them by reference.
*/
protected cloneValidations(): Validation<any>[] {
return this.validations.map((validation) => {
return {
options: validation.options,
rule: validation.rule,
}
})
}
/**
* Shallow clones the options
*/
protected cloneOptions(): FieldOptions {
return { ...this.options }
}
/**
* Compiles validations
*/
protected compileValidations(refs: RefsStore) {
return this.validations.map((validation) => {
return {
ruleFnId: refs.track({
validator: validation.rule.validator,
options: validation.options,
}),
implicit: validation.rule.implicit,
isAsync: validation.rule.isAsync,
}
})
}
/**
* Define a method to parse the input value. The method
* is invoked before any validation and hence you must
* perform type-checking to know the value you are
* working it.
*/
parse(callback: Parser): this {
this.options.parse = callback
return this
}
/**
* Push a validation to the validations chain.
*/
use(validation: Validation<any> | RuleBuilder): this {
this.validations.push(VALIDATION in validation ? validation[VALIDATION]() : validation)
return this
}
/**
* Enable/disable the bail mode. In bail mode, the field validations
* are stopped after the first error.
*/
bail(state: boolean) {
this.options.bail = state
return this
}
/**
* Compiles the schema type to a compiler node
*/
[PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): LiteralNode {
return {
type: 'literal',
fieldName: propertyName,
propertyName: options.toCamelCase ? camelcase(propertyName) : propertyName,
bail: this.options.bail,
allowNull: this.options.allowNull,
isOptional: this.options.isOptional,
parseFnId: this.options.parse ? refs.trackParser(this.options.parse) : undefined,
validations: this.compileValidations(refs),
}
}
}
|
src/schema/base/literal.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/base/main.ts",
"retrieved_chunk": " */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): CompilerNodes {\n const output = this.#parent[PARSE](propertyName, refs, options)\n if (output.type !== 'union') {\n output.allowNull = true\n }\n return output\n }\n}\n/**",
"score": 0.948992133140564
},
{
"filename": "src/schema/base/main.ts",
"retrieved_chunk": " */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): CompilerNodes {\n const output = this.#parent[PARSE](propertyName, refs, options)\n if (output.type !== 'union') {\n output.isOptional = true\n }\n return output\n }\n}\n/**",
"score": 0.9389203190803528
},
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": " /**\n * Compiles the schema type to a compiler node\n */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): ObjectNode {\n return {\n type: 'object',\n fieldName: propertyName,\n propertyName: options.toCamelCase ? camelcase(propertyName) : propertyName,\n bail: this.options.bail,\n allowNull: this.options.allowNull,",
"score": 0.9176764488220215
},
{
"filename": "src/schema/array/main.ts",
"retrieved_chunk": " * Compiles to array data type\n */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): ArrayNode {\n return {\n type: 'array',\n fieldName: propertyName,\n propertyName: options.toCamelCase ? camelcase(propertyName) : propertyName,\n bail: this.options.bail,\n allowNull: this.options.allowNull,\n isOptional: this.options.isOptional,",
"score": 0.9132219552993774
},
{
"filename": "src/schema/union/main.ts",
"retrieved_chunk": " }\n /**\n * Compiles to a union\n */\n [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): UnionNode {\n return {\n type: 'union',\n fieldName: propertyName,\n propertyName: options.toCamelCase ? camelcase(propertyName) : propertyName,\n elseConditionalFnRefId: refs.trackConditional(this.#otherwiseCallback),",
"score": 0.9126893281936646
}
] |
typescript
|
output = this.#parent[PARSE](propertyName, refs, options)
output.allowNull = true
return output
}
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import Macroable from '@poppinss/macroable'
import { VineAny } from './any/main.js'
import { VineEnum } from './enum/main.js'
import { union } from './union/builder.js'
import { VineTuple } from './tuple/main.js'
import { VineArray } from './array/main.js'
import { VineObject } from './object/main.js'
import { VineRecord } from './record/main.js'
import { VineString } from './string/main.js'
import { VineNumber } from './number/main.js'
import { VineBoolean } from './boolean/main.js'
import { VineLiteral } from './literal/main.js'
import { CamelCase } from './camelcase_types.js'
import { VineAccepted } from './accepted/main.js'
import { group } from './object/group_builder.js'
import { VineNativeEnum } from './enum/native_enum.js'
import { VineUnionOfTypes } from './union_of_types/main.js'
import { OTYPE, COTYPE, IS_OF_TYPE, UNIQUE_NAME } from '../symbols.js'
import type { EnumLike, FieldContext, SchemaTypes } from '../types.js'
/**
* Schema builder exposes methods to construct a Vine schema. You may
* add custom methods to it using macros.
*/
export class SchemaBuilder extends Macroable {
/**
* Define a sub-object as a union
*/
group = group
/**
* Define a union value
*/
union = union
/**
* Define a string value
*/
string() {
return new VineString()
}
/**
* Define a boolean value
*/
boolean(options?: { strict: boolean }) {
return new VineBoolean(options)
}
/**
* Validate a checkbox to be checked
*/
accepted() {
return new VineAccepted()
}
/**
* Define a number value
*/
number(options?: { strict: boolean }) {
|
return new VineNumber(options)
}
|
/**
* Define a schema type in which the input value
* matches the pre-defined value
*/
literal<const Value>(value: Value) {
return new VineLiteral<Value>(value)
}
/**
* Define an object with known properties. You may call "allowUnknownProperties"
* to merge unknown properties.
*/
object<Properties extends Record<string, SchemaTypes>>(properties: Properties) {
return new VineObject<
Properties,
{
[K in keyof Properties]: Properties[K][typeof OTYPE]
},
{
[K in keyof Properties as CamelCase<K & string>]: Properties[K][typeof COTYPE]
}
>(properties)
}
/**
* Define an array field and validate its children elements.
*/
array<Schema extends SchemaTypes>(schema: Schema) {
return new VineArray<Schema>(schema)
}
/**
* Define an array field with known length and each children
* element may have its own schema.
*/
tuple<Schema extends SchemaTypes[]>(schemas: [...Schema]) {
return new VineTuple<
Schema,
{ [K in keyof Schema]: Schema[K][typeof OTYPE] },
{ [K in keyof Schema]: Schema[K][typeof COTYPE] }
>(schemas)
}
/**
* Define an object field with key-value pair. The keys in
* a record are unknown and values can be of a specific
* schema type.
*/
record<Schema extends SchemaTypes>(schema: Schema) {
return new VineRecord<Schema>(schema)
}
/**
* Define a field whose value matches the enum choices.
*/
enum<const Values extends readonly unknown[]>(
values: Values | ((field: FieldContext) => Values)
): VineEnum<Values>
enum<Values extends EnumLike>(values: Values): VineNativeEnum<Values>
enum<Values extends readonly unknown[] | EnumLike>(values: Values): any {
if (Array.isArray(values) || typeof values === 'function') {
return new VineEnum(values)
}
return new VineNativeEnum(values as EnumLike)
}
/**
* Allow the field value to be anything
*/
any() {
return new VineAny()
}
/**
* Define a union of unique schema types.
*/
unionOfTypes<Schema extends SchemaTypes>(schemas: Schema[]) {
const schemasInUse: Set<string> = new Set()
schemas.forEach((schema) => {
if (!schema[IS_OF_TYPE] || !schema[UNIQUE_NAME]) {
throw new Error(
`Cannot use "${schema.constructor.name}". The schema type is not compatible for use with "vine.unionOfTypes"`
)
}
if (schemasInUse.has(schema[UNIQUE_NAME])) {
throw new Error(
`Cannot use duplicate schema "${schema[UNIQUE_NAME]}". "vine.unionOfTypes" needs distinct schema types only`
)
}
schemasInUse.add(schema[UNIQUE_NAME])
})
schemasInUse.clear()
return new VineUnionOfTypes(schemas)
}
}
|
src/schema/builder.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/number/main.ts",
"retrieved_chunk": " }\n /**\n * Clones the VineNumber schema type. The applied options\n * and validations are copied to the new instance\n */\n clone(): this {\n return new VineNumber(this.cloneOptions(), this.cloneValidations()) as this\n }\n}",
"score": 0.8634393215179443
},
{
"filename": "src/schema/number/main.ts",
"retrieved_chunk": " withoutDecimalsRule,\n} from './rules.js'\n/**\n * VineNumber represents a numeric value in the validation schema.\n */\nexport class VineNumber extends BaseLiteralType<number, number> {\n protected declare options: FieldOptions & { strict?: boolean }\n /**\n * Default collection of number rules\n */",
"score": 0.8607174158096313
},
{
"filename": "src/schema/accepted/main.ts",
"retrieved_chunk": "import type { FieldOptions, Validation } from '../../types.js'\n/**\n * VineAccepted represents a checkbox input that must be checked\n */\nexport class VineAccepted extends BaseLiteralType<true, true> {\n /**\n * Default collection of accepted rules\n */\n static rules = {\n accepted: acceptedRule,",
"score": 0.8589394688606262
},
{
"filename": "src/schema/accepted/main.ts",
"retrieved_chunk": " }\n constructor(options?: Partial<FieldOptions>, validations?: Validation<any>[]) {\n super(options, validations || [acceptedRule()])\n }\n /**\n * Clones the VineAccepted schema type. The applied options\n * and validations are copied to the new instance\n */\n clone(): this {\n return new VineAccepted(this.cloneOptions(), this.cloneValidations()) as this",
"score": 0.8467609882354736
},
{
"filename": "src/schema/literal/main.ts",
"retrieved_chunk": " clone(): this {\n return new VineLiteral(this.#value, this.cloneOptions(), this.cloneValidations()) as this\n }\n}",
"score": 0.8451237678527832
}
] |
typescript
|
return new VineNumber(options)
}
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import Macroable from '@poppinss/macroable'
import { VineAny } from './any/main.js'
import { VineEnum } from './enum/main.js'
import { union } from './union/builder.js'
import { VineTuple } from './tuple/main.js'
import { VineArray } from './array/main.js'
import { VineObject } from './object/main.js'
import { VineRecord } from './record/main.js'
import { VineString } from './string/main.js'
import { VineNumber } from './number/main.js'
import { VineBoolean } from './boolean/main.js'
import { VineLiteral } from './literal/main.js'
import { CamelCase } from './camelcase_types.js'
import { VineAccepted } from './accepted/main.js'
import { group } from './object/group_builder.js'
import { VineNativeEnum } from './enum/native_enum.js'
import { VineUnionOfTypes } from './union_of_types/main.js'
import { OTYPE, COTYPE, IS_OF_TYPE, UNIQUE_NAME } from '../symbols.js'
import type { EnumLike, FieldContext, SchemaTypes } from '../types.js'
/**
* Schema builder exposes methods to construct a Vine schema. You may
* add custom methods to it using macros.
*/
export class SchemaBuilder extends Macroable {
/**
* Define a sub-object as a union
*/
group = group
/**
* Define a union value
*/
union = union
/**
* Define a string value
*/
string() {
return new VineString()
}
/**
* Define a boolean value
*/
boolean(options?: { strict: boolean }) {
return new VineBoolean(options)
}
/**
* Validate a checkbox to be checked
*/
accepted() {
return new VineAccepted()
}
/**
* Define a number value
*/
number(options?: { strict: boolean }) {
return new VineNumber(options)
}
/**
* Define a schema type in which the input value
* matches the pre-defined value
*/
literal<const Value>(value: Value) {
return new VineLiteral<Value>(value)
}
/**
* Define an object with known properties. You may call "allowUnknownProperties"
* to merge unknown properties.
*/
object<Properties extends Record<string, SchemaTypes>>(properties: Properties) {
return
|
new VineObject<
Properties,
{
|
[K in keyof Properties]: Properties[K][typeof OTYPE]
},
{
[K in keyof Properties as CamelCase<K & string>]: Properties[K][typeof COTYPE]
}
>(properties)
}
/**
* Define an array field and validate its children elements.
*/
array<Schema extends SchemaTypes>(schema: Schema) {
return new VineArray<Schema>(schema)
}
/**
* Define an array field with known length and each children
* element may have its own schema.
*/
tuple<Schema extends SchemaTypes[]>(schemas: [...Schema]) {
return new VineTuple<
Schema,
{ [K in keyof Schema]: Schema[K][typeof OTYPE] },
{ [K in keyof Schema]: Schema[K][typeof COTYPE] }
>(schemas)
}
/**
* Define an object field with key-value pair. The keys in
* a record are unknown and values can be of a specific
* schema type.
*/
record<Schema extends SchemaTypes>(schema: Schema) {
return new VineRecord<Schema>(schema)
}
/**
* Define a field whose value matches the enum choices.
*/
enum<const Values extends readonly unknown[]>(
values: Values | ((field: FieldContext) => Values)
): VineEnum<Values>
enum<Values extends EnumLike>(values: Values): VineNativeEnum<Values>
enum<Values extends readonly unknown[] | EnumLike>(values: Values): any {
if (Array.isArray(values) || typeof values === 'function') {
return new VineEnum(values)
}
return new VineNativeEnum(values as EnumLike)
}
/**
* Allow the field value to be anything
*/
any() {
return new VineAny()
}
/**
* Define a union of unique schema types.
*/
unionOfTypes<Schema extends SchemaTypes>(schemas: Schema[]) {
const schemasInUse: Set<string> = new Set()
schemas.forEach((schema) => {
if (!schema[IS_OF_TYPE] || !schema[UNIQUE_NAME]) {
throw new Error(
`Cannot use "${schema.constructor.name}". The schema type is not compatible for use with "vine.unionOfTypes"`
)
}
if (schemasInUse.has(schema[UNIQUE_NAME])) {
throw new Error(
`Cannot use duplicate schema "${schema[UNIQUE_NAME]}". "vine.unionOfTypes" needs distinct schema types only`
)
}
schemasInUse.add(schema[UNIQUE_NAME])
})
schemasInUse.clear()
return new VineUnionOfTypes(schemas)
}
}
|
src/schema/builder.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": " /**\n * Copy unknown properties to the final output.\n */\n allowUnknownProperties<Value>(): VineObject<\n Properties,\n Output & { [K: string]: Value },\n CamelCaseOutput & { [K: string]: Value }\n > {\n this.#allowUnknownProperties = true\n return this as VineObject<",
"score": 0.8711365461349487
},
{
"filename": "src/schema/tuple/main.ts",
"retrieved_chunk": " this.#schemas = schemas\n }\n /**\n * Copy unknown properties to the final output.\n */\n allowUnknownProperties<Value>(): VineTuple<\n Schema,\n [...Output, ...Value[]],\n [...CamelCaseOutput, ...Value[]]\n > {",
"score": 0.8467631936073303
},
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": " * Clone object\n */\n clone(): this {\n const cloned = new VineObject<Properties, Output, CamelCaseOutput>(\n this.getProperties(),\n this.cloneOptions(),\n this.cloneValidations()\n )\n this.#groups.forEach((group) => cloned.merge(group))\n if (this.#allowUnknownProperties) {",
"score": 0.8423783183097839
},
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": "}\n/**\n * VineObject represents an object value in the validation\n * schema.\n */\nexport class VineObject<\n Properties extends Record<string, SchemaTypes>,\n Output,\n CamelCaseOutput,\n> extends BaseType<Output, CamelCaseOutput> {",
"score": 0.8397362232208252
},
{
"filename": "src/schema/tuple/main.ts",
"retrieved_chunk": " this.#allowUnknownProperties = true\n return this as unknown as VineTuple<\n Schema,\n [...Output, ...Value[]],\n [...CamelCaseOutput, ...Value[]]\n >\n }\n /**\n * Clone object\n */",
"score": 0.836851954460144
}
] |
typescript
|
new VineObject<
Properties,
{
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import Macroable from '@poppinss/macroable'
import { VineAny } from './any/main.js'
import { VineEnum } from './enum/main.js'
import { union } from './union/builder.js'
import { VineTuple } from './tuple/main.js'
import { VineArray } from './array/main.js'
import { VineObject } from './object/main.js'
import { VineRecord } from './record/main.js'
import { VineString } from './string/main.js'
import { VineNumber } from './number/main.js'
import { VineBoolean } from './boolean/main.js'
import { VineLiteral } from './literal/main.js'
import { CamelCase } from './camelcase_types.js'
import { VineAccepted } from './accepted/main.js'
import { group } from './object/group_builder.js'
import { VineNativeEnum } from './enum/native_enum.js'
import { VineUnionOfTypes } from './union_of_types/main.js'
import { OTYPE, COTYPE, IS_OF_TYPE, UNIQUE_NAME } from '../symbols.js'
import type { EnumLike, FieldContext, SchemaTypes } from '../types.js'
/**
* Schema builder exposes methods to construct a Vine schema. You may
* add custom methods to it using macros.
*/
export class SchemaBuilder extends Macroable {
/**
* Define a sub-object as a union
*/
group = group
/**
* Define a union value
*/
union = union
/**
* Define a string value
*/
string() {
return new VineString()
}
/**
* Define a boolean value
*/
boolean(options?: { strict: boolean }) {
return new VineBoolean(options)
}
/**
* Validate a checkbox to be checked
*/
accepted() {
return new VineAccepted()
}
/**
* Define a number value
*/
number(options?: { strict: boolean }) {
return new VineNumber(options)
}
/**
* Define a schema type in which the input value
* matches the pre-defined value
*/
literal<const Value>(value: Value) {
return new VineLiteral<Value>(value)
}
/**
* Define an object with known properties. You may call "allowUnknownProperties"
* to merge unknown properties.
*/
object<Properties extends Record<string
|
, SchemaTypes>>(properties: Properties) {
|
return new VineObject<
Properties,
{
[K in keyof Properties]: Properties[K][typeof OTYPE]
},
{
[K in keyof Properties as CamelCase<K & string>]: Properties[K][typeof COTYPE]
}
>(properties)
}
/**
* Define an array field and validate its children elements.
*/
array<Schema extends SchemaTypes>(schema: Schema) {
return new VineArray<Schema>(schema)
}
/**
* Define an array field with known length and each children
* element may have its own schema.
*/
tuple<Schema extends SchemaTypes[]>(schemas: [...Schema]) {
return new VineTuple<
Schema,
{ [K in keyof Schema]: Schema[K][typeof OTYPE] },
{ [K in keyof Schema]: Schema[K][typeof COTYPE] }
>(schemas)
}
/**
* Define an object field with key-value pair. The keys in
* a record are unknown and values can be of a specific
* schema type.
*/
record<Schema extends SchemaTypes>(schema: Schema) {
return new VineRecord<Schema>(schema)
}
/**
* Define a field whose value matches the enum choices.
*/
enum<const Values extends readonly unknown[]>(
values: Values | ((field: FieldContext) => Values)
): VineEnum<Values>
enum<Values extends EnumLike>(values: Values): VineNativeEnum<Values>
enum<Values extends readonly unknown[] | EnumLike>(values: Values): any {
if (Array.isArray(values) || typeof values === 'function') {
return new VineEnum(values)
}
return new VineNativeEnum(values as EnumLike)
}
/**
* Allow the field value to be anything
*/
any() {
return new VineAny()
}
/**
* Define a union of unique schema types.
*/
unionOfTypes<Schema extends SchemaTypes>(schemas: Schema[]) {
const schemasInUse: Set<string> = new Set()
schemas.forEach((schema) => {
if (!schema[IS_OF_TYPE] || !schema[UNIQUE_NAME]) {
throw new Error(
`Cannot use "${schema.constructor.name}". The schema type is not compatible for use with "vine.unionOfTypes"`
)
}
if (schemasInUse.has(schema[UNIQUE_NAME])) {
throw new Error(
`Cannot use duplicate schema "${schema[UNIQUE_NAME]}". "vine.unionOfTypes" needs distinct schema types only`
)
}
schemasInUse.add(schema[UNIQUE_NAME])
})
schemasInUse.clear()
return new VineUnionOfTypes(schemas)
}
}
|
src/schema/builder.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/literal/main.ts",
"retrieved_chunk": " }\n #value: Value\n constructor(value: Value, options?: FieldOptions, validations?: Validation<any>[]) {\n super(options, validations || [equalsRule({ expectedValue: value })])\n this.#value = value\n }\n /**\n * Clones the VineLiteral schema type. The applied options\n * and validations are copied to the new instance\n */",
"score": 0.8617565631866455
},
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": "}\n/**\n * VineObject represents an object value in the validation\n * schema.\n */\nexport class VineObject<\n Properties extends Record<string, SchemaTypes>,\n Output,\n CamelCaseOutput,\n> extends BaseType<Output, CamelCaseOutput> {",
"score": 0.8521245718002319
},
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": " /**\n * Copy unknown properties to the final output.\n */\n allowUnknownProperties<Value>(): VineObject<\n Properties,\n Output & { [K: string]: Value },\n CamelCaseOutput & { [K: string]: Value }\n > {\n this.#allowUnknownProperties = true\n return this as VineObject<",
"score": 0.8435796499252319
},
{
"filename": "src/schema/literal/main.ts",
"retrieved_chunk": "import type { FieldOptions, Validation } from '../../types.js'\n/**\n * VineLiteral represents a type that matches an exact value\n */\nexport class VineLiteral<Value> extends BaseLiteralType<Value, Value> {\n /**\n * Default collection of literal rules\n */\n static rules = {\n equals: equalsRule,",
"score": 0.8403515815734863
},
{
"filename": "src/schema/literal/main.ts",
"retrieved_chunk": " clone(): this {\n return new VineLiteral(this.#value, this.cloneOptions(), this.cloneValidations()) as this\n }\n}",
"score": 0.8398745059967041
}
] |
typescript
|
, SchemaTypes>>(properties: Properties) {
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import Macroable from '@poppinss/macroable'
import { VineAny } from './any/main.js'
import { VineEnum } from './enum/main.js'
import { union } from './union/builder.js'
import { VineTuple } from './tuple/main.js'
import { VineArray } from './array/main.js'
import { VineObject } from './object/main.js'
import { VineRecord } from './record/main.js'
import { VineString } from './string/main.js'
import { VineNumber } from './number/main.js'
import { VineBoolean } from './boolean/main.js'
import { VineLiteral } from './literal/main.js'
import { CamelCase } from './camelcase_types.js'
import { VineAccepted } from './accepted/main.js'
import { group } from './object/group_builder.js'
import { VineNativeEnum } from './enum/native_enum.js'
import { VineUnionOfTypes } from './union_of_types/main.js'
import { OTYPE, COTYPE, IS_OF_TYPE, UNIQUE_NAME } from '../symbols.js'
import type { EnumLike, FieldContext, SchemaTypes } from '../types.js'
/**
* Schema builder exposes methods to construct a Vine schema. You may
* add custom methods to it using macros.
*/
export class SchemaBuilder extends Macroable {
/**
* Define a sub-object as a union
*/
group = group
/**
* Define a union value
*/
union = union
/**
* Define a string value
*/
string() {
return new VineString()
}
/**
* Define a boolean value
*/
boolean(options?: { strict: boolean }) {
return new VineBoolean(options)
}
/**
* Validate a checkbox to be checked
*/
accepted() {
return new VineAccepted()
}
/**
* Define a number value
*/
number(options?: { strict: boolean }) {
return new VineNumber(options)
}
/**
* Define a schema type in which the input value
* matches the pre-defined value
*/
literal<const Value>(value: Value) {
return new VineLiteral<Value>(value)
}
/**
* Define an object with known properties. You may call "allowUnknownProperties"
* to merge unknown properties.
*/
object<Properties extends Record<string, SchemaTypes>>(properties: Properties) {
return new VineObject<
Properties,
{
[K in keyof Properties]: Properties[K][typeof OTYPE]
},
{
[K in keyof Properties as CamelCase<K & string>]: Properties[K][typeof COTYPE]
}
>(properties)
}
/**
* Define an array field and validate its children elements.
*/
array<Schema extends SchemaTypes>(schema: Schema) {
return new VineArray<Schema>(schema)
}
/**
* Define an array field with known length and each children
* element may have its own schema.
*/
tuple<Schema extends SchemaTypes[]>(schemas: [...Schema]) {
return new VineTuple<
Schema,
{ [K in keyof Schema]: Schema[K][typeof OTYPE] },
{ [K in keyof Schema]: Schema[K][typeof COTYPE] }
>(schemas)
}
/**
* Define an object field with key-value pair. The keys in
* a record are unknown and values can be of a specific
* schema type.
*/
record<Schema extends SchemaTypes>(schema: Schema) {
return new VineRecord<Schema>(schema)
}
/**
* Define a field whose value matches the enum choices.
*/
enum<const Values extends readonly unknown[]>(
values: Values | ((field: FieldContext) => Values)
): VineEnum<Values>
enum<Values extends EnumLike>(values: Values):
|
VineNativeEnum<Values>
enum<Values extends readonly unknown[] | EnumLike>(values: Values): any {
|
if (Array.isArray(values) || typeof values === 'function') {
return new VineEnum(values)
}
return new VineNativeEnum(values as EnumLike)
}
/**
* Allow the field value to be anything
*/
any() {
return new VineAny()
}
/**
* Define a union of unique schema types.
*/
unionOfTypes<Schema extends SchemaTypes>(schemas: Schema[]) {
const schemasInUse: Set<string> = new Set()
schemas.forEach((schema) => {
if (!schema[IS_OF_TYPE] || !schema[UNIQUE_NAME]) {
throw new Error(
`Cannot use "${schema.constructor.name}". The schema type is not compatible for use with "vine.unionOfTypes"`
)
}
if (schemasInUse.has(schema[UNIQUE_NAME])) {
throw new Error(
`Cannot use duplicate schema "${schema[UNIQUE_NAME]}". "vine.unionOfTypes" needs distinct schema types only`
)
}
schemasInUse.add(schema[UNIQUE_NAME])
})
schemasInUse.clear()
return new VineUnionOfTypes(schemas)
}
}
|
src/schema/builder.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/enum/main.ts",
"retrieved_chunk": "import type { FieldContext, FieldOptions, Validation } from '../../types.js'\n/**\n * VineEnum represents a enum data type that performs validation\n * against a pre-defined choices list.\n */\nexport class VineEnum<const Values extends readonly unknown[]> extends BaseLiteralType<\n Values[number],\n Values[number]\n> {\n /**",
"score": 0.8956319689750671
},
{
"filename": "src/schema/enum/native_enum.ts",
"retrieved_chunk": "import type { EnumLike, FieldOptions, Validation } from '../../types.js'\n/**\n * VineNativeEnum represents a enum data type that performs validation\n * against a pre-defined choices list.\n *\n * The choices list is derived from TypeScript enum data type or an\n * object\n */\nexport class VineNativeEnum<Values extends EnumLike> extends BaseLiteralType<\n Values[keyof Values],",
"score": 0.8827114701271057
},
{
"filename": "src/schema/enum/rules.ts",
"retrieved_chunk": "import { FieldContext } from '@vinejs/compiler/types'\n/**\n * Enum rule is used to validate the field's value to be one\n * from the pre-defined choices.\n */\nexport const enumRule = createRule<{\n choices: readonly any[] | ((field: FieldContext) => readonly any[])\n}>((value, options, field) => {\n const choices = typeof options.choices === 'function' ? options.choices(field) : options.choices\n /**",
"score": 0.8681213855743408
},
{
"filename": "src/schema/enum/main.ts",
"retrieved_chunk": " return this.#values\n }\n constructor(\n values: Values | ((field: FieldContext) => Values),\n options?: FieldOptions,\n validations?: Validation<any>[]\n ) {\n super(options, validations || [enumRule({ choices: values })])\n this.#values = values\n }",
"score": 0.865892767906189
},
{
"filename": "src/schema/enum/native_enum.ts",
"retrieved_chunk": " Values[keyof Values]\n> {\n /**\n * Default collection of enum rules\n */\n static rules = {\n enum: enumRule,\n }\n #values: Values\n constructor(values: Values, options?: FieldOptions, validations?: Validation<any>[]) {",
"score": 0.8605104088783264
}
] |
typescript
|
VineNativeEnum<Values>
enum<Values extends readonly unknown[] | EnumLike>(values: Values): any {
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import Macroable from '@poppinss/macroable'
import { VineAny } from './any/main.js'
import { VineEnum } from './enum/main.js'
import { union } from './union/builder.js'
import { VineTuple } from './tuple/main.js'
import { VineArray } from './array/main.js'
import { VineObject } from './object/main.js'
import { VineRecord } from './record/main.js'
import { VineString } from './string/main.js'
import { VineNumber } from './number/main.js'
import { VineBoolean } from './boolean/main.js'
import { VineLiteral } from './literal/main.js'
import { CamelCase } from './camelcase_types.js'
import { VineAccepted } from './accepted/main.js'
import { group } from './object/group_builder.js'
import { VineNativeEnum } from './enum/native_enum.js'
import { VineUnionOfTypes } from './union_of_types/main.js'
import { OTYPE, COTYPE, IS_OF_TYPE, UNIQUE_NAME } from '../symbols.js'
import type { EnumLike, FieldContext, SchemaTypes } from '../types.js'
/**
* Schema builder exposes methods to construct a Vine schema. You may
* add custom methods to it using macros.
*/
export class SchemaBuilder extends Macroable {
/**
* Define a sub-object as a union
*/
group = group
/**
* Define a union value
*/
union = union
/**
* Define a string value
*/
string() {
return new VineString()
}
/**
* Define a boolean value
*/
boolean(options?: { strict: boolean }) {
return new VineBoolean(options)
}
/**
* Validate a checkbox to be checked
*/
accepted() {
return new VineAccepted()
}
/**
* Define a number value
*/
number(options?: { strict: boolean }) {
return new VineNumber(options)
}
/**
* Define a schema type in which the input value
* matches the pre-defined value
*/
literal<const Value>(value: Value) {
return new VineLiteral<Value>(value)
}
/**
* Define an object with known properties. You may call "allowUnknownProperties"
* to merge unknown properties.
*/
object<Properties extends Record<string, SchemaTypes>>(properties: Properties) {
return new VineObject<
Properties,
{
[K in keyof Properties]: Properties[K][typeof OTYPE]
},
{
[K in keyof Properties as CamelCase<K & string>]: Properties[K][typeof COTYPE]
}
>(properties)
}
/**
* Define an array field and validate its children elements.
*/
array<Schema extends SchemaTypes>(schema: Schema) {
|
return new VineArray<Schema>(schema)
}
|
/**
* Define an array field with known length and each children
* element may have its own schema.
*/
tuple<Schema extends SchemaTypes[]>(schemas: [...Schema]) {
return new VineTuple<
Schema,
{ [K in keyof Schema]: Schema[K][typeof OTYPE] },
{ [K in keyof Schema]: Schema[K][typeof COTYPE] }
>(schemas)
}
/**
* Define an object field with key-value pair. The keys in
* a record are unknown and values can be of a specific
* schema type.
*/
record<Schema extends SchemaTypes>(schema: Schema) {
return new VineRecord<Schema>(schema)
}
/**
* Define a field whose value matches the enum choices.
*/
enum<const Values extends readonly unknown[]>(
values: Values | ((field: FieldContext) => Values)
): VineEnum<Values>
enum<Values extends EnumLike>(values: Values): VineNativeEnum<Values>
enum<Values extends readonly unknown[] | EnumLike>(values: Values): any {
if (Array.isArray(values) || typeof values === 'function') {
return new VineEnum(values)
}
return new VineNativeEnum(values as EnumLike)
}
/**
* Allow the field value to be anything
*/
any() {
return new VineAny()
}
/**
* Define a union of unique schema types.
*/
unionOfTypes<Schema extends SchemaTypes>(schemas: Schema[]) {
const schemasInUse: Set<string> = new Set()
schemas.forEach((schema) => {
if (!schema[IS_OF_TYPE] || !schema[UNIQUE_NAME]) {
throw new Error(
`Cannot use "${schema.constructor.name}". The schema type is not compatible for use with "vine.unionOfTypes"`
)
}
if (schemasInUse.has(schema[UNIQUE_NAME])) {
throw new Error(
`Cannot use duplicate schema "${schema[UNIQUE_NAME]}". "vine.unionOfTypes" needs distinct schema types only`
)
}
schemasInUse.add(schema[UNIQUE_NAME])
})
schemasInUse.clear()
return new VineUnionOfTypes(schemas)
}
}
|
src/schema/builder.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/array/main.ts",
"retrieved_chunk": "} from './rules.js'\n/**\n * VineArray represents an array schema type in the validation\n * pipeline\n */\nexport class VineArray<Schema extends SchemaTypes> extends BaseType<\n Schema[typeof OTYPE][],\n Schema[typeof COTYPE][]\n> {\n /**",
"score": 0.8688259124755859
},
{
"filename": "src/schema/object/group_builder.ts",
"retrieved_chunk": " {\n [K in keyof Properties as CamelCase<K & string>]: Properties[K][typeof COTYPE]\n }\n >(() => true, properties)\n}",
"score": 0.8630387783050537
},
{
"filename": "src/schema/tuple/main.ts",
"retrieved_chunk": " [UNIQUE_NAME] = 'vine.array';\n /**\n * Checks if the value is of array type. The method must be\n * implemented for \"unionOfTypes\"\n */\n [IS_OF_TYPE] = (value: unknown) => {\n return Array.isArray(value)\n }\n constructor(schemas: [...Schema], options?: FieldOptions, validations?: Validation<any>[]) {\n super(options, validations)",
"score": 0.8609986305236816
},
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": "}\n/**\n * VineObject represents an object value in the validation\n * schema.\n */\nexport class VineObject<\n Properties extends Record<string, SchemaTypes>,\n Output,\n CamelCaseOutput,\n> extends BaseType<Output, CamelCaseOutput> {",
"score": 0.8536243438720703
},
{
"filename": "src/schema/record/main.ts",
"retrieved_chunk": "import { BaseType } from '../base/main.js'\nimport { OTYPE, COTYPE, PARSE, UNIQUE_NAME, IS_OF_TYPE } from '../../symbols.js'\nimport type { FieldOptions, ParserOptions, SchemaTypes, Validation } from '../../types.js'\nimport { fixedLengthRule, maxLengthRule, minLengthRule, validateKeysRule } from './rules.js'\n/**\n * VineRecord represents an object of key-value pair in which\n * keys are unknown\n */\nexport class VineRecord<Schema extends SchemaTypes> extends BaseType<\n { [K: string]: Schema[typeof OTYPE] },",
"score": 0.8285129070281982
}
] |
typescript
|
return new VineArray<Schema>(schema)
}
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import Macroable from '@poppinss/macroable'
import { VineAny } from './any/main.js'
import { VineEnum } from './enum/main.js'
import { union } from './union/builder.js'
import { VineTuple } from './tuple/main.js'
import { VineArray } from './array/main.js'
import { VineObject } from './object/main.js'
import { VineRecord } from './record/main.js'
import { VineString } from './string/main.js'
import { VineNumber } from './number/main.js'
import { VineBoolean } from './boolean/main.js'
import { VineLiteral } from './literal/main.js'
import { CamelCase } from './camelcase_types.js'
import { VineAccepted } from './accepted/main.js'
import { group } from './object/group_builder.js'
import { VineNativeEnum } from './enum/native_enum.js'
import { VineUnionOfTypes } from './union_of_types/main.js'
import { OTYPE, COTYPE, IS_OF_TYPE, UNIQUE_NAME } from '../symbols.js'
import type { EnumLike, FieldContext, SchemaTypes } from '../types.js'
/**
* Schema builder exposes methods to construct a Vine schema. You may
* add custom methods to it using macros.
*/
export class SchemaBuilder extends Macroable {
/**
* Define a sub-object as a union
*/
group = group
/**
* Define a union value
*/
union = union
/**
* Define a string value
*/
string() {
return new VineString()
}
/**
* Define a boolean value
*/
boolean(options?: { strict: boolean }) {
return new VineBoolean(options)
}
/**
* Validate a checkbox to be checked
*/
accepted() {
return new VineAccepted()
}
/**
* Define a number value
*/
number(options?: { strict: boolean }) {
return new VineNumber(options)
}
/**
* Define a schema type in which the input value
* matches the pre-defined value
*/
literal<const Value>(value: Value) {
return new VineLiteral<Value>(value)
}
/**
* Define an object with known properties. You may call "allowUnknownProperties"
* to merge unknown properties.
*/
object<Properties extends Record<string, SchemaTypes>>(properties: Properties) {
return new VineObject<
Properties,
{
[K in keyof Properties]: Properties[K][typeof OTYPE]
},
{
[K in keyof Properties as CamelCase<K & string>]: Properties[K][typeof COTYPE]
}
>(properties)
}
/**
* Define an array field and validate its children elements.
*/
|
array<Schema extends SchemaTypes>(schema: Schema) {
|
return new VineArray<Schema>(schema)
}
/**
* Define an array field with known length and each children
* element may have its own schema.
*/
tuple<Schema extends SchemaTypes[]>(schemas: [...Schema]) {
return new VineTuple<
Schema,
{ [K in keyof Schema]: Schema[K][typeof OTYPE] },
{ [K in keyof Schema]: Schema[K][typeof COTYPE] }
>(schemas)
}
/**
* Define an object field with key-value pair. The keys in
* a record are unknown and values can be of a specific
* schema type.
*/
record<Schema extends SchemaTypes>(schema: Schema) {
return new VineRecord<Schema>(schema)
}
/**
* Define a field whose value matches the enum choices.
*/
enum<const Values extends readonly unknown[]>(
values: Values | ((field: FieldContext) => Values)
): VineEnum<Values>
enum<Values extends EnumLike>(values: Values): VineNativeEnum<Values>
enum<Values extends readonly unknown[] | EnumLike>(values: Values): any {
if (Array.isArray(values) || typeof values === 'function') {
return new VineEnum(values)
}
return new VineNativeEnum(values as EnumLike)
}
/**
* Allow the field value to be anything
*/
any() {
return new VineAny()
}
/**
* Define a union of unique schema types.
*/
unionOfTypes<Schema extends SchemaTypes>(schemas: Schema[]) {
const schemasInUse: Set<string> = new Set()
schemas.forEach((schema) => {
if (!schema[IS_OF_TYPE] || !schema[UNIQUE_NAME]) {
throw new Error(
`Cannot use "${schema.constructor.name}". The schema type is not compatible for use with "vine.unionOfTypes"`
)
}
if (schemasInUse.has(schema[UNIQUE_NAME])) {
throw new Error(
`Cannot use duplicate schema "${schema[UNIQUE_NAME]}". "vine.unionOfTypes" needs distinct schema types only`
)
}
schemasInUse.add(schema[UNIQUE_NAME])
})
schemasInUse.clear()
return new VineUnionOfTypes(schemas)
}
}
|
src/schema/builder.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/object/group_builder.ts",
"retrieved_chunk": " {\n [K in keyof Properties as CamelCase<K & string>]: Properties[K][typeof COTYPE]\n }\n >(() => true, properties)\n}",
"score": 0.8782224059104919
},
{
"filename": "src/schema/object/group_builder.ts",
"retrieved_chunk": " Properties,\n {\n [K in keyof Properties]: Properties[K][typeof OTYPE]\n },\n {\n [K in keyof Properties as CamelCase<K & string>]: Properties[K][typeof COTYPE]\n }\n >(conditon, properties)\n}\n/**",
"score": 0.8302093744277954
},
{
"filename": "src/schema/record/main.ts",
"retrieved_chunk": " { [K: string]: Schema[typeof COTYPE] }\n> {\n /**\n * Default collection of record rules\n */\n static rules = {\n maxLength: maxLengthRule,\n minLength: minLengthRule,\n fixedLength: fixedLengthRule,\n validateKeys: validateKeysRule,",
"score": 0.826170802116394
},
{
"filename": "src/schema/array/main.ts",
"retrieved_chunk": "} from './rules.js'\n/**\n * VineArray represents an array schema type in the validation\n * pipeline\n */\nexport class VineArray<Schema extends SchemaTypes> extends BaseType<\n Schema[typeof OTYPE][],\n Schema[typeof COTYPE][]\n> {\n /**",
"score": 0.8187330961227417
},
{
"filename": "src/schema/base/literal.ts",
"retrieved_chunk": " Schema extends BaseModifiersType<any, any>,\n Output,\n> extends BaseModifiersType<Output, Output> {\n /**\n * The output value of the field. The property points to a type only\n * and not the real value.\n */\n declare [OTYPE]: Output;\n declare [COTYPE]: Output\n #parent: Schema",
"score": 0.807846188545227
}
] |
typescript
|
array<Schema extends SchemaTypes>(schema: Schema) {
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import Macroable from '@poppinss/macroable'
import { VineAny } from './any/main.js'
import { VineEnum } from './enum/main.js'
import { union } from './union/builder.js'
import { VineTuple } from './tuple/main.js'
import { VineArray } from './array/main.js'
import { VineObject } from './object/main.js'
import { VineRecord } from './record/main.js'
import { VineString } from './string/main.js'
import { VineNumber } from './number/main.js'
import { VineBoolean } from './boolean/main.js'
import { VineLiteral } from './literal/main.js'
import { CamelCase } from './camelcase_types.js'
import { VineAccepted } from './accepted/main.js'
import { group } from './object/group_builder.js'
import { VineNativeEnum } from './enum/native_enum.js'
import { VineUnionOfTypes } from './union_of_types/main.js'
import { OTYPE, COTYPE, IS_OF_TYPE, UNIQUE_NAME } from '../symbols.js'
import type { EnumLike, FieldContext, SchemaTypes } from '../types.js'
/**
* Schema builder exposes methods to construct a Vine schema. You may
* add custom methods to it using macros.
*/
export class SchemaBuilder extends Macroable {
/**
* Define a sub-object as a union
*/
group = group
/**
* Define a union value
*/
union = union
/**
* Define a string value
*/
string() {
return new VineString()
}
/**
* Define a boolean value
*/
boolean(options?: { strict: boolean }) {
return new VineBoolean(options)
}
/**
* Validate a checkbox to be checked
*/
accepted() {
return new VineAccepted()
}
/**
* Define a number value
*/
number(options?: { strict: boolean }) {
return new VineNumber(options)
}
/**
* Define a schema type in which the input value
* matches the pre-defined value
*/
literal<const Value>(value: Value) {
|
return new VineLiteral<Value>(value)
}
|
/**
* Define an object with known properties. You may call "allowUnknownProperties"
* to merge unknown properties.
*/
object<Properties extends Record<string, SchemaTypes>>(properties: Properties) {
return new VineObject<
Properties,
{
[K in keyof Properties]: Properties[K][typeof OTYPE]
},
{
[K in keyof Properties as CamelCase<K & string>]: Properties[K][typeof COTYPE]
}
>(properties)
}
/**
* Define an array field and validate its children elements.
*/
array<Schema extends SchemaTypes>(schema: Schema) {
return new VineArray<Schema>(schema)
}
/**
* Define an array field with known length and each children
* element may have its own schema.
*/
tuple<Schema extends SchemaTypes[]>(schemas: [...Schema]) {
return new VineTuple<
Schema,
{ [K in keyof Schema]: Schema[K][typeof OTYPE] },
{ [K in keyof Schema]: Schema[K][typeof COTYPE] }
>(schemas)
}
/**
* Define an object field with key-value pair. The keys in
* a record are unknown and values can be of a specific
* schema type.
*/
record<Schema extends SchemaTypes>(schema: Schema) {
return new VineRecord<Schema>(schema)
}
/**
* Define a field whose value matches the enum choices.
*/
enum<const Values extends readonly unknown[]>(
values: Values | ((field: FieldContext) => Values)
): VineEnum<Values>
enum<Values extends EnumLike>(values: Values): VineNativeEnum<Values>
enum<Values extends readonly unknown[] | EnumLike>(values: Values): any {
if (Array.isArray(values) || typeof values === 'function') {
return new VineEnum(values)
}
return new VineNativeEnum(values as EnumLike)
}
/**
* Allow the field value to be anything
*/
any() {
return new VineAny()
}
/**
* Define a union of unique schema types.
*/
unionOfTypes<Schema extends SchemaTypes>(schemas: Schema[]) {
const schemasInUse: Set<string> = new Set()
schemas.forEach((schema) => {
if (!schema[IS_OF_TYPE] || !schema[UNIQUE_NAME]) {
throw new Error(
`Cannot use "${schema.constructor.name}". The schema type is not compatible for use with "vine.unionOfTypes"`
)
}
if (schemasInUse.has(schema[UNIQUE_NAME])) {
throw new Error(
`Cannot use duplicate schema "${schema[UNIQUE_NAME]}". "vine.unionOfTypes" needs distinct schema types only`
)
}
schemasInUse.add(schema[UNIQUE_NAME])
})
schemasInUse.clear()
return new VineUnionOfTypes(schemas)
}
}
|
src/schema/builder.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/literal/main.ts",
"retrieved_chunk": "import type { FieldOptions, Validation } from '../../types.js'\n/**\n * VineLiteral represents a type that matches an exact value\n */\nexport class VineLiteral<Value> extends BaseLiteralType<Value, Value> {\n /**\n * Default collection of literal rules\n */\n static rules = {\n equals: equalsRule,",
"score": 0.8770423531532288
},
{
"filename": "src/schema/number/main.ts",
"retrieved_chunk": " }\n /**\n * Clones the VineNumber schema type. The applied options\n * and validations are copied to the new instance\n */\n clone(): this {\n return new VineNumber(this.cloneOptions(), this.cloneValidations()) as this\n }\n}",
"score": 0.8759826421737671
},
{
"filename": "src/schema/literal/main.ts",
"retrieved_chunk": " }\n #value: Value\n constructor(value: Value, options?: FieldOptions, validations?: Validation<any>[]) {\n super(options, validations || [equalsRule({ expectedValue: value })])\n this.#value = value\n }\n /**\n * Clones the VineLiteral schema type. The applied options\n * and validations are copied to the new instance\n */",
"score": 0.8737565279006958
},
{
"filename": "src/schema/number/main.ts",
"retrieved_chunk": " withoutDecimalsRule,\n} from './rules.js'\n/**\n * VineNumber represents a numeric value in the validation schema.\n */\nexport class VineNumber extends BaseLiteralType<number, number> {\n protected declare options: FieldOptions & { strict?: boolean }\n /**\n * Default collection of number rules\n */",
"score": 0.865478515625
},
{
"filename": "src/schema/literal/main.ts",
"retrieved_chunk": " clone(): this {\n return new VineLiteral(this.#value, this.cloneOptions(), this.cloneValidations()) as this\n }\n}",
"score": 0.8522560596466064
}
] |
typescript
|
return new VineLiteral<Value>(value)
}
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import Macroable from '@poppinss/macroable'
import { VineAny } from './any/main.js'
import { VineEnum } from './enum/main.js'
import { union } from './union/builder.js'
import { VineTuple } from './tuple/main.js'
import { VineArray } from './array/main.js'
import { VineObject } from './object/main.js'
import { VineRecord } from './record/main.js'
import { VineString } from './string/main.js'
import { VineNumber } from './number/main.js'
import { VineBoolean } from './boolean/main.js'
import { VineLiteral } from './literal/main.js'
import { CamelCase } from './camelcase_types.js'
import { VineAccepted } from './accepted/main.js'
import { group } from './object/group_builder.js'
import { VineNativeEnum } from './enum/native_enum.js'
import { VineUnionOfTypes } from './union_of_types/main.js'
import { OTYPE, COTYPE, IS_OF_TYPE, UNIQUE_NAME } from '../symbols.js'
import type { EnumLike, FieldContext, SchemaTypes } from '../types.js'
/**
* Schema builder exposes methods to construct a Vine schema. You may
* add custom methods to it using macros.
*/
export class SchemaBuilder extends Macroable {
/**
* Define a sub-object as a union
*/
group = group
/**
* Define a union value
*/
union = union
/**
* Define a string value
*/
string() {
return new VineString()
}
/**
* Define a boolean value
*/
boolean(options?: { strict: boolean }) {
return new VineBoolean(options)
}
/**
* Validate a checkbox to be checked
*/
accepted() {
return new VineAccepted()
}
/**
* Define a number value
*/
number(options?: { strict: boolean }) {
return new VineNumber(options)
}
/**
* Define a schema type in which the input value
* matches the pre-defined value
*/
literal<const Value>(value: Value) {
return new VineLiteral<Value>(value)
}
/**
* Define an object with known properties. You may call "allowUnknownProperties"
* to merge unknown properties.
*/
object<Properties extends Record<string, SchemaTypes>>(properties: Properties) {
return new VineObject<
Properties,
{
|
[K in keyof Properties]: Properties[K][typeof OTYPE]
},
{
|
[K in keyof Properties as CamelCase<K & string>]: Properties[K][typeof COTYPE]
}
>(properties)
}
/**
* Define an array field and validate its children elements.
*/
array<Schema extends SchemaTypes>(schema: Schema) {
return new VineArray<Schema>(schema)
}
/**
* Define an array field with known length and each children
* element may have its own schema.
*/
tuple<Schema extends SchemaTypes[]>(schemas: [...Schema]) {
return new VineTuple<
Schema,
{ [K in keyof Schema]: Schema[K][typeof OTYPE] },
{ [K in keyof Schema]: Schema[K][typeof COTYPE] }
>(schemas)
}
/**
* Define an object field with key-value pair. The keys in
* a record are unknown and values can be of a specific
* schema type.
*/
record<Schema extends SchemaTypes>(schema: Schema) {
return new VineRecord<Schema>(schema)
}
/**
* Define a field whose value matches the enum choices.
*/
enum<const Values extends readonly unknown[]>(
values: Values | ((field: FieldContext) => Values)
): VineEnum<Values>
enum<Values extends EnumLike>(values: Values): VineNativeEnum<Values>
enum<Values extends readonly unknown[] | EnumLike>(values: Values): any {
if (Array.isArray(values) || typeof values === 'function') {
return new VineEnum(values)
}
return new VineNativeEnum(values as EnumLike)
}
/**
* Allow the field value to be anything
*/
any() {
return new VineAny()
}
/**
* Define a union of unique schema types.
*/
unionOfTypes<Schema extends SchemaTypes>(schemas: Schema[]) {
const schemasInUse: Set<string> = new Set()
schemas.forEach((schema) => {
if (!schema[IS_OF_TYPE] || !schema[UNIQUE_NAME]) {
throw new Error(
`Cannot use "${schema.constructor.name}". The schema type is not compatible for use with "vine.unionOfTypes"`
)
}
if (schemasInUse.has(schema[UNIQUE_NAME])) {
throw new Error(
`Cannot use duplicate schema "${schema[UNIQUE_NAME]}". "vine.unionOfTypes" needs distinct schema types only`
)
}
schemasInUse.add(schema[UNIQUE_NAME])
})
schemasInUse.clear()
return new VineUnionOfTypes(schemas)
}
}
|
src/schema/builder.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": " /**\n * Copy unknown properties to the final output.\n */\n allowUnknownProperties<Value>(): VineObject<\n Properties,\n Output & { [K: string]: Value },\n CamelCaseOutput & { [K: string]: Value }\n > {\n this.#allowUnknownProperties = true\n return this as VineObject<",
"score": 0.8596146702766418
},
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": "}\n/**\n * VineObject represents an object value in the validation\n * schema.\n */\nexport class VineObject<\n Properties extends Record<string, SchemaTypes>,\n Output,\n CamelCaseOutput,\n> extends BaseType<Output, CamelCaseOutput> {",
"score": 0.846793532371521
},
{
"filename": "src/schema/record/main.ts",
"retrieved_chunk": "import { BaseType } from '../base/main.js'\nimport { OTYPE, COTYPE, PARSE, UNIQUE_NAME, IS_OF_TYPE } from '../../symbols.js'\nimport type { FieldOptions, ParserOptions, SchemaTypes, Validation } from '../../types.js'\nimport { fixedLengthRule, maxLengthRule, minLengthRule, validateKeysRule } from './rules.js'\n/**\n * VineRecord represents an object of key-value pair in which\n * keys are unknown\n */\nexport class VineRecord<Schema extends SchemaTypes> extends BaseType<\n { [K: string]: Schema[typeof OTYPE] },",
"score": 0.845281720161438
},
{
"filename": "src/schema/tuple/main.ts",
"retrieved_chunk": " this.#schemas = schemas\n }\n /**\n * Copy unknown properties to the final output.\n */\n allowUnknownProperties<Value>(): VineTuple<\n Schema,\n [...Output, ...Value[]],\n [...CamelCaseOutput, ...Value[]]\n > {",
"score": 0.8333691358566284
},
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": " * Clone object\n */\n clone(): this {\n const cloned = new VineObject<Properties, Output, CamelCaseOutput>(\n this.getProperties(),\n this.cloneOptions(),\n this.cloneValidations()\n )\n this.#groups.forEach((group) => cloned.merge(group))\n if (this.#allowUnknownProperties) {",
"score": 0.8332738876342773
}
] |
typescript
|
[K in keyof Properties]: Properties[K][typeof OTYPE]
},
{
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import Macroable from '@poppinss/macroable'
import { VineAny } from './any/main.js'
import { VineEnum } from './enum/main.js'
import { union } from './union/builder.js'
import { VineTuple } from './tuple/main.js'
import { VineArray } from './array/main.js'
import { VineObject } from './object/main.js'
import { VineRecord } from './record/main.js'
import { VineString } from './string/main.js'
import { VineNumber } from './number/main.js'
import { VineBoolean } from './boolean/main.js'
import { VineLiteral } from './literal/main.js'
import { CamelCase } from './camelcase_types.js'
import { VineAccepted } from './accepted/main.js'
import { group } from './object/group_builder.js'
import { VineNativeEnum } from './enum/native_enum.js'
import { VineUnionOfTypes } from './union_of_types/main.js'
import { OTYPE, COTYPE, IS_OF_TYPE, UNIQUE_NAME } from '../symbols.js'
import type { EnumLike, FieldContext, SchemaTypes } from '../types.js'
/**
* Schema builder exposes methods to construct a Vine schema. You may
* add custom methods to it using macros.
*/
export class SchemaBuilder extends Macroable {
/**
* Define a sub-object as a union
*/
group = group
/**
* Define a union value
*/
union = union
/**
* Define a string value
*/
string() {
return new VineString()
}
/**
* Define a boolean value
*/
boolean(options?: { strict: boolean }) {
return new VineBoolean(options)
}
/**
* Validate a checkbox to be checked
*/
accepted() {
return new VineAccepted()
}
/**
* Define a number value
*/
number(options?: { strict: boolean }) {
return new VineNumber(options)
}
/**
* Define a schema type in which the input value
* matches the pre-defined value
*/
literal<const Value>(value: Value) {
return new VineLiteral<Value>(value)
}
/**
* Define an object with known properties. You may call "allowUnknownProperties"
* to merge unknown properties.
*/
object<Properties extends Record<string, SchemaTypes>>(properties: Properties) {
return new VineObject<
Properties,
{
[K in keyof Properties]: Properties[K][typeof OTYPE]
},
{
[K in keyof Properties as CamelCase<K & string>]: Properties[K][typeof COTYPE]
}
>(properties)
}
/**
* Define an array field and validate its children elements.
*/
array<Schema extends SchemaTypes>(schema: Schema) {
return new VineArray<Schema>(schema)
}
/**
* Define an array field with known length and each children
* element may have its own schema.
*/
tuple<Schema extends SchemaTypes[]>(schemas: [...Schema]) {
return new VineTuple<
Schema,
{ [K in keyof Schema]: Schema[K][typeof OTYPE] },
{ [K in keyof Schema]: Schema[K][typeof COTYPE] }
>(schemas)
}
/**
* Define an object field with key-value pair. The keys in
* a record are unknown and values can be of a specific
* schema type.
*/
record<Schema extends SchemaTypes>(schema: Schema) {
return new VineRecord<Schema>(schema)
}
/**
* Define a field whose value matches the enum choices.
*/
enum<const Values extends readonly unknown[]>(
values: Values | ((field: FieldContext) => Values)
): VineEnum<Values>
enum<Values extends EnumLike>(values: Values): VineNativeEnum<Values>
enum<Values extends readonly unknown[] | EnumLike>(values: Values): any {
if (Array.isArray(values) || typeof values === 'function') {
return new VineEnum(values)
}
return new VineNativeEnum(values as EnumLike)
}
/**
* Allow the field value to be anything
*/
any() {
return new VineAny()
}
/**
* Define a union of unique schema types.
*/
unionOfTypes<Schema extends SchemaTypes>(schemas: Schema[]) {
const schemasInUse: Set<string> = new Set()
schemas.forEach((schema) => {
if (!schema[IS_OF_TYPE] || !schema[UNIQUE_NAME]) {
throw new Error(
`Cannot use "${schema.constructor.name}". The schema type is not compatible for use with "vine.unionOfTypes"`
)
}
if (schemasInUse.has(schema[UNIQUE_NAME])) {
throw new Error(
`Cannot use duplicate schema "${schema[UNIQUE_NAME]}". "vine.unionOfTypes" needs distinct schema types only`
)
}
schemasInUse.add(schema[UNIQUE_NAME])
})
schemasInUse.clear()
|
return new VineUnionOfTypes(schemas)
}
|
}
|
src/schema/builder.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/union_of_types/main.ts",
"retrieved_chunk": " return this\n }\n /**\n * Clones the VineUnionOfTypes schema type.\n */\n clone(): this {\n const cloned = new VineUnionOfTypes<Schema>(this.#schemas)\n cloned.otherwise(this.#otherwiseCallback)\n return cloned as this\n }",
"score": 0.8746428489685059
},
{
"filename": "src/schema/union_of_types/main.ts",
"retrieved_chunk": " * of conditionals and each condition has an associated schema\n */\nexport class VineUnionOfTypes<Schema extends SchemaTypes>\n implements ConstructableSchema<Schema[typeof OTYPE], Schema[typeof COTYPE]>\n{\n declare [OTYPE]: Schema[typeof OTYPE];\n declare [COTYPE]: Schema[typeof COTYPE]\n #schemas: Schema[]\n #otherwiseCallback: UnionNoMatchCallback<Record<string, unknown>> = (_, field) => {\n field.report(messages.unionOfTypes, 'unionOfTypes', field)",
"score": 0.8515475988388062
},
{
"filename": "src/schema/tuple/main.ts",
"retrieved_chunk": " [UNIQUE_NAME] = 'vine.array';\n /**\n * Checks if the value is of array type. The method must be\n * implemented for \"unionOfTypes\"\n */\n [IS_OF_TYPE] = (value: unknown) => {\n return Array.isArray(value)\n }\n constructor(schemas: [...Schema], options?: FieldOptions, validations?: Validation<any>[]) {\n super(options, validations)",
"score": 0.8266047835350037
},
{
"filename": "src/schema/record/main.ts",
"retrieved_chunk": " }\n #schema: Schema;\n /**\n * The property must be implemented for \"unionOfTypes\"\n */\n [UNIQUE_NAME] = 'vine.object';\n /**\n * Checks if the value is of object type. The method must be\n * implemented for \"unionOfTypes\"\n */",
"score": 0.8161807060241699
},
{
"filename": "src/schema/array/main.ts",
"retrieved_chunk": " #schema: Schema;\n /**\n * The property must be implemented for \"unionOfTypes\"\n */\n [UNIQUE_NAME] = 'vine.array';\n /**\n * Checks if the value is of array type. The method must be\n * implemented for \"unionOfTypes\"\n */\n [IS_OF_TYPE] = (value: unknown) => {",
"score": 0.8143305778503418
}
] |
typescript
|
return new VineUnionOfTypes(schemas)
}
|
/*
* @vinejs/vine
*
* (c) VineJS
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
import Macroable from '@poppinss/macroable'
import { VineAny } from './any/main.js'
import { VineEnum } from './enum/main.js'
import { union } from './union/builder.js'
import { VineTuple } from './tuple/main.js'
import { VineArray } from './array/main.js'
import { VineObject } from './object/main.js'
import { VineRecord } from './record/main.js'
import { VineString } from './string/main.js'
import { VineNumber } from './number/main.js'
import { VineBoolean } from './boolean/main.js'
import { VineLiteral } from './literal/main.js'
import { CamelCase } from './camelcase_types.js'
import { VineAccepted } from './accepted/main.js'
import { group } from './object/group_builder.js'
import { VineNativeEnum } from './enum/native_enum.js'
import { VineUnionOfTypes } from './union_of_types/main.js'
import { OTYPE, COTYPE, IS_OF_TYPE, UNIQUE_NAME } from '../symbols.js'
import type { EnumLike, FieldContext, SchemaTypes } from '../types.js'
/**
* Schema builder exposes methods to construct a Vine schema. You may
* add custom methods to it using macros.
*/
export class SchemaBuilder extends Macroable {
/**
* Define a sub-object as a union
*/
group = group
/**
* Define a union value
*/
union = union
/**
* Define a string value
*/
string() {
return new VineString()
}
/**
* Define a boolean value
*/
boolean(options?: { strict: boolean }) {
return new VineBoolean(options)
}
/**
* Validate a checkbox to be checked
*/
accepted() {
return new VineAccepted()
}
/**
* Define a number value
*/
number(options?: { strict: boolean }) {
return new VineNumber(options)
}
/**
* Define a schema type in which the input value
* matches the pre-defined value
*/
literal<const Value>(value: Value) {
return new VineLiteral<Value>(value)
}
/**
* Define an object with known properties. You may call "allowUnknownProperties"
* to merge unknown properties.
*/
object<Properties extends Record<string, SchemaTypes>>(properties: Properties) {
return new VineObject<
Properties,
{
[K in keyof Properties]: Properties[K][typeof OTYPE]
},
{
[K in keyof Properties as CamelCase<K & string>]: Properties[K][typeof COTYPE]
}
>(properties)
}
/**
* Define an array field and validate its children elements.
*/
array<Schema extends SchemaTypes>(schema: Schema) {
return new VineArray<Schema>(schema)
}
/**
* Define an array field with known length and each children
* element may have its own schema.
*/
tuple<Schema extends SchemaTypes[]>(schemas: [...Schema]) {
return new VineTuple<
Schema,
{ [K in keyof Schema]: Schema[K][typeof OTYPE] },
{ [K in keyof Schema]: Schema[K][typeof COTYPE] }
>(schemas)
}
/**
* Define an object field with key-value pair. The keys in
* a record are unknown and values can be of a specific
* schema type.
*/
record<Schema extends SchemaTypes>(schema: Schema) {
return new VineRecord<Schema>(schema)
}
/**
* Define a field whose value matches the enum choices.
*/
enum<const Values extends readonly unknown[]>(
values: Values | ((field: FieldContext) => Values)
): VineEnum<Values>
enum<Values extends EnumLike>(values: Values): VineNativeEnum<Values>
enum<Values extends readonly unknown[] | EnumLike>(values: Values): any {
if (Array.isArray(values) || typeof values === 'function') {
return new VineEnum(values)
}
return new VineNativeEnum(values as EnumLike)
}
/**
* Allow the field value to be anything
*/
any() {
return new VineAny()
}
/**
* Define a union of unique schema types.
*/
unionOfTypes<Schema extends SchemaTypes>(schemas: Schema[]) {
const schemasInUse: Set<string> = new Set()
schemas.forEach((schema) => {
if (
|
!schema[IS_OF_TYPE] || !schema[UNIQUE_NAME]) {
|
throw new Error(
`Cannot use "${schema.constructor.name}". The schema type is not compatible for use with "vine.unionOfTypes"`
)
}
if (schemasInUse.has(schema[UNIQUE_NAME])) {
throw new Error(
`Cannot use duplicate schema "${schema[UNIQUE_NAME]}". "vine.unionOfTypes" needs distinct schema types only`
)
}
schemasInUse.add(schema[UNIQUE_NAME])
})
schemasInUse.clear()
return new VineUnionOfTypes(schemas)
}
}
|
src/schema/builder.ts
|
vinejs-vine-f8fa0af
|
[
{
"filename": "src/schema/union_of_types/main.ts",
"retrieved_chunk": " return this\n }\n /**\n * Clones the VineUnionOfTypes schema type.\n */\n clone(): this {\n const cloned = new VineUnionOfTypes<Schema>(this.#schemas)\n cloned.otherwise(this.#otherwiseCallback)\n return cloned as this\n }",
"score": 0.8696867227554321
},
{
"filename": "src/schema/union_of_types/main.ts",
"retrieved_chunk": " * of conditionals and each condition has an associated schema\n */\nexport class VineUnionOfTypes<Schema extends SchemaTypes>\n implements ConstructableSchema<Schema[typeof OTYPE], Schema[typeof COTYPE]>\n{\n declare [OTYPE]: Schema[typeof OTYPE];\n declare [COTYPE]: Schema[typeof COTYPE]\n #schemas: Schema[]\n #otherwiseCallback: UnionNoMatchCallback<Record<string, unknown>> = (_, field) => {\n field.report(messages.unionOfTypes, 'unionOfTypes', field)",
"score": 0.8656412959098816
},
{
"filename": "src/schema/array/main.ts",
"retrieved_chunk": " #schema: Schema;\n /**\n * The property must be implemented for \"unionOfTypes\"\n */\n [UNIQUE_NAME] = 'vine.array';\n /**\n * Checks if the value is of array type. The method must be\n * implemented for \"unionOfTypes\"\n */\n [IS_OF_TYPE] = (value: unknown) => {",
"score": 0.8539644479751587
},
{
"filename": "src/schema/tuple/main.ts",
"retrieved_chunk": " [UNIQUE_NAME] = 'vine.array';\n /**\n * Checks if the value is of array type. The method must be\n * implemented for \"unionOfTypes\"\n */\n [IS_OF_TYPE] = (value: unknown) => {\n return Array.isArray(value)\n }\n constructor(schemas: [...Schema], options?: FieldOptions, validations?: Validation<any>[]) {\n super(options, validations)",
"score": 0.8487511873245239
},
{
"filename": "src/schema/record/main.ts",
"retrieved_chunk": " }\n #schema: Schema;\n /**\n * The property must be implemented for \"unionOfTypes\"\n */\n [UNIQUE_NAME] = 'vine.object';\n /**\n * Checks if the value is of object type. The method must be\n * implemented for \"unionOfTypes\"\n */",
"score": 0.8313137292861938
}
] |
typescript
|
!schema[IS_OF_TYPE] || !schema[UNIQUE_NAME]) {
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.