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 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/tweet.ts",
"retrieved_chunk": "\t\t\tscreen_name: user?.screen_name,\n\t\t\tindices: [match.index, withTag.length + (match.index || 0)],\n\t\t});\n\t}\n\tconst tweetId = randInt(12);\n\tconst tweetData = {\n\t\tedit_perspective: {\n\t\t\tfavorited: false,\n\t\t\tretweeted: false,\n\t\t},",
"score": 0.7253456115722656
},
{
"filename": "src/models/Notification.ts",
"retrieved_chunk": "import mongoose from \"mongoose\";\nconst notification = new mongoose.Schema({\n\tid: String,\n\ttimestampMs: String,\n\ticon: {\n\t\tid: String,\n\t},\n\tmessage: {\n\t\ttext: String,\n\t\t// entities: [",
"score": 0.7100627422332764
},
{
"filename": "src/models/Message.ts",
"retrieved_chunk": "import mongoose from \"mongoose\";\nconst message = new mongoose.Schema({\n\tid: String,\n\ttime: String,\n\taffects_sort: Boolean,\n\trequest_id: String,\n\tconversation_id: String,\n\tmessage_data: {\n\t\tid: String,\n\t\ttime: String,",
"score": 0.7067989110946655
},
{
"filename": "src/types/guide.ts",
"retrieved_chunk": "}\nexport interface Broadcasts {}\nexport interface TweetValue {\n\tcreated_at: string;\n\tid: number;\n\tid_str: string;\n\tfull_text: string;\n\ttruncated: boolean;\n\tdisplay_text_range: number[];\n\tentities: TweetEntities;",
"score": 0.7000797390937805
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\twithQuickPromoteEligibilityTweetFields: boolean;\n\twithVoice: boolean;\n\twithV2Timeline: boolean;\n}\ninterface IFavouriteTweetVariables {\n\ttweet_id: string;\n}\nexport async function UserTweets(req: express.Request, res: express.Response) {\n\tconst loggedInUser = req.cookies[\"jwt\"]\n\t\t? await User.findOne({",
"score": 0.6960024237632751
}
] | 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": "\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": 0.8228157758712769
},
{
"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": 0.8124426007270813
},
{
"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": 0.7983846664428711
},
{
"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": 0.7865703701972961
},
{
"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": 0.7781194448471069
}
] | 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/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": 0.757179856300354
},
{
"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": 0.7359564304351807
},
{
"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": 0.7358720302581787
},
{
"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": 0.7252213954925537
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "// \t\t\tuser: {\n// \t\t\t\tresult: {\n// \t\t\t\t\t__typename: \"User\",\n// \t\t\t\t\tid: user._id,\n// \t\t\t\t\trest_id: user.id,\n// \t\t\t\t\taffiliates_highlighted_label: {\n// \t\t\t\t\t\tlabel: {\n// \t\t\t\t\t\t\turl: {\n// \t\t\t\t\t\t\t\turl: \"https://twitter.com/notnullptr\",\n// \t\t\t\t\t\t\t\turlType: \"DeepLink\",",
"score": 0.7123558521270752
}
] | typescript | user_mentions as IUserMention[]
).map((mention) => { |
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": 0.8659274578094482
},
{
"filename": "src/middleware/auth.ts",
"retrieved_chunk": "import { Request, Response, NextFunction } from \"express\";\nimport { verify } from \"jsonwebtoken\";\nimport User from \"../models/User\";\nimport { IJwtDecoded } from \"../types/graphql\";\nexport async function requireAuth(req: Request, res: Response): Promise<any> {\n\tif (!req.cookies[\"jwt\"])\n\t\treturn res\n\t\t\t.status(401)\n\t\t\t.send({ msg: \"No auth token (are you missing your jwt cookie?)\" });\n\ttry {",
"score": 0.8002790808677673
},
{
"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": 0.7982351779937744
},
{
"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": 0.7915918827056885
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t\t\t\t\tv1: [],\n\t\t\t\t\t},\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 AuthenticatedUserTFLists(\n\treq: express.Request,",
"score": 0.74528968334198
}
] | typescript | = await requireAuth(req, res); |
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/tweet.ts",
"retrieved_chunk": "\tif (!user) return res.status(400).send({ msg: \"User not found\" });\n\tconst user_mentions = [] as IUserMention[];\n\tconst matches = body.variables.tweet_text.matchAll(/@(\\S+)/gm);\n\tfor (const match of matches) {\n\t\tconst withTag = match[0];\n\t\tconst withoutTag = match[1];\n\t\tconst user = await User.findOne({ screen_name: withoutTag });\n\t\tuser_mentions.push({\n\t\t\tid_str: user?.id_string,\n\t\t\tname: user?.name,",
"score": 0.7309137582778931
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\t});\n\tif (!loggedInUser) return res.status(400).send({ msg: \"Not authenticated\" });\n\tconst userTweets = [];\n\tconst postedTweets = await Tweet.find().limit(50);\n\tfor (const tweet of postedTweets) {\n\t\tconst user = await User.findOne({ id_string: tweet.user_id_str });\n\t\tif (!user) return res.status(400).send({ msg: \"User not found\" });\n\t\tuserTweets.push({\n\t\t\tis_translatable: false,\n\t\t\tlegacy: Object.assign(tweet, {",
"score": 0.7304888367652893
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\t\tawait user.save();\n\t\tawait tweet.save();\n\t} else {\n\t\treturn res.status(400).send({ data: { favourte_tweet: \"NOT DONE\" } });\n\t}\n\tif (tweet.user_id_str !== user.id_string)\n\t\taddNotification(\n\t\t\t\"%1 liked your tweet!\",\n\t\t\t\"like\",\n\t\t\ttweet.user_id_str!,",
"score": 0.730312168598175
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\tif (user.liked_tweet_ids.includes(variables.tweet_id)) {\n\t\tuser.liked_tweet_ids = user.liked_tweet_ids.filter(\n\t\t\t(id) => id !== variables.tweet_id\n\t\t);\n\t\ttweet.favorite_count! -= 1;\n\t\tawait user.save();\n\t\tawait tweet.save();\n\t} else {\n\t\treturn res.status(400).send({ data: { unfavorite_tweet: \"NOT DONE\" } });\n\t}",
"score": 0.7101179361343384
},
{
"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": 0.7040364742279053
}
] | typescript | .findOne({ id_string: recipient }); |
import dotenv from "dotenv";
import ActionHandler from "./action-handler";
import { Agent } from "./agent";
import { startConsole } from "./console";
import { InMemoryMessageBus } from "./in-memory-message-bus";
import { Event, Memory } from "./memory";
import { MessageBus } from "./message-bus";
import core from "./module/definitions/core";
import filesystem from "./module/definitions/filesystem";
import goals from "./module/definitions/goals";
import messaging from "./module/definitions/messaging";
import notes from "./module/definitions/notes";
import web from "./module/definitions/web";
import { ModuleManager } from "./module/module-manager";
import { contextWindowSize } from "./openai";
import { model, numberOfAgents } from "./parameters";
import FileStore from "./store/file-store";
import JsonStore from "./store/json-store";
import { webSocketServer } from "./web-socket-server";
dotenv.config();
const agentIds = Array.from({ length: numberOfAgents + 1 }, (_, i) => `${i}`);
const messageBus: MessageBus = new InMemoryMessageBus();
main();
async function main() {
startConsole(agentIds, messageBus);
webSocketServer(messageBus, 8080);
for (const id of agentIds.slice(1)) {
const moduleManager = new ModuleManager(id, agentIds, [
core,
goals,
notes,
messaging,
filesystem,
web,
]);
const actionHandler = new ActionHandler(
agentIds,
messageBus,
moduleManager
);
const store = new JsonStore<Event[]>(new FileStore([id]));
// We have to leave room for the agent's next action, which is of unknown size
const compressionThreshold = Math.round(contextWindowSize[model] * 0.75);
const memory = new Memory(id, moduleManager, store, compressionThreshold);
const agent = new Agent(
id,
memory,
messageBus,
moduleManager,
actionHandler
);
| await agent.start(); |
}
}
| src/main.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/agent.ts",
"retrieved_chunk": "const actionInterval = 1000;\n// const heartbeatInterval = 60 * 1000;\nexport class Agent {\n constructor(\n public id: string,\n private memory: Memory,\n private messageBus: MessageBus,\n private moduleManager: ModuleManager,\n private actionHandler: ActionHandler\n ) {}",
"score": 0.8319128751754761
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " },\n async execute({\n parameters: { url },\n context: { agentId },\n sendMessage,\n }) {\n try {\n const maxCompletionTokens = contextWindowSize[model] / 4;\n // console.log({ maxCompletionTokens });\n const pageSummary = await getPageSummary(",
"score": 0.8201833963394165
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": "} from \"../util\";\nexport class Memory {\n private firstRetrieval = true;\n constructor(\n private agentId: string,\n private moduleManager: ModuleManager,\n private store: Store<Event[]>,\n private compressionThreshold: number\n ) {}\n async append(event: Event): Promise<Event[]> {",
"score": 0.7971929907798767
},
{
"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": 0.7969680428504944
},
{
"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": 0.7940084338188171
}
] | typescript | await agent.start(); |
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/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": 0.8066756725311279
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " `Note \"${title}\" has been written successfully.`\n )\n );\n },\n },\n viewNote: {\n description: \"Display the content of a note.\",\n parameters: {\n title: {\n description: \"The title of the note to view\",",
"score": 0.789929986000061
},
{
"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": 0.7726050615310669
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": " {\n ... the old content of action-dictionary.json ...\n },\n {\n \"title\": \"NewActionDefinition\",\n \"description\": \"This is an example of a new action definition.\",\n \"properties\": {\n \"type\": {\n \"type\": \"string\",\n \"const\": \"new-action-definition\"",
"score": 0.7660655975341797
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " )\n );\n },\n },\n readPage: {\n description: \"View a markdown summary of a web page.\",\n parameters: {\n url: {\n description: \"The URL of the web page to read\",\n },",
"score": 0.7633369565010071
}
] | typescript | : event.actionText,
}; |
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": " // 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": 0.8451759815216064
},
{
"filename": "src/module/definitions/web.test.ts",
"retrieved_chunk": " \"getSearchResults\",\n async () => {\n const results = await getSearchResults(`\"e/acc\" explanation and sources`);\n console.log(results?.map((item) => item.title).join(\"\\n\"));\n },\n 5 * 60 * 1000\n);",
"score": 0.7969892621040344
},
{
"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": 0.7936127185821533
},
{
"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": 0.7903635501861572
},
{
"filename": "src/agent.ts",
"retrieved_chunk": " this.taskQueue.runPeriodically(() => this.takeAction(), actionInterval);\n // Start heartbeat\n // this.taskQueue.runPeriodically(async () => {\n // const messages = await this.memory.retrieve();\n // const lastMessage = last(messages);\n // if (lastMessage?.type === \"decision\") {\n // this.messageBus.send(\n // messageBuilder.spontaneous(\n // this.id,\n // \"This is your regularly scheduled heartbeat message. Is there anything you need to do?\"",
"score": 0.7787154316902161
}
] | typescript | = await makeDecision([
...eventsToSummarize,
{ |
import { last } from "lodash";
import ActionHandler from "./action-handler";
import makeDecision from "./make-decision";
import { Memory } from "./memory";
import { messageBuilder } from "./message";
import { MessageBus } from "./message-bus";
import { ModuleManager } from "./module/module-manager";
import parseAction from "./parse-action";
import TaskQueue from "./task-queue";
import { agentName, sleep } from "./util";
const actionInterval = 1000;
// const heartbeatInterval = 60 * 1000;
export class Agent {
constructor(
public id: string,
private memory: Memory,
private messageBus: MessageBus,
private moduleManager: ModuleManager,
private actionHandler: ActionHandler
) {}
private taskQueue = new TaskQueue();
// Start this Agent's event loop
async start() {
// Subscribe to messages
this.messageBus.subscribe((message) => {
if (message.targetAgentIds && !message.targetAgentIds.includes(this.id))
return;
this.memory.append({ type: "message", message });
});
// Act on messages periodically
this.taskQueue.runPeriodically(() => this.takeAction(), actionInterval);
// Start heartbeat
// this.taskQueue.runPeriodically(async () => {
// const messages = await this.memory.retrieve();
// const lastMessage = last(messages);
// if (lastMessage?.type === "decision") {
// this.messageBus.send(
// messageBuilder.spontaneous(
// this.id,
// "This is your regularly scheduled heartbeat message. Is there anything you need to do?"
// )
// );
// }
// }, heartbeatInterval);
}
private async takeAction(): Promise<void> {
try {
let events = await this.memory.retrieve();
// Do not act again if the last event was a decision
if (last(events)?.type === "decision") return;
const actionText = await makeDecision(events);
// Reassign events in case summarization occurred
events = await this.memory.append({
type: "decision",
actionText,
});
const result = parseAction(this.moduleManager.actions, actionText);
if (result.type === "error") {
this.messageBus.send( | messageBuilder.error(this.id, result.message)); |
} else {
await this.actionHandler.handle(this.id, result.action);
}
} catch (e) {
console.error(
`${agentName(
this.id
)} encountered the following problem while attempting to take action:`
);
console.error(e);
} finally {
if (process.env.AGENT_DELAY) {
await sleep(parseInt(process.env.AGENT_DELAY));
}
}
}
}
| src/agent.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.printEvent(event);\n let events = await this.retrieve();\n if (event.type === \"message\" && event.message.type === \"ok\") {\n // After an \"ok\" message is sent, remove all errors and their antecedents from memory,\n // since agents tend to repeat mistakes rather than learning from them.\n events = this.removeErrors(events);\n }\n events.push(event);\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));",
"score": 0.817477822303772
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " return events;\n }\n async retrieve(): Promise<Event[]> {\n const introduction = await this.getIntroduction();\n const storedEvents = await this.store.get(this.key);\n let events = [\n introduction,\n ...(storedEvents || [{ type: \"decision\", actionText: \"noop\" }]),\n ];\n if (this.firstRetrieval) {",
"score": 0.8057553172111511
},
{
"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": 0.7934735417366028
},
{
"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": 0.7932136058807373
},
{
"filename": "src/action-handler.ts",
"retrieved_chunk": " actionDef.execute({\n context: this.moduleManager.getModuleForAction(actionDef.name)!.context,\n parameters,\n sendMessage: (message) => this.messageBus.send(message),\n });\n }\n}",
"score": 0.7845461368560791
}
] | typescript | messageBuilder.error(this.id, result.message)); |
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/task-queue.ts",
"retrieved_chunk": " this.tasks.push(() => task().then(resolve).catch(reject));\n this.runNext();\n });\n }\n runPeriodically(task: Task, milliseconds: number): void {\n let pending = false;\n this.intervals.push(\n setInterval(() => {\n if (pending) return;\n pending = true;",
"score": 0.7936723232269287
},
{
"filename": "src/main.ts",
"retrieved_chunk": "const agentIds = Array.from({ length: numberOfAgents + 1 }, (_, i) => `${i}`);\nconst messageBus: MessageBus = new InMemoryMessageBus();\nmain();\nasync function main() {\n startConsole(agentIds, messageBus);\n webSocketServer(messageBus, 8080);\n for (const id of agentIds.slice(1)) {\n const moduleManager = new ModuleManager(id, agentIds, [\n core,\n goals,",
"score": 0.772546648979187
},
{
"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": 0.7703713774681091
},
{
"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": 0.7648844122886658
},
{
"filename": "src/agent.ts",
"retrieved_chunk": " // )\n // );\n // }\n // }, heartbeatInterval);\n }\n private async takeAction(): Promise<void> {\n try {\n let events = await this.memory.retrieve();\n // Do not act again if the last event was a decision\n if (last(events)?.type === \"decision\") return;",
"score": 0.7642111778259277
}
] | typescript | module): Promise<string[]> => { |
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/task-queue.ts",
"retrieved_chunk": " this.tasks.push(() => task().then(resolve).catch(reject));\n this.runNext();\n });\n }\n runPeriodically(task: Task, milliseconds: number): void {\n let pending = false;\n this.intervals.push(\n setInterval(() => {\n if (pending) return;\n pending = true;",
"score": 0.7899709939956665
},
{
"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": 0.7680326104164124
},
{
"filename": "src/main.ts",
"retrieved_chunk": "const agentIds = Array.from({ length: numberOfAgents + 1 }, (_, i) => `${i}`);\nconst messageBus: MessageBus = new InMemoryMessageBus();\nmain();\nasync function main() {\n startConsole(agentIds, messageBus);\n webSocketServer(messageBus, 8080);\n for (const id of agentIds.slice(1)) {\n const moduleManager = new ModuleManager(id, agentIds, [\n core,\n goals,",
"score": 0.7667248845100403
},
{
"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": 0.7624629735946655
},
{
"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": 0.7618227005004883
}
] | typescript | .moduleManager.modules.map(async (module): Promise<string[]> => { |
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": " 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": 0.8160613775253296
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " engine.broadcast.push({\n type: 'playerToggleEndTurn',\n playerId,\n state: true,\n });\n if (![...engine.gameData.players.values()].reduce((numNotReady, playerState) => playerState.endedTurn ? numNotReady : (numNotReady + 1), 0)) {\n const now = moment.now();\n [...engine.gameData.players.values()].forEach(x => x.idleKickTime = now + 2 * SECS_IN_MIN * 1000);\n engine.onEndTurn();\n if (engine.gameData.state !== 'started') {",
"score": 0.7988506555557251
},
{
"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": 0.7963685393333435
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.7868781089782715
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\n static async endGame(gameId: string) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n engine.gameData.state = 'abandoned';\n engine.broadcast.push({ type: 'gameEnd' });\n });\n }\n static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n if (engine.gameData.players.has(playerId)) throw new Error('player already in game');",
"score": 0.7843291759490967
}
] | 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/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": 0.8869134187698364
},
{
"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": 0.870930016040802
},
{
"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": 0.832319438457489
},
{
"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": 0.8280353546142578
},
{
"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": 0.8151969313621521
}
] | typescript | const postedTweets = await Tweet.find().limit(50); |
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": 0.853785514831543
},
{
"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": 0.8267394304275513
},
{
"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": 0.8094693422317505
},
{
"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": 0.7979652881622314
},
{
"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": 0.7849894762039185
}
] | typescript | const tweet = await Tweet.findOne({ id_str: 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/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": 0.784076452255249
},
{
"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": 0.7823207378387451
},
{
"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": 0.7821946144104004
},
{
"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": 0.7717055678367615
},
{
"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": 0.7715845704078674
}
] | typescript | : 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": 0.8264234066009521
},
{
"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": 0.813154935836792
},
{
"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": 0.7948817014694214
},
{
"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": 0.789882242679596
},
{
"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": 0.7696084976196289
}
] | typescript | .ok(
agentId,
`Here are the contents of ${path}:\n${filesWithStats.join("\n")}`
)
); |
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": 0.8895071744918823
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " } catch (e: any) {\n sendMessage(\n messageBuilder.error(\n agentId,\n `Error extracting content from ${url}: ${e.message}`\n )\n );\n }\n },\n },",
"score": 0.8488134741783142
},
{
"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": 0.8484889268875122
},
{
"filename": "src/agent.ts",
"retrieved_chunk": " await this.actionHandler.handle(this.id, result.action);\n }\n } catch (e) {\n console.error(\n `${agentName(\n this.id\n )} encountered the following problem while attempting to take action:`\n );\n console.error(e);\n } finally {",
"score": 0.8309423923492432
},
{
"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": 0.8175126314163208
}
] | 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/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": 0.8286879062652588
},
{
"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": 0.8235247731208801
},
{
"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": 0.8221200704574585
},
{
"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": 0.8186361789703369
},
{
"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": 0.7984965443611145
}
] | typescript | (messageBuilder.error(agentId, JSON.stringify(err))); |
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/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": 0.8117607831954956
},
{
"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": 0.8068462610244751
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": "...\n${CODE_BLOCK_DELIMITER}\n`.trim(),\n };\n }\n text = `name: ${text}`;\n const jsonText =\n \"{\" +\n text\n .split(MULTILINE_DELIMITER)",
"score": 0.799935519695282
},
{
"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": 0.786130428314209
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " `Note \"${title}\" has been written successfully.`\n )\n );\n },\n },\n viewNote: {\n description: \"Display the content of a note.\",\n parameters: {\n title: {\n description: \"The title of the note to view\",",
"score": 0.7855615615844727
}
] | typescript | ${header}${content}`,
}; |
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/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": 0.8648672699928284
},
{
"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": 0.8087702989578247
},
{
"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": 0.8044520616531372
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " if (!checkPath(agentId, destinationPath, sendMessage)) return;\n try {\n await rename(sourcePath, destinationPath);\n sendMessage(\n messageBuilder.ok(\n agentId,\n `Moved ${sourcePath} to ${destinationPath}.`\n )\n );\n } catch (err) {",
"score": 0.7865237593650818
},
{
"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": 0.7801842093467712
}
] | typescript | messageBuilder.error(agentId, `Note "${title}" not found.`)
); |
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/filesystem.ts",
"retrieved_chunk": " if (!checkPath(agentId, destinationPath, sendMessage)) return;\n try {\n await rename(sourcePath, destinationPath);\n sendMessage(\n messageBuilder.ok(\n agentId,\n `Moved ${sourcePath} to ${destinationPath}.`\n )\n );\n } catch (err) {",
"score": 0.8665245771408081
},
{
"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": 0.8589537143707275
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " } catch (e: any) {\n sendMessage(\n messageBuilder.error(\n agentId,\n `Error extracting content from ${url}: ${e.message}`\n )\n );\n }\n },\n },",
"score": 0.8566464185714722
},
{
"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": 0.8519515991210938
},
{
"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": 0.8435344696044922
}
] | 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/game/game-engine.ts",
"retrieved_chunk": " }\n static async endGame(gameId: string) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n engine.gameData.state = 'abandoned';\n engine.broadcast.push({ type: 'gameEnd' });\n });\n }\n static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n if (engine.gameData.players.has(playerId)) throw new Error('player already in game');",
"score": 0.8392078876495361
},
{
"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": 0.8307206630706787
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8285098075866699
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const existingGameData = await ds.GameData.get(gameId);\n if (existingGameData) throw new Error('game with id already exists: ' + gameId);\n const gameData: GameEngine.IGameData = {\n id: gameId,\n difficulty: Math.max(1, difficulty),\n state: 'created',\n turn: 1,\n players: new Map(),\n defaultMovesPerTurn: 3,\n enemies: [],",
"score": 0.8268070220947266
},
{
"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": 0.8241275548934937
}
] | typescript | let gameData: GameEngine.IGameData | undefined = undefined; |
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 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": 0.8584151864051819
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8485071063041687
},
{
"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": 0.8410488367080688
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (engine.broadcast.length) {\n await Promise.all(\n [...gameData.players.keys()].map(playerId => playerPushProvider.push(playerId, engine.broadcast)),\n );\n }\n return gameData;\n }\n static async createGame(gameId: string, rulesetId: string, difficulty: number) {\n const ruleset = rulesets[rulesetId];\n if (!ruleset) throw new Error('invalid ruleSet id: ' + rulesetId);",
"score": 0.8383607864379883
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const existingGameData = await ds.GameData.get(gameId);\n if (existingGameData) throw new Error('game with id already exists: ' + gameId);\n const gameData: GameEngine.IGameData = {\n id: gameId,\n difficulty: Math.max(1, difficulty),\n state: 'created',\n turn: 1,\n players: new Map(),\n defaultMovesPerTurn: 3,\n enemies: [],",
"score": 0.8334540724754333
}
] | 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 playerState = await engine._createPlayerState(playerId, cardIds);\n engine.gameData.players.set(playerId, playerState);\n engine.broadcast.push({ type: 'playerJoin', playerState });\n }\n engine.gameData.pendingPlayers.clear();\n engine.gameData.state = 'started';\n engine.broadcast.push({ type: 'gameStart' });\n engine.ruleset.initGame(engine);\n });\n return gameData;",
"score": 0.8437623977661133
},
{
"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": 0.8307632207870483
},
{
"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": 0.8297211527824402
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 0.8190690279006958
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " playerId: player.id,\n createdAt: nowStr,\n cards: cards.map(x => ({ nftId: x.nftId, mintHeight: x.firstBlock, url: x.urls[0] || '' })),\n label: 'default',\n };\n await ds.execUpdates(\n ds.Players.update.make(player, true),\n ds.CardDecks.update.make(deck, true),\n );\n return deck;",
"score": 0.8129159212112427
}
] | typescript | return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }]; |
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/web.ts",
"retrieved_chunk": " description: \"The string to search for\",\n },\n },\n async execute({\n parameters: { searchString },\n context: { agentId },\n sendMessage,\n }) {\n const items = await getSearchResults(searchString);\n if (!items) {",
"score": 0.8095721006393433
},
{
"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": 0.8077707290649414
},
{
"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": 0.7997404336929321
},
{
"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": 0.7996600866317749
},
{
"filename": "src/module/definitions/core.ts",
"retrieved_chunk": " aboutAction: {\n description: \"The name of an action to get help on\",\n },\n },\n async execute({\n parameters: { aboutAction },\n context: { agentId, actionDictionary },\n sendMessage,\n }) {\n const actionDef = actionDictionary.get(aboutAction);",
"score": 0.799498975276947
}
] | typescript | messageBuilder.error(agentId, `Invalid goal index: ${goalNumber}`)
); |
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 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": 0.8335298299789429
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " engine.broadcast.push({\n type: 'playerToggleEndTurn',\n playerId,\n state: true,\n });\n if (![...engine.gameData.players.values()].reduce((numNotReady, playerState) => playerState.endedTurn ? numNotReady : (numNotReady + 1), 0)) {\n const now = moment.now();\n [...engine.gameData.players.values()].forEach(x => x.idleKickTime = now + 2 * SECS_IN_MIN * 1000);\n engine.onEndTurn();\n if (engine.gameData.state !== 'started') {",
"score": 0.8222243785858154
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\n static async endGame(gameId: string) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n engine.gameData.state = 'abandoned';\n engine.broadcast.push({ type: 'gameEnd' });\n });\n }\n static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n if (engine.gameData.players.has(playerId)) throw new Error('player already in game');",
"score": 0.8162765502929688
},
{
"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": 0.8136864900588989
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8129221200942993
}
] | typescript | if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id'); |
import * as moment from 'moment';
import { z } from 'zod';
import { IAuthProvider, IDataSource, IMetricsProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { toClientPlayer } from '../models';
import { IHttpRouteHandler, StatusCodes } from '../net-utils';
import { FULL_DATETIME_FORMAT } from '../utils';
export const createPlayerHandler = (ds: IDataSource, authProvider: IAuthProvider, metrics?: IMetricsProvider): IHttpRouteHandler =>
async (path, _query, body, req) => {
switch (path[0]) {
case 'connectDid': {
const schema = z.object({
didProof: z.object({
latestCoinId: z.string(),
pubkey: z.string(),
signature: z.string(),
}),
});
const payload = schema.parse(body);
const did = (await ExtDeps.verifyDidProof({
...payload.didProof,
message: 'Proof of DID ownership for ChiaTCG',
}))?.did;
if (!did) {
return [StatusCodes.unauthorized, { reason: 'unable to validate did proof' }];
}
let player = await ds.Players.get(did);
const isNew = !player;
const now = moment.utc();
const newSecret = authProvider.generateNewSecret();
const newAuthExpireAt = moment.utc(now).add({ days: 14 }).format(FULL_DATETIME_FORMAT);
if (!player) {
const nowStr = now.format(FULL_DATETIME_FORMAT);
player = await ds.Players.update.exec({
id: did,
createdAt: nowStr,
lastSeenAt: nowStr,
secret: newSecret,
authExpiresAt: newAuthExpireAt,
activeGameId: '',
activeDeckId: 'default',
score: 0,
});
metrics?.newUser(player.id);
} else {
ds.Leaderboard.set(player.id, player.score);
player.secret = newSecret;
player.authExpiresAt = newAuthExpireAt;
await ds.Players.update.exec(player);
}
return [StatusCodes.ok, {
player: | toClientPlayer(player, authProvider),
status: isNew ? 'new' : 'existing',
}]; |
}
case 'me': {
const player = await authProvider.getPlayerFromRequest(req);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
}
return;
}; | src/apis/players.api.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " ds.CoopGames.update.make(game),\n );\n if (!game.startedAt && game.playersIds.size >= 2) {\n await _onGameStart(game, !!payload.fromMatchmaking);\n }\n metrics?.gameJoined(game.id, gameData.turn >= 2);\n return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];\n }\n case 'leave': {\n const { player, game } = await _expectAuthPlayerInGame(req);",
"score": 0.8676496744155884
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " await gameEngineProvider.removePlayer(game.id, player.id, 'leave');\n } catch {\n // Respect the player's request to leave even if the gameData couldn't be updated for some reason\n }\n if (!game.playersIds.size) {\n await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);\n }\n return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];\n }\n case 'rankings': {",
"score": 0.8493770360946655
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " removePlayers && (player.activeGameId = '');\n const playerState = gameData?.players.get(playerId);\n if (playerState?.score) {\n player.score += playerState?.score || 0;\n await ds.Leaderboard.set(player.id, player.score);\n }\n return [\n ds.PlayerCoopGames.update.make({\n playerId,\n endedAt: game.endedAt,",
"score": 0.8452451825141907
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];\n }\n case 'history': {\n const playerId = authProvider.getPlayerIdFromRequest(req);\n const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);\n return [StatusCodes.ok, games];\n }\n case 'join': {\n const schema = z.object({\n teammateDid: z.string().nonempty(),",
"score": 0.8434655666351318
},
{
"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": 0.8310783505439758
}
] | typescript | toClientPlayer(player, authProvider),
status: isNew ? 'new' : 'existing',
}]; |
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/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": 0.776969850063324
},
{
"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": 0.7720568776130676
},
{
"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": 0.7643375396728516
},
{
"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": 0.7553176879882812
},
{
"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": 0.7475804686546326
}
] | typescript | : messageBuilder.spontaneous(
this.agentId,
nestedEvents.flat().join("\n\n")
),
}; |
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/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": 0.857125997543335
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " } catch (e: any) {\n sendMessage(\n messageBuilder.error(\n agentId,\n `Error extracting content from ${url}: ${e.message}`\n )\n );\n }\n },\n },",
"score": 0.8427020907402039
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));\n }\n },\n },\n moveFile: {\n description: \"Move a file to a new location\",\n parameters: {\n sourcePath: {\n description: \"The original path of the file\",\n },",
"score": 0.823829174041748
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " } catch (err) {\n sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));\n }\n },\n },\n createDirectory: {\n description: \"Create a new directory\",\n parameters: {\n path: {\n description: \"The path of the directory to create\",",
"score": 0.8234604597091675
},
{
"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": 0.8185423612594604
}
] | 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/agent.ts",
"retrieved_chunk": " await this.actionHandler.handle(this.id, result.action);\n }\n } catch (e) {\n console.error(\n `${agentName(\n this.id\n )} encountered the following problem while attempting to take action:`\n );\n console.error(e);\n } finally {",
"score": 0.8549755215644836
},
{
"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": 0.8531949520111084
},
{
"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": 0.8518648147583008
},
{
"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": 0.8300420045852661
},
{
"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": 0.8249964714050293
}
] | typescript | messageBuilder.error(
agentId,
`Error extracting content from ${url}: ${e.message}`
)
); |
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": " enemyCards: {},\n initGame(_engine: GameEngine.IGameEngine) {\n throw new Error('not a startable scenario');\n },\n addAdditionalScriptsFor(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState) {\n if (card.card.tier < 2) return;\n switch (card.card.faction) {\n case 'backdoor':\n card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bd_')).random()]).serialize());\n return;",
"score": 0.8473871946334839
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " enemy.intent = undefined;\n if (regenerateIfInvalid) {\n generateIntent(engine, enemy);\n }\n }\n }\n export function removeCard(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, contextCard?: GameEngine.ICardState) {\n if (card.isRemoved) {\n return;\n }",
"score": 0.8451297283172607
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " throw new Error(`Could not find [${modName}] to remove`);\n }\n }\n CardMod.removeModByName(engine, targetCard, modName, sourceCard);\n };\n export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>\n (engine, sourceCard, _targetCard) => {\n let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);\n switch (spawnPosition) {\n case 'absLeft': spawnIndex = 0; break;",
"score": 0.8353155851364136
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " export function isPlayerCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IPlayerCardState {\n return !isEnemyCard(gameData, card);\n }\n export function recalculateScripts(engine: GameEngine.IGameEngine, card: GameEngine.ICardState) {\n if (card.isRemoved) return;\n card.scripts = card.scripts.map(x => CardScript.deserialize(engine, card, x).serialize());\n engine.broadcast.push(...card.scripts.map(x => ({\n type: 'scriptChanged',\n cardId: card.id,\n scriptData: x,",
"score": 0.8326588869094849
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " if (Math.random() < chance) {\n curriedPart(engine, sourceCard, targetCard);\n }\n };\n export const _TargetHasMod = <T extends CardMod.ModLibrary, K extends keyof T>(modName: K, curry: (mod: InstanceType<T[K]>) => IScriptPart): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n const mod = targetCard.mods.find(x => x[0] === modName);\n if (mod) {\n curry(CardMod.deserialize(engine, mod) as InstanceType<T[K]>)(engine, sourceCard, targetCard);\n }",
"score": 0.8301387429237366
}
] | typescript | const existingModData = card.mods.find(x => x[0] === mod.modName); |
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/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": 0.7414389848709106
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " sendMessage(messageBuilder.ok(agentId, `Created directory ${path}.`));\n } catch (err) {\n sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));\n }\n },\n },\n },\n});\nfunction checkPath(\n agentId: string,",
"score": 0.7228420972824097
},
{
"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": 0.7162775993347168
},
{
"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": 0.7112948298454285
},
{
"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": 0.7080968618392944
}
] | typescript | message\`. ${getUsageText(
messaging.actions.sendMessage
)}`
); |
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/web.test.ts",
"retrieved_chunk": " \"getSearchResults\",\n async () => {\n const results = await getSearchResults(`\"e/acc\" explanation and sources`);\n console.log(results?.map((item) => item.title).join(\"\\n\"));\n },\n 5 * 60 * 1000\n);",
"score": 0.781092643737793
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " cleaned.push(event);\n }\n cleaned.reverse();\n // console.log({ events, cleaned });\n return cleaned;\n }\n /**\n * Compress the event history when it becomes too large in order to free up the context window.\n */\n private async summarize(events: Event[]): Promise<Event[]> {",
"score": 0.7652900815010071
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " (this.compressionThreshold * AVG_WORDS_PER_TOKEN) / 6\n );\n const eventsToSummarize = events.slice(0, i);\n // console.log(\n // `Summarizing ${eventsToSummarize.length} events (${eventsToSummarize\n // .map(countTokens)\n // .reduce((sum, next) => sum + next, 0)} tokens)`\n // );\n const summaryContent = await makeDecision([\n ...eventsToSummarize,",
"score": 0.7607059478759766
},
{
"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": 0.7605606317520142
},
{
"filename": "src/make-decision.ts",
"retrieved_chunk": " const responseContent = await createChatCompletion({\n model,\n messages,\n temperature: 0.0,\n });\n console.log(\n `Arrived at a decision after ${((Date.now() - t0) / 1000).toFixed(1)}s`\n );\n return responseContent;\n}",
"score": 0.7514662742614746
}
] | typescript | const maxCompletionTokens = Math.round(contextWindowSize[model] * 0.9); |
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/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": 0.8474982380867004
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " } catch (e: any) {\n sendMessage(\n messageBuilder.error(\n agentId,\n `Error extracting content from ${url}: ${e.message}`\n )\n );\n }\n },\n },",
"score": 0.8264769315719604
},
{
"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": 0.8199688792228699
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " if (!checkPath(agentId, destinationPath, sendMessage)) return;\n try {\n await rename(sourcePath, destinationPath);\n sendMessage(\n messageBuilder.ok(\n agentId,\n `Moved ${sourcePath} to ${destinationPath}.`\n )\n );\n } catch (err) {",
"score": 0.8157413005828857
},
{
"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": 0.8096194267272949
}
] | typescript | messageBuilder.agentToAgent(agentId, [targetAgentId], message)
); |
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": 0.8081418871879578
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " Leaderboard: {\n getTopN(_n) { return [] as any; },\n async set(_playerId, _score) { },\n },\n async execUpdates(...updateRequests) {\n updateRequests.forEach(x => x());\n },\n};\n// Note: replace with an actual auth provider\nconst authProvider: IAuthProvider = {",
"score": 0.795210599899292
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " }\n }\n return standardTargets;\n };\n export const Any = (ignoreTaunt = false): ITargetFinder =>\n (gameData, card) => [\n ...Opponents(ignoreTaunt)(gameData, card),\n ...Allies()(gameData, card),\n ];\n export const _ModFilter = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modFilter: K[], targetFinder: ITargetFinder): ITargetFinder =>",
"score": 0.7859075665473938
},
{
"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": 0.7652537822723389
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " }\n};\nconst rateLimitProvider: IRateLimitProvider = {\n async shouldRateLimitCreateGame(_playerId) {\n return false;\n },\n async shouldRateLimitSearchGame(_playerId) {\n return false;\n },\n};",
"score": 0.764139711856842
}
] | typescript | (req: IHttpRequest): Promise<IDataSource.IPlayer>; |
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-mods.ts",
"retrieved_chunk": " neverReplace,\n ranked,\n replace,\n stack,\n }\n export interface ICardModDeps {\n engine: GameEngine.IGameEngine;\n sourceCard: GameEngine.ICardState;\n contextCard?: GameEngine.ICardState;\n }",
"score": 0.7965637445449829
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " ) {\n super();\n this.message = `${this.constructor.name} processing game ${gameId}`;\n }\n }\n export class GameNotFoundError extends GameEngineError { }\n export interface IRulesetContent {\n cardMods?: CardMod.ModLibrary;\n cardScripts?: CardScript.ScriptLibrary;\n enemyCards?: Record<string, (engine: IGameEngine) => IEnemyCardState>;",
"score": 0.7959340810775757
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " },\n Players: {\n ...playersTable,\n },\n PlayerCoopGames: {\n ...playerCoopGamesTable,\n async queryByPlayerId(playerId: string) {\n return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };\n },\n },",
"score": 0.792559027671814
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " }\n }\n return standardTargets;\n };\n export const Any = (ignoreTaunt = false): ITargetFinder =>\n (gameData, card) => [\n ...Opponents(ignoreTaunt)(gameData, card),\n ...Allies()(gameData, card),\n ];\n export const _ModFilter = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modFilter: K[], targetFinder: ITargetFinder): ITargetFinder =>",
"score": 0.7861171960830688
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\n export interface IEnemyCardState extends _ICommonCardState {\n enemyClass: string;\n intent?: { scriptData: CardScript.ScriptData, targetCardId: number };\n maxMem: number;\n }\n export type ICardState = IPlayerCardState | IEnemyCardState;\n export abstract class GameEngineError extends Error {\n constructor(\n public gameId: string,",
"score": 0.7843227386474609
}
] | typescript | <GameEngine.IGameData>; |
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": " },\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": 0.9241978526115417
},
{
"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": 0.918354332447052
},
{
"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": 0.914536714553833
},
{
"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": 0.911769449710846
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " destinationPath: {\n description: \"The new path for the file\",\n },\n },\n async execute({\n parameters: { sourcePath, destinationPath },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, sourcePath, sendMessage)) return;",
"score": 0.9057037830352783
}
] | 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/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": 0.675308108329773
},
{
"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": 0.6717654466629028
},
{
"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": 0.663671612739563
},
{
"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": 0.6612163186073303
},
{
"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": 0.6573629379272461
}
] | typescript | `Extraneous parameter \`foo\`. ${getUsageText(core.actions.noop)}`
); |
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": " }\n static async endGame(gameId: string) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n engine.gameData.state = 'abandoned';\n engine.broadcast.push({ type: 'gameEnd' });\n });\n }\n static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n if (engine.gameData.players.has(playerId)) throw new Error('player already in game');",
"score": 0.8479238152503967
},
{
"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": 0.8450246453285217
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8417056798934937
},
{
"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": 0.8387132287025452
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (engine.broadcast.length) {\n await Promise.all(\n [...gameData.players.keys()].map(playerId => playerPushProvider.push(playerId, engine.broadcast)),\n );\n }\n return gameData;\n }\n static async createGame(gameId: string, rulesetId: string, difficulty: number) {\n const ruleset = rulesets[rulesetId];\n if (!ruleset) throw new Error('invalid ruleSet id: ' + rulesetId);",
"score": 0.8356712460517883
}
] | 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/message.ts",
"retrieved_chunk": "export const systemSource: SystemMessageSource = { type: \"system\" };\nexport const agentSource = (id: string): AgentMessageSource => ({\n type: \"agent\",\n id,\n});\nexport const CODE_BLOCK_DELIMITER = \"```\";\nexport const messageBuilder = addMessageTypes({\n spontaneous: singleTargetSystemMessage,\n ok: singleTargetSystemMessage,\n error: singleTargetSystemMessage,",
"score": 0.794764518737793
},
{
"filename": "src/util.ts",
"retrieved_chunk": " clearInterval(interval);\n resolve();\n }\n }, 1000);\n });\n}\nexport function messageSourceName(source: MessageSource) {\n return source.type === \"system\" ? \"System\" : agentName(source.id);\n}\nexport function agentName(agentId: string) {",
"score": 0.7879151105880737
},
{
"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": 0.7816441059112549
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": "} from \"../../util\";\nimport { defineModule } from \"../define-module\";\nexport default defineModule({\n name: \"web\",\n}).with({\n actions: {\n searchWeb: {\n description: \"Search the web.\",\n parameters: {\n searchString: {",
"score": 0.7801961302757263
},
{
"filename": "src/action-handler.ts",
"retrieved_chunk": " actionDef.execute({\n context: this.moduleManager.getModuleForAction(actionDef.name)!.context,\n parameters,\n sendMessage: (message) => this.messageBus.send(message),\n });\n }\n}",
"score": 0.7793451547622681
}
] | typescript | parseAction(moduleManager.actions, text); |
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": 0.8678848743438721
},
{
"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": 0.8628933429718018
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const gameData = await ds.GameData.get(gameId);\n if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n return gameData;\n }\n private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {\n const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))\n .filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)\n .map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));\n if (cards.length !== cardIds.length) {\n throw `could not resolve all cards for player ${playerId}`;",
"score": 0.8610670566558838
},
{
"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": 0.8378086090087891
},
{
"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": 0.8308465480804443
}
] | typescript | const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId))); |
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": "import { CODE_BLOCK_DELIMITER, messageBuilder } from \"../../message\";\nimport { MULTILINE_DELIMITER, agentName } from \"../../util\";\nimport { defineModule } from \"../define-module\";\nimport { getUsageText } from \"../util\";\nexport default defineModule({\n name: \"core\",\n}).with({\n pinnedMessage: async ({ agentId, actionDictionary }) =>\n `\n You are ${agentName(",
"score": 0.6965563893318176
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": "import { CODE_BLOCK_DELIMITER } from \"./message\";\nimport { ActionDefinition } from \"./module/action-definition\";\nimport { getUsageText } from \"./module/util\";\nimport { MULTILINE_DELIMITER } from \"./util\";\ntype ParseResult =\n | {\n type: \"success\";\n action: Action;\n }\n | { type: \"error\"; message: string };",
"score": 0.6853247880935669
},
{
"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": 0.6841619610786438
},
{
"filename": "src/message.ts",
"retrieved_chunk": "export const systemSource: SystemMessageSource = { type: \"system\" };\nexport const agentSource = (id: string): AgentMessageSource => ({\n type: \"agent\",\n id,\n});\nexport const CODE_BLOCK_DELIMITER = \"```\";\nexport const messageBuilder = addMessageTypes({\n spontaneous: singleTargetSystemMessage,\n ok: singleTargetSystemMessage,\n error: singleTargetSystemMessage,",
"score": 0.6838319301605225
},
{
"filename": "src/task-queue.test.ts",
"retrieved_chunk": "import TaskQueue from \"./task-queue\";\nimport { sleep } from \"./util\";\ndescribe(\"TaskQueue\", () => {\n let taskQueue: TaskQueue;\n beforeEach(() => {\n taskQueue = new TaskQueue();\n });\n afterEach(() => taskQueue.stop());\n describe(\"run\", () => {\n it(\"should run tasks in serial\", async () => {",
"score": 0.6817895174026489
}
] | typescript | expect(action.actionDef.name).toBe("sendMessage"); |
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/module/definitions/web.test.ts",
"retrieved_chunk": " \"getSearchResults\",\n async () => {\n const results = await getSearchResults(`\"e/acc\" explanation and sources`);\n console.log(results?.map((item) => item.title).join(\"\\n\"));\n },\n 5 * 60 * 1000\n);",
"score": 0.7833489775657654
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " (this.compressionThreshold * AVG_WORDS_PER_TOKEN) / 6\n );\n const eventsToSummarize = events.slice(0, i);\n // console.log(\n // `Summarizing ${eventsToSummarize.length} events (${eventsToSummarize\n // .map(countTokens)\n // .reduce((sum, next) => sum + next, 0)} tokens)`\n // );\n const summaryContent = await makeDecision([\n ...eventsToSummarize,",
"score": 0.782901406288147
},
{
"filename": "src/store/file-store.ts",
"retrieved_chunk": " return String.fromCharCode(parseInt(encodedChar.slice(1), 16));\n}\nfunction encodeFilename(filename: string): string {\n // Replace invalid characters with their encoded versions\n const replaced = filename.replace(/[\\\\/:*?\"<>|]/g, encodeChar);\n // Limit the filename length, as some file systems have restrictions\n const maxLength = 255;\n const trimmed = replaced.slice(0, maxLength);\n return trimmed;\n}",
"score": 0.7765493988990784
},
{
"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": 0.7764094471931458
},
{
"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": 0.769004762172699
}
] | 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/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": 0.7764090299606323
},
{
"filename": "src/module/util.ts",
"retrieved_chunk": " name === \"name\"\n ? undefined\n : `\\n${name}: <${description.toLowerCase()}>${\n actionDef.parameters[name].optional ? \" (optional)\" : \"\"\n }`\n )\n .filter(Boolean)\n .join(\"\")}\n${CODE_BLOCK_DELIMITER}`;\n}",
"score": 0.7674509286880493
},
{
"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": 0.7661242485046387
},
{
"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": 0.7537497878074646
},
{
"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": 0.7423022985458374
}
] | typescript | ) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
}; |
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 scriptData = card.scripts.find(x => x[0] === scriptName);\n if (!scriptData) {\n throw new Error(`Script [${scriptName}] not found in card [${cardId}]`);\n }\n if (CardScript.isOnCooldown(scriptData)) {\n return;\n }\n const engine = new _Engine(gameData);\n const script = CardScript.deserialize(engine, card, scriptData);\n targets = script.targetFinder(gameData, card).map(x => x.id);",
"score": 0.8863867521286011
},
{
"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": 0.8682735562324524
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " targetCard = enemy;\n }\n CardScript.execute(engine, enemy, intent.scriptData, targetCard);\n return true;\n }\n export function findCardById(gameData: GameEngine.IGameData, cardId: number) {\n const card = findCardByIdMaybe(gameData, cardId);\n if (card) return card;\n throw new Error('card not found');\n }",
"score": 0.8676719665527344
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " (engine, _sourceCard, targetCard) => {\n if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;\n const script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);\n if (script.targetFinder === CardScript.TargetFinders.Self) return;\n const targets = script.targetFinder(engine.gameData, targetCard);\n if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;\n const origTargetId = targetCard.intent.targetCardId;\n while (targetCard.intent.targetCardId === origTargetId) {\n targetCard.intent.targetCardId = targets.random().id;\n }",
"score": 0.8648211359977722
},
{
"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": 0.8634328842163086
}
] | 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-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": 0.8810399770736694
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " if (Math.random() < chance) {\n curriedPart(engine, sourceCard, targetCard);\n }\n };\n export const _TargetHasMod = <T extends CardMod.ModLibrary, K extends keyof T>(modName: K, curry: (mod: InstanceType<T[K]>) => IScriptPart): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n const mod = targetCard.mods.find(x => x[0] === modName);\n if (mod) {\n curry(CardMod.deserialize(engine, mod) as InstanceType<T[K]>)(engine, sourceCard, targetCard);\n }",
"score": 0.8764050006866455
},
{
"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": 0.8623090386390686
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " };\n export const AddMod = (mod: CardMod): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n CardMod.addMod(engine, targetCard, mod, sourceCard);\n };\n export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;\n if (secExceeded) {\n MemDmg(1)(engine, sourceCard, targetCard);",
"score": 0.84991455078125
},
{
"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": 0.840071439743042
}
] | typescript | find(modData => modFilter.find(x => x === modData[0]))); |
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export namespace CardScriptParts {
export interface IScriptPart {
(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): void;
}
export const _Chance = (chance: number, curriedPart: IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (Math.random() < chance) {
curriedPart(engine, sourceCard, targetCard);
}
};
export const _TargetHasMod = <T extends CardMod.ModLibrary, K extends keyof T>(modName: K, curry: (mod: InstanceType<T[K]>) => IScriptPart): IScriptPart =>
(engine, sourceCard, targetCard) => {
const mod = targetCard.mods.find(x => x[0] === modName);
if (mod) {
curry(CardMod.deserialize(engine, mod) as InstanceType<T[K]>)(engine, sourceCard, targetCard);
}
};
export const AddMod = (mod: CardMod): IScriptPart =>
(engine, sourceCard, targetCard) => {
CardMod.addMod(engine, targetCard, mod, sourceCard);
};
export const Attack = (damage: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
const secExceeded = SecDmg(damage, dontTriggerOut, dontTriggerIn)(engine, sourceCard, targetCard) as unknown;
if (secExceeded) {
MemDmg(1)(engine, sourceCard, targetCard);
}
};
export const SecDmg = (secDmg: number, dontTriggerOut = false, dontTriggerIn = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
let resolvedDamage = secDmg;
if (!dontTriggerOut) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageOut', { engine, sourceCard, contextCard: targetCard }, resolvedDamage)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (!dontTriggerIn) {
resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)
.reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);
}
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return false;
}
resolvedDamage = Math.max(0, resolvedDamage);
const secExceeded = resolvedDamage > targetCard.sec;
GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);
return secExceeded;
};
export const MemDmg = (memDmg: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.triggerMods('onMemDmgOut', { engine, sourceCard, contextCard: targetCard }, memDmg);
GameEngineUtils.triggerMods('onMemDmgIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, memDmg);
if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {
return;
}
targetCard.mem -= memDmg;
engine.broadcast.push({
type: 'memDamage',
cardId: targetCard.id,
newMem: targetCard.mem,
value: -memDmg,
});
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, sourceCard.id);
player && (player.stats.memDmg += memDmg);
if (targetCard.mem <= 0) {
GameEngineUtils.removeCard(engine, targetCard, sourceCard);
}
};
export const ChangeCpu = (cpuDelta: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
};
export const RaiseMem = (memBonus: number): IScriptPart =>
(engine, _sourceCard, targetCard) => {
targetCard.mem += memBonus;
engine.broadcast.push({
type: 'memBonus',
cardId: targetCard.id,
newMem: targetCard.mem,
value: memBonus,
});
};
export const RaiseSec = (secBonus: number): IScriptPart =>
(engine, sourceCard, targetCard) => {
GameEngineUtils.changeSec(engine, targetCard, secBonus, false, sourceCard);
};
export const RedirectIntentRandom: IScriptPart =
(engine, _sourceCard, targetCard) => {
if (!GameEngineUtils.isEnemyCard(engine.gameData, targetCard) || !targetCard.intent) return;
const | script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData); |
if (script.targetFinder === CardScript.TargetFinders.Self) return;
const targets = script.targetFinder(engine.gameData, targetCard);
if (!targets.length || (targets.length === 1 && targets[0]?.id === targetCard.intent.targetCardId)) return;
const origTargetId = targetCard.intent.targetCardId;
while (targetCard.intent.targetCardId === origTargetId) {
targetCard.intent.targetCardId = targets.random().id;
}
engine.broadcast.push({
type: 'cardIntent',
cardId: targetCard.id,
intent: targetCard.intent,
});
};
export const RemoveMod = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modName: K, mustRemove = false): IScriptPart =>
(engine, sourceCard, targetCard) => {
if (mustRemove) {
if (!targetCard.mods.find(x => x[0] === modName)) {
throw new Error(`Could not find [${modName}] to remove`);
}
}
CardMod.removeModByName(engine, targetCard, modName, sourceCard);
};
export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>
(engine, sourceCard, _targetCard) => {
let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);
switch (spawnPosition) {
case 'absLeft': spawnIndex = 0; break;
case 'absRight': spawnIndex = engine.gameData.enemies.length; break;
case 'relRight': spawnIndex++; break;
}
GameEngineUtils.spawnEnemy(engine, enemyClass, spawnIndex, generateIntent);
};
} | src/game/card-script-parts.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " targetCard = enemy;\n }\n CardScript.execute(engine, enemy, intent.scriptData, targetCard);\n return true;\n }\n export function findCardById(gameData: GameEngine.IGameData, cardId: number) {\n const card = findCardByIdMaybe(gameData, cardId);\n if (card) return card;\n throw new Error('card not found');\n }",
"score": 0.8737843632698059
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n (engine, sourceCard, targetCard) => {\n CardScript.removeScript(engine, sourceCard, _cardScripts.mw_copypaste);\n if (!targetCard.scripts[1]) return;\n CardScript.addScript(engine, sourceCard, CardScript.fromScriptName(engine, sourceCard, targetCard.scripts[1][0]));\n },\n ],\n }",
"score": 0.8720183968544006
},
{
"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": 0.8693527579307556
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " });\n }\n static async requestCardTargets(gameId: string, playerId: string, cardId: number, scriptName: string) {\n const gameData = await _Engine.getGameData(gameId);\n const card = GameEngineUtils.findPlayerCardById(gameData, cardId);\n let targets = [] as number[];\n try {\n if (card.isUsed) {\n return;\n }",
"score": 0.8614957332611084
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " export const RandomOpponent: ITargetResolver = (gameData, sourceCard, targetCard) => {\n return TargetFinders._excludeImperviousAndOffline([AllOpponents(gameData, sourceCard, targetCard).random()]);\n };\n }\n export namespace TargetFinders {\n export const Self: ITargetFinder = (_gameData, card) => [card];\n export const Allies = (excludeSelf = false): ITargetFinder =>\n (gameData, card) => {\n let targets: GameEngine.ICardState[] = GameEngineUtils.isEnemyCard(gameData, card) ? gameData.enemies : GameEngineUtils.getPlayerCards(gameData);\n excludeSelf && (targets = targets.filter(x => x.id !== card.id));",
"score": 0.8596840500831604
}
] | typescript | script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData); |
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/reaper.ts",
"retrieved_chunk": " if (source.sec <= 0) {\n GameEngineUtils.removeCard(engine, source);\n return;\n }\n } else {\n GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);\n GameEngineUtils.changeCpu(engine, source, 1);\n for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {\n CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));\n }",
"score": 0.8865020871162415
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " },\n reaper_feederPower: class extends CardMod {\n override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {\n if (deps.sourceCard.sec - damage > 0) return;\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);\n CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);\n CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);\n CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);\n const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);\n player && player.stats.kills++;",
"score": 0.8752925395965576
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {\n CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);\n if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {\n GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n }\n }\n },\n },",
"score": 0.8708298802375793
},
{
"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": 0.8355413675308228
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " const boss: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n enemyClass: 'stasis_boss',\n cpu: 3,\n mem: 3,\n maxMem: 3,\n sec: GameEngineUtils.scaleByDifficulty(125, engine.gameData.difficulty),\n mods: [\n new RulesetStasis.cardMods.stasis_boss_ai().serialize(),\n new CardMod.Content._winOnDeath().serialize(),",
"score": 0.8353346586227417
}
] | typescript | CardMod.addMod(deps.engine, enemy, new GameContent_v1.cardMods.optimized(1, -1), boss); |
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": " [memBonus],\n CardScript.TargetFinders.Any(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseMem(1),\n ],\n }\n ],",
"score": 0.9420045614242554
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [secBonus, duration],\n CardScript.TargetFinders.Any(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new CardMod.Content.diagnostics(secBonus, duration)\n ),\n ],",
"score": 0.9200286865234375
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " super(\n [],\n CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.RedirectIntentRandom,\n ],\n }",
"score": 0.9043227434158325
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " super(\n [secDelta],\n CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.SecDmg(secDelta),\n ],\n },",
"score": 0.9007008075714111
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new _cardMods.exposed(stacks),\n ),\n ],\n }",
"score": 0.8974578380584717
}
] | typescript | .RaiseSec(randInt(minBonus, maxBonus)),
],
} |
import { CoreScriptNames } from '../appraise';
import { IPlayerPushProvider } from '../dependencies';
import { randInt, round } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export class CardScript {
cooldownMax = -1;
cooldownCur = 0;
readonly scriptName: string;
constructor(
private _extraScriptData: unknown[],
public targetFinder: CardScript.ITargetFinder,
public targetScriptParts: { targetResolver: CardScript.ITargetResolver, parts: CardScriptParts.IScriptPart[] }[],
) {
this.scriptName = this.constructor.name;
}
serialize() {
const retVal = [this.scriptName, ...this._extraScriptData] as CardScript.ScriptData;
(this.cooldownCur > 0 || this.cooldownMax > 0) && retVal.push(CardScript.makeCooldownData(this.cooldownMax, this.cooldownCur));
return retVal;
}
static addScript(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptData: CardScript.ScriptData) {
card.scripts.push(scriptData);
engine.broadcast.push({
type: 'scriptAdded',
cardId: card.id,
scriptData,
});
}
static areEqual(left: CardScript.ScriptData, right: CardScript.ScriptData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptData: CardScript.ScriptData) {
const scriptCtor = engine.ruleset.cardScripts?.[scriptData[0]];
if (!scriptCtor) throw new Error('script not found: ' + scriptData.join());
const script = new scriptCtor(card, ...scriptData.slice(1));
const cooldownData = CardScript.findCooldownData(scriptData);
if (cooldownData) {
script.cooldownCur = cooldownData[1];
script.cooldownMax = cooldownData[2];
}
return script;
}
static execute(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, sourceCardScript: CardScript.ScriptData, targetCard: GameEngine.ICardState) {
engine.broadcast.push({
type: 'cardExecuting',
cardId: sourceCard.id,
targetCardId: targetCard.id,
scriptData: sourceCardScript,
});
if (this.isOnCooldown(sourceCardScript)) {
throw new Error('Script is on cooldown: ' + sourceCardScript.join());
}
const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript));
const isEnemy = GameEngineUtils.isEnemyCard(engine.gameData, sourceCard);
if (!isEnemy) {
if (!scriptDataFromCard) {
throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());
}
}
const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);
if (cooldownData) {
cooldownData[1] = cooldownData[2] + 1;
}
const script = this.deserialize(engine, sourceCard, sourceCardScript);
const targets = script.targetFinder(engine.gameData, sourceCard);
if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {
throw new Error('Invalid target ' + targets.map(x => x.id).join());
}
for (const pair of script.targetScriptParts) {
const resolvedTargets = pair.targetResolver(engine.gameData, sourceCard, targetCard);
for (const part of pair.parts) {
for (const resolvedTarget of resolvedTargets) {
if (resolvedTarget.isRemoved) continue;
part(engine, sourceCard, resolvedTarget);
}
}
}
engine.broadcast.push({
type: 'cardExecuted',
cardId: sourceCard.id,
targetCardId: targetCard.id,
scriptData: scriptDataFromCard || sourceCardScript,
});
}
static findCooldownData(data: CardScript.ScriptData) {
return data.find((x): x is CardScript.CooldownData => Array.isArray(x) && x[0] === '$cooldown');
}
static fromScriptName(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptName: string) {
return this.deserialize(engine, card, [scriptName]).serialize();
}
static isOnCooldown(data: CardScript.ScriptData) {
return (this.findCooldownData(data)?.[1] || 0) > 0;
}
static makeCooldownData(max: number, cur = 0): CardScript.CooldownData {
return ['$cooldown', cur, max];
}
static removeScript(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptType: CardScript.ScriptConstructor) {
const removed = card.scripts.findAndRemoveFirst(x => x[0] === scriptType.name);
if (!removed) throw new Error('script not found: ' + scriptType.name);
engine.broadcast.push({
type: 'scriptRemoved',
cardId: card.id,
removedScript: scriptType.name,
});
}
static tickCooldowns(card: GameEngine.ICardState, broadcast: IPlayerPushProvider.IPushMessage[]) {
for (const script of card.scripts) {
const cooldownData = CardScript.findCooldownData(script);
if (!cooldownData?.[1]) {
continue;
}
cooldownData[1]--;
broadcast.push({
type: 'scriptChanged',
cardId: card.id,
scriptData: script,
});
}
}
}
export namespace CardScript {
export type ScriptData = [string, ...unknown[]];
export type CooldownData = ['$cooldown', number, number];
export type ScriptConstructor = { new(card: GameEngine.ICardState, ...args: any[]): CardScript };
export type ScriptLibrary = Record<string, ScriptConstructor>;
export interface ITargetResolver {
(gameData: GameEngine.IGameData, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): GameEngine.ICardState[];
}
export interface ITargetFinder {
(gameData: GameEngine.IGameData, card: GameEngine.ICardState): GameEngine.ICardState[];
}
export namespace TargetResolvers {
export const Self: ITargetResolver = (_, sourceCard) => [sourceCard];
export const Target: ITargetResolver = (_, _2, targetCard) => [targetCard];
export const TargetAndAdjacents: ITargetResolver = (gameData, _, targetCard) => {
const cards = GameEngineUtils.isEnemyCard(gameData, targetCard) ? gameData.enemies : (GameEngineUtils.findPlayerByCardId(gameData, targetCard.id).cards);
const i = cards.findIndex(x => x.id === targetCard.id);
return [cards[i], cards[i - 1], cards[i + 1]].filter(Boolean);
};
export const AllAllies: ITargetResolver = (gameData, sourceCard) => {
if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {
return TargetFinders._excludeOffline(gameData.enemies);
} else {
return TargetFinders._excludeOffline(GameEngineUtils.getPlayerCards(gameData));
}
};
export const RandomAlly: ITargetResolver = (gameData, sourceCard, targetCard) => {
return [AllAllies(gameData, sourceCard, targetCard).random()];
};
export const AllOpponents: ITargetResolver = (gameData, sourceCard) => {
if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {
return TargetFinders._excludeImperviousAndOffline(GameEngineUtils.getPlayerCards(gameData));
} else {
return TargetFinders._excludeImperviousAndOffline(gameData.enemies);
}
};
export const RandomOpponent: ITargetResolver = (gameData, sourceCard, targetCard) => {
return TargetFinders._excludeImperviousAndOffline([AllOpponents(gameData, sourceCard, targetCard).random()]);
};
}
export namespace TargetFinders {
export const Self: ITargetFinder = (_gameData, card) => [card];
export const Allies = (excludeSelf = false): ITargetFinder =>
(gameData, card) => {
let targets: GameEngine.ICardState[] = GameEngineUtils.isEnemyCard(gameData, card) ? gameData.enemies : GameEngineUtils.getPlayerCards(gameData);
excludeSelf && (targets = targets.filter(x => x.id !== card.id));
return _excludeOffline(targets);
};
export const Opponents = (ignoreTaunt = false): ITargetFinder =>
(gameData, card) => {
const targets = GameEngineUtils.isEnemyCard(gameData, card) ? GameEngineUtils.getPlayerCards(gameData) : gameData.enemies;
const standardTargets = _excludeImperviousAndOffline(targets);
if (!ignoreTaunt) {
const taunts = _filterForFirewall(standardTargets);
if (taunts.length) {
return taunts;
}
}
return standardTargets;
};
export const Any = (ignoreTaunt = false): ITargetFinder =>
(gameData, card) => [
...Opponents(ignoreTaunt)(gameData, card),
...Allies()(gameData, card),
];
export const _ModFilter = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modFilter: K[], targetFinder: ITargetFinder): ITargetFinder =>
(gameData, card) => {
const targets = targetFinder(gameData, card);
const modMatches = targets.filter(target => target.mods.find(modData => modFilter.find(x => x === modData[0])));
return _excludeImperviousAndOffline(modMatches);
};
const _excludeImpervious = (cards: GameEngine.ICardState[]) => {
return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.impervious.name));
};
export const _excludeOffline = (cards: GameEngine.ICardState[]) => {
return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.offline.name));
};
export const _excludeImperviousAndOffline = (cards: GameEngine.ICardState[]) => _excludeImpervious(_excludeOffline(cards));
const _filterForFirewall = (cards: GameEngine.ICardState[]) => {
return cards.filter(x => x.mods.find(y => y[0] === CardMod.Content.firewall.name));
};
}
export namespace Content {
// Defines a card script - the class name is treated as the script name
export class bd_decode extends CardScript {
constructor(
// MUST always be the first parameter even if not used
card: GameEngine.ICardState,
// Not used but declared to show how the memo is passed back here, see first argument in super(...) below
_secDamage: number,
) {
const secDamage = GameEngineUtils.scaleByCpuMem(12, card.cpu);
| const bdChance = round(GameEngineUtils.scaleByCpuMem(20, card.mem, 'high') / 100, 2); |
const bdDamage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
// Any extra data to serialize into scriptData[1:] as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display potential card effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI scripts
[secDamage, bdChance, bdDamage],
// Which cards are valid targets for this card; AI will typically .random()
TargetFinders.Opponents(),
// A composition of CardScriptParts that get executed when this card is played; this allows for
// composition effects such as "((damage and debuff) to target) AND (chance to stun neighbors)":
// The first part would use the Target resolver and Attack and ApplyMod parts
// The second part would use the Neighbors resolver and curry Stun part into _Chance part
[
{
// Given a chosen target, which actual targets these parts will execute on; this allows
// a card to, for example, deal damage to the neighbors of the specified target
targetResolver: TargetResolvers.Target,
// CardScriptParts to execute on the resolved targets
parts: [
CardScriptParts.SecDmg(secDamage),
CardScriptParts._Chance(bdChance,
CardScriptParts.AddMod(
new CardMod.Content.backdoor(bdDamage),
)
),
],
}
],
);
}
}
export class bd_exploit extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const bdChance = round(GameEngineUtils.scaleByCpuMem(40, card.mem, 'more') / 100, 2);
super(
[damage, bdChance],
(gameData: GameEngine.IGameData, card: GameEngine.ICardState) => [
...TargetFinders.Opponents()(gameData, card),
...TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
TargetFinders.Opponents(true))(gameData, card),
],
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts._TargetHasMod<typeof CardMod.Content, 'backdoor'>('backdoor', mod => CardScriptParts.SecDmg(mod.stackingConfig.rank, true)),
CardScriptParts.Attack(damage),
CardScriptParts._Chance(bdChance,
CardScriptParts.AddMod(
new CardMod.Content.backdoor(damage),
)
),
],
}
],
);
}
}
export class bd_secure extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
TargetFinders.Any(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 1;
}
}
export class bf_spam extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[damage],
TargetFinders.Opponents(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.Attack(damage),
],
}
]
);
}
}
export class bf_firewall extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const modDuration = Math.ceil(card.mem / 2);
super(
[secBonus, modDuration],
TargetFinders.Self,
[
{
targetResolver: TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secBonus),
CardScriptParts.AddMod(
new CardMod.Content.firewall(modDuration),
),
],
}
],
);
this.cooldownMax = 1;
}
}
export class bf_overclock extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(17, card.cpu);
const lagChance = round((100 - GameEngineUtils.scaleByCpuMem(30, card.mem)) / 100, 2);
const lagDuration = 2;
super(
[damage, lagChance, lagDuration],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts._Chance(lagChance,
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
),
],
}
],
);
}
}
export class mw_freeware extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(12, card.cpu, 'more');
super(
[minBonus, maxBonus],
TargetFinders.Any(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 1;
}
}
export class mw_redirect extends CardScript {
constructor(card: GameEngine.ICardState) {
const tempSecBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const duration = Math.ceil(card.mem / 2);
super(
[tempSecBonus, duration],
TargetFinders.Allies(true),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.secured(tempSecBonus, duration),
),
CardScriptParts.AddMod(
new CardMod.Content.firewall(duration),
),
],
}
],
);
this.cooldownMax = 1;
}
}
export class mw_worm extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(7, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(13, card.cpu);
super(
[minDamage, maxDamage],
TargetFinders.Opponents(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
}
}
export class _attack extends CardScript {
constructor(card: GameEngine.ICardState, difficulty: number, strength: 'weak' | 'normal' | 'strong' = 'normal', cooldown = 0) {
let minDmg = 0;
let maxDmg = 0;
switch (strength) {
case 'weak':
minDmg = GameEngineUtils.scaleByCpuMem(6, card.cpu);
maxDmg = GameEngineUtils.scaleByCpuMem(8, card.cpu);
break;
case 'normal':
minDmg = GameEngineUtils.scaleByCpuMem(8, card.cpu);
maxDmg = GameEngineUtils.scaleByCpuMem(12, card.cpu);
break;
case 'strong':
minDmg = GameEngineUtils.scaleByCpuMem(11, card.cpu);
maxDmg = GameEngineUtils.scaleByCpuMem(15, card.cpu);
break;
}
minDmg = GameEngineUtils.scaleByDifficulty(minDmg, difficulty);
maxDmg = GameEngineUtils.scaleByDifficulty(maxDmg, difficulty);
super(
[difficulty, strength, cooldown, minDmg, maxDmg],
TargetFinders.Opponents(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.Attack(randInt(minDmg, maxDmg)),
],
}
],
);
this.cooldownMax = cooldown;
}
}
export class _defend extends CardScript {
constructor(card: GameEngine.ICardState, difficulty: number, strength: 'weak' | 'normal' | 'strong' = 'normal', cooldown = 0) {
let minBonus = 0;
let maxBonus = 0;
switch (strength) {
case 'weak':
minBonus = GameEngineUtils.scaleByCpuMem(4, card.cpu);
maxBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
break;
case 'normal':
minBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
maxBonus = GameEngineUtils.scaleByCpuMem(8, card.cpu);
break;
case 'strong':
minBonus = GameEngineUtils.scaleByCpuMem(8, card.cpu);
maxBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
break;
}
minBonus = GameEngineUtils.scaleByDifficulty(minBonus, difficulty);
maxBonus = GameEngineUtils.scaleByDifficulty(maxBonus, difficulty);
super(
[difficulty, strength, cooldown, minBonus, maxBonus],
TargetFinders.Allies(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = cooldown;
}
}
export class _firewallSelf extends CardScript {
constructor(_card: GameEngine.ICardState, duration = 1, cooldown = 0, startingCooldown = 0) {
super(
[duration, cooldown],
TargetFinders.Self,
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.firewall(duration + 1),
),
],
}
],
);
this.cooldownCur = startingCooldown;
this.cooldownMax = cooldown;
}
}
export class _spawn extends CardScript {
constructor(_card: GameEngine.ICardState, enemyClass: string, spawnPosition: Parameters<typeof CardScriptParts['SpawnEnemy']>[1] = 'relLeft', generateIntent = false, cooldown = 0) {
super(
[enemyClass, spawnPosition, generateIntent, cooldown],
TargetFinders.Self,
[
{
targetResolver: TargetResolvers.Self,
parts: [
CardScriptParts.SpawnEnemy(enemyClass, spawnPosition, generateIntent),
],
}
],
);
this.cooldownMax = cooldown;
}
}
}
(Content as Record<CoreScriptNames, ScriptConstructor>);
} | src/game/card-scripts.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " 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": 0.8890408873558044
},
{
"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": 0.8826940059661865
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " ],\n );\n this.cooldownMax = 1;\n }\n },\n // Raise MEM\n bd_defrag: class extends CardScript {\n constructor(_card: GameEngine.ICardState) {\n const memBonus = 1;\n super(",
"score": 0.872609555721283
},
{
"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": 0.8652117252349854
},
{
"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": 0.8651207685470581
}
] | 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/card-scripts.ts",
"retrieved_chunk": " // MUST always be the first parameter even if not used\n card: GameEngine.ICardState,\n // Not used but declared to show how the memo is passed back here, see first argument in super(...) below\n _secDamage: number,\n ) {\n const secDamage = GameEngineUtils.scaleByCpuMem(12, card.cpu);\n const bdChance = round(GameEngineUtils.scaleByCpuMem(20, card.mem, 'high') / 100, 2);\n const bdDamage = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n super(\n // Any extra data to serialize into scriptData[1:] as a 'memo' which can serve two purposes:",
"score": 0.8683426976203918
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " }\n override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {\n CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);\n }\n },\n // Increases CPU\n optimized: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,",
"score": 0.8671744465827942
},
{
"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": 0.8605116009712219
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " export function changeSec(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, secDelta: number, isPassive: boolean, contextCard?: GameEngine.ICardState) {\n const clampedSecDelta = (card.sec < -secDelta) ? -card.sec : secDelta;\n card.sec += clampedSecDelta;\n engine.broadcast.push({\n type: isPassive ? 'secChange' : (secDelta < 0 ? 'secDamage' : 'secBonus'),\n cardId: card.id,\n newSec: card.sec,\n value: secDelta,\n });\n if (!isPassive && contextCard) {",
"score": 0.8560342788696289
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,\n };\n constructor(public stackCount: number) {\n super(arguments);\n this.stackingConfig.stackCount = stackCount;\n }\n override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {\n return { secDmgBonus: this.stackingConfig.stackCount };\n }",
"score": 0.8498412370681763
}
] | typescript | .reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0); |
import { randInt } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
const _cardMods = {
// Increases incoming damage
exposed: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public stackCount: number) {
super(arguments);
this.stackingConfig.stackCount = stackCount;
}
override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return { secDmgBonus: this.stackingConfig.stackCount };
}
},
// Returns damage to attacker
feedback: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public damage: number) {
super(arguments);
this.stackingConfig.stackCount = damage;
}
override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);
}
},
// Increases CPU
optimized: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(cpuBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = cpuBonus;
}
override onInitMod(deps: CardMod.ICardModDeps) {
GameEngineUtils.changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);
}
override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {
deps.sourceCard.cpu += stackDelta;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
override onRemoveMod(deps: CardMod.ICardModDeps) {
deps.sourceCard.cpu -= this.stackingConfig.stackCount;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
},
// Damages on turn end
virus: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public dot: number) {
super(arguments);
this.stackingConfig.stackCount = dot;
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);
}
},
};
const _cardScripts = {
//
// Backdoor scripts
//
// Swap MEM for CPU
bd_caching: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(-1),
CardScriptParts.ChangeCpu(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise MEM
bd_defrag: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memBonus = 1;
super(
[memBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 4;
}
},
// Heal over time
bd_diagnostics: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const duration = 1 + Math.round(card.mem / 2);
super(
[secBonus, duration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.diagnostics(secBonus, duration)
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Attack and stun (Backdoor finisher)
bd_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const stunDuration = 1;
super(
[damage, stunDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.AddMod(
new CardMod.Content.lag(stunDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and raise CPU on kill
bd_extraction: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Opponents(true)(gameData, card)
.filter( | target => !target.sec && target.mem === 1),
[
{ |
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(1, true, true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.ChangeCpu(1),
],
},
],
);
}
},
// Raises CPU
bd_optimize: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Raises SEC
bd_patch: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 2;
}
},
// Steal SEC and remove Firewall (Backdoor finisher)
bd_proxy: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, card.cpu);
super(
[secDelta],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
}
},
// Steal SEC and causes offline (Backdoor finisher)
bd_reboot: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, _card.cpu);
const offlineDuration = 1;
super(
[secDelta, offlineDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 2;
}
},
// Cause Exposed (Backdoor finisher)
bd_trace: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(7, card.cpu);
super(
[stacks],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and remove 1 MEM
bd_tunnel: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memDmg = 1;
super(
[memDmg],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.MemDmg(memDmg),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 3;
}
},
//
// Bruteforce scripts
//
// Swap CPU for MEM
bf_compression: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.ChangeCpu(-1),
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Offline
bf_ddos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const offlineDuration = 1;
super(
[offlineDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Cause Lag
bf_dos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const lagDuration = 1;
super(
[lagDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Gain feedback
bf_feedback: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Triple SEC attack
bf_flood: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(3, card.cpu);
const numAttacks = 3;
super(
[damage, numAttacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
...Array.from(Array(numAttacks)).map(() => CardScriptParts.SecDmg(damage)),
],
}
],
);
this.cooldownMax = 2;
}
},
// AOE attack
bf_multicast: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.TargetAndAdjacents,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC
bf_obfuscate: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 3;
}
},
// Strong attack
bf_pod: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(16, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 2;
}
},
// Raises CPU
bf_precompute: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
//
// Malware scripts
//
// Causes Lag
mw_bloatware: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[1],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(1),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Swap for another card's secondary script
mw_copypaste: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, sourceCard, targetCard) => {
CardScript.removeScript(engine, sourceCard, _cardScripts.mw_copypaste);
if (!targetCard.scripts[1]) return;
CardScript.addScript(engine, sourceCard, CardScript.fromScriptName(engine, sourceCard, targetCard.scripts[1][0]));
},
],
}
],
);
}
},
// Grant Feedback
mw_honeypot: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Steal SEC
mw_leech: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[secDelta],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 1;
}
},
// Attack random target
mw_phishing: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(18, card.cpu);
super(
[minDamage, maxDamage],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomOpponent,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
this.cooldownMax = 1;
}
},
// Redistribute CPU/MEM
mw_reimage: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, _sourceCard, targetCard) => {
const totalStats = targetCard.cpu + targetCard.mem;
const newCpu = randInt(1, totalStats - 1);
const cpuDelta = newCpu - targetCard.cpu;
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
const newMem = totalStats - newCpu;
const memDelta = newMem - targetCard.mem;
GameEngineUtils.changeMem(engine, targetCard, memDelta);
},
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC on random ally
mw_shareware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);
super(
[minBonus, maxBonus],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomAlly,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 3;
}
},
// Redirect intent
mw_spoof: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RedirectIntentRandom,
],
}
],
);
}
},
// Cause Exposed
mw_spyware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[stacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Virus
mw_virus: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const dot = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[dot],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.virus(dot),
),
],
}
],
);
this.cooldownMax = 2;
}
},
};
export const GameContent_v1 = {
cardMods: _cardMods,
cardScripts: _cardScripts,
enemyCards: {},
initGame(_engine: GameEngine.IGameEngine) {
throw new Error('not a startable scenario');
},
addAdditionalScriptsFor(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState) {
if (card.card.tier < 2) return;
switch (card.card.faction) {
case 'backdoor':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bd_')).random()]).serialize());
return;
case 'bruteforce':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bf_')).random()]).serialize());
return;
case 'malware':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('mw_')).random()]).serialize());
return;
}
},
};
(GameContent_v1 as GameEngine.IRuleset); | src/game/game-content-v1.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/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": 0.8974253535270691
},
{
"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": 0.8909046649932861
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " );\n this.cooldownMax = 1;\n }\n }\n export class bf_spam extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n super(\n [damage],\n TargetFinders.Opponents(),",
"score": 0.8899129629135132
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " export const RandomOpponent: ITargetResolver = (gameData, sourceCard, targetCard) => {\n return TargetFinders._excludeImperviousAndOffline([AllOpponents(gameData, sourceCard, targetCard).random()]);\n };\n }\n export namespace TargetFinders {\n export const Self: ITargetFinder = (_gameData, card) => [card];\n export const Allies = (excludeSelf = false): ITargetFinder =>\n (gameData, card) => {\n let targets: GameEngine.ICardState[] = GameEngineUtils.isEnemyCard(gameData, card) ? gameData.enemies : GameEngineUtils.getPlayerCards(gameData);\n excludeSelf && (targets = targets.filter(x => x.id !== card.id));",
"score": 0.8771718740463257
},
{
"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": 0.8567221164703369
}
] | typescript | target => !target.sec && target.mem === 1),
[
{ |
import * as moment from 'moment';
import { IAppraisedCard, appraiseCard } from '../appraise';
import { IDataSource, IMetricsProvider, IPlayerPushProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { SECS_IN_MIN } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameContent_v1 } from './game-content-v1';
import { GameEngineUtils } from './game-engine-utils';
export namespace GameEngine {
interface _ICommonCardState {
id: number;
cpu: number;
mem: number;
sec: number;
mods: CardMod.ModData[];
scripts: CardScript.ScriptData[];
isRemoved?: boolean;
}
export interface IGameData {
id: string;
difficulty: number;
state: 'created' | 'started' | 'players_won' | 'players_lost' | 'abandoned';
enemies: IEnemyCardState[];
maxEnemies: number;
players: Map<string, IPlayerState>;
defaultMovesPerTurn: number;
turn: number;
nextId: number;
pendingPlayers: Map<string, string[]>;
rulesetIds: string[];
}
export interface IPlayerState {
id: string;
cards: IPlayerCardState[];
endedTurn: boolean;
idleKickTime: number;
movesLeft: number;
movesPerTurn: number;
score: number;
stats: {
kills: number;
secDmg: number;
memDmg: number;
secBonus: number;
};
}
export interface IPlayerCardState extends _ICommonCardState {
card: IAppraisedCard;
isUsed: boolean;
}
export interface IEnemyCardState extends _ICommonCardState {
enemyClass: string;
intent?: { scriptData: CardScript.ScriptData, targetCardId: number };
maxMem: number;
}
export type ICardState = IPlayerCardState | IEnemyCardState;
export abstract class GameEngineError extends Error {
constructor(
public gameId: string,
) {
super();
this.message = `${this.constructor.name} processing game ${gameId}`;
}
}
export class GameNotFoundError extends GameEngineError { }
export interface IRulesetContent {
cardMods?: CardMod.ModLibrary;
cardScripts?: CardScript.ScriptLibrary;
enemyCards?: Record<string, (engine: IGameEngine) => IEnemyCardState>;
}
export interface IRuleset extends IRulesetContent {
initGame(engine: IGameEngine): void;
addAdditionalScriptsFor?(engine: GameEngine.IGameEngine, card: IPlayerCardState): void;
}
export function mergeRulesetContents(...rulesets: IRulesetContent[]): IRulesetContent {
const modLibs = rulesets.map(x => x.cardMods).filter(Boolean);
const scriptLibs = rulesets.map(x => x.cardScripts).filter(Boolean);
const enemyLibs = rulesets.map(x => x.enemyCards).filter(Boolean);
return {
cardMods: Object.fromEntries(modLibs.map(modLib => Object.keys(modLib).map(modName => [modName, modLib[modName]!] as const)).flat()),
cardScripts: Object.fromEntries(scriptLibs.map(scriptLib => Object.keys(scriptLib).map(scriptName => [scriptName, scriptLib[scriptName]!] as const)).flat()),
enemyCards: Object.fromEntries(enemyLibs.map(enemyLib => Object.keys(enemyLib).map(enemyClass => [enemyClass, enemyLib[enemyClass]!] as const)).flat()),
};
}
export type IGameEngine = InstanceType<ReturnType<typeof createGameEngineProvider>>;
}
export const createGameEngineProvider = (rulesets: Record<string, GameEngine.IRuleset>, ds: IDataSource, playerPushProvider: IPlayerPushProvider, metrics?: IMetricsProvider) => {
return class _Engine {
readonly broadcast: IPlayerPushProvider.IPushMessage[] = [];
ruleset!: GameEngine.IRuleset;
constructor(
readonly gameData: GameEngine.IGameData,
) {
const currentRuleset = rulesets[gameData.rulesetIds.at(-1)!];
if (!currentRuleset) throw new Error('invalid initial ruleSet id: ' + gameData.rulesetIds[0]);
this._setRuleset(currentRuleset);
}
private static async _withEngine(gameId: string, stateAssertion: GameEngine.IGameData['state'][], func: (engine: _Engine) => Promise<void>): Promise<GameEngine.IGameData> {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
const engine = new _Engine(gameData);
try {
if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);
await func(engine);
await ds.GameData.update.exec(gameData);
} catch (e: any) {
e.broadcast = engine.broadcast;
throw e;
}
if (engine.broadcast.length) {
await Promise.all(
[...gameData.players.keys()].map(playerId => playerPushProvider.push(playerId, engine.broadcast)),
);
}
return gameData;
}
static async createGame(gameId: string, rulesetId: string, difficulty: number) {
const ruleset = rulesets[rulesetId];
if (!ruleset) throw new Error('invalid ruleSet id: ' + rulesetId);
const existingGameData = await ds.GameData.get(gameId);
if (existingGameData) throw new Error('game with id already exists: ' + gameId);
const gameData: GameEngine.IGameData = {
id: gameId,
difficulty: Math.max(1, difficulty),
state: 'created',
turn: 1,
players: new Map(),
defaultMovesPerTurn: 3,
enemies: [],
maxEnemies: 9,
nextId: 1,
pendingPlayers: new Map(),
rulesetIds: [rulesetId],
};
await ds.GameData.update.exec(gameData);
}
static async startGame(gameId: string) {
const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {
for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
engine.broadcast.push({ type: 'playerJoin', playerState });
}
engine.gameData.pendingPlayers.clear();
engine.gameData.state = 'started';
engine.broadcast.push({ type: 'gameStart' });
engine.ruleset.initGame(engine);
});
return gameData;
}
static async endGame(gameId: string) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
engine.gameData.state = 'abandoned';
engine.broadcast.push({ type: 'gameEnd' });
});
}
static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
if (engine.gameData.players.has(playerId)) throw new Error('player already in game');
if (engine.gameData.players.size >= 2) throw new Error('game is full: ' + gameId);
if (engine.gameData.state === 'started') {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
if (engine.gameData.turn >= 2) {
playerState.endedTurn = true;
playerState.movesLeft = 0;
}
engine.broadcast.push({
type: 'playerJoin',
playerState,
});
} else {
engine.gameData.pendingPlayers.set(playerId, cardIds);
}
});
}
static async removePlayer(gameId: string, playerId: string, reason: 'idle' | 'leave') {
return await _Engine._withEngine(gameId, [], async engine => {
if (!engine.gameData.players.delete(playerId)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId, reason });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
});
}
static async requestCardTargets(gameId: string, playerId: string, cardId: number, scriptName: string) {
const gameData = await _Engine.getGameData(gameId);
const card = GameEngineUtils.findPlayerCardById(gameData, cardId);
let targets = [] as number[];
try {
if (card.isUsed) {
return;
}
const scriptData = card.scripts.find(x => x[0] === scriptName);
if (!scriptData) {
throw new Error(`Script [${scriptName}] not found in card [${cardId}]`);
}
if (CardScript.isOnCooldown(scriptData)) {
return;
}
const engine = new _Engine(gameData);
const script = CardScript.deserialize(engine, card, scriptData);
targets = script.targetFinder(gameData, card).map(x => x.id);
} finally {
await playerPushProvider.push(playerId, [{
type: 'cardTargets',
cardId,
scriptName,
targetCardIds: targets,
}]);
}
}
static async intent(gameId: string, playerId: string, sourceCardId?: string, sourceCardScript?: string, targetCardId?: string) {
const gameData = await _Engine.getGameData(gameId);
const pushMessage: IPlayerPushProvider.IPushMessage[] = [{
type: 'cardIntent',
cardId: sourceCardId,
intent: {
scriptData: sourceCardScript,
targetCardId,
},
playerId,
}];
await Promise.all(
[...gameData.players.keys()].filter(x => x !== playerId).map(x => playerPushProvider?.push(x, pushMessage)),
);
}
static async makeMove(gameId: string, playerId: string, sourceCardId: number, sourceCardScript: CardScript.ScriptData, targetCardId: number) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = GameEngineUtils.findPlayerByCardId(engine.gameData, sourceCardId);
if (playerState.id !== playerId) {
throw new Error(`Player ${playerId} cannot make move on card ${sourceCardId} from owner ${playerState.id}`);
}
if (!playerState.movesLeft) {
throw new Error(`No moves left`);
}
const sourceCard = playerState.cards.find(x => x.id === sourceCardId)!;
if (sourceCard.isUsed) {
throw new Error(`Card is used`);
}
const now = moment.now();
playerState.idleKickTime = now + 2 * | SECS_IN_MIN * 1000; |
playerState.movesLeft--;
const targetCard = GameEngineUtils.findCardById(engine.gameData, targetCardId);
CardScript.execute(engine, sourceCard, sourceCardScript, targetCard);
GameEngineUtils.changeCardIsUsed(engine, sourceCard, true);
metrics?.playerCardPlayed(gameId, engine.gameData.rulesetIds[0] || 'unknown', playerId, sourceCard, sourceCardScript[0]);
});
}
static async toggleEndTurn(gameId: string, playerId: string) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = engine.gameData.players.get(playerId);
if (!playerState) throw new Error('player not found');
if (playerState.endedTurn) {
playerState.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: false,
});
return;
}
playerState.endedTurn = true;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: true,
});
if (![...engine.gameData.players.values()].reduce((numNotReady, playerState) => playerState.endedTurn ? numNotReady : (numNotReady + 1), 0)) {
const now = moment.now();
[...engine.gameData.players.values()].forEach(x => x.idleKickTime = now + 2 * SECS_IN_MIN * 1000);
engine.onEndTurn();
if (engine.gameData.state !== 'started') {
// Stop if the game was won/lost due to an EndTurn effect
return;
}
engine.onTurnStart();
}
});
}
static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {
let kickedPlayerId = '';
await _Engine._withEngine(gameId, ['started'], async engine => {
const playerToKick = [...engine.gameData.players.values()].find(x => x.id !== kickRequestingPlayerId) || '';
if (!playerToKick) throw new Error('kickIfIdle: player not found');
if (playerToKick.idleKickTime < moment.now()) {
if (!engine.gameData.players.delete(playerToKick.id)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId: playerToKick.id, reason: 'idle' });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
kickedPlayerId = playerToKick.id;
}
});
return kickedPlayerId || null;
}
static async getGameData(gameId: string) {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
return gameData;
}
private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {
const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))
.filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)
.map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));
if (cards.length !== cardIds.length) {
throw `could not resolve all cards for player ${playerId}`;
}
const player: GameEngine.IPlayerState = {
id: playerId,
cards: cards.map(card => ({
id: this.nextId(),
card,
isUsed: false,
cpu: card.cpu,
mem: card.mem,
sec: card.mem * 6 + card.cpu * 3,
mods: [],
scripts: [],
})),
endedTurn: false,
movesLeft: this.gameData.defaultMovesPerTurn,
movesPerTurn: this.gameData.defaultMovesPerTurn,
stats: {
kills: 0,
memDmg: 0,
secBonus: 0,
secDmg: 0,
},
score: 0,
idleKickTime: moment.now() + 2 * SECS_IN_MIN * 1000,
};
for (const card of player.cards) {
card.scripts = [
CardScript.fromScriptName(this, card, card.card.coreScript),
];
this.ruleset.addAdditionalScriptsFor && this.ruleset.addAdditionalScriptsFor(this, card);
}
return player;
}
findRuleset(rulesetId: string) {
return rulesets[rulesetId];
}
onTurnStart() {
this.gameData.turn++;
this.broadcast.push({
type: 'newTurn',
turn: this.gameData.turn,
});
for (const player of this.gameData.players.values()) {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
}
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of playerCards) {
GameEngineUtils.changeCardIsUsed(this, playerCard, false);
}
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: playerCard });
}
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: enemy });
}
this._checkGameOver();
}
onEndTurn() {
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: playerCard });
CardScript.tickCooldowns(playerCard, this.broadcast);
}
this.broadcast.push({
type: 'playerTurnEnded',
});
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: enemy });
CardScript.tickCooldowns(enemy, this.broadcast);
}
this.broadcast.push({
type: 'enemyTurnEnded',
});
this._checkGameOver();
}
onNextWave(nextRulesetId: string) {
while (this.gameData.enemies[0]) {
GameEngineUtils.removeCard(this, this.gameData.enemies[0]);
}
[...this.gameData.players.values()].forEach(player => {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
player.cards.forEach(card => {
card.isUsed = false;
});
});
this.gameData.turn++;
this.broadcast.push({
type: 'nextWave',
turn: this.gameData.turn,
nextRulesetId,
});
const nextRuleset = this.findRuleset(nextRulesetId);
if (!nextRuleset) {
throw new Error('invalid rulesetId: ' + nextRulesetId);
}
this.gameData.rulesetIds.push(nextRulesetId);
this._setRuleset(nextRuleset);
nextRuleset.initGame(this);
}
onWinGame() {
this.gameData.state = 'players_won';
this.broadcast.push({
type: 'players_won',
stats: [...this.gameData.players.values()].map(player => {
let score =
player.cards.length * 50
+ player.stats.kills * 25
+ player.stats.memDmg * 50
+ player.stats.secDmg
+ player.stats.secBonus * 2
+ ((this.gameData.rulesetIds.length - 1) * 2000);
score = GameEngineUtils.scaleByDifficulty(score, this.gameData.difficulty + 1);
player.score = score;
return { playerId: player.id, stats: player.stats, score };
}),
});
}
nextId() {
return this.gameData.nextId++;
}
private _checkGameOver() {
if (!GameEngineUtils.getPlayerCards(this.gameData).length) {
this.gameData.state = 'players_lost';
this.broadcast.push({
type: 'players_lost',
});
}
}
private _setRuleset(nextRuleset: GameEngine.IRuleset) {
this.ruleset = {
addAdditionalScriptsFor: GameContent_v1.addAdditionalScriptsFor,
...nextRuleset,
...GameEngine.mergeRulesetContents(
nextRuleset,
{
cardMods: CardMod.Content,
cardScripts: CardScript.Content,
},
{
cardMods: GameContent_v1.cardMods,
cardScripts: GameContent_v1.cardScripts,
enemyCards: GameContent_v1.enemyCards,
}
),
};
}
}
}
export type GameEngineProvider = ReturnType<typeof createGameEngineProvider>; | src/game/game-engine.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " const player = await _expectAuthPlayerNotInGame(req);\n const deck = await _expectValidActiveDeck(player, true);\n if (await rateLimit.shouldRateLimitCreateGame(player.id)) {\n return [StatusCodes.tooManyRequests];\n }\n const now = moment.utc();\n const game: IDataSource.ICoopGame = {\n id: randomBytes(16).toString('hex'),\n createdAt: now.format(FULL_DATETIME_FORMAT),\n difficulty: payload.difficulty,",
"score": 0.8259571194648743
},
{
"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": 0.8235182762145996
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " resolvedDamage += GameEngineUtils.triggerMods('onSecDamageIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, resolvedDamage, sourceCard)\n .reduce((sum, x) => sum + (!!x ? x.secDmgBonus : 0), 0);\n }\n if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {\n return false;\n }\n resolvedDamage = Math.max(0, resolvedDamage);\n const secExceeded = resolvedDamage > targetCard.sec;\n GameEngineUtils.changeSec(engine, targetCard, -resolvedDamage, false, sourceCard);\n return secExceeded;",
"score": 0.8191725611686707
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());\n }\n }\n const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);\n if (cooldownData) {\n cooldownData[1] = cooldownData[2] + 1;\n }\n const script = this.deserialize(engine, sourceCard, sourceCardScript);\n const targets = script.targetFinder(engine.gameData, sourceCard);\n if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {",
"score": 0.8154212236404419
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " if (deck) {\n return deck;\n }\n const cards = (await ExtDeps.getNftsByDidOrWallet(player.id, 6))?.nfts.filter(Boolean) || [];\n if (cards.length < 6) {\n return null;\n }\n const nowStr = moment.utc().format(FULL_DATETIME_FORMAT);\n player.activeDeckId = nowStr;\n deck = {",
"score": 0.8133209347724915
}
] | 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 scriptData = card.scripts.find(x => x[0] === scriptName);\n if (!scriptData) {\n throw new Error(`Script [${scriptName}] not found in card [${cardId}]`);\n }\n if (CardScript.isOnCooldown(scriptData)) {\n return;\n }\n const engine = new _Engine(gameData);\n const script = CardScript.deserialize(engine, card, scriptData);\n targets = script.targetFinder(gameData, card).map(x => x.id);",
"score": 0.8764621615409851
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " onEndTurn() {\n const playerCards = GameEngineUtils.getPlayerCards(this.gameData);\n for (const playerCard of [...playerCards]) {\n if (!playerCards.includes(playerCard)) continue;\n GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: playerCard });\n CardScript.tickCooldowns(playerCard, this.broadcast);\n }\n this.broadcast.push({\n type: 'playerTurnEnded',\n });",
"score": 0.8285354971885681
},
{
"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": 0.8276070952415466
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n (engine, sourceCard, targetCard) => {\n CardScript.removeScript(engine, sourceCard, _cardScripts.mw_copypaste);\n if (!targetCard.scripts[1]) return;\n CardScript.addScript(engine, sourceCard, CardScript.fromScriptName(engine, sourceCard, targetCard.scripts[1][0]));\n },\n ],\n }",
"score": 0.8232080936431885
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " export function isPlayerCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IPlayerCardState {\n return !isEnemyCard(gameData, card);\n }\n export function recalculateScripts(engine: GameEngine.IGameEngine, card: GameEngine.ICardState) {\n if (card.isRemoved) return;\n card.scripts = card.scripts.map(x => CardScript.deserialize(engine, card, x).serialize());\n engine.broadcast.push(...card.scripts.map(x => ({\n type: 'scriptChanged',\n cardId: card.id,\n scriptData: x,",
"score": 0.816258430480957
}
] | typescript | const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript)); |
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/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": 0.8622889518737793
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);\n } else {\n GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);\n }\n }\n }\n export class secured extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,",
"score": 0.8577286601066589
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " ],\n }\n ],\n );\n }\n }\n export class bd_secure extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);\n super(",
"score": 0.8454494476318359
},
{
"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": 0.8352681994438171
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " );\n this.cooldownMax = 1;\n }\n }\n export class bf_spam extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n super(\n [damage],\n TargetFinders.Opponents(),",
"score": 0.8336266279220581
}
] | typescript | bd_caching: class extends CardScript { |
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/reaper.ts",
"retrieved_chunk": " mem: 0,\n maxMem: 0,\n sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content._winOnDeath().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };",
"score": 0.9338746070861816
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new CardScript.Content._defend(enemy, engine.gameData.difficulty).serialize(),",
"score": 0.8909051418304443
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " mem: 0,\n maxMem: 0,\n sec: 1,\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };\n enemy.scripts.push(",
"score": 0.8884138464927673
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " cpu: 2,\n mem: 0,\n maxMem: 0,\n sec: 1,\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };",
"score": 0.8877564668655396
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " maxMem: 1,\n sec: GameEngineUtils.scaleByDifficulty(30, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },",
"score": 0.8852832317352295
}
] | typescript | new RulesetGoliath.cardMods.goliath_power_supply().serialize(),
],
scripts: [],
}; |
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": " 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": 0.8343816995620728
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " ],\n );\n }\n }\n export class _attack extends CardScript {\n constructor(card: GameEngine.ICardState, difficulty: number, strength: 'weak' | 'normal' | 'strong' = 'normal', cooldown = 0) {\n let minDmg = 0;\n let maxDmg = 0;\n switch (strength) {\n case 'weak':",
"score": 0.8231803178787231
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": "// Note: replace with custom game content\nconst gameContent: GameEngine.IRuleset = {\n cardMods: { /** Custom card modifiers **/ },\n cardScripts: { /** Custom card scripts **/ },\n initGame(engine) {\n const testEnemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n enemyClass: 'testEnemy',\n cpu: 1,\n mem: 1,",
"score": 0.8194876909255981
},
{
"filename": "src/appraise.ts",
"retrieved_chunk": "const MINT_HEIGHT_THRESHOLD = 3200000;\nexport type CoreScriptNames = typeof _CoreScriptNames[IAppraisedCard['faction']][number];\nexport interface IAppraisedCard {\n nftId: string;\n faction: 'backdoor' | 'bruteforce' | 'malware';\n coreScript: CoreScriptNames;\n tier: number;\n cpu: number;\n mem: number;\n url: string;",
"score": 0.8166526556015015
},
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " playerId: string;\n endedAt: string;\n gameId: string;\n gameResult: 'win' | 'loss' | 'abandoned' | 'unknown';\n teammates: string[];\n score: number;\n turns: number;\n difficulty: number;\n rulesetIds: string[];\n }",
"score": 0.8162749409675598
}
] | typescript | card: IAppraisedCard; |
import { clamp, round } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
export namespace GameEngineUtils {
export function addEnemy(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, spawnIndex: number, generateIntent: boolean) {
if (engine.gameData.enemies.length >= engine.gameData.maxEnemies) return;
spawnIndex = clamp(spawnIndex, 0, engine.gameData.enemies.length);
engine.gameData.enemies.splice(spawnIndex, 0, enemy);
engine.broadcast.push({
type: 'cardAdded',
enemy,
position: spawnIndex,
});
GameEngineUtils.triggerMods('onInitMod', { engine, sourceCard: enemy });
if (generateIntent) {
GameEngineUtils.generateIntent(engine, enemy);
}
return enemy;
}
export function changeCardIsUsed(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState, isUsed: boolean) {
card.isUsed = isUsed;
engine.broadcast.push({
type: 'cardIsUsedChanged',
cardId: card.id,
isUsed,
});
}
export function clearIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = undefined;
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
});
return true;
}
export function changeCpu(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, cpuDelta: number) {
card.cpu += cpuDelta;
engine.broadcast.push({
type: 'cpuChanged',
cardId: card.id,
newCpu: card.cpu,
cpuDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeMem(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, memDelta: number) {
card.mem += memDelta;
engine.broadcast.push({
type: 'memChanged',
cardId: card.id,
newMem: card.mem,
memDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeSec(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, secDelta: number, isPassive: boolean, contextCard?: GameEngine.ICardState) {
const clampedSecDelta = (card.sec < -secDelta) ? -card.sec : secDelta;
card.sec += clampedSecDelta;
engine.broadcast.push({
type: isPassive ? 'secChange' : (secDelta < 0 ? 'secDamage' : 'secBonus'),
cardId: card.id,
newSec: card.sec,
value: secDelta,
});
if (!isPassive && contextCard) {
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
if (player) {
(clampedSecDelta >= 0) ? (player.stats.secBonus += clampedSecDelta) : (player.stats.secDmg += -clampedSecDelta);
}
}
}
export function executeIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, dontClearIntent = false) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = dontClearIntent ? enemy.intent : undefined;
let targetCard: GameEngine.ICardState | undefined;
if (intent.targetCardId >= 0) {
targetCard = findCardByIdMaybe(engine.gameData, intent.targetCardId);
if (!targetCard) {
// Intent target could've been removed between intent generation and execution
return false;
}
} else {
targetCard = enemy;
}
CardScript.execute(engine, enemy, intent.scriptData, targetCard);
return true;
}
export function findCardById(gameData: GameEngine.IGameData, cardId: number) {
const card = findCardByIdMaybe(gameData, cardId);
if (card) return card;
throw new Error('card not found');
}
export function findCardByIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
const enemy = | gameData.enemies.find(x => x.id === cardId); |
if (enemy) return enemy;
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) {
return player.cards.find(x => x.id === cardId);
}
return;
}
export function findPlayerCardById(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (!player) throw new Error('player not found');
return player.cards.find(x => x.id === cardId)!;
}
export function findPlayerByCardId(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) return player;
throw new Error('player not found');
}
export function findPlayerByCardIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
return [...gameData.players.values()].find(x => x.cards.find(x => x.id === cardId));
}
export function generateIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
enemy.intent = undefined;
const isOffline = !!enemy.mods.find(x => x[0] === 'offline');
if (isOffline) return;
const scriptData = enemy.scripts.filter(x => !CardScript.isOnCooldown(x)).randomOrUndefined();
if (!scriptData) {
return;
}
const script = CardScript.deserialize(engine, enemy, scriptData);
const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();
if (!target) {
return;
}
enemy.intent = {
scriptData,
targetCardId: target.id,
};
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
intent: enemy.intent,
});
}
export function getEnemyIds(gameData: GameEngine.IGameData) {
return gameData.enemies.map(x => x.id);
}
export function getPlayerIds(gameData: GameEngine.IGameData, ...excludePlayer: string[]) {
return [...gameData.players.keys()].filter(x => !excludePlayer.includes(x));
}
export function getPlayerCards(gameData: GameEngine.IGameData) {
return [...gameData.players.values()].map(x => x.cards).flat();
}
export function getPlayerCardIds(gameData: GameEngine.IGameData) {
return getPlayerCards(gameData).map(x => x.id);
}
export function isEnemyCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IEnemyCardState {
return !!gameData.enemies.find(x => x.id === card.id);
}
export function isPlayerCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IPlayerCardState {
return !isEnemyCard(gameData, card);
}
export function recalculateScripts(engine: GameEngine.IGameEngine, card: GameEngine.ICardState) {
if (card.isRemoved) return;
card.scripts = card.scripts.map(x => CardScript.deserialize(engine, card, x).serialize());
engine.broadcast.push(...card.scripts.map(x => ({
type: 'scriptChanged',
cardId: card.id,
scriptData: x,
})));
if (isEnemyCard(engine.gameData, card) && card.intent?.scriptData) {
card.intent.scriptData = CardScript.deserialize(engine, card, card.intent.scriptData).serialize();
engine.broadcast.push({
type: 'cardIntent',
cardId: card.id,
intent: card.intent,
});
}
}
export function revalidateIntents(engine: GameEngine.IGameEngine, regenerateIfInvalid: boolean) {
for (const enemy of engine.gameData.enemies) {
if (!enemy.intent || enemy.intent.targetCardId === -1) {
continue;
}
const script = CardScript.deserialize(engine, enemy, enemy.intent.scriptData);
const validTargets = script.targetFinder(engine.gameData, enemy);
if (validTargets.find(x => x.id === enemy.intent?.targetCardId)) {
continue;
}
enemy.intent = undefined;
if (regenerateIfInvalid) {
generateIntent(engine, enemy);
}
}
}
export function removeCard(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, contextCard?: GameEngine.ICardState) {
if (card.isRemoved) {
return;
}
if (isEnemyCard(engine.gameData, card)) {
engine.gameData.enemies.removeFirst(card)
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
for (const enemy of [...engine.gameData.enemies]) {
if (enemy.isRemoved) continue;
triggerMods('onEnemyDestroyed', { engine, sourceCard: card, contextCard });
}
if (contextCard) {
const player = findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
player && player.stats.kills++;
}
GameEngineUtils.revalidateIntents(engine, true);
} else {
const player = GameEngineUtils.findPlayerByCardId(engine.gameData, card.id);
player.cards.removeFirst(card);
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
GameEngineUtils.revalidateIntents(engine, false);
}
}
export function scaleByCpuMem(baseValue: number, cpuMem: number, cpuMemScaling: 'normal' | 'less' | 'more' | 'minimal' | 'high' = 'normal') {
let valuePerCpu = baseValue / 2;
switch (cpuMemScaling) {
case 'high': valuePerCpu * 1.5; break;
case 'more': valuePerCpu * 1.25; break;
case 'less': valuePerCpu * .75; break;
case 'minimal': valuePerCpu * .5; break;
}
return Math.round(baseValue + ((cpuMem - 1) * valuePerCpu));
}
export function scaleByDifficulty(value: number, difficulty: number, decimals = 0) {
return round(value * Math.pow(1.1, difficulty - 1), decimals);
}
export function spawnEnemy(engine: GameEngine.IGameEngine, enemyClass: string, spawnIndex: number, generateIntent: boolean) {
const enemyFactory = engine.ruleset.enemyCards?.[enemyClass];
if (!enemyFactory) throw new Error('EnemyClass not found for spawning: ' + enemyClass);
const enemy = enemyFactory(engine);
enemy.enemyClass = enemyClass;
return addEnemy(engine, enemy, spawnIndex, generateIntent);
}
export function triggerMods<T extends CardMod.ModEvent>(ev: T, ...args: Parameters<NonNullable<CardMod[typeof ev]>>): ReturnType<NonNullable<CardMod[typeof ev]>>[] {
const deps = args[0];
const card = deps.sourceCard;
return [...card.mods]
.map(modData => (!card.isRemoved && card.mods.find(x => CardMod.areEqual(x, modData))) ? CardMod.trigger(ev, modData, ...args) : undefined)
.filter(Boolean);
}
} | src/game/game-engine-utils.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " const i = cards.findIndex(x => x.id === targetCard.id);\n return [cards[i], cards[i - 1], cards[i + 1]].filter(Boolean);\n };\n export const AllAllies: ITargetResolver = (gameData, sourceCard) => {\n if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {\n return TargetFinders._excludeOffline(gameData.enemies);\n } else {\n return TargetFinders._excludeOffline(GameEngineUtils.getPlayerCards(gameData));\n }\n };",
"score": 0.8751136064529419
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " export const RandomOpponent: ITargetResolver = (gameData, sourceCard, targetCard) => {\n return TargetFinders._excludeImperviousAndOffline([AllOpponents(gameData, sourceCard, targetCard).random()]);\n };\n }\n export namespace TargetFinders {\n export const Self: ITargetFinder = (_gameData, card) => [card];\n export const Allies = (excludeSelf = false): ITargetFinder =>\n (gameData, card) => {\n let targets: GameEngine.ICardState[] = GameEngineUtils.isEnemyCard(gameData, card) ? gameData.enemies : GameEngineUtils.getPlayerCards(gameData);\n excludeSelf && (targets = targets.filter(x => x.id !== card.id));",
"score": 0.8729905486106873
},
{
"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": 0.8692889213562012
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " });\n }\n static async requestCardTargets(gameId: string, playerId: string, cardId: number, scriptName: string) {\n const gameData = await _Engine.getGameData(gameId);\n const card = GameEngineUtils.findPlayerCardById(gameData, cardId);\n let targets = [] as number[];\n try {\n if (card.isUsed) {\n return;\n }",
"score": 0.8634445667266846
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " throw new Error(`Could not find [${modName}] to remove`);\n }\n }\n CardMod.removeModByName(engine, targetCard, modName, sourceCard);\n };\n export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>\n (engine, sourceCard, _targetCard) => {\n let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);\n switch (spawnPosition) {\n case 'absLeft': spawnIndex = 0; break;",
"score": 0.8613793253898621
}
] | 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": 0.8919104933738708
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " for (const script of card.scripts) {\n const cooldownData = CardScript.findCooldownData(script);\n if (!cooldownData?.[1]) {\n continue;\n }\n cooldownData[1]--;\n broadcast.push({\n type: 'scriptChanged',\n cardId: card.id,\n scriptData: script,",
"score": 0.8745933771133423
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());\n }\n }\n const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);\n if (cooldownData) {\n cooldownData[1] = cooldownData[2] + 1;\n }\n const script = this.deserialize(engine, sourceCard, sourceCardScript);\n const targets = script.targetFinder(engine.gameData, sourceCard);\n if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {",
"score": 0.8509955406188965
},
{
"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": 0.8490994572639465
},
{
"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": 0.8340588212013245
}
] | 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/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": 0.8995360732078552
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\n export interface IEnemyCardState extends _ICommonCardState {\n enemyClass: string;\n intent?: { scriptData: CardScript.ScriptData, targetCardId: number };\n maxMem: number;\n }\n export type ICardState = IPlayerCardState | IEnemyCardState;\n export abstract class GameEngineError extends Error {\n constructor(\n public gameId: string,",
"score": 0.890984058380127
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " )\n ),\n ],\n }\n ],\n );\n }\n }\n export class bd_exploit extends CardScript {\n constructor(card: GameEngine.ICardState) {",
"score": 0.8880077004432678
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " ],\n }\n ],\n );\n this.cooldownMax = 3;\n }\n },\n // Redirect intent\n mw_spoof: class extends CardScript {\n constructor(_card: GameEngine.ICardState) {",
"score": 0.8818909525871277
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " ],\n }\n ],\n );\n this.cooldownMax = 1;\n }\n },\n // Cause Offline\n bf_ddos: class extends CardScript {\n constructor(_card: GameEngine.ICardState) {",
"score": 0.8747406601905823
}
] | typescript | public scriptData: CardScript.ScriptData,
override duration: number,
) { |
import * as moment from 'moment';
import { IAppraisedCard, appraiseCard } from '../appraise';
import { IDataSource, IMetricsProvider, IPlayerPushProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { SECS_IN_MIN } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameContent_v1 } from './game-content-v1';
import { GameEngineUtils } from './game-engine-utils';
export namespace GameEngine {
interface _ICommonCardState {
id: number;
cpu: number;
mem: number;
sec: number;
mods: CardMod.ModData[];
scripts: CardScript.ScriptData[];
isRemoved?: boolean;
}
export interface IGameData {
id: string;
difficulty: number;
state: 'created' | 'started' | 'players_won' | 'players_lost' | 'abandoned';
enemies: IEnemyCardState[];
maxEnemies: number;
players: Map<string, IPlayerState>;
defaultMovesPerTurn: number;
turn: number;
nextId: number;
pendingPlayers: Map<string, string[]>;
rulesetIds: string[];
}
export interface IPlayerState {
id: string;
cards: IPlayerCardState[];
endedTurn: boolean;
idleKickTime: number;
movesLeft: number;
movesPerTurn: number;
score: number;
stats: {
kills: number;
secDmg: number;
memDmg: number;
secBonus: number;
};
}
export interface IPlayerCardState extends _ICommonCardState {
card: IAppraisedCard;
isUsed: boolean;
}
export interface IEnemyCardState extends _ICommonCardState {
enemyClass: string;
intent?: { scriptData: CardScript.ScriptData, targetCardId: number };
maxMem: number;
}
export type ICardState = IPlayerCardState | IEnemyCardState;
export abstract class GameEngineError extends Error {
constructor(
public gameId: string,
) {
super();
this.message = `${this.constructor.name} processing game ${gameId}`;
}
}
export class GameNotFoundError extends GameEngineError { }
export interface IRulesetContent {
cardMods?: CardMod.ModLibrary;
cardScripts?: CardScript.ScriptLibrary;
enemyCards?: Record<string, (engine: IGameEngine) => IEnemyCardState>;
}
export interface IRuleset extends IRulesetContent {
initGame(engine: IGameEngine): void;
addAdditionalScriptsFor?(engine: GameEngine.IGameEngine, card: IPlayerCardState): void;
}
export function mergeRulesetContents(...rulesets: IRulesetContent[]): IRulesetContent {
const modLibs = rulesets.map(x => x.cardMods).filter(Boolean);
const scriptLibs = rulesets.map(x => x.cardScripts).filter(Boolean);
const enemyLibs = rulesets.map(x => x.enemyCards).filter(Boolean);
return {
cardMods: Object.fromEntries(modLibs.map(modLib => Object.keys(modLib).map(modName => [modName, modLib[modName]!] as const)).flat()),
cardScripts: Object.fromEntries(scriptLibs.map(scriptLib => Object.keys(scriptLib).map(scriptName => [scriptName, scriptLib[scriptName]!] as const)).flat()),
enemyCards: Object.fromEntries(enemyLibs.map(enemyLib => Object.keys(enemyLib).map(enemyClass => [enemyClass, enemyLib[enemyClass]!] as const)).flat()),
};
}
export type IGameEngine = InstanceType<ReturnType<typeof createGameEngineProvider>>;
}
export const createGameEngineProvider = (rulesets: Record<string, GameEngine.IRuleset>, ds: IDataSource, playerPushProvider: IPlayerPushProvider, metrics?: IMetricsProvider) => {
return class _Engine {
readonly broadcast: IPlayerPushProvider.IPushMessage[] = [];
ruleset!: GameEngine.IRuleset;
constructor(
readonly gameData: GameEngine.IGameData,
) {
const currentRuleset = rulesets[gameData.rulesetIds.at(-1)!];
if (!currentRuleset) throw new Error('invalid initial ruleSet id: ' + gameData.rulesetIds[0]);
this._setRuleset(currentRuleset);
}
private static async _withEngine(gameId: string, stateAssertion: GameEngine.IGameData['state'][], func: (engine: _Engine) => Promise<void>): Promise<GameEngine.IGameData> {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
const engine = new _Engine(gameData);
try {
if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);
await func(engine);
await ds.GameData.update.exec(gameData);
} catch (e: any) {
e.broadcast = engine.broadcast;
throw e;
}
if (engine.broadcast.length) {
await Promise.all(
[...gameData.players.keys()].map(playerId => playerPushProvider.push(playerId, engine.broadcast)),
);
}
return gameData;
}
static async createGame(gameId: string, rulesetId: string, difficulty: number) {
const ruleset = rulesets[rulesetId];
if (!ruleset) throw new Error('invalid ruleSet id: ' + rulesetId);
const existingGameData = await ds.GameData.get(gameId);
if (existingGameData) throw new Error('game with id already exists: ' + gameId);
const gameData: GameEngine.IGameData = {
id: gameId,
difficulty: Math.max(1, difficulty),
state: 'created',
turn: 1,
players: new Map(),
defaultMovesPerTurn: 3,
enemies: [],
maxEnemies: 9,
nextId: 1,
pendingPlayers: new Map(),
rulesetIds: [rulesetId],
};
await ds.GameData.update.exec(gameData);
}
static async startGame(gameId: string) {
const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {
for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
engine.broadcast.push({ type: 'playerJoin', playerState });
}
engine.gameData.pendingPlayers.clear();
engine.gameData.state = 'started';
engine.broadcast.push({ type: 'gameStart' });
engine.ruleset.initGame(engine);
});
return gameData;
}
static async endGame(gameId: string) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
engine.gameData.state = 'abandoned';
engine.broadcast.push({ type: 'gameEnd' });
});
}
static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
if (engine.gameData.players.has(playerId)) throw new Error('player already in game');
if (engine.gameData.players.size >= 2) throw new Error('game is full: ' + gameId);
if (engine.gameData.state === 'started') {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
if (engine.gameData.turn >= 2) {
playerState.endedTurn = true;
playerState.movesLeft = 0;
}
engine.broadcast.push({
type: 'playerJoin',
playerState,
});
} else {
engine.gameData.pendingPlayers.set(playerId, cardIds);
}
});
}
static async removePlayer(gameId: string, playerId: string, reason: 'idle' | 'leave') {
return await _Engine._withEngine(gameId, [], async engine => {
if (!engine.gameData.players.delete(playerId)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId, reason });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
});
}
static async requestCardTargets(gameId: string, playerId: string, cardId: number, scriptName: string) {
const gameData = await _Engine.getGameData(gameId);
const card = GameEngineUtils.findPlayerCardById(gameData, cardId);
let targets = [] as number[];
try {
if (card.isUsed) {
return;
}
| const scriptData = card.scripts.find(x => x[0] === scriptName); |
if (!scriptData) {
throw new Error(`Script [${scriptName}] not found in card [${cardId}]`);
}
if (CardScript.isOnCooldown(scriptData)) {
return;
}
const engine = new _Engine(gameData);
const script = CardScript.deserialize(engine, card, scriptData);
targets = script.targetFinder(gameData, card).map(x => x.id);
} finally {
await playerPushProvider.push(playerId, [{
type: 'cardTargets',
cardId,
scriptName,
targetCardIds: targets,
}]);
}
}
static async intent(gameId: string, playerId: string, sourceCardId?: string, sourceCardScript?: string, targetCardId?: string) {
const gameData = await _Engine.getGameData(gameId);
const pushMessage: IPlayerPushProvider.IPushMessage[] = [{
type: 'cardIntent',
cardId: sourceCardId,
intent: {
scriptData: sourceCardScript,
targetCardId,
},
playerId,
}];
await Promise.all(
[...gameData.players.keys()].filter(x => x !== playerId).map(x => playerPushProvider?.push(x, pushMessage)),
);
}
static async makeMove(gameId: string, playerId: string, sourceCardId: number, sourceCardScript: CardScript.ScriptData, targetCardId: number) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = GameEngineUtils.findPlayerByCardId(engine.gameData, sourceCardId);
if (playerState.id !== playerId) {
throw new Error(`Player ${playerId} cannot make move on card ${sourceCardId} from owner ${playerState.id}`);
}
if (!playerState.movesLeft) {
throw new Error(`No moves left`);
}
const sourceCard = playerState.cards.find(x => x.id === sourceCardId)!;
if (sourceCard.isUsed) {
throw new Error(`Card is used`);
}
const now = moment.now();
playerState.idleKickTime = now + 2 * SECS_IN_MIN * 1000;
playerState.movesLeft--;
const targetCard = GameEngineUtils.findCardById(engine.gameData, targetCardId);
CardScript.execute(engine, sourceCard, sourceCardScript, targetCard);
GameEngineUtils.changeCardIsUsed(engine, sourceCard, true);
metrics?.playerCardPlayed(gameId, engine.gameData.rulesetIds[0] || 'unknown', playerId, sourceCard, sourceCardScript[0]);
});
}
static async toggleEndTurn(gameId: string, playerId: string) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = engine.gameData.players.get(playerId);
if (!playerState) throw new Error('player not found');
if (playerState.endedTurn) {
playerState.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: false,
});
return;
}
playerState.endedTurn = true;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: true,
});
if (![...engine.gameData.players.values()].reduce((numNotReady, playerState) => playerState.endedTurn ? numNotReady : (numNotReady + 1), 0)) {
const now = moment.now();
[...engine.gameData.players.values()].forEach(x => x.idleKickTime = now + 2 * SECS_IN_MIN * 1000);
engine.onEndTurn();
if (engine.gameData.state !== 'started') {
// Stop if the game was won/lost due to an EndTurn effect
return;
}
engine.onTurnStart();
}
});
}
static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {
let kickedPlayerId = '';
await _Engine._withEngine(gameId, ['started'], async engine => {
const playerToKick = [...engine.gameData.players.values()].find(x => x.id !== kickRequestingPlayerId) || '';
if (!playerToKick) throw new Error('kickIfIdle: player not found');
if (playerToKick.idleKickTime < moment.now()) {
if (!engine.gameData.players.delete(playerToKick.id)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId: playerToKick.id, reason: 'idle' });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
kickedPlayerId = playerToKick.id;
}
});
return kickedPlayerId || null;
}
static async getGameData(gameId: string) {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
return gameData;
}
private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {
const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))
.filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)
.map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));
if (cards.length !== cardIds.length) {
throw `could not resolve all cards for player ${playerId}`;
}
const player: GameEngine.IPlayerState = {
id: playerId,
cards: cards.map(card => ({
id: this.nextId(),
card,
isUsed: false,
cpu: card.cpu,
mem: card.mem,
sec: card.mem * 6 + card.cpu * 3,
mods: [],
scripts: [],
})),
endedTurn: false,
movesLeft: this.gameData.defaultMovesPerTurn,
movesPerTurn: this.gameData.defaultMovesPerTurn,
stats: {
kills: 0,
memDmg: 0,
secBonus: 0,
secDmg: 0,
},
score: 0,
idleKickTime: moment.now() + 2 * SECS_IN_MIN * 1000,
};
for (const card of player.cards) {
card.scripts = [
CardScript.fromScriptName(this, card, card.card.coreScript),
];
this.ruleset.addAdditionalScriptsFor && this.ruleset.addAdditionalScriptsFor(this, card);
}
return player;
}
findRuleset(rulesetId: string) {
return rulesets[rulesetId];
}
onTurnStart() {
this.gameData.turn++;
this.broadcast.push({
type: 'newTurn',
turn: this.gameData.turn,
});
for (const player of this.gameData.players.values()) {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
}
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of playerCards) {
GameEngineUtils.changeCardIsUsed(this, playerCard, false);
}
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: playerCard });
}
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: enemy });
}
this._checkGameOver();
}
onEndTurn() {
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: playerCard });
CardScript.tickCooldowns(playerCard, this.broadcast);
}
this.broadcast.push({
type: 'playerTurnEnded',
});
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: enemy });
CardScript.tickCooldowns(enemy, this.broadcast);
}
this.broadcast.push({
type: 'enemyTurnEnded',
});
this._checkGameOver();
}
onNextWave(nextRulesetId: string) {
while (this.gameData.enemies[0]) {
GameEngineUtils.removeCard(this, this.gameData.enemies[0]);
}
[...this.gameData.players.values()].forEach(player => {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
player.cards.forEach(card => {
card.isUsed = false;
});
});
this.gameData.turn++;
this.broadcast.push({
type: 'nextWave',
turn: this.gameData.turn,
nextRulesetId,
});
const nextRuleset = this.findRuleset(nextRulesetId);
if (!nextRuleset) {
throw new Error('invalid rulesetId: ' + nextRulesetId);
}
this.gameData.rulesetIds.push(nextRulesetId);
this._setRuleset(nextRuleset);
nextRuleset.initGame(this);
}
onWinGame() {
this.gameData.state = 'players_won';
this.broadcast.push({
type: 'players_won',
stats: [...this.gameData.players.values()].map(player => {
let score =
player.cards.length * 50
+ player.stats.kills * 25
+ player.stats.memDmg * 50
+ player.stats.secDmg
+ player.stats.secBonus * 2
+ ((this.gameData.rulesetIds.length - 1) * 2000);
score = GameEngineUtils.scaleByDifficulty(score, this.gameData.difficulty + 1);
player.score = score;
return { playerId: player.id, stats: player.stats, score };
}),
});
}
nextId() {
return this.gameData.nextId++;
}
private _checkGameOver() {
if (!GameEngineUtils.getPlayerCards(this.gameData).length) {
this.gameData.state = 'players_lost';
this.broadcast.push({
type: 'players_lost',
});
}
}
private _setRuleset(nextRuleset: GameEngine.IRuleset) {
this.ruleset = {
addAdditionalScriptsFor: GameContent_v1.addAdditionalScriptsFor,
...nextRuleset,
...GameEngine.mergeRulesetContents(
nextRuleset,
{
cardMods: CardMod.Content,
cardScripts: CardScript.Content,
},
{
cardMods: GameContent_v1.cardMods,
cardScripts: GameContent_v1.cardScripts,
enemyCards: GameContent_v1.enemyCards,
}
),
};
}
}
}
export type GameEngineProvider = ReturnType<typeof createGameEngineProvider>; | src/game/game-engine.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " targetCard = enemy;\n }\n CardScript.execute(engine, enemy, intent.scriptData, targetCard);\n return true;\n }\n export function findCardById(gameData: GameEngine.IGameData, cardId: number) {\n const card = findCardByIdMaybe(gameData, cardId);\n if (card) return card;\n throw new Error('card not found');\n }",
"score": 0.905896008014679
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " export function findCardByIdMaybe(gameData: GameEngine.IGameData, cardId: number) {\n const enemy = gameData.enemies.find(x => x.id === cardId);\n if (enemy) return enemy;\n const player = findPlayerByCardIdMaybe(gameData, cardId);\n if (player) {\n return player.cards.find(x => x.id === cardId);\n }\n return;\n }\n export function findPlayerCardById(gameData: GameEngine.IGameData, cardId: number) {",
"score": 0.8844685554504395
},
{
"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": 0.877034068107605
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " targetCardId: targetCard.id,\n scriptData: sourceCardScript,\n });\n if (this.isOnCooldown(sourceCardScript)) {\n throw new Error('Script is on cooldown: ' + sourceCardScript.join());\n }\n const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript));\n const isEnemy = GameEngineUtils.isEnemyCard(engine.gameData, sourceCard);\n if (!isEnemy) {\n if (!scriptDataFromCard) {",
"score": 0.871435284614563
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());\n }\n }\n const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);\n if (cooldownData) {\n cooldownData[1] = cooldownData[2] + 1;\n }\n const script = this.deserialize(engine, sourceCard, sourceCardScript);\n const targets = script.targetFinder(engine.gameData, sourceCard);\n if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {",
"score": 0.8706822395324707
}
] | 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-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": 0.8364150524139404
},
{
"filename": "src/appraise.ts",
"retrieved_chunk": " const SQ = Q.slice(2);\n const tier = SQ.reduce((sum, c) => isNaN(+c) ? sum : (sum + 1), 0);\n if (tier < 2 || mintHeight >= MINT_HEIGHT_THRESHOLD) {\n // Less than 2 digits or minted after threshold is a T1; either 1/2 or 2/1\n const singleQualifier = Q[1]; // Only either 's' or 'q'\n const cpu = singleQualifier === 's' ? 2 : 1;\n const mem = 3 - cpu;\n return {\n nftId,\n faction,",
"score": 0.8100247383117676
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " // MUST always be the first parameter even if not used\n card: GameEngine.ICardState,\n // Not used but declared to show how the memo is passed back here, see first argument in super(...) below\n _secDamage: number,\n ) {\n const secDamage = GameEngineUtils.scaleByCpuMem(12, card.cpu);\n const bdChance = round(GameEngineUtils.scaleByCpuMem(20, card.mem, 'high') / 100, 2);\n const bdDamage = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n super(\n // Any extra data to serialize into scriptData[1:] as a 'memo' which can serve two purposes:",
"score": 0.8096961379051208
},
{
"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": 0.7869608402252197
},
{
"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": 0.7859222888946533
}
] | typescript | return round(value * Math.pow(1.1, difficulty - 1), decimals); |
import { clamp, round } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
export namespace GameEngineUtils {
export function addEnemy(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, spawnIndex: number, generateIntent: boolean) {
if (engine.gameData.enemies.length >= engine.gameData.maxEnemies) return;
spawnIndex = clamp(spawnIndex, 0, engine.gameData.enemies.length);
engine.gameData.enemies.splice(spawnIndex, 0, enemy);
engine.broadcast.push({
type: 'cardAdded',
enemy,
position: spawnIndex,
});
GameEngineUtils.triggerMods('onInitMod', { engine, sourceCard: enemy });
if (generateIntent) {
GameEngineUtils.generateIntent(engine, enemy);
}
return enemy;
}
export function changeCardIsUsed(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState, isUsed: boolean) {
card.isUsed = isUsed;
engine.broadcast.push({
type: 'cardIsUsedChanged',
cardId: card.id,
isUsed,
});
}
export function clearIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = undefined;
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
});
return true;
}
export function changeCpu(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, cpuDelta: number) {
card.cpu += cpuDelta;
engine.broadcast.push({
type: 'cpuChanged',
cardId: card.id,
newCpu: card.cpu,
cpuDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeMem(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, memDelta: number) {
card.mem += memDelta;
engine.broadcast.push({
type: 'memChanged',
cardId: card.id,
newMem: card.mem,
memDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeSec(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, secDelta: number, isPassive: boolean, contextCard?: GameEngine.ICardState) {
const clampedSecDelta = (card.sec < -secDelta) ? -card.sec : secDelta;
card.sec += clampedSecDelta;
engine.broadcast.push({
type: isPassive ? 'secChange' : (secDelta < 0 ? 'secDamage' : 'secBonus'),
cardId: card.id,
newSec: card.sec,
value: secDelta,
});
if (!isPassive && contextCard) {
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
if (player) {
(clampedSecDelta >= 0) ? (player.stats.secBonus += clampedSecDelta) : (player.stats.secDmg += -clampedSecDelta);
}
}
}
export function executeIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, dontClearIntent = false) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = dontClearIntent ? enemy.intent : undefined;
let targetCard: GameEngine.ICardState | undefined;
if (intent.targetCardId >= 0) {
targetCard = findCardByIdMaybe(engine.gameData, intent.targetCardId);
if (!targetCard) {
// Intent target could've been removed between intent generation and execution
return false;
}
} else {
targetCard = enemy;
}
CardScript.execute(engine, enemy, intent.scriptData, targetCard);
return true;
}
export function findCardById(gameData: GameEngine.IGameData, cardId: number) {
const card = findCardByIdMaybe(gameData, cardId);
if (card) return card;
throw new Error('card not found');
}
export function findCardByIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
const enemy = gameData.enemies.find(x => x.id === cardId);
if (enemy) return enemy;
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) {
return player.cards.find(x => x.id === cardId);
}
return;
}
export function findPlayerCardById(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (!player) throw new Error('player not found');
return player.cards.find(x => x.id === cardId)!;
}
export function findPlayerByCardId(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) return player;
throw new Error('player not found');
}
export function findPlayerByCardIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
return [...gameData.players.values()].find(x => x.cards.find(x => x.id === cardId));
}
export function generateIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
enemy.intent = undefined;
const isOffline = !!enemy.mods.find(x => x[0] === 'offline');
if (isOffline) return;
const scriptData = enemy.scripts.filter(x => !CardScript.isOnCooldown(x)).randomOrUndefined();
if (!scriptData) {
return;
}
const script = CardScript.deserialize(engine, enemy, scriptData);
const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();
if (!target) {
return;
}
enemy.intent = {
scriptData,
targetCardId: target.id,
};
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
intent: enemy.intent,
});
}
export function getEnemyIds(gameData: GameEngine.IGameData) {
return gameData.enemies.map(x => x.id);
}
export function getPlayerIds(gameData: GameEngine.IGameData, ...excludePlayer: string[]) {
return [...gameData.players.keys()].filter(x => !excludePlayer.includes(x));
}
export function getPlayerCards(gameData: GameEngine.IGameData) {
return [...gameData.players.values()].map(x => x.cards).flat();
}
export function getPlayerCardIds(gameData: GameEngine.IGameData) {
return getPlayerCards(gameData).map(x => x.id);
}
export function isEnemyCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IEnemyCardState {
return !!gameData.enemies.find(x => x.id === card.id);
}
export function isPlayerCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IPlayerCardState {
return !isEnemyCard(gameData, card);
}
export function recalculateScripts(engine: GameEngine.IGameEngine, card: GameEngine.ICardState) {
if (card.isRemoved) return;
card.scripts = card.scripts.map(x => CardScript.deserialize(engine, card, x).serialize());
engine.broadcast.push(...card.scripts.map(x => ({
type: 'scriptChanged',
cardId: card.id,
scriptData: x,
})));
if (isEnemyCard(engine.gameData, card) && card.intent?.scriptData) {
card.intent.scriptData = CardScript.deserialize(engine, card, card.intent.scriptData).serialize();
engine.broadcast.push({
type: 'cardIntent',
cardId: card.id,
intent: card.intent,
});
}
}
export function revalidateIntents(engine: GameEngine.IGameEngine, regenerateIfInvalid: boolean) {
for (const enemy of engine.gameData.enemies) {
if (!enemy.intent || enemy.intent.targetCardId === -1) {
continue;
}
const script = CardScript.deserialize(engine, enemy, enemy.intent.scriptData);
const validTargets = script.targetFinder(engine.gameData, enemy);
if (validTargets.find(x => x.id === enemy.intent?.targetCardId)) {
continue;
}
enemy.intent = undefined;
if (regenerateIfInvalid) {
generateIntent(engine, enemy);
}
}
}
export function removeCard(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, contextCard?: GameEngine.ICardState) {
if (card.isRemoved) {
return;
}
if (isEnemyCard(engine.gameData, card)) {
engine.gameData.enemies.removeFirst(card)
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
for (const enemy of [...engine.gameData.enemies]) {
if (enemy.isRemoved) continue;
triggerMods('onEnemyDestroyed', { engine, sourceCard: card, contextCard });
}
if (contextCard) {
const player = findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
player && player.stats.kills++;
}
GameEngineUtils.revalidateIntents(engine, true);
} else {
const player = GameEngineUtils.findPlayerByCardId(engine.gameData, card.id);
player.cards.removeFirst(card);
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
GameEngineUtils.revalidateIntents(engine, false);
}
}
export function scaleByCpuMem(baseValue: number, cpuMem: number, cpuMemScaling: 'normal' | 'less' | 'more' | 'minimal' | 'high' = 'normal') {
let valuePerCpu = baseValue / 2;
switch (cpuMemScaling) {
case 'high': valuePerCpu * 1.5; break;
case 'more': valuePerCpu * 1.25; break;
case 'less': valuePerCpu * .75; break;
case 'minimal': valuePerCpu * .5; break;
}
return Math.round(baseValue + ((cpuMem - 1) * valuePerCpu));
}
export function scaleByDifficulty(value: number, difficulty: number, decimals = 0) {
return round(value * Math.pow(1.1, difficulty - 1), decimals);
}
export function spawnEnemy(engine: GameEngine.IGameEngine, enemyClass: string, spawnIndex: number, generateIntent: boolean) {
const enemyFactory = engine.ruleset.enemyCards?.[enemyClass];
if (!enemyFactory) throw new Error('EnemyClass not found for spawning: ' + enemyClass);
const enemy = enemyFactory(engine);
enemy.enemyClass = enemyClass;
return addEnemy(engine, enemy, spawnIndex, generateIntent);
}
export function triggerMods<T extends CardMod.ModEvent>(ev: T, ...args: Parameters<NonNullable<CardMod[typeof ev]>>): ReturnType<NonNullable<CardMod[typeof ev]>>[] {
const deps = args[0];
const card = | deps.sourceCard; |
return [...card.mods]
.map(modData => (!card.isRemoved && card.mods.find(x => CardMod.areEqual(x, modData))) ? CardMod.trigger(ev, modData, ...args) : undefined)
.filter(Boolean);
}
} | src/game/game-engine-utils.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " throw new Error(`Could not find [${modName}] to remove`);\n }\n }\n CardMod.removeModByName(engine, targetCard, modName, sourceCard);\n };\n export const SpawnEnemy = (enemyClass: string, spawnPosition?: 'relLeft' | 'relRight' | 'absLeft' | 'absRight', generateIntent = false): IScriptPart =>\n (engine, sourceCard, _targetCard) => {\n let spawnIndex = engine.gameData.enemies.findIndex(x => x.id === sourceCard.id);\n switch (spawnPosition) {\n case 'absLeft': spawnIndex = 0; break;",
"score": 0.8721181154251099
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {\n const mod = card.mods.find(x => x[0] === modName);\n mod && this.removeMod(engine, card, mod, contextCard);\n }\n static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {\n const deps = args[0];\n const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));\n if (!modDataFromCard) {\n throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);\n }",
"score": 0.8507630228996277
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " this.cooldownCur = startingCooldown;\n this.cooldownMax = cooldown;\n }\n }\n export class _spawn extends CardScript {\n constructor(_card: GameEngine.ICardState, enemyClass: string, spawnPosition: Parameters<typeof CardScriptParts['SpawnEnemy']>[1] = 'relLeft', generateIntent = false, cooldown = 0) {\n super(\n [enemyClass, spawnPosition, generateIntent, cooldown],\n TargetFinders.Self,\n [",
"score": 0.8347048759460449
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " ) {\n super();\n this.message = `${this.constructor.name} processing game ${gameId}`;\n }\n }\n export class GameNotFoundError extends GameEngineError { }\n export interface IRulesetContent {\n cardMods?: CardMod.ModLibrary;\n cardScripts?: CardScript.ScriptLibrary;\n enemyCards?: Record<string, (engine: IGameEngine) => IEnemyCardState>;",
"score": 0.8289304971694946
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " override stackingConfig = {\n behavior: CardMod.StackingBehavior.ranked as const,\n rank: 0,\n };\n constructor(override duration: number) {\n super(arguments);\n this.stackingConfig.rank = duration;\n }\n override onInitMod(deps: ICardModDeps) {\n if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {",
"score": 0.8276001811027527
}
] | 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": " [damage, cooldown],\n CardScript.TargetFinders.Allies(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new GameContent_v1.cardMods.feedback(damage),\n ),\n ],",
"score": 0.8360956907272339
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " CardScriptParts.SecDmg(secDelta),\n CardScriptParts.AddMod(\n new CardMod.Content.offline(offlineDuration),\n ),\n CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),\n ],\n },\n {\n targetResolver: CardScript.TargetResolvers.Self,\n parts: [",
"score": 0.8288354873657227
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Self,\n parts: [\n CardScriptParts.RaiseSec(secBonus),\n CardScriptParts.AddMod(\n new CardMod.Content.firewall(modDuration),\n ),\n ],\n }\n ],",
"score": 0.8249825239181519
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " CardScript.TargetFinders.Opponents(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new _cardMods.exposed(stacks),\n ),\n ],\n }",
"score": 0.8209491968154907
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [secBonus, duration],\n CardScript.TargetFinders.Any(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.AddMod(\n new CardMod.Content.diagnostics(secBonus, duration)\n ),\n ],",
"score": 0.819827675819397
}
] | typescript | cardMods: CardMod.Content,
cardScripts: CardScript.Content,
},
{ |
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": 0.8870670199394226
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " if (deps.sourceCard.mem - memDmg <= 0) return;\n const boss = deps.sourceCard as GameEngine.IEnemyCardState;\n let secBonus = 100;\n const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);\n if (shieldBuff) {\n secBonus += CardMod.getStackCount(shieldBuff) * 100;\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);\n for (const enemy of [...deps.engine.gameData.enemies]) {\n if (enemy === boss) continue;",
"score": 0.8743820786476135
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {\n GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);\n } else {\n GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);\n }\n }\n override onTurnStart(deps: CardMod.ICardModDeps) {\n if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {\n GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);\n } else {",
"score": 0.8426101207733154
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n const bdChance = round(GameEngineUtils.scaleByCpuMem(40, card.mem, 'more') / 100, 2);\n super(\n [damage, bdChance],\n (gameData: GameEngine.IGameData, card: GameEngine.ICardState) => [\n ...TargetFinders.Opponents()(gameData, card),\n ...TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],\n TargetFinders.Opponents(true))(gameData, card),\n ],\n [",
"score": 0.8356273174285889
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);\n }\n }\n override onRemoveMod(deps: ICardModDeps): void {\n if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {\n GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);\n } else {\n GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);\n }\n }",
"score": 0.8353530168533325
}
] | 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/reaper.ts",
"retrieved_chunk": " mem: 0,\n maxMem: 0,\n sec: 1,\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };\n enemy.scripts.push(",
"score": 0.9030199646949768
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " cpu: 2,\n mem: 0,\n maxMem: 0,\n sec: 1,\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };",
"score": 0.8796418309211731
},
{
"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": 0.8740156888961792
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " enemyClass: '',\n cpu: 1,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new RulesetGoliath.cardMods.goliath_shield_supply().serialize(),\n ],\n scripts: [],",
"score": 0.8665888905525208
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " maxMem: 1,\n sec: GameEngineUtils.scaleByDifficulty(30, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },",
"score": 0.8580648899078369
}
] | typescript | testEnemy.mods.push(new CardMod.Content._standardAi().serialize()); |
import { CardMod } from '../card-mods';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
const GOLIATH_ID = 9999;
export const RulesetGoliath = {
cardMods: {
goliath_power_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_power(), deps.sourceCard);
}
},
goliath_shield_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_shield(), deps.sourceCard);
}
},
goliath_boss_ai: class extends CardMod {
override onTurnStart(deps: CardMod.ICardModDeps) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard as GameEngine.IEnemyCardState);
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
const targetId = boss.intent?.targetCardId;
if (!targetId) return;
let numAttacks = 1;
const powerBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_power);
if (powerBuff) {
const powerStacks = CardMod.getStackCount(powerBuff);
numAttacks += powerStacks;
}
for (let i = 0; i < numAttacks - 1; i++) {
GameEngineUtils.executeIntent(deps.engine, boss, true);
}
GameEngineUtils.executeIntent(deps.engine, boss);
}
override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {
if (deps.sourceCard.mem - memDmg <= 0) return;
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
let secBonus = 100;
const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);
if (shieldBuff) {
secBonus += CardMod.getStackCount(shieldBuff) * 100;
}
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);
for (const enemy of [...deps.engine.gameData.enemies]) {
if (enemy === boss) continue;
CardMod.addMod(deps.engine, enemy, new GameContent_v1.cardMods.optimized(1, -1), boss);
}
}
},
goliath_boss_power: class extends CardMod {
override stackingConfig = {
behavior | : CardMod.StackingBehavior.stack as const,
stackCount: 1,
}; |
},
goliath_boss_shield: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
},
},
enemyCards: {
goliath_power_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 2,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_power_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),
);
return enemy;
},
goliath_shield_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_shield_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._defend(enemy, engine.gameData.difficulty, 'weak').serialize(),
new CardScript.Content._firewallSelf(enemy, 1, 2).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: GOLIATH_ID,
enemyClass: 'goliath_boss',
cpu: 2,
mem: 4,
maxMem: 4,
sec: GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
mods: [
new RulesetGoliath.cardMods.goliath_boss_ai().serialize(),
new CardMod.Content._winOnDeath().serialize(),
],
scripts: [],
};
boss.scripts.push(
new CardScript.Content._attack(boss, engine.gameData.difficulty).serialize(),
);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
},
}; | src/game/rulesets/goliath.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);\n } else {\n GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);\n }\n }\n }\n export class secured extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,",
"score": 0.8758958578109741
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,\n };\n constructor(public stackCount: number) {\n super(arguments);\n this.stackingConfig.stackCount = stackCount;\n }\n override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {\n return { secDmgBonus: this.stackingConfig.stackCount };\n }",
"score": 0.8550150990486145
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " }\n override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {\n CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);\n }\n },\n // Increases CPU\n optimized: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 0,",
"score": 0.8548239469528198
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " override stackingConfig = {\n behavior: CardMod.StackingBehavior.ranked as const,\n rank: 0,\n };\n constructor(override duration: number) {\n super(arguments);\n this.stackingConfig.rank = duration;\n }\n override onInitMod(deps: ICardModDeps) {\n if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {",
"score": 0.8515635132789612
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " mods: [\n new RulesetReaper.cardMods.reaper_feederPower().serialize(),\n ],\n scripts: [],\n };\n },\n reaper_guardian: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n enemyClass: 'reaper_guardian',",
"score": 0.851342499256134
}
] | 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 },\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": 0.8620671033859253
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " export const RandomOpponent: ITargetResolver = (gameData, sourceCard, targetCard) => {\n return TargetFinders._excludeImperviousAndOffline([AllOpponents(gameData, sourceCard, targetCard).random()]);\n };\n }\n export namespace TargetFinders {\n export const Self: ITargetFinder = (_gameData, card) => [card];\n export const Allies = (excludeSelf = false): ITargetFinder =>\n (gameData, card) => {\n let targets: GameEngine.ICardState[] = GameEngineUtils.isEnemyCard(gameData, card) ? gameData.enemies : GameEngineUtils.getPlayerCards(gameData);\n excludeSelf && (targets = targets.filter(x => x.id !== card.id));",
"score": 0.8606643676757812
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " const i = cards.findIndex(x => x.id === targetCard.id);\n return [cards[i], cards[i - 1], cards[i + 1]].filter(Boolean);\n };\n export const AllAllies: ITargetResolver = (gameData, sourceCard) => {\n if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {\n return TargetFinders._excludeOffline(gameData.enemies);\n } else {\n return TargetFinders._excludeOffline(GameEngineUtils.getPlayerCards(gameData));\n }\n };",
"score": 0.8579627275466919
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [],\n (gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseMem(-1),\n CardScriptParts.ChangeCpu(1),\n ],\n }",
"score": 0.8549660444259644
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },\n goliath_shield_node: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),",
"score": 0.8528876304626465
}
] | 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/dependencies.d.ts",
"retrieved_chunk": " export type PlayerCoopGame = {\n update: Updater<IPlayerCoopGame>;\n queryByPlayerId: Query<string, IPlayerCoopGame>;\n }\n export type GameData = {\n get: GetterSingle<GameEngine.IGameData>;\n update: Updater<GameEngine.IGameData>;\n };\n export type Leaderboard = {\n getTopN(n: number): Promise<[string, number][]>;",
"score": 0.8070361614227295
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8038536310195923
},
{
"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": 0.7999627590179443
},
{
"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": 0.7978534698486328
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " },\n ],\n }\n ],\n );\n }\n },\n },\n enemyCards: {\n reaper_feeder: (engine: GameEngine.IGameEngine): GameEngine.IEnemyCardState => {",
"score": 0.7948768138885498
}
] | 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": 0.8846173286437988
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " new CardMod.Content._standardAi().serialize(),\n ],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new RulesetStasis.cardScripts.stasis_disrupt(enemy, engine.gameData.difficulty).serialize(),\n );\n return enemy;\n },",
"score": 0.8611036539077759
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " maxMem: 1,\n sec: GameEngineUtils.scaleByDifficulty(30, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },",
"score": 0.8328018188476562
},
{
"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": 0.8261134624481201
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " enemyClass: '',\n cpu: 1,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new RulesetGoliath.cardMods.goliath_shield_supply().serialize(),\n ],\n scripts: [],",
"score": 0.8166821599006653
}
] | typescript | new RulesetReaper.cardScripts.reaper_bossEat(boss).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/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": 0.8787479996681213
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8607093691825867
},
{
"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": 0.8583005666732788
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " this.cooldownMax = 3;\n }\n },\n // Swap for another card's secondary script\n mw_copypaste: class extends CardScript {\n constructor(_card: GameEngine.ICardState) {\n super(\n [],\n CardScript.TargetFinders.Allies(),\n [",
"score": 0.8506437540054321
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " );\n this.cooldownMax = 3;\n }\n },\n //\n // Bruteforce scripts\n //\n // Swap CPU for MEM\n bf_compression: class extends CardScript {\n constructor(_card: GameEngine.ICardState) {",
"score": 0.8466014266014099
}
] | 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/game/game-engine.ts",
"retrieved_chunk": " const playerState = await engine._createPlayerState(playerId, cardIds);\n engine.gameData.players.set(playerId, playerState);\n engine.broadcast.push({ type: 'playerJoin', playerState });\n }\n engine.gameData.pendingPlayers.clear();\n engine.gameData.state = 'started';\n engine.broadcast.push({ type: 'gameStart' });\n engine.ruleset.initGame(engine);\n });\n return gameData;",
"score": 0.8561525344848633
},
{
"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": 0.8410619497299194
},
{
"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": 0.8236236572265625
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 0.8113699555397034
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8111292123794556
}
] | 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/card-scripts.ts",
"retrieved_chunk": " export const RandomOpponent: ITargetResolver = (gameData, sourceCard, targetCard) => {\n return TargetFinders._excludeImperviousAndOffline([AllOpponents(gameData, sourceCard, targetCard).random()]);\n };\n }\n export namespace TargetFinders {\n export const Self: ITargetFinder = (_gameData, card) => [card];\n export const Allies = (excludeSelf = false): ITargetFinder =>\n (gameData, card) => {\n let targets: GameEngine.ICardState[] = GameEngineUtils.isEnemyCard(gameData, card) ? gameData.enemies : GameEngineUtils.getPlayerCards(gameData);\n excludeSelf && (targets = targets.filter(x => x.id !== card.id));",
"score": 0.8582663536071777
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " const i = cards.findIndex(x => x.id === targetCard.id);\n return [cards[i], cards[i - 1], cards[i + 1]].filter(Boolean);\n };\n export const AllAllies: ITargetResolver = (gameData, sourceCard) => {\n if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {\n return TargetFinders._excludeOffline(gameData.enemies);\n } else {\n return TargetFinders._excludeOffline(GameEngineUtils.getPlayerCards(gameData));\n }\n };",
"score": 0.8574763536453247
},
{
"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": 0.8527971506118774
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },\n goliath_shield_node: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),",
"score": 0.8515710830688477
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [],\n (gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseMem(-1),\n CardScriptParts.ChangeCpu(1),\n ],\n }",
"score": 0.8509201407432556
}
] | typescript | engine, source, target) => { |
import { randInt } from '../../utils';
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetReaper = {
cardMods: {
reaper_feederCorrupted: class extends CardMod {
},
reaper_feederPower: class extends CardMod {
override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {
if (deps.sourceCard.sec - damage > 0) return;
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);
CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);
const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);
player && player.stats.kills++;
return { secDmgBonus: -9999 };
}
},
},
cardScripts: {
reaper_bossEat: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, _card) => {
return gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_feeder.name);
},
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, source, target) => {
GameEngineUtils.removeCard(engine, target, source);
if (target.mods.find(x => x[0] === RulesetReaper.cardMods.reaper_feederCorrupted.name)) {
GameEngineUtils.changeSec(engine, source, -50, false);
if (source.sec <= 0) {
GameEngineUtils.removeCard(engine, source);
return;
}
} else {
GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);
GameEngineUtils.changeCpu(engine, source, 1);
for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {
CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));
}
}
const highDiff = engine.gameData.difficulty >= 7;
if (engine.gameData.enemies.length <= (highDiff ? 6 : 4)) {
while (engine.gameData.enemies.findIndex(x => x.id === source.id) < (highDiff ? 4 : 3)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absLeft')(engine, source, target);
}
while (engine.gameData.enemies.length < (highDiff ? 9 : 7)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absRight')(engine, source, target);
}
}
},
],
}
],
);
}
},
},
enemyCards: {
reaper_feeder: (engine: GameEngine.IGameEngine): GameEngine.IEnemyCardState => {
return {
id: engine.nextId(),
enemyClass: 'reaper_feeder',
cpu: 0,
mem: 0,
maxMem: 0,
sec: randInt(
GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),
GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
),
mods: [
| new RulesetReaper.cardMods.reaper_feederPower().serialize(),
],
scripts: [],
}; |
},
reaper_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_lesser_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak', 1).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_boss',
cpu: 0,
mem: 0,
maxMem: 0,
sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content._winOnDeath().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
boss.scripts.push(
new RulesetReaper.cardScripts.reaper_bossEat(boss).serialize(),
);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
},
};
| src/game/rulesets/reaper.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " enemyClass: '',\n cpu: 1,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new RulesetGoliath.cardMods.goliath_shield_supply().serialize(),\n ],\n scripts: [],",
"score": 0.8903149962425232
},
{
"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": 0.8796550035476685
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " maxMem: 1,\n sec: GameEngineUtils.scaleByDifficulty(30, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },",
"score": 0.876496434211731
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new CardScript.Content._defend(enemy, engine.gameData.difficulty).serialize(),",
"score": 0.8564453721046448
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " const boss: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n enemyClass: 'stasis_boss',\n cpu: 3,\n mem: 3,\n maxMem: 3,\n sec: GameEngineUtils.scaleByDifficulty(125, engine.gameData.difficulty),\n mods: [\n new RulesetStasis.cardMods.stasis_boss_ai().serialize(),\n new CardMod.Content._winOnDeath().serialize(),",
"score": 0.8470178842544556
}
] | typescript | new RulesetReaper.cardMods.reaper_feederPower().serialize(),
],
scripts: [],
}; |
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": 0.9254400730133057
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new CardScript.Content._defend(enemy, engine.gameData.difficulty).serialize(),",
"score": 0.9192099571228027
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " scripts: [],\n };\n boss.mods.push(\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content._waveTrigger(['reaper', 'goliath', 'stasis', 'stasis'], 12).serialize(),\n new CardMod.Content._yieldScript(new CardScript.Content._spawn(boss, RulesetMfrm.enemyCards.intro_perimeter.name, undefined, undefined, 2).serialize(), 2).serialize(),\n );\n boss.scripts.push(\n new CardScript.Content._defend(boss, engine.gameData.difficulty).serialize(),\n );",
"score": 0.8936061859130859
},
{
"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": 0.890001118183136
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " mem: 0,\n maxMem: 0,\n sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content._winOnDeath().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };",
"score": 0.8757365345954895
}
] | 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": 0.9002540707588196
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new CardScript.Content._defend(enemy, engine.gameData.difficulty).serialize(),",
"score": 0.8990309238433838
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " mem: 0,\n maxMem: 0,\n sec: 1,\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };\n enemy.scripts.push(",
"score": 0.8848363161087036
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " mem: 0,\n maxMem: 0,\n sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content._winOnDeath().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };",
"score": 0.8838830590248108
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " enemyClass: '',\n cpu: 1,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new RulesetGoliath.cardMods.goliath_shield_supply().serialize(),\n ],\n scripts: [],",
"score": 0.8740717172622681
}
] | typescript | testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize()); |
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 playerState = await engine._createPlayerState(playerId, cardIds);\n engine.gameData.players.set(playerId, playerState);\n engine.broadcast.push({ type: 'playerJoin', playerState });\n }\n engine.gameData.pendingPlayers.clear();\n engine.gameData.state = 'started';\n engine.broadcast.push({ type: 'gameStart' });\n engine.ruleset.initGame(engine);\n });\n return gameData;",
"score": 0.8425724506378174
},
{
"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": 0.8283671736717224
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 0.8061548471450806
},
{
"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": 0.8041670322418213
},
{
"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": 0.7951653003692627
}
] | 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/game/game-engine.ts",
"retrieved_chunk": " const playerState = await engine._createPlayerState(playerId, cardIds);\n engine.gameData.players.set(playerId, playerState);\n engine.broadcast.push({ type: 'playerJoin', playerState });\n }\n engine.gameData.pendingPlayers.clear();\n engine.gameData.state = 'started';\n engine.broadcast.push({ type: 'gameStart' });\n engine.ruleset.initGame(engine);\n });\n return gameData;",
"score": 0.8561525344848633
},
{
"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": 0.8410619497299194
},
{
"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": 0.8236236572265625
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 0.8113699555397034
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8111292123794556
}
] | typescript | ds.Players.update.make(player),
); |
import * as moment from 'moment';
import { createCoopHandler } from './apis/coop.api';
import { IAuthProvider, IDataSource, IPlayerPushProvider, IRateLimitProvider } from './dependencies';
import { CardMod } from './game/card-mods';
import { CardScript } from './game/card-scripts';
import { GameEngine, createGameEngineProvider } from './game/game-engine';
import { GameEngineUtils } from './game/game-engine-utils';
import { IHttpRequest, IHttpRouteHandler, StatusCodes } from './net-utils';
import { FULL_DATETIME_FORMAT } from './utils';
/**
* Main entry point
*/
// TODO: this should be replaced with node:http or expressjs
export const handleRequest = async (req: IHttpRequest) => {
const split = req.path.split('/').filter(Boolean);
const subPath = split.slice(1);
const body = req.body ? JSON.parse(req.body) : null;
const query = req.queryStringParameters || {};
let handler: IHttpRouteHandler | undefined = undefined;
switch (split[0]) {
case 'coop':
handler = coopHandler;
// ... Note: implement remaining route handlers
}
const result = handler ? (await handler(subPath, query, body, req)) : null;
return result || [StatusCodes.badRequest, { reason: 'invalid api' }];
};
/**
* Dependencies
*/
// Note: replace with an actual database
const cardDecksTable = createMockTableDualKey<IDataSource.ICardDeck>('playerId', 'createdAt');
const coopGamesTable = createMockTableSingleKey<IDataSource.ICoopGame>('id');
const playersTable = createMockTableSingleKey<IDataSource.IPlayer>('id');
const playerCoopGamesTable = createMockTableSingleKey<IDataSource.IPlayerCoopGame>('playerId');
const dataSource: IDataSource = {
CardDecks: {
...cardDecksTable,
async queryByDid(did) {
return { items: [...cardDecksTable._db.values()].filter(x => x.playerId === did) };
},
},
CoopGames: {
...coopGamesTable,
async queryByGameState(gameState) {
return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };
},
},
GameData: {
...createMockTableSingleKey<GameEngine.IGameData>('id'),
},
Players: {
...playersTable,
},
PlayerCoopGames: {
...playerCoopGamesTable,
async queryByPlayerId(playerId: string) {
return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };
},
},
Leaderboard: {
getTopN(_n) { return [] as any; },
async set(_playerId, _score) { },
},
async execUpdates(...updateRequests) {
updateRequests.forEach(x => x());
},
};
// Note: replace with an actual auth provider
const authProvider: IAuthProvider = {
generateNewSecret: () => `${Math.random()}`,
getAuthTokenForPlayer: player => player.secret,
getPlayerFromRequest: async () => [...playersTable._db.values()][0]!,
getPlayerIdFromRequest: () => [...playersTable._db.values()][0]?.id!,
};
// Note: replace with an actual push provider
const pushProvider: IPlayerPushProvider = {
async push(playerId, messages) {
console.log(`Push messages for player [${playerId}]:`);
messages.forEach(x => console.log(x));
}
};
const rateLimitProvider: IRateLimitProvider = {
async shouldRateLimitCreateGame(_playerId) {
return false;
},
async shouldRateLimitSearchGame(_playerId) {
return false;
},
};
// Note: replace with custom game content
const gameContent: GameEngine.IRuleset = {
cardMods: { /** Custom card modifiers **/ },
cardScripts: { /** Custom card scripts **/ },
initGame(engine) {
const testEnemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'testEnemy',
cpu: 1,
mem: 1,
maxMem: 1,
mods: [],
scripts: [],
sec: 10,
};
testEnemy.mods.push(new CardMod.Content._standardAi().serialize());
testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());
GameEngineUtils.addEnemy(engine, testEnemy, 0, true);
},
addAdditionalScriptsFor(_card) {
// Note: Called by GameEngine when a player is joined; this hook allows for dynamic scripts for a given card
},
};
const gameEngine = createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
| const coopHandler = createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider); |
/**
* Example
*/
(async () => {
/**
* Players are normally created via /players/connectDid; to keep this example concise,
* we'll inject one with CO8's DID into the mock database.
*/
const mockPlayer = {
id: 'did:chia:1sc5hxvcs26e4zsc7uvlfuc7x9sjj5aw6cu0g8vcyvscy49ffp8zqwh63tq',
activeDeckId: '',
activeGameId: '',
secret: '',
authExpiresAt: '2100-01-01',
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),
score: 0,
}
playersTable._db.set(mockPlayer.id, mockPlayer);
/**
* This calls into /coop/create which is a complex API.
* Step thru this to learn about how the route handlers work.
*/
console.log('Creating game...');
await handleRequest({
httpMethod: 'POST',
path: '/coop/create',
body: JSON.stringify({
gameVisibility: 'private',
difficulty: 1,
}),
});
console.log('Game created, gameId: ' + mockPlayer.activeGameId);
/**
* Games normally start automatically when enough players join via /coop/join or /coop/search,
* to keep this example concise, we'll start it directly via the gameEngine reference.
* Step thru this to learn about how the game engine works.
*/
console.log('Starting game...');
await gameEngine.startGame(mockPlayer.activeGameId);
})();
/**
* In-memory DB helpers
* Note: this is a mock database that only satisfies the example above and is
* not meant to be starting point for production.
*/
function createMockTableSingleKey<T extends Record<string, any>>(idKey: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id: string) {
return _db.get(id) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(item[idKey], item);
return item;
},
},
};
}
function createMockTableDualKey<T extends Record<string, any>>(id1Key: keyof T, id2Key: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id1: string, id2: string) {
return _db.get(`${id1}_${id2}`) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(`${item[id1Key]}_${item[id2Key]}`, item);
return item;
},
},
};
}
| src/reference-example.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },\n goliath_shield_node: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),",
"score": 0.8705735206604004
},
{
"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": 0.8663878440856934
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " maxMem: 1,\n sec: GameEngineUtils.scaleByDifficulty(30, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },",
"score": 0.8647987842559814
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " ],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n );\n return enemy;\n },\n },\n cardScripts: {",
"score": 0.8583208322525024
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " }\n GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);\n }\n override onTurnEnd(deps: ICardModDeps) {\n if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {\n throw new Error('not an enemy card');\n }\n GameEngineUtils.executeIntent(deps.engine, deps.sourceCard);\n }\n }",
"score": 0.847093939781189
}
] | 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/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": 0.8549560308456421
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const playerState = await engine._createPlayerState(playerId, cardIds);\n engine.gameData.players.set(playerId, playerState);\n engine.broadcast.push({ type: 'playerJoin', playerState });\n }\n engine.gameData.pendingPlayers.clear();\n engine.gameData.state = 'started';\n engine.broadcast.push({ type: 'gameStart' });\n engine.ruleset.initGame(engine);\n });\n return gameData;",
"score": 0.8376085758209229
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const playerToKick = [...engine.gameData.players.values()].find(x => x.id !== kickRequestingPlayerId) || '';\n if (!playerToKick) throw new Error('kickIfIdle: player not found');\n if (playerToKick.idleKickTime < moment.now()) {\n if (!engine.gameData.players.delete(playerToKick.id)) throw new Error('player not found');\n engine.broadcast.push({ type: 'playerLeave', playerId: playerToKick.id, reason: 'idle' });\n GameEngineUtils.revalidateIntents(engine, true);\n for (const remainingPlayer of engine.gameData.players.values()) {\n remainingPlayer.endedTurn = false;\n engine.broadcast.push({\n type: 'playerToggleEndTurn',",
"score": 0.8192884922027588
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " engine.broadcast.push({\n type: 'playerToggleEndTurn',\n playerId,\n state: true,\n });\n if (![...engine.gameData.players.values()].reduce((numNotReady, playerState) => playerState.endedTurn ? numNotReady : (numNotReady + 1), 0)) {\n const now = moment.now();\n [...engine.gameData.players.values()].forEach(x => x.idleKickTime = now + 2 * SECS_IN_MIN * 1000);\n engine.onEndTurn();\n if (engine.gameData.state !== 'started') {",
"score": 0.8154515027999878
},
{
"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": 0.806354284286499
}
] | typescript | const gameData = await gameEngineProvider.getGameData(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/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.85148024559021
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const existingGameData = await ds.GameData.get(gameId);\n if (existingGameData) throw new Error('game with id already exists: ' + gameId);\n const gameData: GameEngine.IGameData = {\n id: gameId,\n difficulty: Math.max(1, difficulty),\n state: 'created',\n turn: 1,\n players: new Map(),\n defaultMovesPerTurn: 3,\n enemies: [],",
"score": 0.8504330515861511
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (engine.broadcast.length) {\n await Promise.all(\n [...gameData.players.keys()].map(playerId => playerPushProvider.push(playerId, engine.broadcast)),\n );\n }\n return gameData;\n }\n static async createGame(gameId: string, rulesetId: string, difficulty: number) {\n const ruleset = rulesets[rulesetId];\n if (!ruleset) throw new Error('invalid ruleSet id: ' + rulesetId);",
"score": 0.8342304825782776
},
{
"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": 0.8318310379981995
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\n static async endGame(gameId: string) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n engine.gameData.state = 'abandoned';\n engine.broadcast.push({ type: 'gameEnd' });\n });\n }\n static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n if (engine.gameData.players.has(playerId)) throw new Error('player already in game');",
"score": 0.8183141350746155
}
] | 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/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": 0.8491069078445435
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const playerState = await engine._createPlayerState(playerId, cardIds);\n engine.gameData.players.set(playerId, playerState);\n engine.broadcast.push({ type: 'playerJoin', playerState });\n }\n engine.gameData.pendingPlayers.clear();\n engine.gameData.state = 'started';\n engine.broadcast.push({ type: 'gameStart' });\n engine.ruleset.initGame(engine);\n });\n return gameData;",
"score": 0.8306900262832642
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const playerToKick = [...engine.gameData.players.values()].find(x => x.id !== kickRequestingPlayerId) || '';\n if (!playerToKick) throw new Error('kickIfIdle: player not found');\n if (playerToKick.idleKickTime < moment.now()) {\n if (!engine.gameData.players.delete(playerToKick.id)) throw new Error('player not found');\n engine.broadcast.push({ type: 'playerLeave', playerId: playerToKick.id, reason: 'idle' });\n GameEngineUtils.revalidateIntents(engine, true);\n for (const remainingPlayer of engine.gameData.players.values()) {\n remainingPlayer.endedTurn = false;\n engine.broadcast.push({\n type: 'playerToggleEndTurn',",
"score": 0.8068002462387085
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\n this.gameData.rulesetIds.push(nextRulesetId);\n this._setRuleset(nextRuleset);\n nextRuleset.initGame(this);\n }\n onWinGame() {\n this.gameData.state = 'players_won';\n this.broadcast.push({\n type: 'players_won',\n stats: [...this.gameData.players.values()].map(player => {",
"score": 0.7973508238792419
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 0.7941301465034485
}
] | 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": 0.8702876567840576
},
{
"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": 0.8631781339645386
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const gameData = await ds.GameData.get(gameId);\n if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n return gameData;\n }\n private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {\n const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))\n .filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)\n .map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));\n if (cards.length !== cardIds.length) {\n throw `could not resolve all cards for player ${playerId}`;",
"score": 0.8614346981048584
},
{
"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": 0.8589476943016052
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " if (deck) {\n return deck;\n }\n const cards = (await ExtDeps.getNftsByDidOrWallet(player.id, 6))?.nfts.filter(Boolean) || [];\n if (cards.length < 6) {\n return null;\n }\n const nowStr = moment.utc().format(FULL_DATETIME_FORMAT);\n player.activeDeckId = nowStr;\n deck = {",
"score": 0.8460180759429932
}
] | 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": " 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": 0.8742520809173584
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " playerId: remainingPlayer.id,\n state: false,\n });\n }\n kickedPlayerId = playerToKick.id;\n }\n });\n return kickedPlayerId || null;\n }\n static async getGameData(gameId: string) {",
"score": 0.8512850999832153
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " // Stop if the game was won/lost due to an EndTurn effect\n return;\n }\n engine.onTurnStart();\n }\n });\n }\n static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {\n let kickedPlayerId = '';\n await _Engine._withEngine(gameId, ['started'], async engine => {",
"score": 0.8451794981956482
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (engine.broadcast.length) {\n await Promise.all(\n [...gameData.players.keys()].map(playerId => playerPushProvider.push(playerId, engine.broadcast)),\n );\n }\n return gameData;\n }\n static async createGame(gameId: string, rulesetId: string, difficulty: number) {\n const ruleset = rulesets[rulesetId];\n if (!ruleset) throw new Error('invalid ruleSet id: ' + rulesetId);",
"score": 0.8449313640594482
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8379775881767273
}
] | 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/game/game-engine.ts",
"retrieved_chunk": " const existingGameData = await ds.GameData.get(gameId);\n if (existingGameData) throw new Error('game with id already exists: ' + gameId);\n const gameData: GameEngine.IGameData = {\n id: gameId,\n difficulty: Math.max(1, difficulty),\n state: 'created',\n turn: 1,\n players: new Map(),\n defaultMovesPerTurn: 3,\n enemies: [],",
"score": 0.8320800065994263
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " // Stop if the game was won/lost due to an EndTurn effect\n return;\n }\n engine.onTurnStart();\n }\n });\n }\n static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {\n let kickedPlayerId = '';\n await _Engine._withEngine(gameId, ['started'], async engine => {",
"score": 0.8251657485961914
},
{
"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": 0.8165898323059082
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8150453567504883
},
{
"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": 0.8144996166229248
}
] | typescript | if (await rateLimit.shouldRateLimitSearchGame(player.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/goliath.ts",
"retrieved_chunk": " scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },\n goliath_shield_node: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),",
"score": 0.8833326697349548
},
{
"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": 0.883272647857666
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " maxMem: 1,\n sec: GameEngineUtils.scaleByDifficulty(30, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),\n );\n return enemy;\n },",
"score": 0.8821402788162231
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " ],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n );\n return enemy;\n },\n },\n cardScripts: {",
"score": 0.8771415948867798
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " new CardMod.Content._standardAi().serialize(),\n ],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new RulesetStasis.cardScripts.stasis_disrupt(enemy, engine.gameData.difficulty).serialize(),\n );\n return enemy;\n },",
"score": 0.8613481521606445
}
] | typescript | createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider); |
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": 0.8537909984588623
},
{
"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": 0.8435591459274292
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.819598376750946
},
{
"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": 0.8150259256362915
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (!playerState.movesLeft) {\n throw new Error(`No moves left`);\n }\n const sourceCard = playerState.cards.find(x => x.id === sourceCardId)!;\n if (sourceCard.isUsed) {\n throw new Error(`Card is used`);\n }\n const now = moment.now();\n playerState.idleKickTime = now + 2 * SECS_IN_MIN * 1000;\n playerState.movesLeft--;",
"score": 0.8107609152793884
}
] | 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": 0.9071595072746277
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " new CardMod.Content._standardAi().serialize(),\n ],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new RulesetStasis.cardScripts.stasis_disrupt(enemy, engine.gameData.difficulty).serialize(),\n );\n return enemy;\n },",
"score": 0.8978534936904907
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " cpu: 2,\n mem: 2,\n maxMem: 2,\n sec: GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),\n mods: [new CardMod.Content._standardAi().serialize()],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n new CardScript.Content._defend(enemy, engine.gameData.difficulty).serialize(),",
"score": 0.8916640281677246
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " mem: 0,\n maxMem: 0,\n sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),\n mods: [\n new CardMod.Content._standardAi().serialize(),\n new CardMod.Content._winOnDeath().serialize(),\n new CardMod.Content.impervious().serialize(),\n ],\n scripts: [],\n };",
"score": 0.8697195053100586
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " ],\n scripts: [],\n };\n enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n );\n return enemy;\n },\n },\n cardScripts: {",
"score": 0.8525629043579102
}
] | typescript | (_card) { |
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 playerState = await engine._createPlayerState(playerId, cardIds);\n engine.gameData.players.set(playerId, playerState);\n engine.broadcast.push({ type: 'playerJoin', playerState });\n }\n engine.gameData.pendingPlayers.clear();\n engine.gameData.state = 'started';\n engine.broadcast.push({ type: 'gameStart' });\n engine.ruleset.initGame(engine);\n });\n return gameData;",
"score": 0.8338562250137329
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 0.8270686268806458
},
{
"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": 0.8183189630508423
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " return [StatusCodes.ok, {\n player: toClientPlayer(player, authProvider),\n status: isNew ? 'new' : 'existing',\n }];\n }\n case 'me': {\n const player = await authProvider.getPlayerFromRequest(req);\n return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];\n }\n }",
"score": 0.8132765889167786
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8108997941017151
}
] | 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/apis/players.api.ts",
"retrieved_chunk": " return [StatusCodes.ok, {\n player: toClientPlayer(player, authProvider),\n status: isNew ? 'new' : 'existing',\n }];\n }\n case 'me': {\n const player = await authProvider.getPlayerFromRequest(req);\n return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];\n }\n }",
"score": 0.8776320815086365
},
{
"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": 0.8518897294998169
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8472830057144165
},
{
"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": 0.8393986225128174
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 0.8234657049179077
}
] | typescript | const playerId = authProvider.getPlayerIdFromRequest(req); |
import { randomInt } from 'crypto';
import { appraiseCard } from '../appraise';
const excludedChars = ['1', 'b', 'i', 'o'];
const testSize = 1000000;
function generateId() {
let id = 'nft1'.padEnd(54, '_');
while (id.length < 62) {
const i = randomInt(0, 36);
let c: string;
if (i >= 10) {
c = String.fromCharCode(97 + i - 10);
} else {
c = String.fromCharCode(48 + i);
}
if (!excludedChars.includes(c)) {
id += c;
}
}
id = id.substring(0, 55) + (Math.random() < 0.5 ? 's' : 'q') + id.substring(56);
return id;
}
test('appraiseCard', () => {
const results = {
factions: {
backdoor: 0,
bruteforce: 0,
malware: 0,
},
scripts: {
bd_exploit: 0,
bd_decode: 0,
bd_secure: 0,
bf_firewall: 0,
bf_overclock: 0,
bf_spam: 0,
mw_redirect: 0,
mw_freeware: 0,
mw_worm: 0,
},
tiers: [0, 0, 0, 0, 0, 0, 0],
cpu: 0,
mem: 0,
};
for (let i = 0; i < testSize; i++) {
| const card = appraiseCard({ nftId: generateId(), mintHeight: 1, url: '' }); |
results.factions[card.faction]++;
results.tiers[card.tier]++;
results.cpu += card.cpu;
results.mem += card.mem;
results.scripts[card.coreScript]++;
if (card.cpu + card.mem !== card.tier + 2) {
// This assertion is not done using expect() as it would slow down the test too much
throw new Error('CPU + MEM is expected to be Tier + 2');
}
}
expect(results.factions.bruteforce / results.factions.malware).toBeCloseTo(1, 1);
expect(results.factions.bruteforce / results.factions.backdoor).toBeCloseTo(1.1, 1);
expect(results.cpu / results.mem).toBeCloseTo(1);
expect(results.scripts.bd_decode / results.scripts.bd_exploit).toBeCloseTo(1, 1);
expect(results.scripts.bd_decode / results.scripts.bd_secure).toBeCloseTo(1, 1);
expect(results.scripts.bf_firewall / results.scripts.bf_overclock).toBeCloseTo(1, 1);
expect(results.scripts.bf_firewall / results.scripts.bf_spam).toBeCloseTo(1, 1);
expect(results.scripts.mw_redirect / results.scripts.mw_freeware).toBeCloseTo(1, 1);
expect(results.scripts.mw_redirect / results.scripts.mw_worm).toBeCloseTo(1, 1);
expect(results.tiers[1]! / testSize).toBeCloseTo(.46156);
expect(results.tiers[2]! / testSize).toBeCloseTo(.31667);
expect(results.tiers[3]! / testSize).toBeCloseTo(.16521);
expect(results.tiers[4]! / testSize).toBeCloseTo(.04849);
expect(results.tiers[5]! / testSize).toBeCloseTo(.00759, 3);
// Cannot reliably test T6 as the numbers are so small but if T1-T5 pass then by process of elimination we can assert T6 is correct
}); | src/tests/appraise.test.ts | chiatcg-chiatcg-server-0c3f71d | [
{
"filename": "src/appraise.ts",
"retrieved_chunk": " const SQ = Q.slice(2);\n const tier = SQ.reduce((sum, c) => isNaN(+c) ? sum : (sum + 1), 0);\n if (tier < 2 || mintHeight >= MINT_HEIGHT_THRESHOLD) {\n // Less than 2 digits or minted after threshold is a T1; either 1/2 or 2/1\n const singleQualifier = Q[1]; // Only either 's' or 'q'\n const cpu = singleQualifier === 's' ? 2 : 1;\n const mem = 3 - cpu;\n return {\n nftId,\n faction,",
"score": 0.8512451648712158
},
{
"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": 0.8413228988647461
},
{
"filename": "src/appraise.ts",
"retrieved_chunk": " tier: 1,\n cpu,\n mem,\n coreScript,\n url,\n };\n }\n // For each character c in SQ, grant CPU or MEM if c is numeric, nothing otherwise\n // Since there are only 9 possible digits per character, we use 2-5 for MEM, 6-9 for CPU, 0 is treated special\n let cpu = 1;",
"score": 0.8393861651420593
},
{
"filename": "src/appraise.ts",
"retrieved_chunk": "}\n/**\n * Generates card stats based on the number of digits in the last 9 chars of the nftId,\n */\nexport const appraiseCard = ({ nftId, mintHeight, url }: { nftId: string, mintHeight: number, url: string }): IAppraisedCard => {\n // Last 9 chars of the nftId determine the card qualifier, Q\n const Q = nftId.substring(nftId.length - 8).split('');\n // Q[0] determines faction\n // Since 34 potential characters does not divide cleanly by 3 factions,\n // distribution will not come out even - Backdoor will appear 10% less than other factions",
"score": 0.8342188596725464
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\n const player: GameEngine.IPlayerState = {\n id: playerId,\n cards: cards.map(card => ({\n id: this.nextId(),\n card,\n isUsed: false,\n cpu: card.cpu,\n mem: card.mem,\n sec: card.mem * 6 + card.cpu * 3,",
"score": 0.8248431086540222
}
] | 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": 0.8736275434494019
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " // Stop if the game was won/lost due to an EndTurn effect\n return;\n }\n engine.onTurnStart();\n }\n });\n }\n static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {\n let kickedPlayerId = '';\n await _Engine._withEngine(gameId, ['started'], async engine => {",
"score": 0.8670729398727417
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.861335277557373
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " playerId: remainingPlayer.id,\n state: false,\n });\n }\n kickedPlayerId = playerToKick.id;\n }\n });\n return kickedPlayerId || null;\n }\n static async getGameData(gameId: string) {",
"score": 0.8610677719116211
},
{
"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": 0.852623701095581
}
] | 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/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": 0.858473539352417
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8520975112915039
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (engine.broadcast.length) {\n await Promise.all(\n [...gameData.players.keys()].map(playerId => playerPushProvider.push(playerId, engine.broadcast)),\n );\n }\n return gameData;\n }\n static async createGame(gameId: string, rulesetId: string, difficulty: number) {\n const ruleset = rulesets[rulesetId];\n if (!ruleset) throw new Error('invalid ruleSet id: ' + rulesetId);",
"score": 0.8427771329879761
},
{
"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": 0.8392036557197571
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const existingGameData = await ds.GameData.get(gameId);\n if (existingGameData) throw new Error('game with id already exists: ' + gameId);\n const gameData: GameEngine.IGameData = {\n id: gameId,\n difficulty: Math.max(1, difficulty),\n state: 'created',\n turn: 1,\n players: new Map(),\n defaultMovesPerTurn: 3,\n enemies: [],",
"score": 0.8350797891616821
}
] | 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": " }\n static async endGame(gameId: string) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n engine.gameData.state = 'abandoned';\n engine.broadcast.push({ type: 'gameEnd' });\n });\n }\n static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n if (engine.gameData.players.has(playerId)) throw new Error('player already in game');",
"score": 0.8496224880218506
},
{
"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": 0.8455216288566589
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8421916961669922
},
{
"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": 0.8413519859313965
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (engine.broadcast.length) {\n await Promise.all(\n [...gameData.players.keys()].map(playerId => playerPushProvider.push(playerId, engine.broadcast)),\n );\n }\n return gameData;\n }\n static async createGame(gameId: string, rulesetId: string, difficulty: number) {\n const ruleset = rulesets[rulesetId];\n if (!ruleset) throw new Error('invalid ruleSet id: ' + rulesetId);",
"score": 0.8367571830749512
}
] | 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": 0.8784459829330444
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const gameData = await ds.GameData.get(gameId);\n if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n return gameData;\n }\n private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {\n const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))\n .filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)\n .map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));\n if (cards.length !== cardIds.length) {\n throw `could not resolve all cards for player ${playerId}`;",
"score": 0.8669941425323486
},
{
"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": 0.8649930953979492
},
{
"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": 0.846347451210022
},
{
"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": 0.8455058932304382
}
] | typescript | (x => ExtDeps.getNft(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": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.829259991645813
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const gameData = await ds.GameData.get(gameId);\n if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n return gameData;\n }\n private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {\n const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))\n .filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)\n .map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));\n if (cards.length !== cardIds.length) {\n throw `could not resolve all cards for player ${playerId}`;",
"score": 0.826852560043335
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const existingGameData = await ds.GameData.get(gameId);\n if (existingGameData) throw new Error('game with id already exists: ' + gameId);\n const gameData: GameEngine.IGameData = {\n id: gameId,\n difficulty: Math.max(1, difficulty),\n state: 'created',\n turn: 1,\n players: new Map(),\n defaultMovesPerTurn: 3,\n enemies: [],",
"score": 0.8252772092819214
},
{
"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": 0.8234950304031372
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];\n }\n case 'list': {\n const schema = z.object({\n ct: z.string().optional(),\n });\n const q = schema.parse(query);\n const player = await authProvider.getPlayerFromRequest(req);\n const decks = await Promise.all((await ds.CardDecks.queryByDid(player.id, 10, q.ct)).items);\n if (!decks.length) {",
"score": 0.8222664594650269
}
] | typescript | gameData = await ds.GameData.get(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": " return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];\n }\n case 'list': {\n const schema = z.object({\n ct: z.string().optional(),\n });\n const q = schema.parse(query);\n const player = await authProvider.getPlayerFromRequest(req);\n const decks = await Promise.all((await ds.CardDecks.queryByDid(player.id, 10, q.ct)).items);\n if (!decks.length) {",
"score": 0.8547208309173584
},
{
"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": 0.8476763367652893
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8250192403793335
},
{
"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": 0.8144568204879761
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (!playerState.movesLeft) {\n throw new Error(`No moves left`);\n }\n const sourceCard = playerState.cards.find(x => x.id === sourceCardId)!;\n if (sourceCard.isUsed) {\n throw new Error(`Card is used`);\n }\n const now = moment.now();\n playerState.idleKickTime = now + 2 * SECS_IN_MIN * 1000;\n playerState.movesLeft--;",
"score": 0.8135433197021484
}
] | 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/game/game-engine.ts",
"retrieved_chunk": " maxEnemies: 9,\n nextId: 1,\n pendingPlayers: new Map(),\n rulesetIds: [rulesetId],\n };\n await ds.GameData.update.exec(gameData);\n }\n static async startGame(gameId: string) {\n const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {\n for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {",
"score": 0.8128939270973206
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const playerState = await engine._createPlayerState(playerId, cardIds);\n engine.gameData.players.set(playerId, playerState);\n engine.broadcast.push({ type: 'playerJoin', playerState });\n }\n engine.gameData.pendingPlayers.clear();\n engine.gameData.state = 'started';\n engine.broadcast.push({ type: 'gameStart' });\n engine.ruleset.initGame(engine);\n });\n return gameData;",
"score": 0.8003896474838257
},
{
"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": 0.7923245429992676
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\n static async endGame(gameId: string) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n engine.gameData.state = 'abandoned';\n engine.broadcast.push({ type: 'gameEnd' });\n });\n }\n static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n if (engine.gameData.players.has(playerId)) throw new Error('player already in game');",
"score": 0.7905248403549194
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " activeDeckId: 'default',\n score: 0,\n });\n metrics?.newUser(player.id);\n } else {\n ds.Leaderboard.set(player.id, player.score);\n player.secret = newSecret;\n player.authExpiresAt = newAuthExpireAt;\n await ds.Players.update.exec(player);\n }",
"score": 0.7858115434646606
}
] | 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/game/game-engine.ts",
"retrieved_chunk": " }\n static async endGame(gameId: string) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n engine.gameData.state = 'abandoned';\n engine.broadcast.push({ type: 'gameEnd' });\n });\n }\n static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {\n return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {\n if (engine.gameData.players.has(playerId)) throw new Error('player already in game');",
"score": 0.8518879413604736
},
{
"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": 0.8378307819366455
},
{
"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": 0.8312965631484985
},
{
"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": 0.8293282985687256
},
{
"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": 0.8275867104530334
}
] | typescript | deck = await getOrCreateActiveDeck(player, ds); |
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": 0.8532705903053284
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const gameData = await ds.GameData.get(gameId);\n if (!gameData) throw new GameEngine.GameNotFoundError(gameId);\n return gameData;\n }\n private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {\n const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))\n .filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)\n .map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));\n if (cards.length !== cardIds.length) {\n throw `could not resolve all cards for player ${playerId}`;",
"score": 0.8305400609970093
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " const player = await _expectAuthPlayerNotInGame(req);\n const deck = await _expectValidActiveDeck(player, true);\n if (await rateLimit.shouldRateLimitCreateGame(player.id)) {\n return [StatusCodes.tooManyRequests];\n }\n const now = moment.utc();\n const game: IDataSource.ICoopGame = {\n id: randomBytes(16).toString('hex'),\n createdAt: now.format(FULL_DATETIME_FORMAT),\n difficulty: payload.difficulty,",
"score": 0.8240717053413391
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " }\n async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {\n const deck = await getOrCreateActiveDeck(player, ds);\n if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');\n if (validateNftOwnership) {\n const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));\n if (nfts.find(x => !x || x.nft.did !== player.id)) {\n metrics?.nftOwnershipConflict(player.id);\n throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');\n }",
"score": 0.8216643929481506
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " } while (ct);\n // No joinable game found - proceed to create a public game\n const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);\n return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);\n }\n case 'start': {\n const { game } = await _expectAuthPlayerInGame(req);\n const gameData = await ds.GameData.get(game.id);\n if (gameData?.state !== 'created') {\n return [StatusCodes.forbidden];",
"score": 0.8138347268104553
}
] | typescript | metrics?.deckUpdated(player.id, deck.createdAt); |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.