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 { Event } from ".";
import makeDecision, { toOpenAiMessage } from "../make-decision";
import { messageBuilder } from "../message";
import { ModuleManager } from "../module/module-manager";
import { Store } from "../store";
import {
AVG_WORDS_PER_TOKEN,
agentName,
countTokens as countTokensInText,
messageSourceName,
} from "../util";
export class Memory {
private firstRetrieval = true;
constructor(
private agentId: string,
private moduleManager: ModuleManager,
private store: Store<Event[]>,
private compressionThreshold: number
) {}
async append(event: Event): Promise<Event[]> {
this.printEvent(event);
let events = await this.retrieve();
if (event.type === "message" && event.message.type === "ok") {
// After an "ok" message is sent, remove all errors and their antecedents from memory,
// since agents tend to repeat mistakes rather than learning from them.
events = this.removeErrors(events);
}
events.push(event);
events = await this.summarize(events);
await this.store.set(this.key, events.slice(1));
return events;
}
async retrieve(): Promise<Event[]> {
const introduction = await this.getIntroduction();
const storedEvents = await this.store.get(this.key);
let events = [
introduction,
...(storedEvents || [{ type: "decision", actionText: "noop" }]),
];
if (this.firstRetrieval) {
this.firstRetrieval = false;
events = await this.summarize(events);
await this.store.set(this.key, events.slice(1));
}
// events.forEach((event) => this.printEvent(event));
return events;
}
private async getIntroduction(): Promise<Event> {
const nestedEvents = await Promise.all(
this.moduleManager.modules.map(async (module): Promise<string[]> => {
const { name, pinnedMessage } = module.moduleDef;
if (!pinnedMessage) return [];
const content = await pinnedMessage(module.context);
if (!content) return [];
return [`--- ${name.toUpperCase()} ---\n\n${content}`];
})
);
return {
type: "message",
message: messageBuilder.spontaneous(
this.agentId,
nestedEvents.flat().join("\n\n")
),
};
}
private removeErrors(events: Event[]): Event[] {
const cleaned: Event[] = [];
for (let i = events.length - 1; i >= 0; i--) {
const event = events[i];
if (event.type === "message" && event.message.type === "error") {
const prevEvent = events[i - 1];
// console.log("REMOVING", JSON.stringify(prevEvent, null, 2));
// console.log("REMOVING", JSON.stringify(event, null, 2));
if (prevEvent.type === "decision") {
i--; // skip the previous action which generated the error
} else {
console.error("error event was not preceded by an action");
}
continue;
}
cleaned.push(event);
}
cleaned.reverse();
// console.log({ events, cleaned });
return cleaned;
}
/**
* Compress the event history when it becomes too large in order to free up the context window.
*/
private async summarize(events: Event[]): Promise<Event[]> {
if (!events.length) return [];
const cumulativeTokenCounts = this.getCumulativeTokenCounts(events);
const totalTokenCount =
cumulativeTokenCounts[cumulativeTokenCounts.length - 1];
const thresholdOverrun = totalTokenCount - this.compressionThreshold;
const truncationThreshold =
cumulativeTokenCounts[0] +
Math.max(
thresholdOverrun,
Math.floor((totalTokenCount - cumulativeTokenCounts[0]) / 2)
);
// console.log(
// `Token count: ${totalTokenCount}\nRemaining context space: ${-thresholdOverrun}`
// );
// console.log({
// compressionThreshold: this.compressionThreshold,
// truncationThreshold,
// thresholdOverrun,
// cumulativeTokenCounts,
// });
if (thresholdOverrun > 0) {
let i = 1;
// prettier-ignore
for (; i < events.length && cumulativeTokenCounts[i - 1] <= truncationThreshold; i++);
// prettier-ignore
for (; i > 0 && cumulativeTokenCounts[i - 1] > this.compressionThreshold; i--);
i = Math.max(i, 3);
const precedingTokens = cumulativeTokenCounts[i - 1];
// console.log({ truncationIndex: i, precedingTokens });
const summaryWordLimit = Math.floor(
(this.compressionThreshold * AVG_WORDS_PER_TOKEN) / 6
);
const eventsToSummarize = events.slice(0, i);
// console.log(
// `Summarizing ${eventsToSummarize.length} events (${eventsToSummarize
// .map(countTokens)
// .reduce((sum, next) => sum + next, 0)} tokens)`
// );
const summaryContent | = await makeDecision([
...eventsToSummarize,
{ |
type: "message",
message: messageBuilder.ok(
this.agentId,
`Write a summary in ${summaryWordLimit} words or less of what has happened since (but not including) the introductory message. Include key information that you learned which you don't want to forget. This information will serve as a note to yourself to help you understand what has gone before. Use the second person voice, as if you are someone filling in your replacement who knows nothing. The summarized messages will be omitted from your context window going forward and you will only have this summary to go by, so make it as useful and information-dense as possible. Be as specific as possible, but only include important information. If there are details that seem unimportant, or which you could recover outside of your memory (for instance the particular contents of a file which you could read any time), then omit them from your summary. Once again, your summary must not exceed ${summaryWordLimit} words. In this particular instance, your response should just be raw text, not formatted as an action.`
),
},
]);
const summary = `Several events are omitted here to free up space in your context window, summarized as follows:\n\n${summaryContent}`;
// const summary =
// "Several events are omitted here to free up space in your context window.";
const summaryEvent: Event = {
type: "message",
message: messageBuilder.spontaneous(this.agentId, summary),
};
const summaryTokens = countTokens(summaryEvent);
const tokenSavings =
precedingTokens - summaryTokens - cumulativeTokenCounts[0];
if (tokenSavings > 0) {
// console.log(
// `Summarized events, saving ${tokenSavings} tokens:\n\n${summary}`
// );
const newEvents = [events[0], summaryEvent, ...events.slice(i)];
// const newCumulativeTokenCounts =
// this.getCumulativeTokenCounts(newEvents);
// console.log({ newCumulativeTokenCounts });
return newEvents;
}
}
return events;
}
private getCumulativeTokenCounts(events: Event[]) {
return events.reduce((counts, event) => {
const prevSum = counts.length ? counts[counts.length - 1] : 0;
counts.push(prevSum + countTokens(event));
return counts;
}, [] as number[]);
}
private get key() {
return "memory";
}
private printEvent(event: Event) {
let sourceName: string;
let targetNames: string[];
if (event.type === "message") {
const { message } = event;
sourceName = messageSourceName(message.source);
targetNames = message.targetAgentIds?.map(agentName);
} else {
sourceName = agentName(this.agentId);
targetNames = ["System"];
}
console.log(
`${sourceName} -> ${targetNames.join(", ")}:\n\n${
toOpenAiMessage(event).content
}\n\n=============\n`
);
}
}
function countTokens(event: Event) {
return countTokensInText(toOpenAiMessage(event).content);
}
| src/memory/memory.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/make-decision.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport { Event } from \"./memory\";\nimport { createChatCompletion } from \"./openai\";\nimport { model } from \"./parameters\";\nimport { messageSourceName } from \"./util\";\nexport default async function makeDecision(events: Event[]): Promise<string> {\n console.log(`Reflecting on ${events.length} events...`);\n const t0 = Date.now();\n const messages = events.map(toOpenAiMessage);\n // console.log(JSON.stringify(messages, null, 2));",
"score": 25.48501888651117
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " console.log(`HTML tokens: ${countTokens(htmlContent)}`);\n turndownService.remove([\"style\", \"script\"]);\n const markdownContent = turndownService\n .turndown(htmlContent)\n .replace(/\\\\_/g, \"_\");\n const markdownTokens = countTokens(markdownContent);\n console.log(`Markdown tokens: ${markdownTokens}`);\n const chunks: string[] = [];\n let currentChunkLines: string[] = [];\n let currentChunkTokens = 0;",
"score": 21.01568334385945
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " // const summaryLimitText = `${maxChunkSummaryWords} words`;\n const chunkSummaryLimitText = `${maxChunkSummaryCharacters} characters`;\n console.log(\n `Max tokens per chunk summary: ${maxChunkSummaryTokens} (${chunkSummaryLimitText})`\n );\n console.log(\"Summarizing chunks...\");\n const summarizedChunks = await Promise.all(\n chunks.map(async (chunk) =>\n createChatCompletion({\n model,",
"score": 20.713856032768884
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " .map(\n (chunk) =>\n `=== SUMMARIZED CHUNK (${countTokens(\n chunk\n )} tokens) ===\\n\\n${chunk}\\n\\n`\n )\n .join(\"\");\n // console.log(`Summary:\\n\\n${summary}\\n`);\n console.log(`Summary tokens: ${countTokens(summary)}`);\n await browser.close();",
"score": 20.512508492605235
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " chunks.push(lastChunk);\n // console.log(\n // chunks\n // .map((chunk) => `CHUNK (${countTokens(chunk)}):\\n\\n${chunk}\\n\\n`)\n // .join(\"\")\n // );\n console.log(\n `Total chunks: ${chunks.length} (${Math.round(\n markdownTokens / chunks.length\n )} tokens per chunk)`",
"score": 19.14894565595562
}
] | typescript | = await makeDecision([
...eventsToSummarize,
{ |
import Notification from "../models/Notification";
import User from "../models/User";
import { randStr } from "./randUtil";
/**
* Adds a notification to a given user
* @param {string} text The message. `%1` is automatically replaced with the username of the recipient.
* @param {string} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
*/
export async function addNotification(
text: string,
type: "internal",
recipient: string
): Promise<void>;
/**
* Adds a notification to a given user
* @param {string} text The message. `%1` is automatically replaced with the username of the sender.
* @param {string} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
* @param {string} sender The user who added the notification
*/
export async function addNotification(
text: string,
type: "like" | "reply" | "retweet",
recipient: string,
sender: string,
tweet: string
): Promise<void>;
/**
* Adds a notification to a given user
* @param {string=} text The message. `%1` is automatically replaced with the username.
* @param {string=} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
* @param {string=} sender The user who added the notification
*/
export async function addNotification(
text: string,
type: "like" | "reply" | "retweet" | "internal",
recipient: string,
sender?: string,
tweet?: string
) {
const | id = randStr(64); |
if (sender) {
// user-based
const icon = (() => {
if (type === "like") return "heart_icon";
if (type === "reply") return "reply_icon";
if (type === "retweet") return "reweet_icon";
else return "bird_icon";
})();
const recipientUser = await User.findOne({ id_string: recipient });
if (!recipientUser) throw new Error(`Recipient not found`);
const senderUser = await User.findOne({ id_string: sender });
if (!senderUser) throw new Error(`Sender not found`);
const noti = new Notification({
id,
message: {
text: text.replaceAll("%1", senderUser.name!),
rtl: false,
entities: [
{
fromIndex: 0,
toIndex: senderUser.name!.length,
ref: {
user: {
id: sender,
},
},
},
],
},
icon: {
id: icon,
},
timestampMs: Date.now(),
template: {
aggregateUserActionsV1: {
targetObjects: [
{
tweet: {
id: tweet,
},
},
],
fromUsers: [
{
user: {
id: sender,
},
},
],
},
},
});
recipientUser.notification_ids.push(id);
await noti.save();
await recipientUser.save();
return;
} else {
// sent from admin
const recipientUser = await User.findOne({ id_string: recipient });
if (!recipientUser) throw new Error(`Recipient not found`);
recipientUser.notification_ids.push(id);
const noti = new Notification({
id,
message: {
text: text.replaceAll("%1", recipientUser.name!),
rtl: false,
entities: [
{
fromIndex: 0,
toIndex: recipientUser.name!.length,
ref: {
user: {
id: recipient,
},
},
},
],
},
icon: {
id: "bird_icon",
},
timestampMs: Date.now(),
});
await noti.save();
await recipientUser.save();
return;
}
}
| src/util/notifications.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/types/guide.ts",
"retrieved_chunk": "export interface ExtendedEntitiesMedia {\n\tid: number;\n\tid_str: string;\n\tindices: number[];\n\tmedia_url: string;\n\tmedia_url_https: string;\n\turl: string;\n\tdisplay_url: string;\n\texpanded_url: string;\n\ttype: Type | string;",
"score": 29.59985131733523
},
{
"filename": "src/types/guide.ts",
"retrieved_chunk": "export interface EntitiesMedia {\n\tid: number;\n\tid_str: string;\n\tindices: number[];\n\tmedia_url: string;\n\tmedia_url_https: string;\n\turl: string;\n\tdisplay_url: string;\n\texpanded_url: string;\n\ttype: Type | string;",
"score": 29.59985131733523
},
{
"filename": "src/types/task.ts",
"retrieved_chunk": "\tuser_identifier_display_type: string;\n\tusername: string;\n}\nexport interface Footer {\n\tfootnote_text: Text;\n\tstyle: string;\n}\nexport interface Text {\n\tentities: PrimaryTextEntity[];\n\ttext: string;",
"score": 28.817160639024717
},
{
"filename": "src/types/guide.ts",
"retrieved_chunk": "export interface SelfThread {\n\tid: number;\n\tid_str: string;\n}\nexport interface IUser {\n\tid?: number;\n\tid_str?: string;\n\tname: string;\n\tscreen_name: string;\n\tlocation: string;",
"score": 27.852501833169626
},
{
"filename": "src/types/guide.ts",
"retrieved_chunk": "export interface ItemContent {\n\ttweet: ContentTweet;\n}\nexport interface ContentTweet {\n\tid: string;\n\tdisplayType: DisplayType | string;\n}\nexport enum DisplayType {\n\tTweet = \"Tweet\",\n}",
"score": 25.434340600139297
}
] | typescript | id = randStr(64); |
import express from "express";
import { verify } from "jsonwebtoken";
import { requireAuth } from "../../middleware/auth";
import Tweet from "../../models/Tweet";
import User from "../../models/User";
import {
ICreateTweetBody,
IGenericFeatures,
IJwtDecoded,
} from "../../types/graphql";
import { IUser } from "../../types/guide";
import { formatDate } from "../../util/formatDate";
import { log } from "../../util/logging";
import { randInt } from "../../util/randUtil";
import { IUserMention } from "./user";
import { addNotification } from "../../util/notifications";
interface IUserTweetsVariables {
userId: string;
count: number;
includePromotedContent: boolean;
withQuickPromoteEligibilityTweetFields: boolean;
withVoice: boolean;
withV2Timeline: boolean;
}
interface IFavouriteTweetVariables {
tweet_id: string;
}
export async function UserTweets(req: express.Request, res: express.Response) {
const loggedInUser = req.cookies["jwt"]
? await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id,
})
: undefined;
const features = JSON.parse(
req.query.features!.toString()
) as IGenericFeatures;
const variables = JSON.parse(
req.query.variables!.toString()
) as IUserTweetsVariables;
if (!features || !variables)
return res.status(400).send({ msg: "Missing parameters" });
const user = await User.findOne({ id: variables.userId });
if (!user) return res.status(400).send({ msg: "User not found" });
const userTweets = [];
const postedTweets = Array.from(user.posted_tweet_ids);
for (const id of postedTweets) {
const tweet = await Tweet.findOne({ id_str: id });
userTweets.push({
is_translatable: false,
legacy: tweet
? Object.assign(tweet, {
favorited: loggedInUser
? loggedInUser.liked_tweet_ids.includes(tweet.id_str || "")
: false,
})
: tweet,
source: tweet?.source,
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
});
}
return res.status(200).send({
data: {
user: {
result: {
__typename: "User",
timeline_v2: {
timeline: {
instructions: [
{
type: "TimelineClearCache",
},
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified:
user.ext_is_blue_verified,
legacy: {
...(user as any)._doc,
},
profile_image_shape:
user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
},
},
});
}
export async function HomeTimeline(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const userId = req.cookies["jwt"]
? ((verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded)
.id as number)
: undefined;
const loggedInUser = await User.findOne({
id_string: userId,
});
if (!loggedInUser) return res.status(400).send({ msg: "Not authenticated" });
const userTweets = [];
const postedTweets = await Tweet.find().limit(50);
for (const tweet of postedTweets) {
const user = await User.findOne({ id_string: tweet.user_id_str });
if (!user) return res.status(400).send({ msg: "User not found" });
userTweets.push({
is_translatable: false,
legacy: Object.assign(tweet, {
favorited: loggedInUser.liked_tweet_ids.includes(tweet.id_str || ""),
}),
unmention_data: {},
unmention_info: {},
views: tweet.ext_views,
user: user,
});
}
return res.status(200).send({
data: {
home: {
home_timeline_urt: {
instructions: [
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
tweet.user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: tweet.user._id,
is_blue_verified:
tweet.user.ext_is_blue_verified,
legacy: {
...(tweet.user as any)._doc,
entities: {
user_mentions: (
tweet.legacy.entities
?.user_mentions as IUserMention[]
).map((mention) => {
return {
a: true,
};
}),
},
},
profile_image_shape:
tweet.user.ext_profile_image_shape,
rest_id: tweet.user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.legacy.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
});
}
export async function FavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (!user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids.push(variables.tweet_id);
tweet.favorite_count! += 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { favourte_tweet: "NOT DONE" } });
}
if (tweet.user_id_str !== user.id_string)
addNotification(
"%1 liked your tweet!",
"like",
tweet.user_id_str!,
user.id_string!,
tweet.id_str!
);
return res.status(200).send({ data: { favorite_tweet: "Done" } });
}
export async function UnfavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids = user.liked_tweet_ids.filter(
(id) => id !== variables.tweet_id
);
tweet.favorite_count! -= 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { unfavorite_tweet: "NOT DONE" } });
}
return res.status(200).send({ data: { unfavorite_tweet: "Done" } });
}
export async function CreateTweet(req: express.Request, res: express.Response) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const body = req.body as ICreateTweetBody;
const id = (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id as number;
const user = await User.findOne({ id });
if (!user) return res.status(400).send({ msg: "User not found" });
const user_mentions = [] as IUserMention[];
const matches = body.variables.tweet_text.matchAll(/@(\S+)/gm);
for (const match of matches) {
const withTag = match[0];
const withoutTag = match[1];
const user = await User.findOne({ screen_name: withoutTag });
user_mentions.push({
id_str: user?.id_string,
name: user?.name,
screen_name: user?.screen_name,
indices: [match.index, withTag.length + (match.index || 0)],
});
}
const tweetId = randInt(12);
const tweetData = {
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
| created_at: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: { |
hashtags: [],
symbols: [],
urls: [],
user_mentions,
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id: tweetId,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
source:
'<a href="https://mobile.twitter.com" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
};
const tweet = new Tweet({
bookmark_count: tweetData.legacy.bookmark_count,
bookmarked: tweetData.legacy.bookmarked,
conversation_id_str: tweetData.legacy.conversation_id_str,
created_at: tweetData.legacy.created_at,
display_text_range: tweetData.legacy.display_text_range,
entities: {
hashtags: tweetData.legacy.entities.hashtags,
symbols: tweetData.legacy.entities.symbols,
urls: tweetData.legacy.entities.urls,
user_mentions,
},
favorite_count: tweetData.legacy.favorite_count,
favorited: tweetData.legacy.favorited,
full_text: tweetData.legacy.full_text,
id_str: tweetData.legacy.id_str,
is_quote_status: tweetData.legacy.is_quote_status,
lang: tweetData.legacy.lang,
quote_count: tweetData.legacy.quote_count,
reply_count: tweetData.legacy.reply_count,
retweet_count: tweetData.legacy.retweet_count,
retweeted: tweetData.legacy.retweeted,
user_id_str: tweetData.legacy.user_id_str,
});
await tweet.save();
user.posted_tweet_ids.push(tweetId.toString());
await user.save();
log(`${user.name} (@${user.screen_name}) just posted a tweet:`);
log(`"${tweet.full_text}"`);
// addNotification(
// "%1 just posted a tweet!",
// "reply",
// user.id_string!,
// user.id_string!,
// tweet.id_str!
// );
return res.status(200).send({
// data: {
// create_tweet: {
// tweet_results: {
// result: {
// core: {
// user_results: {
// result: {
// __typename: "User",
// affiliates_highlighted_label:
// user.ext?.highlightedLabel?.r?.ok,
// business_account: {},
// id: user._id,
// is_blue_verified: user.ext_is_blue_verified,
// legacy: {
// created_at: user.created_at,
// default_profile: user.default_profile,
// default_profile_image: user.default_profile_image,
// description: user.description,
// entities: user.entities,
// fast_followers_count: user.fast_followers_count,
// favourites_count: user.favourites_count,
// followers_count: user.followers_count,
// friends_count: user.friends_count,
// has_custom_timelines: user.has_custom_timelines,
// is_translator: user.is_translator,
// listed_count: user.listed_count,
// location: user.location,
// media_count: user.media_count,
// name: user.name,
// normal_followers_count: user.normal_followers_count,
// pinned_tweet_ids_str: user.pinned_tweet_ids_str,
// possibly_sensitive: false,
// profile_image_url_https: user.profile_image_url_https,
// profile_interstitial_type: "",
// screen_name: user.screen_name,
// statuses_count: user.statuses_count,
// translator_type: user.translator_type,
// verified: user.verified,
// withheld_in_countries: user.withheld_in_countries,
// },
// profile_image_shape: user.ext_profile_image_shape,
// rest_id: user.id,
// },
// },
// },
// ...tweetData,
// },
// },
// },
// },
data: {
create_tweet: {
tweet_results: {
result: {
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified: user.ext_is_blue_verified,
legacy: {
created_at: user.created_at,
default_profile: user.default_profile,
default_profile_image: user.default_profile_image,
description: user.description,
entities: user.entities,
fast_followers_count: user.fast_followers_count,
favourites_count: user.favourites_count,
followers_count: user.followers_count,
friends_count: user.friends_count,
has_custom_timelines: user.has_custom_timelines,
is_translator: user.is_translator,
listed_count: user.listed_count,
location: user.location,
media_count: user.media_count,
name: user.name,
normal_followers_count: user.normal_followers_count,
pinned_tweet_ids_str: user.pinned_tweet_ids_str,
possibly_sensitive: false,
profile_image_url_https: user.profile_image_url_https,
profile_interstitial_type: "",
screen_name: user.screen_name,
statuses_count: user.statuses_count,
translator_type: user.translator_type,
verified: user.verified,
withheld_in_countries: user.withheld_in_countries,
},
profile_image_shape: user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_control: {
edit_tweet_ids: [tweetId.toString()],
editable_until_msecs: "1682984834000",
edits_remaining: "5",
is_edit_eligible: true,
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, 68],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions: (
tweet.entities!.user_mentions as Array<Array<IUserMention>>
).map((mention) => mention[0]),
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
rest_id: tweetId.toString(),
source:
'<a href="https://github.com/" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Disabled",
},
},
},
},
},
});
}
| src/routes/gql/tweet.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/models/Tweet.ts",
"retrieved_chunk": "import mongoose from \"mongoose\";\nconst tweet = new mongoose.Schema({\n\tbookmark_count: {\n\t\ttype: \"Number\",\n\t},\n\tbookmarked: {\n\t\ttype: \"Boolean\",\n\t},\n\tconversation_id_str: {\n\t\ttype: \"String\",",
"score": 24.175562446239386
},
{
"filename": "src/models/Tweet.ts",
"retrieved_chunk": "\t},\n\tcreated_at: {\n\t\ttype: \"String\",\n\t},\n\tdisplay_text_range: {\n\t\ttype: [\"Number\"],\n\t},\n\tentities: {\n\t\thashtags: {\n\t\t\ttype: \"Array\",",
"score": 19.45210592412102
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\t\t\tvalue: false,\n\t\t\t\t\t},\n\t\t\t\t\tresponsive_web_settings_timeline_polling_enabled: {\n\t\t\t\t\t\tvalue: false,\n\t\t\t\t\t},\n\t\t\t\t\tresponsive_web_settings_timeline_polling_interval_ms: {\n\t\t\t\t\t\tvalue: 0,\n\t\t\t\t\t},\n\t\t\t\t\tresponsive_web_settings_timeline_refresh_background_interval: {\n\t\t\t\t\t\tvalue: 0,",
"score": 18.87044089828726
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\thighContrastEnabled: false,\n\t\t\t\tloginPromptLastShown: 0,\n\t\t\t\treducedMotionEnabled: false,\n\t\t\t\tshowTweetMediaDetailDrawer: true,\n\t\t\t\tautoPollNewTweets: false,\n\t\t\t\tshouldAutoTagLocation: false,\n\t\t\t\tundoPreview: {},\n\t\t\t\treplyVotingSurveyClicked: 0,\n\t\t\t\tpushNotificationsPermission: null,\n\t\t\t},",
"score": 18.596183756782022
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\t\t\tfavourites_count: user.favourites_count || 0,\n\t\t\t\t\t\tfollowers_count: user.followers_count || 0,\n\t\t\t\t\t\tfriends_count: user.friends_count || 0,\n\t\t\t\t\t\thas_custom_timelines: user.has_custom_timelines || false,\n\t\t\t\t\t\tis_translator: user.is_translator || false,\n\t\t\t\t\t\tlisted_count: user.listed_count || 0,\n\t\t\t\t\t\tlocation: user.location || \"\",\n\t\t\t\t\t\tmedia_count: user.media_count || 0,\n\t\t\t\t\t\tname: user.name || \"\",\n\t\t\t\t\t\tneeds_phone_verification: false,",
"score": 17.62725616807401
}
] | typescript | created_at: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: { |
import {
readFile,
readdir,
rename,
stat,
unlink,
writeFile,
mkdir,
} from "fs/promises";
import { join as joinPath, resolve as resolvePath } from "path";
import { defineModule } from "../define-module";
import { messageBuilder } from "../../message";
export default defineModule({
name: "filesystem",
}).with({
actions: {
listDirectory: {
description: "Inspect the contents of a particular directory",
parameters: {
path: {
description: "The path of the directory you want to inspect",
},
},
async execute({
parameters: { path },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, path, sendMessage)) return;
try {
const files = await readdir(path);
const filesWithStatsPromises = files.map(async (file) => {
const stats = await stat(joinPath(path, file));
return `${file} ${stats.isDirectory() ? "[directory]" : "[file]"}`;
});
const filesWithStats = await Promise.all(filesWithStatsPromises);
sendMessage(
messageBuilder | .ok(
agentId,
`Here are the contents of ${path}:\n${filesWithStats.join("\n")}`
)
); |
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
readFile: {
description: "Read the contents of a particular file",
parameters: {
path: {
description: "The path of the file you want to inspect",
},
},
async execute({
parameters: { path },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, path, sendMessage)) return;
try {
const data = await readFile(path, "utf8");
sendMessage(
messageBuilder.ok(agentId, `Contents of ${path}:\n\n${data}`)
);
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
writeFile: {
description: "Write the contents of a particular file",
parameters: {
path: {
description: "The path of the file you want to write to",
},
content: {
description: "The new content of the file",
},
},
async execute({
parameters: { path, content },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, path, sendMessage)) return;
try {
await writeFile(path, content, "utf8");
sendMessage(messageBuilder.ok(agentId, `Wrote to ${path}.`));
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
moveFile: {
description: "Move a file to a new location",
parameters: {
sourcePath: {
description: "The original path of the file",
},
destinationPath: {
description: "The new path for the file",
},
},
async execute({
parameters: { sourcePath, destinationPath },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, sourcePath, sendMessage)) return;
if (!checkPath(agentId, destinationPath, sendMessage)) return;
try {
await rename(sourcePath, destinationPath);
sendMessage(
messageBuilder.ok(
agentId,
`Moved ${sourcePath} to ${destinationPath}.`
)
);
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
deleteFile: {
description: "Delete a file",
parameters: {
path: {
description: "The path of the file to delete",
},
},
async execute({
parameters: { path },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, path, sendMessage)) return;
try {
await unlink(path);
sendMessage(messageBuilder.ok(agentId, `Deleted ${path}.`));
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
createDirectory: {
description: "Create a new directory",
parameters: {
path: {
description: "The path of the directory to create",
},
},
async execute({
parameters: { path },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, path, sendMessage)) return;
try {
await mkdir(path);
sendMessage(messageBuilder.ok(agentId, `Created directory ${path}.`));
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
},
});
function checkPath(
agentId: string,
path: string,
sendMessage: (message: any) => void
) {
const currentDirectory = process.cwd();
const resolvedPath = resolvePath(path);
if (!resolvedPath.startsWith(currentDirectory)) {
sendMessage(
messageBuilder.error(
agentId,
"Invalid path; must be within the current directory."
)
);
return false;
}
if (resolvedPath.includes(".git") || resolvedPath.includes("node_modules")) {
sendMessage(messageBuilder.error(agentId, "That path is off-limits!"));
return false;
}
return true;
}
| src/module/definitions/filesystem.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " sendMessage(\n messageBuilder.ok(\n agentId,\n `These are the agents in the system:\\n\\n${allAgentIds\n .map((id) => `${agentName(id)} [agentId=${id}]`)\n .join(\"\\n\")}`\n )\n );\n },\n },",
"score": 24.29998958581431
},
{
"filename": "src/store/file-store.ts",
"retrieved_chunk": " const path = this.pathFor(key);\n const fileExists = await checkExists(path);\n if (!fileExists) return false;\n await unlink(path);\n return true;\n }\n async getKeys() {\n await this.mkdirs();\n const fileNames = await readdir(this.dirPath);\n // Get file stats for each file in parallel",
"score": 22.609797861119194
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " model,\n maxCompletionTokens,\n url\n );\n sendMessage(\n messageBuilder.ok(\n agentId,\n `Here is a summarized markdown version of the page, in a series of summarized chunks:\\n\\n${pageSummary}`\n )\n );",
"score": 22.580381484474078
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " return sendMessage(\n messageBuilder.ok(agentId, \"Search returned no results.\")\n );\n }\n sendMessage(\n messageBuilder.ok(\n agentId,\n `Search results:\\n\\n${items\n .map((item) => `- Title: \"${item.title}\"\\n URL: ${item.link}`)\n .join(\"\\n\\n\")}`",
"score": 21.619277882412977
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " messageBuilder.ok(agentId, `Content of \"${title}\":\\n\\n${content}`)\n );\n } else {\n sendMessage(\n messageBuilder.error(agentId, `Note \"${title}\" not found.`)\n );\n }\n },\n },\n deleteNote: {",
"score": 18.702615903967477
}
] | typescript | .ok(
agentId,
`Here are the contents of ${path}:\n${filesWithStats.join("\n")}`
)
); |
import Notification from "../models/Notification";
import User from "../models/User";
import { randStr } from "./randUtil";
/**
* Adds a notification to a given user
* @param {string} text The message. `%1` is automatically replaced with the username of the recipient.
* @param {string} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
*/
export async function addNotification(
text: string,
type: "internal",
recipient: string
): Promise<void>;
/**
* Adds a notification to a given user
* @param {string} text The message. `%1` is automatically replaced with the username of the sender.
* @param {string} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
* @param {string} sender The user who added the notification
*/
export async function addNotification(
text: string,
type: "like" | "reply" | "retweet",
recipient: string,
sender: string,
tweet: string
): Promise<void>;
/**
* Adds a notification to a given user
* @param {string=} text The message. `%1` is automatically replaced with the username.
* @param {string=} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
* @param {string=} sender The user who added the notification
*/
export async function addNotification(
text: string,
type: "like" | "reply" | "retweet" | "internal",
recipient: string,
sender?: string,
tweet?: string
) {
const id = randStr(64);
if (sender) {
// user-based
const icon = (() => {
if (type === "like") return "heart_icon";
if (type === "reply") return "reply_icon";
if (type === "retweet") return "reweet_icon";
else return "bird_icon";
})();
| const recipientUser = await User.findOne({ id_string: recipient }); |
if (!recipientUser) throw new Error(`Recipient not found`);
const senderUser = await User.findOne({ id_string: sender });
if (!senderUser) throw new Error(`Sender not found`);
const noti = new Notification({
id,
message: {
text: text.replaceAll("%1", senderUser.name!),
rtl: false,
entities: [
{
fromIndex: 0,
toIndex: senderUser.name!.length,
ref: {
user: {
id: sender,
},
},
},
],
},
icon: {
id: icon,
},
timestampMs: Date.now(),
template: {
aggregateUserActionsV1: {
targetObjects: [
{
tweet: {
id: tweet,
},
},
],
fromUsers: [
{
user: {
id: sender,
},
},
],
},
},
});
recipientUser.notification_ids.push(id);
await noti.save();
await recipientUser.save();
return;
} else {
// sent from admin
const recipientUser = await User.findOne({ id_string: recipient });
if (!recipientUser) throw new Error(`Recipient not found`);
recipientUser.notification_ids.push(id);
const noti = new Notification({
id,
message: {
text: text.replaceAll("%1", recipientUser.name!),
rtl: false,
entities: [
{
fromIndex: 0,
toIndex: recipientUser.name!.length,
ref: {
user: {
id: recipient,
},
},
},
],
},
icon: {
id: "bird_icon",
},
timestampMs: Date.now(),
});
await noti.save();
await recipientUser.save();
return;
}
}
| src/util/notifications.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "// \t\treturn res.status(400).send({ msg: \"Missing parameters\" });\n// \tconst id_string = variables.userId;\n// \tif (!id_string || id_string === \"undefined\")\n// \t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n// \tconst user = await User.findOne({\n// \t\tid_string,\n// \t});\n// \tif (!user) return res.status(200).send({ data: {} });\n// \treturn res.status(200).send({\n// \t\tdata: {",
"score": 52.72240325390765
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": " `);\n\t}\n\tif (!req.cookies.jwt) return res.redirect(\"https://twitter.com\");\n\tconst user = await User.findOne({\n\t\tid_string: (decode(req.cookies.jwt) as { id: string }).id.toString(),\n\t});\n\tif (!user) return res.redirect(\"https://twitter.com\");\n\tconst __INITIAL_STATE__ = {\n\t\toptimist: [],\n\t\tentities: {",
"score": 52.45597716451802
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\tif (unauthorized) return;\n\tconst user = await User.findOne({\n\t\tid_string: (\n\t\t\tverify(req.cookies[\"jwt\"], process.env.JWT_SECRET!) as IJwtDecoded\n\t\t).id.toString(),\n\t});\n\tif (!user) return res.status(400).send({ msg: \"Not authenticated\" });\n\tconst variables = req.body.variables as IFavouriteTweetVariables;\n\tconst tweet = await Tweet.findOne({ id_str: variables.tweet_id });\n\tif (!tweet) return res.status(400).send({ msg: \"Tweet not found\" });",
"score": 51.505313342000264
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\t) as IUserTweetsVariables;\n\tif (!features || !variables)\n\t\treturn res.status(400).send({ msg: \"Missing parameters\" });\n\tconst user = await User.findOne({ id: variables.userId });\n\tif (!user) return res.status(400).send({ msg: \"User not found\" });\n\tconst userTweets = [];\n\tconst postedTweets = Array.from(user.posted_tweet_ids);\n\tfor (const id of postedTweets) {\n\t\tconst tweet = await Tweet.findOne({ id_str: id });\n\t\tuserTweets.push({",
"score": 50.07489505409448
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\t});\n}\nexport async function FavoriteTweet(\n\treq: express.Request,\n\tres: express.Response\n) {\n\tconst unauthorized = await requireAuth(req, res);\n\tif (unauthorized) return;\n\tconst user = await User.findOne({\n\t\tid_string: (",
"score": 49.67729562385112
}
] | typescript | const recipientUser = await User.findOne({ id_string: recipient }); |
import { ChatCompletionRequestMessage } from "openai";
import { Event } from "./memory";
import { createChatCompletion } from "./openai";
import { model } from "./parameters";
import { messageSourceName } from "./util";
export default async function makeDecision(events: Event[]): Promise<string> {
console.log(`Reflecting on ${events.length} events...`);
const t0 = Date.now();
const messages = events.map(toOpenAiMessage);
// console.log(JSON.stringify(messages, null, 2));
const responseContent = await createChatCompletion({
model,
messages,
temperature: 0.0,
});
console.log(
`Arrived at a decision after ${((Date.now() - t0) / 1000).toFixed(1)}s`
);
return responseContent;
}
// lazy load to avoid accessing OPENAI_API_KEY before env has been loaded
export function toOpenAiMessage(event: Event): ChatCompletionRequestMessage {
switch (event.type) {
case "message": {
const { type: messageType, source, content } = event.message;
const role = source.type === "system" ? "system" : "user";
let header: string;
switch (messageType) {
case "spontaneous":
case "ok":
header = "";
break;
case "agentToAgent":
header = `--- MESSAGE FROM ${messageSourceName(
source
).toUpperCase()} ---\n\n`;
break;
case "error":
header = "--- ERROR ---\n\n";
break;
}
return {
role,
content: ` | ${header}${content}`,
}; |
}
case "decision":
return {
role: "assistant",
content: event.actionText,
};
}
}
| src/make-decision.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " const { name, pinnedMessage } = module.moduleDef;\n if (!pinnedMessage) return [];\n const content = await pinnedMessage(module.context);\n if (!content) return [];\n return [`--- ${name.toUpperCase()} ---\\n\\n${content}`];\n })\n );\n return {\n type: \"message\",\n message: messageBuilder.spontaneous(",
"score": 13.97967348007145
},
{
"filename": "src/parameters.ts",
"retrieved_chunk": " break;\n default:\n throw Error(`Unrecognized OpenAI model: '${modelText}'`);\n}\nconsole.log(`Model: ${model}`);",
"score": 13.678681893673245
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " messageBuilder.ok(agentId, `Content of \"${title}\":\\n\\n${content}`)\n );\n } else {\n sendMessage(\n messageBuilder.error(agentId, `Note \"${title}\" not found.`)\n );\n }\n },\n },\n deleteNote: {",
"score": 13.430386695205298
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " targetNames = [\"System\"];\n }\n console.log(\n `${sourceName} -> ${targetNames.join(\", \")}:\\n\\n${\n toOpenAiMessage(event).content\n }\\n\\n=============\\n`\n );\n }\n}\nfunction countTokens(event: Event) {",
"score": 12.834435858092997
},
{
"filename": "src/console.ts",
"retrieved_chunk": " messageBus.subscribe((message) => {\n if (message.targetAgentIds && !message.targetAgentIds.includes(AGENT_ID))\n return;\n console.log(`\\n${message.content}\\n`);\n rl.prompt();\n });\n rl.on(\"line\", (input) => {\n const colonIndex = -1; //input.indexOf(\":\");\n let targetAgentIds: string[];\n let content: string;",
"score": 11.730776756706717
}
] | typescript | ${header}${content}`,
}; |
import express from "express";
import { verify } from "jsonwebtoken";
import { requireAuth } from "../../middleware/auth";
import Tweet from "../../models/Tweet";
import User from "../../models/User";
import {
ICreateTweetBody,
IGenericFeatures,
IJwtDecoded,
} from "../../types/graphql";
import { IUser } from "../../types/guide";
import { formatDate } from "../../util/formatDate";
import { log } from "../../util/logging";
import { randInt } from "../../util/randUtil";
import { IUserMention } from "./user";
import { addNotification } from "../../util/notifications";
interface IUserTweetsVariables {
userId: string;
count: number;
includePromotedContent: boolean;
withQuickPromoteEligibilityTweetFields: boolean;
withVoice: boolean;
withV2Timeline: boolean;
}
interface IFavouriteTweetVariables {
tweet_id: string;
}
export async function UserTweets(req: express.Request, res: express.Response) {
const loggedInUser = req.cookies["jwt"]
? await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id,
})
: undefined;
const features = JSON.parse(
req.query.features!.toString()
) as IGenericFeatures;
const variables = JSON.parse(
req.query.variables!.toString()
) as IUserTweetsVariables;
if (!features || !variables)
return res.status(400).send({ msg: "Missing parameters" });
const user = await User.findOne({ id: variables.userId });
if (!user) return res.status(400).send({ msg: "User not found" });
const userTweets = [];
const postedTweets = Array.from(user.posted_tweet_ids);
for (const id of postedTweets) {
const tweet = await Tweet.findOne({ id_str: id });
userTweets.push({
is_translatable: false,
legacy: tweet
? Object.assign(tweet, {
favorited: loggedInUser
? loggedInUser.liked_tweet_ids.includes(tweet.id_str || "")
: false,
})
: tweet,
source: tweet?.source,
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
});
}
return res.status(200).send({
data: {
user: {
result: {
__typename: "User",
timeline_v2: {
timeline: {
instructions: [
{
type: "TimelineClearCache",
},
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified:
user.ext_is_blue_verified,
legacy: {
...(user as any)._doc,
},
profile_image_shape:
user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
},
},
});
}
export async function HomeTimeline(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const userId = req.cookies["jwt"]
? ((verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded)
.id as number)
: undefined;
const loggedInUser = await User.findOne({
id_string: userId,
});
if (!loggedInUser) return res.status(400).send({ msg: "Not authenticated" });
const userTweets = [];
const postedTweets = await Tweet.find().limit(50);
for (const tweet of postedTweets) {
const user = await User.findOne({ id_string: tweet.user_id_str });
if (!user) return res.status(400).send({ msg: "User not found" });
userTweets.push({
is_translatable: false,
legacy: Object.assign(tweet, {
favorited: loggedInUser.liked_tweet_ids.includes(tweet.id_str || ""),
}),
unmention_data: {},
unmention_info: {},
views: tweet.ext_views,
user: user,
});
}
return res.status(200).send({
data: {
home: {
home_timeline_urt: {
instructions: [
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
tweet.user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: tweet.user._id,
is_blue_verified:
tweet.user.ext_is_blue_verified,
legacy: {
...(tweet.user as any)._doc,
entities: {
user_mentions: (
tweet.legacy.entities
?.user_mentions as IUserMention[]
).map((mention) => {
return {
a: true,
};
}),
},
},
profile_image_shape:
tweet.user.ext_profile_image_shape,
rest_id: tweet.user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.legacy.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
});
}
export async function FavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (!user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids.push(variables.tweet_id);
tweet.favorite_count! += 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { favourte_tweet: "NOT DONE" } });
}
if (tweet.user_id_str !== user.id_string)
addNotification(
"%1 liked your tweet!",
"like",
tweet.user_id_str!,
user.id_string!,
tweet.id_str!
);
return res.status(200).send({ data: { favorite_tweet: "Done" } });
}
export async function UnfavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids = user.liked_tweet_ids.filter(
(id) => id !== variables.tweet_id
);
tweet.favorite_count! -= 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { unfavorite_tweet: "NOT DONE" } });
}
return res.status(200).send({ data: { unfavorite_tweet: "Done" } });
}
export async function CreateTweet(req: express.Request, res: express.Response) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const body = req.body as ICreateTweetBody;
const id = (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id as number;
const user = await User.findOne({ id });
if (!user) return res.status(400).send({ msg: "User not found" });
const user_mentions = [] as IUserMention[];
const matches = body.variables.tweet_text.matchAll(/@(\S+)/gm);
for (const match of matches) {
const withTag = match[0];
const withoutTag = match[1];
const user = await User.findOne({ screen_name: withoutTag });
user_mentions.push({
id_str: user?.id_string,
name: user?.name,
screen_name: user?.screen_name,
indices: [match.index, withTag.length + (match.index || 0)],
});
}
const tweetId = randInt(12);
const tweetData = {
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions,
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id: tweetId,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
source:
'<a href="https://mobile.twitter.com" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
};
const tweet = new Tweet({
bookmark_count: tweetData.legacy.bookmark_count,
bookmarked: tweetData.legacy.bookmarked,
conversation_id_str: tweetData.legacy.conversation_id_str,
created_at: tweetData.legacy.created_at,
display_text_range: tweetData.legacy.display_text_range,
entities: {
hashtags: tweetData.legacy.entities.hashtags,
symbols: tweetData.legacy.entities.symbols,
urls: tweetData.legacy.entities.urls,
user_mentions,
},
favorite_count: tweetData.legacy.favorite_count,
favorited: tweetData.legacy.favorited,
full_text: tweetData.legacy.full_text,
id_str: tweetData.legacy.id_str,
is_quote_status: tweetData.legacy.is_quote_status,
lang: tweetData.legacy.lang,
quote_count: tweetData.legacy.quote_count,
reply_count: tweetData.legacy.reply_count,
retweet_count: tweetData.legacy.retweet_count,
retweeted: tweetData.legacy.retweeted,
user_id_str: tweetData.legacy.user_id_str,
});
await tweet.save();
user.posted_tweet_ids.push(tweetId.toString());
await user.save();
log(`${user.name} (@${user.screen_name}) just posted a tweet:`);
| log(`"${tweet.full_text}"`); |
// addNotification(
// "%1 just posted a tweet!",
// "reply",
// user.id_string!,
// user.id_string!,
// tweet.id_str!
// );
return res.status(200).send({
// data: {
// create_tweet: {
// tweet_results: {
// result: {
// core: {
// user_results: {
// result: {
// __typename: "User",
// affiliates_highlighted_label:
// user.ext?.highlightedLabel?.r?.ok,
// business_account: {},
// id: user._id,
// is_blue_verified: user.ext_is_blue_verified,
// legacy: {
// created_at: user.created_at,
// default_profile: user.default_profile,
// default_profile_image: user.default_profile_image,
// description: user.description,
// entities: user.entities,
// fast_followers_count: user.fast_followers_count,
// favourites_count: user.favourites_count,
// followers_count: user.followers_count,
// friends_count: user.friends_count,
// has_custom_timelines: user.has_custom_timelines,
// is_translator: user.is_translator,
// listed_count: user.listed_count,
// location: user.location,
// media_count: user.media_count,
// name: user.name,
// normal_followers_count: user.normal_followers_count,
// pinned_tweet_ids_str: user.pinned_tweet_ids_str,
// possibly_sensitive: false,
// profile_image_url_https: user.profile_image_url_https,
// profile_interstitial_type: "",
// screen_name: user.screen_name,
// statuses_count: user.statuses_count,
// translator_type: user.translator_type,
// verified: user.verified,
// withheld_in_countries: user.withheld_in_countries,
// },
// profile_image_shape: user.ext_profile_image_shape,
// rest_id: user.id,
// },
// },
// },
// ...tweetData,
// },
// },
// },
// },
data: {
create_tweet: {
tweet_results: {
result: {
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified: user.ext_is_blue_verified,
legacy: {
created_at: user.created_at,
default_profile: user.default_profile,
default_profile_image: user.default_profile_image,
description: user.description,
entities: user.entities,
fast_followers_count: user.fast_followers_count,
favourites_count: user.favourites_count,
followers_count: user.followers_count,
friends_count: user.friends_count,
has_custom_timelines: user.has_custom_timelines,
is_translator: user.is_translator,
listed_count: user.listed_count,
location: user.location,
media_count: user.media_count,
name: user.name,
normal_followers_count: user.normal_followers_count,
pinned_tweet_ids_str: user.pinned_tweet_ids_str,
possibly_sensitive: false,
profile_image_url_https: user.profile_image_url_https,
profile_interstitial_type: "",
screen_name: user.screen_name,
statuses_count: user.statuses_count,
translator_type: user.translator_type,
verified: user.verified,
withheld_in_countries: user.withheld_in_countries,
},
profile_image_shape: user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_control: {
edit_tweet_ids: [tweetId.toString()],
editable_until_msecs: "1682984834000",
edits_remaining: "5",
is_edit_eligible: true,
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, 68],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions: (
tweet.entities!.user_mentions as Array<Array<IUserMention>>
).map((mention) => mention[0]),
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
rest_id: tweetId.toString(),
source:
'<a href="https://github.com/" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Disabled",
},
},
},
},
},
});
}
| src/routes/gql/tweet.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t\t\t\tlegacy: {\n\t\t\t\t\t\tblocked_by: false,\n\t\t\t\t\t\tblocking: false,\n\t\t\t\t\t\tfollowed_by: false,\n\t\t\t\t\t\tfollowing: false,\n\t\t\t\t\t\tname: user.name,\n\t\t\t\t\t\tprotected: false,\n\t\t\t\t\t\tscreen_name: user.screen_name,\n\t\t\t\t\t},\n\t\t\t\t\tprofilemodules: {",
"score": 51.19184756139679
},
{
"filename": "src/models/Tweet.ts",
"retrieved_chunk": "\t\ttype: \"Number\",\n\t},\n\treply_count: {\n\t\ttype: \"Number\",\n\t},\n\tretweet_count: {\n\t\ttype: \"Number\",\n\t},\n\tretweeted: {\n\t\ttype: \"Boolean\",",
"score": 47.94710274645521
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t\t\t\tbusiness_account: {},\n\t\t\t\t\tid: user._id,\n\t\t\t\t\tis_blue_verified: user.ext_is_blue_verified,\n\t\t\t\t\tlegacy: {\n\t\t\t\t\t\tcreated_at: user.created_at,\n\t\t\t\t\t\tdefault_profile: user.default_profile,\n\t\t\t\t\t\tdefault_profile_image: user.default_profile_image,\n\t\t\t\t\t\tdescription: user.description,\n\t\t\t\t\t\tentities: user.entities,\n\t\t\t\t\t\tfast_followers_count: user.fast_followers_count,",
"score": 43.29825544669395
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\tdata: {\n\t\t\tuser: {\n\t\t\t\tresult: {\n\t\t\t\t\t__typename: \"User\",\n\t\t\t\t\taffiliates_highlighted_label: user.ext?.highlightedLabel?.r?.ok,\n\t\t\t\t\tbusiness_account: {},\n\t\t\t\t\tid: user._id,\n\t\t\t\t\tis_blue_verified: user.ext_is_blue_verified,\n\t\t\t\t\tlegacy: {\n\t\t\t\t\t\tcreated_at: user.created_at,",
"score": 42.92954943567584
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "// \t\t\t\t\tprofile_image_shape: \"Circle\",\n// \t\t\t\t\tlegacy: user,\n// \t\t\t\t\tbusiness_account: {},\n// \t\t\t\t},\n// \t\t\t},\n// \t\t},\n// \t});\n// });\nexport async function UserByScreenName(\n\treq: express.Request,",
"score": 39.526308693055356
}
] | typescript | log(`"${tweet.full_text}"`); |
import { CODE_BLOCK_DELIMITER, messageBuilder } from "../../message";
import { MULTILINE_DELIMITER, agentName } from "../../util";
import { defineModule } from "../define-module";
import { getUsageText } from "../util";
export default defineModule({
name: "core",
}).with({
pinnedMessage: async ({ agentId, actionDictionary }) =>
`
You are ${agentName(
agentId
)}, a highly capable autonomous entity who is able to perform actions in order to accomplish tasks. The following points should govern everything you do. Read carefully and never forget them:
1) The entirety of your response should always be an invocation of an action, using the following format:
${CODE_BLOCK_DELIMITER}
<action name>
thoughts: <reasoning behind this action>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
${CODE_BLOCK_DELIMITER}
Example of a correct response:
${CODE_BLOCK_DELIMITER}
writeNote
thoughts: This seems important since it's fundamental to the way I communicate with the system.
title: Always Remember
content: Encode every response as an action!
${CODE_BLOCK_DELIMITER}
Example of an incorrect response:
${CODE_BLOCK_DELIMITER}
Note to self: always encode every response as an action!
${CODE_BLOCK_DELIMITER}
2) These are the actions at your disposal:
${[...actionDictionary.values()]
.map((actionDef) => `\`${actionDef.name}\` - ${actionDef.description}`)
.join("\n")}
To get help on a specific action, use the \`help\` action with the \`aboutAction\` parameter set to the name of the action you want help with. For example:
${CODE_BLOCK_DELIMITER}
help
aboutAction: writeNote
${CODE_BLOCK_DELIMITER}
You may only invoke actions mentioned in the above list.
*NOTE* You never invoke an action until you have first invoked \`help\` on it so that you know what parameters it expects. Being the careful agent that you are, you do not simply guess parameters that you think would make sense.
3) When passing multiple lines of text as an action parameter, you *MUST* use the multi-line delimiter \`${MULTILINE_DELIMITER}\` to enclose the parameter value in its entirety.
Example:
${CODE_BLOCK_DELIMITER}
writeNote
title: Always Remember
content:
${MULTILINE_DELIMITER}
Encode
every
response
as
an
action!
${MULTILINE_DELIMITER}
${CODE_BLOCK_DELIMITER}
Notice that both the start and end delimiters appear on lines by themselves, and they enclose the \`message\` parameter value in its entirety.
4) Every time you receive a message, you must decide on an action to take. If there's nothing you feel like you need to do at the moment, you can use the \`noop\` action.
5) You are not serving a mere advisory role. You are not a chat bot. You are an autonomous entity who invokes actions to accomplish goals.
`.trim(),
actions: {
noop: {
description: "Do nothing",
async execute() {},
},
help: {
description:
"Get help on a specific action and the parameters it expects.",
parameters: {
aboutAction: {
description: "The name of an action to get help on",
},
},
async execute({
parameters: { aboutAction },
context: { agentId, actionDictionary },
sendMessage,
}) {
const actionDef = actionDictionary.get(aboutAction);
if (!actionDef) {
sendMessage(
messageBuilder. | error(
agentId,
`Unknown action \`${aboutAction}\`. Please refer to the list of available actions given in the introductory message.`
)
); |
} else {
sendMessage(messageBuilder.ok(agentId, getUsageText(actionDef)));
}
},
},
},
});
| src/module/definitions/core.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " .join(\",\") +\n \"}\";\n const { name, thoughts, ...parameters } = JSON.parse(jsonText);\n const actionDef = actionDictionary.get(name);\n if (!actionDef)\n return {\n type: \"error\",\n message: `Unknown action \\`${name}\\`. Please refer to the list of available actions given in the introductory message.`,\n };\n const missingProps = Object.entries(actionDef.parameters)",
"score": 54.23448194253838
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": " );\n expect(thoughts).toBe(\n \"Trying a multi-line parameter followed by another parameter.\"\n );\n});\ntest(\"invalid command name\", () => {\n expect(assertInvalid(\"foo\")).toBe(\n \"Unknown action `foo`. Please refer to the list of available actions given in the introductory message.\"\n );\n});",
"score": 39.19719473266043
},
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " agentId,\n `You tried to send your message to an invalid targetAgentId (${JSON.stringify(\n targetAgentId\n )}). You can use the 'queryAgentRegistry' action to see a list of available agents and their agent IDs.`\n )\n );\n }\n },\n },\n },",
"score": 17.3054869924768
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " } ${missingProps.map((p) => `\\`${p}\\``)}. ${getUsageText(actionDef)}`,\n };\n }\n const extraProps = Object.keys(parameters).filter(\n (p) => !(p in actionDef.parameters)\n );\n if (extraProps.length) {\n return {\n type: \"error\",\n message: `Extraneous parameter${",
"score": 15.328305194691193
},
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " async execute({\n parameters: { targetAgentId, message },\n context: { agentId, allAgentIds },\n sendMessage,\n }) {\n if (agentId === targetAgentId) {\n return sendMessage(\n messageBuilder.error(\n agentId,\n \"You can't send a message to yourself. Use the `writeNote` action if you want to make notes for yourself.\"",
"score": 14.715898265790425
}
] | typescript | error(
agentId,
`Unknown action \`${aboutAction}\`. Please refer to the list of available actions given in the introductory message.`
)
); |
import {
readFile,
readdir,
rename,
stat,
unlink,
writeFile,
mkdir,
} from "fs/promises";
import { join as joinPath, resolve as resolvePath } from "path";
import { defineModule } from "../define-module";
import { messageBuilder } from "../../message";
export default defineModule({
name: "filesystem",
}).with({
actions: {
listDirectory: {
description: "Inspect the contents of a particular directory",
parameters: {
path: {
description: "The path of the directory you want to inspect",
},
},
async execute({
parameters: { path },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, path, sendMessage)) return;
try {
const files = await readdir(path);
const filesWithStatsPromises = files.map(async (file) => {
const stats = await stat(joinPath(path, file));
return `${file} ${stats.isDirectory() ? "[directory]" : "[file]"}`;
});
const filesWithStats = await Promise.all(filesWithStatsPromises);
sendMessage(
messageBuilder.ok(
agentId,
`Here are the contents of ${path}:\n${filesWithStats.join("\n")}`
)
);
} catch (err) {
sendMessage | (messageBuilder.error(agentId, JSON.stringify(err))); |
}
},
},
readFile: {
description: "Read the contents of a particular file",
parameters: {
path: {
description: "The path of the file you want to inspect",
},
},
async execute({
parameters: { path },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, path, sendMessage)) return;
try {
const data = await readFile(path, "utf8");
sendMessage(
messageBuilder.ok(agentId, `Contents of ${path}:\n\n${data}`)
);
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
writeFile: {
description: "Write the contents of a particular file",
parameters: {
path: {
description: "The path of the file you want to write to",
},
content: {
description: "The new content of the file",
},
},
async execute({
parameters: { path, content },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, path, sendMessage)) return;
try {
await writeFile(path, content, "utf8");
sendMessage(messageBuilder.ok(agentId, `Wrote to ${path}.`));
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
moveFile: {
description: "Move a file to a new location",
parameters: {
sourcePath: {
description: "The original path of the file",
},
destinationPath: {
description: "The new path for the file",
},
},
async execute({
parameters: { sourcePath, destinationPath },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, sourcePath, sendMessage)) return;
if (!checkPath(agentId, destinationPath, sendMessage)) return;
try {
await rename(sourcePath, destinationPath);
sendMessage(
messageBuilder.ok(
agentId,
`Moved ${sourcePath} to ${destinationPath}.`
)
);
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
deleteFile: {
description: "Delete a file",
parameters: {
path: {
description: "The path of the file to delete",
},
},
async execute({
parameters: { path },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, path, sendMessage)) return;
try {
await unlink(path);
sendMessage(messageBuilder.ok(agentId, `Deleted ${path}.`));
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
createDirectory: {
description: "Create a new directory",
parameters: {
path: {
description: "The path of the directory to create",
},
},
async execute({
parameters: { path },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, path, sendMessage)) return;
try {
await mkdir(path);
sendMessage(messageBuilder.ok(agentId, `Created directory ${path}.`));
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
},
});
function checkPath(
agentId: string,
path: string,
sendMessage: (message: any) => void
) {
const currentDirectory = process.cwd();
const resolvedPath = resolvePath(path);
if (!resolvedPath.startsWith(currentDirectory)) {
sendMessage(
messageBuilder.error(
agentId,
"Invalid path; must be within the current directory."
)
);
return false;
}
if (resolvedPath.includes(".git") || resolvedPath.includes("node_modules")) {
sendMessage(messageBuilder.error(agentId, "That path is off-limits!"));
return false;
}
return true;
}
| src/module/definitions/filesystem.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " sendMessage(\n messageBuilder.ok(\n agentId,\n `These are the agents in the system:\\n\\n${allAgentIds\n .map((id) => `${agentName(id)} [agentId=${id}]`)\n .join(\"\\n\")}`\n )\n );\n },\n },",
"score": 30.50655448115613
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " messageBuilder.ok(agentId, `Content of \"${title}\":\\n\\n${content}`)\n );\n } else {\n sendMessage(\n messageBuilder.error(agentId, `Note \"${title}\" not found.`)\n );\n }\n },\n },\n deleteNote: {",
"score": 28.488151384904832
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " model,\n maxCompletionTokens,\n url\n );\n sendMessage(\n messageBuilder.ok(\n agentId,\n `Here is a summarized markdown version of the page, in a series of summarized chunks:\\n\\n${pageSummary}`\n )\n );",
"score": 27.91075816763993
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " return sendMessage(\n messageBuilder.ok(agentId, \"Search returned no results.\")\n );\n }\n sendMessage(\n messageBuilder.ok(\n agentId,\n `Search results:\\n\\n${items\n .map((item) => `- Title: \"${item.title}\"\\n URL: ${item.link}`)\n .join(\"\\n\\n\")}`",
"score": 27.688090456101868
},
{
"filename": "src/module/definitions/core.ts",
"retrieved_chunk": " if (!actionDef) {\n sendMessage(\n messageBuilder.error(\n agentId,\n `Unknown action \\`${aboutAction}\\`. Please refer to the list of available actions given in the introductory message.`\n )\n );\n } else {\n sendMessage(messageBuilder.ok(agentId, getUsageText(actionDef)));\n }",
"score": 22.796401358488268
}
] | typescript | (messageBuilder.error(agentId, JSON.stringify(err))); |
import Notification from "../models/Notification";
import User from "../models/User";
import { randStr } from "./randUtil";
/**
* Adds a notification to a given user
* @param {string} text The message. `%1` is automatically replaced with the username of the recipient.
* @param {string} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
*/
export async function addNotification(
text: string,
type: "internal",
recipient: string
): Promise<void>;
/**
* Adds a notification to a given user
* @param {string} text The message. `%1` is automatically replaced with the username of the sender.
* @param {string} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
* @param {string} sender The user who added the notification
*/
export async function addNotification(
text: string,
type: "like" | "reply" | "retweet",
recipient: string,
sender: string,
tweet: string
): Promise<void>;
/**
* Adds a notification to a given user
* @param {string=} text The message. `%1` is automatically replaced with the username.
* @param {string=} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
* @param {string=} sender The user who added the notification
*/
export async function addNotification(
text: string,
type: "like" | "reply" | "retweet" | "internal",
recipient: string,
sender?: string,
tweet?: string
) {
| const id = randStr(64); |
if (sender) {
// user-based
const icon = (() => {
if (type === "like") return "heart_icon";
if (type === "reply") return "reply_icon";
if (type === "retweet") return "reweet_icon";
else return "bird_icon";
})();
const recipientUser = await User.findOne({ id_string: recipient });
if (!recipientUser) throw new Error(`Recipient not found`);
const senderUser = await User.findOne({ id_string: sender });
if (!senderUser) throw new Error(`Sender not found`);
const noti = new Notification({
id,
message: {
text: text.replaceAll("%1", senderUser.name!),
rtl: false,
entities: [
{
fromIndex: 0,
toIndex: senderUser.name!.length,
ref: {
user: {
id: sender,
},
},
},
],
},
icon: {
id: icon,
},
timestampMs: Date.now(),
template: {
aggregateUserActionsV1: {
targetObjects: [
{
tweet: {
id: tweet,
},
},
],
fromUsers: [
{
user: {
id: sender,
},
},
],
},
},
});
recipientUser.notification_ids.push(id);
await noti.save();
await recipientUser.save();
return;
} else {
// sent from admin
const recipientUser = await User.findOne({ id_string: recipient });
if (!recipientUser) throw new Error(`Recipient not found`);
recipientUser.notification_ids.push(id);
const noti = new Notification({
id,
message: {
text: text.replaceAll("%1", recipientUser.name!),
rtl: false,
entities: [
{
fromIndex: 0,
toIndex: recipientUser.name!.length,
ref: {
user: {
id: recipient,
},
},
},
],
},
icon: {
id: "bird_icon",
},
timestampMs: Date.now(),
});
await noti.save();
await recipientUser.save();
return;
}
}
| src/util/notifications.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/types/guide.ts",
"retrieved_chunk": "export interface ExtendedEntitiesMedia {\n\tid: number;\n\tid_str: string;\n\tindices: number[];\n\tmedia_url: string;\n\tmedia_url_https: string;\n\turl: string;\n\tdisplay_url: string;\n\texpanded_url: string;\n\ttype: Type | string;",
"score": 35.22240975469991
},
{
"filename": "src/types/guide.ts",
"retrieved_chunk": "export interface EntitiesMedia {\n\tid: number;\n\tid_str: string;\n\tindices: number[];\n\tmedia_url: string;\n\tmedia_url_https: string;\n\turl: string;\n\tdisplay_url: string;\n\texpanded_url: string;\n\ttype: Type | string;",
"score": 35.22240975469991
},
{
"filename": "src/types/task.ts",
"retrieved_chunk": "\tuser_identifier_display_type: string;\n\tusername: string;\n}\nexport interface Footer {\n\tfootnote_text: Text;\n\tstyle: string;\n}\nexport interface Text {\n\tentities: PrimaryTextEntity[];\n\ttext: string;",
"score": 33.936010297749824
},
{
"filename": "src/types/guide.ts",
"retrieved_chunk": "export interface SelfThread {\n\tid: number;\n\tid_str: string;\n}\nexport interface IUser {\n\tid?: number;\n\tid_str?: string;\n\tname: string;\n\tscreen_name: string;\n\tlocation: string;",
"score": 33.161931372666245
},
{
"filename": "src/types/task.ts",
"retrieved_chunk": "}\nexport interface NextLinkClass {\n\tlabel: string;\n\tlink_id: string;\n\tlink_type: string;\n\tsubtask_id?: string;\n}\nexport interface PasswordField {\n\tcontent_type: string;\n\tdetail_text: DetailText;",
"score": 30.56012149063451
}
] | typescript | const id = randStr(64); |
import express from "express";
import { verify } from "jsonwebtoken";
import { requireAuth } from "../../middleware/auth";
import Tweet from "../../models/Tweet";
import User from "../../models/User";
import {
ICreateTweetBody,
IGenericFeatures,
IJwtDecoded,
} from "../../types/graphql";
import { IUser } from "../../types/guide";
import { formatDate } from "../../util/formatDate";
import { log } from "../../util/logging";
import { randInt } from "../../util/randUtil";
import { IUserMention } from "./user";
import { addNotification } from "../../util/notifications";
interface IUserTweetsVariables {
userId: string;
count: number;
includePromotedContent: boolean;
withQuickPromoteEligibilityTweetFields: boolean;
withVoice: boolean;
withV2Timeline: boolean;
}
interface IFavouriteTweetVariables {
tweet_id: string;
}
export async function UserTweets(req: express.Request, res: express.Response) {
const loggedInUser = req.cookies["jwt"]
? await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id,
})
: undefined;
const features = JSON.parse(
req.query.features!.toString()
) as IGenericFeatures;
const variables = JSON.parse(
req.query.variables!.toString()
) as IUserTweetsVariables;
if (!features || !variables)
return res.status(400).send({ msg: "Missing parameters" });
const user = await User.findOne({ id: variables.userId });
if (!user) return res.status(400).send({ msg: "User not found" });
const userTweets = [];
const postedTweets = Array.from(user.posted_tweet_ids);
for (const id of postedTweets) {
const tweet = await Tweet.findOne({ id_str: id });
userTweets.push({
is_translatable: false,
legacy: tweet
? Object.assign(tweet, {
favorited: loggedInUser
? loggedInUser.liked_tweet_ids.includes(tweet.id_str || "")
: false,
})
: tweet,
source: tweet?.source,
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
});
}
return res.status(200).send({
data: {
user: {
result: {
__typename: "User",
timeline_v2: {
timeline: {
instructions: [
{
type: "TimelineClearCache",
},
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified:
user.ext_is_blue_verified,
legacy: {
...(user as any)._doc,
},
profile_image_shape:
user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
},
},
});
}
export async function HomeTimeline(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const userId = req.cookies["jwt"]
? ((verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded)
.id as number)
: undefined;
const loggedInUser = await User.findOne({
id_string: userId,
});
if (!loggedInUser) return res.status(400).send({ msg: "Not authenticated" });
const userTweets = [];
const postedTweets = await Tweet.find().limit(50);
for (const tweet of postedTweets) {
const user = await User.findOne({ id_string: tweet.user_id_str });
if (!user) return res.status(400).send({ msg: "User not found" });
userTweets.push({
is_translatable: false,
legacy: Object.assign(tweet, {
favorited: loggedInUser.liked_tweet_ids.includes(tweet.id_str || ""),
}),
unmention_data: {},
unmention_info: {},
views: tweet.ext_views,
user: user,
});
}
return res.status(200).send({
data: {
home: {
home_timeline_urt: {
instructions: [
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
tweet.user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: tweet.user._id,
is_blue_verified:
tweet.user.ext_is_blue_verified,
legacy: {
...(tweet.user as any)._doc,
entities: {
user_mentions: (
tweet.legacy.entities
?.user_mentions as IUserMention[]
).map((mention) => {
return {
a: true,
};
}),
},
},
profile_image_shape:
tweet.user.ext_profile_image_shape,
rest_id: tweet.user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.legacy.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
});
}
export async function FavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (!user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids.push(variables.tweet_id);
tweet.favorite_count! += 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { favourte_tweet: "NOT DONE" } });
}
if (tweet.user_id_str !== user.id_string)
addNotification(
"%1 liked your tweet!",
"like",
tweet.user_id_str!,
user.id_string!,
tweet.id_str!
);
return res.status(200).send({ data: { favorite_tweet: "Done" } });
}
export async function UnfavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids = user.liked_tweet_ids.filter(
(id) => id !== variables.tweet_id
);
tweet.favorite_count! -= 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { unfavorite_tweet: "NOT DONE" } });
}
return res.status(200).send({ data: { unfavorite_tweet: "Done" } });
}
export async function CreateTweet(req: express.Request, res: express.Response) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const body = req.body as ICreateTweetBody;
const id = (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id as number;
const user = await User.findOne({ id });
if (!user) return res.status(400).send({ msg: "User not found" });
const user_mentions = [] as IUserMention[];
const matches = body.variables.tweet_text.matchAll(/@(\S+)/gm);
for (const match of matches) {
const withTag = match[0];
const withoutTag = match[1];
const user = await User.findOne({ screen_name: withoutTag });
user_mentions.push({
id_str: user?.id_string,
name: user?.name,
screen_name: user?.screen_name,
indices: [match.index, withTag.length + (match.index || 0)],
});
}
| const tweetId = randInt(12); |
const tweetData = {
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions,
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id: tweetId,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
source:
'<a href="https://mobile.twitter.com" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
};
const tweet = new Tweet({
bookmark_count: tweetData.legacy.bookmark_count,
bookmarked: tweetData.legacy.bookmarked,
conversation_id_str: tweetData.legacy.conversation_id_str,
created_at: tweetData.legacy.created_at,
display_text_range: tweetData.legacy.display_text_range,
entities: {
hashtags: tweetData.legacy.entities.hashtags,
symbols: tweetData.legacy.entities.symbols,
urls: tweetData.legacy.entities.urls,
user_mentions,
},
favorite_count: tweetData.legacy.favorite_count,
favorited: tweetData.legacy.favorited,
full_text: tweetData.legacy.full_text,
id_str: tweetData.legacy.id_str,
is_quote_status: tweetData.legacy.is_quote_status,
lang: tweetData.legacy.lang,
quote_count: tweetData.legacy.quote_count,
reply_count: tweetData.legacy.reply_count,
retweet_count: tweetData.legacy.retweet_count,
retweeted: tweetData.legacy.retweeted,
user_id_str: tweetData.legacy.user_id_str,
});
await tweet.save();
user.posted_tweet_ids.push(tweetId.toString());
await user.save();
log(`${user.name} (@${user.screen_name}) just posted a tweet:`);
log(`"${tweet.full_text}"`);
// addNotification(
// "%1 just posted a tweet!",
// "reply",
// user.id_string!,
// user.id_string!,
// tweet.id_str!
// );
return res.status(200).send({
// data: {
// create_tweet: {
// tweet_results: {
// result: {
// core: {
// user_results: {
// result: {
// __typename: "User",
// affiliates_highlighted_label:
// user.ext?.highlightedLabel?.r?.ok,
// business_account: {},
// id: user._id,
// is_blue_verified: user.ext_is_blue_verified,
// legacy: {
// created_at: user.created_at,
// default_profile: user.default_profile,
// default_profile_image: user.default_profile_image,
// description: user.description,
// entities: user.entities,
// fast_followers_count: user.fast_followers_count,
// favourites_count: user.favourites_count,
// followers_count: user.followers_count,
// friends_count: user.friends_count,
// has_custom_timelines: user.has_custom_timelines,
// is_translator: user.is_translator,
// listed_count: user.listed_count,
// location: user.location,
// media_count: user.media_count,
// name: user.name,
// normal_followers_count: user.normal_followers_count,
// pinned_tweet_ids_str: user.pinned_tweet_ids_str,
// possibly_sensitive: false,
// profile_image_url_https: user.profile_image_url_https,
// profile_interstitial_type: "",
// screen_name: user.screen_name,
// statuses_count: user.statuses_count,
// translator_type: user.translator_type,
// verified: user.verified,
// withheld_in_countries: user.withheld_in_countries,
// },
// profile_image_shape: user.ext_profile_image_shape,
// rest_id: user.id,
// },
// },
// },
// ...tweetData,
// },
// },
// },
// },
data: {
create_tweet: {
tweet_results: {
result: {
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified: user.ext_is_blue_verified,
legacy: {
created_at: user.created_at,
default_profile: user.default_profile,
default_profile_image: user.default_profile_image,
description: user.description,
entities: user.entities,
fast_followers_count: user.fast_followers_count,
favourites_count: user.favourites_count,
followers_count: user.followers_count,
friends_count: user.friends_count,
has_custom_timelines: user.has_custom_timelines,
is_translator: user.is_translator,
listed_count: user.listed_count,
location: user.location,
media_count: user.media_count,
name: user.name,
normal_followers_count: user.normal_followers_count,
pinned_tweet_ids_str: user.pinned_tweet_ids_str,
possibly_sensitive: false,
profile_image_url_https: user.profile_image_url_https,
profile_interstitial_type: "",
screen_name: user.screen_name,
statuses_count: user.statuses_count,
translator_type: user.translator_type,
verified: user.verified,
withheld_in_countries: user.withheld_in_countries,
},
profile_image_shape: user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_control: {
edit_tweet_ids: [tweetId.toString()],
editable_until_msecs: "1682984834000",
edits_remaining: "5",
is_edit_eligible: true,
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, 68],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions: (
tweet.entities!.user_mentions as Array<Array<IUserMention>>
).map((mention) => mention[0]),
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
rest_id: tweetId.toString(),
source:
'<a href="https://github.com/" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Disabled",
},
},
},
},
},
});
}
| src/routes/gql/tweet.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t\t\t\t\tlisted_count: user.listed_count,\n\t\t\t\t\t\tlocation: user.location,\n\t\t\t\t\t\tmedia_count: user.media_count,\n\t\t\t\t\t\tname: user.name,\n\t\t\t\t\t\tnormal_followers_count: user.normal_followers_count,\n\t\t\t\t\t\tpinned_tweet_ids_str: user.pinned_tweet_ids_str,\n\t\t\t\t\t\tpossibly_sensitive: false,\n\t\t\t\t\t\tprofile_image_url_https: user.profile_image_url_https,\n\t\t\t\t\t\tprofile_interstitial_type: \"\",\n\t\t\t\t\t\tscreen_name: user.screen_name,",
"score": 51.92992861330167
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t\t\t\tlegacy: {\n\t\t\t\t\t\tblocked_by: false,\n\t\t\t\t\t\tblocking: false,\n\t\t\t\t\t\tfollowed_by: false,\n\t\t\t\t\t\tfollowing: false,\n\t\t\t\t\t\tname: user.name,\n\t\t\t\t\t\tprotected: false,\n\t\t\t\t\t\tscreen_name: user.screen_name,\n\t\t\t\t\t},\n\t\t\t\t\tprofilemodules: {",
"score": 48.791426936459786
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\t\t\tnormal_followers_count: user.normal_followers_count || 0,\n\t\t\t\t\t\tpinned_tweet_ids_str: user.pinned_tweet_ids_str || [],\n\t\t\t\t\t\tpossibly_sensitive: false,\n\t\t\t\t\t\tprofile_image_url_https: user.profile_image_url_https || \"\",\n\t\t\t\t\t\tprofile_interstitial_type: \"\",\n\t\t\t\t\t\tscreen_name: user.screen_name || \"\",\n\t\t\t\t\t\tstatuses_count: user.statuses_count || 0,\n\t\t\t\t\t\ttranslator_type: user.translator_type || \"\",\n\t\t\t\t\t\tverified: user.verified || false,\n\t\t\t\t\t\twant_retweets: user.want_retweets || false,",
"score": 44.68111404397221
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\tconst screenName = variables.screen_name;\n\tif (!screenName || screenName === \"undefined\")\n\t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n\tconst user = await User.findOne({\n\t\tscreen_name: {\n\t\t\t$regex: new RegExp(screenName, \"i\"),\n\t\t},\n\t});\n\tif (!user) return res.status(200).send({ data: {} });\n\treturn res.status(200).send({",
"score": 44.350744968608915
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t\t\t\t\tpinned_tweet_ids_str: user.pinned_tweet_ids_str,\n\t\t\t\t\t\tpossibly_sensitive: false,\n\t\t\t\t\t\tprofile_image_url_https: user.profile_image_url_https,\n\t\t\t\t\t\tprofile_interstitial_type: \"\",\n\t\t\t\t\t\tscreen_name: user.screen_name,\n\t\t\t\t\t\tstatuses_count: user.statuses_count,\n\t\t\t\t\t\ttranslator_type: user.translator_type,\n\t\t\t\t\t\tverified: user.verified,\n\t\t\t\t\t\twithheld_in_countries: user.withheld_in_countries,\n\t\t\t\t\t},",
"score": 42.67098361969711
}
] | typescript | const tweetId = randInt(12); |
import { defineModule } from "../define-module";
import { messageBuilder } from "../../message";
import { Store } from "../../store";
import FileStore from "../../store/file-store";
export default defineModule<Store>({
name: "notes",
createState: ({ agentId }) => new FileStore([agentId, "notes"]),
}).with({
async pinnedMessage({ state }) {
const noteTitles = await state.getKeys();
const currentNotes = noteTitles.length
? `Here are your current notes:\n\n${noteTitles
.map((title) => `- "${title}"`)
.join("\n")}`
: "Your have no notes currently.";
return `
You can manage your notes using the \`writeNote\`, \`viewNote\` and \`deleteNote\` actions. Use notes to keep track of any important information that you come across that may be of longterm interest. Because notes contain content in addition to a title, you can store larger thoughts here which might not fit into the text of a goal. Your notes list will always be pinned to the top of your context and won't be summarized away.
${currentNotes}
`.trim();
},
actions: {
writeNote: {
description: "Create or update a note which will only be visible to you.",
parameters: {
title: {
description: "The title of the note",
},
content: {
description: "The content of the note",
},
},
async execute({
parameters: { title, content },
context: { agentId, state },
sendMessage,
}) {
await state.set(title, content);
sendMessage(
messageBuilder.ok(
agentId,
`Note "${title}" has been written successfully.`
)
);
},
},
viewNote: {
description: "Display the content of a note.",
parameters: {
title: {
description: "The title of the note to view",
},
},
async execute({
parameters: { title },
context: { agentId, state },
sendMessage,
}) {
const content = await state.get(title);
if (content) {
sendMessage(
messageBuilder.ok(agentId, `Content of "${title}":\n\n${content}`)
);
} else {
sendMessage(
| messageBuilder.error(agentId, `Note "${title}" not found.`)
); |
}
},
},
deleteNote: {
description: "Delete a note.",
parameters: {
title: {
description: "The title of the note to delete",
},
},
async execute({
parameters: { title },
context: { agentId, state },
sendMessage,
}) {
if (await state.delete(title)) {
sendMessage(messageBuilder.ok(agentId, `Deleted note "${title}".`));
} else {
sendMessage(
messageBuilder.error(agentId, `Note "${title}" not found.`)
);
}
},
},
},
});
| src/module/definitions/notes.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " return sendMessage(\n messageBuilder.ok(agentId, \"Search returned no results.\")\n );\n }\n sendMessage(\n messageBuilder.ok(\n agentId,\n `Search results:\\n\\n${items\n .map((item) => `- Title: \"${item.title}\"\\n URL: ${item.link}`)\n .join(\"\\n\\n\")}`",
"score": 33.24688111932346
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " try {\n const data = await readFile(path, \"utf8\");\n sendMessage(\n messageBuilder.ok(agentId, `Contents of ${path}:\\n\\n${data}`)\n );\n } catch (err) {\n sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));\n }\n },\n },",
"score": 26.46633113106729
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " async execute({\n parameters: { path, content },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;\n try {\n await writeFile(path, content, \"utf8\");\n sendMessage(messageBuilder.ok(agentId, `Wrote to ${path}.`));\n } catch (err) {",
"score": 26.169546505634774
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " const { name, pinnedMessage } = module.moduleDef;\n if (!pinnedMessage) return [];\n const content = await pinnedMessage(module.context);\n if (!content) return [];\n return [`--- ${name.toUpperCase()} ---\\n\\n${content}`];\n })\n );\n return {\n type: \"message\",\n message: messageBuilder.spontaneous(",
"score": 23.565311658486614
},
{
"filename": "src/module/definitions/goals.ts",
"retrieved_chunk": " context: { agentId, state },\n sendMessage,\n }) {\n const goals = (await state.get(KEY)) || [];\n await state.set(KEY, [...goals, { text: goal, complete: false }]);\n sendMessage(messageBuilder.ok(agentId, \"Goal added.\"));\n },\n },\n completeGoal: {\n description: \"Mark a goal as complete.\",",
"score": 22.803986657617408
}
] | typescript | messageBuilder.error(agentId, `Note "${title}" not found.`)
); |
import express from "express";
import { verify } from "jsonwebtoken";
import { requireAuth } from "../../middleware/auth";
import Tweet from "../../models/Tweet";
import User from "../../models/User";
import {
ICreateTweetBody,
IGenericFeatures,
IJwtDecoded,
} from "../../types/graphql";
import { IUser } from "../../types/guide";
import { formatDate } from "../../util/formatDate";
import { log } from "../../util/logging";
import { randInt } from "../../util/randUtil";
import { IUserMention } from "./user";
import { addNotification } from "../../util/notifications";
interface IUserTweetsVariables {
userId: string;
count: number;
includePromotedContent: boolean;
withQuickPromoteEligibilityTweetFields: boolean;
withVoice: boolean;
withV2Timeline: boolean;
}
interface IFavouriteTweetVariables {
tweet_id: string;
}
export async function UserTweets(req: express.Request, res: express.Response) {
const loggedInUser = req.cookies["jwt"]
? await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id,
})
: undefined;
const features = JSON.parse(
req.query.features!.toString()
) as IGenericFeatures;
const variables = JSON.parse(
req.query.variables!.toString()
) as IUserTweetsVariables;
if (!features || !variables)
return res.status(400).send({ msg: "Missing parameters" });
const user = await User.findOne({ id: variables.userId });
if (!user) return res.status(400).send({ msg: "User not found" });
const userTweets = [];
const postedTweets = Array.from(user.posted_tweet_ids);
for (const id of postedTweets) {
const tweet = await Tweet.findOne({ id_str: id });
userTweets.push({
is_translatable: false,
legacy: tweet
? Object.assign(tweet, {
favorited: loggedInUser
? loggedInUser.liked_tweet_ids.includes(tweet.id_str || "")
: false,
})
: tweet,
source: tweet?.source,
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
});
}
return res.status(200).send({
data: {
user: {
result: {
__typename: "User",
timeline_v2: {
timeline: {
instructions: [
{
type: "TimelineClearCache",
},
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified:
user.ext_is_blue_verified,
legacy: {
...(user as any)._doc,
},
profile_image_shape:
user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
},
},
});
}
export async function HomeTimeline(
req: express.Request,
res: express.Response
) {
const unauthorized | = await requireAuth(req, res); |
if (unauthorized) return;
const userId = req.cookies["jwt"]
? ((verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded)
.id as number)
: undefined;
const loggedInUser = await User.findOne({
id_string: userId,
});
if (!loggedInUser) return res.status(400).send({ msg: "Not authenticated" });
const userTweets = [];
const postedTweets = await Tweet.find().limit(50);
for (const tweet of postedTweets) {
const user = await User.findOne({ id_string: tweet.user_id_str });
if (!user) return res.status(400).send({ msg: "User not found" });
userTweets.push({
is_translatable: false,
legacy: Object.assign(tweet, {
favorited: loggedInUser.liked_tweet_ids.includes(tweet.id_str || ""),
}),
unmention_data: {},
unmention_info: {},
views: tweet.ext_views,
user: user,
});
}
return res.status(200).send({
data: {
home: {
home_timeline_urt: {
instructions: [
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
tweet.user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: tweet.user._id,
is_blue_verified:
tweet.user.ext_is_blue_verified,
legacy: {
...(tweet.user as any)._doc,
entities: {
user_mentions: (
tweet.legacy.entities
?.user_mentions as IUserMention[]
).map((mention) => {
return {
a: true,
};
}),
},
},
profile_image_shape:
tweet.user.ext_profile_image_shape,
rest_id: tweet.user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.legacy.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
});
}
export async function FavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (!user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids.push(variables.tweet_id);
tweet.favorite_count! += 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { favourte_tweet: "NOT DONE" } });
}
if (tweet.user_id_str !== user.id_string)
addNotification(
"%1 liked your tweet!",
"like",
tweet.user_id_str!,
user.id_string!,
tweet.id_str!
);
return res.status(200).send({ data: { favorite_tweet: "Done" } });
}
export async function UnfavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids = user.liked_tweet_ids.filter(
(id) => id !== variables.tweet_id
);
tweet.favorite_count! -= 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { unfavorite_tweet: "NOT DONE" } });
}
return res.status(200).send({ data: { unfavorite_tweet: "Done" } });
}
export async function CreateTweet(req: express.Request, res: express.Response) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const body = req.body as ICreateTweetBody;
const id = (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id as number;
const user = await User.findOne({ id });
if (!user) return res.status(400).send({ msg: "User not found" });
const user_mentions = [] as IUserMention[];
const matches = body.variables.tweet_text.matchAll(/@(\S+)/gm);
for (const match of matches) {
const withTag = match[0];
const withoutTag = match[1];
const user = await User.findOne({ screen_name: withoutTag });
user_mentions.push({
id_str: user?.id_string,
name: user?.name,
screen_name: user?.screen_name,
indices: [match.index, withTag.length + (match.index || 0)],
});
}
const tweetId = randInt(12);
const tweetData = {
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions,
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id: tweetId,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
source:
'<a href="https://mobile.twitter.com" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
};
const tweet = new Tweet({
bookmark_count: tweetData.legacy.bookmark_count,
bookmarked: tweetData.legacy.bookmarked,
conversation_id_str: tweetData.legacy.conversation_id_str,
created_at: tweetData.legacy.created_at,
display_text_range: tweetData.legacy.display_text_range,
entities: {
hashtags: tweetData.legacy.entities.hashtags,
symbols: tweetData.legacy.entities.symbols,
urls: tweetData.legacy.entities.urls,
user_mentions,
},
favorite_count: tweetData.legacy.favorite_count,
favorited: tweetData.legacy.favorited,
full_text: tweetData.legacy.full_text,
id_str: tweetData.legacy.id_str,
is_quote_status: tweetData.legacy.is_quote_status,
lang: tweetData.legacy.lang,
quote_count: tweetData.legacy.quote_count,
reply_count: tweetData.legacy.reply_count,
retweet_count: tweetData.legacy.retweet_count,
retweeted: tweetData.legacy.retweeted,
user_id_str: tweetData.legacy.user_id_str,
});
await tweet.save();
user.posted_tweet_ids.push(tweetId.toString());
await user.save();
log(`${user.name} (@${user.screen_name}) just posted a tweet:`);
log(`"${tweet.full_text}"`);
// addNotification(
// "%1 just posted a tweet!",
// "reply",
// user.id_string!,
// user.id_string!,
// tweet.id_str!
// );
return res.status(200).send({
// data: {
// create_tweet: {
// tweet_results: {
// result: {
// core: {
// user_results: {
// result: {
// __typename: "User",
// affiliates_highlighted_label:
// user.ext?.highlightedLabel?.r?.ok,
// business_account: {},
// id: user._id,
// is_blue_verified: user.ext_is_blue_verified,
// legacy: {
// created_at: user.created_at,
// default_profile: user.default_profile,
// default_profile_image: user.default_profile_image,
// description: user.description,
// entities: user.entities,
// fast_followers_count: user.fast_followers_count,
// favourites_count: user.favourites_count,
// followers_count: user.followers_count,
// friends_count: user.friends_count,
// has_custom_timelines: user.has_custom_timelines,
// is_translator: user.is_translator,
// listed_count: user.listed_count,
// location: user.location,
// media_count: user.media_count,
// name: user.name,
// normal_followers_count: user.normal_followers_count,
// pinned_tweet_ids_str: user.pinned_tweet_ids_str,
// possibly_sensitive: false,
// profile_image_url_https: user.profile_image_url_https,
// profile_interstitial_type: "",
// screen_name: user.screen_name,
// statuses_count: user.statuses_count,
// translator_type: user.translator_type,
// verified: user.verified,
// withheld_in_countries: user.withheld_in_countries,
// },
// profile_image_shape: user.ext_profile_image_shape,
// rest_id: user.id,
// },
// },
// },
// ...tweetData,
// },
// },
// },
// },
data: {
create_tweet: {
tweet_results: {
result: {
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified: user.ext_is_blue_verified,
legacy: {
created_at: user.created_at,
default_profile: user.default_profile,
default_profile_image: user.default_profile_image,
description: user.description,
entities: user.entities,
fast_followers_count: user.fast_followers_count,
favourites_count: user.favourites_count,
followers_count: user.followers_count,
friends_count: user.friends_count,
has_custom_timelines: user.has_custom_timelines,
is_translator: user.is_translator,
listed_count: user.listed_count,
location: user.location,
media_count: user.media_count,
name: user.name,
normal_followers_count: user.normal_followers_count,
pinned_tweet_ids_str: user.pinned_tweet_ids_str,
possibly_sensitive: false,
profile_image_url_https: user.profile_image_url_https,
profile_interstitial_type: "",
screen_name: user.screen_name,
statuses_count: user.statuses_count,
translator_type: user.translator_type,
verified: user.verified,
withheld_in_countries: user.withheld_in_countries,
},
profile_image_shape: user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_control: {
edit_tweet_ids: [tweetId.toString()],
editable_until_msecs: "1682984834000",
edits_remaining: "5",
is_edit_eligible: true,
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, 68],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions: (
tweet.entities!.user_mentions as Array<Array<IUserMention>>
).map((mention) => mention[0]),
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
rest_id: tweetId.toString(),
source:
'<a href="https://github.com/" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Disabled",
},
},
},
},
},
});
}
| src/routes/gql/tweet.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t},\n\t});\n}\nexport async function UserByRestId(\n\treq: express.Request,\n\tres: express.Response\n) {\n\tconst features = JSON.parse(\n\t\treq.query.features!.toString()\n\t) as IGenericFeatures;",
"score": 50.19191803254002
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t\t\t\tprofile_image_shape: user.ext_profile_image_shape,\n\t\t\t\t\trest_id: user.id,\n\t\t\t\t},\n\t\t\t},\n\t\t},\n\t});\n}\nexport async function ProfileSpotlightsQuery(\n\treq: express.Request,\n\tres: express.Response",
"score": 48.480953980231824
},
{
"filename": "src/routes/gql/blue.ts",
"retrieved_chunk": "import express from \"express\";\nexport function TwitterBlueSignUpV2Query(\n\treq: express.Request,\n\tres: express.Response\n) {\n\treturn res.status(200).send({\n\t\tdata: {\n\t\t\tblue_marketing_page_config: {\n\t\t\t\tproducts: [\n\t\t\t\t\t{",
"score": 45.29293286426898
},
{
"filename": "src/routes/gql/dm.ts",
"retrieved_chunk": "import express from \"express\";\nexport function DMPinnedInboxQuery(\n\treq: express.Request,\n\tres: express.Response\n) {\n\treturn res.status(200).send({\n\t\tdata: { labeled_conversation_slice: { items: [], slice_info: {} } },\n\t});\n}",
"score": 44.49757268290998
},
{
"filename": "src/routes/gql/viewer.ts",
"retrieved_chunk": "import express from \"express\";\nimport User from \"../../models/User\";\nexport async function Viewer(req: express.Request, res: express.Response) {\n\t// if (!req.cookies.twt_id)\n\t// \treturn res.status(400).send({ msg: \"No twid detected\" });\n\tconst id = (req.cookies.twt_id as string | undefined)?.split(\"=\")[1] as\n\t\t| string\n\t\t| undefined;\n\tif (!id || id === \"undefined\")\n\t\treturn res.status(200).send({",
"score": 38.38473435781704
}
] | typescript | = await requireAuth(req, res); |
import { defineModule } from "../define-module";
import { messageBuilder } from "../../message";
import { Store } from "../../store";
import FileStore from "../../store/file-store";
export default defineModule<Store>({
name: "notes",
createState: ({ agentId }) => new FileStore([agentId, "notes"]),
}).with({
async pinnedMessage({ state }) {
const noteTitles = await state.getKeys();
const currentNotes = noteTitles.length
? `Here are your current notes:\n\n${noteTitles
.map((title) => `- "${title}"`)
.join("\n")}`
: "Your have no notes currently.";
return `
You can manage your notes using the \`writeNote\`, \`viewNote\` and \`deleteNote\` actions. Use notes to keep track of any important information that you come across that may be of longterm interest. Because notes contain content in addition to a title, you can store larger thoughts here which might not fit into the text of a goal. Your notes list will always be pinned to the top of your context and won't be summarized away.
${currentNotes}
`.trim();
},
actions: {
writeNote: {
description: "Create or update a note which will only be visible to you.",
parameters: {
title: {
description: "The title of the note",
},
content: {
description: "The content of the note",
},
},
async execute({
parameters: { title, content },
context: { agentId, state },
sendMessage,
}) {
await state.set(title, content);
sendMessage(
messageBuilder. | ok(
agentId,
`Note "${title}" has been written successfully.`
)
); |
},
},
viewNote: {
description: "Display the content of a note.",
parameters: {
title: {
description: "The title of the note to view",
},
},
async execute({
parameters: { title },
context: { agentId, state },
sendMessage,
}) {
const content = await state.get(title);
if (content) {
sendMessage(
messageBuilder.ok(agentId, `Content of "${title}":\n\n${content}`)
);
} else {
sendMessage(
messageBuilder.error(agentId, `Note "${title}" not found.`)
);
}
},
},
deleteNote: {
description: "Delete a note.",
parameters: {
title: {
description: "The title of the note to delete",
},
},
async execute({
parameters: { title },
context: { agentId, state },
sendMessage,
}) {
if (await state.delete(title)) {
sendMessage(messageBuilder.ok(agentId, `Deleted note "${title}".`));
} else {
sendMessage(
messageBuilder.error(agentId, `Note "${title}" not found.`)
);
}
},
},
},
});
| src/module/definitions/notes.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/goals.ts",
"retrieved_chunk": " context: { agentId, state },\n sendMessage,\n }) {\n const goals = (await state.get(KEY)) || [];\n await state.set(KEY, [...goals, { text: goal, complete: false }]);\n sendMessage(messageBuilder.ok(agentId, \"Goal added.\"));\n },\n },\n completeGoal: {\n description: \"Mark a goal as complete.\",",
"score": 19.52126870357005
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " return sendMessage(\n messageBuilder.ok(agentId, \"Search returned no results.\")\n );\n }\n sendMessage(\n messageBuilder.ok(\n agentId,\n `Search results:\\n\\n${items\n .map((item) => `- Title: \"${item.title}\"\\n URL: ${item.link}`)\n .join(\"\\n\\n\")}`",
"score": 18.257416579130453
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " async execute({\n parameters: { path, content },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;\n try {\n await writeFile(path, content, \"utf8\");\n sendMessage(messageBuilder.ok(agentId, `Wrote to ${path}.`));\n } catch (err) {",
"score": 15.163096560845755
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " },\n async execute({\n parameters: { path },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;\n try {\n await unlink(path);\n sendMessage(messageBuilder.ok(agentId, `Deleted ${path}.`));",
"score": 12.880597541110564
},
{
"filename": "src/module/definitions/goals.ts",
"retrieved_chunk": " const idx = parseInt(goalNumber) - 1;\n const goals = (await state.get(KEY)) || [];\n if (isNaN(idx) || idx < 0 || idx >= goals.length)\n return sendMessage(\n messageBuilder.error(agentId, `Invalid goal index: ${goalNumber}`)\n );\n await state.set(KEY, [\n ...goals.slice(0, idx),\n { ...goals[idx], complete: true },\n ...goals.slice(idx + 1),",
"score": 12.765410904802792
}
] | typescript | ok(
agentId,
`Note "${title}" has been written successfully.`
)
); |
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/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": 46.84873779053458
},
{
"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": 43.85761774536018
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),\n score: 0,\n }\n playersTable._db.set(mockPlayer.id, mockPlayer);\n /**\n * This calls into /coop/create which is a complex API.\n * Step thru this to learn about how the route handlers work.\n */\n console.log('Creating game...');\n await handleRequest({",
"score": 37.08540935278374
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 35.58346848402079
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n const engine = new _Engine(gameData);\n try {\n if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);\n await func(engine);\n await ds.GameData.update.exec(gameData);\n } catch (e: any) {\n e.broadcast = engine.broadcast;\n throw e;\n }",
"score": 32.95085747258735
}
] | typescript | : IHttpRequest) { |
import express from "express";
import { verify } from "jsonwebtoken";
import { requireAuth } from "../../middleware/auth";
import Tweet from "../../models/Tweet";
import User from "../../models/User";
import {
ICreateTweetBody,
IGenericFeatures,
IJwtDecoded,
} from "../../types/graphql";
import { IUser } from "../../types/guide";
import { formatDate } from "../../util/formatDate";
import { log } from "../../util/logging";
import { randInt } from "../../util/randUtil";
import { IUserMention } from "./user";
import { addNotification } from "../../util/notifications";
interface IUserTweetsVariables {
userId: string;
count: number;
includePromotedContent: boolean;
withQuickPromoteEligibilityTweetFields: boolean;
withVoice: boolean;
withV2Timeline: boolean;
}
interface IFavouriteTweetVariables {
tweet_id: string;
}
export async function UserTweets(req: express.Request, res: express.Response) {
const loggedInUser = req.cookies["jwt"]
? await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id,
})
: undefined;
const features = JSON.parse(
req.query.features!.toString()
) as IGenericFeatures;
const variables = JSON.parse(
req.query.variables!.toString()
) as IUserTweetsVariables;
if (!features || !variables)
return res.status(400).send({ msg: "Missing parameters" });
const user = await User.findOne({ id: variables.userId });
if (!user) return res.status(400).send({ msg: "User not found" });
const userTweets = [];
const postedTweets = Array.from(user.posted_tweet_ids);
for (const id of postedTweets) {
const tweet = await Tweet.findOne({ id_str: id });
userTweets.push({
is_translatable: false,
legacy: tweet
? Object.assign(tweet, {
favorited: loggedInUser
? loggedInUser.liked_tweet_ids.includes(tweet.id_str || "")
: false,
})
: tweet,
source: tweet?.source,
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
});
}
return res.status(200).send({
data: {
user: {
result: {
__typename: "User",
timeline_v2: {
timeline: {
instructions: [
{
type: "TimelineClearCache",
},
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified:
user.ext_is_blue_verified,
legacy: {
...(user as any)._doc,
},
profile_image_shape:
user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
},
},
});
}
export async function HomeTimeline(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const userId = req.cookies["jwt"]
? ((verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded)
.id as number)
: undefined;
const loggedInUser = await User.findOne({
id_string: userId,
});
if (!loggedInUser) return res.status(400).send({ msg: "Not authenticated" });
const userTweets = [];
const postedTweets = await Tweet.find().limit(50);
for (const tweet of postedTweets) {
const user = await User.findOne({ id_string: tweet.user_id_str });
if (!user) return res.status(400).send({ msg: "User not found" });
userTweets.push({
is_translatable: false,
legacy: Object.assign(tweet, {
favorited: loggedInUser.liked_tweet_ids.includes(tweet.id_str || ""),
}),
unmention_data: {},
unmention_info: {},
views: tweet.ext_views,
user: user,
});
}
return res.status(200).send({
data: {
home: {
home_timeline_urt: {
instructions: [
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
tweet.user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: tweet.user._id,
is_blue_verified:
tweet.user.ext_is_blue_verified,
legacy: {
...(tweet.user as any)._doc,
entities: {
user_mentions: (
tweet.legacy.entities
?.user_mentions as IUserMention[]
).map((mention) => {
return {
a: true,
};
}),
},
},
profile_image_shape:
tweet.user.ext_profile_image_shape,
rest_id: tweet.user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.legacy.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
});
}
export async function FavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (!user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids.push(variables.tweet_id);
tweet.favorite_count! += 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { favourte_tweet: "NOT DONE" } });
}
if (tweet.user_id_str !== user.id_string)
addNotification(
"%1 liked your tweet!",
"like",
tweet.user_id_str!,
user.id_string!,
tweet.id_str!
);
return res.status(200).send({ data: { favorite_tweet: "Done" } });
}
export async function UnfavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids = user.liked_tweet_ids.filter(
| (id) => id !== variables.tweet_id
); |
tweet.favorite_count! -= 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { unfavorite_tweet: "NOT DONE" } });
}
return res.status(200).send({ data: { unfavorite_tweet: "Done" } });
}
export async function CreateTweet(req: express.Request, res: express.Response) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const body = req.body as ICreateTweetBody;
const id = (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id as number;
const user = await User.findOne({ id });
if (!user) return res.status(400).send({ msg: "User not found" });
const user_mentions = [] as IUserMention[];
const matches = body.variables.tweet_text.matchAll(/@(\S+)/gm);
for (const match of matches) {
const withTag = match[0];
const withoutTag = match[1];
const user = await User.findOne({ screen_name: withoutTag });
user_mentions.push({
id_str: user?.id_string,
name: user?.name,
screen_name: user?.screen_name,
indices: [match.index, withTag.length + (match.index || 0)],
});
}
const tweetId = randInt(12);
const tweetData = {
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions,
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id: tweetId,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
source:
'<a href="https://mobile.twitter.com" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
};
const tweet = new Tweet({
bookmark_count: tweetData.legacy.bookmark_count,
bookmarked: tweetData.legacy.bookmarked,
conversation_id_str: tweetData.legacy.conversation_id_str,
created_at: tweetData.legacy.created_at,
display_text_range: tweetData.legacy.display_text_range,
entities: {
hashtags: tweetData.legacy.entities.hashtags,
symbols: tweetData.legacy.entities.symbols,
urls: tweetData.legacy.entities.urls,
user_mentions,
},
favorite_count: tweetData.legacy.favorite_count,
favorited: tweetData.legacy.favorited,
full_text: tweetData.legacy.full_text,
id_str: tweetData.legacy.id_str,
is_quote_status: tweetData.legacy.is_quote_status,
lang: tweetData.legacy.lang,
quote_count: tweetData.legacy.quote_count,
reply_count: tweetData.legacy.reply_count,
retweet_count: tweetData.legacy.retweet_count,
retweeted: tweetData.legacy.retweeted,
user_id_str: tweetData.legacy.user_id_str,
});
await tweet.save();
user.posted_tweet_ids.push(tweetId.toString());
await user.save();
log(`${user.name} (@${user.screen_name}) just posted a tweet:`);
log(`"${tweet.full_text}"`);
// addNotification(
// "%1 just posted a tweet!",
// "reply",
// user.id_string!,
// user.id_string!,
// tweet.id_str!
// );
return res.status(200).send({
// data: {
// create_tweet: {
// tweet_results: {
// result: {
// core: {
// user_results: {
// result: {
// __typename: "User",
// affiliates_highlighted_label:
// user.ext?.highlightedLabel?.r?.ok,
// business_account: {},
// id: user._id,
// is_blue_verified: user.ext_is_blue_verified,
// legacy: {
// created_at: user.created_at,
// default_profile: user.default_profile,
// default_profile_image: user.default_profile_image,
// description: user.description,
// entities: user.entities,
// fast_followers_count: user.fast_followers_count,
// favourites_count: user.favourites_count,
// followers_count: user.followers_count,
// friends_count: user.friends_count,
// has_custom_timelines: user.has_custom_timelines,
// is_translator: user.is_translator,
// listed_count: user.listed_count,
// location: user.location,
// media_count: user.media_count,
// name: user.name,
// normal_followers_count: user.normal_followers_count,
// pinned_tweet_ids_str: user.pinned_tweet_ids_str,
// possibly_sensitive: false,
// profile_image_url_https: user.profile_image_url_https,
// profile_interstitial_type: "",
// screen_name: user.screen_name,
// statuses_count: user.statuses_count,
// translator_type: user.translator_type,
// verified: user.verified,
// withheld_in_countries: user.withheld_in_countries,
// },
// profile_image_shape: user.ext_profile_image_shape,
// rest_id: user.id,
// },
// },
// },
// ...tweetData,
// },
// },
// },
// },
data: {
create_tweet: {
tweet_results: {
result: {
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified: user.ext_is_blue_verified,
legacy: {
created_at: user.created_at,
default_profile: user.default_profile,
default_profile_image: user.default_profile_image,
description: user.description,
entities: user.entities,
fast_followers_count: user.fast_followers_count,
favourites_count: user.favourites_count,
followers_count: user.followers_count,
friends_count: user.friends_count,
has_custom_timelines: user.has_custom_timelines,
is_translator: user.is_translator,
listed_count: user.listed_count,
location: user.location,
media_count: user.media_count,
name: user.name,
normal_followers_count: user.normal_followers_count,
pinned_tweet_ids_str: user.pinned_tweet_ids_str,
possibly_sensitive: false,
profile_image_url_https: user.profile_image_url_https,
profile_interstitial_type: "",
screen_name: user.screen_name,
statuses_count: user.statuses_count,
translator_type: user.translator_type,
verified: user.verified,
withheld_in_countries: user.withheld_in_countries,
},
profile_image_shape: user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_control: {
edit_tweet_ids: [tweetId.toString()],
editable_until_msecs: "1682984834000",
edits_remaining: "5",
is_edit_eligible: true,
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, 68],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions: (
tweet.entities!.user_mentions as Array<Array<IUserMention>>
).map((mention) => mention[0]),
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
rest_id: tweetId.toString(),
source:
'<a href="https://github.com/" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Disabled",
},
},
},
},
},
});
}
| src/routes/gql/tweet.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": ") {\n\tconst variables = JSON.parse(\n\t\treq.query.variables!.toString()\n\t) as IProfileSpotlightsQueryVariables;\n\tif (!variables) return res.status(400).send({ msg: \"Missing parameters\" });\n\tconst screenName = variables.screen_name;\n\tif (!screenName || screenName === \"undefined\")\n\t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n\tconst user = await User.findOne({\n\t\tscreen_name: screenName,",
"score": 121.72294955473426
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\tconst variables = JSON.parse(\n\t\treq.query.variables!.toString()\n\t) as IUserByRestIdVariables;\n\tif (!features || !variables)\n\t\treturn res.status(400).send({ msg: \"Missing parameters\" });\n\tconst id_string = variables.userId;\n\tif (!id_string || id_string === \"undefined\")\n\t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n\tconst user = await User.findOne({\n\t\tid_string: {",
"score": 121.72294955473426
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "// \t\treturn res.status(400).send({ msg: \"Missing parameters\" });\n// \tconst id_string = variables.userId;\n// \tif (!id_string || id_string === \"undefined\")\n// \t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n// \tconst user = await User.findOne({\n// \t\tid_string,\n// \t});\n// \tif (!user) return res.status(200).send({ data: {} });\n// \treturn res.status(200).send({\n// \t\tdata: {",
"score": 108.29500273144312
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t});\n\tif (!user) return res.status(400).send({ msg: \"User not found\" });\n\t// if (user.id !== jwtParams.id)\n\t// \treturn res.status(401).send({ msg: \"Unauthorized\" });\n\treturn res.status(200).send({\n\t\tdata: {\n\t\t\tuser_result_by_screen_name: {\n\t\t\t\tresult: {\n\t\t\t\t\t__typename: \"User\",\n\t\t\t\t\tid: user._id,",
"score": 107.52108581100032
},
{
"filename": "src/routes/gql/viewer.ts",
"retrieved_chunk": "\tconst user = await User.findOne({\n\t\tid,\n\t});\n\tif (!user) return res.status(400).send({ msg: \"User not found\" });\n\treturn res.status(200).send({\n\t\tdata: {\n\t\t\tis_super_follow_subscriber: false,\n\t\t\tviewer: {\n\t\t\t\tcreate_community_action_result: {\n\t\t\t\t\t__typename: \"CommunityCreateActionUnavailable\",",
"score": 104.01828501841045
}
] | typescript | (id) => id !== variables.tweet_id
); |
import express from "express";
import { verify } from "jsonwebtoken";
import { requireAuth } from "../../middleware/auth";
import Tweet from "../../models/Tweet";
import User from "../../models/User";
import {
ICreateTweetBody,
IGenericFeatures,
IJwtDecoded,
} from "../../types/graphql";
import { IUser } from "../../types/guide";
import { formatDate } from "../../util/formatDate";
import { log } from "../../util/logging";
import { randInt } from "../../util/randUtil";
import { IUserMention } from "./user";
import { addNotification } from "../../util/notifications";
interface IUserTweetsVariables {
userId: string;
count: number;
includePromotedContent: boolean;
withQuickPromoteEligibilityTweetFields: boolean;
withVoice: boolean;
withV2Timeline: boolean;
}
interface IFavouriteTweetVariables {
tweet_id: string;
}
export async function UserTweets(req: express.Request, res: express.Response) {
const loggedInUser = req.cookies["jwt"]
? await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id,
})
: undefined;
const features = JSON.parse(
req.query.features!.toString()
) as IGenericFeatures;
const variables = JSON.parse(
req.query.variables!.toString()
) as IUserTweetsVariables;
if (!features || !variables)
return res.status(400).send({ msg: "Missing parameters" });
const user = await User.findOne({ id: variables.userId });
if (!user) return res.status(400).send({ msg: "User not found" });
const userTweets = [];
const postedTweets = Array.from(user.posted_tweet_ids);
for (const id of postedTweets) {
const tweet = await Tweet.findOne({ id_str: id });
userTweets.push({
is_translatable: false,
legacy: tweet
? Object.assign(tweet, {
favorited: loggedInUser
? loggedInUser.liked_tweet_ids.includes(tweet.id_str || "")
: false,
})
: tweet,
source: tweet?.source,
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
});
}
return res.status(200).send({
data: {
user: {
result: {
__typename: "User",
timeline_v2: {
timeline: {
instructions: [
{
type: "TimelineClearCache",
},
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified:
user.ext_is_blue_verified,
legacy: {
...(user as any)._doc,
},
profile_image_shape:
user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
},
},
});
}
export async function HomeTimeline(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const userId = req.cookies["jwt"]
? ((verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded)
.id as number)
: undefined;
const loggedInUser = await User.findOne({
id_string: userId,
});
if (!loggedInUser) return res.status(400).send({ msg: "Not authenticated" });
const userTweets = [];
const postedTweets = await Tweet.find().limit(50);
for (const tweet of postedTweets) {
const user = await User.findOne({ id_string: tweet.user_id_str });
if (!user) return res.status(400).send({ msg: "User not found" });
userTweets.push({
is_translatable: false,
legacy: Object.assign(tweet, {
favorited: loggedInUser.liked_tweet_ids.includes(tweet.id_str || ""),
}),
unmention_data: {},
unmention_info: {},
views: tweet.ext_views,
user: user,
});
}
return res.status(200).send({
data: {
home: {
home_timeline_urt: {
instructions: [
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
tweet.user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: tweet.user._id,
is_blue_verified:
tweet.user.ext_is_blue_verified,
legacy: {
...(tweet.user as any)._doc,
entities: {
user_mentions: (
tweet.legacy.entities
?. | user_mentions as IUserMention[]
).map((mention) => { |
return {
a: true,
};
}),
},
},
profile_image_shape:
tweet.user.ext_profile_image_shape,
rest_id: tweet.user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.legacy.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
});
}
export async function FavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (!user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids.push(variables.tweet_id);
tweet.favorite_count! += 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { favourte_tweet: "NOT DONE" } });
}
if (tweet.user_id_str !== user.id_string)
addNotification(
"%1 liked your tweet!",
"like",
tweet.user_id_str!,
user.id_string!,
tweet.id_str!
);
return res.status(200).send({ data: { favorite_tweet: "Done" } });
}
export async function UnfavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids = user.liked_tweet_ids.filter(
(id) => id !== variables.tweet_id
);
tweet.favorite_count! -= 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { unfavorite_tweet: "NOT DONE" } });
}
return res.status(200).send({ data: { unfavorite_tweet: "Done" } });
}
export async function CreateTweet(req: express.Request, res: express.Response) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const body = req.body as ICreateTweetBody;
const id = (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id as number;
const user = await User.findOne({ id });
if (!user) return res.status(400).send({ msg: "User not found" });
const user_mentions = [] as IUserMention[];
const matches = body.variables.tweet_text.matchAll(/@(\S+)/gm);
for (const match of matches) {
const withTag = match[0];
const withoutTag = match[1];
const user = await User.findOne({ screen_name: withoutTag });
user_mentions.push({
id_str: user?.id_string,
name: user?.name,
screen_name: user?.screen_name,
indices: [match.index, withTag.length + (match.index || 0)],
});
}
const tweetId = randInt(12);
const tweetData = {
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions,
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id: tweetId,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
source:
'<a href="https://mobile.twitter.com" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
};
const tweet = new Tweet({
bookmark_count: tweetData.legacy.bookmark_count,
bookmarked: tweetData.legacy.bookmarked,
conversation_id_str: tweetData.legacy.conversation_id_str,
created_at: tweetData.legacy.created_at,
display_text_range: tweetData.legacy.display_text_range,
entities: {
hashtags: tweetData.legacy.entities.hashtags,
symbols: tweetData.legacy.entities.symbols,
urls: tweetData.legacy.entities.urls,
user_mentions,
},
favorite_count: tweetData.legacy.favorite_count,
favorited: tweetData.legacy.favorited,
full_text: tweetData.legacy.full_text,
id_str: tweetData.legacy.id_str,
is_quote_status: tweetData.legacy.is_quote_status,
lang: tweetData.legacy.lang,
quote_count: tweetData.legacy.quote_count,
reply_count: tweetData.legacy.reply_count,
retweet_count: tweetData.legacy.retweet_count,
retweeted: tweetData.legacy.retweeted,
user_id_str: tweetData.legacy.user_id_str,
});
await tweet.save();
user.posted_tweet_ids.push(tweetId.toString());
await user.save();
log(`${user.name} (@${user.screen_name}) just posted a tweet:`);
log(`"${tweet.full_text}"`);
// addNotification(
// "%1 just posted a tweet!",
// "reply",
// user.id_string!,
// user.id_string!,
// tweet.id_str!
// );
return res.status(200).send({
// data: {
// create_tweet: {
// tweet_results: {
// result: {
// core: {
// user_results: {
// result: {
// __typename: "User",
// affiliates_highlighted_label:
// user.ext?.highlightedLabel?.r?.ok,
// business_account: {},
// id: user._id,
// is_blue_verified: user.ext_is_blue_verified,
// legacy: {
// created_at: user.created_at,
// default_profile: user.default_profile,
// default_profile_image: user.default_profile_image,
// description: user.description,
// entities: user.entities,
// fast_followers_count: user.fast_followers_count,
// favourites_count: user.favourites_count,
// followers_count: user.followers_count,
// friends_count: user.friends_count,
// has_custom_timelines: user.has_custom_timelines,
// is_translator: user.is_translator,
// listed_count: user.listed_count,
// location: user.location,
// media_count: user.media_count,
// name: user.name,
// normal_followers_count: user.normal_followers_count,
// pinned_tweet_ids_str: user.pinned_tweet_ids_str,
// possibly_sensitive: false,
// profile_image_url_https: user.profile_image_url_https,
// profile_interstitial_type: "",
// screen_name: user.screen_name,
// statuses_count: user.statuses_count,
// translator_type: user.translator_type,
// verified: user.verified,
// withheld_in_countries: user.withheld_in_countries,
// },
// profile_image_shape: user.ext_profile_image_shape,
// rest_id: user.id,
// },
// },
// },
// ...tweetData,
// },
// },
// },
// },
data: {
create_tweet: {
tweet_results: {
result: {
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified: user.ext_is_blue_verified,
legacy: {
created_at: user.created_at,
default_profile: user.default_profile,
default_profile_image: user.default_profile_image,
description: user.description,
entities: user.entities,
fast_followers_count: user.fast_followers_count,
favourites_count: user.favourites_count,
followers_count: user.followers_count,
friends_count: user.friends_count,
has_custom_timelines: user.has_custom_timelines,
is_translator: user.is_translator,
listed_count: user.listed_count,
location: user.location,
media_count: user.media_count,
name: user.name,
normal_followers_count: user.normal_followers_count,
pinned_tweet_ids_str: user.pinned_tweet_ids_str,
possibly_sensitive: false,
profile_image_url_https: user.profile_image_url_https,
profile_interstitial_type: "",
screen_name: user.screen_name,
statuses_count: user.statuses_count,
translator_type: user.translator_type,
verified: user.verified,
withheld_in_countries: user.withheld_in_countries,
},
profile_image_shape: user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_control: {
edit_tweet_ids: [tweetId.toString()],
editable_until_msecs: "1682984834000",
edits_remaining: "5",
is_edit_eligible: true,
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, 68],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions: (
tweet.entities!.user_mentions as Array<Array<IUserMention>>
).map((mention) => mention[0]),
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
rest_id: tweetId.toString(),
source:
'<a href="https://github.com/" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Disabled",
},
},
},
},
},
});
}
| src/routes/gql/tweet.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/routes/gql/viewer.ts",
"retrieved_chunk": "\t\t\t\t\t\t// \twithheld_in_countries: [],\n\t\t\t\t\t\t// },\n\t\t\t\t\t\tlegacy: {\n\t\t\t\t\t\t\t...(user as any)._doc,\n\t\t\t\t\t\t},\n\t\t\t\t\t\tlegacy_extended_profile: {\n\t\t\t\t\t\t\tbirthdate: {\n\t\t\t\t\t\t\t\tday: 7,\n\t\t\t\t\t\t\t\tmonth: 1,\n\t\t\t\t\t\t\t\tvisibility: \"Self\",",
"score": 40.75956218370224
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t\t\t\tbusiness_account: {},\n\t\t\t\t\tid: user._id,\n\t\t\t\t\tis_blue_verified: user.ext_is_blue_verified,\n\t\t\t\t\tlegacy: {\n\t\t\t\t\t\tcreated_at: user.created_at,\n\t\t\t\t\t\tdefault_profile: user.default_profile,\n\t\t\t\t\t\tdefault_profile_image: user.default_profile_image,\n\t\t\t\t\t\tdescription: user.description,\n\t\t\t\t\t\tentities: user.entities,\n\t\t\t\t\t\tfast_followers_count: user.fast_followers_count,",
"score": 40.6412228706896
},
{
"filename": "src/models/Notification.ts",
"retrieved_chunk": "\t\tentities: [],\n\t\trtl: Boolean,\n\t},\n\ttemplate: {\n\t\taggregateUserActionsV1: {\n\t\t\ttargetObjects: [\n\t\t\t\t{\n\t\t\t\t\ttweet: {\n\t\t\t\t\t\tid: String,\n\t\t\t\t\t},",
"score": 32.52249087974909
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\tdata: {\n\t\t\tuser: {\n\t\t\t\tresult: {\n\t\t\t\t\t__typename: \"User\",\n\t\t\t\t\taffiliates_highlighted_label: user.ext?.highlightedLabel?.r?.ok,\n\t\t\t\t\tbusiness_account: {},\n\t\t\t\t\tid: user._id,\n\t\t\t\t\tis_blue_verified: user.ext_is_blue_verified,\n\t\t\t\t\tlegacy: {\n\t\t\t\t\t\tcreated_at: user.created_at,",
"score": 31.14748439883811
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\tentities: {},\n\t\t\t\terrors: {},\n\t\t\t\tfetchStatus: {},\n\t\t\t},\n\t\t\tusers: {\n\t\t\t\tentities: {\n\t\t\t\t\t[user.id_string!]: {\n\t\t\t\t\t\t...user,\n\t\t\t\t\t\thasNftAvatar: {\n\t\t\t\t\t\t\tr: {",
"score": 24.27110983211571
}
] | typescript | user_mentions as IUserMention[]
).map((mention) => { |
import Notification from "../models/Notification";
import User from "../models/User";
import { randStr } from "./randUtil";
/**
* Adds a notification to a given user
* @param {string} text The message. `%1` is automatically replaced with the username of the recipient.
* @param {string} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
*/
export async function addNotification(
text: string,
type: "internal",
recipient: string
): Promise<void>;
/**
* Adds a notification to a given user
* @param {string} text The message. `%1` is automatically replaced with the username of the sender.
* @param {string} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
* @param {string} sender The user who added the notification
*/
export async function addNotification(
text: string,
type: "like" | "reply" | "retweet",
recipient: string,
sender: string,
tweet: string
): Promise<void>;
/**
* Adds a notification to a given user
* @param {string=} text The message. `%1` is automatically replaced with the username.
* @param {string=} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
* @param {string=} sender The user who added the notification
*/
export async function addNotification(
text: string,
type: "like" | "reply" | "retweet" | "internal",
recipient: string,
sender?: string,
tweet?: string
) {
const id = randStr(64);
if (sender) {
// user-based
const icon = (() => {
if (type === "like") return "heart_icon";
if (type === "reply") return "reply_icon";
if (type === "retweet") return "reweet_icon";
else return "bird_icon";
})();
const recipientUser = await User | .findOne({ id_string: recipient }); |
if (!recipientUser) throw new Error(`Recipient not found`);
const senderUser = await User.findOne({ id_string: sender });
if (!senderUser) throw new Error(`Sender not found`);
const noti = new Notification({
id,
message: {
text: text.replaceAll("%1", senderUser.name!),
rtl: false,
entities: [
{
fromIndex: 0,
toIndex: senderUser.name!.length,
ref: {
user: {
id: sender,
},
},
},
],
},
icon: {
id: icon,
},
timestampMs: Date.now(),
template: {
aggregateUserActionsV1: {
targetObjects: [
{
tweet: {
id: tweet,
},
},
],
fromUsers: [
{
user: {
id: sender,
},
},
],
},
},
});
recipientUser.notification_ids.push(id);
await noti.save();
await recipientUser.save();
return;
} else {
// sent from admin
const recipientUser = await User.findOne({ id_string: recipient });
if (!recipientUser) throw new Error(`Recipient not found`);
recipientUser.notification_ids.push(id);
const noti = new Notification({
id,
message: {
text: text.replaceAll("%1", recipientUser.name!),
rtl: false,
entities: [
{
fromIndex: 0,
toIndex: recipientUser.name!.length,
ref: {
user: {
id: recipient,
},
},
},
],
},
icon: {
id: "bird_icon",
},
timestampMs: Date.now(),
});
await noti.save();
await recipientUser.save();
return;
}
}
| src/util/notifications.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "// \t\treturn res.status(400).send({ msg: \"Missing parameters\" });\n// \tconst id_string = variables.userId;\n// \tif (!id_string || id_string === \"undefined\")\n// \t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n// \tconst user = await User.findOne({\n// \t\tid_string,\n// \t});\n// \tif (!user) return res.status(200).send({ data: {} });\n// \treturn res.status(200).send({\n// \t\tdata: {",
"score": 49.994562940283224
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\tif (unauthorized) return;\n\tconst user = await User.findOne({\n\t\tid_string: (\n\t\t\tverify(req.cookies[\"jwt\"], process.env.JWT_SECRET!) as IJwtDecoded\n\t\t).id.toString(),\n\t});\n\tif (!user) return res.status(400).send({ msg: \"Not authenticated\" });\n\tconst variables = req.body.variables as IFavouriteTweetVariables;\n\tconst tweet = await Tweet.findOne({ id_str: variables.tweet_id });\n\tif (!tweet) return res.status(400).send({ msg: \"Tweet not found\" });",
"score": 47.174011522807355
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": " `);\n\t}\n\tif (!req.cookies.jwt) return res.redirect(\"https://twitter.com\");\n\tconst user = await User.findOne({\n\t\tid_string: (decode(req.cookies.jwt) as { id: string }).id.toString(),\n\t});\n\tif (!user) return res.redirect(\"https://twitter.com\");\n\tconst __INITIAL_STATE__ = {\n\t\toptimist: [],\n\t\tentities: {",
"score": 46.905774193799004
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\t});\n}\nexport async function FavoriteTweet(\n\treq: express.Request,\n\tres: express.Response\n) {\n\tconst unauthorized = await requireAuth(req, res);\n\tif (unauthorized) return;\n\tconst user = await User.findOne({\n\t\tid_string: (",
"score": 46.05710005301512
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\tconst variables = JSON.parse(\n\t\treq.query.variables!.toString()\n\t) as IUserByRestIdVariables;\n\tif (!features || !variables)\n\t\treturn res.status(400).send({ msg: \"Missing parameters\" });\n\tconst id_string = variables.userId;\n\tif (!id_string || id_string === \"undefined\")\n\t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n\tconst user = await User.findOne({\n\t\tid_string: {",
"score": 45.85830931771587
}
] | typescript | .findOne({ id_string: recipient }); |
import express from "express";
import { verify } from "jsonwebtoken";
import { requireAuth } from "../../middleware/auth";
import Tweet from "../../models/Tweet";
import User from "../../models/User";
import {
ICreateTweetBody,
IGenericFeatures,
IJwtDecoded,
} from "../../types/graphql";
import { IUser } from "../../types/guide";
import { formatDate } from "../../util/formatDate";
import { log } from "../../util/logging";
import { randInt } from "../../util/randUtil";
import { IUserMention } from "./user";
import { addNotification } from "../../util/notifications";
interface IUserTweetsVariables {
userId: string;
count: number;
includePromotedContent: boolean;
withQuickPromoteEligibilityTweetFields: boolean;
withVoice: boolean;
withV2Timeline: boolean;
}
interface IFavouriteTweetVariables {
tweet_id: string;
}
export async function UserTweets(req: express.Request, res: express.Response) {
const loggedInUser = req.cookies["jwt"]
? await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id,
})
: undefined;
const features = JSON.parse(
req.query.features!.toString()
) as IGenericFeatures;
const variables = JSON.parse(
req.query.variables!.toString()
) as IUserTweetsVariables;
if (!features || !variables)
return res.status(400).send({ msg: "Missing parameters" });
const user = await User.findOne({ id: variables.userId });
if (!user) return res.status(400).send({ msg: "User not found" });
const userTweets = [];
const postedTweets = Array.from(user.posted_tweet_ids);
for (const id of postedTweets) {
| const tweet = await Tweet.findOne({ id_str: id }); |
userTweets.push({
is_translatable: false,
legacy: tweet
? Object.assign(tweet, {
favorited: loggedInUser
? loggedInUser.liked_tweet_ids.includes(tweet.id_str || "")
: false,
})
: tweet,
source: tweet?.source,
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
});
}
return res.status(200).send({
data: {
user: {
result: {
__typename: "User",
timeline_v2: {
timeline: {
instructions: [
{
type: "TimelineClearCache",
},
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified:
user.ext_is_blue_verified,
legacy: {
...(user as any)._doc,
},
profile_image_shape:
user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
},
},
});
}
export async function HomeTimeline(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const userId = req.cookies["jwt"]
? ((verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded)
.id as number)
: undefined;
const loggedInUser = await User.findOne({
id_string: userId,
});
if (!loggedInUser) return res.status(400).send({ msg: "Not authenticated" });
const userTweets = [];
const postedTweets = await Tweet.find().limit(50);
for (const tweet of postedTweets) {
const user = await User.findOne({ id_string: tweet.user_id_str });
if (!user) return res.status(400).send({ msg: "User not found" });
userTweets.push({
is_translatable: false,
legacy: Object.assign(tweet, {
favorited: loggedInUser.liked_tweet_ids.includes(tweet.id_str || ""),
}),
unmention_data: {},
unmention_info: {},
views: tweet.ext_views,
user: user,
});
}
return res.status(200).send({
data: {
home: {
home_timeline_urt: {
instructions: [
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
tweet.user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: tweet.user._id,
is_blue_verified:
tweet.user.ext_is_blue_verified,
legacy: {
...(tweet.user as any)._doc,
entities: {
user_mentions: (
tweet.legacy.entities
?.user_mentions as IUserMention[]
).map((mention) => {
return {
a: true,
};
}),
},
},
profile_image_shape:
tweet.user.ext_profile_image_shape,
rest_id: tweet.user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.legacy.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
});
}
export async function FavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (!user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids.push(variables.tweet_id);
tweet.favorite_count! += 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { favourte_tweet: "NOT DONE" } });
}
if (tweet.user_id_str !== user.id_string)
addNotification(
"%1 liked your tweet!",
"like",
tweet.user_id_str!,
user.id_string!,
tweet.id_str!
);
return res.status(200).send({ data: { favorite_tweet: "Done" } });
}
export async function UnfavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids = user.liked_tweet_ids.filter(
(id) => id !== variables.tweet_id
);
tweet.favorite_count! -= 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { unfavorite_tweet: "NOT DONE" } });
}
return res.status(200).send({ data: { unfavorite_tweet: "Done" } });
}
export async function CreateTweet(req: express.Request, res: express.Response) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const body = req.body as ICreateTweetBody;
const id = (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id as number;
const user = await User.findOne({ id });
if (!user) return res.status(400).send({ msg: "User not found" });
const user_mentions = [] as IUserMention[];
const matches = body.variables.tweet_text.matchAll(/@(\S+)/gm);
for (const match of matches) {
const withTag = match[0];
const withoutTag = match[1];
const user = await User.findOne({ screen_name: withoutTag });
user_mentions.push({
id_str: user?.id_string,
name: user?.name,
screen_name: user?.screen_name,
indices: [match.index, withTag.length + (match.index || 0)],
});
}
const tweetId = randInt(12);
const tweetData = {
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions,
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id: tweetId,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
source:
'<a href="https://mobile.twitter.com" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
};
const tweet = new Tweet({
bookmark_count: tweetData.legacy.bookmark_count,
bookmarked: tweetData.legacy.bookmarked,
conversation_id_str: tweetData.legacy.conversation_id_str,
created_at: tweetData.legacy.created_at,
display_text_range: tweetData.legacy.display_text_range,
entities: {
hashtags: tweetData.legacy.entities.hashtags,
symbols: tweetData.legacy.entities.symbols,
urls: tweetData.legacy.entities.urls,
user_mentions,
},
favorite_count: tweetData.legacy.favorite_count,
favorited: tweetData.legacy.favorited,
full_text: tweetData.legacy.full_text,
id_str: tweetData.legacy.id_str,
is_quote_status: tweetData.legacy.is_quote_status,
lang: tweetData.legacy.lang,
quote_count: tweetData.legacy.quote_count,
reply_count: tweetData.legacy.reply_count,
retweet_count: tweetData.legacy.retweet_count,
retweeted: tweetData.legacy.retweeted,
user_id_str: tweetData.legacy.user_id_str,
});
await tweet.save();
user.posted_tweet_ids.push(tweetId.toString());
await user.save();
log(`${user.name} (@${user.screen_name}) just posted a tweet:`);
log(`"${tweet.full_text}"`);
// addNotification(
// "%1 just posted a tweet!",
// "reply",
// user.id_string!,
// user.id_string!,
// tweet.id_str!
// );
return res.status(200).send({
// data: {
// create_tweet: {
// tweet_results: {
// result: {
// core: {
// user_results: {
// result: {
// __typename: "User",
// affiliates_highlighted_label:
// user.ext?.highlightedLabel?.r?.ok,
// business_account: {},
// id: user._id,
// is_blue_verified: user.ext_is_blue_verified,
// legacy: {
// created_at: user.created_at,
// default_profile: user.default_profile,
// default_profile_image: user.default_profile_image,
// description: user.description,
// entities: user.entities,
// fast_followers_count: user.fast_followers_count,
// favourites_count: user.favourites_count,
// followers_count: user.followers_count,
// friends_count: user.friends_count,
// has_custom_timelines: user.has_custom_timelines,
// is_translator: user.is_translator,
// listed_count: user.listed_count,
// location: user.location,
// media_count: user.media_count,
// name: user.name,
// normal_followers_count: user.normal_followers_count,
// pinned_tweet_ids_str: user.pinned_tweet_ids_str,
// possibly_sensitive: false,
// profile_image_url_https: user.profile_image_url_https,
// profile_interstitial_type: "",
// screen_name: user.screen_name,
// statuses_count: user.statuses_count,
// translator_type: user.translator_type,
// verified: user.verified,
// withheld_in_countries: user.withheld_in_countries,
// },
// profile_image_shape: user.ext_profile_image_shape,
// rest_id: user.id,
// },
// },
// },
// ...tweetData,
// },
// },
// },
// },
data: {
create_tweet: {
tweet_results: {
result: {
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified: user.ext_is_blue_verified,
legacy: {
created_at: user.created_at,
default_profile: user.default_profile,
default_profile_image: user.default_profile_image,
description: user.description,
entities: user.entities,
fast_followers_count: user.fast_followers_count,
favourites_count: user.favourites_count,
followers_count: user.followers_count,
friends_count: user.friends_count,
has_custom_timelines: user.has_custom_timelines,
is_translator: user.is_translator,
listed_count: user.listed_count,
location: user.location,
media_count: user.media_count,
name: user.name,
normal_followers_count: user.normal_followers_count,
pinned_tweet_ids_str: user.pinned_tweet_ids_str,
possibly_sensitive: false,
profile_image_url_https: user.profile_image_url_https,
profile_interstitial_type: "",
screen_name: user.screen_name,
statuses_count: user.statuses_count,
translator_type: user.translator_type,
verified: user.verified,
withheld_in_countries: user.withheld_in_countries,
},
profile_image_shape: user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_control: {
edit_tweet_ids: [tweetId.toString()],
editable_until_msecs: "1682984834000",
edits_remaining: "5",
is_edit_eligible: true,
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, 68],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions: (
tweet.entities!.user_mentions as Array<Array<IUserMention>>
).map((mention) => mention[0]),
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
rest_id: tweetId.toString(),
source:
'<a href="https://github.com/" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Disabled",
},
},
},
},
},
});
}
| src/routes/gql/tweet.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\tconst variables = JSON.parse(\n\t\treq.query.variables!.toString()\n\t) as IUserByRestIdVariables;\n\tif (!features || !variables)\n\t\treturn res.status(400).send({ msg: \"Missing parameters\" });\n\tconst id_string = variables.userId;\n\tif (!id_string || id_string === \"undefined\")\n\t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n\tconst user = await User.findOne({\n\t\tid_string: {",
"score": 139.22801559561012
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": ") {\n\tconst variables = JSON.parse(\n\t\treq.query.variables!.toString()\n\t) as IProfileSpotlightsQueryVariables;\n\tif (!variables) return res.status(400).send({ msg: \"Missing parameters\" });\n\tconst screenName = variables.screen_name;\n\tif (!screenName || screenName === \"undefined\")\n\t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n\tconst user = await User.findOne({\n\t\tscreen_name: screenName,",
"score": 133.0388447391518
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "// \t\treturn res.status(400).send({ msg: \"Missing parameters\" });\n// \tconst id_string = variables.userId;\n// \tif (!id_string || id_string === \"undefined\")\n// \t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n// \tconst user = await User.findOne({\n// \t\tid_string,\n// \t});\n// \tif (!user) return res.status(200).send({ data: {} });\n// \treturn res.status(200).send({\n// \t\tdata: {",
"score": 124.77233004517305
},
{
"filename": "src/routes/gql/viewer.ts",
"retrieved_chunk": "\tconst user = await User.findOne({\n\t\tid,\n\t});\n\tif (!user) return res.status(400).send({ msg: \"User not found\" });\n\treturn res.status(200).send({\n\t\tdata: {\n\t\t\tis_super_follow_subscriber: false,\n\t\t\tviewer: {\n\t\t\t\tcreate_community_action_result: {\n\t\t\t\t\t__typename: \"CommunityCreateActionUnavailable\",",
"score": 121.35120670780948
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\tres: express.Response\n) {\n\tconst features = JSON.parse(\n\t\treq.query.features!.toString()\n\t) as IGenericFeatures;\n\tconst variables = JSON.parse(\n\t\treq.query.variables!.toString()\n\t) as IUserByScreenNameVariables;\n\tif (!features || !variables)\n\t\treturn res.status(400).send({ msg: \"Missing parameters\" });",
"score": 113.63841183397085
}
] | typescript | const tweet = await Tweet.findOne({ id_str: id }); |
import { defineModule } from "../define-module";
import { messageBuilder } from "../../message";
import { Store } from "../../store";
import FileStore from "../../store/file-store";
import JsonStore from "../../store/json-store";
interface Goal {
text: string;
complete: boolean;
}
const KEY = "goals";
export default defineModule<Store<Goal[]>>({
name: "goals",
createState: ({ agentId }) => new JsonStore(new FileStore([agentId])),
}).with({
async pinnedMessage({ state }) {
const goals = (await state.get(KEY)) || [];
const currentGloals = goals.length
? `This is your current goal list:\n\n${goals
.map(
({ text, complete }, index) =>
`${index + 1}) "${text}" [${complete ? "COMPLETE" : "PENDING"}]`
)
.join("\n")}`
: "You have no goals currently.";
return `
You are responsible for maintaining your list of goals, based on higher-level objectives which will be given to you. Whenever you start doing something, first add a goal. Whenever you finish doing something, mark it complete. This list of goals will always be pinned to the top of your context and won't be summarized away. Goals should be medium-term (requiring several actions to complete) and concrete. Do not invent goals out of nothing, they should encapsulate instructions that have been given to you.
${currentGloals}
`.trim();
},
actions: {
addGoal: {
description: "Add a new goal at the end of your goals list.",
parameters: {
goal: {
description:
"A summary of what you want to achieve (keep this relatively short but information dense)",
},
},
async execute({
parameters: { goal },
context: { agentId, state },
sendMessage,
}) {
const goals = (await state.get(KEY)) || [];
await state.set(KEY, [...goals, { text: goal, complete: false }]);
sendMessage(messageBuilder.ok(agentId, "Goal added."));
},
},
completeGoal: {
description: "Mark a goal as complete.",
parameters: {
goalNumber: {
description: "The number of the goal you want to mark as complete",
},
},
async execute({
parameters: { goalNumber },
context: { agentId, state },
sendMessage,
}) {
const idx = parseInt(goalNumber) - 1;
const goals = (await state.get(KEY)) || [];
if (isNaN(idx) || idx < 0 || idx >= goals.length)
return sendMessage(
| messageBuilder.error(agentId, `Invalid goal index: ${goalNumber}`)
); |
await state.set(KEY, [
...goals.slice(0, idx),
{ ...goals[idx], complete: true },
...goals.slice(idx + 1),
]);
sendMessage(messageBuilder.ok(agentId, "Goal marked complete."));
},
},
},
});
| src/module/definitions/goals.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " },\n },\n async execute({\n parameters: { title },\n context: { agentId, state },\n sendMessage,\n }) {\n const content = await state.get(title);\n if (content) {\n sendMessage(",
"score": 29.51568987843937
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " },\n async execute({\n parameters: { title, content },\n context: { agentId, state },\n sendMessage,\n }) {\n await state.set(title, content);\n sendMessage(\n messageBuilder.ok(\n agentId,",
"score": 26.04782940652523
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " }) {\n if (await state.delete(title)) {\n sendMessage(messageBuilder.ok(agentId, `Deleted note \"${title}\".`));\n } else {\n sendMessage(\n messageBuilder.error(agentId, `Note \"${title}\" not found.`)\n );\n }\n },\n },",
"score": 22.643419949792303
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " },\n async execute({\n parameters: { path },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;\n try {\n await unlink(path);\n sendMessage(messageBuilder.ok(agentId, `Deleted ${path}.`));",
"score": 17.798992410287273
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " path: string,\n sendMessage: (message: any) => void\n) {\n const currentDirectory = process.cwd();\n const resolvedPath = resolvePath(path);\n if (!resolvedPath.startsWith(currentDirectory)) {\n sendMessage(\n messageBuilder.error(\n agentId,\n \"Invalid path; must be within the current directory.\"",
"score": 17.30742560343572
}
] | typescript | messageBuilder.error(agentId, `Invalid goal index: ${goalNumber}`)
); |
import express from "express";
import { verify } from "jsonwebtoken";
import { requireAuth } from "../../middleware/auth";
import Tweet from "../../models/Tweet";
import User from "../../models/User";
import {
ICreateTweetBody,
IGenericFeatures,
IJwtDecoded,
} from "../../types/graphql";
import { IUser } from "../../types/guide";
import { formatDate } from "../../util/formatDate";
import { log } from "../../util/logging";
import { randInt } from "../../util/randUtil";
import { IUserMention } from "./user";
import { addNotification } from "../../util/notifications";
interface IUserTweetsVariables {
userId: string;
count: number;
includePromotedContent: boolean;
withQuickPromoteEligibilityTweetFields: boolean;
withVoice: boolean;
withV2Timeline: boolean;
}
interface IFavouriteTweetVariables {
tweet_id: string;
}
export async function UserTweets(req: express.Request, res: express.Response) {
const loggedInUser = req.cookies["jwt"]
? await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id,
})
: undefined;
const features = JSON.parse(
req.query.features!.toString()
) as IGenericFeatures;
const variables = JSON.parse(
req.query.variables!.toString()
) as IUserTweetsVariables;
if (!features || !variables)
return res.status(400).send({ msg: "Missing parameters" });
const user = await User.findOne({ id: variables.userId });
if (!user) return res.status(400).send({ msg: "User not found" });
const userTweets = [];
const postedTweets = Array.from(user.posted_tweet_ids);
for (const id of postedTweets) {
const tweet = await Tweet.findOne({ id_str: id });
userTweets.push({
is_translatable: false,
legacy: tweet
? Object.assign(tweet, {
favorited: loggedInUser
? loggedInUser.liked_tweet_ids.includes(tweet.id_str || "")
: false,
})
: tweet,
source: tweet?.source,
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
});
}
return res.status(200).send({
data: {
user: {
result: {
__typename: "User",
timeline_v2: {
timeline: {
instructions: [
{
type: "TimelineClearCache",
},
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified:
user.ext_is_blue_verified,
legacy: {
...(user as any)._doc,
},
profile_image_shape:
user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
},
},
});
}
export async function HomeTimeline(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const userId = req.cookies["jwt"]
? ((verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded)
.id as number)
: undefined;
const loggedInUser = await User.findOne({
id_string: userId,
});
if (!loggedInUser) return res.status(400).send({ msg: "Not authenticated" });
const userTweets = [];
| const postedTweets = await Tweet.find().limit(50); |
for (const tweet of postedTweets) {
const user = await User.findOne({ id_string: tweet.user_id_str });
if (!user) return res.status(400).send({ msg: "User not found" });
userTweets.push({
is_translatable: false,
legacy: Object.assign(tweet, {
favorited: loggedInUser.liked_tweet_ids.includes(tweet.id_str || ""),
}),
unmention_data: {},
unmention_info: {},
views: tweet.ext_views,
user: user,
});
}
return res.status(200).send({
data: {
home: {
home_timeline_urt: {
instructions: [
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
tweet.user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: tweet.user._id,
is_blue_verified:
tweet.user.ext_is_blue_verified,
legacy: {
...(tweet.user as any)._doc,
entities: {
user_mentions: (
tweet.legacy.entities
?.user_mentions as IUserMention[]
).map((mention) => {
return {
a: true,
};
}),
},
},
profile_image_shape:
tweet.user.ext_profile_image_shape,
rest_id: tweet.user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.legacy.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
});
}
export async function FavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (!user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids.push(variables.tweet_id);
tweet.favorite_count! += 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { favourte_tweet: "NOT DONE" } });
}
if (tweet.user_id_str !== user.id_string)
addNotification(
"%1 liked your tweet!",
"like",
tweet.user_id_str!,
user.id_string!,
tweet.id_str!
);
return res.status(200).send({ data: { favorite_tweet: "Done" } });
}
export async function UnfavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids = user.liked_tweet_ids.filter(
(id) => id !== variables.tweet_id
);
tweet.favorite_count! -= 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { unfavorite_tweet: "NOT DONE" } });
}
return res.status(200).send({ data: { unfavorite_tweet: "Done" } });
}
export async function CreateTweet(req: express.Request, res: express.Response) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const body = req.body as ICreateTweetBody;
const id = (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id as number;
const user = await User.findOne({ id });
if (!user) return res.status(400).send({ msg: "User not found" });
const user_mentions = [] as IUserMention[];
const matches = body.variables.tweet_text.matchAll(/@(\S+)/gm);
for (const match of matches) {
const withTag = match[0];
const withoutTag = match[1];
const user = await User.findOne({ screen_name: withoutTag });
user_mentions.push({
id_str: user?.id_string,
name: user?.name,
screen_name: user?.screen_name,
indices: [match.index, withTag.length + (match.index || 0)],
});
}
const tweetId = randInt(12);
const tweetData = {
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions,
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id: tweetId,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
source:
'<a href="https://mobile.twitter.com" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
};
const tweet = new Tweet({
bookmark_count: tweetData.legacy.bookmark_count,
bookmarked: tweetData.legacy.bookmarked,
conversation_id_str: tweetData.legacy.conversation_id_str,
created_at: tweetData.legacy.created_at,
display_text_range: tweetData.legacy.display_text_range,
entities: {
hashtags: tweetData.legacy.entities.hashtags,
symbols: tweetData.legacy.entities.symbols,
urls: tweetData.legacy.entities.urls,
user_mentions,
},
favorite_count: tweetData.legacy.favorite_count,
favorited: tweetData.legacy.favorited,
full_text: tweetData.legacy.full_text,
id_str: tweetData.legacy.id_str,
is_quote_status: tweetData.legacy.is_quote_status,
lang: tweetData.legacy.lang,
quote_count: tweetData.legacy.quote_count,
reply_count: tweetData.legacy.reply_count,
retweet_count: tweetData.legacy.retweet_count,
retweeted: tweetData.legacy.retweeted,
user_id_str: tweetData.legacy.user_id_str,
});
await tweet.save();
user.posted_tweet_ids.push(tweetId.toString());
await user.save();
log(`${user.name} (@${user.screen_name}) just posted a tweet:`);
log(`"${tweet.full_text}"`);
// addNotification(
// "%1 just posted a tweet!",
// "reply",
// user.id_string!,
// user.id_string!,
// tweet.id_str!
// );
return res.status(200).send({
// data: {
// create_tweet: {
// tweet_results: {
// result: {
// core: {
// user_results: {
// result: {
// __typename: "User",
// affiliates_highlighted_label:
// user.ext?.highlightedLabel?.r?.ok,
// business_account: {},
// id: user._id,
// is_blue_verified: user.ext_is_blue_verified,
// legacy: {
// created_at: user.created_at,
// default_profile: user.default_profile,
// default_profile_image: user.default_profile_image,
// description: user.description,
// entities: user.entities,
// fast_followers_count: user.fast_followers_count,
// favourites_count: user.favourites_count,
// followers_count: user.followers_count,
// friends_count: user.friends_count,
// has_custom_timelines: user.has_custom_timelines,
// is_translator: user.is_translator,
// listed_count: user.listed_count,
// location: user.location,
// media_count: user.media_count,
// name: user.name,
// normal_followers_count: user.normal_followers_count,
// pinned_tweet_ids_str: user.pinned_tweet_ids_str,
// possibly_sensitive: false,
// profile_image_url_https: user.profile_image_url_https,
// profile_interstitial_type: "",
// screen_name: user.screen_name,
// statuses_count: user.statuses_count,
// translator_type: user.translator_type,
// verified: user.verified,
// withheld_in_countries: user.withheld_in_countries,
// },
// profile_image_shape: user.ext_profile_image_shape,
// rest_id: user.id,
// },
// },
// },
// ...tweetData,
// },
// },
// },
// },
data: {
create_tweet: {
tweet_results: {
result: {
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified: user.ext_is_blue_verified,
legacy: {
created_at: user.created_at,
default_profile: user.default_profile,
default_profile_image: user.default_profile_image,
description: user.description,
entities: user.entities,
fast_followers_count: user.fast_followers_count,
favourites_count: user.favourites_count,
followers_count: user.followers_count,
friends_count: user.friends_count,
has_custom_timelines: user.has_custom_timelines,
is_translator: user.is_translator,
listed_count: user.listed_count,
location: user.location,
media_count: user.media_count,
name: user.name,
normal_followers_count: user.normal_followers_count,
pinned_tweet_ids_str: user.pinned_tweet_ids_str,
possibly_sensitive: false,
profile_image_url_https: user.profile_image_url_https,
profile_interstitial_type: "",
screen_name: user.screen_name,
statuses_count: user.statuses_count,
translator_type: user.translator_type,
verified: user.verified,
withheld_in_countries: user.withheld_in_countries,
},
profile_image_shape: user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_control: {
edit_tweet_ids: [tweetId.toString()],
editable_until_msecs: "1682984834000",
edits_remaining: "5",
is_edit_eligible: true,
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, 68],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions: (
tweet.entities!.user_mentions as Array<Array<IUserMention>>
).map((mention) => mention[0]),
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
rest_id: tweetId.toString(),
source:
'<a href="https://github.com/" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Disabled",
},
},
},
},
},
});
}
| src/routes/gql/tweet.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/middleware/auth.ts",
"retrieved_chunk": "\t\tconst jwtParams = verify(\n\t\t\treq.cookies[\"jwt\"] as string,\n\t\t\tprocess.env.JWT_SECRET!\n\t\t) as IJwtDecoded;\n\t\tconst user = await User.findOne({ id: jwtParams.id });\n\t\tif (!user)\n\t\t\treturn res\n\t\t\t\t.status(401)\n\t\t\t\t.send({ msg: \"Auth token invalid (does your account exist?)\" });\n\t} catch (e) {",
"score": 91.40026630995474
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": " `);\n\t}\n\tif (!req.cookies.jwt) return res.redirect(\"https://twitter.com\");\n\tconst user = await User.findOne({\n\t\tid_string: (decode(req.cookies.jwt) as { id: string }).id.toString(),\n\t});\n\tif (!user) return res.redirect(\"https://twitter.com\");\n\tconst __INITIAL_STATE__ = {\n\t\toptimist: [],\n\t\tentities: {",
"score": 79.61314028612736
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\tconst variables = JSON.parse(\n\t\treq.query.variables!.toString()\n\t) as IUserByRestIdVariables;\n\tif (!features || !variables)\n\t\treturn res.status(400).send({ msg: \"Missing parameters\" });\n\tconst id_string = variables.userId;\n\tif (!id_string || id_string === \"undefined\")\n\t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n\tconst user = await User.findOne({\n\t\tid_string: {",
"score": 78.69164924934151
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "// \t\treturn res.status(400).send({ msg: \"Missing parameters\" });\n// \tconst id_string = variables.userId;\n// \tif (!id_string || id_string === \"undefined\")\n// \t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n// \tconst user = await User.findOne({\n// \t\tid_string,\n// \t});\n// \tif (!user) return res.status(200).send({ data: {} });\n// \treturn res.status(200).send({\n// \t\tdata: {",
"score": 71.97534930394066
},
{
"filename": "src/routes/gql/viewer.ts",
"retrieved_chunk": "import express from \"express\";\nimport User from \"../../models/User\";\nexport async function Viewer(req: express.Request, res: express.Response) {\n\t// if (!req.cookies.twt_id)\n\t// \treturn res.status(400).send({ msg: \"No twid detected\" });\n\tconst id = (req.cookies.twt_id as string | undefined)?.split(\"=\")[1] as\n\t\t| string\n\t\t| undefined;\n\tif (!id || id === \"undefined\")\n\t\treturn res.status(200).send({",
"score": 65.53054336875876
}
] | typescript | const postedTweets = await Tweet.find().limit(50); |
import { Event } from ".";
import makeDecision, { toOpenAiMessage } from "../make-decision";
import { messageBuilder } from "../message";
import { ModuleManager } from "../module/module-manager";
import { Store } from "../store";
import {
AVG_WORDS_PER_TOKEN,
agentName,
countTokens as countTokensInText,
messageSourceName,
} from "../util";
export class Memory {
private firstRetrieval = true;
constructor(
private agentId: string,
private moduleManager: ModuleManager,
private store: Store<Event[]>,
private compressionThreshold: number
) {}
async append(event: Event): Promise<Event[]> {
this.printEvent(event);
let events = await this.retrieve();
if (event.type === "message" && event.message.type === "ok") {
// After an "ok" message is sent, remove all errors and their antecedents from memory,
// since agents tend to repeat mistakes rather than learning from them.
events = this.removeErrors(events);
}
events.push(event);
events = await this.summarize(events);
await this.store.set(this.key, events.slice(1));
return events;
}
async retrieve(): Promise<Event[]> {
const introduction = await this.getIntroduction();
const storedEvents = await this.store.get(this.key);
let events = [
introduction,
...(storedEvents || [{ type: "decision", actionText: "noop" }]),
];
if (this.firstRetrieval) {
this.firstRetrieval = false;
events = await this.summarize(events);
await this.store.set(this.key, events.slice(1));
}
// events.forEach((event) => this.printEvent(event));
return events;
}
private async getIntroduction(): Promise<Event> {
const nestedEvents = await Promise.all(
this.moduleManager.modules.map(async (module): Promise<string[]> => {
const { name, pinnedMessage } = module.moduleDef;
if (!pinnedMessage) return [];
const content = await pinnedMessage(module.context);
if (!content) return [];
return [`--- ${name.toUpperCase()} ---\n\n${content}`];
})
);
return {
type: "message",
message | : messageBuilder.spontaneous(
this.agentId,
nestedEvents.flat().join("\n\n")
),
}; |
}
private removeErrors(events: Event[]): Event[] {
const cleaned: Event[] = [];
for (let i = events.length - 1; i >= 0; i--) {
const event = events[i];
if (event.type === "message" && event.message.type === "error") {
const prevEvent = events[i - 1];
// console.log("REMOVING", JSON.stringify(prevEvent, null, 2));
// console.log("REMOVING", JSON.stringify(event, null, 2));
if (prevEvent.type === "decision") {
i--; // skip the previous action which generated the error
} else {
console.error("error event was not preceded by an action");
}
continue;
}
cleaned.push(event);
}
cleaned.reverse();
// console.log({ events, cleaned });
return cleaned;
}
/**
* Compress the event history when it becomes too large in order to free up the context window.
*/
private async summarize(events: Event[]): Promise<Event[]> {
if (!events.length) return [];
const cumulativeTokenCounts = this.getCumulativeTokenCounts(events);
const totalTokenCount =
cumulativeTokenCounts[cumulativeTokenCounts.length - 1];
const thresholdOverrun = totalTokenCount - this.compressionThreshold;
const truncationThreshold =
cumulativeTokenCounts[0] +
Math.max(
thresholdOverrun,
Math.floor((totalTokenCount - cumulativeTokenCounts[0]) / 2)
);
// console.log(
// `Token count: ${totalTokenCount}\nRemaining context space: ${-thresholdOverrun}`
// );
// console.log({
// compressionThreshold: this.compressionThreshold,
// truncationThreshold,
// thresholdOverrun,
// cumulativeTokenCounts,
// });
if (thresholdOverrun > 0) {
let i = 1;
// prettier-ignore
for (; i < events.length && cumulativeTokenCounts[i - 1] <= truncationThreshold; i++);
// prettier-ignore
for (; i > 0 && cumulativeTokenCounts[i - 1] > this.compressionThreshold; i--);
i = Math.max(i, 3);
const precedingTokens = cumulativeTokenCounts[i - 1];
// console.log({ truncationIndex: i, precedingTokens });
const summaryWordLimit = Math.floor(
(this.compressionThreshold * AVG_WORDS_PER_TOKEN) / 6
);
const eventsToSummarize = events.slice(0, i);
// console.log(
// `Summarizing ${eventsToSummarize.length} events (${eventsToSummarize
// .map(countTokens)
// .reduce((sum, next) => sum + next, 0)} tokens)`
// );
const summaryContent = await makeDecision([
...eventsToSummarize,
{
type: "message",
message: messageBuilder.ok(
this.agentId,
`Write a summary in ${summaryWordLimit} words or less of what has happened since (but not including) the introductory message. Include key information that you learned which you don't want to forget. This information will serve as a note to yourself to help you understand what has gone before. Use the second person voice, as if you are someone filling in your replacement who knows nothing. The summarized messages will be omitted from your context window going forward and you will only have this summary to go by, so make it as useful and information-dense as possible. Be as specific as possible, but only include important information. If there are details that seem unimportant, or which you could recover outside of your memory (for instance the particular contents of a file which you could read any time), then omit them from your summary. Once again, your summary must not exceed ${summaryWordLimit} words. In this particular instance, your response should just be raw text, not formatted as an action.`
),
},
]);
const summary = `Several events are omitted here to free up space in your context window, summarized as follows:\n\n${summaryContent}`;
// const summary =
// "Several events are omitted here to free up space in your context window.";
const summaryEvent: Event = {
type: "message",
message: messageBuilder.spontaneous(this.agentId, summary),
};
const summaryTokens = countTokens(summaryEvent);
const tokenSavings =
precedingTokens - summaryTokens - cumulativeTokenCounts[0];
if (tokenSavings > 0) {
// console.log(
// `Summarized events, saving ${tokenSavings} tokens:\n\n${summary}`
// );
const newEvents = [events[0], summaryEvent, ...events.slice(i)];
// const newCumulativeTokenCounts =
// this.getCumulativeTokenCounts(newEvents);
// console.log({ newCumulativeTokenCounts });
return newEvents;
}
}
return events;
}
private getCumulativeTokenCounts(events: Event[]) {
return events.reduce((counts, event) => {
const prevSum = counts.length ? counts[counts.length - 1] : 0;
counts.push(prevSum + countTokens(event));
return counts;
}, [] as number[]);
}
private get key() {
return "memory";
}
private printEvent(event: Event) {
let sourceName: string;
let targetNames: string[];
if (event.type === "message") {
const { message } = event;
sourceName = messageSourceName(message.source);
targetNames = message.targetAgentIds?.map(agentName);
} else {
sourceName = agentName(this.agentId);
targetNames = ["System"];
}
console.log(
`${sourceName} -> ${targetNames.join(", ")}:\n\n${
toOpenAiMessage(event).content
}\n\n=============\n`
);
}
}
function countTokens(event: Event) {
return countTokensInText(toOpenAiMessage(event).content);
}
| src/memory/memory.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " return sendMessage(\n messageBuilder.ok(agentId, \"Search returned no results.\")\n );\n }\n sendMessage(\n messageBuilder.ok(\n agentId,\n `Search results:\\n\\n${items\n .map((item) => `- Title: \"${item.title}\"\\n URL: ${item.link}`)\n .join(\"\\n\\n\")}`",
"score": 14.771089449892813
},
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " sendMessage(\n messageBuilder.ok(\n agentId,\n `These are the agents in the system:\\n\\n${allAgentIds\n .map((id) => `${agentName(id)} [agentId=${id}]`)\n .join(\"\\n\")}`\n )\n );\n },\n },",
"score": 13.38780497464684
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " .map(\n (chunk) =>\n `=== SUMMARIZED CHUNK (${countTokens(\n chunk\n )} tokens) ===\\n\\n${chunk}\\n\\n`\n )\n .join(\"\");\n // console.log(`Summary:\\n\\n${summary}\\n`);\n console.log(`Summary tokens: ${countTokens(summary)}`);\n await browser.close();",
"score": 10.896973021248868
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " messageBuilder.ok(agentId, `Content of \"${title}\":\\n\\n${content}`)\n );\n } else {\n sendMessage(\n messageBuilder.error(agentId, `Note \"${title}\" not found.`)\n );\n }\n },\n },\n deleteNote: {",
"score": 10.7278254227892
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " const files = await readdir(path);\n const filesWithStatsPromises = files.map(async (file) => {\n const stats = await stat(joinPath(path, file));\n return `${file} ${stats.isDirectory() ? \"[directory]\" : \"[file]\"}`;\n });\n const filesWithStats = await Promise.all(filesWithStatsPromises);\n sendMessage(\n messageBuilder.ok(\n agentId,\n `Here are the contents of ${path}:\\n${filesWithStats.join(\"\\n\")}`",
"score": 9.913291051215463
}
] | typescript | : messageBuilder.spontaneous(
this.agentId,
nestedEvents.flat().join("\n\n")
),
}; |
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": " 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": 52.256112405935504
},
{
"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": 51.964679024770724
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " });\n const payload = schema.parse(body);\n const uniqueNftIds = new Set<string>(payload.nftIds);\n if (uniqueNftIds.size !== 6) {\n return [StatusCodes.badRequest, { reason: 'nftIds must contain 6 unique NFT ids that belong to the player' }];\n }\n const player = await authProvider.getPlayerFromRequest(req);\n const deck = await ds.CardDecks.get(player.id, payload.deckId);\n if (!deck) {\n return [StatusCodes.notFound, { reason: 'invalid deck id' }];",
"score": 44.47926327831431
},
{
"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": 40.60442810557377
},
{
"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": 39.551299724514905
}
] | typescript | .addPlayer(game.id, player.id, deck.cards.map(x => x.nftId)); |
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
const gameData = await gameEngineProvider.getGameData(game.id);
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider.removePlayer(game.id, player.id, 'leave');
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
const rankings = await ds.Leaderboard.getTopN(20);
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort((a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
const gameData = await gameEngineProvider.startGame(game.id);
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game.gameState = `ended_${now.format(DATE_FORMAT)}`;
game.endedAt = now.format(FULL_DATETIME_FORMAT);
| let gameData: GameEngine.IGameData | undefined = undefined; |
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
await gameEngineProvider.endGame(game.id);
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
} | src/apis/coop.api.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const existingGameData = await ds.GameData.get(gameId);\n if (existingGameData) throw new Error('game with id already exists: ' + gameId);\n const gameData: GameEngine.IGameData = {\n id: gameId,\n difficulty: Math.max(1, difficulty),\n state: 'created',\n turn: 1,\n players: new Map(),\n defaultMovesPerTurn: 3,\n enemies: [],",
"score": 53.26208892219294
},
{
"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": 52.44222198715454
},
{
"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": 44.924556822202014
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " // Stop if the game was won/lost due to an EndTurn effect\n return;\n }\n engine.onTurnStart();\n }\n });\n }\n static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {\n let kickedPlayerId = '';\n await _Engine._withEngine(gameId, ['started'], async engine => {",
"score": 44.056715761499795
},
{
"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": 41.25798032037755
}
] | typescript | let gameData: GameEngine.IGameData | undefined = undefined; |
import { defineModule } from "../define-module";
import { messageBuilder } from "../../message";
import { agentName } from "../../util";
export default defineModule({
name: "messaging",
}).with({
actions: {
queryAgentRegistry: {
description: "Ask who the other agents are that you can talk to",
async execute({ context: { agentId, allAgentIds }, sendMessage }) {
sendMessage(
messageBuilder.ok(
agentId,
`These are the agents in the system:\n\n${allAgentIds
.map((id) => `${agentName(id)} [agentId=${id}]`)
.join("\n")}`
)
);
},
},
sendMessage: {
description: "Send a message to another agent",
parameters: {
targetAgentId: {
description: "The target agent's ID",
},
message: {
description: "The content of the message",
},
},
async execute({
parameters: { targetAgentId, message },
context: { agentId, allAgentIds },
sendMessage,
}) {
if (agentId === targetAgentId) {
return sendMessage(
messageBuilder | .error(
agentId,
"You can't send a message to yourself. Use the `writeNote` action if you want to make notes for yourself."
)
); |
}
if (allAgentIds.includes(targetAgentId)) {
sendMessage(
messageBuilder.agentToAgent(agentId, [targetAgentId], message)
);
} else {
sendMessage(
messageBuilder.error(
agentId,
`You tried to send your message to an invalid targetAgentId (${JSON.stringify(
targetAgentId
)}). You can use the 'queryAgentRegistry' action to see a list of available agents and their agent IDs.`
)
);
}
},
},
},
});
| src/module/definitions/messaging.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " const currentNotes = noteTitles.length\n ? `Here are your current notes:\\n\\n${noteTitles\n .map((title) => `- \"${title}\"`)\n .join(\"\\n\")}`\n : \"Your have no notes currently.\";\n return `\nYou can manage your notes using the \\`writeNote\\`, \\`viewNote\\` and \\`deleteNote\\` actions. Use notes to keep track of any important information that you come across that may be of longterm interest. Because notes contain content in addition to a title, you can store larger thoughts here which might not fit into the text of a goal. Your notes list will always be pinned to the top of your context and won't be summarized away.\n${currentNotes}\n`.trim();\n },",
"score": 23.388608825181397
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " path: {\n description: \"The path of the file you want to inspect\",\n },\n },\n async execute({\n parameters: { path },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;",
"score": 22.02499591815352
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " description: \"The path of the directory you want to inspect\",\n },\n },\n async execute({\n parameters: { path },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;\n try {",
"score": 22.02499591815352
},
{
"filename": "src/module/definitions/core.ts",
"retrieved_chunk": " if (!actionDef) {\n sendMessage(\n messageBuilder.error(\n agentId,\n `Unknown action \\`${aboutAction}\\`. Please refer to the list of available actions given in the introductory message.`\n )\n );\n } else {\n sendMessage(messageBuilder.ok(agentId, getUsageText(actionDef)));\n }",
"score": 21.125141541028032
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " {\n type: \"message\",\n message: messageBuilder.ok(\n this.agentId,\n `Write a summary in ${summaryWordLimit} words or less of what has happened since (but not including) the introductory message. Include key information that you learned which you don't want to forget. This information will serve as a note to yourself to help you understand what has gone before. Use the second person voice, as if you are someone filling in your replacement who knows nothing. The summarized messages will be omitted from your context window going forward and you will only have this summary to go by, so make it as useful and information-dense as possible. Be as specific as possible, but only include important information. If there are details that seem unimportant, or which you could recover outside of your memory (for instance the particular contents of a file which you could read any time), then omit them from your summary. Once again, your summary must not exceed ${summaryWordLimit} words. In this particular instance, your response should just be raw text, not formatted as an action.`\n ),\n },\n ]);\n const summary = `Several events are omitted here to free up space in your context window, summarized as follows:\\n\\n${summaryContent}`;\n // const summary =",
"score": 20.060617681088353
}
] | typescript | .error(
agentId,
"You can't send a message to yourself. Use the `writeNote` action if you want to make notes for yourself."
)
); |
import { google } from "googleapis";
import puppeteer from "puppeteer";
import TurndownService from "turndown";
import { messageBuilder } from "../../message";
import { Model, contextWindowSize, createChatCompletion } from "../../openai";
import { model } from "../../parameters";
import {
AVG_CHARACTERS_PER_TOKEN,
AVG_WORDS_PER_TOKEN,
countTokens,
} from "../../util";
import { defineModule } from "../define-module";
export default defineModule({
name: "web",
}).with({
actions: {
searchWeb: {
description: "Search the web.",
parameters: {
searchString: {
description: "The string to search for",
},
},
async execute({
parameters: { searchString },
context: { agentId },
sendMessage,
}) {
const items = await getSearchResults(searchString);
if (!items) {
return sendMessage(
messageBuilder.ok(agentId, "Search returned no results.")
);
}
sendMessage(
messageBuilder.ok(
agentId,
`Search results:\n\n${items
.map((item) => `- Title: "${item.title}"\n URL: ${item.link}`)
.join("\n\n")}`
)
);
},
},
readPage: {
description: "View a markdown summary of a web page.",
parameters: {
url: {
description: "The URL of the web page to read",
},
},
async execute({
parameters: { url },
context: { agentId },
sendMessage,
}) {
try {
const maxCompletionTokens = contextWindowSize[model] / 4;
// console.log({ maxCompletionTokens });
const pageSummary = await getPageSummary(
model,
maxCompletionTokens,
url
);
sendMessage(
messageBuilder.ok(
agentId,
`Here is a summarized markdown version of the page, in a series of summarized chunks:\n\n${pageSummary}`
)
);
} catch (e: any) {
sendMessage(
| messageBuilder.error(
agentId,
`Error extracting content from ${url}: ${e.message}`
)
); |
}
},
},
},
});
export async function getSearchResults(searchString: string) {
const { data } = await google.customsearch("v1").cse.list({
q: searchString,
cx: process.env.GOOGLE_SEARCH_ENGINE_ID,
key: process.env.GOOGLE_API_KEY,
});
return data.items;
}
export async function getPageSummary(
model: Model,
maxSummaryTokens: number,
url: string
) {
const maxCompletionTokens = Math.round(contextWindowSize[model] * 0.9);
console.log("Initializing...");
const browser = await puppeteer.launch();
const page = await browser.newPage();
const turndownService = new TurndownService().addRule(
"remove-extraneous-tags",
{
filter: ["style", "script", "img"],
replacement: () => "",
}
);
console.log(`Reading page at ${url}...`);
await page.goto(url);
const htmlContent = await page.content();
// console.log(htmlContent);
console.log(`HTML tokens: ${countTokens(htmlContent)}`);
turndownService.remove(["style", "script"]);
const markdownContent = turndownService
.turndown(htmlContent)
.replace(/\\_/g, "_");
const markdownTokens = countTokens(markdownContent);
console.log(`Markdown tokens: ${markdownTokens}`);
const chunks: string[] = [];
let currentChunkLines: string[] = [];
let currentChunkTokens = 0;
for (const line of markdownContent.split("\n")) {
const lineTokens = countTokens(line);
if (currentChunkTokens + lineTokens > maxCompletionTokens) {
chunks.push(currentChunkLines.join("\n"));
currentChunkLines = [];
currentChunkTokens = 0;
}
currentChunkLines.push(line);
currentChunkTokens += lineTokens;
}
let lastChunk = currentChunkLines.join("\n");
if (countTokens(lastChunk) > maxCompletionTokens) {
const characterLimit = Math.round(
maxCompletionTokens * AVG_CHARACTERS_PER_TOKEN
);
console.log(
`Truncating final chunk at ${characterLimit} characters:\n\n${lastChunk}`
);
lastChunk = lastChunk.substring(0, characterLimit);
}
chunks.push(lastChunk);
// console.log(
// chunks
// .map((chunk) => `CHUNK (${countTokens(chunk)}):\n\n${chunk}\n\n`)
// .join("")
// );
console.log(
`Total chunks: ${chunks.length} (${Math.round(
markdownTokens / chunks.length
)} tokens per chunk)`
);
const maxChunkSummaryTokens = Math.round(maxSummaryTokens / chunks.length);
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const maxChunkSummaryWords = Math.round(
maxChunkSummaryTokens * AVG_WORDS_PER_TOKEN
);
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const maxChunkSummaryCharacters = Math.round(
maxChunkSummaryTokens * AVG_CHARACTERS_PER_TOKEN
);
// const summaryLimitText = `${maxChunkSummaryWords} words`;
const chunkSummaryLimitText = `${maxChunkSummaryCharacters} characters`;
console.log(
`Max tokens per chunk summary: ${maxChunkSummaryTokens} (${chunkSummaryLimitText})`
);
console.log("Summarizing chunks...");
const summarizedChunks = await Promise.all(
chunks.map(async (chunk) =>
createChatCompletion({
model,
messages: [
{
role: "user",
content: `Modify the following markdown excerpt only as much as necessary to bring it under a maximum of ${chunkSummaryLimitText}, preserving the most essential information. In particular, try to preserve links (example: \`[my special link](https://foo.bar/baz/)\`). Write this in the same voice as the original text; do not speak in the voice of someone who is describing it to someone else. For instance, don't use phrases like "The article talks about...". Excerpt to summarize follows:\n\n=============\n\n${chunk}`,
},
],
})
)
);
const summary = summarizedChunks
.map(
(chunk) =>
`=== SUMMARIZED CHUNK (${countTokens(
chunk
)} tokens) ===\n\n${chunk}\n\n`
)
.join("");
// console.log(`Summary:\n\n${summary}\n`);
console.log(`Summary tokens: ${countTokens(summary)}`);
await browser.close();
return summary;
}
| src/module/definitions/web.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " const currentNotes = noteTitles.length\n ? `Here are your current notes:\\n\\n${noteTitles\n .map((title) => `- \"${title}\"`)\n .join(\"\\n\")}`\n : \"Your have no notes currently.\";\n return `\nYou can manage your notes using the \\`writeNote\\`, \\`viewNote\\` and \\`deleteNote\\` actions. Use notes to keep track of any important information that you come across that may be of longterm interest. Because notes contain content in addition to a title, you can store larger thoughts here which might not fit into the text of a goal. Your notes list will always be pinned to the top of your context and won't be summarized away.\n${currentNotes}\n`.trim();\n },",
"score": 22.42965858050454
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " messageBuilder.ok(agentId, `Content of \"${title}\":\\n\\n${content}`)\n );\n } else {\n sendMessage(\n messageBuilder.error(agentId, `Note \"${title}\" not found.`)\n );\n }\n },\n },\n deleteNote: {",
"score": 20.732021059803067
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " try {\n const data = await readFile(path, \"utf8\");\n sendMessage(\n messageBuilder.ok(agentId, `Contents of ${path}:\\n\\n${data}`)\n );\n } catch (err) {\n sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));\n }\n },\n },",
"score": 20.289051818015256
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " extraProps.length > 1 ? \"s\" : \"\"\n } ${extraProps.map((p) => `\\`${p}\\``)}. ${getUsageText(actionDef)}`,\n };\n }\n return { type: \"success\", action: { actionDef, thoughts, parameters } };\n } catch (e: any) {\n return {\n type: \"error\",\n message: e.message,\n };",
"score": 19.17651919200453
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " )\n );\n } catch (err) {\n sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));\n }\n },\n },\n readFile: {\n description: \"Read the contents of a particular file\",\n parameters: {",
"score": 18.71314708544345
}
] | typescript | messageBuilder.error(
agentId,
`Error extracting content from ${url}: ${e.message}`
)
); |
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": " 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": 89.92244922104274
},
{
"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": 68.96531542624359
},
{
"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": 63.719093739928965
},
{
"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": 62.09859336794018
},
{
"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": 59.464800827517415
}
] | typescript | return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }]; |
import express from "express";
import { verify } from "jsonwebtoken";
import { requireAuth } from "../../middleware/auth";
import Tweet from "../../models/Tweet";
import User from "../../models/User";
import {
ICreateTweetBody,
IGenericFeatures,
IJwtDecoded,
} from "../../types/graphql";
import { IUser } from "../../types/guide";
import { formatDate } from "../../util/formatDate";
import { log } from "../../util/logging";
import { randInt } from "../../util/randUtil";
import { IUserMention } from "./user";
import { addNotification } from "../../util/notifications";
interface IUserTweetsVariables {
userId: string;
count: number;
includePromotedContent: boolean;
withQuickPromoteEligibilityTweetFields: boolean;
withVoice: boolean;
withV2Timeline: boolean;
}
interface IFavouriteTweetVariables {
tweet_id: string;
}
export async function UserTweets(req: express.Request, res: express.Response) {
const loggedInUser = req.cookies["jwt"]
? await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id,
})
: undefined;
const features = JSON.parse(
req.query.features!.toString()
) as IGenericFeatures;
const variables = JSON.parse(
req.query.variables!.toString()
) as IUserTweetsVariables;
if (!features || !variables)
return res.status(400).send({ msg: "Missing parameters" });
const user = await User.findOne({ id: variables.userId });
if (!user) return res.status(400).send({ msg: "User not found" });
const userTweets = [];
const postedTweets = Array.from(user.posted_tweet_ids);
for (const id of postedTweets) {
const tweet = await Tweet.findOne({ id_str: id });
userTweets.push({
is_translatable: false,
legacy: tweet
? Object.assign(tweet, {
favorited: loggedInUser
? loggedInUser.liked_tweet_ids.includes(tweet.id_str || "")
: false,
})
: tweet,
source: tweet?.source,
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
});
}
return res.status(200).send({
data: {
user: {
result: {
__typename: "User",
timeline_v2: {
timeline: {
instructions: [
{
type: "TimelineClearCache",
},
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified:
user.ext_is_blue_verified,
legacy: {
...(user as any)._doc,
},
profile_image_shape:
user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
},
},
});
}
export async function HomeTimeline(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const userId = req.cookies["jwt"]
? ((verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded)
.id as number)
: undefined;
const loggedInUser = await User.findOne({
id_string: userId,
});
if (!loggedInUser) return res.status(400).send({ msg: "Not authenticated" });
const userTweets = [];
const postedTweets = await Tweet.find().limit(50);
for (const tweet of postedTweets) {
const user = await User.findOne({ id_string: tweet.user_id_str });
if (!user) return res.status(400).send({ msg: "User not found" });
userTweets.push({
is_translatable: false,
legacy: Object.assign(tweet, {
favorited: loggedInUser.liked_tweet_ids.includes(tweet.id_str || ""),
}),
unmention_data: {},
unmention_info: {},
views: tweet.ext_views,
user: user,
});
}
return res.status(200).send({
data: {
home: {
home_timeline_urt: {
instructions: [
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
tweet.user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: tweet.user._id,
is_blue_verified:
tweet.user.ext_is_blue_verified,
legacy: {
...(tweet.user as any)._doc,
entities: {
user_mentions: (
tweet.legacy.entities
?.user_mentions as IUserMention[]
).map((mention) => {
return {
a: true,
};
}),
},
},
profile_image_shape:
tweet.user.ext_profile_image_shape,
rest_id: tweet.user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.legacy.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
});
}
export async function FavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (!user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids.push(variables.tweet_id);
tweet.favorite_count! += 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { favourte_tweet: "NOT DONE" } });
}
if (tweet.user_id_str !== user.id_string)
addNotification(
"%1 liked your tweet!",
"like",
tweet.user_id_str!,
user.id_string!,
tweet.id_str!
);
return res.status(200).send({ data: { favorite_tweet: "Done" } });
}
export async function UnfavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids = user.liked_tweet_ids.filter(
(id) => id !== variables.tweet_id
);
tweet.favorite_count! -= 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { unfavorite_tweet: "NOT DONE" } });
}
return res.status(200).send({ data: { unfavorite_tweet: "Done" } });
}
export async function CreateTweet(req: express.Request, res: express.Response) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const body = req.body as ICreateTweetBody;
const id = (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id as number;
const user = await User.findOne({ id });
if (!user) return res.status(400).send({ msg: "User not found" });
const user_mentions = [] as IUserMention[];
const matches = body.variables.tweet_text.matchAll(/@(\S+)/gm);
for (const match of matches) {
const withTag = match[0];
const withoutTag = match[1];
const user = await User.findOne({ screen_name: withoutTag });
user_mentions.push({
id_str: user?.id_string,
name: user?.name,
screen_name: user?.screen_name,
indices: [match.index, withTag.length + (match.index || 0)],
});
}
const tweetId = randInt(12);
const tweetData = {
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at | : formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: { |
hashtags: [],
symbols: [],
urls: [],
user_mentions,
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id: tweetId,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
source:
'<a href="https://mobile.twitter.com" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
};
const tweet = new Tweet({
bookmark_count: tweetData.legacy.bookmark_count,
bookmarked: tweetData.legacy.bookmarked,
conversation_id_str: tweetData.legacy.conversation_id_str,
created_at: tweetData.legacy.created_at,
display_text_range: tweetData.legacy.display_text_range,
entities: {
hashtags: tweetData.legacy.entities.hashtags,
symbols: tweetData.legacy.entities.symbols,
urls: tweetData.legacy.entities.urls,
user_mentions,
},
favorite_count: tweetData.legacy.favorite_count,
favorited: tweetData.legacy.favorited,
full_text: tweetData.legacy.full_text,
id_str: tweetData.legacy.id_str,
is_quote_status: tweetData.legacy.is_quote_status,
lang: tweetData.legacy.lang,
quote_count: tweetData.legacy.quote_count,
reply_count: tweetData.legacy.reply_count,
retweet_count: tweetData.legacy.retweet_count,
retweeted: tweetData.legacy.retweeted,
user_id_str: tweetData.legacy.user_id_str,
});
await tweet.save();
user.posted_tweet_ids.push(tweetId.toString());
await user.save();
log(`${user.name} (@${user.screen_name}) just posted a tweet:`);
log(`"${tweet.full_text}"`);
// addNotification(
// "%1 just posted a tweet!",
// "reply",
// user.id_string!,
// user.id_string!,
// tweet.id_str!
// );
return res.status(200).send({
// data: {
// create_tweet: {
// tweet_results: {
// result: {
// core: {
// user_results: {
// result: {
// __typename: "User",
// affiliates_highlighted_label:
// user.ext?.highlightedLabel?.r?.ok,
// business_account: {},
// id: user._id,
// is_blue_verified: user.ext_is_blue_verified,
// legacy: {
// created_at: user.created_at,
// default_profile: user.default_profile,
// default_profile_image: user.default_profile_image,
// description: user.description,
// entities: user.entities,
// fast_followers_count: user.fast_followers_count,
// favourites_count: user.favourites_count,
// followers_count: user.followers_count,
// friends_count: user.friends_count,
// has_custom_timelines: user.has_custom_timelines,
// is_translator: user.is_translator,
// listed_count: user.listed_count,
// location: user.location,
// media_count: user.media_count,
// name: user.name,
// normal_followers_count: user.normal_followers_count,
// pinned_tweet_ids_str: user.pinned_tweet_ids_str,
// possibly_sensitive: false,
// profile_image_url_https: user.profile_image_url_https,
// profile_interstitial_type: "",
// screen_name: user.screen_name,
// statuses_count: user.statuses_count,
// translator_type: user.translator_type,
// verified: user.verified,
// withheld_in_countries: user.withheld_in_countries,
// },
// profile_image_shape: user.ext_profile_image_shape,
// rest_id: user.id,
// },
// },
// },
// ...tweetData,
// },
// },
// },
// },
data: {
create_tweet: {
tweet_results: {
result: {
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified: user.ext_is_blue_verified,
legacy: {
created_at: user.created_at,
default_profile: user.default_profile,
default_profile_image: user.default_profile_image,
description: user.description,
entities: user.entities,
fast_followers_count: user.fast_followers_count,
favourites_count: user.favourites_count,
followers_count: user.followers_count,
friends_count: user.friends_count,
has_custom_timelines: user.has_custom_timelines,
is_translator: user.is_translator,
listed_count: user.listed_count,
location: user.location,
media_count: user.media_count,
name: user.name,
normal_followers_count: user.normal_followers_count,
pinned_tweet_ids_str: user.pinned_tweet_ids_str,
possibly_sensitive: false,
profile_image_url_https: user.profile_image_url_https,
profile_interstitial_type: "",
screen_name: user.screen_name,
statuses_count: user.statuses_count,
translator_type: user.translator_type,
verified: user.verified,
withheld_in_countries: user.withheld_in_countries,
},
profile_image_shape: user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_control: {
edit_tweet_ids: [tweetId.toString()],
editable_until_msecs: "1682984834000",
edits_remaining: "5",
is_edit_eligible: true,
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, 68],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions: (
tweet.entities!.user_mentions as Array<Array<IUserMention>>
).map((mention) => mention[0]),
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
rest_id: tweetId.toString(),
source:
'<a href="https://github.com/" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Disabled",
},
},
},
},
},
});
}
| src/routes/gql/tweet.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/models/Tweet.ts",
"retrieved_chunk": "import mongoose from \"mongoose\";\nconst tweet = new mongoose.Schema({\n\tbookmark_count: {\n\t\ttype: \"Number\",\n\t},\n\tbookmarked: {\n\t\ttype: \"Boolean\",\n\t},\n\tconversation_id_str: {\n\t\ttype: \"String\",",
"score": 24.175562446239386
},
{
"filename": "src/models/Tweet.ts",
"retrieved_chunk": "\t},\n\tcreated_at: {\n\t\ttype: \"String\",\n\t},\n\tdisplay_text_range: {\n\t\ttype: [\"Number\"],\n\t},\n\tentities: {\n\t\thashtags: {\n\t\t\ttype: \"Array\",",
"score": 19.45210592412102
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\t\t\tvalue: false,\n\t\t\t\t\t},\n\t\t\t\t\tresponsive_web_settings_timeline_polling_enabled: {\n\t\t\t\t\t\tvalue: false,\n\t\t\t\t\t},\n\t\t\t\t\tresponsive_web_settings_timeline_polling_interval_ms: {\n\t\t\t\t\t\tvalue: 0,\n\t\t\t\t\t},\n\t\t\t\t\tresponsive_web_settings_timeline_refresh_background_interval: {\n\t\t\t\t\t\tvalue: 0,",
"score": 16.381685489855304
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\thighContrastEnabled: false,\n\t\t\t\tloginPromptLastShown: 0,\n\t\t\t\treducedMotionEnabled: false,\n\t\t\t\tshowTweetMediaDetailDrawer: true,\n\t\t\t\tautoPollNewTweets: false,\n\t\t\t\tshouldAutoTagLocation: false,\n\t\t\t\tundoPreview: {},\n\t\t\t\treplyVotingSurveyClicked: 0,\n\t\t\t\tpushNotificationsPermission: null,\n\t\t\t},",
"score": 15.796159981732377
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\t\t\tfavourites_count: user.favourites_count || 0,\n\t\t\t\t\t\tfollowers_count: user.followers_count || 0,\n\t\t\t\t\t\tfriends_count: user.friends_count || 0,\n\t\t\t\t\t\thas_custom_timelines: user.has_custom_timelines || false,\n\t\t\t\t\t\tis_translator: user.is_translator || false,\n\t\t\t\t\t\tlisted_count: user.listed_count || 0,\n\t\t\t\t\t\tlocation: user.location || \"\",\n\t\t\t\t\t\tmedia_count: user.media_count || 0,\n\t\t\t\t\t\tname: user.name || \"\",\n\t\t\t\t\t\tneeds_phone_verification: false,",
"score": 15.579762853778753
}
] | typescript | : formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: { |
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/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": 64.6198434274757
},
{
"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": 52.99225579182215
},
{
"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": 49.405638290683925
},
{
"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": 47.84409373873127
},
{
"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": 44.222973216719225
}
] | typescript | if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id'); |
import core from "./module/definitions/core";
import filesystem from "./module/definitions/filesystem";
import messaging from "./module/definitions/messaging";
import notes from "./module/definitions/notes";
import { ModuleManager } from "./module/module-manager";
import { getUsageText } from "./module/util";
import parseAction, { Action } from "./parse-action";
import { MULTILINE_DELIMITER } from "./util";
const moduleManager = new ModuleManager(
"1",
["1"],
[core, notes, messaging, filesystem]
);
test("case 1", () => {
assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
Hello Control, this is Agent 1.
I am sending you a multi-line message.
This is another line.
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("case 2", () => {
assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
Hello Control, this is Agent 1.
Here is a multi-line message:
This is the first line.
This is the second line.
This is the third line.
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("case 3", () => {
assertValid(`
writeFile
path: ./schema/action-dictionary.json
content:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
{
"$schema": "http://json-schema.org/draft-07/schema#",
"type": "object",
"title": "Action",
"oneOf": [
{
... the old content of action-dictionary.json ...
},
{
"title": "NewActionDefinition",
"description": "This is an example of a new action definition.",
"properties": {
"type": {
"type": "string",
"const": "new-action-definition"
},
"exampleArg": {
"type": "string",
"description": "An example parameter for the new action definition."
}
},
"required": [
"type",
"exampleArg"
],
"additionalProperties": false
}
]
}
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("invalid multiline with no delimiter", () => {
expect(
assertInvalid(`
sendMessage
targetAgentId: 0
message: Hello Control, here's a list of things,
- 9 bottles of ketchup
- 2 pairs of socks
- a very big balloon
`)
).toEqual(
`Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\`% ff9d7713-0bb0-40d4-823c-5a66de48761b\`)?`
);
});
test("multiline delimiter not starting on its own line", () => {
expect(
assertValid(`
sendMessage
targetAgentId: 0
message: % ff9d7713-0bb0-40d4-823c-5a66de48761b
here is a
multi
line
message
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`).parameters.message
).toBe(
`
here is a
multi
line
message
`.trim()
);
});
test("parameter after multiline parameter", () => {
const { parameters, thoughts } = assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
multi
line
parameter
% ff9d7713-0bb0-40d4-823c-5a66de48761b
thoughts: Trying a multi-line parameter followed by another parameter.
`);
expect(parameters.message).toBe(
`
multi
line
parameter
`.trim()
);
expect(thoughts).toBe(
"Trying a multi-line parameter followed by another parameter."
);
});
test("invalid command name", () => {
expect(assertInvalid("foo")).toBe(
"Unknown action `foo`. Please refer to the list of available actions given in the introductory message."
);
});
test("invalid raw text", () => {
expect(assertInvalid("Hello Control, how are you doing?")).toEqual(
`
Your action could not be parsed. Remember to always format your entire response as an action, like this:
\`\`\`
<action name>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
\`\`\`
`.trim()
);
});
test("missing required parameter", () => {
expect(assertInvalid("sendMessage\ntargetAgentId: 0")).toBe(
`Missing required parameter \` | message\`. ${getUsageText(
messaging.actions.sendMessage
)}`
); |
});
test("extra parameter", () => {
expect(assertInvalid("noop\nfoo: bar")).toEqual(
`Extraneous parameter \`foo\`. ${getUsageText(core.actions.noop)}`
);
});
describe("quotes", () => {
test("in-line parameter", () => {
const action = assertValid(`
sendMessage
targetAgentId: 0
message: hello, "control"
`);
expect(action.actionDef.name).toBe("sendMessage");
expect(action.parameters).toEqual({
targetAgentId: "0",
message: 'hello, "control"',
});
});
test("multi-line parameter", () => {
const action = assertValid(`
sendMessage
targetAgentId: 0
message:
${MULTILINE_DELIMITER}
hello, "control"
${MULTILINE_DELIMITER}
`);
expect(action.actionDef.name).toBe("sendMessage");
expect(action.parameters).toEqual({
targetAgentId: "0",
message: 'hello, "control"',
});
});
});
// =============================================================================
function assertValid(text: string): Action {
const result = parseAction(moduleManager.actions, text);
if (result.type === "error") throw Error(`Parse failed: ${result.message}`);
return result.action;
}
function assertInvalid(text: string): string {
const result = parseAction(moduleManager.actions, text);
if (result.type === "success")
throw Error(
`Parse succeeded when it should've failed: ${JSON.stringify(
result.action,
null,
2
)}`
);
return result.message;
}
| src/parse-action.test.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " .filter(\n ([name, parameterDef]) =>\n !parameterDef.optional && !(name in parameters)\n )\n .map(([name]) => name);\n if (missingProps.length) {\n return {\n type: \"error\",\n message: `Missing required parameter${\n missingProps.length > 1 ? \"s\" : \"\"",
"score": 24.37001302870754
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " } ${missingProps.map((p) => `\\`${p}\\``)}. ${getUsageText(actionDef)}`,\n };\n }\n const extraProps = Object.keys(parameters).filter(\n (p) => !(p in actionDef.parameters)\n );\n if (extraProps.length) {\n return {\n type: \"error\",\n message: `Extraneous parameter${",
"score": 11.78198278155932
},
{
"filename": "src/module/define-module.ts",
"retrieved_chunk": " name,\n parameters: mapValues(parameters, (parameter) => ({\n optional: false,\n ...parameter,\n })),\n ...definition,\n },\n ]\n )\n ) as any,",
"score": 11.628821972259315
},
{
"filename": "src/module/definitions/core.ts",
"retrieved_chunk": " if (!actionDef) {\n sendMessage(\n messageBuilder.error(\n agentId,\n `Unknown action \\`${aboutAction}\\`. Please refer to the list of available actions given in the introductory message.`\n )\n );\n } else {\n sendMessage(messageBuilder.ok(agentId, getUsageText(actionDef)));\n }",
"score": 10.693305147960434
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " if (colonIndex < 0)\n throw new Error(\n `Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\\`${MULTILINE_DELIMITER}\\`)?`\n );\n const key = line.substring(0, colonIndex).trim();\n let value = line.substring(colonIndex + 1).trim();\n if (!value.startsWith('\"') || !value.endsWith('\"'))\n value = JSON.stringify(value);\n return `\"${key}\": ${value}`;\n })",
"score": 10.457004970973536
}
] | typescript | message\`. ${getUsageText(
messaging.actions.sendMessage
)}`
); |
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 { google } from "googleapis";
import puppeteer from "puppeteer";
import TurndownService from "turndown";
import { messageBuilder } from "../../message";
import { Model, contextWindowSize, createChatCompletion } from "../../openai";
import { model } from "../../parameters";
import {
AVG_CHARACTERS_PER_TOKEN,
AVG_WORDS_PER_TOKEN,
countTokens,
} from "../../util";
import { defineModule } from "../define-module";
export default defineModule({
name: "web",
}).with({
actions: {
searchWeb: {
description: "Search the web.",
parameters: {
searchString: {
description: "The string to search for",
},
},
async execute({
parameters: { searchString },
context: { agentId },
sendMessage,
}) {
const items = await getSearchResults(searchString);
if (!items) {
return sendMessage(
messageBuilder.ok(agentId, "Search returned no results.")
);
}
sendMessage(
messageBuilder.ok(
agentId,
`Search results:\n\n${items
.map((item) => `- Title: "${item.title}"\n URL: ${item.link}`)
.join("\n\n")}`
)
);
},
},
readPage: {
description: "View a markdown summary of a web page.",
parameters: {
url: {
description: "The URL of the web page to read",
},
},
async execute({
parameters: { url },
context: { agentId },
sendMessage,
}) {
try {
const maxCompletionTokens = contextWindowSize[model] / 4;
// console.log({ maxCompletionTokens });
const pageSummary = await getPageSummary(
model,
maxCompletionTokens,
url
);
sendMessage(
messageBuilder.ok(
agentId,
`Here is a summarized markdown version of the page, in a series of summarized chunks:\n\n${pageSummary}`
)
);
} catch (e: any) {
sendMessage(
messageBuilder.error(
agentId,
`Error extracting content from ${url}: ${e.message}`
)
);
}
},
},
},
});
export async function getSearchResults(searchString: string) {
const { data } = await google.customsearch("v1").cse.list({
q: searchString,
cx: process.env.GOOGLE_SEARCH_ENGINE_ID,
key: process.env.GOOGLE_API_KEY,
});
return data.items;
}
export async function getPageSummary(
model: Model,
maxSummaryTokens: number,
url: string
) {
| const maxCompletionTokens = Math.round(contextWindowSize[model] * 0.9); |
console.log("Initializing...");
const browser = await puppeteer.launch();
const page = await browser.newPage();
const turndownService = new TurndownService().addRule(
"remove-extraneous-tags",
{
filter: ["style", "script", "img"],
replacement: () => "",
}
);
console.log(`Reading page at ${url}...`);
await page.goto(url);
const htmlContent = await page.content();
// console.log(htmlContent);
console.log(`HTML tokens: ${countTokens(htmlContent)}`);
turndownService.remove(["style", "script"]);
const markdownContent = turndownService
.turndown(htmlContent)
.replace(/\\_/g, "_");
const markdownTokens = countTokens(markdownContent);
console.log(`Markdown tokens: ${markdownTokens}`);
const chunks: string[] = [];
let currentChunkLines: string[] = [];
let currentChunkTokens = 0;
for (const line of markdownContent.split("\n")) {
const lineTokens = countTokens(line);
if (currentChunkTokens + lineTokens > maxCompletionTokens) {
chunks.push(currentChunkLines.join("\n"));
currentChunkLines = [];
currentChunkTokens = 0;
}
currentChunkLines.push(line);
currentChunkTokens += lineTokens;
}
let lastChunk = currentChunkLines.join("\n");
if (countTokens(lastChunk) > maxCompletionTokens) {
const characterLimit = Math.round(
maxCompletionTokens * AVG_CHARACTERS_PER_TOKEN
);
console.log(
`Truncating final chunk at ${characterLimit} characters:\n\n${lastChunk}`
);
lastChunk = lastChunk.substring(0, characterLimit);
}
chunks.push(lastChunk);
// console.log(
// chunks
// .map((chunk) => `CHUNK (${countTokens(chunk)}):\n\n${chunk}\n\n`)
// .join("")
// );
console.log(
`Total chunks: ${chunks.length} (${Math.round(
markdownTokens / chunks.length
)} tokens per chunk)`
);
const maxChunkSummaryTokens = Math.round(maxSummaryTokens / chunks.length);
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const maxChunkSummaryWords = Math.round(
maxChunkSummaryTokens * AVG_WORDS_PER_TOKEN
);
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const maxChunkSummaryCharacters = Math.round(
maxChunkSummaryTokens * AVG_CHARACTERS_PER_TOKEN
);
// const summaryLimitText = `${maxChunkSummaryWords} words`;
const chunkSummaryLimitText = `${maxChunkSummaryCharacters} characters`;
console.log(
`Max tokens per chunk summary: ${maxChunkSummaryTokens} (${chunkSummaryLimitText})`
);
console.log("Summarizing chunks...");
const summarizedChunks = await Promise.all(
chunks.map(async (chunk) =>
createChatCompletion({
model,
messages: [
{
role: "user",
content: `Modify the following markdown excerpt only as much as necessary to bring it under a maximum of ${chunkSummaryLimitText}, preserving the most essential information. In particular, try to preserve links (example: \`[my special link](https://foo.bar/baz/)\`). Write this in the same voice as the original text; do not speak in the voice of someone who is describing it to someone else. For instance, don't use phrases like "The article talks about...". Excerpt to summarize follows:\n\n=============\n\n${chunk}`,
},
],
})
)
);
const summary = summarizedChunks
.map(
(chunk) =>
`=== SUMMARIZED CHUNK (${countTokens(
chunk
)} tokens) ===\n\n${chunk}\n\n`
)
.join("");
// console.log(`Summary:\n\n${summary}\n`);
console.log(`Summary tokens: ${countTokens(summary)}`);
await browser.close();
return summary;
}
| src/module/definitions/web.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/main.ts",
"retrieved_chunk": " const store = new JsonStore<Event[]>(new FileStore([id]));\n // We have to leave room for the agent's next action, which is of unknown size\n const compressionThreshold = Math.round(contextWindowSize[model] * 0.75);\n const memory = new Memory(id, moduleManager, store, compressionThreshold);\n const agent = new Agent(\n id,\n memory,\n messageBus,\n moduleManager,\n actionHandler",
"score": 17.82409462150303
},
{
"filename": "src/parameters.ts",
"retrieved_chunk": "import { GPT_3_5_TURBO, GPT_4, Model } from \"./openai\";\nconst args = process.argv.slice(2); // Remove the first two elements (Node.js executable and script path)\nexport const numberOfAgents = args.length > 0 ? parseInt(args[0]) : 1;\nconsole.log(`Number of agents: ${numberOfAgents}`);\nconst modelText = args.length > 1 ? args[1] : \"gpt-3.5-turbo\";\nexport let model: Model;\nswitch (modelText) {\n case GPT_3_5_TURBO:\n case GPT_4:\n model = modelText;",
"score": 17.721527386793035
},
{
"filename": "src/parameters.ts",
"retrieved_chunk": " break;\n default:\n throw Error(`Unrecognized OpenAI model: '${modelText}'`);\n}\nconsole.log(`Model: ${model}`);",
"score": 16.70505230572456
},
{
"filename": "src/agent.ts",
"retrieved_chunk": " if (process.env.AGENT_DELAY) {\n await sleep(parseInt(process.env.AGENT_DELAY));\n }\n }\n }\n}",
"score": 13.82446481681465
},
{
"filename": "src/openai.ts",
"retrieved_chunk": "}\n// lazy load to avoid accessing OPENAI_API_KEY before env has been loaded\nconst openai = memoize(() => {\n const apiKey = process.env.OPENAI_API_KEY;\n if (!apiKey) throw Error(\"OPENAI_API_KEY is not configured!\");\n const configuration = new Configuration({\n apiKey: process.env.OPENAI_API_KEY,\n });\n return new OpenAIApi(configuration);\n});",
"score": 12.713912477319104
}
] | typescript | const maxCompletionTokens = Math.round(contextWindowSize[model] * 0.9); |
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export abstract class CardMod {
duration = -1;
stackingConfig: Parameters<typeof CardMod['makeStackingData']>[0] = { behavior: CardMod.StackingBehavior.neverReplace };
readonly modName: string;
constructor(
private _extraModData?: IArguments,
) {
this.modName = this.constructor.name;
}
onSecDamageIn?(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState): { secDmgBonus: number } | void;
onSecDamageOut?(deps: CardMod.ICardModDeps, baseDmg: number): { secDmgBonus: number } | void;
onMemDmgIn?(deps: CardMod.ICardModDeps, memDmg: number): void;
onMemDmgOut?(deps: CardMod.ICardModDeps, memDmg: number): void;
onInitMod?(deps: CardMod.ICardModDeps): void;
onRemoveMod?(deps: CardMod.ICardModDeps): void;
onCardDestroyed?(deps: CardMod.ICardModDeps): void;
onStackMod?(deps: CardMod.ICardModDeps, stackDelta: number): void;
onTurnStart?(deps: CardMod.ICardModDeps): void;
onTurnEnd?(deps: CardMod.ICardModDeps): void;
onEnemyDestroyed?(deps: CardMod.ICardModDeps): void;
serialize() {
const stackingData = CardMod.makeStackingData(this.stackingConfig);
const modData = [this.modName, stackingData] as CardMod.ModData;
(this.duration >= 0) && (modData.push(CardMod.makeDurationData(this.duration)));
this._extraModData && modData.push(...this._extraModData);
return modData;
}
static addMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, mod: CardMod, contextCard?: GameEngine.ICardState) {
const modData = mod.serialize();
switch (mod.stackingConfig.behavior) {
case CardMod.StackingBehavior.append: {
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.neverReplace: {
| const existingModData = card.mods.find(x => x[0] === mod.modName); |
if (existingModData) return;
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.ranked: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
if (existingStackingData[2] >= mod.stackingConfig.rank) {
return;
}
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.replace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.stack: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
existingStackingData && (existingStackingData[2] += mod.stackingConfig.stackCount);
engine.broadcast.push({
type: 'modStackChanged',
cardId: card.id,
modData: existingModData,
stackDelta: mod.stackingConfig.stackCount,
newStackCount: existingStackingData[2],
});
this.trigger('onStackMod', existingModData, { engine, sourceCard: card, contextCard }, mod.stackingConfig.stackCount);
return;
}
card.mods.push(modData);
break;
}
}
engine.broadcast.push({
type: 'modAdded',
cardId: card.id,
modData,
});
this.trigger('onInitMod', modData, { engine, sourceCard: card, contextCard });
}
static areEqual(left: CardMod.ModData, right: CardMod.ModData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, modData: CardMod.ModData) {
const modCtor = engine.ruleset.cardMods?.[modData[0]];
if (!modCtor) throw new Error('mod not found: ' + modData.join());
const durationData = this.findDurationData(modData);
const mod = new modCtor(...modData.slice(durationData ? 3 : 2));
durationData && (mod.duration = durationData[1]);
const stackingData = modData[1];
mod.stackingConfig.behavior = stackingData[1];
switch (stackingData[1]) {
case CardMod.StackingBehavior.ranked:
(mod.stackingConfig as any).rank = stackingData[2];
break;
case CardMod.StackingBehavior.stack:
(mod.stackingConfig as any).stackCount = stackingData[2];
break;
}
return mod;
}
static findDurationData(modData: CardMod.ModData) {
const maybeDurationData = modData[2];
return (Array.isArray(maybeDurationData) && maybeDurationData[0] === '$duration') ? (modData[2] as CardMod.DurationData) : undefined;
}
static findModOfType(card: GameEngine.ICardState, modType: CardMod.ModConstructor) {
return card.mods.find(x => x[0] === modType.name);
}
static getStackCount(modData: CardMod.ModData) {
return modData[1][1] === CardMod.StackingBehavior.stack ? modData[1][2] : 0;
}
static makeDurationData(duration: number): CardMod.DurationData {
return ['$duration', duration];
}
static makeStackingData(
stackConfig: { behavior: CardMod.StackingBehavior.append }
| { behavior: CardMod.StackingBehavior.neverReplace }
| { behavior: CardMod.StackingBehavior.ranked, rank: number }
| { behavior: CardMod.StackingBehavior.replace }
| { behavior: CardMod.StackingBehavior.stack, stackCount: number }
) {
const stackingData = ['$stack', stackConfig.behavior];
(stackConfig.behavior === CardMod.StackingBehavior.ranked) && stackingData.push(stackConfig.rank);
(stackConfig.behavior === CardMod.StackingBehavior.stack) && stackingData.push(stackConfig.stackCount);
return stackingData as CardMod.StackingData;
}
static removeMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modData: CardMod.ModData, contextCard?: GameEngine.ICardState) {
engine.broadcast.push({
type: 'modRemoved',
cardId: card.id,
modData,
});
if (!card.mods.find(x => this.areEqual(x, modData))) {
throw new Error('mod not found');
}
this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });
card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));
}
static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {
const mod = card.mods.find(x => x[0] === modName);
mod && this.removeMod(engine, card, mod, contextCard);
}
static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {
const deps = args[0];
const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));
if (!modDataFromCard) {
throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);
}
const mod = this.deserialize(deps.engine, modDataFromCard);
const evnt = mod[ev];
const evntRetVal = evnt ? (evnt as any).apply(mod, args) : undefined;
if (deps.sourceCard.isRemoved) {
return;
}
if (ev === 'onTurnStart') {
const durationData = this.findDurationData(modDataFromCard);
if (durationData) {
if (durationData[1] > 1) {
durationData[1]--;
deps.engine.broadcast.push({
type: 'modDurationChanged',
cardId: deps.sourceCard.id,
modData: modData,
newDuration: durationData[1],
});
} else {
this.removeMod(deps.engine, deps.sourceCard, modData);
}
}
}
return evntRetVal as ReturnType<NonNullable<CardMod[T]>> | undefined;
}
}
export namespace CardMod {
export type ModData = [string, StackingData, ...unknown[],];
export type DurationData = ['$duration', number];
export type EnemyModData = unknown[];
export type ModConstructor = TypeConstructor<CardMod>;
export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;
export type ModLibrary = Record<string, ModConstructor>;
export type AppendStackingData = ['$stack', StackingBehavior.append];
export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];
export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];
export type ReplaceStackingData = ['$stack', StackingBehavior.replace];
export type StackStackingData = ['$stack', StackingBehavior.stack, number];
export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;
export enum StackingBehavior {
append,
neverReplace,
ranked,
replace,
stack,
}
export interface ICardModDeps {
engine: GameEngine.IGameEngine;
sourceCard: GameEngine.ICardState;
contextCard?: GameEngine.ICardState;
}
export namespace Content {
// Defines a card modifier - the class name is treated as the mod name
export class backdoor extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(public damage: number) {
// Any extra data to serialize into this.modData as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display modifier effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI modifiers,
// see _standardAi below for example
super(arguments);
this.stackingConfig.rank = damage;
}
}
export class diagnostics extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public secBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = secBonus;
}
override onTurnEnd(deps: ICardModDeps): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
}
export class firewall extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(override duration: number) {
super(arguments);
this.stackingConfig.rank = duration;
}
override onInitMod(deps: ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
return;
}
GameEngineUtils.revalidateIntents(deps.engine, true);
}
}
export class impervious extends CardMod {
constructor(override duration = -1) {
super(arguments);
}
override onSecDamageIn(_deps: ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return {
secDmgBonus: -9999,
};
}
}
export class lag extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class offline extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
}
GameEngineUtils.revalidateIntents(deps.engine, GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard));
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class secured extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public tempSecBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = tempSecBonus;
}
override onInitMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
override onStackMod(deps: ICardModDeps, stackDelta: number): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, stackDelta, false);
}
override onRemoveMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -this.stackingConfig.stackCount, true);
}
}
export class _waveBonus_extraMove extends CardMod {
override onInitMod(deps: ICardModDeps): void {
const player = GameEngineUtils.findPlayerByCardId(deps.engine.gameData, deps.sourceCard.id);
player.movesPerTurn++;
player.movesLeft = player.movesPerTurn;
deps.engine.broadcast.push({
type: 'movesPerTurnsChange',
playerId: player.id,
newMovesLeft: player.movesLeft,
newMovesPerTurn: player.movesPerTurn,
});
}
}
export class _winOnDeath extends CardMod {
override onCardDestroyed(deps: ICardModDeps) {
const player = deps.contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null;
player && player.stats.kills++;
deps.engine.onWinGame();
player && player.stats.kills--;
}
}
export class _standardAi extends CardMod {
override onTurnStart(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
}
override onTurnEnd(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.executeIntent(deps.engine, deps.sourceCard);
}
}
export class _yieldScript extends CardMod {
constructor(
public scriptData: CardScript.ScriptData,
override duration: number,
) {
super(arguments);
}
override onRemoveMod(deps: ICardModDeps) {
CardScript.addScript(deps.engine, deps.sourceCard, this.scriptData);
}
}
export class _waveTrigger extends CardMod {
constructor(
public rulesetIds: string[],
override duration = -1,
) {
super(arguments);
}
override onInitMod(deps: ICardModDeps): void {
deps.engine.gameData.difficulty < 3 && GameEngineUtils.changeSec(deps.engine, deps.sourceCard, 25, true);
}
override onCardDestroyed(deps: ICardModDeps) {
deps.engine.onNextWave(this.rulesetIds.random());
deps.contextCard && CardMod.addMod(deps.engine, deps.contextCard, new _waveBonus_extraMove());
}
override onRemoveMod(deps: ICardModDeps): void {
CardMod.addMod(deps.engine, deps.sourceCard, new _winOnDeath());
}
}
}
}
| src/game/card-mods.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/card-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.70751919692049
},
{
"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": 50.06907876068565
},
{
"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": 48.868740282298134
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " };\n export const AddMod = (mod: CardMod): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n CardMod.addMod(engine, targetCard, mod, sourceCard);\n };\n export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;\n if (secExceeded) {\n MemDmg(1)(engine, sourceCard, targetCard);",
"score": 38.289265376551455
},
{
"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": 37.73330664000655
}
] | typescript | const existingModData = card.mods.find(x => x[0] === mod.modName); |
import { defineModule } from "../define-module";
import { messageBuilder } from "../../message";
import { agentName } from "../../util";
export default defineModule({
name: "messaging",
}).with({
actions: {
queryAgentRegistry: {
description: "Ask who the other agents are that you can talk to",
async execute({ context: { agentId, allAgentIds }, sendMessage }) {
sendMessage(
messageBuilder.ok(
agentId,
`These are the agents in the system:\n\n${allAgentIds
.map((id) => `${agentName(id)} [agentId=${id}]`)
.join("\n")}`
)
);
},
},
sendMessage: {
description: "Send a message to another agent",
parameters: {
targetAgentId: {
description: "The target agent's ID",
},
message: {
description: "The content of the message",
},
},
async execute({
parameters: { targetAgentId, message },
context: { agentId, allAgentIds },
sendMessage,
}) {
if (agentId === targetAgentId) {
return sendMessage(
messageBuilder.error(
agentId,
"You can't send a message to yourself. Use the `writeNote` action if you want to make notes for yourself."
)
);
}
if (allAgentIds.includes(targetAgentId)) {
sendMessage(
| messageBuilder.agentToAgent(agentId, [targetAgentId], message)
); |
} else {
sendMessage(
messageBuilder.error(
agentId,
`You tried to send your message to an invalid targetAgentId (${JSON.stringify(
targetAgentId
)}). You can use the 'queryAgentRegistry' action to see a list of available agents and their agent IDs.`
)
);
}
},
},
},
});
| src/module/definitions/messaging.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " const currentNotes = noteTitles.length\n ? `Here are your current notes:\\n\\n${noteTitles\n .map((title) => `- \"${title}\"`)\n .join(\"\\n\")}`\n : \"Your have no notes currently.\";\n return `\nYou can manage your notes using the \\`writeNote\\`, \\`viewNote\\` and \\`deleteNote\\` actions. Use notes to keep track of any important information that you come across that may be of longterm interest. Because notes contain content in addition to a title, you can store larger thoughts here which might not fit into the text of a goal. Your notes list will always be pinned to the top of your context and won't be summarized away.\n${currentNotes}\n`.trim();\n },",
"score": 22.980822141324534
},
{
"filename": "src/module/definitions/core.ts",
"retrieved_chunk": " if (!actionDef) {\n sendMessage(\n messageBuilder.error(\n agentId,\n `Unknown action \\`${aboutAction}\\`. Please refer to the list of available actions given in the introductory message.`\n )\n );\n } else {\n sendMessage(messageBuilder.ok(agentId, getUsageText(actionDef)));\n }",
"score": 22.284994334026884
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " {\n type: \"message\",\n message: messageBuilder.ok(\n this.agentId,\n `Write a summary in ${summaryWordLimit} words or less of what has happened since (but not including) the introductory message. Include key information that you learned which you don't want to forget. This information will serve as a note to yourself to help you understand what has gone before. Use the second person voice, as if you are someone filling in your replacement who knows nothing. The summarized messages will be omitted from your context window going forward and you will only have this summary to go by, so make it as useful and information-dense as possible. Be as specific as possible, but only include important information. If there are details that seem unimportant, or which you could recover outside of your memory (for instance the particular contents of a file which you could read any time), then omit them from your summary. Once again, your summary must not exceed ${summaryWordLimit} words. In this particular instance, your response should just be raw text, not formatted as an action.`\n ),\n },\n ]);\n const summary = `Several events are omitted here to free up space in your context window, summarized as follows:\\n\\n${summaryContent}`;\n // const summary =",
"score": 21.14300674283148
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " path: {\n description: \"The path of the file you want to inspect\",\n },\n },\n async execute({\n parameters: { path },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;",
"score": 19.038779830622264
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " description: \"The path of the directory you want to inspect\",\n },\n },\n async execute({\n parameters: { path },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;\n try {",
"score": 19.038779830622264
}
] | typescript | messageBuilder.agentToAgent(agentId, [targetAgentId], message)
); |
import { google } from "googleapis";
import puppeteer from "puppeteer";
import TurndownService from "turndown";
import { messageBuilder } from "../../message";
import { Model, contextWindowSize, createChatCompletion } from "../../openai";
import { model } from "../../parameters";
import {
AVG_CHARACTERS_PER_TOKEN,
AVG_WORDS_PER_TOKEN,
countTokens,
} from "../../util";
import { defineModule } from "../define-module";
export default defineModule({
name: "web",
}).with({
actions: {
searchWeb: {
description: "Search the web.",
parameters: {
searchString: {
description: "The string to search for",
},
},
async execute({
parameters: { searchString },
context: { agentId },
sendMessage,
}) {
const items = await getSearchResults(searchString);
if (!items) {
return sendMessage(
messageBuilder.ok(agentId, "Search returned no results.")
);
}
sendMessage(
messageBuilder.ok(
agentId,
`Search results:\n\n${items
.map((item) => `- Title: "${item.title}"\n URL: ${item.link}`)
.join("\n\n")}`
)
);
},
},
readPage: {
description: "View a markdown summary of a web page.",
parameters: {
url: {
description: "The URL of the web page to read",
},
},
async execute({
parameters: { url },
context: { agentId },
sendMessage,
}) {
try {
const | maxCompletionTokens = contextWindowSize[model] / 4; |
// console.log({ maxCompletionTokens });
const pageSummary = await getPageSummary(
model,
maxCompletionTokens,
url
);
sendMessage(
messageBuilder.ok(
agentId,
`Here is a summarized markdown version of the page, in a series of summarized chunks:\n\n${pageSummary}`
)
);
} catch (e: any) {
sendMessage(
messageBuilder.error(
agentId,
`Error extracting content from ${url}: ${e.message}`
)
);
}
},
},
},
});
export async function getSearchResults(searchString: string) {
const { data } = await google.customsearch("v1").cse.list({
q: searchString,
cx: process.env.GOOGLE_SEARCH_ENGINE_ID,
key: process.env.GOOGLE_API_KEY,
});
return data.items;
}
export async function getPageSummary(
model: Model,
maxSummaryTokens: number,
url: string
) {
const maxCompletionTokens = Math.round(contextWindowSize[model] * 0.9);
console.log("Initializing...");
const browser = await puppeteer.launch();
const page = await browser.newPage();
const turndownService = new TurndownService().addRule(
"remove-extraneous-tags",
{
filter: ["style", "script", "img"],
replacement: () => "",
}
);
console.log(`Reading page at ${url}...`);
await page.goto(url);
const htmlContent = await page.content();
// console.log(htmlContent);
console.log(`HTML tokens: ${countTokens(htmlContent)}`);
turndownService.remove(["style", "script"]);
const markdownContent = turndownService
.turndown(htmlContent)
.replace(/\\_/g, "_");
const markdownTokens = countTokens(markdownContent);
console.log(`Markdown tokens: ${markdownTokens}`);
const chunks: string[] = [];
let currentChunkLines: string[] = [];
let currentChunkTokens = 0;
for (const line of markdownContent.split("\n")) {
const lineTokens = countTokens(line);
if (currentChunkTokens + lineTokens > maxCompletionTokens) {
chunks.push(currentChunkLines.join("\n"));
currentChunkLines = [];
currentChunkTokens = 0;
}
currentChunkLines.push(line);
currentChunkTokens += lineTokens;
}
let lastChunk = currentChunkLines.join("\n");
if (countTokens(lastChunk) > maxCompletionTokens) {
const characterLimit = Math.round(
maxCompletionTokens * AVG_CHARACTERS_PER_TOKEN
);
console.log(
`Truncating final chunk at ${characterLimit} characters:\n\n${lastChunk}`
);
lastChunk = lastChunk.substring(0, characterLimit);
}
chunks.push(lastChunk);
// console.log(
// chunks
// .map((chunk) => `CHUNK (${countTokens(chunk)}):\n\n${chunk}\n\n`)
// .join("")
// );
console.log(
`Total chunks: ${chunks.length} (${Math.round(
markdownTokens / chunks.length
)} tokens per chunk)`
);
const maxChunkSummaryTokens = Math.round(maxSummaryTokens / chunks.length);
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const maxChunkSummaryWords = Math.round(
maxChunkSummaryTokens * AVG_WORDS_PER_TOKEN
);
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const maxChunkSummaryCharacters = Math.round(
maxChunkSummaryTokens * AVG_CHARACTERS_PER_TOKEN
);
// const summaryLimitText = `${maxChunkSummaryWords} words`;
const chunkSummaryLimitText = `${maxChunkSummaryCharacters} characters`;
console.log(
`Max tokens per chunk summary: ${maxChunkSummaryTokens} (${chunkSummaryLimitText})`
);
console.log("Summarizing chunks...");
const summarizedChunks = await Promise.all(
chunks.map(async (chunk) =>
createChatCompletion({
model,
messages: [
{
role: "user",
content: `Modify the following markdown excerpt only as much as necessary to bring it under a maximum of ${chunkSummaryLimitText}, preserving the most essential information. In particular, try to preserve links (example: \`[my special link](https://foo.bar/baz/)\`). Write this in the same voice as the original text; do not speak in the voice of someone who is describing it to someone else. For instance, don't use phrases like "The article talks about...". Excerpt to summarize follows:\n\n=============\n\n${chunk}`,
},
],
})
)
);
const summary = summarizedChunks
.map(
(chunk) =>
`=== SUMMARIZED CHUNK (${countTokens(
chunk
)} tokens) ===\n\n${chunk}\n\n`
)
.join("");
// console.log(`Summary:\n\n${summary}\n`);
console.log(`Summary tokens: ${countTokens(summary)}`);
await browser.close();
return summary;
}
| src/module/definitions/web.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " },\n },\n async execute({\n parameters: { path },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;\n try {\n await mkdir(path);",
"score": 15.72918146309833
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " },\n async execute({\n parameters: { path },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;\n try {\n await unlink(path);\n sendMessage(messageBuilder.ok(agentId, `Deleted ${path}.`));",
"score": 14.845007036136527
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " description: \"The path of the directory you want to inspect\",\n },\n },\n async execute({\n parameters: { path },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;\n try {",
"score": 14.107005655728763
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " async execute({\n parameters: { path, content },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;\n try {\n await writeFile(path, content, \"utf8\");\n sendMessage(messageBuilder.ok(agentId, `Wrote to ${path}.`));\n } catch (err) {",
"score": 13.69729913784609
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " },\n },\n async execute({\n parameters: { title },\n context: { agentId, state },\n sendMessage,\n }) {\n const content = await state.get(title);\n if (content) {\n sendMessage(",
"score": 12.577337216500482
}
] | typescript | maxCompletionTokens = contextWindowSize[model] / 4; |
import core from "./module/definitions/core";
import filesystem from "./module/definitions/filesystem";
import messaging from "./module/definitions/messaging";
import notes from "./module/definitions/notes";
import { ModuleManager } from "./module/module-manager";
import { getUsageText } from "./module/util";
import parseAction, { Action } from "./parse-action";
import { MULTILINE_DELIMITER } from "./util";
const moduleManager = new ModuleManager(
"1",
["1"],
[core, notes, messaging, filesystem]
);
test("case 1", () => {
assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
Hello Control, this is Agent 1.
I am sending you a multi-line message.
This is another line.
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("case 2", () => {
assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
Hello Control, this is Agent 1.
Here is a multi-line message:
This is the first line.
This is the second line.
This is the third line.
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("case 3", () => {
assertValid(`
writeFile
path: ./schema/action-dictionary.json
content:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
{
"$schema": "http://json-schema.org/draft-07/schema#",
"type": "object",
"title": "Action",
"oneOf": [
{
... the old content of action-dictionary.json ...
},
{
"title": "NewActionDefinition",
"description": "This is an example of a new action definition.",
"properties": {
"type": {
"type": "string",
"const": "new-action-definition"
},
"exampleArg": {
"type": "string",
"description": "An example parameter for the new action definition."
}
},
"required": [
"type",
"exampleArg"
],
"additionalProperties": false
}
]
}
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("invalid multiline with no delimiter", () => {
expect(
assertInvalid(`
sendMessage
targetAgentId: 0
message: Hello Control, here's a list of things,
- 9 bottles of ketchup
- 2 pairs of socks
- a very big balloon
`)
).toEqual(
`Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\`% ff9d7713-0bb0-40d4-823c-5a66de48761b\`)?`
);
});
test("multiline delimiter not starting on its own line", () => {
expect(
assertValid(`
sendMessage
targetAgentId: 0
message: % ff9d7713-0bb0-40d4-823c-5a66de48761b
here is a
multi
line
message
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`).parameters.message
).toBe(
`
here is a
multi
line
message
`.trim()
);
});
test("parameter after multiline parameter", () => {
const { parameters, thoughts } = assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
multi
line
parameter
% ff9d7713-0bb0-40d4-823c-5a66de48761b
thoughts: Trying a multi-line parameter followed by another parameter.
`);
expect(parameters.message).toBe(
`
multi
line
parameter
`.trim()
);
expect(thoughts).toBe(
"Trying a multi-line parameter followed by another parameter."
);
});
test("invalid command name", () => {
expect(assertInvalid("foo")).toBe(
"Unknown action `foo`. Please refer to the list of available actions given in the introductory message."
);
});
test("invalid raw text", () => {
expect(assertInvalid("Hello Control, how are you doing?")).toEqual(
`
Your action could not be parsed. Remember to always format your entire response as an action, like this:
\`\`\`
<action name>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
\`\`\`
`.trim()
);
});
test("missing required parameter", () => {
expect(assertInvalid("sendMessage\ntargetAgentId: 0")).toBe(
`Missing required parameter \`message\`. ${getUsageText(
messaging.actions.sendMessage
)}`
);
});
test("extra parameter", () => {
expect(assertInvalid("noop\nfoo: bar")).toEqual(
| `Extraneous parameter \`foo\`. ${getUsageText(core.actions.noop)}`
); |
});
describe("quotes", () => {
test("in-line parameter", () => {
const action = assertValid(`
sendMessage
targetAgentId: 0
message: hello, "control"
`);
expect(action.actionDef.name).toBe("sendMessage");
expect(action.parameters).toEqual({
targetAgentId: "0",
message: 'hello, "control"',
});
});
test("multi-line parameter", () => {
const action = assertValid(`
sendMessage
targetAgentId: 0
message:
${MULTILINE_DELIMITER}
hello, "control"
${MULTILINE_DELIMITER}
`);
expect(action.actionDef.name).toBe("sendMessage");
expect(action.parameters).toEqual({
targetAgentId: "0",
message: 'hello, "control"',
});
});
});
// =============================================================================
function assertValid(text: string): Action {
const result = parseAction(moduleManager.actions, text);
if (result.type === "error") throw Error(`Parse failed: ${result.message}`);
return result.action;
}
function assertInvalid(text: string): string {
const result = parseAction(moduleManager.actions, text);
if (result.type === "success")
throw Error(
`Parse succeeded when it should've failed: ${JSON.stringify(
result.action,
null,
2
)}`
);
return result.message;
}
| src/parse-action.test.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " } ${missingProps.map((p) => `\\`${p}\\``)}. ${getUsageText(actionDef)}`,\n };\n }\n const extraProps = Object.keys(parameters).filter(\n (p) => !(p in actionDef.parameters)\n );\n if (extraProps.length) {\n return {\n type: \"error\",\n message: `Extraneous parameter${",
"score": 24.24355774099918
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " .filter(\n ([name, parameterDef]) =>\n !parameterDef.optional && !(name in parameters)\n )\n .map(([name]) => name);\n if (missingProps.length) {\n return {\n type: \"error\",\n message: `Missing required parameter${\n missingProps.length > 1 ? \"s\" : \"\"",
"score": 22.552837115053602
},
{
"filename": "src/module/define-module.ts",
"retrieved_chunk": " name,\n parameters: mapValues(parameters, (parameter) => ({\n optional: false,\n ...parameter,\n })),\n ...definition,\n },\n ]\n )\n ) as any,",
"score": 17.443232958388972
},
{
"filename": "src/task-queue.test.ts",
"retrieved_chunk": " await sleep(500);\n expect(taskQueue.length).toBeLessThanOrEqual(1);\n expect(numTasksRun).toBeGreaterThanOrEqual(3);\n expect(numTasksRun).toBeLessThanOrEqual(5);\n });\n });\n});",
"score": 16.517627691302224
},
{
"filename": "src/module/definitions/core.ts",
"retrieved_chunk": " if (!actionDef) {\n sendMessage(\n messageBuilder.error(\n agentId,\n `Unknown action \\`${aboutAction}\\`. Please refer to the list of available actions given in the introductory message.`\n )\n );\n } else {\n sendMessage(messageBuilder.ok(agentId, getUsageText(actionDef)));\n }",
"score": 16.313383005243885
}
] | typescript | `Extraneous parameter \`foo\`. ${getUsageText(core.actions.noop)}`
); |
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/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": 44.023914110795836
},
{
"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": 29.206688797524507
},
{
"filename": "src/net-utils.ts",
"retrieved_chunk": "export type IHttpRouteHandler = (\n path: string[],\n query: Record<string, string | number>,\n body: Record<string, any>,\n req: IHttpRequest,\n) => Promise<[StatusCodes] | [StatusCodes, Record<string, any>] | [StatusCodes, Record<string, any>, Record<string, string>] | undefined>;\nexport class RouteError extends Error {\n constructor(\n public statusCode: StatusCodes,\n message: string,",
"score": 25.051280581837904
},
{
"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": 24.540212724491752
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": "// Note: replace with an actual database\nconst cardDecksTable = createMockTableDualKey<IDataSource.ICardDeck>('playerId', 'createdAt');\nconst coopGamesTable = createMockTableSingleKey<IDataSource.ICoopGame>('id');\nconst playersTable = createMockTableSingleKey<IDataSource.IPlayer>('id');\nconst playerCoopGamesTable = createMockTableSingleKey<IDataSource.IPlayerCoopGame>('playerId');\nconst dataSource: IDataSource = {\n CardDecks: {\n ...cardDecksTable,\n async queryByDid(did) {\n return { items: [...cardDecksTable._db.values()].filter(x => x.playerId === did) };",
"score": 24.4972709938197
}
] | typescript | (req: IHttpRequest): Promise<IDataSource.IPlayer>; |
import core from "./module/definitions/core";
import filesystem from "./module/definitions/filesystem";
import messaging from "./module/definitions/messaging";
import notes from "./module/definitions/notes";
import { ModuleManager } from "./module/module-manager";
import { getUsageText } from "./module/util";
import parseAction, { Action } from "./parse-action";
import { MULTILINE_DELIMITER } from "./util";
const moduleManager = new ModuleManager(
"1",
["1"],
[core, notes, messaging, filesystem]
);
test("case 1", () => {
assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
Hello Control, this is Agent 1.
I am sending you a multi-line message.
This is another line.
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("case 2", () => {
assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
Hello Control, this is Agent 1.
Here is a multi-line message:
This is the first line.
This is the second line.
This is the third line.
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("case 3", () => {
assertValid(`
writeFile
path: ./schema/action-dictionary.json
content:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
{
"$schema": "http://json-schema.org/draft-07/schema#",
"type": "object",
"title": "Action",
"oneOf": [
{
... the old content of action-dictionary.json ...
},
{
"title": "NewActionDefinition",
"description": "This is an example of a new action definition.",
"properties": {
"type": {
"type": "string",
"const": "new-action-definition"
},
"exampleArg": {
"type": "string",
"description": "An example parameter for the new action definition."
}
},
"required": [
"type",
"exampleArg"
],
"additionalProperties": false
}
]
}
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("invalid multiline with no delimiter", () => {
expect(
assertInvalid(`
sendMessage
targetAgentId: 0
message: Hello Control, here's a list of things,
- 9 bottles of ketchup
- 2 pairs of socks
- a very big balloon
`)
).toEqual(
`Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\`% ff9d7713-0bb0-40d4-823c-5a66de48761b\`)?`
);
});
test("multiline delimiter not starting on its own line", () => {
expect(
assertValid(`
sendMessage
targetAgentId: 0
message: % ff9d7713-0bb0-40d4-823c-5a66de48761b
here is a
multi
line
message
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`).parameters.message
).toBe(
`
here is a
multi
line
message
`.trim()
);
});
test("parameter after multiline parameter", () => {
const { parameters, thoughts } = assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
multi
line
parameter
% ff9d7713-0bb0-40d4-823c-5a66de48761b
thoughts: Trying a multi-line parameter followed by another parameter.
`);
expect(parameters.message).toBe(
`
multi
line
parameter
`.trim()
);
expect(thoughts).toBe(
"Trying a multi-line parameter followed by another parameter."
);
});
test("invalid command name", () => {
expect(assertInvalid("foo")).toBe(
"Unknown action `foo`. Please refer to the list of available actions given in the introductory message."
);
});
test("invalid raw text", () => {
expect(assertInvalid("Hello Control, how are you doing?")).toEqual(
`
Your action could not be parsed. Remember to always format your entire response as an action, like this:
\`\`\`
<action name>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
\`\`\`
`.trim()
);
});
test("missing required parameter", () => {
expect(assertInvalid("sendMessage\ntargetAgentId: 0")).toBe(
`Missing required parameter \`message\`. ${getUsageText(
messaging.actions.sendMessage
)}`
);
});
test("extra parameter", () => {
expect(assertInvalid("noop\nfoo: bar")).toEqual(
`Extraneous parameter \`foo\`. ${getUsageText(core.actions.noop)}`
);
});
describe("quotes", () => {
test("in-line parameter", () => {
const action = assertValid(`
sendMessage
targetAgentId: 0
message: hello, "control"
`);
| expect(action.actionDef.name).toBe("sendMessage"); |
expect(action.parameters).toEqual({
targetAgentId: "0",
message: 'hello, "control"',
});
});
test("multi-line parameter", () => {
const action = assertValid(`
sendMessage
targetAgentId: 0
message:
${MULTILINE_DELIMITER}
hello, "control"
${MULTILINE_DELIMITER}
`);
expect(action.actionDef.name).toBe("sendMessage");
expect(action.parameters).toEqual({
targetAgentId: "0",
message: 'hello, "control"',
});
});
});
// =============================================================================
function assertValid(text: string): Action {
const result = parseAction(moduleManager.actions, text);
if (result.type === "error") throw Error(`Parse failed: ${result.message}`);
return result.action;
}
function assertInvalid(text: string): string {
const result = parseAction(moduleManager.actions, text);
if (result.type === "success")
throw Error(
`Parse succeeded when it should've failed: ${JSON.stringify(
result.action,
null,
2
)}`
);
return result.message;
}
| src/parse-action.test.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/core.ts",
"retrieved_chunk": " if (!actionDef) {\n sendMessage(\n messageBuilder.error(\n agentId,\n `Unknown action \\`${aboutAction}\\`. Please refer to the list of available actions given in the introductory message.`\n )\n );\n } else {\n sendMessage(messageBuilder.ok(agentId, getUsageText(actionDef)));\n }",
"score": 15.014322061819753
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " .join(\",\") +\n \"}\";\n const { name, thoughts, ...parameters } = JSON.parse(jsonText);\n const actionDef = actionDictionary.get(name);\n if (!actionDef)\n return {\n type: \"error\",\n message: `Unknown action \\`${name}\\`. Please refer to the list of available actions given in the introductory message.`,\n };\n const missingProps = Object.entries(actionDef.parameters)",
"score": 14.489883616045923
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " text = text.trim();\n if (!/^\\S+(?=\\n|$)/.test(text.split(\"\\n\")[0])) {\n return {\n type: \"error\",\n message: `\nYour action could not be parsed. Remember to always format your entire response as an action, like this:\n${CODE_BLOCK_DELIMITER}\n<action name>\n<arg 1 name>: <prop value>\n<arg 2 name>: <prop value>",
"score": 14.18622472347139
},
{
"filename": "src/module/definitions/core.ts",
"retrieved_chunk": " ${CODE_BLOCK_DELIMITER}\n 2) These are the actions at your disposal:\n ${[...actionDictionary.values()]\n .map((actionDef) => `\\`${actionDef.name}\\` - ${actionDef.description}`)\n .join(\"\\n\")}\n To get help on a specific action, use the \\`help\\` action with the \\`aboutAction\\` parameter set to the name of the action you want help with. For example:\n ${CODE_BLOCK_DELIMITER}\n help\n aboutAction: writeNote\n ${CODE_BLOCK_DELIMITER}",
"score": 13.894152258911266
},
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " async execute({\n parameters: { targetAgentId, message },\n context: { agentId, allAgentIds },\n sendMessage,\n }) {\n if (agentId === targetAgentId) {\n return sendMessage(\n messageBuilder.error(\n agentId,\n \"You can't send a message to yourself. Use the `writeNote` action if you want to make notes for yourself.\"",
"score": 13.463688047636625
}
] | typescript | expect(action.actionDef.name).toBe("sendMessage"); |
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": 20.262068620178834
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " ruleset!: GameEngine.IRuleset;\n constructor(\n readonly gameData: GameEngine.IGameData,\n ) {\n const currentRuleset = rulesets[gameData.rulesetIds.at(-1)!];\n if (!currentRuleset) throw new Error('invalid initial ruleSet id: ' + gameData.rulesetIds[0]);\n this._setRuleset(currentRuleset);\n }\n private static async _withEngine(gameId: string, stateAssertion: GameEngine.IGameData['state'][], func: (engine: _Engine) => Promise<void>): Promise<GameEngine.IGameData> {\n const gameData = await ds.GameData.get(gameId);",
"score": 18.545730860817937
},
{
"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": 17.248586915359226
},
{
"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": 16.62901464722697
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;\n export type ModLibrary = Record<string, ModConstructor>;\n export type AppendStackingData = ['$stack', StackingBehavior.append];\n export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];\n export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];\n export type ReplaceStackingData = ['$stack', StackingBehavior.replace];\n export type StackStackingData = ['$stack', StackingBehavior.stack, number];\n export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;\n export enum StackingBehavior {\n append,",
"score": 16.412054512175622
}
] | typescript | <GameEngine.IGameData>; |
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
const gameData = await gameEngineProvider.getGameData(game.id);
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider.removePlayer(game.id, player.id, 'leave');
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
const rankings = await ds.Leaderboard.getTopN(20);
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort((a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
const gameData = await gameEngineProvider.startGame(game.id);
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game.gameState = `ended_${now.format | (DATE_FORMAT)}`; |
game.endedAt = now.format(FULL_DATETIME_FORMAT);
let gameData: GameEngine.IGameData | undefined = undefined;
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
await gameEngineProvider.endGame(game.id);
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
} | src/apis/coop.api.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const existingGameData = await ds.GameData.get(gameId);\n if (existingGameData) throw new Error('game with id already exists: ' + gameId);\n const gameData: GameEngine.IGameData = {\n id: gameId,\n difficulty: Math.max(1, difficulty),\n state: 'created',\n turn: 1,\n players: new Map(),\n defaultMovesPerTurn: 3,\n enemies: [],",
"score": 45.73166816977411
},
{
"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": 42.39381976964949
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " // Stop if the game was won/lost due to an EndTurn effect\n return;\n }\n engine.onTurnStart();\n }\n });\n }\n static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {\n let kickedPlayerId = '';\n await _Engine._withEngine(gameId, ['started'], async engine => {",
"score": 39.0027832317868
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n const engine = new _Engine(gameData);\n try {\n if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);\n await func(engine);\n await ds.GameData.update.exec(gameData);\n } catch (e: any) {\n e.broadcast = engine.broadcast;\n throw e;\n }",
"score": 36.176044686140074
},
{
"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": 35.134767896544126
}
] | typescript | (DATE_FORMAT)}`; |
import core from "./module/definitions/core";
import filesystem from "./module/definitions/filesystem";
import messaging from "./module/definitions/messaging";
import notes from "./module/definitions/notes";
import { ModuleManager } from "./module/module-manager";
import { getUsageText } from "./module/util";
import parseAction, { Action } from "./parse-action";
import { MULTILINE_DELIMITER } from "./util";
const moduleManager = new ModuleManager(
"1",
["1"],
[core, notes, messaging, filesystem]
);
test("case 1", () => {
assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
Hello Control, this is Agent 1.
I am sending you a multi-line message.
This is another line.
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("case 2", () => {
assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
Hello Control, this is Agent 1.
Here is a multi-line message:
This is the first line.
This is the second line.
This is the third line.
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("case 3", () => {
assertValid(`
writeFile
path: ./schema/action-dictionary.json
content:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
{
"$schema": "http://json-schema.org/draft-07/schema#",
"type": "object",
"title": "Action",
"oneOf": [
{
... the old content of action-dictionary.json ...
},
{
"title": "NewActionDefinition",
"description": "This is an example of a new action definition.",
"properties": {
"type": {
"type": "string",
"const": "new-action-definition"
},
"exampleArg": {
"type": "string",
"description": "An example parameter for the new action definition."
}
},
"required": [
"type",
"exampleArg"
],
"additionalProperties": false
}
]
}
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("invalid multiline with no delimiter", () => {
expect(
assertInvalid(`
sendMessage
targetAgentId: 0
message: Hello Control, here's a list of things,
- 9 bottles of ketchup
- 2 pairs of socks
- a very big balloon
`)
).toEqual(
`Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\`% ff9d7713-0bb0-40d4-823c-5a66de48761b\`)?`
);
});
test("multiline delimiter not starting on its own line", () => {
expect(
assertValid(`
sendMessage
targetAgentId: 0
message: % ff9d7713-0bb0-40d4-823c-5a66de48761b
here is a
multi
line
message
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`).parameters.message
).toBe(
`
here is a
multi
line
message
`.trim()
);
});
test("parameter after multiline parameter", () => {
const { parameters, thoughts } = assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
multi
line
parameter
% ff9d7713-0bb0-40d4-823c-5a66de48761b
thoughts: Trying a multi-line parameter followed by another parameter.
`);
expect(parameters.message).toBe(
`
multi
line
parameter
`.trim()
);
expect(thoughts).toBe(
"Trying a multi-line parameter followed by another parameter."
);
});
test("invalid command name", () => {
expect(assertInvalid("foo")).toBe(
"Unknown action `foo`. Please refer to the list of available actions given in the introductory message."
);
});
test("invalid raw text", () => {
expect(assertInvalid("Hello Control, how are you doing?")).toEqual(
`
Your action could not be parsed. Remember to always format your entire response as an action, like this:
\`\`\`
<action name>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
\`\`\`
`.trim()
);
});
test("missing required parameter", () => {
expect(assertInvalid("sendMessage\ntargetAgentId: 0")).toBe(
`Missing required parameter \`message\`. ${getUsageText(
messaging.actions.sendMessage
)}`
);
});
test("extra parameter", () => {
expect(assertInvalid("noop\nfoo: bar")).toEqual(
`Extraneous parameter \`foo\`. ${getUsageText(core.actions.noop)}`
);
});
describe("quotes", () => {
test("in-line parameter", () => {
const action = assertValid(`
sendMessage
targetAgentId: 0
message: hello, "control"
`);
expect(action.actionDef.name).toBe("sendMessage");
expect(action.parameters).toEqual({
targetAgentId: "0",
message: 'hello, "control"',
});
});
test("multi-line parameter", () => {
const action = assertValid(`
sendMessage
targetAgentId: 0
message:
${MULTILINE_DELIMITER}
hello, "control"
${MULTILINE_DELIMITER}
`);
expect(action.actionDef.name).toBe("sendMessage");
expect(action.parameters).toEqual({
targetAgentId: "0",
message: 'hello, "control"',
});
});
});
// =============================================================================
function assertValid(text: string): Action {
const result = | parseAction(moduleManager.actions, text); |
if (result.type === "error") throw Error(`Parse failed: ${result.message}`);
return result.action;
}
function assertInvalid(text: string): string {
const result = parseAction(moduleManager.actions, text);
if (result.type === "success")
throw Error(
`Parse succeeded when it should've failed: ${JSON.stringify(
result.action,
null,
2
)}`
);
return result.message;
}
| src/parse-action.test.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/parse-action.ts",
"retrieved_chunk": "export interface Action {\n actionDef: ActionDefinition;\n thoughts?: string;\n parameters: Record<string, string>;\n}\nexport default function parseAction(\n actionDictionary: Map<string, ActionDefinition>,\n text: string\n): ParseResult {\n try {",
"score": 20.833623111478687
},
{
"filename": "src/agent.ts",
"retrieved_chunk": " const actionText = await makeDecision(events);\n // Reassign events in case summarization occurred\n events = await this.memory.append({\n type: \"decision\",\n actionText,\n });\n const result = parseAction(this.moduleManager.actions, actionText);\n if (result.type === \"error\") {\n this.messageBus.send(messageBuilder.error(this.id, result.message));\n } else {",
"score": 16.306207500052878
},
{
"filename": "src/util.ts",
"retrieved_chunk": " return `${agentId === \"0\" ? \"Control\" : `Agent ${agentId}`}`;\n}\nexport const MULTILINE_DELIMITER = `% ${\"ff9d7713-0bb0-40d4-823c-5a66de48761b\"}`;\nexport const AVG_WORDS_PER_TOKEN = 0.75;\nexport const AVG_CHARACTERS_PER_TOKEN = 4;\nexport function countTokens(text: string) {\n return encode(text).length;\n}",
"score": 13.931347180571823
},
{
"filename": "src/action-handler.ts",
"retrieved_chunk": "import { ModuleManager } from \"./module/module-manager\";\nimport { MessageBus } from \"./message-bus\";\nimport { Action } from \"./parse-action\";\nexport default class ActionHandler {\n constructor(\n private agentIds: string[],\n private messageBus: MessageBus,\n private moduleManager: ModuleManager\n ) {}\n async handle(agentId: string, { actionDef, parameters }: Action) {",
"score": 13.1499380188962
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " text = text.trim();\n if (!/^\\S+(?=\\n|$)/.test(text.split(\"\\n\")[0])) {\n return {\n type: \"error\",\n message: `\nYour action could not be parsed. Remember to always format your entire response as an action, like this:\n${CODE_BLOCK_DELIMITER}\n<action name>\n<arg 1 name>: <prop value>\n<arg 2 name>: <prop value>",
"score": 12.89574705327585
}
] | typescript | parseAction(moduleManager.actions, text); |
import { CODE_BLOCK_DELIMITER } from "./message";
import { ActionDefinition } from "./module/action-definition";
import { getUsageText } from "./module/util";
import { MULTILINE_DELIMITER } from "./util";
type ParseResult =
| {
type: "success";
action: Action;
}
| { type: "error"; message: string };
export interface Action {
actionDef: ActionDefinition;
thoughts?: string;
parameters: Record<string, string>;
}
export default function parseAction(
actionDictionary: Map<string, ActionDefinition>,
text: string
): ParseResult {
try {
text = text.trim();
if (!/^\S+(?=\n|$)/.test(text.split("\n")[0])) {
return {
type: "error",
message: `
Your action could not be parsed. Remember to always format your entire response as an action, like this:
${CODE_BLOCK_DELIMITER}
<action name>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
${CODE_BLOCK_DELIMITER}
`.trim(),
};
}
text = `name: ${text}`;
const jsonText =
"{" +
text
| .split(MULTILINE_DELIMITER)
.map((part) => part.trim())
.map((part, i) => { |
if (i % 2 === 0) return part;
return JSON.stringify(part) + "\n";
})
.join("")
.split("\n")
.filter(Boolean)
.map((line) => {
const colonIndex = line.indexOf(":");
if (colonIndex < 0)
throw new Error(
`Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\`${MULTILINE_DELIMITER}\`)?`
);
const key = line.substring(0, colonIndex).trim();
let value = line.substring(colonIndex + 1).trim();
if (!value.startsWith('"') || !value.endsWith('"'))
value = JSON.stringify(value);
return `"${key}": ${value}`;
})
.join(",") +
"}";
const { name, thoughts, ...parameters } = JSON.parse(jsonText);
const actionDef = actionDictionary.get(name);
if (!actionDef)
return {
type: "error",
message: `Unknown action \`${name}\`. Please refer to the list of available actions given in the introductory message.`,
};
const missingProps = Object.entries(actionDef.parameters)
.filter(
([name, parameterDef]) =>
!parameterDef.optional && !(name in parameters)
)
.map(([name]) => name);
if (missingProps.length) {
return {
type: "error",
message: `Missing required parameter${
missingProps.length > 1 ? "s" : ""
} ${missingProps.map((p) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
};
}
const extraProps = Object.keys(parameters).filter(
(p) => !(p in actionDef.parameters)
);
if (extraProps.length) {
return {
type: "error",
message: `Extraneous parameter${
extraProps.length > 1 ? "s" : ""
} ${extraProps.map((p) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
};
}
return { type: "success", action: { actionDef, thoughts, parameters } };
} catch (e: any) {
return {
type: "error",
message: e.message,
};
}
}
| src/parse-action.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/util.ts",
"retrieved_chunk": " return `${agentId === \"0\" ? \"Control\" : `Agent ${agentId}`}`;\n}\nexport const MULTILINE_DELIMITER = `% ${\"ff9d7713-0bb0-40d4-823c-5a66de48761b\"}`;\nexport const AVG_WORDS_PER_TOKEN = 0.75;\nexport const AVG_CHARACTERS_PER_TOKEN = 4;\nexport function countTokens(text: string) {\n return encode(text).length;\n}",
"score": 15.684863424438127
},
{
"filename": "src/module/definitions/goals.ts",
"retrieved_chunk": "export default defineModule<Store<Goal[]>>({\n name: \"goals\",\n createState: ({ agentId }) => new JsonStore(new FileStore([agentId])),\n}).with({\n async pinnedMessage({ state }) {\n const goals = (await state.get(KEY)) || [];\n const currentGloals = goals.length\n ? `This is your current goal list:\\n\\n${goals\n .map(\n ({ text, complete }, index) =>",
"score": 13.44040600290754
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": " message: 'hello, \"control\"',\n });\n });\n});\n// =============================================================================\nfunction assertValid(text: string): Action {\n const result = parseAction(moduleManager.actions, text);\n if (result.type === \"error\") throw Error(`Parse failed: ${result.message}`);\n return result.action;\n}",
"score": 12.550386205814727
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": "function assertInvalid(text: string): string {\n const result = parseAction(moduleManager.actions, text);\n if (result.type === \"success\")\n throw Error(\n `Parse succeeded when it should've failed: ${JSON.stringify(\n result.action,\n null,\n 2\n )}`\n );",
"score": 12.151031239214161
},
{
"filename": "src/module/module-manager.ts",
"retrieved_chunk": " moduleDefinitions: ModuleDefinition[]\n ) {\n this.modules = moduleDefinitions.map(\n (moduleDef) => new ModuleInstance(this, moduleDef)\n );\n this.actions = moduleDefinitions\n .flatMap((module) => Object.values(module.actions))\n .reduce(\n (map, actionDef) => (map.set(actionDef.name, actionDef), map),\n new Map()",
"score": 10.088887775344691
}
] | typescript | .split(MULTILINE_DELIMITER)
.map((part) => part.trim())
.map((part, i) => { |
import { CODE_BLOCK_DELIMITER } from "./message";
import { ActionDefinition } from "./module/action-definition";
import { getUsageText } from "./module/util";
import { MULTILINE_DELIMITER } from "./util";
type ParseResult =
| {
type: "success";
action: Action;
}
| { type: "error"; message: string };
export interface Action {
actionDef: ActionDefinition;
thoughts?: string;
parameters: Record<string, string>;
}
export default function parseAction(
actionDictionary: Map<string, ActionDefinition>,
text: string
): ParseResult {
try {
text = text.trim();
if (!/^\S+(?=\n|$)/.test(text.split("\n")[0])) {
return {
type: "error",
message: `
Your action could not be parsed. Remember to always format your entire response as an action, like this:
${CODE_BLOCK_DELIMITER}
<action name>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
${CODE_BLOCK_DELIMITER}
`.trim(),
};
}
text = `name: ${text}`;
const jsonText =
"{" +
text
.split(MULTILINE_DELIMITER)
.map((part) => part.trim())
.map((part, i) => {
if (i % 2 === 0) return part;
return JSON.stringify(part) + "\n";
})
.join("")
.split("\n")
.filter(Boolean)
.map((line) => {
const colonIndex = line.indexOf(":");
if (colonIndex < 0)
throw new Error(
`Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\`${MULTILINE_DELIMITER}\`)?`
);
const key = line.substring(0, colonIndex).trim();
let value = line.substring(colonIndex + 1).trim();
if (!value.startsWith('"') || !value.endsWith('"'))
value = JSON.stringify(value);
return `"${key}": ${value}`;
})
.join(",") +
"}";
const { name, thoughts, ...parameters } = JSON.parse(jsonText);
const actionDef = actionDictionary.get(name);
if (!actionDef)
return {
type: "error",
message: `Unknown action \`${name}\`. Please refer to the list of available actions given in the introductory message.`,
};
const missingProps = Object.entries(actionDef.parameters)
.filter(
([name, parameterDef]) =>
!parameterDef.optional && !(name in parameters)
)
.map(([name]) => name);
if (missingProps.length) {
return {
type: "error",
message: `Missing required parameter${
missingProps.length > 1 ? "s" : ""
} ${missingProps.map((p | ) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
}; |
}
const extraProps = Object.keys(parameters).filter(
(p) => !(p in actionDef.parameters)
);
if (extraProps.length) {
return {
type: "error",
message: `Extraneous parameter${
extraProps.length > 1 ? "s" : ""
} ${extraProps.map((p) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
};
}
return { type: "success", action: { actionDef, thoughts, parameters } };
} catch (e: any) {
return {
type: "error",
message: e.message,
};
}
}
| src/parse-action.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": "`.trim()\n );\n});\ntest(\"missing required parameter\", () => {\n expect(assertInvalid(\"sendMessage\\ntargetAgentId: 0\")).toBe(\n `Missing required parameter \\`message\\`. ${getUsageText(\n messaging.actions.sendMessage\n )}`\n );\n});",
"score": 22.91040398158296
},
{
"filename": "src/module/util.ts",
"retrieved_chunk": "import { CODE_BLOCK_DELIMITER } from \"../message\";\nimport { ActionDefinition } from \"./action-definition\";\nexport function getUsageText(actionDef: ActionDefinition): string {\n return `Usage:\n${CODE_BLOCK_DELIMITER}\n${actionDef.name}\nthoughts: <reasoning behind this action> (optional)${Object.entries(\n actionDef.parameters\n )\n .map(([name, { description }]) =>",
"score": 19.845622958936808
},
{
"filename": "src/module/module-manager.ts",
"retrieved_chunk": " moduleDefinitions: ModuleDefinition[]\n ) {\n this.modules = moduleDefinitions.map(\n (moduleDef) => new ModuleInstance(this, moduleDef)\n );\n this.actions = moduleDefinitions\n .flatMap((module) => Object.values(module.actions))\n .reduce(\n (map, actionDef) => (map.set(actionDef.name, actionDef), map),\n new Map()",
"score": 16.876387587211266
},
{
"filename": "src/module/definitions/core.ts",
"retrieved_chunk": " ${CODE_BLOCK_DELIMITER}\n 2) These are the actions at your disposal:\n ${[...actionDictionary.values()]\n .map((actionDef) => `\\`${actionDef.name}\\` - ${actionDef.description}`)\n .join(\"\\n\")}\n To get help on a specific action, use the \\`help\\` action with the \\`aboutAction\\` parameter set to the name of the action you want help with. For example:\n ${CODE_BLOCK_DELIMITER}\n help\n aboutAction: writeNote\n ${CODE_BLOCK_DELIMITER}",
"score": 14.393759511403035
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.agentId,\n nestedEvents.flat().join(\"\\n\\n\")\n ),\n };\n }\n private removeErrors(events: Event[]): Event[] {\n const cleaned: Event[] = [];\n for (let i = events.length - 1; i >= 0; i--) {\n const event = events[i];\n if (event.type === \"message\" && event.message.type === \"error\") {",
"score": 13.116329428333927
}
] | typescript | ) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
}; |
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": " }\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": 84.84844000106075
},
{
"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": 81.90168101914735
},
{
"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": 81.25535487136136
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " });\n const payload = schema.parse(body);\n const uniqueNftIds = new Set<string>(payload.nftIds);\n if (uniqueNftIds.size !== 6) {\n return [StatusCodes.badRequest, { reason: 'nftIds must contain 6 unique NFT ids that belong to the player' }];\n }\n const player = await authProvider.getPlayerFromRequest(req);\n const deck = await ds.CardDecks.get(player.id, payload.deckId);\n if (!deck) {\n return [StatusCodes.notFound, { reason: 'invalid deck id' }];",
"score": 63.38446776662046
},
{
"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": 60.72559435937103
}
] | typescript | const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId))); |
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-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": 46.41999412472197
},
{
"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": 42.79354408146166
},
{
"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": 41.56718419071864
},
{
"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": 36.37199494385618
},
{
"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": 35.44275564103384
}
] | typescript | const isEnemy = GameEngineUtils.isEnemyCard(engine.gameData, 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/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 | find(modData => modFilter.find(x => x === modData[0]))); |
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": " export namespace Content {\n // Defines a card modifier - the class name is treated as the mod name\n export class backdoor extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.ranked as const,\n rank: 0,\n };\n constructor(public damage: number) {\n // Any extra data to serialize into this.modData as a 'memo' which can serve two purposes:\n // 1) the client relies on the memo to display modifier effects in the UI instead calculating it independently",
"score": 67.57925991367955
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " // 2) memo is passed back into the constructor during deserialization, useful for dynamic AI modifiers,\n // see _standardAi below for example\n super(arguments);\n this.stackingConfig.rank = damage;\n }\n }\n export class diagnostics extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,",
"score": 55.20207052901632
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " ],\n );\n }\n },\n // Grant Feedback\n mw_honeypot: class extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));\n super(",
"score": 44.99713751300788
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " );\n this.cooldownMax = 4;\n }\n },\n // Heal over time\n bd_diagnostics: class extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n const duration = 1 + Math.round(card.mem / 2);\n super(",
"score": 44.45052559975041
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " bf_feedback: class extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const damage = GameEngineUtils.scaleByCpuMem(10, card.cpu);\n const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));\n super(\n [damage, cooldown],\n CardScript.TargetFinders.Self,\n [\n {\n targetResolver: CardScript.TargetResolvers.Self,",
"score": 42.08391360961295
}
] | typescript | const bdChance = round(GameEngineUtils.scaleByCpuMem(20, card.mem, 'high') / 100, 2); |
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 | script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData); |
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 | .RaiseSec(randInt(minBonus, maxBonus)),
],
} |
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": 80.62470277220788
},
{
"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": 74.33664003077965
},
{
"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": 66.95580193622665
},
{
"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": 64.70799536353994
},
{
"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": 63.62570353699003
}
] | typescript | CardMod.addMod(deps.engine, enemy, new GameContent_v1.cardMods.optimized(1, -1), boss); |
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 | target => !target.sec && target.mem === 1),
[
{ |
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": 37.76726916476699
},
{
"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": " 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": 31.172050358152966
},
{
"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/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": 30.591088512224257
}
] | typescript | .reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 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/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 | SECS_IN_MIN * 1000; |
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-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": 40.0275279304831
},
{
"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": 39.83785227422412
},
{
"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": 38.473326093827225
},
{
"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": 34.61730447854749
},
{
"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": 34.043450476440896
}
] | typescript | const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript)); |
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/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": 27.10032079639656
},
{
"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.388190317493766
},
{
"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": 19.952175647444797
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " this.modName = this.constructor.name;\n }\n onSecDamageIn?(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState): { secDmgBonus: number } | void;\n onSecDamageOut?(deps: CardMod.ICardModDeps, baseDmg: number): { secDmgBonus: number } | void;\n onMemDmgIn?(deps: CardMod.ICardModDeps, memDmg: number): void;\n onMemDmgOut?(deps: CardMod.ICardModDeps, memDmg: number): void;\n onInitMod?(deps: CardMod.ICardModDeps): void;\n onRemoveMod?(deps: CardMod.ICardModDeps): void;\n onCardDestroyed?(deps: CardMod.ICardModDeps): void;\n onStackMod?(deps: CardMod.ICardModDeps, stackDelta: number): void;",
"score": 19.927884871387803
},
{
"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": 19.21701604078997
}
] | typescript | card: IAppraisedCard; |
import { CardMod } from '../card-mods';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
const GOLIATH_ID = 9999;
export const RulesetGoliath = {
cardMods: {
goliath_power_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_power(), deps.sourceCard);
}
},
goliath_shield_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_shield(), deps.sourceCard);
}
},
goliath_boss_ai: class extends CardMod {
override onTurnStart(deps: CardMod.ICardModDeps) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard as GameEngine.IEnemyCardState);
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
const targetId = boss.intent?.targetCardId;
if (!targetId) return;
let numAttacks = 1;
const powerBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_power);
if (powerBuff) {
const powerStacks = CardMod.getStackCount(powerBuff);
numAttacks += powerStacks;
}
for (let i = 0; i < numAttacks - 1; i++) {
GameEngineUtils.executeIntent(deps.engine, boss, true);
}
GameEngineUtils.executeIntent(deps.engine, boss);
}
override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {
if (deps.sourceCard.mem - memDmg <= 0) return;
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
let secBonus = 100;
const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);
if (shieldBuff) {
secBonus += CardMod.getStackCount(shieldBuff) * 100;
}
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);
for (const enemy of [...deps.engine.gameData.enemies]) {
if (enemy === boss) continue;
CardMod.addMod(deps.engine, enemy, new GameContent_v1.cardMods.optimized(1, -1), boss);
}
}
},
goliath_boss_power: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
},
goliath_boss_shield: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
},
},
enemyCards: {
goliath_power_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 2,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
| new RulesetGoliath.cardMods.goliath_power_supply().serialize(),
],
scripts: [],
}; |
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),
);
return enemy;
},
goliath_shield_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_shield_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._defend(enemy, engine.gameData.difficulty, 'weak').serialize(),
new CardScript.Content._firewallSelf(enemy, 1, 2).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: GOLIATH_ID,
enemyClass: 'goliath_boss',
cpu: 2,
mem: 4,
maxMem: 4,
sec: GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
mods: [
new RulesetGoliath.cardMods.goliath_boss_ai().serialize(),
new CardMod.Content._winOnDeath().serialize(),
],
scripts: [],
};
boss.scripts.push(
new CardScript.Content._attack(boss, engine.gameData.difficulty).serialize(),
);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
},
}; | src/game/rulesets/goliath.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " 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": 54.62489481196824
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " cpu: 2,\n mem: 0,\n maxMem: 0,\n sec: 1,\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };",
"score": 48.709064066488914
},
{
"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": 47.028271484054585
},
{
"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": 46.79729647120776
},
{
"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": 42.455629809482716
}
] | typescript | new RulesetGoliath.cardMods.goliath_power_supply().serialize(),
],
scripts: [],
}; |
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": 50.72876491627144
},
{
"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": 43.41079263182522
},
{
"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": 39.21209681614636
},
{
"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": 34.77473351585195
}
] | typescript | gameData.enemies.find(x => x.id === cardId); |
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 { 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": 28.804035081488916
},
{
"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": " 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": 27.222516889867677
},
{
"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
}
] | typescript | public scriptData: CardScript.ScriptData,
override duration: number,
) { |
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": " 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": 48.095918144636784
},
{
"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": 40.709777601978985
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " maxBonus = GameEngineUtils.scaleByCpuMem(8, card.cpu);\n break;\n case 'strong':\n minBonus = GameEngineUtils.scaleByCpuMem(8, card.cpu);\n maxBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);\n break;\n }\n minBonus = GameEngineUtils.scaleByDifficulty(minBonus, difficulty);\n maxBonus = GameEngineUtils.scaleByDifficulty(maxBonus, difficulty);\n super(",
"score": 40.6304379212198
},
{
"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": 37.26483061530013
},
{
"filename": "src/utils.ts",
"retrieved_chunk": " return new Map(Object.entries(value.value));\n }\n return value;\n};\nexport const clamp = (value: number, min: number, max: number) => {\n return value < min ? min : (value > max) ? max : value;\n}\nexport const rand = (minIncl: number, maxExcl: number) =>\n minIncl + Math.random() * (maxExcl - minIncl);\nexport const randInt = (min: number, max: number) =>",
"score": 34.0067338256661
}
] | typescript | return round(value * Math.pow(1.1, difficulty - 1), decimals); |
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 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": 35.109501497914664
},
{
"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": 31.423354158125147
},
{
"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": 31.337385477809427
},
{
"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": 29.32409758048648
},
{
"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.559129075751297
}
] | typescript | bd_caching: class extends CardScript { |
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 | const scriptData = card.scripts.find(x => x[0] === scriptName); |
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": 75.9639411425694
},
{
"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.31323673289633
},
{
"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": 40.732223014059585
},
{
"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": 40.54809447992926
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (deps.sourceCard.mem - memDmg <= 0) return;\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n let secBonus = 100;\n const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);\n if (shieldBuff) {\n secBonus += CardMod.getStackCount(shieldBuff) * 100;\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);\n for (const enemy of [...deps.engine.gameData.enemies]) {\n if (enemy === boss) continue;",
"score": 39.34560989736024
}
] | typescript | 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-content-v1.ts",
"retrieved_chunk": " }\n ],\n );\n this.cooldownMax = 2;\n }\n },\n};\nexport const GameContent_v1 = {\n cardMods: _cardMods,\n cardScripts: _cardScripts,",
"score": 17.362572531495005
},
{
"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": 17.226780504346927
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n CardScriptParts.AddMod(\n new GameContent_v1.cardMods.feedback(damage),\n ),\n ],\n }\n ],\n );\n this.cooldownMax = cooldown;\n }",
"score": 11.572056770393946
},
{
"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": 11.567976656987426
},
{
"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": 10.886769460265011
}
] | typescript | cardMods: CardMod.Content,
cardScripts: CardScript.Content,
},
{ |
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 { randInt } from '../../utils';
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetReaper = {
cardMods: {
reaper_feederCorrupted: class extends CardMod {
},
reaper_feederPower: class extends CardMod {
override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {
if (deps.sourceCard.sec - damage > 0) return;
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);
CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);
const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);
player && player.stats.kills++;
return { secDmgBonus: -9999 };
}
},
},
cardScripts: {
reaper_bossEat: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, _card) => {
return gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_feeder.name);
},
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, | source, target) => { |
GameEngineUtils.removeCard(engine, target, source);
if (target.mods.find(x => x[0] === RulesetReaper.cardMods.reaper_feederCorrupted.name)) {
GameEngineUtils.changeSec(engine, source, -50, false);
if (source.sec <= 0) {
GameEngineUtils.removeCard(engine, source);
return;
}
} else {
GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);
GameEngineUtils.changeCpu(engine, source, 1);
for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {
CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));
}
}
const highDiff = engine.gameData.difficulty >= 7;
if (engine.gameData.enemies.length <= (highDiff ? 6 : 4)) {
while (engine.gameData.enemies.findIndex(x => x.id === source.id) < (highDiff ? 4 : 3)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absLeft')(engine, source, target);
}
while (engine.gameData.enemies.length < (highDiff ? 9 : 7)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absRight')(engine, source, target);
}
}
},
],
}
],
);
}
},
},
enemyCards: {
reaper_feeder: (engine: GameEngine.IGameEngine): GameEngine.IEnemyCardState => {
return {
id: engine.nextId(),
enemyClass: 'reaper_feeder',
cpu: 0,
mem: 0,
maxMem: 0,
sec: randInt(
GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),
GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
),
mods: [
new RulesetReaper.cardMods.reaper_feederPower().serialize(),
],
scripts: [],
};
},
reaper_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_lesser_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak', 1).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_boss',
cpu: 0,
mem: 0,
maxMem: 0,
sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content._winOnDeath().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
boss.scripts.push(
new RulesetReaper.cardScripts.reaper_bossEat(boss).serialize(),
);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
},
};
| src/game/rulesets/reaper.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [],\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/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
},
{
"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": 21.76194383946263
},
{
"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": 20.50506364554598
},
{
"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": 17.333470309683136
}
] | typescript | source, target) => { |
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/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": 40.697394896627976
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " cpu: 2,\n mem: 0,\n maxMem: 0,\n sec: 1,\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };",
"score": 40.45807980612887
},
{
"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": 39.74222183760775
},
{
"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": 38.14104313413178
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " id: engine.nextId(),\n enemyClass: '',\n cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new RulesetGoliath.cardMods.goliath_power_supply().serialize(),\n ],",
"score": 37.22048556725683
}
] | typescript | testEnemy.mods.push(new CardMod.Content._standardAi().serialize()); |
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 { 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": 69.16411547518395
},
{
"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": 57.287584105151105
},
{
"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": 51.66803427605619
},
{
"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": 51.25093819843038
},
{
"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": 51.054015555474045
}
] | typescript | new RulesetReaper.cardScripts.reaper_bossEat(boss).serialize(),
); |
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 | guardian, 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/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 | (engine) { |
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": " 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": 86.32972890511947
},
{
"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": 64.82249799826192
},
{
"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": 60.14650816971013
},
{
"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": 57.558122694291384
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 53.87774199402618
}
] | typescript | ds.CoopGames.update.make(game),
ds.Players.update.make(player),
); |
import { randInt } from '../../utils';
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetReaper = {
cardMods: {
reaper_feederCorrupted: class extends CardMod {
},
reaper_feederPower: class extends CardMod {
override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {
if (deps.sourceCard.sec - damage > 0) return;
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);
CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);
const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);
player && player.stats.kills++;
return { secDmgBonus: -9999 };
}
},
},
cardScripts: {
reaper_bossEat: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, _card) => {
return gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_feeder.name);
},
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
( | engine, source, target) => { |
GameEngineUtils.removeCard(engine, target, source);
if (target.mods.find(x => x[0] === RulesetReaper.cardMods.reaper_feederCorrupted.name)) {
GameEngineUtils.changeSec(engine, source, -50, false);
if (source.sec <= 0) {
GameEngineUtils.removeCard(engine, source);
return;
}
} else {
GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);
GameEngineUtils.changeCpu(engine, source, 1);
for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {
CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));
}
}
const highDiff = engine.gameData.difficulty >= 7;
if (engine.gameData.enemies.length <= (highDiff ? 6 : 4)) {
while (engine.gameData.enemies.findIndex(x => x.id === source.id) < (highDiff ? 4 : 3)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absLeft')(engine, source, target);
}
while (engine.gameData.enemies.length < (highDiff ? 9 : 7)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absRight')(engine, source, target);
}
}
},
],
}
],
);
}
},
},
enemyCards: {
reaper_feeder: (engine: GameEngine.IGameEngine): GameEngine.IEnemyCardState => {
return {
id: engine.nextId(),
enemyClass: 'reaper_feeder',
cpu: 0,
mem: 0,
maxMem: 0,
sec: randInt(
GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),
GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
),
mods: [
new RulesetReaper.cardMods.reaper_feederPower().serialize(),
],
scripts: [],
};
},
reaper_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_lesser_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak', 1).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_boss',
cpu: 0,
mem: 0,
maxMem: 0,
sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content._winOnDeath().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
boss.scripts.push(
new RulesetReaper.cardScripts.reaper_bossEat(boss).serialize(),
);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
},
};
| src/game/rulesets/reaper.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [],\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/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
},
{
"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": 21.76194383946263
},
{
"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": 20.50506364554598
},
{
"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": 17.333470309683136
}
] | typescript | 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": " 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": 68.33762611817234
},
{
"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": 68.3143483188788
},
{
"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": 55.13252855145247
},
{
"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": 53.81049979686147
},
{
"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": 53.40819680697467
}
] | typescript | RulesetStasis.cardScripts.stasis_disrupt(enemy, engine.gameData.difficulty).serialize(),
); |
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": 55.89084987854224
},
{
"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": 55.38688122817324
},
{
"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": 54.33966936982497
},
{
"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": 53.24528493262726
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " cpu: 2,\n mem: 0,\n maxMem: 0,\n sec: 1,\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };",
"score": 52.326584690828305
}
] | typescript | testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize()); |
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": " 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": 42.051488706127344
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " id: GOLIATH_ID,\n enemyClass: 'goliath_boss',\n cpu: 2,\n mem: 4,\n maxMem: 4,\n sec: GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),\n mods: [\n new RulesetGoliath.cardMods.goliath_boss_ai().serialize(),\n new CardMod.Content._winOnDeath().serialize(),\n ],",
"score": 41.69539063947275
},
{
"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": 40.419228974738125
},
{
"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": 38.794730711969734
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " id: engine.nextId(),\n enemyClass: '',\n cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new RulesetGoliath.cardMods.goliath_power_supply().serialize(),\n ],",
"score": 37.55037695571035
}
] | typescript | new RulesetReaper.cardMods.reaper_feederPower().serialize(),
],
scripts: [],
}; |
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": " 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": 83.2049297215255
},
{
"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": 55.372086464374625
},
{
"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": 52.433296912718276
},
{
"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": 51.356939531470566
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 49.822368343700205
}
] | typescript | .execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
); |
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": " 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": 86.32972890511947
},
{
"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": 64.82249799826192
},
{
"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": 60.14650816971013
},
{
"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": 57.558122694291384
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 53.87774199402618
}
] | typescript | ds.Players.update.make(player),
); |
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": " 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": 58.904411422156855
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 47.47221895734556
},
{
"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": 42.43970140161159
},
{
"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": 41.730008699232805
},
{
"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": 36.9298442720775
}
] | typescript | const gameData = await gameEngineProvider.getGameData(game.id); |
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 coopHandler = createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider); |
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/dependencies.d.ts",
"retrieved_chunk": " difficulty: number;\n createdAt: string;\n gameState: 'open' | 'private' | `ended_${string}`;\n playersIds: Set<string>;\n ingorePlayerIds: Set<string>;\n startedAt: string;\n endedAt: string;\n isCompleted: boolean;\n _dbTtl?: number;\n }",
"score": 45.0340937742495
},
{
"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": 33.0978047682327
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " });\n const payload = schema.parse(body);\n const uniqueNftIds = new Set<string>(payload.nftIds);\n if (uniqueNftIds.size !== 6) {\n return [StatusCodes.badRequest, { reason: 'nftIds must contain 6 unique NFT ids that belong to the player' }];\n }\n const player = await authProvider.getPlayerFromRequest(req);\n const deck = await ds.CardDecks.get(player.id, payload.deckId);\n if (!deck) {\n return [StatusCodes.notFound, { reason: 'invalid deck id' }];",
"score": 31.420288631677455
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " ...payload.didProof,\n message: 'Proof of DID ownership for ChiaTCG',\n }))?.did;\n if (!did) {\n return [StatusCodes.unauthorized, { reason: 'unable to validate did proof' }];\n }\n let player = await ds.Players.get(did);\n const isNew = !player;\n const now = moment.utc();\n const newSecret = authProvider.generateNewSecret();",
"score": 26.948114579576313
},
{
"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": 26.77412961641102
}
] | typescript | createGame(game.id, initialRulesetId, payload.difficulty); |
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": " 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": 54.856864736196215
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 45.63269892314563
},
{
"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": 42.18145433220928
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const existingGameData = await ds.GameData.get(gameId);\n if (existingGameData) throw new Error('game with id already exists: ' + gameId);\n const gameData: GameEngine.IGameData = {\n id: gameId,\n difficulty: Math.max(1, difficulty),\n state: 'created',\n turn: 1,\n players: new Map(),\n defaultMovesPerTurn: 3,\n enemies: [],",
"score": 36.84782219681034
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n const engine = new _Engine(gameData);\n try {\n if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);\n await func(engine);\n await ds.GameData.update.exec(gameData);\n } catch (e: any) {\n e.broadcast = engine.broadcast;\n throw e;\n }",
"score": 34.93896570953302
}
] | typescript | gameJoined(game.id, gameData.turn >= 2); |
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": " }\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": 103.56911992459615
},
{
"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": 85.03915809138867
},
{
"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": 80.23900749663805
},
{
"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": 72.86686702520322
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), deck: toClientDeck(player, deck) }];\n }\n case 'create': {\n const schema = z.object({\n deckLabel: z.string().min(1).max(20),\n nftIds: z.array(z.string().startsWith('nft1')).length(6),\n });\n const payload = schema.parse(body);\n const player = await authProvider.getPlayerFromRequest(req);\n const nfts = (await Promise.all((payload.nftIds).slice(0, 6).map(ExtDeps.getNft))).filter(Boolean).map(x => x.nft);",
"score": 72.40345835184975
}
] | typescript | ?.nftOwnershipConflict(player.id); |
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
const gameData = await gameEngineProvider.getGameData(game.id);
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider | .removePlayer(game.id, player.id, 'leave'); |
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
const rankings = await ds.Leaderboard.getTopN(20);
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort((a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
const gameData = await gameEngineProvider.startGame(game.id);
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game.gameState = `ended_${now.format(DATE_FORMAT)}`;
game.endedAt = now.format(FULL_DATETIME_FORMAT);
let gameData: GameEngine.IGameData | undefined = undefined;
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
await gameEngineProvider.endGame(game.id);
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
} | src/apis/coop.api.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n const engine = new _Engine(gameData);\n try {\n if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);\n await func(engine);\n await ds.GameData.update.exec(gameData);\n } catch (e: any) {\n e.broadcast = engine.broadcast;\n throw e;\n }",
"score": 33.777271570558085
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " let score =\n player.cards.length * 50\n + player.stats.kills * 25\n + player.stats.memDmg * 50\n + player.stats.secDmg\n + player.stats.secBonus * 2\n + ((this.gameData.rulesetIds.length - 1) * 2000);\n score = GameEngineUtils.scaleByDifficulty(score, this.gameData.difficulty + 1);\n player.score = score;\n return { playerId: player.id, stats: player.stats, score };",
"score": 18.986605752060058
},
{
"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": 17.828854316286805
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " }\n export class _waveTrigger extends CardMod {\n constructor(\n public rulesetIds: string[],\n override duration = -1,\n ) {\n super(arguments);\n }\n override onInitMod(deps: ICardModDeps): void {\n deps.engine.gameData.difficulty < 3 && GameEngineUtils.changeSec(deps.engine, deps.sourceCard, 25, true);",
"score": 16.07754756900688
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " ruleset!: GameEngine.IRuleset;\n constructor(\n readonly gameData: GameEngine.IGameData,\n ) {\n const currentRuleset = rulesets[gameData.rulesetIds.at(-1)!];\n if (!currentRuleset) throw new Error('invalid initial ruleSet id: ' + gameData.rulesetIds[0]);\n this._setRuleset(currentRuleset);\n }\n private static async _withEngine(gameId: string, stateAssertion: GameEngine.IGameData['state'][], func: (engine: _Engine) => Promise<void>): Promise<GameEngine.IGameData> {\n const gameData = await ds.GameData.get(gameId);",
"score": 15.714954034876818
}
] | typescript | .removePlayer(game.id, player.id, 'leave'); |
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": " 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": 60.504629862990306
},
{
"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": 54.791360897963806
},
{
"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": 51.698860651925166
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 48.504041586827896
},
{
"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": 47.306573842148836
}
] | typescript | toClientPlayer(player, authProvider), status: 'gamecreated' }]; |
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
const gameData = await gameEngineProvider.getGameData(game.id);
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider.removePlayer(game.id, player.id, 'leave');
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
const rankings = await ds.Leaderboard.getTopN(20);
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort((a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
| if (await rateLimit.shouldRateLimitSearchGame(player.id)) { |
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
const gameData = await gameEngineProvider.startGame(game.id);
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game.gameState = `ended_${now.format(DATE_FORMAT)}`;
game.endedAt = now.format(FULL_DATETIME_FORMAT);
let gameData: GameEngine.IGameData | undefined = undefined;
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
await gameEngineProvider.endGame(game.id);
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
} | src/apis/coop.api.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (engine.gameData.players.size >= 2) throw new Error('game is full: ' + gameId);\n if (engine.gameData.state === 'started') {\n const playerState = await engine._createPlayerState(playerId, cardIds);\n engine.gameData.players.set(playerId, playerState);\n if (engine.gameData.turn >= 2) {\n playerState.endedTurn = true;\n playerState.movesLeft = 0;\n }\n engine.broadcast.push({\n type: 'playerJoin',",
"score": 57.00923890038876
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const existingGameData = await ds.GameData.get(gameId);\n if (existingGameData) throw new Error('game with id already exists: ' + gameId);\n const gameData: GameEngine.IGameData = {\n id: gameId,\n difficulty: Math.max(1, difficulty),\n state: 'created',\n turn: 1,\n players: new Map(),\n defaultMovesPerTurn: 3,\n enemies: [],",
"score": 45.680448729512854
},
{
"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": 44.87204876171751
},
{
"filename": "src/net-utils.ts",
"retrieved_chunk": " /**\n * Server state is incompatible with request, e.g. leaving a game without being in a game.\n * This could be due to stale state on the client or wrong client logic.\n */\n forbidden = 403, // retry won't help\n /**\n * Resource specified in the request does not exist and it is unknown whether it ever existed\n */\n notFound = 404,\n /**",
"score": 41.99658365995208
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n const engine = new _Engine(gameData);\n try {\n if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);\n await func(engine);\n await ds.GameData.update.exec(gameData);\n } catch (e: any) {\n e.broadcast = engine.broadcast;\n throw e;\n }",
"score": 40.89451459341185
}
] | typescript | if (await rateLimit.shouldRateLimitSearchGame(player.id)) { |
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": " return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];\n }\n case 'list': {\n const schema = z.object({\n ct: z.string().optional(),\n });\n const q = schema.parse(query);\n const player = await authProvider.getPlayerFromRequest(req);\n const decks = await Promise.all((await ds.CardDecks.queryByDid(player.id, 10, q.ct)).items);\n if (!decks.length) {",
"score": 45.76602275069278
},
{
"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": 34.285876817553884
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " });\n const payload = schema.parse(body);\n const uniqueNftIds = new Set<string>(payload.nftIds);\n if (uniqueNftIds.size !== 6) {\n return [StatusCodes.badRequest, { reason: 'nftIds must contain 6 unique NFT ids that belong to the player' }];\n }\n const player = await authProvider.getPlayerFromRequest(req);\n const deck = await ds.CardDecks.get(player.id, payload.deckId);\n if (!deck) {\n return [StatusCodes.notFound, { reason: 'invalid deck id' }];",
"score": 33.74991845368182
},
{
"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": 31.860621940377037
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " ...payload.didProof,\n message: 'Proof of DID ownership for ChiaTCG',\n }))?.did;\n if (!did) {\n return [StatusCodes.unauthorized, { reason: 'unable to validate did proof' }];\n }\n let player = await ds.Players.get(did);\n const isNew = !player;\n const now = moment.utc();\n const newSecret = authProvider.generateNewSecret();",
"score": 30.930429931942335
}
] | typescript | (a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size); |
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 | 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/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": 50.4183100635004
},
{
"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": 49.376042697774096
},
{
"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": 45.986949247535755
},
{
"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": 44.992429430522826
},
{
"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
}
] | typescript | (_card) { |
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": 46.53669218952045
},
{
"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": 43.7563518629934
},
{
"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": 32.844720431638386
},
{
"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": 32.551992108101885
},
{
"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": 31.214692353604363
}
] | typescript | const card = appraiseCard({ nftId: generateId(), mintHeight: 1, url: '' }); |
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/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": 62.389022582314794
},
{
"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": 60.76045271670177
},
{
"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": 55.93269486929979
},
{
"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": 54.00741643545139
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 46.15389220047326
}
] | typescript | const playerId = authProvider.getPlayerIdFromRequest(req); |
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/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": 44.85267502572658
},
{
"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.14144637676
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " });\n const payload = schema.parse(body);\n const uniqueNftIds = new Set<string>(payload.nftIds);\n if (uniqueNftIds.size !== 6) {\n return [StatusCodes.badRequest, { reason: 'nftIds must contain 6 unique NFT ids that belong to the player' }];\n }\n const player = await authProvider.getPlayerFromRequest(req);\n const deck = await ds.CardDecks.get(player.id, payload.deckId);\n if (!deck) {\n return [StatusCodes.notFound, { reason: 'invalid deck id' }];",
"score": 43.96639502561792
},
{
"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": 38.17854264427716
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 37.77247785717099
}
] | typescript | const rankings = await ds.Leaderboard.getTopN(20); |
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": " 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": 52.256112405935504
},
{
"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": 51.964679024770724
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " });\n const payload = schema.parse(body);\n const uniqueNftIds = new Set<string>(payload.nftIds);\n if (uniqueNftIds.size !== 6) {\n return [StatusCodes.badRequest, { reason: 'nftIds must contain 6 unique NFT ids that belong to the player' }];\n }\n const player = await authProvider.getPlayerFromRequest(req);\n const deck = await ds.CardDecks.get(player.id, payload.deckId);\n if (!deck) {\n return [StatusCodes.notFound, { reason: 'invalid deck id' }];",
"score": 44.47926327831431
},
{
"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": 40.60442810557377
},
{
"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": 39.551299724514905
}
] | typescript | .cards.map(x => x.nftId)); |
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
const gameData = await gameEngineProvider.getGameData(game.id);
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider.removePlayer(game.id, player.id, 'leave');
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
const rankings = await ds.Leaderboard.getTopN(20);
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort((a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
const gameData = await gameEngineProvider.startGame(game.id);
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game | .gameState = `ended_${now.format(DATE_FORMAT)}`; |
game.endedAt = now.format(FULL_DATETIME_FORMAT);
let gameData: GameEngine.IGameData | undefined = undefined;
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
await gameEngineProvider.endGame(game.id);
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
} | src/apis/coop.api.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const existingGameData = await ds.GameData.get(gameId);\n if (existingGameData) throw new Error('game with id already exists: ' + gameId);\n const gameData: GameEngine.IGameData = {\n id: gameId,\n difficulty: Math.max(1, difficulty),\n state: 'created',\n turn: 1,\n players: new Map(),\n defaultMovesPerTurn: 3,\n enemies: [],",
"score": 45.73166816977411
},
{
"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": 42.39381976964949
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " // Stop if the game was won/lost due to an EndTurn effect\n return;\n }\n engine.onTurnStart();\n }\n });\n }\n static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {\n let kickedPlayerId = '';\n await _Engine._withEngine(gameId, ['started'], async engine => {",
"score": 39.0027832317868
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n const engine = new _Engine(gameData);\n try {\n if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);\n await func(engine);\n await ds.GameData.update.exec(gameData);\n } catch (e: any) {\n e.broadcast = engine.broadcast;\n throw e;\n }",
"score": 36.176044686140074
},
{
"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": 35.134767896544126
}
] | typescript | .gameState = `ended_${now.format(DATE_FORMAT)}`; |
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": 64.7896456405611
},
{
"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": 62.1148088571133
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const existingGameData = await ds.GameData.get(gameId);\n if (existingGameData) throw new Error('game with id already exists: ' + gameId);\n const gameData: GameEngine.IGameData = {\n id: gameId,\n difficulty: Math.max(1, difficulty),\n state: 'created',\n turn: 1,\n players: new Map(),\n defaultMovesPerTurn: 3,\n enemies: [],",
"score": 57.76030512083638
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (engine.gameData.players.size >= 2) throw new Error('game is full: ' + gameId);\n if (engine.gameData.state === 'started') {\n const playerState = await engine._createPlayerState(playerId, cardIds);\n engine.gameData.players.set(playerId, playerState);\n if (engine.gameData.turn >= 2) {\n playerState.endedTurn = true;\n playerState.movesLeft = 0;\n }\n engine.broadcast.push({\n type: 'playerJoin',",
"score": 55.43111721775612
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n const engine = new _Engine(gameData);\n try {\n if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);\n await func(engine);\n await ds.GameData.update.exec(gameData);\n } catch (e: any) {\n e.broadcast = engine.broadcast;\n throw e;\n }",
"score": 53.75510584790776
}
] | typescript | deck = await getOrCreateActiveDeck(player, ds); |
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": " return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];\n }\n case 'list': {\n const schema = z.object({\n ct: z.string().optional(),\n });\n const q = schema.parse(query);\n const player = await authProvider.getPlayerFromRequest(req);\n const decks = await Promise.all((await ds.CardDecks.queryByDid(player.id, 10, q.ct)).items);\n if (!decks.length) {",
"score": 45.76602275069278
},
{
"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": 34.285876817553884
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " });\n const payload = schema.parse(body);\n const uniqueNftIds = new Set<string>(payload.nftIds);\n if (uniqueNftIds.size !== 6) {\n return [StatusCodes.badRequest, { reason: 'nftIds must contain 6 unique NFT ids that belong to the player' }];\n }\n const player = await authProvider.getPlayerFromRequest(req);\n const deck = await ds.CardDecks.get(player.id, payload.deckId);\n if (!deck) {\n return [StatusCodes.notFound, { reason: 'invalid deck id' }];",
"score": 33.74991845368182
},
{
"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": 31.860621940377037
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " ...payload.didProof,\n message: 'Proof of DID ownership for ChiaTCG',\n }))?.did;\n if (!did) {\n return [StatusCodes.unauthorized, { reason: 'unable to validate did proof' }];\n }\n let player = await ds.Players.get(did);\n const isNew = !player;\n const now = moment.utc();\n const newSecret = authProvider.generateNewSecret();",
"score": 30.930429931942335
}
] | typescript | , b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size); |
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": " return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];\n }\n case 'list': {\n const schema = z.object({\n ct: z.string().optional(),\n });\n const q = schema.parse(query);\n const player = await authProvider.getPlayerFromRequest(req);\n const decks = await Promise.all((await ds.CardDecks.queryByDid(player.id, 10, q.ct)).items);\n if (!decks.length) {",
"score": 45.62805092628657
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " });\n const payload = schema.parse(body);\n const uniqueNftIds = new Set<string>(payload.nftIds);\n if (uniqueNftIds.size !== 6) {\n return [StatusCodes.badRequest, { reason: 'nftIds must contain 6 unique NFT ids that belong to the player' }];\n }\n const player = await authProvider.getPlayerFromRequest(req);\n const deck = await ds.CardDecks.get(player.id, payload.deckId);\n if (!deck) {\n return [StatusCodes.notFound, { reason: 'invalid deck id' }];",
"score": 43.449591774243835
},
{
"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": 42.47450666270749
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " ...payload.didProof,\n message: 'Proof of DID ownership for ChiaTCG',\n }))?.did;\n if (!did) {\n return [StatusCodes.unauthorized, { reason: 'unable to validate did proof' }];\n }\n let player = await ds.Players.get(did);\n const isNew = !player;\n const now = moment.utc();\n const newSecret = authProvider.generateNewSecret();",
"score": 42.427578822815775
},
{
"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": 35.76284013029687
}
] | typescript | gameData = await ds.GameData.get(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/cards.api.ts",
"retrieved_chunk": " if (resp?.nfts.length) {\n return [StatusCodes.ok, {\n cards: resp.nfts.map(nft => ({\n ...appraiseCard({ nftId: nft.nftId, mintHeight: nft.firstBlock, url: nft.urls[0] || '' }),\n urls: nft.urls,\n })),\n ct: resp.ct,\n }];\n }\n return [StatusCodes.notFound, { reason: 'no nfts found' }];",
"score": 72.94037558863562
},
{
"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": 71.73606370722518
},
{
"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": 54.416951972898715
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);\n await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));\n if (payload.gameVisibility === 'solo') {\n await _onGameStart(game, false);\n }\n player.activeGameId = game.id;\n await ds.execUpdates(\n ds.CoopGames.update.make(game),\n ds.Players.update.make(player),\n );",
"score": 53.09158329359231
},
{
"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": 48.82136975277043
}
] | typescript | metrics?.deckUpdated(player.id, deck.createdAt); |
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": " 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": 29.996857926770367
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n const engine = new _Engine(gameData);\n try {\n if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);\n await func(engine);\n await ds.GameData.update.exec(gameData);\n } catch (e: any) {\n e.broadcast = engine.broadcast;\n throw e;\n }",
"score": 21.059572783717186
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 18.762662932037326
},
{
"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": 18.737236713599664
},
{
"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": 17.24761479247048
}
] | typescript | await gameEngineProvider.endGame(game.id); |
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": " }\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": 77.51805928428158
},
{
"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": 77.33464053200822
},
{
"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": 72.3113394047524
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " });\n const payload = schema.parse(body);\n const uniqueNftIds = new Set<string>(payload.nftIds);\n if (uniqueNftIds.size !== 6) {\n return [StatusCodes.badRequest, { reason: 'nftIds must contain 6 unique NFT ids that belong to the player' }];\n }\n const player = await authProvider.getPlayerFromRequest(req);\n const deck = await ds.CardDecks.get(player.id, payload.deckId);\n if (!deck) {\n return [StatusCodes.notFound, { reason: 'invalid deck id' }];",
"score": 57.957758759436274
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), deck: toClientDeck(player, deck) }];\n }\n case 'create': {\n const schema = z.object({\n deckLabel: z.string().min(1).max(20),\n nftIds: z.array(z.string().startsWith('nft1')).length(6),\n });\n const payload = schema.parse(body);\n const player = await authProvider.getPlayerFromRequest(req);\n const nfts = (await Promise.all((payload.nftIds).slice(0, 6).map(ExtDeps.getNft))).filter(Boolean).map(x => x.nft);",
"score": 57.747501450276346
}
] | typescript | (x => ExtDeps.getNft(x.nftId))); |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.