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/apis/decks.api.ts",
"retrieved_chunk": " const deck = await ds.CardDecks.get(player.id, path[0]);\n if (!deck) {\n return [StatusCodes.notFound];\n }\n return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];\n }\n }\n };\nexport const getOrCreateActiveDeck = async (player: IDataSource.IPlayer, ds: IDataSource) => {\n let deck = player.activeDeckId ? (await ds.CardDecks.get(player.id, player.activeDeckId)) : null;",
"score": 27.611091731105113
},
{
"filename": "src/apis/cards.api.ts",
"retrieved_chunk": " if (id.startsWith('nft1')) {\n return _handleCardsNft(id);\n }\n }\n return [StatusCodes.badRequest, { reason: 'invalid id' }];\n };\n async function _handleCardsNft(nftId: string): Promise<ReturnType<IHttpRouteHandler>> {\n const resp = await ExtDeps.getNft(nftId);\n if (resp?.nft) {\n return [StatusCodes.ok, {",
"score": 27.15660438958627
},
{
"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": 22.89982967220168
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": "import * as moment from 'moment';\nimport { createCoopHandler } from './apis/coop.api';\nimport { IAuthProvider, IDataSource, IPlayerPushProvider, IRateLimitProvider } from './dependencies';\nimport { CardMod } from './game/card-mods';\nimport { CardScript } from './game/card-scripts';\nimport { GameEngine, createGameEngineProvider } from './game/game-engine';\nimport { GameEngineUtils } from './game/game-engine-utils';\nimport { IHttpRequest, IHttpRouteHandler, StatusCodes } from './net-utils';\nimport { FULL_DATETIME_FORMAT } from './utils';\n/**",
"score": 22.785017947368587
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " }\n case 'activeDeck': {\n const player = await authProvider.getPlayerFromRequest(req);\n return [StatusCodes.ok, { deck: toClientDeck(player, await getOrCreateActiveDeck(player, ds)) }];\n }\n default: {\n if (!path[0]) {\n return;\n }\n const player = await authProvider.getPlayerFromRequest(req);",
"score": 21.03640362242405
}
] | 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": 84.71580959836184
},
{
"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": 79.19523400832658
},
{
"filename": "src/models.ts",
"retrieved_chunk": " return {\n id: deck.createdAt,\n label: deck.label,\n cards: deck.cards.map(appraiseCard),\n isActiveDeck: player.activeDeckId === deck.createdAt,\n };\n};",
"score": 74.55604533617112
},
{
"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": 63.95571578970552
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " const player = await _expectAuthPlayerNotInGame(req);\n const deck = await _expectValidActiveDeck(player, true);\n if (await rateLimit.shouldRateLimitCreateGame(player.id)) {\n return [StatusCodes.tooManyRequests];\n }\n const now = moment.utc();\n const game: IDataSource.ICoopGame = {\n id: randomBytes(16).toString('hex'),\n createdAt: now.format(FULL_DATETIME_FORMAT),\n difficulty: payload.difficulty,",
"score": 55.964357482080175
}
] | 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": " 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": 51.320798212161236
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " return {\n player,\n game,\n };\n }\n player.activeGameId = '';\n await ds.Players.update.exec(player);\n throw new RouteError(StatusCodes.forbidden, 'player is not in game');\n }\n async function _expectAuthPlayerNotInGame(req: IHttpRequest) {",
"score": 47.993931339968356
},
{
"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": 47.9716325980058
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " case 'activate': {\n const schema = z.object({\n deckId: z.string(),\n });\n const payload = schema.parse(body);\n const player = await authProvider.getPlayerFromRequest(req);\n const deck = await ds.CardDecks.get(player.id, payload.deckId);\n if (!deck) return [StatusCodes.notFound];\n player.activeDeckId = deck.createdAt;\n await ds.Players.update.exec(player);",
"score": 46.13604992983419
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " }\n case 'activeDeck': {\n const player = await authProvider.getPlayerFromRequest(req);\n return [StatusCodes.ok, { deck: toClientDeck(player, await getOrCreateActiveDeck(player, ds)) }];\n }\n default: {\n if (!path[0]) {\n return;\n }\n const player = await authProvider.getPlayerFromRequest(req);",
"score": 44.63689080609491
}
] | 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/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": 22.872269104974507
},
{
"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": 20.232687101932967
},
{
"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": 19.453291687092275
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " }\n }\n return evntRetVal as ReturnType<NonNullable<CardMod[T]>> | undefined;\n }\n}\nexport namespace CardMod {\n export type ModData = [string, StackingData, ...unknown[],];\n export type DurationData = ['$duration', number];\n export type EnemyModData = unknown[];\n export type ModConstructor = TypeConstructor<CardMod>;",
"score": 19.137454860279476
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\n export interface IEnemyCardState extends _ICommonCardState {\n enemyClass: string;\n intent?: { scriptData: CardScript.ScriptData, targetCardId: number };\n maxMem: number;\n }\n export type ICardState = IPlayerCardState | IEnemyCardState;\n export abstract class GameEngineError extends Error {\n constructor(\n public gameId: string,",
"score": 18.63309444099182
}
] | 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": 55.892543179440224
},
{
"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": 52.26856592824165
},
{
"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": 51.8617315582538
},
{
"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": 50.22028763831703
},
{
"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": 49.59139881510859
}
] | 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": " };\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": 69.14888665562555
},
{
"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": 61.684536008417254
},
{
"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": 52.71704004609194
},
{
"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": 43.02692077879456
},
{
"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": 42.15385956620297
}
] | 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/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": 55.057423636755956
},
{
"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": 47.797347497513755
},
{
"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": 43.19376557305193
},
{
"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": 38.66933553275516
},
{
"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": 38.12395983396844
}
] | 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 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": 109.07131384434595
},
{
"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": 96.57332007214187
},
{
"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": 91.62547147056186
},
{
"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": 90.98027302988365
},
{
"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": 83.99470142948529
}
] | 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/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": 49.34954679658345
},
{
"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": 46.20120419591834
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " }\n engine.broadcast.push({\n type: 'cardExecuted',\n cardId: sourceCard.id,\n targetCardId: targetCard.id,\n scriptData: scriptDataFromCard || sourceCardScript,\n });\n }\n static findCooldownData(data: CardScript.ScriptData) {\n return data.find((x): x is CardScript.CooldownData => Array.isArray(x) && x[0] === '$cooldown');",
"score": 45.280919783415726
},
{
"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": 43.45276535965986
},
{
"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": 42.30971831548323
}
] | typescript | .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/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": 50.72125094164769
},
{
"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": 44.94780800621861
},
{
"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": 39.46527486906549
},
{
"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": 38.858696535457874
},
{
"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": 37.880333830972084
}
] | typescript | contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null; |
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/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": 23.295923644536256
},
{
"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": 22.399063115675236
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " * Players are normally created via /players/connectDid; to keep this example concise,\n * we'll inject one with CO8's DID into the mock database.\n */\n const mockPlayer = {\n id: 'did:chia:1sc5hxvcs26e4zsc7uvlfuc7x9sjj5aw6cu0g8vcyvscy49ffp8zqwh63tq',\n activeDeckId: '',\n activeGameId: '',\n secret: '',\n authExpiresAt: '2100-01-01',\n createdAt: moment.utc().format(FULL_DATETIME_FORMAT),",
"score": 20.165919091648085
},
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " authExpiresAt: string;\n activeGameId: string;\n activeDeckId: string;\n score: number;\n }\n export type Players = {\n get: GetterSingle<IPlayer>;\n update: Updater<IPlayer>;\n };\n export interface IPlayerCoopGame {",
"score": 20.148342022496106
},
{
"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": 16.562252331476117
}
] | typescript | newUser(player.id); |
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": " {\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": 45.90458380520851
},
{
"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": 39.197353415373854
},
{
"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": 38.613383107812446
},
{
"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": 38.27957739847533
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " }\n engine.broadcast.push({\n type: 'cardExecuted',\n cardId: sourceCard.id,\n targetCardId: targetCard.id,\n scriptData: scriptDataFromCard || sourceCardScript,\n });\n }\n static findCooldownData(data: CardScript.ScriptData) {\n return data.find((x): x is CardScript.CooldownData => Array.isArray(x) && x[0] === '$cooldown');",
"score": 37.659270431693024
}
] | 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": " };\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": 109.14710862927532
},
{
"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": 101.55131136315109
},
{
"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": 93.31226103226915
},
{
"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": 89.13812700233142
},
{
"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": 86.94444824322983
}
] | 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/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": 31.917949957019847
},
{
"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": 27.53996931382044
},
{
"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": 27.399048779999042
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (powerBuff) {\n const powerStacks = CardMod.getStackCount(powerBuff);\n numAttacks += powerStacks;\n }\n for (let i = 0; i < numAttacks - 1; i++) {\n GameEngineUtils.executeIntent(deps.engine, boss, true);\n }\n GameEngineUtils.executeIntent(deps.engine, boss);\n }\n override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {",
"score": 27.15870907879937
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " type: 'cpuChanged',\n cardId: deps.sourceCard.id,\n newCpu: deps.sourceCard.cpu,\n });\n GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);\n }\n },\n // Damages on turn end\n virus: class extends CardMod {\n override stackingConfig = {",
"score": 26.66730025064087
}
] | 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/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": 37.08345391207395
},
{
"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": 26.948666265197254
},
{
"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": 25.349811631016372
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " }\n engine.broadcast.push({\n type: 'cardExecuted',\n cardId: sourceCard.id,\n targetCardId: targetCard.id,\n scriptData: scriptDataFromCard || sourceCardScript,\n });\n }\n static findCooldownData(data: CardScript.ScriptData) {\n return data.find((x): x is CardScript.CooldownData => Array.isArray(x) && x[0] === '$cooldown');",
"score": 25.078130201865044
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " (gameData: GameEngine.IGameData, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): GameEngine.ICardState[];\n }\n export interface ITargetFinder {\n (gameData: GameEngine.IGameData, card: GameEngine.ICardState): GameEngine.ICardState[];\n }\n export namespace TargetResolvers {\n export const Self: ITargetResolver = (_, sourceCard) => [sourceCard];\n export const Target: ITargetResolver = (_, _2, targetCard) => [targetCard];\n export const TargetAndAdjacents: ITargetResolver = (gameData, _, targetCard) => {\n const cards = GameEngineUtils.isEnemyCard(gameData, targetCard) ? gameData.enemies : (GameEngineUtils.findPlayerByCardId(gameData, targetCard.id).cards);",
"score": 25.046390994104662
}
] | 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/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": 94.49036624585501
},
{
"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": 80.53738159558772
},
{
"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": 77.75696693310539
},
{
"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": 77.3710469792276
},
{
"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": 76.82997673281602
}
] | 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": 74.91689999839627
},
{
"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": 56.29270260311501
},
{
"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": 49.70189870046108
},
{
"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": 46.24074611990988
},
{
"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": 45.870682680124396
}
] | 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/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": 77.7080689183907
},
{
"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": 60.56307159033185
},
{
"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": 59.43186307717163
},
{
"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": 59.01079635151197
},
{
"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": 58.23203896452895
}
] | 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": " {\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": 36.84104901285723
},
{
"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": 35.25595763974414
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " }\n engine.broadcast.push({\n type: 'cardExecuted',\n cardId: sourceCard.id,\n targetCardId: targetCard.id,\n scriptData: scriptDataFromCard || sourceCardScript,\n });\n }\n static findCooldownData(data: CardScript.ScriptData) {\n return data.find((x): x is CardScript.CooldownData => Array.isArray(x) && x[0] === '$cooldown');",
"score": 31.1324223482536
},
{
"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": 29.745346334684967
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " }\n enemy.intent = dontClearIntent ? enemy.intent : undefined;\n let targetCard: GameEngine.ICardState | undefined;\n if (intent.targetCardId >= 0) {\n targetCard = findCardByIdMaybe(engine.gameData, intent.targetCardId);\n if (!targetCard) {\n // Intent target could've been removed between intent generation and execution\n return false;\n }\n } else {",
"score": 29.35706530527925
}
] | 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/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": 71.82773315349043
},
{
"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": 70.58138163442014
},
{
"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": 69.72077592742997
},
{
"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": 68.2179719666896
},
{
"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": 66.37079499313502
}
] | 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/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": 46.320467871916314
},
{
"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": 35.96182882402133
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " (gameData: GameEngine.IGameData, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): GameEngine.ICardState[];\n }\n export interface ITargetFinder {\n (gameData: GameEngine.IGameData, card: GameEngine.ICardState): GameEngine.ICardState[];\n }\n export namespace TargetResolvers {\n export const Self: ITargetResolver = (_, sourceCard) => [sourceCard];\n export const Target: ITargetResolver = (_, _2, targetCard) => [targetCard];\n export const TargetAndAdjacents: ITargetResolver = (gameData, _, targetCard) => {\n const cards = GameEngineUtils.isEnemyCard(gameData, targetCard) ? gameData.enemies : (GameEngineUtils.findPlayerByCardId(gameData, targetCard.id).cards);",
"score": 34.922976468292724
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const targetCard = GameEngineUtils.findCardById(engine.gameData, targetCardId);\n CardScript.execute(engine, sourceCard, sourceCardScript, targetCard);\n GameEngineUtils.changeCardIsUsed(engine, sourceCard, true);\n metrics?.playerCardPlayed(gameId, engine.gameData.rulesetIds[0] || 'unknown', playerId, sourceCard, sourceCardScript[0]);\n });\n }\n static async toggleEndTurn(gameId: string, playerId: string) {\n return await _Engine._withEngine(gameId, ['started'], async engine => {\n const playerState = engine.gameData.players.get(playerId);\n if (!playerState) throw new Error('player not found');",
"score": 34.30732902010564
},
{
"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": 33.37628932760866
}
] | 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/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": 49.34954679658345
},
{
"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": 46.20120419591834
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " }\n engine.broadcast.push({\n type: 'cardExecuted',\n cardId: sourceCard.id,\n targetCardId: targetCard.id,\n scriptData: scriptDataFromCard || sourceCardScript,\n });\n }\n static findCooldownData(data: CardScript.ScriptData) {\n return data.find((x): x is CardScript.CooldownData => Array.isArray(x) && x[0] === '$cooldown');",
"score": 45.280919783415726
},
{
"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": 43.45276535965986
},
{
"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": 42.30971831548323
}
] | 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/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": 131.0532502171299
},
{
"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": 121.05066238085044
},
{
"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": 117.95430093477047
},
{
"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": 117.75666229552498
},
{
"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": 116.51460039725619
}
] | 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": " 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": 60.784365404963786
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " }\n enemy.intent = dontClearIntent ? enemy.intent : undefined;\n let targetCard: GameEngine.ICardState | undefined;\n if (intent.targetCardId >= 0) {\n targetCard = findCardByIdMaybe(engine.gameData, intent.targetCardId);\n if (!targetCard) {\n // Intent target could've been removed between intent generation and execution\n return false;\n }\n } else {",
"score": 58.880574548153064
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " (gameData: GameEngine.IGameData, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): GameEngine.ICardState[];\n }\n export interface ITargetFinder {\n (gameData: GameEngine.IGameData, card: GameEngine.ICardState): GameEngine.ICardState[];\n }\n export namespace TargetResolvers {\n export const Self: ITargetResolver = (_, sourceCard) => [sourceCard];\n export const Target: ITargetResolver = (_, _2, targetCard) => [targetCard];\n export const TargetAndAdjacents: ITargetResolver = (gameData, _, targetCard) => {\n const cards = GameEngineUtils.isEnemyCard(gameData, targetCard) ? gameData.enemies : (GameEngineUtils.findPlayerByCardId(gameData, targetCard.id).cards);",
"score": 57.800564893793485
},
{
"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": 56.65848004116093
},
{
"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": 54.881976329516036
}
] | 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": 74.31613950602267
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " }\n }\n return standardTargets;\n };\n export const Any = (ignoreTaunt = false): ITargetFinder =>\n (gameData, card) => [\n ...Opponents(ignoreTaunt)(gameData, card),\n ...Allies()(gameData, card),\n ];\n export const _ModFilter = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modFilter: K[], targetFinder: ITargetFinder): ITargetFinder =>",
"score": 45.19059583458002
},
{
"filename": "src/extensions.d.ts",
"retrieved_chunk": "declare interface Array<T> {\n findAndRemoveFirst(predicate: (item: T) => boolean): boolean;\n random(): T;\n randomOrUndefined(): T | undefined;\n removeFirst(item: T): boolean;\n filter(booleanCtor: typeof Boolean): NonNullableVoid<T>[];\n}\ndeclare type NonNullableVoid<T> = Exclude<NonNullable<T>, void>;\ndeclare type StringsStartingWith<T extends string, K extends string> = T extends `${K}${infer _X}` ? T : never;\ndeclare type KeyOfFilteredByValueType<T, F> = NonNullable<{ [K in keyof T]: T[K] extends F ? K : never }[keyof T]>;",
"score": 42.04283682873917
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " this.removeMod(engine, card, existingModData, contextCard);\n if (card.isRemoved) return;\n }\n card.mods.push(modData);\n break;\n }\n case CardMod.StackingBehavior.replace: {\n const existingModData = card.mods.find(x => x[0] === mod.modName);\n if (existingModData) {\n this.removeMod(engine, card, existingModData, contextCard);",
"score": 36.27297657033179
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " card.mods.push(modData);\n break;\n }\n case CardMod.StackingBehavior.ranked: {\n const existingModData = card.mods.find(x => x[0] === mod.modName);\n if (existingModData) {\n const existingStackingData = existingModData[1] as CardMod.RankedStackingData;\n if (existingStackingData[2] >= mod.stackingConfig.rank) {\n return;\n }",
"score": 36.15332207978922
}
] | typescript | removeModByName(engine, targetCard, modName, sourceCard); |
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": 33.475238269557686
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " bd_patch: class extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const secBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);\n super(\n [secBonus],\n CardScript.TargetFinders.Any(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [",
"score": 27.90315778167118
},
{
"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": 25.053958540674792
},
{
"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": 25.050927601773232
},
{
"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": 22.208540570342905
}
] | typescript | .RaiseSec(secBonus),
],
} |
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 (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": 46.1945350834718
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " (gameData: GameEngine.IGameData, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): GameEngine.ICardState[];\n }\n export interface ITargetFinder {\n (gameData: GameEngine.IGameData, card: GameEngine.ICardState): GameEngine.ICardState[];\n }\n export namespace TargetResolvers {\n export const Self: ITargetResolver = (_, sourceCard) => [sourceCard];\n export const Target: ITargetResolver = (_, _2, targetCard) => [targetCard];\n export const TargetAndAdjacents: ITargetResolver = (gameData, _, targetCard) => {\n const cards = GameEngineUtils.isEnemyCard(gameData, targetCard) ? gameData.enemies : (GameEngineUtils.findPlayerByCardId(gameData, targetCard.id).cards);",
"score": 45.8170695924446
},
{
"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": 43.789446998764326
},
{
"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": 42.490777967372026
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " }\n enemy.intent = dontClearIntent ? enemy.intent : undefined;\n let targetCard: GameEngine.ICardState | undefined;\n if (intent.targetCardId >= 0) {\n targetCard = findCardByIdMaybe(engine.gameData, intent.targetCardId);\n if (!targetCard) {\n // Intent target could've been removed between intent generation and execution\n return false;\n }\n } else {",
"score": 41.24313010844211
}
] | typescript | if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) 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-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": 69.70628201570305
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " }\n override onTurnStart(deps: CardMod.ICardModDeps) {\n 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 onRemoveMod(deps: ICardModDeps): void {\n if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {",
"score": 57.45016965115875
},
{
"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": 56.20321903437455
},
{
"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": 55.91907598504076
},
{
"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": 55.12780107863074
}
] | 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/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": 64.93954467849623
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " }\n const highDiff = engine.gameData.difficulty >= 7;\n if (engine.gameData.enemies.length <= (highDiff ? 6 : 4)) {\n while (engine.gameData.enemies.findIndex(x => x.id === source.id) < (highDiff ? 4 : 3)) {\n CardScriptParts.SpawnEnemy('reaper_feeder', 'absLeft')(engine, source, target);\n }\n while (engine.gameData.enemies.length < (highDiff ? 9 : 7)) {\n CardScriptParts.SpawnEnemy('reaper_feeder', 'absRight')(engine, source, target);\n }\n }",
"score": 57.18759195307941
},
{
"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": 53.09713325002034
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " return round(value * Math.pow(1.1, difficulty - 1), decimals);\n }\n export function spawnEnemy(engine: GameEngine.IGameEngine, enemyClass: string, spawnIndex: number, generateIntent: boolean) {\n const enemyFactory = engine.ruleset.enemyCards?.[enemyClass];\n if (!enemyFactory) throw new Error('EnemyClass not found for spawning: ' + enemyClass);\n const enemy = enemyFactory(engine);\n enemy.enemyClass = enemyClass;\n return addEnemy(engine, enemy, spawnIndex, generateIntent);\n }\n export function triggerMods<T extends CardMod.ModEvent>(ev: T, ...args: Parameters<NonNullable<CardMod[typeof ev]>>): ReturnType<NonNullable<CardMod[typeof ev]>>[] {",
"score": 51.35700904714579
},
{
"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": 49.46562963899987
}
] | typescript | .spawnEnemy(engine, enemyClass, spawnIndex, generateIntent); |
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": 70.6546825836563
},
{
"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": 49.28794241150561
},
{
"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": 47.82661670763465
},
{
"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": 45.183542523426034
},
{
"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": 44.66510811498143
}
] | typescript | CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
} |
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-engine-utils.ts",
"retrieved_chunk": " }\n enemy.intent = dontClearIntent ? enemy.intent : undefined;\n let targetCard: GameEngine.ICardState | undefined;\n if (intent.targetCardId >= 0) {\n targetCard = findCardByIdMaybe(engine.gameData, intent.targetCardId);\n if (!targetCard) {\n // Intent target could've been removed between intent generation and execution\n return false;\n }\n } else {",
"score": 60.78759004565284
},
{
"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": 60.784365404963786
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " (gameData: GameEngine.IGameData, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): GameEngine.ICardState[];\n }\n export interface ITargetFinder {\n (gameData: GameEngine.IGameData, card: GameEngine.ICardState): GameEngine.ICardState[];\n }\n export namespace TargetResolvers {\n export const Self: ITargetResolver = (_, sourceCard) => [sourceCard];\n export const Target: ITargetResolver = (_, _2, targetCard) => [targetCard];\n export const TargetAndAdjacents: ITargetResolver = (gameData, _, targetCard) => {\n const cards = GameEngineUtils.isEnemyCard(gameData, targetCard) ? gameData.enemies : (GameEngineUtils.findPlayerByCardId(gameData, targetCard.id).cards);",
"score": 60.22268892180804
},
{
"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": 59.80655692676582
},
{
"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": 58.11930104265653
}
] | 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-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": 74.41585223142953
},
{
"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": 72.6870409087494
},
{
"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": 72.29946407688087
},
{
"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": 60.37560930565193
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " }\n override onRemoveMod(deps: ICardModDeps) {\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -this.stackingConfig.stackCount, true);\n }\n }\n export class _waveBonus_extraMove extends CardMod {\n override onInitMod(deps: ICardModDeps): void {\n const player = GameEngineUtils.findPlayerByCardId(deps.engine.gameData, deps.sourceCard.id);\n player.movesPerTurn++;\n player.movesLeft = player.movesPerTurn;",
"score": 53.64653803890037
}
] | 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": 58.50454535637246
},
{
"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": 25.053958540674792
},
{
"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": 22.574805805500624
},
{
"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": 22.208540570342905
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " const offlineDuration = 1;\n super(\n [offlineDuration],\n CardScript.TargetFinders.Any(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new CardMod.Content.offline(offlineDuration),",
"score": 21.85397053653367
}
] | 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-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": 63.99288479963327
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " engine.broadcast.push({\n type: 'cardIntent',\n cardId: targetCard.id,\n intent: targetCard.intent,\n });\n };\n export const RemoveMod = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modName: K, mustRemove = false): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n if (mustRemove) {\n if (!targetCard.mods.find(x => x[0] === modName)) {",
"score": 57.20452408069113
},
{
"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": 56.488520140927484
},
{
"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": 51.62078655449534
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " const deps = args[0];\n const card = deps.sourceCard;\n return [...card.mods]\n .map(modData => (!card.isRemoved && card.mods.find(x => CardMod.areEqual(x, modData))) ? CardMod.trigger(ev, modData, ...args) : undefined)\n .filter(Boolean);\n }\n}",
"score": 49.71585440259758
}
] | 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/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": 42.29753899749288
},
{
"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": 39.204029575653344
},
{
"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": 32.98919079128998
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " return [...gameData.players.values()].find(x => x.cards.find(x => x.id === cardId));\n }\n export function generateIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {\n enemy.intent = undefined;\n const isOffline = !!enemy.mods.find(x => x[0] === 'offline');\n if (isOffline) return;\n const scriptData = enemy.scripts.filter(x => !CardScript.isOnCooldown(x)).randomOrUndefined();\n if (!scriptData) {\n return;\n }",
"score": 30.76345963726255
},
{
"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": 30.011486993819112
}
] | 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": 38.26144171718097
},
{
"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": 38.03790654607509
},
{
"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": 36.547105251857836
},
{
"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": 32.64563425439995
},
{
"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": 31.423817580481384
}
] | 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": " [damage, lagChance, lagDuration],\n CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.Attack(damage),\n ],\n },\n {",
"score": 32.61603110147714
},
{
"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": 32.600791782686684
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [\n {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),\n ],\n }\n ],\n );\n this.cooldownMax = 1;",
"score": 30.204717638461737
},
{
"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": 30.204717638461737
},
{
"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": 29.603433277305612
}
] | 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": " 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": 58.676489438772016
},
{
"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": 44.111532185990576
},
{
"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": 42.23806828572523
},
{
"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": 40.79293756694969
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " (gameData: GameEngine.IGameData, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): GameEngine.ICardState[];\n }\n export interface ITargetFinder {\n (gameData: GameEngine.IGameData, card: GameEngine.ICardState): GameEngine.ICardState[];\n }\n export namespace TargetResolvers {\n export const Self: ITargetResolver = (_, sourceCard) => [sourceCard];\n export const Target: ITargetResolver = (_, _2, targetCard) => [targetCard];\n export const TargetAndAdjacents: ITargetResolver = (gameData, _, targetCard) => {\n const cards = GameEngineUtils.isEnemyCard(gameData, targetCard) ? gameData.enemies : (GameEngineUtils.findPlayerByCardId(gameData, targetCard.id).cards);",
"score": 39.26623610008511
}
] | 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": " );\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": 30.87189007875282
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " return { secDmgBonus: -9999 };\n }\n },\n },\n cardScripts: {\n reaper_bossEat: class extends CardScript {\n constructor(_card: GameEngine.ICardState) {\n super(\n [],\n (gameData, _card) => {",
"score": 29.397157728110706
},
{
"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": 28.242755855747944
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " stasis_disrupt: class extends CardScript {\n constructor(card: GameEngine.ICardState, difficulty: number) {\n const dmg = GameEngineUtils.scaleByDifficulty(GameEngineUtils.scaleByCpuMem(5, card.cpu), difficulty);\n super(\n [difficulty, dmg],\n CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [",
"score": 28.160299115254446
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " );\n this.cooldownMax = cooldown;\n }\n }\n export class _firewallSelf extends CardScript {\n constructor(_card: GameEngine.ICardState, duration = 1, cooldown = 0, startingCooldown = 0) {\n super(\n [duration, cooldown],\n TargetFinders.Self,\n [",
"score": 27.84378196826782
}
] | 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-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": 79.29311597314371
},
{
"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": 56.91659176400647
},
{
"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": 56.09684020276986
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " const mod = this.deserialize(deps.engine, modDataFromCard);\n const evnt = mod[ev];\n const evntRetVal = evnt ? (evnt as any).apply(mod, args) : undefined;\n if (deps.sourceCard.isRemoved) {\n return;\n }\n if (ev === 'onTurnStart') {\n const durationData = this.findDurationData(modDataFromCard);\n if (durationData) {\n if (durationData[1] > 1) {",
"score": 49.98834770570739
},
{
"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": 48.46743170703476
}
] | 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/game/game-engine-utils.ts",
"retrieved_chunk": " const player = findPlayerByCardIdMaybe(gameData, cardId);\n if (!player) throw new Error('player not found');\n return player.cards.find(x => x.id === cardId)!;\n }\n export function findPlayerByCardId(gameData: GameEngine.IGameData, cardId: number) {\n const player = findPlayerByCardIdMaybe(gameData, cardId);\n if (player) return player;\n throw new Error('player not found');\n }\n export function findPlayerByCardIdMaybe(gameData: GameEngine.IGameData, cardId: number) {",
"score": 37.64092130108385
},
{
"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": 36.408954292940486
},
{
"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": 33.79700896125195
},
{
"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": 33.590794878500134
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " gameId: game.id,\n gameResult,\n score: playerState?.score || 0,\n teammates: _getOtherPlayerIds(playerId, game),\n turns: gameData?.turn || -1,\n difficulty: game.difficulty,\n rulesetIds: gameData?.rulesetIds || [],\n }, true),\n ds.Players.update.make(player, true),\n ];",
"score": 33.17851358607754
}
] | 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 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": 30.841024769493742
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " return { secDmgBonus: -9999 };\n }\n },\n },\n cardScripts: {\n reaper_bossEat: class extends CardScript {\n constructor(_card: GameEngine.ICardState) {\n super(\n [],\n (gameData, _card) => {",
"score": 29.397157728110706
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " );\n this.cooldownMax = cooldown;\n }\n }\n export class _firewallSelf extends CardScript {\n constructor(_card: GameEngine.ICardState, duration = 1, cooldown = 0, startingCooldown = 0) {\n super(\n [duration, cooldown],\n TargetFinders.Self,\n [",
"score": 27.84378196826782
},
{
"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": 26.521053158818304
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " }\n }\n export class bf_firewall extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n const modDuration = Math.ceil(card.mem / 2);\n super(\n [secBonus, modDuration],\n TargetFinders.Self,\n [",
"score": 26.315413541670562
}
] | 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": " 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": 35.05859411424893
},
{
"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": 31.014558785149955
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " this.removeMod(engine, card, existingModData, contextCard);\n if (card.isRemoved) return;\n }\n card.mods.push(modData);\n break;\n }\n case CardMod.StackingBehavior.replace: {\n const existingModData = card.mods.find(x => x[0] === mod.modName);\n if (existingModData) {\n this.removeMod(engine, card, existingModData, contextCard);",
"score": 29.379815980168562
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " for (const enemy of [...this.gameData.enemies]) {\n if (!this.gameData.enemies.includes(enemy)) continue;\n GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: enemy });\n CardScript.tickCooldowns(enemy, this.broadcast);\n }\n this.broadcast.push({\n type: 'enemyTurnEnded',\n });\n this._checkGameOver();\n }",
"score": 26.994927766849905
},
{
"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": 26.300041334093056
}
] | 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": 51.15977790714934
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " const gameData = await gameEngineProvider.getGameData(game.id);\n const playerState = gameData.players.get(player.id);\n if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {\n const now = moment.utc().format(FULL_DATETIME_FORMAT);\n await ds.PlayerCoopGames.update.exec({\n playerId: player.id,\n endedAt: now,\n gameId: game.id,\n gameResult: _getGameResult(gameData),\n score: playerState.score,",
"score": 43.53427275632066
},
{
"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": 41.762574061491975
},
{
"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": 35.59916494843335
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " }\n return deck;\n }\n};\nexport async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {\n const game = await ds.CoopGames.get(gameId);\n if (!game) throw new Error('game not found: ' + gameId);\n if (game.gameState.startsWith('ended')) return;\n const now = moment.utc();\n game.gameState = `ended_${now.format(DATE_FORMAT)}`;",
"score": 34.36255119676218
}
] | 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": 38.26144171718097
},
{
"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": 38.03790654607509
},
{
"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": 36.547105251857836
},
{
"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": 32.64563425439995
},
{
"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": 31.423817580481384
}
] | 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-scripts.ts",
"retrieved_chunk": " (gameData, card) => {\n const targets = targetFinder(gameData, card);\n const modMatches = targets.filter(target => target.mods.find(modData => modFilter.find(x => x === modData[0])));\n return _excludeImperviousAndOffline(modMatches);\n };\n const _excludeImpervious = (cards: GameEngine.ICardState[]) => {\n return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.impervious.name));\n };\n export const _excludeOffline = (cards: GameEngine.ICardState[]) => {\n return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.offline.name));",
"score": 69.97437953648495
},
{
"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": 63.588129926442285
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " }\n engine.broadcast.push({\n type: 'cardExecuted',\n cardId: sourceCard.id,\n targetCardId: targetCard.id,\n scriptData: scriptDataFromCard || sourceCardScript,\n });\n }\n static findCooldownData(data: CardScript.ScriptData) {\n return data.find((x): x is CardScript.CooldownData => Array.isArray(x) && x[0] === '$cooldown');",
"score": 53.48290179750949
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\n export interface IRuleset extends IRulesetContent {\n initGame(engine: IGameEngine): void;\n addAdditionalScriptsFor?(engine: GameEngine.IGameEngine, card: IPlayerCardState): void;\n }\n export function mergeRulesetContents(...rulesets: IRulesetContent[]): IRulesetContent {\n const modLibs = rulesets.map(x => x.cardMods).filter(Boolean);\n const scriptLibs = rulesets.map(x => x.cardScripts).filter(Boolean);\n const enemyLibs = rulesets.map(x => x.enemyCards).filter(Boolean);\n return {",
"score": 52.61806362325283
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " engine.broadcast.push({\n type: 'cardIntent',\n cardId: targetCard.id,\n intent: targetCard.intent,\n });\n };\n export const RemoveMod = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modName: K, mustRemove = false): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n if (mustRemove) {\n if (!targetCard.mods.find(x => x[0] === modName)) {",
"score": 50.72692267590964
}
] | 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": 73.10289452910034
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " engine.broadcast.push({\n type: 'cardIntent',\n cardId: targetCard.id,\n intent: targetCard.intent,\n });\n };\n export const RemoveMod = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modName: K, mustRemove = false): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n if (mustRemove) {\n if (!targetCard.mods.find(x => x[0] === modName)) {",
"score": 48.30718099899681
},
{
"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": 34.99494841042738
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const targetCard = GameEngineUtils.findCardById(engine.gameData, targetCardId);\n CardScript.execute(engine, sourceCard, sourceCardScript, targetCard);\n GameEngineUtils.changeCardIsUsed(engine, sourceCard, true);\n metrics?.playerCardPlayed(gameId, engine.gameData.rulesetIds[0] || 'unknown', playerId, sourceCard, sourceCardScript[0]);\n });\n }\n static async toggleEndTurn(gameId: string, playerId: string) {\n return await _Engine._withEngine(gameId, ['started'], async engine => {\n const playerState = engine.gameData.players.get(playerId);\n if (!playerState) throw new Error('player not found');",
"score": 29.797380232419457
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\n export interface IEnemyCardState extends _ICommonCardState {\n enemyClass: string;\n intent?: { scriptData: CardScript.ScriptData, targetCardId: number };\n maxMem: number;\n }\n export type ICardState = IPlayerCardState | IEnemyCardState;\n export abstract class GameEngineError extends Error {\n constructor(\n public gameId: string,",
"score": 29.391856122188102
}
] | typescript | CardScript.execute(engine, enemy, intent.scriptData, targetCard); |
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": 50.42262323902554
},
{
"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": 31.65175765307287
},
{
"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": 28.92985556545062
},
{
"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": 28.75953735993727
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [\n {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),\n ],\n }\n ],\n );\n this.cooldownMax = 1;",
"score": 26.568618960394573
}
] | typescript | RaiseSec(secBonus),
],
} |
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": " 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": 60.748429785734984
},
{
"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": 49.71714694365831
},
{
"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": 47.97103901720976
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " };\n enemy.scripts.push(\n new CardScript.Content._defend(enemy, engine.gameData.difficulty, 'weak').serialize(),\n new CardScript.Content._firewallSelf(enemy, 1, 2).serialize(),\n );\n return enemy;\n },\n },\n initGame(engine: GameEngine.IGameEngine) {\n const boss: GameEngine.IEnemyCardState = {",
"score": 47.486568119937786
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " new CardScript.Content._firewallSelf(enemy, 1, 2).serialize(),\n );\n return enemy;\n },\n intro_perimeter: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n enemyClass: 'intro_perimeter',\n cpu: 1,\n mem: 1,",
"score": 44.2611422169159
}
] | 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": " [damage, lagChance, lagDuration],\n CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.Attack(damage),\n ],\n },\n {",
"score": 32.61603110147714
},
{
"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": 32.600791782686684
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [\n {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),\n ],\n }\n ],\n );\n this.cooldownMax = 1;",
"score": 30.204717638461737
},
{
"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": 30.204717638461737
},
{
"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": 29.603433277305612
}
] | 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": " 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": 41.86362952326346
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " return [...gameData.players.values()].find(x => x.cards.find(x => x.id === cardId));\n }\n export function generateIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {\n enemy.intent = undefined;\n const isOffline = !!enemy.mods.find(x => x[0] === 'offline');\n if (isOffline) return;\n const scriptData = enemy.scripts.filter(x => !CardScript.isOnCooldown(x)).randomOrUndefined();\n if (!scriptData) {\n return;\n }",
"score": 38.754829452300775
},
{
"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": 37.73540891679836
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " }\n static areEqual(left: CardScript.ScriptData, right: CardScript.ScriptData) {\n // Caveat: could collide since join() flattens array but highly unlikely\n return left.join('') === right.join('');\n }\n static deserialize(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptData: CardScript.ScriptData) {\n const scriptCtor = engine.ruleset.cardScripts?.[scriptData[0]];\n if (!scriptCtor) throw new Error('script not found: ' + scriptData.join());\n const script = new scriptCtor(card, ...scriptData.slice(1));\n const cooldownData = CardScript.findCooldownData(scriptData);",
"score": 35.615002598239364
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " const player = findPlayerByCardIdMaybe(gameData, cardId);\n if (!player) throw new Error('player not found');\n return player.cards.find(x => x.id === cardId)!;\n }\n export function findPlayerByCardId(gameData: GameEngine.IGameData, cardId: number) {\n const player = findPlayerByCardIdMaybe(gameData, cardId);\n if (player) return player;\n throw new Error('player not found');\n }\n export function findPlayerByCardIdMaybe(gameData: GameEngine.IGameData, cardId: number) {",
"score": 32.51148389527317
}
] | 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/apis/coop.api.ts",
"retrieved_chunk": " const gameData = await gameEngineProvider.getGameData(game.id);\n const playerState = gameData.players.get(player.id);\n if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {\n const now = moment.utc().format(FULL_DATETIME_FORMAT);\n await ds.PlayerCoopGames.update.exec({\n playerId: player.id,\n endedAt: now,\n gameId: game.id,\n gameResult: _getGameResult(gameData),\n score: playerState.score,",
"score": 43.84357305956432
},
{
"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": 35.24012246474538
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " }\n return deck;\n }\n};\nexport async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {\n const game = await ds.CoopGames.get(gameId);\n if (!game) throw new Error('game not found: ' + gameId);\n if (game.gameState.startsWith('ended')) return;\n const now = moment.utc();\n game.gameState = `ended_${now.format(DATE_FORMAT)}`;",
"score": 34.02295697589438
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " const player = findPlayerByCardIdMaybe(gameData, cardId);\n if (!player) throw new Error('player not found');\n return player.cards.find(x => x.id === cardId)!;\n }\n export function findPlayerByCardId(gameData: GameEngine.IGameData, cardId: number) {\n const player = findPlayerByCardIdMaybe(gameData, cardId);\n if (player) return player;\n throw new Error('player not found');\n }\n export function findPlayerByCardIdMaybe(gameData: GameEngine.IGameData, cardId: number) {",
"score": 32.3009052710142
},
{
"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": 32.10825702783416
}
] | typescript | .idleKickTime = now + 2 * SECS_IN_MIN * 1000; |
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/tests/appraise.test.ts",
"retrieved_chunk": " cpu: 0,\n mem: 0,\n };\n for (let i = 0; i < testSize; i++) {\n const card = appraiseCard({ nftId: generateId(), mintHeight: 1, url: '' });\n results.factions[card.faction]++;\n results.tiers[card.tier]++;\n results.cpu += card.cpu;\n results.mem += card.mem;\n results.scripts[card.coreScript]++;",
"score": 23.11736140370162
},
{
"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": 19.52672647728448
},
{
"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": 17.906653726941062
},
{
"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": 16.68880768725716
},
{
"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": 16.57420018428229
}
] | 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/extensions.ts",
"retrieved_chunk": "/// <reference path='extensions.d.ts' />\nArray.prototype.removeFirst = function (item) {\n const i = this.indexOf(item);\n if (i === -1) return false;\n this.splice(i, 1);\n return true;\n};\nArray.prototype.findAndRemoveFirst = function (predicate) {\n for (let i = 0; i < this.length; i++) {\n if (predicate(this[i])) {",
"score": 43.807677183541266
},
{
"filename": "src/tests/appraise.test.ts",
"retrieved_chunk": "import { randomInt } from 'crypto';\nimport { appraiseCard } from '../appraise';\nconst excludedChars = ['1', 'b', 'i', 'o'];\nconst testSize = 1000000;\nfunction generateId() {\n let id = 'nft1'.padEnd(54, '_');\n while (id.length < 62) {\n const i = randomInt(0, 36);\n let c: string;\n if (i >= 10) {",
"score": 37.81444256680224
},
{
"filename": "src/tests/appraise.test.ts",
"retrieved_chunk": " cpu: 0,\n mem: 0,\n };\n for (let i = 0; i < testSize; i++) {\n const card = appraiseCard({ nftId: generateId(), mintHeight: 1, url: '' });\n results.factions[card.faction]++;\n results.tiers[card.tier]++;\n results.cpu += card.cpu;\n results.mem += card.mem;\n results.scripts[card.coreScript]++;",
"score": 34.73349236723932
},
{
"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": 32.83439607449661
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " },\n // Triple SEC attack\n bf_flood: class extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const damage = GameEngineUtils.scaleByCpuMem(3, card.cpu);\n const numAttacks = 3;\n super(\n [damage, numAttacks],\n CardScript.TargetFinders.Opponents(),\n [",
"score": 30.215946551023524
}
] | typescript | GameEngineUtils.executeIntent(deps.engine, boss, true); |
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/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": 42.71635509599203
},
{
"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": 38.307081306215004
},
{
"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": 35.636697737842354
},
{
"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": 35.33326008202915
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " durationData && (mod.duration = durationData[1]);\n const stackingData = modData[1];\n mod.stackingConfig.behavior = stackingData[1];\n switch (stackingData[1]) {\n case CardMod.StackingBehavior.ranked:\n (mod.stackingConfig as any).rank = stackingData[2];\n break;\n case CardMod.StackingBehavior.stack:\n (mod.stackingConfig as any).stackCount = stackingData[2];\n break;",
"score": 33.677440645853004
}
] | 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-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": 72.29602105407972
},
{
"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": 71.60008660073994
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " }\n override onTurnStart(deps: CardMod.ICardModDeps) {\n 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 onRemoveMod(deps: ICardModDeps): void {\n if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {",
"score": 70.0435745749623
},
{
"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": 68.84181971653942
},
{
"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": 68.48694149020403
}
] | 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": 72.74132575403827
},
{
"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": 64.94692727989892
},
{
"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": 58.71704716082713
},
{
"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": 57.045830360241055
},
{
"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": 56.03679278098005
}
] | 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": " 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": 34.18499251327798
},
{
"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": 29.53689439991175
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " engine.broadcast.push({ type: 'playerLeave', playerId, reason });\n GameEngineUtils.revalidateIntents(engine, true);\n for (const remainingPlayer of engine.gameData.players.values()) {\n remainingPlayer.endedTurn = false;\n engine.broadcast.push({\n type: 'playerToggleEndTurn',\n playerId: remainingPlayer.id,\n state: false,\n });\n }",
"score": 28.96075883739048
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " const player = deps.contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null;\n player && player.stats.kills++;\n deps.engine.onWinGame();\n player && player.stats.kills--;\n }\n }\n export class _standardAi extends CardMod {\n override onTurnStart(deps: ICardModDeps) {\n if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {\n throw new Error('not an enemy card');",
"score": 28.511331271721694
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const playerToKick = [...engine.gameData.players.values()].find(x => x.id !== kickRequestingPlayerId) || '';\n if (!playerToKick) throw new Error('kickIfIdle: player not found');\n if (playerToKick.idleKickTime < moment.now()) {\n if (!engine.gameData.players.delete(playerToKick.id)) throw new Error('player not found');\n engine.broadcast.push({ type: 'playerLeave', playerId: playerToKick.id, reason: 'idle' });\n GameEngineUtils.revalidateIntents(engine, true);\n for (const remainingPlayer of engine.gameData.players.values()) {\n remainingPlayer.endedTurn = false;\n engine.broadcast.push({\n type: 'playerToggleEndTurn',",
"score": 28.04402627707189
}
] | 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/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": 77.12566967310563
},
{
"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": 66.2167485747213
},
{
"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": 55.13726556896618
},
{
"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": 54.35363711559189
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " maxMem: 1,\n mods: [],\n scripts: [],\n sec: 10,\n };\n testEnemy.mods.push(new CardMod.Content._standardAi().serialize());\n testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());\n GameEngineUtils.addEnemy(engine, testEnemy, 0, true);\n },\n addAdditionalScriptsFor(_card) {",
"score": 54.33134628890396
}
] | 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-scripts.ts",
"retrieved_chunk": " (gameData, card) => {\n const targets = targetFinder(gameData, card);\n const modMatches = targets.filter(target => target.mods.find(modData => modFilter.find(x => x === modData[0])));\n return _excludeImperviousAndOffline(modMatches);\n };\n const _excludeImpervious = (cards: GameEngine.ICardState[]) => {\n return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.impervious.name));\n };\n export const _excludeOffline = (cards: GameEngine.ICardState[]) => {\n return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.offline.name));",
"score": 26.111760964384896
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " }\n },\n // Attack and raise CPU on kill\n bd_extraction: class extends CardScript {\n constructor(_card: GameEngine.ICardState) {\n super(\n [],\n (gameData, card) =>\n CardScript.TargetFinders.Opponents(true)(gameData, card)\n .filter(target => !target.sec && target.mem === 1),",
"score": 24.012764626922568
},
{
"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": 23.399624010997474
},
{
"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": 23.31984821127579
},
{
"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": 23.097978304217975
}
] | 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/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": 42.83481334316781
},
{
"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": 37.36972552231265
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " (gameData, card) => {\n const targets = targetFinder(gameData, card);\n const modMatches = targets.filter(target => target.mods.find(modData => modFilter.find(x => x === modData[0])));\n return _excludeImperviousAndOffline(modMatches);\n };\n const _excludeImpervious = (cards: GameEngine.ICardState[]) => {\n return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.impervious.name));\n };\n export const _excludeOffline = (cards: GameEngine.ICardState[]) => {\n return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.offline.name));",
"score": 34.99248851143874
},
{
"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": 29.127701068703455
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " }\n },\n // Attack and raise CPU on kill\n bd_extraction: class extends CardScript {\n constructor(_card: GameEngine.ICardState) {\n super(\n [],\n (gameData, card) =>\n CardScript.TargetFinders.Opponents(true)(gameData, card)\n .filter(target => !target.sec && target.mem === 1),",
"score": 28.274082446477227
}
] | 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": 70.9985614578772
},
{
"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": 59.329332885071686
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " maxMem: 1,\n mods: [],\n scripts: [],\n sec: 10,\n };\n testEnemy.mods.push(new CardMod.Content._standardAi().serialize());\n testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());\n GameEngineUtils.addEnemy(engine, testEnemy, 0, true);\n },\n addAdditionalScriptsFor(_card) {",
"score": 58.117152741456266
},
{
"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": 57.35524793687657
},
{
"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": 52.591406532116444
}
] | 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/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": 64.60036124532559
},
{
"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": 55.06355400836005
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " GameEngineUtils.addEnemy(engine, boss, 0, true);\n GameEngineUtils.addEnemy(engine, RulesetMfrm.enemyCards.intro_sentinel(engine), 0, true);\n GameEngineUtils.addEnemy(engine, RulesetMfrm.enemyCards.intro_perimeter(engine), 0, true);\n engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetMfrm.enemyCards.intro_perimeter(engine), 0, true);\n GameEngineUtils.addEnemy(engine, RulesetMfrm.enemyCards.intro_sentinel(engine), engine.gameData.enemies.length, true);\n GameEngineUtils.addEnemy(engine, RulesetMfrm.enemyCards.intro_perimeter(engine), engine.gameData.enemies.length, true);\n engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetMfrm.enemyCards.intro_perimeter(engine), engine.gameData.enemies.length, true);\n }\n};",
"score": 47.946092932024534
},
{
"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": 46.079951875163545
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " export function revalidateIntents(engine: GameEngine.IGameEngine, regenerateIfInvalid: boolean) {\n for (const enemy of engine.gameData.enemies) {\n if (!enemy.intent || enemy.intent.targetCardId === -1) {\n continue;\n }\n const script = CardScript.deserialize(engine, enemy, enemy.intent.scriptData);\n const validTargets = script.targetFinder(engine.gameData, enemy);\n if (validTargets.find(x => x.id === enemy.intent?.targetCardId)) {\n continue;\n }",
"score": 44.901838113480416
}
] | 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/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": 43.25753295046255
},
{
"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": 41.90936096534421
},
{
"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": 36.548762966748136
},
{
"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": 35.371822144190496
},
{
"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": 35.14381928876805
}
] | 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/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": 47.8588738210411
},
{
"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": 34.10031520980707
},
{
"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": 33.1016723967062
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " CardMod.addMod(deps.engine, enemy, new GameContent_v1.cardMods.optimized(1, -1), boss);\n }\n }\n },\n goliath_boss_power: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 1,\n };\n },",
"score": 32.657864644055955
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " stasis_shocker: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n 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(),",
"score": 30.684853300023054
}
] | 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": " 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": 44.990486053730606
},
{
"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": 44.5987113483922
},
{
"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": 44.31380154869034
},
{
"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": 40.24013970395253
},
{
"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": 39.70356485697163
}
] | 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/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": 17.81901056020668
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\n export interface IRuleset extends IRulesetContent {\n initGame(engine: IGameEngine): void;\n addAdditionalScriptsFor?(engine: GameEngine.IGameEngine, card: IPlayerCardState): void;\n }\n export function mergeRulesetContents(...rulesets: IRulesetContent[]): IRulesetContent {\n const modLibs = rulesets.map(x => x.cardMods).filter(Boolean);\n const scriptLibs = rulesets.map(x => x.cardScripts).filter(Boolean);\n const enemyLibs = rulesets.map(x => x.enemyCards).filter(Boolean);\n return {",
"score": 17.708345440394204
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": "import { randInt } from '../../utils';\nimport { CardMod } from '../card-mods';\nimport { CardScriptParts } from '../card-script-parts';\nimport { CardScript } from '../card-scripts';\nimport { GameContent_v1 } from '../game-content-v1';\nimport { GameEngine } from '../game-engine';\nimport { GameEngineUtils } from '../game-engine-utils';\nexport const RulesetReaper = {\n cardMods: {\n reaper_feederCorrupted: class extends CardMod {",
"score": 17.505330723993954
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": "import { CardMod } from '../card-mods';\nimport { CardScriptParts } from '../card-script-parts';\nimport { CardScript } from '../card-scripts';\nimport { GameEngine } from '../game-engine';\nimport { GameEngineUtils } from '../game-engine-utils';\nexport const RulesetStasis = {\n cardMods: {\n stasis_boss_ai: class extends CardMod.Content._standardAi {\n override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {\n if (deps.sourceCard.mem - memDmg <= 0) return;",
"score": 12.911820711868334
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " case 'bruteforce':\n card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bf_')).random()]).serialize());\n return;\n case 'malware':\n card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('mw_')).random()]).serialize());\n return;\n }\n },\n};\n(GameContent_v1 as GameEngine.IRuleset);",
"score": 12.714617948480884
}
] | 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/apis/decks.api.ts",
"retrieved_chunk": " }\n payload.deckLabel && (deck.label = deck.label);\n 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);\n if (nfts.length !== payload.nftIds.length) {\n return [StatusCodes.notFound, { reason: 'one or more nft ids were not found, or did not belong to the player' }];\n }\n deck.cards = nfts.map(x => ({ nftId: x.nftId, mintHeight: x.firstBlock, url: x.urls[0] || '' }));\n await ds.CardDecks.update.exec(deck);\n metrics?.deckUpdated(player.id, deck.createdAt);\n return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];",
"score": 18.448355162057805
},
{
"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": 17.815613257503326
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " await Promise.all(\n [...gameData.players.keys()].filter(x => x !== playerId).map(x => playerPushProvider?.push(x, pushMessage)),\n );\n }\n static async makeMove(gameId: string, playerId: string, sourceCardId: number, sourceCardScript: CardScript.ScriptData, targetCardId: number) {\n return await _Engine._withEngine(gameId, ['started'], async engine => {\n const playerState = GameEngineUtils.findPlayerByCardId(engine.gameData, sourceCardId);\n if (playerState.id !== playerId) {\n throw new Error(`Player ${playerId} cannot make move on card ${sourceCardId} from owner ${playerState.id}`);\n }",
"score": 17.75160857133726
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " }\n}\nfunction _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {\n return [\n ...[...game.playersIds.keys()].filter(x => x !== playerId),\n // ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),\n ];\n}",
"score": 17.175112989369186
},
{
"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": 16.044339669505998
}
] | 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 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": 21.142246474480878
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " }\n export function getPlayerCards(gameData: GameEngine.IGameData) {\n return [...gameData.players.values()].map(x => x.cards).flat();\n }\n export function getPlayerCardIds(gameData: GameEngine.IGameData) {\n return getPlayerCards(gameData).map(x => x.id);\n }\n export function isEnemyCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IEnemyCardState {\n return !!gameData.enemies.find(x => x.id === card.id);\n }",
"score": 19.32365390800443
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " }\n return deck;\n }\n};\nexport async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {\n const game = await ds.CoopGames.get(gameId);\n if (!game) throw new Error('game not found: ' + gameId);\n if (game.gameState.startsWith('ended')) return;\n const now = moment.utc();\n game.gameState = `ended_${now.format(DATE_FORMAT)}`;",
"score": 18.911599937684187
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " player.activeGameId = '';\n if (!game.gameState.startsWith('ended')) {\n game.playersIds.delete(player.id);\n game.ingorePlayerIds.add(player.id);\n }\n await ds.execUpdates(\n ds.Players.update.make(player),\n ds.CoopGames.update.make(game),\n );\n try {",
"score": 17.95664056800098
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " type: 'cardIntent',\n cardId: enemy.id,\n intent: enemy.intent,\n });\n }\n export function getEnemyIds(gameData: GameEngine.IGameData) {\n return gameData.enemies.map(x => x.id);\n }\n export function getPlayerIds(gameData: GameEngine.IGameData, ...excludePlayer: string[]) {\n return [...gameData.players.keys()].filter(x => !excludePlayer.includes(x));",
"score": 17.578885593722593
}
] | 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/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": 29.083922181731673
},
{
"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": 28.560209270653168
},
{
"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": 28.279075693699063
},
{
"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": 27.991623786449622
},
{
"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": 27.95607757364774
}
] | 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/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": 61.85570464413668
},
{
"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": 35.364207938206825
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " const player = await _expectAuthPlayerNotInGame(req);\n const deck = await _expectValidActiveDeck(player, true);\n if (await rateLimit.shouldRateLimitCreateGame(player.id)) {\n return [StatusCodes.tooManyRequests];\n }\n const now = moment.utc();\n const game: IDataSource.ICoopGame = {\n id: randomBytes(16).toString('hex'),\n createdAt: now.format(FULL_DATETIME_FORMAT),\n difficulty: payload.difficulty,",
"score": 31.462572353558258
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " const gameData = await gameEngineProvider.getGameData(game.id);\n const playerState = gameData.players.get(player.id);\n if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {\n const now = moment.utc().format(FULL_DATETIME_FORMAT);\n await ds.PlayerCoopGames.update.exec({\n playerId: player.id,\n endedAt: now,\n gameId: game.id,\n gameResult: _getGameResult(gameData),\n score: playerState.score,",
"score": 29.60539250419814
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " if (nfts.length !== 6) {\n return [StatusCodes.forbidden, { reason: `not enough nftIds, need 6, got ${nfts.length}` }];\n }\n const deck = await ds.CardDecks.update.exec({\n playerId: player.id,\n createdAt: moment.utc().format(FULL_DATETIME_FORMAT),\n label: payload.deckLabel,\n cards: nfts.map(x => ({ nftId: x.nftId, mintHeight: x.firstBlock, url: x.urls[0] || '' })),\n });\n metrics?.deckUpdated(player.id, deck.createdAt);",
"score": 29.297366498331044
}
] | 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": " 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": 81.93533831820697
},
{
"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": 81.40809647176731
},
{
"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": 62.11923829054926
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " maxMem: 1,\n mods: [],\n scripts: [],\n sec: 10,\n };\n testEnemy.mods.push(new CardMod.Content._standardAi().serialize());\n testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());\n GameEngineUtils.addEnemy(engine, testEnemy, 0, true);\n },\n addAdditionalScriptsFor(_card) {",
"score": 61.21574853753072
},
{
"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": 59.84973077456526
}
] | 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/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": 36.19685004630428
},
{
"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": 32.820703323476614
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new _cardMods.exposed(stacks),\n ),\n ],\n }",
"score": 31.95624251429007
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [dot],\n CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new _cardMods.virus(dot),\n ),\n ],",
"score": 31.417833375808087
},
{
"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": 30.43753414852886
}
] | 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/extensions.ts",
"retrieved_chunk": "/// <reference path='extensions.d.ts' />\nArray.prototype.removeFirst = function (item) {\n const i = this.indexOf(item);\n if (i === -1) return false;\n this.splice(i, 1);\n return true;\n};\nArray.prototype.findAndRemoveFirst = function (predicate) {\n for (let i = 0; i < this.length; i++) {\n if (predicate(this[i])) {",
"score": 45.52809099404345
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (powerBuff) {\n const powerStacks = CardMod.getStackCount(powerBuff);\n numAttacks += powerStacks;\n }\n for (let i = 0; i < numAttacks - 1; i++) {\n GameEngineUtils.executeIntent(deps.engine, boss, true);\n }\n GameEngineUtils.executeIntent(deps.engine, boss);\n }\n override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {",
"score": 42.64315991136039
},
{
"filename": "src/appraise.ts",
"retrieved_chunk": " let faction: IAppraisedCard['faction'];\n const factionQualifier = Q[0]!.charCodeAt(0);\n if (factionQualifier < 99) faction = 'backdoor'; // 0-9, a, b (10 chars, '1' and 'b' do not exist)\n else if (factionQualifier < 111) faction = 'bruteforce'; // c-n (11 chars, 'i' does not exist)\n else faction = 'malware'; // o-z (11 chars, 'o' does not exist)\n // The sum of the char codes of Q, sumQ, determines faction core script\n const sumQ = Q.reduce((sum, c) => sum + c.charCodeAt(0), 0);\n const coreScripts = _CoreScriptNames[faction];\n const coreScript = coreScripts[sumQ % coreScripts.length]!;\n // Q[2:] is the card statistics qualifier, SQ, each granted statistic increases card tier",
"score": 31.222861980098635
},
{
"filename": "src/appraise.ts",
"retrieved_chunk": " let mem = 1;\n for (const c of SQ) {\n if (+c > 5) {\n cpu++; // 6, 7, 8, 9\n } else if (+c > 0) {\n mem++; // 2, 3, 4, 5 ('1' does not exist)\n } else if (+c === 0) {\n // For 0, we flip a coin on the char code sum of Q which results in 50:50 CPU:MEM distribution\n (sumQ % 2) ? (cpu++) : (mem++);\n }",
"score": 30.956229968335162
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " constructor(card: GameEngine.ICardState, difficulty: number, strength: 'weak' | 'normal' | 'strong' = 'normal', cooldown = 0) {\n let minBonus = 0;\n let maxBonus = 0;\n switch (strength) {\n case 'weak':\n minBonus = GameEngineUtils.scaleByCpuMem(4, card.cpu);\n maxBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n break;\n case 'normal':\n minBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);",
"score": 29.467417168816848
}
] | 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/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": 36.19685004630428
},
{
"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": 32.820703323476614
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new _cardMods.exposed(stacks),\n ),\n ],\n }",
"score": 31.95624251429007
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [dot],\n CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new _cardMods.virus(dot),\n ),\n ],",
"score": 31.417833375808087
},
{
"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": 30.43753414852886
}
] | 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/game/game-engine.ts",
"retrieved_chunk": " await Promise.all(\n [...gameData.players.keys()].filter(x => x !== playerId).map(x => playerPushProvider?.push(x, pushMessage)),\n );\n }\n static async makeMove(gameId: string, playerId: string, sourceCardId: number, sourceCardScript: CardScript.ScriptData, targetCardId: number) {\n return await _Engine._withEngine(gameId, ['started'], async engine => {\n const playerState = GameEngineUtils.findPlayerByCardId(engine.gameData, sourceCardId);\n if (playerState.id !== playerId) {\n throw new Error(`Player ${playerId} cannot make move on card ${sourceCardId} from owner ${playerState.id}`);\n }",
"score": 30.156992039134195
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " playerState,\n });\n } else {\n engine.gameData.pendingPlayers.set(playerId, cardIds);\n }\n });\n }\n static async removePlayer(gameId: string, playerId: string, reason: 'idle' | 'leave') {\n return await _Engine._withEngine(gameId, [], async engine => {\n if (!engine.gameData.players.delete(playerId)) throw new Error('player not found');",
"score": 29.99675287320552
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " }\n}\nfunction _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {\n return [\n ...[...game.playersIds.keys()].filter(x => x !== playerId),\n // ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),\n ];\n}",
"score": 28.58279993942826
},
{
"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": 25.748493192462924
},
{
"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": 25.469924331520396
}
] | 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/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": 25.467750201261392
},
{
"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": 24.790276770890664
},
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " /**\n * Transactionlly executes all UpdateRequests; no changes are made if any one of the UpdateRquests fail.\n */\n execUpdates(...updateRequests: IDataSource.UpdateRequest[]): Promise<void>;\n}\ndeclare interface IAuthProvider {\n generateNewSecret(): string;\n getAuthTokenForPlayer(player: IDataSource.IPlayer): string;\n getPlayerFromRequest(req: IHttpRequest): Promise<IDataSource.IPlayer>;\n getPlayerIdFromRequest(req: IHttpRequest): string;",
"score": 24.687306282701382
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " }\n case 'activeDeck': {\n const player = await authProvider.getPlayerFromRequest(req);\n return [StatusCodes.ok, { deck: toClientDeck(player, await getOrCreateActiveDeck(player, ds)) }];\n }\n default: {\n if (!path[0]) {\n return;\n }\n const player = await authProvider.getPlayerFromRequest(req);",
"score": 22.923322848375694
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " const player = await authProvider.getPlayerFromRequest(req);\n if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');\n return player;\n }\n async function _expectCoopGameJoinable(gameId: string) {\n const game = await ds.CoopGames.get(gameId);\n if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');\n if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');\n if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');\n return game;",
"score": 22.680960001682557
}
] | typescript | async push(playerId, messages) { |
/*
* @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": 31.955094285772695
},
{
"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": 27.33787372178829
},
{
"filename": "src/types.ts",
"retrieved_chunk": " */\nexport type ValidationOptions<MetaData extends Record<string, any> | undefined> = {\n /**\n * Messages provider is used to resolve error messages during\n * the validation lifecycle\n */\n messagesProvider?: MessagesProviderContact\n /**\n * Validation errors are reported directly to an error reporter. The reporter\n * can decide how to format and output errors.",
"score": 22.620626126145833
},
{
"filename": "src/schema/base/main.ts",
"retrieved_chunk": " use(validation: Validation<any> | RuleBuilder): this {\n this.validations.push(VALIDATION in validation ? validation[VALIDATION]() : validation)\n return this\n }\n /**\n * Enable/disable the bail mode. In bail mode, the field validations\n * are stopped after the first error.\n */\n bail(state: boolean) {\n this.options.bail = state",
"score": 19.245778114222432
},
{
"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": 15.428696958183767
}
] | typescript | (): ValidationError { |
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": " await Promise.all(\n [...gameData.players.keys()].filter(x => x !== playerId).map(x => playerPushProvider?.push(x, pushMessage)),\n );\n }\n static async makeMove(gameId: string, playerId: string, sourceCardId: number, sourceCardScript: CardScript.ScriptData, targetCardId: number) {\n return await _Engine._withEngine(gameId, ['started'], async engine => {\n const playerState = GameEngineUtils.findPlayerByCardId(engine.gameData, sourceCardId);\n if (playerState.id !== playerId) {\n throw new Error(`Player ${playerId} cannot make move on card ${sourceCardId} from owner ${playerState.id}`);\n }",
"score": 30.156992039134195
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " playerState,\n });\n } else {\n engine.gameData.pendingPlayers.set(playerId, cardIds);\n }\n });\n }\n static async removePlayer(gameId: string, playerId: string, reason: 'idle' | 'leave') {\n return await _Engine._withEngine(gameId, [], async engine => {\n if (!engine.gameData.players.delete(playerId)) throw new Error('player not found');",
"score": 29.99675287320552
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " }\n}\nfunction _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {\n return [\n ...[...game.playersIds.keys()].filter(x => x !== playerId),\n // ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),\n ];\n}",
"score": 28.58279993942826
},
{
"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": 25.748493192462924
},
{
"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": 25.469924331520396
}
] | 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/messages_provider/simple_messages_provider.ts",
"retrieved_chunk": " output = Object.hasOwn(output, token) ? output[token] : undefined\n }\n return output\n })\n }\n /**\n * Returns a validation message for a given field + rule.\n */\n getMessage(rawMessage: string, rule: string, field: FieldContext, args?: Record<string, any>) {\n const fieldName = this.#fields[field.name] || field.name",
"score": 21.029301460354976
},
{
"filename": "src/messages_provider/simple_messages_provider.ts",
"retrieved_chunk": " #fields: ValidationFields\n constructor(messages: ValidationMessages, fields: ValidationFields) {\n this.#messages = messages\n this.#fields = fields\n }\n /**\n * Interpolates place holders within error messages\n */\n #interpolate(message: string, data: any): string {\n if (!message.includes('{{')) {",
"score": 14.719930987333104
},
{
"filename": "src/schema/enum/rules.ts",
"retrieved_chunk": " * Report error when value is not part of the pre-defined\n * options\n */\n if (!choices.includes(value)) {\n field.report(messages.enum, 'enum', field, { choices })\n }\n})",
"score": 13.124779053242804
},
{
"filename": "src/types.ts",
"retrieved_chunk": " */\nexport type ValidationOptions<MetaData extends Record<string, any> | undefined> = {\n /**\n * Messages provider is used to resolve error messages during\n * the validation lifecycle\n */\n messagesProvider?: MessagesProviderContact\n /**\n * Validation errors are reported directly to an error reporter. The reporter\n * can decide how to format and output errors.",
"score": 13.103555767121506
},
{
"filename": "src/schema/union/main.ts",
"retrieved_chunk": " field.report(messages.union, 'union', field)\n }\n constructor(conditionals: Conditional[]) {\n this.#conditionals = conditionals\n }\n /**\n * Define a fallback method to invoke when all of the union conditions\n * fail. You may use this method to report an error.\n */\n otherwise(callback: UnionNoMatchCallback<Record<string, unknown>>): this {",
"score": 12.240009603882077
}
] | 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/errors/main.ts",
"retrieved_chunk": " * Create an instance of validation error\n */\nexport const E_VALIDATION_ERROR = ValidationError",
"score": 31.955094285772695
},
{
"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": 27.33787372178829
},
{
"filename": "src/types.ts",
"retrieved_chunk": " */\nexport type ValidationOptions<MetaData extends Record<string, any> | undefined> = {\n /**\n * Messages provider is used to resolve error messages during\n * the validation lifecycle\n */\n messagesProvider?: MessagesProviderContact\n /**\n * Validation errors are reported directly to an error reporter. The reporter\n * can decide how to format and output errors.",
"score": 22.620626126145833
},
{
"filename": "src/schema/base/main.ts",
"retrieved_chunk": " use(validation: Validation<any> | RuleBuilder): this {\n this.validations.push(VALIDATION in validation ? validation[VALIDATION]() : validation)\n return this\n }\n /**\n * Enable/disable the bail mode. In bail mode, the field validations\n * are stopped after the first error.\n */\n bail(state: boolean) {\n this.options.bail = state",
"score": 19.90266727859553
},
{
"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": 18.331715138054825
}
] | 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": 34.948253106253766
},
{
"filename": "src/types.ts",
"retrieved_chunk": " */\nexport type ValidationOptions<MetaData extends Record<string, any> | undefined> = {\n /**\n * Messages provider is used to resolve error messages during\n * the validation lifecycle\n */\n messagesProvider?: MessagesProviderContact\n /**\n * Validation errors are reported directly to an error reporter. The reporter\n * can decide how to format and output errors.",
"score": 25.274278605552293
},
{
"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": 19.99199016785024
},
{
"filename": "src/schema/base/main.ts",
"retrieved_chunk": " use(validation: Validation<any> | RuleBuilder): this {\n this.validations.push(VALIDATION in validation ? validation[VALIDATION]() : validation)\n return this\n }\n /**\n * Enable/disable the bail mode. In bail mode, the field validations\n * are stopped after the first error.\n */\n bail(state: boolean) {\n this.options.bail = state",
"score": 16.811474638541014
},
{
"filename": "src/schema/object/group.ts",
"retrieved_chunk": " */\n clone(): this {\n const cloned = new ObjectGroup<Conditional>(this.#conditionals)\n cloned.otherwise(this.#otherwiseCallback)\n return cloned as this\n }\n /**\n * Define a fallback method to invoke when all of the group conditions\n * fail. You may use this method to report an error.\n */",
"score": 13.883377870855893
}
] | 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/record/main.ts",
"retrieved_chunk": " }\n /**\n * Clones the VineRecord schema type. The applied options\n * and validations are copied to the new instance\n */\n clone(): this {\n return new VineRecord(\n this.#schema.clone(),\n this.cloneOptions(),\n this.cloneValidations()",
"score": 61.22958247793884
},
{
"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": 59.76672930576104
},
{
"filename": "src/schema/enum/main.ts",
"retrieved_chunk": " /**\n * Clones the VineEnum schema type. The applied options\n * and validations are copied to the new instance\n */\n clone(): this {\n return new VineEnum(this.#values, this.cloneOptions(), this.cloneValidations()) as this\n }\n}",
"score": 58.32996563229479
},
{
"filename": "src/schema/boolean/main.ts",
"retrieved_chunk": " super(options, validations || [booleanRule(options || {})])\n }\n /**\n * Clones the VineBoolean schema type. The applied options\n * and validations are copied to the new instance\n */\n clone(): this {\n return new VineBoolean(this.cloneOptions(), this.cloneValidations()) as this\n }\n}",
"score": 57.7898670849894
},
{
"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": 54.275738035755225
}
] | 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": " */\nexport const maxLengthRule = createRule<{ max: number }>((value, options, field) => {\n /**\n * 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.",
"score": 49.38226785629323
},
{
"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": 47.3225444163356
},
{
"filename": "src/schema/record/rules.ts",
"retrieved_chunk": " }\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.min) {\n field.report(messages['record.minLength'], 'record.minLength', field, options)\n }\n})\n/**\n * Enforce a maximum length on an object field",
"score": 37.219937765313944
},
{
"filename": "src/schema/number/rules.ts",
"retrieved_chunk": " */\nexport const decimalRule = createRule<{ range: [number, number?] }>((value, options, field) => {\n /**\n * Skip if the field is not valid.\n */\n if (!field.isValid) {\n return\n }\n if (\n !helpers.isDecimal(String(value), {",
"score": 33.51377073504687
},
{
"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": 33.32097485426975
}
] | 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/messages_provider/simple_messages_provider.ts",
"retrieved_chunk": " output = Object.hasOwn(output, token) ? output[token] : undefined\n }\n return output\n })\n }\n /**\n * Returns a validation message for a given field + rule.\n */\n getMessage(rawMessage: string, rule: string, field: FieldContext, args?: Record<string, any>) {\n const fieldName = this.#fields[field.name] || field.name",
"score": 21.029301460354976
},
{
"filename": "src/types.ts",
"retrieved_chunk": " */\nexport type ValidationOptions<MetaData extends Record<string, any> | undefined> = {\n /**\n * Messages provider is used to resolve error messages during\n * the validation lifecycle\n */\n messagesProvider?: MessagesProviderContact\n /**\n * Validation errors are reported directly to an error reporter. The reporter\n * can decide how to format and output errors.",
"score": 19.64628038538418
},
{
"filename": "src/messages_provider/simple_messages_provider.ts",
"retrieved_chunk": " #fields: ValidationFields\n constructor(messages: ValidationMessages, fields: ValidationFields) {\n this.#messages = messages\n this.#fields = fields\n }\n /**\n * Interpolates place holders within error messages\n */\n #interpolate(message: string, data: any): string {\n if (!message.includes('{{')) {",
"score": 14.719930987333104
},
{
"filename": "src/schema/enum/rules.ts",
"retrieved_chunk": " * Report error when value is not part of the pre-defined\n * options\n */\n if (!choices.includes(value)) {\n field.report(messages.enum, 'enum', field, { choices })\n }\n})",
"score": 13.124779053242804
},
{
"filename": "src/schema/union/main.ts",
"retrieved_chunk": " field.report(messages.union, 'union', field)\n }\n constructor(conditionals: Conditional[]) {\n this.#conditionals = conditionals\n }\n /**\n * Define a fallback method to invoke when all of the union conditions\n * fail. You may use this method to report an error.\n */\n otherwise(callback: UnionNoMatchCallback<Record<string, unknown>>): this {",
"score": 12.240009603882077
}
] | 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/record/main.ts",
"retrieved_chunk": " }\n /**\n * Clones the VineRecord schema type. The applied options\n * and validations are copied to the new instance\n */\n clone(): this {\n return new VineRecord(\n this.#schema.clone(),\n this.cloneOptions(),\n this.cloneValidations()",
"score": 46.08297223206079
},
{
"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": 45.02841729906191
},
{
"filename": "src/schema/enum/main.ts",
"retrieved_chunk": " /**\n * Clones the VineEnum schema type. The applied options\n * and validations are copied to the new instance\n */\n clone(): this {\n return new VineEnum(this.#values, this.cloneOptions(), this.cloneValidations()) as this\n }\n}",
"score": 44.02482330197906
},
{
"filename": "src/schema/boolean/main.ts",
"retrieved_chunk": " super(options, validations || [booleanRule(options || {})])\n }\n /**\n * Clones the VineBoolean schema type. The applied options\n * and validations are copied to the new instance\n */\n clone(): this {\n return new VineBoolean(this.cloneOptions(), this.cloneValidations()) as this\n }\n}",
"score": 43.616954667581105
},
{
"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": 41.58072843465044
}
] | 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": 56.07809278875237
},
{
"filename": "src/schema/array/main.ts",
"retrieved_chunk": " */\n fixedLength(expectedLength: number) {\n return this.use(fixedLengthRule({ size: expectedLength }))\n }\n /**\n * Ensure the array is not empty\n */\n notEmpty() {\n return this.use(notEmptyRule())\n }",
"score": 50.94492599025656
},
{
"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": 46.83114645291866
},
{
"filename": "src/schema/record/rules.ts",
"retrieved_chunk": " */\nexport const maxLengthRule = createRule<{ max: number }>((value, options, field) => {\n /**\n * 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.",
"score": 44.64722785811597
},
{
"filename": "src/defaults.ts",
"retrieved_chunk": " 'accepted': 'The {{ field }} field must be accepted',\n 'enum': 'The selected {{ field }} is invalid',\n 'literal': 'The {{ field }} field must be {{ expectedValue }}',\n 'object': 'The {{ field }} field must be an object',\n 'array': 'The {{ field }} field must be an array',\n 'array.minLength': 'The {{ field }} field must have at least {{ min }} items',\n 'array.maxLength': 'The {{ field }} field must not have more than {{ max }} items',\n 'array.fixedLength': 'The {{ field }} field must contain {{ size }} items',\n 'notEmpty': 'The {{ field }} field must not be empty',\n 'distinct': 'The {{ field }} field has duplicate values',",
"score": 41.782959852558115
}
] | 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": 72.63167933005447
},
{
"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": 62.09119841284872
},
{
"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": 53.861702554458525
},
{
"filename": "src/schema/base/literal.ts",
"retrieved_chunk": " [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): LiteralNode {\n const output = this.#parent[PARSE](propertyName, refs, options)\n output.isOptional = true\n return output\n }\n}\n/**\n * Modifies the schema type to allow custom transformed values\n */\nclass TransformModifier<",
"score": 52.764555289418006
},
{
"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": 44.862461989913044
}
] | 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/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": 44.31497208247029
},
{
"filename": "src/schema/object/group_builder.ts",
"retrieved_chunk": " * Wrap object properties inside an else conditon\n */\ngroup.else = function groupElse<Properties extends Record<string, SchemaTypes>>(\n properties: Properties\n) {\n return new GroupConditional<\n Properties,\n {\n [K in keyof Properties]: Properties[K][typeof OTYPE]\n },",
"score": 41.84194895512299
},
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": " Properties,\n Output & { [K: string]: Value },\n CamelCaseOutput & { [K: string]: Value }\n >\n }\n /**\n * Merge a union to the object groups. The union can be a \"vine.union\"\n * with objects, or a \"vine.object.union\" with properties.\n */\n merge<Group extends ObjectGroup<GroupConditional<any, any, any>>>(",
"score": 41.80607800828292
},
{
"filename": "src/schema/object/group_builder.ts",
"retrieved_chunk": " return new ObjectGroup<Conditional>(conditionals)\n}\n/**\n * Wrap object properties inside a conditonal\n */\ngroup.if = function groupIf<Properties extends Record<string, SchemaTypes>>(\n conditon: (value: Record<string, unknown>, field: FieldContext) => any,\n properties: Properties\n) {\n return new GroupConditional<",
"score": 41.372034544889246
},
{
"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": 38.265540354171804
}
] | 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": 65.92475172268269
},
{
"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": 61.59582364329226
},
{
"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": 46.684001275778485
},
{
"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": 43.4528755541421
},
{
"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": 40.004998946384646
}
] | 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": " 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": 22.625548867208185
},
{
"filename": "src/schema/number/rules.ts",
"retrieved_chunk": "import { messages } from '../../defaults.js'\n/**\n * Enforce the value to be a number or a string representation\n * of a number\n */\nexport const numberRule = createRule<{ strict?: boolean }>((value, options, field) => {\n const valueAsNumber = options.strict ? value : helpers.asNumber(value)\n if (\n typeof valueAsNumber !== 'number' ||\n Number.isNaN(valueAsNumber) ||",
"score": 16.690025558668847
},
{
"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": 15.866629214016548
},
{
"filename": "src/schema/number/main.ts",
"retrieved_chunk": " return !Number.isNaN(valueAsNumber)\n }\n constructor(\n options?: Partial<FieldOptions> & { strict?: boolean },\n validations?: Validation<any>[]\n ) {\n super(options, validations || [numberRule(options || {})])\n }\n /**\n * Enforce a minimum value for the number input",
"score": 15.355831374470117
},
{
"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": 14.980312357905603
}
] | 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/group_builder.ts",
"retrieved_chunk": " * Wrap object properties inside an else conditon\n */\ngroup.else = function groupElse<Properties extends Record<string, SchemaTypes>>(\n properties: Properties\n) {\n return new GroupConditional<\n Properties,\n {\n [K in keyof Properties]: Properties[K][typeof OTYPE]\n },",
"score": 48.035211827962875
},
{
"filename": "src/schema/object/group_builder.ts",
"retrieved_chunk": " return new ObjectGroup<Conditional>(conditionals)\n}\n/**\n * Wrap object properties inside a conditonal\n */\ngroup.if = function groupIf<Properties extends Record<string, SchemaTypes>>(\n conditon: (value: Record<string, unknown>, field: FieldContext) => any,\n properties: Properties\n) {\n return new GroupConditional<",
"score": 44.471945775837845
},
{
"filename": "src/schema/object/conditional.ts",
"retrieved_chunk": " declare [OTYPE]: Output;\n declare [COTYPE]: CamelCaseOutput\n /**\n * Properties to merge when conditonal is true\n */\n #properties: Properties\n /**\n * Conditional to evaluate\n */\n #conditional: ConditionalFn<Record<string, unknown>>",
"score": 36.76139843653238
},
{
"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": 36.33358270651205
},
{
"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": 34.65384655977248
}
] | 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/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": 43.08568799418563
},
{
"filename": "src/schema/object/group_builder.ts",
"retrieved_chunk": " * Wrap object properties inside an else conditon\n */\ngroup.else = function groupElse<Properties extends Record<string, SchemaTypes>>(\n properties: Properties\n) {\n return new GroupConditional<\n Properties,\n {\n [K in keyof Properties]: Properties[K][typeof OTYPE]\n },",
"score": 41.84194895512299
},
{
"filename": "src/schema/object/group_builder.ts",
"retrieved_chunk": " return new ObjectGroup<Conditional>(conditionals)\n}\n/**\n * Wrap object properties inside a conditonal\n */\ngroup.if = function groupIf<Properties extends Record<string, SchemaTypes>>(\n conditon: (value: Record<string, unknown>, field: FieldContext) => any,\n properties: Properties\n) {\n return new GroupConditional<",
"score": 40.9209766867468
},
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": " Properties,\n Output & { [K: string]: Value },\n CamelCaseOutput & { [K: string]: Value }\n >\n }\n /**\n * Merge a union to the object groups. The union can be a \"vine.union\"\n * with objects, or a \"vine.object.union\" with properties.\n */\n merge<Group extends ObjectGroup<GroupConditional<any, any, any>>>(",
"score": 40.801889436187814
},
{
"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": 36.855666193604435
}
] | 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/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": 115.82793593227444
},
{
"filename": "src/schema/enum/main.ts",
"retrieved_chunk": " * Default collection of enum rules\n */\n static rules = {\n enum: enumRule,\n }\n #values: Values | ((field: FieldContext) => Values)\n /**\n * Returns the enum choices\n */\n getChoices() {",
"score": 114.02788761795566
},
{
"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": 109.67685295965919
},
{
"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": 106.9961175569736
},
{
"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": 88.27989754466266
}
] | 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/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": 64.14041314632006
},
{
"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": 61.661676010604296
},
{
"filename": "src/schema/object/group_builder.ts",
"retrieved_chunk": " * Wrap object properties inside an else conditon\n */\ngroup.else = function groupElse<Properties extends Record<string, SchemaTypes>>(\n properties: Properties\n) {\n return new GroupConditional<\n Properties,\n {\n [K in keyof Properties]: Properties[K][typeof OTYPE]\n },",
"score": 52.27169993587911
},
{
"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": 44.428834280444406
},
{
"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": 30.20166822414983
}
] | 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": " 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": 64.14041314632006
},
{
"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": 61.661676010604296
},
{
"filename": "src/schema/object/group_builder.ts",
"retrieved_chunk": " * Wrap object properties inside an else conditon\n */\ngroup.else = function groupElse<Properties extends Record<string, SchemaTypes>>(\n properties: Properties\n) {\n return new GroupConditional<\n Properties,\n {\n [K in keyof Properties]: Properties[K][typeof OTYPE]\n },",
"score": 49.883190621997386
},
{
"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": 31.474036872335045
},
{
"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": 29.954315752882966
}
] | 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": 34.86264891741901
},
{
"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": 32.609612146465466
},
{
"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": 27.72928647594427
},
{
"filename": "src/vine/helpers.ts",
"retrieved_chunk": " */\n isArray<Value>(value: unknown): value is Value[] {\n return Array.isArray(value)\n },\n /**\n * Check if the value is a number or a string representation of a number.\n */\n isNumeric(value: any): boolean {\n return !Number.isNaN(Number(value))\n },",
"score": 26.080485867173454
},
{
"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": 21.762044749510434
}
] | 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/group_builder.ts",
"retrieved_chunk": " * Wrap object properties inside an else conditon\n */\ngroup.else = function groupElse<Properties extends Record<string, SchemaTypes>>(\n properties: Properties\n) {\n return new GroupConditional<\n Properties,\n {\n [K in keyof Properties]: Properties[K][typeof OTYPE]\n },",
"score": 83.29827782979578
},
{
"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": 75.621464096389
},
{
"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": 67.48899648365534
},
{
"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": 54.81668912833891
},
{
"filename": "src/schema/object/group_builder.ts",
"retrieved_chunk": " return new ObjectGroup<Conditional>(conditionals)\n}\n/**\n * Wrap object properties inside a conditonal\n */\ngroup.if = function groupIf<Properties extends Record<string, SchemaTypes>>(\n conditon: (value: Record<string, unknown>, field: FieldContext) => any,\n properties: Properties\n) {\n return new GroupConditional<",
"score": 53.37811538658975
}
] | 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/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": 25.574069096958247
},
{
"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": 25.243158586056072
},
{
"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": 24.483287994396687
},
{
"filename": "src/schema/object/main.ts",
"retrieved_chunk": "> extends BaseModifiersType<Schema[typeof COTYPE], Schema[typeof COTYPE]> {\n #schema: Schema;\n /**\n * The property must be implemented for \"unionOfTypes\"\n */\n [UNIQUE_NAME] = 'types.object';\n /**\n * Checks if the value is of object type. The method must be\n * implemented for \"unionOfTypes\"\n */",
"score": 22.819873658936316
},
{
"filename": "src/schema/tuple/main.ts",
"retrieved_chunk": " clone(): this {\n const cloned = new VineTuple<Schema, Output, CamelCaseOutput>(\n this.#schemas.map((schema) => schema.clone()) as Schema,\n this.cloneOptions(),\n this.cloneValidations()\n )\n if (this.#allowUnknownProperties) {\n cloned.allowUnknownProperties()\n }\n return cloned as this",
"score": 19.903946538850413
}
] | 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/builder.ts",
"retrieved_chunk": "union.else = function unionElse<Schema extends SchemaTypes>(schema: Schema) {\n return new UnionConditional<Schema>(() => true, schema)\n}",
"score": 34.42093574899299
},
{
"filename": "src/schema/union/builder.ts",
"retrieved_chunk": " */\nunion.if = function unionIf<Schema extends SchemaTypes>(\n conditon: (value: Record<string, unknown>, field: FieldContext) => any,\n schema: Schema\n) {\n return new UnionConditional<Schema>(conditon, schema)\n}\n/**\n * Wrap object properties inside an else conditon\n */",
"score": 29.956027300345287
},
{
"filename": "src/schema/tuple/main.ts",
"retrieved_chunk": " clone(): this {\n const cloned = new VineTuple<Schema, Output, CamelCaseOutput>(\n this.#schemas.map((schema) => schema.clone()) as Schema,\n this.cloneOptions(),\n this.cloneValidations()\n )\n if (this.#allowUnknownProperties) {\n cloned.allowUnknownProperties()\n }\n return cloned as this",
"score": 29.039399850844152
},
{
"filename": "src/vine/main.ts",
"retrieved_chunk": " *\n * ```ts\n * const validate = vine.compile(schema)\n * await validate({ data })\n * ```\n */\n compile<Schema extends SchemaTypes>(schema: Schema) {\n return new VineValidator<Schema, Record<string, any> | undefined>(schema, {\n convertEmptyStringsToNull: this.convertEmptyStringsToNull,\n messagesProvider: this.messagesProvider,",
"score": 28.32659152353897
},
{
"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": 28.312349724394462
}
] | 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.