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 express from "express";
import { verify } from "jsonwebtoken";
import { requireAuth } from "../../middleware/auth";
import Tweet from "../../models/Tweet";
import User from "../../models/User";
import {
ICreateTweetBody,
IGenericFeatures,
IJwtDecoded,
} from "../../types/graphql";
import { IUser } from "../../types/guide";
import { formatDate } from "../../util/formatDate";
import { log } from "../../util/logging";
import { randInt } from "../../util/randUtil";
import { IUserMention } from "./user";
import { addNotification } from "../../util/notifications";
interface IUserTweetsVariables {
userId: string;
count: number;
includePromotedContent: boolean;
withQuickPromoteEligibilityTweetFields: boolean;
withVoice: boolean;
withV2Timeline: boolean;
}
interface IFavouriteTweetVariables {
tweet_id: string;
}
export async function UserTweets(req: express.Request, res: express.Response) {
const loggedInUser = req.cookies["jwt"]
? await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id,
})
: undefined;
const features = JSON.parse(
req.query.features!.toString()
) as IGenericFeatures;
const variables = JSON.parse(
req.query.variables!.toString()
) as IUserTweetsVariables;
if (!features || !variables)
return res.status(400).send({ msg: "Missing parameters" });
const user = await User.findOne({ id: variables.userId });
if (!user) return res.status(400).send({ msg: "User not found" });
const userTweets = [];
const postedTweets = Array.from(user.posted_tweet_ids);
for (const id of postedTweets) {
const tweet = await Tweet.findOne({ id_str: id });
userTweets.push({
is_translatable: false,
legacy: tweet
? Object.assign(tweet, {
favorited: loggedInUser
? loggedInUser.liked_tweet_ids.includes(tweet.id_str || "")
: false,
})
: tweet,
source: tweet?.source,
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
});
}
return res.status(200).send({
data: {
user: {
result: {
__typename: "User",
timeline_v2: {
timeline: {
instructions: [
{
type: "TimelineClearCache",
},
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified:
user.ext_is_blue_verified,
legacy: {
...(user as any)._doc,
},
profile_image_shape:
user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
},
},
});
}
export async function HomeTimeline(
req: express.Request,
res: express.Response
) {
const unauthorized
|
= await requireAuth(req, res);
|
if (unauthorized) return;
const userId = req.cookies["jwt"]
? ((verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded)
.id as number)
: undefined;
const loggedInUser = await User.findOne({
id_string: userId,
});
if (!loggedInUser) return res.status(400).send({ msg: "Not authenticated" });
const userTweets = [];
const postedTweets = await Tweet.find().limit(50);
for (const tweet of postedTweets) {
const user = await User.findOne({ id_string: tweet.user_id_str });
if (!user) return res.status(400).send({ msg: "User not found" });
userTweets.push({
is_translatable: false,
legacy: Object.assign(tweet, {
favorited: loggedInUser.liked_tweet_ids.includes(tweet.id_str || ""),
}),
unmention_data: {},
unmention_info: {},
views: tweet.ext_views,
user: user,
});
}
return res.status(200).send({
data: {
home: {
home_timeline_urt: {
instructions: [
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
tweet.user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: tweet.user._id,
is_blue_verified:
tweet.user.ext_is_blue_verified,
legacy: {
...(tweet.user as any)._doc,
entities: {
user_mentions: (
tweet.legacy.entities
?.user_mentions as IUserMention[]
).map((mention) => {
return {
a: true,
};
}),
},
},
profile_image_shape:
tweet.user.ext_profile_image_shape,
rest_id: tweet.user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.legacy.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
});
}
export async function FavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (!user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids.push(variables.tweet_id);
tweet.favorite_count! += 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { favourte_tweet: "NOT DONE" } });
}
if (tweet.user_id_str !== user.id_string)
addNotification(
"%1 liked your tweet!",
"like",
tweet.user_id_str!,
user.id_string!,
tweet.id_str!
);
return res.status(200).send({ data: { favorite_tweet: "Done" } });
}
export async function UnfavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids = user.liked_tweet_ids.filter(
(id) => id !== variables.tweet_id
);
tweet.favorite_count! -= 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { unfavorite_tweet: "NOT DONE" } });
}
return res.status(200).send({ data: { unfavorite_tweet: "Done" } });
}
export async function CreateTweet(req: express.Request, res: express.Response) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const body = req.body as ICreateTweetBody;
const id = (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id as number;
const user = await User.findOne({ id });
if (!user) return res.status(400).send({ msg: "User not found" });
const user_mentions = [] as IUserMention[];
const matches = body.variables.tweet_text.matchAll(/@(\S+)/gm);
for (const match of matches) {
const withTag = match[0];
const withoutTag = match[1];
const user = await User.findOne({ screen_name: withoutTag });
user_mentions.push({
id_str: user?.id_string,
name: user?.name,
screen_name: user?.screen_name,
indices: [match.index, withTag.length + (match.index || 0)],
});
}
const tweetId = randInt(12);
const tweetData = {
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions,
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id: tweetId,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
source:
'<a href="https://mobile.twitter.com" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
};
const tweet = new Tweet({
bookmark_count: tweetData.legacy.bookmark_count,
bookmarked: tweetData.legacy.bookmarked,
conversation_id_str: tweetData.legacy.conversation_id_str,
created_at: tweetData.legacy.created_at,
display_text_range: tweetData.legacy.display_text_range,
entities: {
hashtags: tweetData.legacy.entities.hashtags,
symbols: tweetData.legacy.entities.symbols,
urls: tweetData.legacy.entities.urls,
user_mentions,
},
favorite_count: tweetData.legacy.favorite_count,
favorited: tweetData.legacy.favorited,
full_text: tweetData.legacy.full_text,
id_str: tweetData.legacy.id_str,
is_quote_status: tweetData.legacy.is_quote_status,
lang: tweetData.legacy.lang,
quote_count: tweetData.legacy.quote_count,
reply_count: tweetData.legacy.reply_count,
retweet_count: tweetData.legacy.retweet_count,
retweeted: tweetData.legacy.retweeted,
user_id_str: tweetData.legacy.user_id_str,
});
await tweet.save();
user.posted_tweet_ids.push(tweetId.toString());
await user.save();
log(`${user.name} (@${user.screen_name}) just posted a tweet:`);
log(`"${tweet.full_text}"`);
// addNotification(
// "%1 just posted a tweet!",
// "reply",
// user.id_string!,
// user.id_string!,
// tweet.id_str!
// );
return res.status(200).send({
// data: {
// create_tweet: {
// tweet_results: {
// result: {
// core: {
// user_results: {
// result: {
// __typename: "User",
// affiliates_highlighted_label:
// user.ext?.highlightedLabel?.r?.ok,
// business_account: {},
// id: user._id,
// is_blue_verified: user.ext_is_blue_verified,
// legacy: {
// created_at: user.created_at,
// default_profile: user.default_profile,
// default_profile_image: user.default_profile_image,
// description: user.description,
// entities: user.entities,
// fast_followers_count: user.fast_followers_count,
// favourites_count: user.favourites_count,
// followers_count: user.followers_count,
// friends_count: user.friends_count,
// has_custom_timelines: user.has_custom_timelines,
// is_translator: user.is_translator,
// listed_count: user.listed_count,
// location: user.location,
// media_count: user.media_count,
// name: user.name,
// normal_followers_count: user.normal_followers_count,
// pinned_tweet_ids_str: user.pinned_tweet_ids_str,
// possibly_sensitive: false,
// profile_image_url_https: user.profile_image_url_https,
// profile_interstitial_type: "",
// screen_name: user.screen_name,
// statuses_count: user.statuses_count,
// translator_type: user.translator_type,
// verified: user.verified,
// withheld_in_countries: user.withheld_in_countries,
// },
// profile_image_shape: user.ext_profile_image_shape,
// rest_id: user.id,
// },
// },
// },
// ...tweetData,
// },
// },
// },
// },
data: {
create_tweet: {
tweet_results: {
result: {
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified: user.ext_is_blue_verified,
legacy: {
created_at: user.created_at,
default_profile: user.default_profile,
default_profile_image: user.default_profile_image,
description: user.description,
entities: user.entities,
fast_followers_count: user.fast_followers_count,
favourites_count: user.favourites_count,
followers_count: user.followers_count,
friends_count: user.friends_count,
has_custom_timelines: user.has_custom_timelines,
is_translator: user.is_translator,
listed_count: user.listed_count,
location: user.location,
media_count: user.media_count,
name: user.name,
normal_followers_count: user.normal_followers_count,
pinned_tweet_ids_str: user.pinned_tweet_ids_str,
possibly_sensitive: false,
profile_image_url_https: user.profile_image_url_https,
profile_interstitial_type: "",
screen_name: user.screen_name,
statuses_count: user.statuses_count,
translator_type: user.translator_type,
verified: user.verified,
withheld_in_countries: user.withheld_in_countries,
},
profile_image_shape: user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_control: {
edit_tweet_ids: [tweetId.toString()],
editable_until_msecs: "1682984834000",
edits_remaining: "5",
is_edit_eligible: true,
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, 68],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions: (
tweet.entities!.user_mentions as Array<Array<IUserMention>>
).map((mention) => mention[0]),
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
rest_id: tweetId.toString(),
source:
'<a href="https://github.com/" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Disabled",
},
},
},
},
},
});
}
|
src/routes/gql/tweet.ts
|
not-nullptr-blue-3b2284a
|
[
{
"filename": "src/routes/gql/viewer.ts",
"retrieved_chunk": "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.8396004438400269
},
{
"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.8268753290176392
},
{
"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.8190212249755859
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "import express from \"express\";\nimport { verify } from \"jsonwebtoken\";\nimport { requireAuth } from \"../../middleware/auth\";\nimport Tweet from \"../../models/Tweet\";\nimport User from \"../../models/User\";\nimport {\n\tIGenericFeatures,\n\tIUserByScreenNameVariables,\n\tIUserByRestIdVariables,\n\tIJwtDecoded,",
"score": 0.8174638152122498
},
{
"filename": "src/routes/1.1/account/account.ts",
"retrieved_chunk": "import express from \"express\";\nconst router = express.Router();\nrouter.use(\"/account/logout.json\", async (req, res) => {\n\tres.cookie(\"twt_id\", `u=0`, {\n\t\tmaxAge: 0,\n\t\tpath: \"/\",\n\t\tdomain: \".twitter.com\",\n\t\tsecure: true,\n\t\thttpOnly: true,\n\t\tsameSite: \"none\",",
"score": 0.8121278882026672
}
] |
typescript
|
= await requireAuth(req, res);
|
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/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.8439379930496216
},
{
"filename": "src/main.ts",
"retrieved_chunk": " notes,\n messaging,\n filesystem,\n web,\n ]);\n const actionHandler = new ActionHandler(\n agentIds,\n messageBus,\n moduleManager\n );",
"score": 0.8414491415023804
},
{
"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.8367637395858765
},
{
"filename": "src/action-handler.ts",
"retrieved_chunk": "import { ModuleManager } from \"./module/module-manager\";\nimport { MessageBus } from \"./message-bus\";\nimport { Action } from \"./parse-action\";\nexport default class ActionHandler {\n constructor(\n private agentIds: string[],\n private messageBus: MessageBus,\n private moduleManager: ModuleManager\n ) {}\n async handle(agentId: string, { actionDef, parameters }: Action) {",
"score": 0.8342061042785645
},
{
"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.8248656392097473
}
] |
typescript
|
await this.actionHandler.handle(this.id, result.action);
|
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.8896420001983643
},
{
"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.8894637227058411
},
{
"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.8671329021453857
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t});\n\tif (!user) return res.status(400).send({ msg: \"User not found\" });\n\t// if (user.id !== jwtParams.id)\n\t// \treturn res.status(401).send({ msg: \"Unauthorized\" });\n\treturn res.status(200).send({\n\t\tdata: {\n\t\t\tuser_result_by_screen_name: {\n\t\t\t\tresult: {\n\t\t\t\t\t__typename: \"User\",\n\t\t\t\t\tid: user._id,",
"score": 0.8598946332931519
},
{
"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.855675220489502
}
] |
typescript
|
(id) => id !== variables.tweet_id
);
|
import express from "express";
import { verify } from "jsonwebtoken";
import { requireAuth } from "../../middleware/auth";
import Tweet from "../../models/Tweet";
import User from "../../models/User";
import {
ICreateTweetBody,
IGenericFeatures,
IJwtDecoded,
} from "../../types/graphql";
import { IUser } from "../../types/guide";
import { formatDate } from "../../util/formatDate";
import { log } from "../../util/logging";
import { randInt } from "../../util/randUtil";
import { IUserMention } from "./user";
import { addNotification } from "../../util/notifications";
interface IUserTweetsVariables {
userId: string;
count: number;
includePromotedContent: boolean;
withQuickPromoteEligibilityTweetFields: boolean;
withVoice: boolean;
withV2Timeline: boolean;
}
interface IFavouriteTweetVariables {
tweet_id: string;
}
export async function UserTweets(req: express.Request, res: express.Response) {
const loggedInUser = req.cookies["jwt"]
? await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id,
})
: undefined;
const features = JSON.parse(
req.query.features!.toString()
) as IGenericFeatures;
const variables = JSON.parse(
req.query.variables!.toString()
) as IUserTweetsVariables;
if (!features || !variables)
return res.status(400).send({ msg: "Missing parameters" });
const user = await User.findOne({ id: variables.userId });
if (!user) return res.status(400).send({ msg: "User not found" });
const userTweets = [];
const postedTweets = Array.from(user.posted_tweet_ids);
for (const id of postedTweets) {
const tweet = await Tweet.findOne({ id_str: id });
userTweets.push({
is_translatable: false,
legacy: tweet
? Object.assign(tweet, {
favorited: loggedInUser
? loggedInUser.liked_tweet_ids.includes(tweet.id_str || "")
: false,
})
: tweet,
source: tweet?.source,
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
});
}
return res.status(200).send({
data: {
user: {
result: {
__typename: "User",
timeline_v2: {
timeline: {
instructions: [
{
type: "TimelineClearCache",
},
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified:
user.ext_is_blue_verified,
legacy: {
...(user as any)._doc,
},
profile_image_shape:
user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
},
},
});
}
export async function HomeTimeline(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const userId = req.cookies["jwt"]
? ((verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded)
.id as number)
: undefined;
const loggedInUser = await User.findOne({
id_string: userId,
});
if (!loggedInUser) return res.status(400).send({ msg: "Not authenticated" });
const userTweets = [];
const postedTweets = await Tweet.find().limit(50);
for (const tweet of postedTweets) {
const user = await User.findOne({ id_string: tweet.user_id_str });
if (!user) return res.status(400).send({ msg: "User not found" });
userTweets.push({
is_translatable: false,
legacy: Object.assign(tweet, {
favorited: loggedInUser.liked_tweet_ids.includes(tweet.id_str || ""),
}),
unmention_data: {},
unmention_info: {},
views: tweet.ext_views,
user: user,
});
}
return res.status(200).send({
data: {
home: {
home_timeline_urt: {
instructions: [
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
tweet.user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: tweet.user._id,
is_blue_verified:
tweet.user.ext_is_blue_verified,
legacy: {
...(tweet.user as any)._doc,
entities: {
user_mentions: (
tweet.legacy.entities
?.
|
user_mentions as IUserMention[]
).map((mention) => {
|
return {
a: true,
};
}),
},
},
profile_image_shape:
tweet.user.ext_profile_image_shape,
rest_id: tweet.user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.legacy.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
});
}
export async function FavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (!user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids.push(variables.tweet_id);
tweet.favorite_count! += 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { favourte_tweet: "NOT DONE" } });
}
if (tweet.user_id_str !== user.id_string)
addNotification(
"%1 liked your tweet!",
"like",
tweet.user_id_str!,
user.id_string!,
tweet.id_str!
);
return res.status(200).send({ data: { favorite_tweet: "Done" } });
}
export async function UnfavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids = user.liked_tweet_ids.filter(
(id) => id !== variables.tweet_id
);
tweet.favorite_count! -= 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { unfavorite_tweet: "NOT DONE" } });
}
return res.status(200).send({ data: { unfavorite_tweet: "Done" } });
}
export async function CreateTweet(req: express.Request, res: express.Response) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const body = req.body as ICreateTweetBody;
const id = (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id as number;
const user = await User.findOne({ id });
if (!user) return res.status(400).send({ msg: "User not found" });
const user_mentions = [] as IUserMention[];
const matches = body.variables.tweet_text.matchAll(/@(\S+)/gm);
for (const match of matches) {
const withTag = match[0];
const withoutTag = match[1];
const user = await User.findOne({ screen_name: withoutTag });
user_mentions.push({
id_str: user?.id_string,
name: user?.name,
screen_name: user?.screen_name,
indices: [match.index, withTag.length + (match.index || 0)],
});
}
const tweetId = randInt(12);
const tweetData = {
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions,
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id: tweetId,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
source:
'<a href="https://mobile.twitter.com" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
};
const tweet = new Tweet({
bookmark_count: tweetData.legacy.bookmark_count,
bookmarked: tweetData.legacy.bookmarked,
conversation_id_str: tweetData.legacy.conversation_id_str,
created_at: tweetData.legacy.created_at,
display_text_range: tweetData.legacy.display_text_range,
entities: {
hashtags: tweetData.legacy.entities.hashtags,
symbols: tweetData.legacy.entities.symbols,
urls: tweetData.legacy.entities.urls,
user_mentions,
},
favorite_count: tweetData.legacy.favorite_count,
favorited: tweetData.legacy.favorited,
full_text: tweetData.legacy.full_text,
id_str: tweetData.legacy.id_str,
is_quote_status: tweetData.legacy.is_quote_status,
lang: tweetData.legacy.lang,
quote_count: tweetData.legacy.quote_count,
reply_count: tweetData.legacy.reply_count,
retweet_count: tweetData.legacy.retweet_count,
retweeted: tweetData.legacy.retweeted,
user_id_str: tweetData.legacy.user_id_str,
});
await tweet.save();
user.posted_tweet_ids.push(tweetId.toString());
await user.save();
log(`${user.name} (@${user.screen_name}) just posted a tweet:`);
log(`"${tweet.full_text}"`);
// addNotification(
// "%1 just posted a tweet!",
// "reply",
// user.id_string!,
// user.id_string!,
// tweet.id_str!
// );
return res.status(200).send({
// data: {
// create_tweet: {
// tweet_results: {
// result: {
// core: {
// user_results: {
// result: {
// __typename: "User",
// affiliates_highlighted_label:
// user.ext?.highlightedLabel?.r?.ok,
// business_account: {},
// id: user._id,
// is_blue_verified: user.ext_is_blue_verified,
// legacy: {
// created_at: user.created_at,
// default_profile: user.default_profile,
// default_profile_image: user.default_profile_image,
// description: user.description,
// entities: user.entities,
// fast_followers_count: user.fast_followers_count,
// favourites_count: user.favourites_count,
// followers_count: user.followers_count,
// friends_count: user.friends_count,
// has_custom_timelines: user.has_custom_timelines,
// is_translator: user.is_translator,
// listed_count: user.listed_count,
// location: user.location,
// media_count: user.media_count,
// name: user.name,
// normal_followers_count: user.normal_followers_count,
// pinned_tweet_ids_str: user.pinned_tweet_ids_str,
// possibly_sensitive: false,
// profile_image_url_https: user.profile_image_url_https,
// profile_interstitial_type: "",
// screen_name: user.screen_name,
// statuses_count: user.statuses_count,
// translator_type: user.translator_type,
// verified: user.verified,
// withheld_in_countries: user.withheld_in_countries,
// },
// profile_image_shape: user.ext_profile_image_shape,
// rest_id: user.id,
// },
// },
// },
// ...tweetData,
// },
// },
// },
// },
data: {
create_tweet: {
tweet_results: {
result: {
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified: user.ext_is_blue_verified,
legacy: {
created_at: user.created_at,
default_profile: user.default_profile,
default_profile_image: user.default_profile_image,
description: user.description,
entities: user.entities,
fast_followers_count: user.fast_followers_count,
favourites_count: user.favourites_count,
followers_count: user.followers_count,
friends_count: user.friends_count,
has_custom_timelines: user.has_custom_timelines,
is_translator: user.is_translator,
listed_count: user.listed_count,
location: user.location,
media_count: user.media_count,
name: user.name,
normal_followers_count: user.normal_followers_count,
pinned_tweet_ids_str: user.pinned_tweet_ids_str,
possibly_sensitive: false,
profile_image_url_https: user.profile_image_url_https,
profile_interstitial_type: "",
screen_name: user.screen_name,
statuses_count: user.statuses_count,
translator_type: user.translator_type,
verified: user.verified,
withheld_in_countries: user.withheld_in_countries,
},
profile_image_shape: user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_control: {
edit_tweet_ids: [tweetId.toString()],
editable_until_msecs: "1682984834000",
edits_remaining: "5",
is_edit_eligible: true,
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, 68],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions: (
tweet.entities!.user_mentions as Array<Array<IUserMention>>
).map((mention) => mention[0]),
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
rest_id: tweetId.toString(),
source:
'<a href="https://github.com/" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Disabled",
},
},
},
},
},
});
}
|
src/routes/gql/tweet.ts
|
not-nullptr-blue-3b2284a
|
[
{
"filename": "src/routes/gql/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.8424369096755981
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tttl: -1,\n\t\t\t\t\t\t},\n\t\t\t\t\t\tcan_dm: user.can_dm || true,\n\t\t\t\t\t\tcan_media_tag: false || false,\n\t\t\t\t\t\tdefault_profile: user.default_profile || true,\n\t\t\t\t\t\tdefault_profile_image: user.default_profile_image || false,\n\t\t\t\t\t\tdescription: user.description || \"\",\n\t\t\t\t\t\tentities: user.entities || { description: { urls: [] } },\n\t\t\t\t\t\tfast_followers_count: user.fast_followers_count || 0,",
"score": 0.8308795690536499
},
{
"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.8300603032112122
},
{
"filename": "src/routes/gql/viewer.ts",
"retrieved_chunk": "\t\t\t\t\t\taffiliates_highlighted_label: {},\n\t\t\t\t\t\thas_graduated_access: true,\n\t\t\t\t\t\tid: user._id,\n\t\t\t\t\t\tis_blue_verified: false,\n\t\t\t\t\t\tis_profile_translatable: false,\n\t\t\t\t\t\t// legacy: {\n\t\t\t\t\t\t// \tcan_dm: true,\n\t\t\t\t\t\t// \tcan_media_tag: true,\n\t\t\t\t\t\t// \tcreated_at: \"Mon Jan 17 11:43:44 +0000 2022\",\n\t\t\t\t\t\t// \tdefault_profile: true,",
"score": 0.8291236162185669
},
{
"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.8202377557754517
}
] |
typescript
|
user_mentions as IUserMention[]
).map((mention) => {
|
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.8751943111419678
},
{
"filename": "src/agent.ts",
"retrieved_chunk": "import { last } from \"lodash\";\nimport ActionHandler from \"./action-handler\";\nimport makeDecision from \"./make-decision\";\nimport { Memory } from \"./memory\";\nimport { messageBuilder } from \"./message\";\nimport { MessageBus } from \"./message-bus\";\nimport { ModuleManager } from \"./module/module-manager\";\nimport parseAction from \"./parse-action\";\nimport TaskQueue from \"./task-queue\";\nimport { agentName, sleep } from \"./util\";",
"score": 0.8654288053512573
},
{
"filename": "src/agent.ts",
"retrieved_chunk": " private taskQueue = new TaskQueue();\n // Start this Agent's event loop\n async start() {\n // Subscribe to messages\n this.messageBus.subscribe((message) => {\n if (message.targetAgentIds && !message.targetAgentIds.includes(this.id))\n return;\n this.memory.append({ type: \"message\", message });\n });\n // Act on messages periodically",
"score": 0.8473473787307739
},
{
"filename": "src/console.ts",
"retrieved_chunk": "import readline from \"readline\";\nimport { messageBuilder } from \"./message\";\nimport { MessageBus } from \"./message-bus\";\nconst AGENT_ID = \"0\";\nconst rl = readline.createInterface({\n input: process.stdin,\n output: process.stdout,\n prompt: \"$ \",\n});\nexport function startConsole(agentIds: string[], messageBus: MessageBus) {",
"score": 0.8356667757034302
},
{
"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.833992600440979
}
] |
typescript
|
await agent.start();
|
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.8008203506469727
},
{
"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.8006012439727783
},
{
"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.7999053597450256
},
{
"filename": "src/routes/gql/viewer.ts",
"retrieved_chunk": "\tconst user = await User.findOne({\n\t\tid,\n\t});\n\tif (!user) return res.status(400).send({ msg: \"User not found\" });\n\treturn res.status(200).send({\n\t\tdata: {\n\t\t\tis_super_follow_subscriber: false,\n\t\t\tviewer: {\n\t\t\t\tcreate_community_action_result: {\n\t\t\t\t\t__typename: \"CommunityCreateActionUnavailable\",",
"score": 0.7935235500335693
},
{
"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.7917050123214722
}
] |
typescript
|
.findOne({ id_string: recipient });
|
import { ChatCompletionRequestMessage } from "openai";
import { Event } from "./memory";
import { createChatCompletion } from "./openai";
import { model } from "./parameters";
import { messageSourceName } from "./util";
export default async function makeDecision(events: Event[]): Promise<string> {
console.log(`Reflecting on ${events.length} events...`);
const t0 = Date.now();
const messages = events.map(toOpenAiMessage);
// console.log(JSON.stringify(messages, null, 2));
const responseContent = await createChatCompletion({
model,
messages,
temperature: 0.0,
});
console.log(
`Arrived at a decision after ${((Date.now() - t0) / 1000).toFixed(1)}s`
);
return responseContent;
}
// lazy load to avoid accessing OPENAI_API_KEY before env has been loaded
export function toOpenAiMessage(event: Event): ChatCompletionRequestMessage {
switch (event.type) {
case "message": {
const { type: messageType, source, content } = event.message;
const role = source.type === "system" ? "system" : "user";
let header: string;
switch (messageType) {
case "spontaneous":
case "ok":
header = "";
break;
case "agentToAgent":
header = `--- MESSAGE FROM ${messageSourceName(
source
).toUpperCase()} ---\n\n`;
break;
case "error":
header = "--- ERROR ---\n\n";
break;
}
return {
role,
content: `${header}${content}`,
};
}
case "decision":
return {
role: "assistant",
content
|
: event.actionText,
};
|
}
}
|
src/make-decision.ts
|
eumemic-ai-legion-4d145b3
|
[
{
"filename": "src/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.8351558446884155
},
{
"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.8172842264175415
},
{
"filename": "src/memory/index.ts",
"retrieved_chunk": "import { Message } from \"../message\";\nexport { Memory } from \"./memory\";\nexport type Event = MessageEvent | DecisionEvent;\nexport interface MessageEvent {\n type: \"message\";\n message: Message;\n}\nexport interface DecisionEvent {\n type: \"decision\";\n actionText: string;",
"score": 0.8069677948951721
},
{
"filename": "src/module/define-module.ts",
"retrieved_chunk": " }),\n };\n}",
"score": 0.8052569627761841
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": "import { Event } from \".\";\nimport makeDecision, { toOpenAiMessage } from \"../make-decision\";\nimport { messageBuilder } from \"../message\";\nimport { ModuleManager } from \"../module/module-manager\";\nimport { Store } from \"../store\";\nimport {\n AVG_WORDS_PER_TOKEN,\n agentName,\n countTokens as countTokensInText,\n messageSourceName,",
"score": 0.8052559494972229
}
] |
typescript
|
: event.actionText,
};
|
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/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.8607798218727112
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": "import { Event } from \".\";\nimport makeDecision, { toOpenAiMessage } from \"../make-decision\";\nimport { messageBuilder } from \"../message\";\nimport { ModuleManager } from \"../module/module-manager\";\nimport { Store } from \"../store\";\nimport {\n AVG_WORDS_PER_TOKEN,\n agentName,\n countTokens as countTokensInText,\n messageSourceName,",
"score": 0.8438776135444641
},
{
"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.8349919319152832
},
{
"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.8316313624382019
},
{
"filename": "src/memory/index.ts",
"retrieved_chunk": "import { Message } from \"../message\";\nexport { Memory } from \"./memory\";\nexport type Event = MessageEvent | DecisionEvent;\nexport interface MessageEvent {\n type: \"message\";\n message: Message;\n}\nexport interface DecisionEvent {\n type: \"decision\";\n actionText: string;",
"score": 0.8287732601165771
}
] |
typescript
|
messageBuilder.error(this.id, result.message));
|
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.9360772967338562
},
{
"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.9228782653808594
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\tres: express.Response\n) {\n\tconst features = JSON.parse(\n\t\treq.query.features!.toString()\n\t) as IGenericFeatures;\n\tconst variables = JSON.parse(\n\t\treq.query.variables!.toString()\n\t) as IUserByScreenNameVariables;\n\tif (!features || !variables)\n\t\treturn res.status(400).send({ msg: \"Missing parameters\" });",
"score": 0.9013756513595581
},
{
"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.8857216835021973
},
{
"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.8839038610458374
}
] |
typescript
|
const tweet = await Tweet.findOne({ id_str: id });
|
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/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.823613166809082
},
{
"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.7969989776611328
},
{
"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.7875789403915405
},
{
"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.7826937437057495
},
{
"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.7821557521820068
}
] |
typescript
|
.moduleManager.modules.map(async (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/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.8249695301055908
},
{
"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.7998404502868652
},
{
"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.7905514240264893
},
{
"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.7851802110671997
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " messages: [\n {\n role: \"user\",\n 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}`,\n },\n ],\n })\n )\n );\n const summary = summarizedChunks",
"score": 0.7832362651824951
}
] |
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/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.8491722345352173
},
{
"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.8346405029296875
},
{
"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.8258461356163025
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " messages: [\n {\n role: \"user\",\n 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}`,\n },\n ],\n })\n )\n );\n const summary = summarizedChunks",
"score": 0.8106660842895508
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " .map(\n (chunk) =>\n `=== SUMMARIZED CHUNK (${countTokens(\n chunk\n )} tokens) ===\\n\\n${chunk}\\n\\n`\n )\n .join(\"\");\n // console.log(`Summary:\\n\\n${summary}\\n`);\n console.log(`Summary tokens: ${countTokens(summary)}`);\n await browser.close();",
"score": 0.8030465245246887
}
] |
typescript
|
= await makeDecision([
...eventsToSummarize,
{
|
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.8381080627441406
},
{
"filename": "src/store/file-store.ts",
"retrieved_chunk": " const withStats = await Promise.all(\n fileNames.map(async (fileName) => {\n const stats = await stat(`${this.dirPath}/${fileName}`);\n return { keyName: decodeFilename(fileName), stats };\n })\n );\n // Sort by last modified date\n const sortedKeys = withStats\n .sort((a, b) => a.stats.mtime.getTime() - b.stats.mtime.getTime())\n .map(({ keyName }) => keyName);",
"score": 0.8347452878952026
},
{
"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.8288140296936035
},
{
"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.8198364973068237
},
{
"filename": "src/store/file-store.ts",
"retrieved_chunk": " const path = this.pathFor(key);\n const fileExists = await checkExists(path);\n if (!fileExists) return false;\n await unlink(path);\n return true;\n }\n async getKeys() {\n await this.mkdirs();\n const fileNames = await readdir(this.dirPath);\n // Get file stats for each file in parallel",
"score": 0.7936959266662598
}
] |
typescript
|
.ok(
agentId,
`Here are the contents of ${path}:\n${filesWithStats.join("\n")}`
)
);
|
import { ChatCompletionRequestMessage } from "openai";
import { Event } from "./memory";
import { createChatCompletion } from "./openai";
import { model } from "./parameters";
import { messageSourceName } from "./util";
export default async function makeDecision(events: Event[]): Promise<string> {
console.log(`Reflecting on ${events.length} events...`);
const t0 = Date.now();
const messages = events.map(toOpenAiMessage);
// console.log(JSON.stringify(messages, null, 2));
const responseContent = await createChatCompletion({
model,
messages,
temperature: 0.0,
});
console.log(
`Arrived at a decision after ${((Date.now() - t0) / 1000).toFixed(1)}s`
);
return responseContent;
}
// lazy load to avoid accessing OPENAI_API_KEY before env has been loaded
export function toOpenAiMessage(event: Event): ChatCompletionRequestMessage {
switch (event.type) {
case "message": {
const { type: messageType, source, content } = event.message;
const role = source.type === "system" ? "system" : "user";
let header: string;
switch (messageType) {
case "spontaneous":
case "ok":
header = "";
break;
case "agentToAgent":
header = `--- MESSAGE FROM ${messageSourceName(
source
).toUpperCase()} ---\n\n`;
break;
case "error":
header = "--- ERROR ---\n\n";
break;
}
return {
role,
content: `
|
${header}${content}`,
};
|
}
case "decision":
return {
role: "assistant",
content: event.actionText,
};
}
}
|
src/make-decision.ts
|
eumemic-ai-legion-4d145b3
|
[
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " const { name, pinnedMessage } = module.moduleDef;\n if (!pinnedMessage) return [];\n const content = await pinnedMessage(module.context);\n if (!content) return [];\n return [`--- ${name.toUpperCase()} ---\\n\\n${content}`];\n })\n );\n return {\n type: \"message\",\n message: messageBuilder.spontaneous(",
"score": 0.8070546388626099
},
{
"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.7933775186538696
},
{
"filename": "src/module/define-module.ts",
"retrieved_chunk": " }),\n };\n}",
"score": 0.7835749387741089
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " .map((part) => part.trim())\n .map((part, i) => {\n if (i % 2 === 0) return part;\n return JSON.stringify(part) + \"\\n\";\n })\n .join(\"\")\n .split(\"\\n\")\n .filter(Boolean)\n .map((line) => {\n const colonIndex = line.indexOf(\":\");",
"score": 0.7786045670509338
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " if (colonIndex < 0)\n throw new Error(\n `Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\\`${MULTILINE_DELIMITER}\\`)?`\n );\n const key = line.substring(0, colonIndex).trim();\n let value = line.substring(colonIndex + 1).trim();\n if (!value.startsWith('\"') || !value.endsWith('\"'))\n value = JSON.stringify(value);\n return `\"${key}\": ${value}`;\n })",
"score": 0.7785687446594238
}
] |
typescript
|
${header}${content}`,
};
|
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/module/definitions/messaging.ts",
"retrieved_chunk": " agentId,\n `You tried to send your message to an invalid targetAgentId (${JSON.stringify(\n targetAgentId\n )}). You can use the 'queryAgentRegistry' action to see a list of available agents and their agent IDs.`\n )\n );\n }\n },\n },\n },",
"score": 0.839116096496582
},
{
"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.8278906345367432
},
{
"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.8192510604858398
},
{
"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.8134149312973022
},
{
"filename": "src/main.ts",
"retrieved_chunk": " notes,\n messaging,\n filesystem,\n web,\n ]);\n const actionHandler = new ActionHandler(\n agentIds,\n messageBus,\n moduleManager\n );",
"score": 0.8127158880233765
}
] |
typescript
|
error(
agentId,
`Unknown action \`${aboutAction}\`. Please refer to the list of available actions given in the introductory message.`
)
);
|
import {
readFile,
readdir,
rename,
stat,
unlink,
writeFile,
mkdir,
} from "fs/promises";
import { join as joinPath, resolve as resolvePath } from "path";
import { defineModule } from "../define-module";
import { messageBuilder } from "../../message";
export default defineModule({
name: "filesystem",
}).with({
actions: {
listDirectory: {
description: "Inspect the contents of a particular directory",
parameters: {
path: {
description: "The path of the directory you want to inspect",
},
},
async execute({
parameters: { path },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, path, sendMessage)) return;
try {
const files = await readdir(path);
const filesWithStatsPromises = files.map(async (file) => {
const stats = await stat(joinPath(path, file));
return `${file} ${stats.isDirectory() ? "[directory]" : "[file]"}`;
});
const filesWithStats = await Promise.all(filesWithStatsPromises);
sendMessage(
messageBuilder.ok(
agentId,
`Here are the contents of ${path}:\n${filesWithStats.join("\n")}`
)
);
} catch (err) {
sendMessage
|
(messageBuilder.error(agentId, JSON.stringify(err)));
|
}
},
},
readFile: {
description: "Read the contents of a particular file",
parameters: {
path: {
description: "The path of the file you want to inspect",
},
},
async execute({
parameters: { path },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, path, sendMessage)) return;
try {
const data = await readFile(path, "utf8");
sendMessage(
messageBuilder.ok(agentId, `Contents of ${path}:\n\n${data}`)
);
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
writeFile: {
description: "Write the contents of a particular file",
parameters: {
path: {
description: "The path of the file you want to write to",
},
content: {
description: "The new content of the file",
},
},
async execute({
parameters: { path, content },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, path, sendMessage)) return;
try {
await writeFile(path, content, "utf8");
sendMessage(messageBuilder.ok(agentId, `Wrote to ${path}.`));
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
moveFile: {
description: "Move a file to a new location",
parameters: {
sourcePath: {
description: "The original path of the file",
},
destinationPath: {
description: "The new path for the file",
},
},
async execute({
parameters: { sourcePath, destinationPath },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, sourcePath, sendMessage)) return;
if (!checkPath(agentId, destinationPath, sendMessage)) return;
try {
await rename(sourcePath, destinationPath);
sendMessage(
messageBuilder.ok(
agentId,
`Moved ${sourcePath} to ${destinationPath}.`
)
);
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
deleteFile: {
description: "Delete a file",
parameters: {
path: {
description: "The path of the file to delete",
},
},
async execute({
parameters: { path },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, path, sendMessage)) return;
try {
await unlink(path);
sendMessage(messageBuilder.ok(agentId, `Deleted ${path}.`));
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
createDirectory: {
description: "Create a new directory",
parameters: {
path: {
description: "The path of the directory to create",
},
},
async execute({
parameters: { path },
context: { agentId },
sendMessage,
}) {
if (!checkPath(agentId, path, sendMessage)) return;
try {
await mkdir(path);
sendMessage(messageBuilder.ok(agentId, `Created directory ${path}.`));
} catch (err) {
sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));
}
},
},
},
});
function checkPath(
agentId: string,
path: string,
sendMessage: (message: any) => void
) {
const currentDirectory = process.cwd();
const resolvedPath = resolvePath(path);
if (!resolvedPath.startsWith(currentDirectory)) {
sendMessage(
messageBuilder.error(
agentId,
"Invalid path; must be within the current directory."
)
);
return false;
}
if (resolvedPath.includes(".git") || resolvedPath.includes("node_modules")) {
sendMessage(messageBuilder.error(agentId, "That path is off-limits!"));
return false;
}
return true;
}
|
src/module/definitions/filesystem.ts
|
eumemic-ai-legion-4d145b3
|
[
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " sendMessage(\n messageBuilder.ok(\n agentId,\n `These are the agents in the system:\\n\\n${allAgentIds\n .map((id) => `${agentName(id)} [agentId=${id}]`)\n .join(\"\\n\")}`\n )\n );\n },\n },",
"score": 0.8524471521377563
},
{
"filename": "src/store/file-store.ts",
"retrieved_chunk": " const withStats = await Promise.all(\n fileNames.map(async (fileName) => {\n const stats = await stat(`${this.dirPath}/${fileName}`);\n return { keyName: decodeFilename(fileName), stats };\n })\n );\n // Sort by last modified date\n const sortedKeys = withStats\n .sort((a, b) => a.stats.mtime.getTime() - b.stats.mtime.getTime())\n .map(({ keyName }) => keyName);",
"score": 0.8382099866867065
},
{
"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.8319212198257446
},
{
"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.8274044990539551
},
{
"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.8266687393188477
}
] |
typescript
|
(messageBuilder.error(agentId, JSON.stringify(err)));
|
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.8765588998794556
},
{
"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.860649824142456
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),\n score: 0,\n }\n playersTable._db.set(mockPlayer.id, mockPlayer);\n /**\n * This calls into /coop/create which is a complex API.\n * Step thru this to learn about how the route handlers work.\n */\n console.log('Creating game...');\n await handleRequest({",
"score": 0.8482908010482788
},
{
"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.8481820821762085
},
{
"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.8479267358779907
}
] |
typescript
|
: IHttpRequest) {
|
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.8573095798492432
},
{
"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.816206693649292
},
{
"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.8150259256362915
},
{
"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.8129600882530212
},
{
"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.8114197254180908
}
] |
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/goals.ts",
"retrieved_chunk": " context: { agentId, state },\n sendMessage,\n }) {\n const goals = (await state.get(KEY)) || [];\n await state.set(KEY, [...goals, { text: goal, complete: false }]);\n sendMessage(messageBuilder.ok(agentId, \"Goal added.\"));\n },\n },\n completeGoal: {\n description: \"Mark a goal as complete.\",",
"score": 0.8532648682594299
},
{
"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.8529125452041626
},
{
"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.8508033156394958
},
{
"filename": "src/module/definitions/goals.ts",
"retrieved_chunk": " ]);\n sendMessage(messageBuilder.ok(agentId, \"Goal marked complete.\"));\n },\n },\n },\n});",
"score": 0.8429149389266968
},
{
"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.8338203430175781
}
] |
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": " 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.8882011771202087
},
{
"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.8762853741645813
},
{
"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.8756780624389648
},
{
"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.8726058602333069
},
{
"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.870110273361206
}
] |
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": " }\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.8888606429100037
},
{
"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.865902304649353
},
{
"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.8602228760719299
},
{
"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.8468620777130127
},
{
"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.8460255861282349
}
] |
typescript
|
let gameData: GameEngine.IGameData | undefined = undefined;
|
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/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.8343257904052734
},
{
"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.8244861960411072
},
{
"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.8225728273391724
},
{
"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.8158594369888306
},
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " sendMessage: {\n description: \"Send a message to another agent\",\n parameters: {\n targetAgentId: {\n description: \"The target agent's ID\",\n },\n message: {\n description: \"The content of the message\",\n },\n },",
"score": 0.812757134437561
}
] |
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/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.8886424899101257
},
{
"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.888026773929596
},
{
"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.8841460943222046
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), deck: toClientDeck(player, deck) }];\n }\n case 'create': {\n const schema = z.object({\n deckLabel: z.string().min(1).max(20),\n nftIds: z.array(z.string().startsWith('nft1')).length(6),\n });\n const payload = schema.parse(body);\n const player = await authProvider.getPlayerFromRequest(req);\n const nfts = (await Promise.all((payload.nftIds).slice(0, 6).map(ExtDeps.getNft))).filter(Boolean).map(x => x.nft);",
"score": 0.8788302540779114
},
{
"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.8779587745666504
}
] |
typescript
|
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
|
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.8298578262329102
},
{
"filename": "src/message.ts",
"retrieved_chunk": "}\nfunction singleTargetSystemMessage(\n agentId: string,\n content: string\n): TypelessMessage {\n return {\n source: systemSource,\n targetAgentIds: [agentId],\n content,\n };",
"score": 0.818953275680542
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": "I am sending you a multi-line message.\nThis is another line.\n% ff9d7713-0bb0-40d4-823c-5a66de48761b\n `);\n});\ntest(\"case 2\", () => {\n assertValid(`\nsendMessage\ntargetAgentId: 0\nmessage:",
"score": 0.8160398602485657
},
{
"filename": "src/module/definitions/goals.ts",
"retrieved_chunk": " ]);\n sendMessage(messageBuilder.ok(agentId, \"Goal marked complete.\"));\n },\n },\n },\n});",
"score": 0.8134790062904358
},
{
"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.8133322596549988
}
] |
typescript
|
: messageBuilder.spontaneous(
this.agentId,
nestedEvents.flat().join("\n\n")
),
};
|
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
const gameData = await gameEngineProvider.getGameData(game.id);
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider.removePlayer(game.id, player.id, 'leave');
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
const rankings = await ds.Leaderboard.getTopN(20);
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort((a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
const gameData = await gameEngineProvider.startGame(game.id);
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
|
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
|
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game.gameState = `ended_${now.format(DATE_FORMAT)}`;
game.endedAt = now.format(FULL_DATETIME_FORMAT);
let gameData: GameEngine.IGameData | undefined = undefined;
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
await gameEngineProvider.endGame(game.id);
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
}
|
src/apis/coop.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/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.8863353729248047
},
{
"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.8730926513671875
},
{
"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.8725661039352417
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),\n score: 0,\n }\n playersTable._db.set(mockPlayer.id, mockPlayer);\n /**\n * This calls into /coop/create which is a complex API.\n * Step thru this to learn about how the route handlers work.\n */\n console.log('Creating game...');\n await handleRequest({",
"score": 0.871604323387146
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " const newAuthExpireAt = moment.utc(now).add({ days: 14 }).format(FULL_DATETIME_FORMAT);\n if (!player) {\n const nowStr = now.format(FULL_DATETIME_FORMAT);\n player = await ds.Players.update.exec({\n id: did,\n createdAt: nowStr,\n lastSeenAt: nowStr,\n secret: newSecret,\n authExpiresAt: newAuthExpireAt,\n activeGameId: '',",
"score": 0.8677583932876587
}
] |
typescript
|
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
|
import { defineModule } from "../define-module";
import { messageBuilder } from "../../message";
import { agentName } from "../../util";
export default defineModule({
name: "messaging",
}).with({
actions: {
queryAgentRegistry: {
description: "Ask who the other agents are that you can talk to",
async execute({ context: { agentId, allAgentIds }, sendMessage }) {
sendMessage(
messageBuilder.ok(
agentId,
`These are the agents in the system:\n\n${allAgentIds
.map((id) => `${agentName(id)} [agentId=${id}]`)
.join("\n")}`
)
);
},
},
sendMessage: {
description: "Send a message to another agent",
parameters: {
targetAgentId: {
description: "The target agent's ID",
},
message: {
description: "The content of the message",
},
},
async execute({
parameters: { targetAgentId, message },
context: { agentId, allAgentIds },
sendMessage,
}) {
if (agentId === targetAgentId) {
return sendMessage(
messageBuilder
|
.error(
agentId,
"You can't send a message to yourself. Use the `writeNote` action if you want to make notes for yourself."
)
);
|
}
if (allAgentIds.includes(targetAgentId)) {
sendMessage(
messageBuilder.agentToAgent(agentId, [targetAgentId], message)
);
} else {
sendMessage(
messageBuilder.error(
agentId,
`You tried to send your message to an invalid targetAgentId (${JSON.stringify(
targetAgentId
)}). You can use the 'queryAgentRegistry' action to see a list of available agents and their agent IDs.`
)
);
}
},
},
},
});
|
src/module/definitions/messaging.ts
|
eumemic-ai-legion-4d145b3
|
[
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " 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.8578130006790161
},
{
"filename": "src/module/definitions/goals.ts",
"retrieved_chunk": " ]);\n sendMessage(messageBuilder.ok(agentId, \"Goal marked complete.\"));\n },\n },\n },\n});",
"score": 0.842095673084259
},
{
"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.8365576267242432
},
{
"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.8334873914718628
},
{
"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.8274638056755066
}
] |
typescript
|
.error(
agentId,
"You can't send a message to yourself. Use the `writeNote` action if you want to make notes for yourself."
)
);
|
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": " `);\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.8924105167388916
},
{
"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.891201913356781
},
{
"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.8767217397689819
},
{
"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.874151885509491
},
{
"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.8720870018005371
}
] |
typescript
|
const postedTweets = await Tweet.find().limit(50);
|
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/memory/memory.ts",
"retrieved_chunk": " {\n type: \"message\",\n message: messageBuilder.ok(\n this.agentId,\n `Write a summary in ${summaryWordLimit} words or less of what has happened since (but not including) the introductory message. Include key information that you learned which you don't want to forget. This information will serve as a note to yourself to help you understand what has gone before. Use the second person voice, as if you are someone filling in your replacement who knows nothing. The summarized messages will be omitted from your context window going forward and you will only have this summary to go by, so make it as useful and information-dense as possible. Be as specific as possible, but only include important information. If there are details that seem unimportant, or which you could recover outside of your memory (for instance the particular contents of a file which you could read any time), then omit them from your summary. Once again, your summary must not exceed ${summaryWordLimit} words. In this particular instance, your response should just be raw text, not formatted as an action.`\n ),\n },\n ]);\n const summary = `Several events are omitted here to free up space in your context window, summarized as follows:\\n\\n${summaryContent}`;\n // const summary =",
"score": 0.8336344957351685
},
{
"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.8297477960586548
},
{
"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.8023933172225952
},
{
"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.8010622262954712
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " // \"Several events are omitted here to free up space in your context window.\";\n const summaryEvent: Event = {\n type: \"message\",\n message: messageBuilder.spontaneous(this.agentId, summary),\n };\n const summaryTokens = countTokens(summaryEvent);\n const tokenSavings =\n precedingTokens - summaryTokens - cumulativeTokenCounts[0];\n if (tokenSavings > 0) {\n // console.log(",
"score": 0.7984524965286255
}
] |
typescript
|
messageBuilder.error(
agentId,
`Error extracting content from ${url}: ${e.message}`
)
);
|
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.8658032417297363
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " game.startedAt = now.format(FULL_DATETIME_FORMAT);\n game._dbTtl = 9999999999;\n await ds.CoopGames.update.exec(game);\n metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);\n }\n async function _expectAuthPlayerInGame(req: IHttpRequest) {\n const player = await authProvider.getPlayerFromRequest(req);\n if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');\n const game = await ds.CoopGames.get(player.activeGameId);\n if (game) {",
"score": 0.8630257844924927
},
{
"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.8584671020507812
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " const [deck, game] = await Promise.all([\n _expectValidActiveDeck(player, true),\n _expectCoopGameJoinable(teammate.activeGameId),\n ]);\n const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));\n player.activeGameId = game.id;\n game.playersIds.add(player.id);\n game.ingorePlayerIds.delete(player.id);\n await ds.execUpdates(\n ds.Players.update.make(player),",
"score": 0.856787919998169
},
{
"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.8553882837295532
}
] |
typescript
|
toClientPlayer(player, authProvider),
status: isNew ? 'new' : 'existing',
}];
|
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/messaging.ts",
"retrieved_chunk": " agentId,\n `You tried to send your message to an invalid targetAgentId (${JSON.stringify(\n targetAgentId\n )}). You can use the 'queryAgentRegistry' action to see a list of available agents and their agent IDs.`\n )\n );\n }\n },\n },\n },",
"score": 0.8281388878822327
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " } ${missingProps.map((p) => `\\`${p}\\``)}. ${getUsageText(actionDef)}`,\n };\n }\n const extraProps = Object.keys(parameters).filter(\n (p) => !(p in actionDef.parameters)\n );\n if (extraProps.length) {\n return {\n type: \"error\",\n message: `Extraneous parameter${",
"score": 0.8204917311668396
},
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " sendMessage: {\n description: \"Send a message to another agent\",\n parameters: {\n targetAgentId: {\n description: \"The target agent's ID\",\n },\n message: {\n description: \"The content of the message\",\n },\n },",
"score": 0.8081788420677185
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " .filter(\n ([name, parameterDef]) =>\n !parameterDef.optional && !(name in parameters)\n )\n .map(([name]) => name);\n if (missingProps.length) {\n return {\n type: \"error\",\n message: `Missing required parameter${\n missingProps.length > 1 ? \"s\" : \"\"",
"score": 0.8058406114578247
},
{
"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.8045735359191895
}
] |
typescript
|
message\`. ${getUsageText(
messaging.actions.sendMessage
)}`
);
|
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export abstract class CardMod {
duration = -1;
stackingConfig: Parameters<typeof CardMod['makeStackingData']>[0] = { behavior: CardMod.StackingBehavior.neverReplace };
readonly modName: string;
constructor(
private _extraModData?: IArguments,
) {
this.modName = this.constructor.name;
}
onSecDamageIn?(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState): { secDmgBonus: number } | void;
onSecDamageOut?(deps: CardMod.ICardModDeps, baseDmg: number): { secDmgBonus: number } | void;
onMemDmgIn?(deps: CardMod.ICardModDeps, memDmg: number): void;
onMemDmgOut?(deps: CardMod.ICardModDeps, memDmg: number): void;
onInitMod?(deps: CardMod.ICardModDeps): void;
onRemoveMod?(deps: CardMod.ICardModDeps): void;
onCardDestroyed?(deps: CardMod.ICardModDeps): void;
onStackMod?(deps: CardMod.ICardModDeps, stackDelta: number): void;
onTurnStart?(deps: CardMod.ICardModDeps): void;
onTurnEnd?(deps: CardMod.ICardModDeps): void;
onEnemyDestroyed?(deps: CardMod.ICardModDeps): void;
serialize() {
const stackingData = CardMod.makeStackingData(this.stackingConfig);
const modData = [this.modName, stackingData] as CardMod.ModData;
(this.duration >= 0) && (modData.push(CardMod.makeDurationData(this.duration)));
this._extraModData && modData.push(...this._extraModData);
return modData;
}
static addMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, mod: CardMod, contextCard?: GameEngine.ICardState) {
const modData = mod.serialize();
switch (mod.stackingConfig.behavior) {
case CardMod.StackingBehavior.append: {
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.neverReplace: {
|
const existingModData = card.mods.find(x => x[0] === mod.modName);
|
if (existingModData) return;
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.ranked: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
if (existingStackingData[2] >= mod.stackingConfig.rank) {
return;
}
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.replace: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
this.removeMod(engine, card, existingModData, contextCard);
if (card.isRemoved) return;
}
card.mods.push(modData);
break;
}
case CardMod.StackingBehavior.stack: {
const existingModData = card.mods.find(x => x[0] === mod.modName);
if (existingModData) {
const existingStackingData = existingModData[1] as CardMod.RankedStackingData;
existingStackingData && (existingStackingData[2] += mod.stackingConfig.stackCount);
engine.broadcast.push({
type: 'modStackChanged',
cardId: card.id,
modData: existingModData,
stackDelta: mod.stackingConfig.stackCount,
newStackCount: existingStackingData[2],
});
this.trigger('onStackMod', existingModData, { engine, sourceCard: card, contextCard }, mod.stackingConfig.stackCount);
return;
}
card.mods.push(modData);
break;
}
}
engine.broadcast.push({
type: 'modAdded',
cardId: card.id,
modData,
});
this.trigger('onInitMod', modData, { engine, sourceCard: card, contextCard });
}
static areEqual(left: CardMod.ModData, right: CardMod.ModData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, modData: CardMod.ModData) {
const modCtor = engine.ruleset.cardMods?.[modData[0]];
if (!modCtor) throw new Error('mod not found: ' + modData.join());
const durationData = this.findDurationData(modData);
const mod = new modCtor(...modData.slice(durationData ? 3 : 2));
durationData && (mod.duration = durationData[1]);
const stackingData = modData[1];
mod.stackingConfig.behavior = stackingData[1];
switch (stackingData[1]) {
case CardMod.StackingBehavior.ranked:
(mod.stackingConfig as any).rank = stackingData[2];
break;
case CardMod.StackingBehavior.stack:
(mod.stackingConfig as any).stackCount = stackingData[2];
break;
}
return mod;
}
static findDurationData(modData: CardMod.ModData) {
const maybeDurationData = modData[2];
return (Array.isArray(maybeDurationData) && maybeDurationData[0] === '$duration') ? (modData[2] as CardMod.DurationData) : undefined;
}
static findModOfType(card: GameEngine.ICardState, modType: CardMod.ModConstructor) {
return card.mods.find(x => x[0] === modType.name);
}
static getStackCount(modData: CardMod.ModData) {
return modData[1][1] === CardMod.StackingBehavior.stack ? modData[1][2] : 0;
}
static makeDurationData(duration: number): CardMod.DurationData {
return ['$duration', duration];
}
static makeStackingData(
stackConfig: { behavior: CardMod.StackingBehavior.append }
| { behavior: CardMod.StackingBehavior.neverReplace }
| { behavior: CardMod.StackingBehavior.ranked, rank: number }
| { behavior: CardMod.StackingBehavior.replace }
| { behavior: CardMod.StackingBehavior.stack, stackCount: number }
) {
const stackingData = ['$stack', stackConfig.behavior];
(stackConfig.behavior === CardMod.StackingBehavior.ranked) && stackingData.push(stackConfig.rank);
(stackConfig.behavior === CardMod.StackingBehavior.stack) && stackingData.push(stackConfig.stackCount);
return stackingData as CardMod.StackingData;
}
static removeMod(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modData: CardMod.ModData, contextCard?: GameEngine.ICardState) {
engine.broadcast.push({
type: 'modRemoved',
cardId: card.id,
modData,
});
if (!card.mods.find(x => this.areEqual(x, modData))) {
throw new Error('mod not found');
}
this.trigger('onRemoveMod', modData, { engine, sourceCard: card, contextCard });
card.mods.findAndRemoveFirst(x => this.areEqual(x, modData));
}
static removeModByName<T extends CardMod.ModLibrary, K extends keyof T>(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, modName: K, contextCard?: GameEngine.ICardState) {
const mod = card.mods.find(x => x[0] === modName);
mod && this.removeMod(engine, card, mod, contextCard);
}
static trigger<T extends CardMod.ModEvent>(ev: T, modData: CardMod.ModData, ...args: Parameters<NonNullable<CardMod[typeof ev]>>) {
const deps = args[0];
const modDataFromCard = deps.sourceCard.mods.find(x => this.areEqual(x, modData));
if (!modDataFromCard) {
throw new Error(`card [${deps.sourceCard.id}] does not have mod [${modData.join()}], mods are ${deps.sourceCard.mods.join('|')}`);
}
const mod = this.deserialize(deps.engine, modDataFromCard);
const evnt = mod[ev];
const evntRetVal = evnt ? (evnt as any).apply(mod, args) : undefined;
if (deps.sourceCard.isRemoved) {
return;
}
if (ev === 'onTurnStart') {
const durationData = this.findDurationData(modDataFromCard);
if (durationData) {
if (durationData[1] > 1) {
durationData[1]--;
deps.engine.broadcast.push({
type: 'modDurationChanged',
cardId: deps.sourceCard.id,
modData: modData,
newDuration: durationData[1],
});
} else {
this.removeMod(deps.engine, deps.sourceCard, modData);
}
}
}
return evntRetVal as ReturnType<NonNullable<CardMod[T]>> | undefined;
}
}
export namespace CardMod {
export type ModData = [string, StackingData, ...unknown[],];
export type DurationData = ['$duration', number];
export type EnemyModData = unknown[];
export type ModConstructor = TypeConstructor<CardMod>;
export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;
export type ModLibrary = Record<string, ModConstructor>;
export type AppendStackingData = ['$stack', StackingBehavior.append];
export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];
export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];
export type ReplaceStackingData = ['$stack', StackingBehavior.replace];
export type StackStackingData = ['$stack', StackingBehavior.stack, number];
export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;
export enum StackingBehavior {
append,
neverReplace,
ranked,
replace,
stack,
}
export interface ICardModDeps {
engine: GameEngine.IGameEngine;
sourceCard: GameEngine.ICardState;
contextCard?: GameEngine.ICardState;
}
export namespace Content {
// Defines a card modifier - the class name is treated as the mod name
export class backdoor extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(public damage: number) {
// Any extra data to serialize into this.modData as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display modifier effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI modifiers,
// see _standardAi below for example
super(arguments);
this.stackingConfig.rank = damage;
}
}
export class diagnostics extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public secBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = secBonus;
}
override onTurnEnd(deps: ICardModDeps): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
}
export class firewall extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.ranked as const,
rank: 0,
};
constructor(override duration: number) {
super(arguments);
this.stackingConfig.rank = duration;
}
override onInitMod(deps: ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
return;
}
GameEngineUtils.revalidateIntents(deps.engine, true);
}
}
export class impervious extends CardMod {
constructor(override duration = -1) {
super(arguments);
}
override onSecDamageIn(_deps: ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return {
secDmgBonus: -9999,
};
}
}
export class lag extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class offline extends CardMod {
constructor(override duration: number) {
super(arguments);
}
override onInitMod(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
}
GameEngineUtils.revalidateIntents(deps.engine, GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard));
}
override onTurnStart(deps: CardMod.ICardModDeps) {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.clearIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, true);
}
}
override onRemoveMod(deps: ICardModDeps): void {
if (GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
} else {
GameEngineUtils.changeCardIsUsed(deps.engine, deps.sourceCard, false);
}
}
}
export class secured extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public tempSecBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = tempSecBonus;
}
override onInitMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, this.stackingConfig.stackCount, false);
}
override onStackMod(deps: ICardModDeps, stackDelta: number): void {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, stackDelta, false);
}
override onRemoveMod(deps: ICardModDeps) {
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -this.stackingConfig.stackCount, true);
}
}
export class _waveBonus_extraMove extends CardMod {
override onInitMod(deps: ICardModDeps): void {
const player = GameEngineUtils.findPlayerByCardId(deps.engine.gameData, deps.sourceCard.id);
player.movesPerTurn++;
player.movesLeft = player.movesPerTurn;
deps.engine.broadcast.push({
type: 'movesPerTurnsChange',
playerId: player.id,
newMovesLeft: player.movesLeft,
newMovesPerTurn: player.movesPerTurn,
});
}
}
export class _winOnDeath extends CardMod {
override onCardDestroyed(deps: ICardModDeps) {
const player = deps.contextCard ? GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, deps.contextCard.id) : null;
player && player.stats.kills++;
deps.engine.onWinGame();
player && player.stats.kills--;
}
}
export class _standardAi extends CardMod {
override onTurnStart(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard);
}
override onTurnEnd(deps: ICardModDeps) {
if (!GameEngineUtils.isEnemyCard(deps.engine.gameData, deps.sourceCard)) {
throw new Error('not an enemy card');
}
GameEngineUtils.executeIntent(deps.engine, deps.sourceCard);
}
}
export class _yieldScript extends CardMod {
constructor(
public scriptData: CardScript.ScriptData,
override duration: number,
) {
super(arguments);
}
override onRemoveMod(deps: ICardModDeps) {
CardScript.addScript(deps.engine, deps.sourceCard, this.scriptData);
}
}
export class _waveTrigger extends CardMod {
constructor(
public rulesetIds: string[],
override duration = -1,
) {
super(arguments);
}
override onInitMod(deps: ICardModDeps): void {
deps.engine.gameData.difficulty < 3 && GameEngineUtils.changeSec(deps.engine, deps.sourceCard, 25, true);
}
override onCardDestroyed(deps: ICardModDeps) {
deps.engine.onNextWave(this.rulesetIds.random());
deps.contextCard && CardMod.addMod(deps.engine, deps.contextCard, new _waveBonus_extraMove());
}
override onRemoveMod(deps: ICardModDeps): void {
CardMod.addMod(deps.engine, deps.sourceCard, new _winOnDeath());
}
}
}
}
|
src/game/card-mods.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " 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.8514981269836426
},
{
"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.8489831686019897
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": "import { clamp, round } from '../utils';\nimport { CardMod } from './card-mods';\nimport { CardScript } from './card-scripts';\nimport { GameEngine } from './game-engine';\nexport namespace GameEngineUtils {\n export function addEnemy(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, spawnIndex: number, generateIntent: boolean) {\n if (engine.gameData.enemies.length >= engine.gameData.maxEnemies) return;\n spawnIndex = clamp(spawnIndex, 0, engine.gameData.enemies.length);\n engine.gameData.enemies.splice(spawnIndex, 0, enemy);\n engine.broadcast.push({",
"score": 0.8475177884101868
},
{
"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.8404600620269775
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " goliath_boss_shield: class extends CardMod {\n override stackingConfig = {\n behavior: CardMod.StackingBehavior.stack as const,\n stackCount: 1,\n };\n },\n },\n enemyCards: {\n goliath_power_node: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {",
"score": 0.8383566737174988
}
] |
typescript
|
const existingModData = card.mods.find(x => x[0] === mod.modName);
|
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/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.8588489294052124
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " generateNewSecret: () => `${Math.random()}`,\n getAuthTokenForPlayer: player => player.secret,\n getPlayerFromRequest: async () => [...playersTable._db.values()][0]!,\n getPlayerIdFromRequest: () => [...playersTable._db.values()][0]?.id!,\n};\n// Note: replace with an actual push provider\nconst pushProvider: IPlayerPushProvider = {\n async push(playerId, messages) {\n console.log(`Push messages for player [${playerId}]:`);\n messages.forEach(x => console.log(x));",
"score": 0.8041735887527466
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " }\n return;\n }))).filter(Boolean).flat();\n await ds.execUpdates(\n ...playerUpdates,\n ds.CoopGames.update.make(game),\n );\n try {\n await gameEngineProvider.endGame(game.id);\n } catch {",
"score": 0.7974244356155396
},
{
"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.7973077297210693
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " game.startedAt = now.format(FULL_DATETIME_FORMAT);\n game._dbTtl = 9999999999;\n await ds.CoopGames.update.exec(game);\n metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);\n }\n async function _expectAuthPlayerInGame(req: IHttpRequest) {\n const player = await authProvider.getPlayerFromRequest(req);\n if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');\n const game = await ds.CoopGames.get(player.activeGameId);\n if (game) {",
"score": 0.791693389415741
}
] |
typescript
|
(req: IHttpRequest): Promise<IDataSource.IPlayer>;
|
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": "import dotenv from \"dotenv\";\nimport { GPT_3_5_TURBO } from \"../../openai\";\nimport { getPageSummary, getSearchResults } from \"./web\";\ndotenv.config();\ntest.skip(\n \"getPageSummary\",\n async () => {\n await getPageSummary(\n GPT_3_5_TURBO,\n // GPT_4,",
"score": 0.8329620957374573
},
{
"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.798318088054657
},
{
"filename": "src/openai.ts",
"retrieved_chunk": "import { AxiosError, AxiosRequestConfig } from \"axios\";\nimport { memoize } from \"lodash\";\nimport { Configuration, CreateChatCompletionRequest, OpenAIApi } from \"openai\";\nexport const GPT_3_5_TURBO = \"gpt-3.5-turbo\";\nexport const GPT_4 = \"gpt-4\";\nexport const contextWindowSize = {\n [GPT_3_5_TURBO]: 4000,\n [GPT_4]: 8000,\n};\nexport type Model = typeof GPT_3_5_TURBO | typeof GPT_4;",
"score": 0.7829496264457703
},
{
"filename": "src/parameters.ts",
"retrieved_chunk": "import { GPT_3_5_TURBO, GPT_4, Model } from \"./openai\";\nconst args = process.argv.slice(2); // Remove the first two elements (Node.js executable and script path)\nexport const numberOfAgents = args.length > 0 ? parseInt(args[0]) : 1;\nconsole.log(`Number of agents: ${numberOfAgents}`);\nconst modelText = args.length > 1 ? args[1] : \"gpt-3.5-turbo\";\nexport let model: Model;\nswitch (modelText) {\n case GPT_3_5_TURBO:\n case GPT_4:\n model = modelText;",
"score": 0.7816957235336304
},
{
"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.7813618183135986
}
] |
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/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.8489898443222046
},
{
"filename": "src/module/definitions/goals.ts",
"retrieved_chunk": " ]);\n sendMessage(messageBuilder.ok(agentId, \"Goal marked complete.\"));\n },\n },\n },\n});",
"score": 0.8374232053756714
},
{
"filename": "src/console.ts",
"retrieved_chunk": " if (colonIndex >= 0) {\n targetAgentIds = [input.substring(0, colonIndex)];\n content = input.substring(colonIndex + 1);\n } else {\n targetAgentIds = agentIds.filter((id) => id !== AGENT_ID);\n content = input;\n }\n if (content)\n messageBus.send(\n messageBuilder.agentToAgent(AGENT_ID, targetAgentIds, content)",
"score": 0.827991247177124
},
{
"filename": "src/message.ts",
"retrieved_chunk": "}\nfunction singleTargetSystemMessage(\n agentId: string,\n content: string\n): TypelessMessage {\n return {\n source: systemSource,\n targetAgentIds: [agentId],\n content,\n };",
"score": 0.8275505304336548
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": "sendMessage\ntargetAgentId: 0\nmessage:\n${MULTILINE_DELIMITER}\nhello, \"control\"\n${MULTILINE_DELIMITER}\n`);\n expect(action.actionDef.name).toBe(\"sendMessage\");\n expect(action.parameters).toEqual({\n targetAgentId: \"0\",",
"score": 0.8253718018531799
}
] |
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/game/game-engine.ts",
"retrieved_chunk": " rulesetIds: string[];\n }\n export interface IPlayerState {\n id: string;\n cards: IPlayerCardState[];\n endedTurn: boolean;\n idleKickTime: number;\n movesLeft: number;\n movesPerTurn: number;\n score: number;",
"score": 0.8685184717178345
},
{
"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.8678749799728394
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " },\n },\n CoopGames: {\n ...coopGamesTable,\n async queryByGameState(gameState) {\n return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };\n },\n },\n GameData: {\n ...createMockTableSingleKey<GameEngine.IGameData>('id'),",
"score": 0.8515583872795105
},
{
"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.843080997467041
},
{
"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.8399991989135742
}
] |
typescript
|
<GameEngine.IGameData>;
|
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
const gameData = await gameEngineProvider.getGameData(game.id);
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider.removePlayer(game.id, player.id, 'leave');
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
const rankings = await ds.Leaderboard.getTopN(20);
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort((a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
const gameData = await gameEngineProvider.startGame(game.id);
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game.gameState = `ended_${now.format
|
(DATE_FORMAT)}`;
|
game.endedAt = now.format(FULL_DATETIME_FORMAT);
let gameData: GameEngine.IGameData | undefined = undefined;
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
await gameEngineProvider.endGame(game.id);
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
}
|
src/apis/coop.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " }\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.8933541774749756
},
{
"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.8682749271392822
},
{
"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.849611759185791
},
{
"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.8470155000686646
},
{
"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.845292329788208
}
] |
typescript
|
(DATE_FORMAT)}`;
|
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/goals.ts",
"retrieved_chunk": " parameters: {\n goalNumber: {\n description: \"The number of the goal you want to mark as complete\",\n },\n },\n async execute({\n parameters: { goalNumber },\n context: { agentId, state },\n sendMessage,\n }) {",
"score": 0.8392312526702881
},
{
"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.8371855020523071
},
{
"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.8360223770141602
},
{
"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.8257701992988586
},
{
"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.8249029517173767
}
] |
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/messaging.ts",
"retrieved_chunk": " agentId,\n `You tried to send your message to an invalid targetAgentId (${JSON.stringify(\n targetAgentId\n )}). You can use the 'queryAgentRegistry' action to see a list of available agents and their agent IDs.`\n )\n );\n }\n },\n },\n },",
"score": 0.8313500285148621
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " } ${missingProps.map((p) => `\\`${p}\\``)}. ${getUsageText(actionDef)}`,\n };\n }\n const extraProps = Object.keys(parameters).filter(\n (p) => !(p in actionDef.parameters)\n );\n if (extraProps.length) {\n return {\n type: \"error\",\n message: `Extraneous parameter${",
"score": 0.8128374814987183
},
{
"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.8073909282684326
},
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " sendMessage: {\n description: \"Send a message to another agent\",\n parameters: {\n targetAgentId: {\n description: \"The target agent's ID\",\n },\n message: {\n description: \"The content of the message\",\n },\n },",
"score": 0.8070499897003174
},
{
"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.8006759881973267
}
] |
typescript
|
`Extraneous parameter \`foo\`. ${getUsageText(core.actions.noop)}`
);
|
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": " 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.8187344074249268
},
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " agentId,\n `You tried to send your message to an invalid targetAgentId (${JSON.stringify(\n targetAgentId\n )}). You can use the 'queryAgentRegistry' action to see a list of available agents and their agent IDs.`\n )\n );\n }\n },\n },\n },",
"score": 0.8101531267166138
},
{
"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.8038776516914368
},
{
"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.7984237670898438
},
{
"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.7960985898971558
}
] |
typescript
|
expect(action.actionDef.name).toBe("sendMessage");
|
import core from "./module/definitions/core";
import filesystem from "./module/definitions/filesystem";
import messaging from "./module/definitions/messaging";
import notes from "./module/definitions/notes";
import { ModuleManager } from "./module/module-manager";
import { getUsageText } from "./module/util";
import parseAction, { Action } from "./parse-action";
import { MULTILINE_DELIMITER } from "./util";
const moduleManager = new ModuleManager(
"1",
["1"],
[core, notes, messaging, filesystem]
);
test("case 1", () => {
assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
Hello Control, this is Agent 1.
I am sending you a multi-line message.
This is another line.
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("case 2", () => {
assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
Hello Control, this is Agent 1.
Here is a multi-line message:
This is the first line.
This is the second line.
This is the third line.
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("case 3", () => {
assertValid(`
writeFile
path: ./schema/action-dictionary.json
content:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
{
"$schema": "http://json-schema.org/draft-07/schema#",
"type": "object",
"title": "Action",
"oneOf": [
{
... the old content of action-dictionary.json ...
},
{
"title": "NewActionDefinition",
"description": "This is an example of a new action definition.",
"properties": {
"type": {
"type": "string",
"const": "new-action-definition"
},
"exampleArg": {
"type": "string",
"description": "An example parameter for the new action definition."
}
},
"required": [
"type",
"exampleArg"
],
"additionalProperties": false
}
]
}
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("invalid multiline with no delimiter", () => {
expect(
assertInvalid(`
sendMessage
targetAgentId: 0
message: Hello Control, here's a list of things,
- 9 bottles of ketchup
- 2 pairs of socks
- a very big balloon
`)
).toEqual(
`Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\`% ff9d7713-0bb0-40d4-823c-5a66de48761b\`)?`
);
});
test("multiline delimiter not starting on its own line", () => {
expect(
assertValid(`
sendMessage
targetAgentId: 0
message: % ff9d7713-0bb0-40d4-823c-5a66de48761b
here is a
multi
line
message
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`).parameters.message
).toBe(
`
here is a
multi
line
message
`.trim()
);
});
test("parameter after multiline parameter", () => {
const { parameters, thoughts } = assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
multi
line
parameter
% ff9d7713-0bb0-40d4-823c-5a66de48761b
thoughts: Trying a multi-line parameter followed by another parameter.
`);
expect(parameters.message).toBe(
`
multi
line
parameter
`.trim()
);
expect(thoughts).toBe(
"Trying a multi-line parameter followed by another parameter."
);
});
test("invalid command name", () => {
expect(assertInvalid("foo")).toBe(
"Unknown action `foo`. Please refer to the list of available actions given in the introductory message."
);
});
test("invalid raw text", () => {
expect(assertInvalid("Hello Control, how are you doing?")).toEqual(
`
Your action could not be parsed. Remember to always format your entire response as an action, like this:
\`\`\`
<action name>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
\`\`\`
`.trim()
);
});
test("missing required parameter", () => {
expect(assertInvalid("sendMessage\ntargetAgentId: 0")).toBe(
`Missing required parameter \`message\`. ${getUsageText(
messaging.actions.sendMessage
)}`
);
});
test("extra parameter", () => {
expect(assertInvalid("noop\nfoo: bar")).toEqual(
`Extraneous parameter \`foo\`. ${getUsageText(core.actions.noop)}`
);
});
describe("quotes", () => {
test("in-line parameter", () => {
const action = assertValid(`
sendMessage
targetAgentId: 0
message: hello, "control"
`);
expect(action.actionDef.name).toBe("sendMessage");
expect(action.parameters).toEqual({
targetAgentId: "0",
message: 'hello, "control"',
});
});
test("multi-line parameter", () => {
const action = assertValid(`
sendMessage
targetAgentId: 0
message:
${MULTILINE_DELIMITER}
hello, "control"
${MULTILINE_DELIMITER}
`);
expect(action.actionDef.name).toBe("sendMessage");
expect(action.parameters).toEqual({
targetAgentId: "0",
message: 'hello, "control"',
});
});
});
// =============================================================================
function assertValid(text: string): Action {
const result =
|
parseAction(moduleManager.actions, text);
|
if (result.type === "error") throw Error(`Parse failed: ${result.message}`);
return result.action;
}
function assertInvalid(text: string): string {
const result = parseAction(moduleManager.actions, text);
if (result.type === "success")
throw Error(
`Parse succeeded when it should've failed: ${JSON.stringify(
result.action,
null,
2
)}`
);
return result.message;
}
|
src/parse-action.test.ts
|
eumemic-ai-legion-4d145b3
|
[
{
"filename": "src/parse-action.ts",
"retrieved_chunk": "export interface Action {\n actionDef: ActionDefinition;\n thoughts?: string;\n parameters: Record<string, string>;\n}\nexport default function parseAction(\n actionDictionary: Map<string, ActionDefinition>,\n text: string\n): ParseResult {\n try {",
"score": 0.8324040174484253
},
{
"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.8124069571495056
},
{
"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.8098001480102539
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " text = text.trim();\n if (!/^\\S+(?=\\n|$)/.test(text.split(\"\\n\")[0])) {\n return {\n type: \"error\",\n message: `\nYour action could not be parsed. Remember to always format your entire response as an action, like this:\n${CODE_BLOCK_DELIMITER}\n<action name>\n<arg 1 name>: <prop value>\n<arg 2 name>: <prop value>",
"score": 0.8083266019821167
},
{
"filename": "src/main.ts",
"retrieved_chunk": " notes,\n messaging,\n filesystem,\n web,\n ]);\n const actionHandler = new ActionHandler(\n agentIds,\n messageBus,\n moduleManager\n );",
"score": 0.8083239793777466
}
] |
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.8869364261627197
},
{
"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.8826971054077148
},
{
"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.8712145090103149
},
{
"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.8634600043296814
},
{
"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.8581231236457825
}
] |
typescript
|
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
|
import { CODE_BLOCK_DELIMITER } from "./message";
import { ActionDefinition } from "./module/action-definition";
import { getUsageText } from "./module/util";
import { MULTILINE_DELIMITER } from "./util";
type ParseResult =
| {
type: "success";
action: Action;
}
| { type: "error"; message: string };
export interface Action {
actionDef: ActionDefinition;
thoughts?: string;
parameters: Record<string, string>;
}
export default function parseAction(
actionDictionary: Map<string, ActionDefinition>,
text: string
): ParseResult {
try {
text = text.trim();
if (!/^\S+(?=\n|$)/.test(text.split("\n")[0])) {
return {
type: "error",
message: `
Your action could not be parsed. Remember to always format your entire response as an action, like this:
${CODE_BLOCK_DELIMITER}
<action name>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
${CODE_BLOCK_DELIMITER}
`.trim(),
};
}
text = `name: ${text}`;
const jsonText =
"{" +
text
|
.split(MULTILINE_DELIMITER)
.map((part) => part.trim())
.map((part, i) => {
|
if (i % 2 === 0) return part;
return JSON.stringify(part) + "\n";
})
.join("")
.split("\n")
.filter(Boolean)
.map((line) => {
const colonIndex = line.indexOf(":");
if (colonIndex < 0)
throw new Error(
`Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\`${MULTILINE_DELIMITER}\`)?`
);
const key = line.substring(0, colonIndex).trim();
let value = line.substring(colonIndex + 1).trim();
if (!value.startsWith('"') || !value.endsWith('"'))
value = JSON.stringify(value);
return `"${key}": ${value}`;
})
.join(",") +
"}";
const { name, thoughts, ...parameters } = JSON.parse(jsonText);
const actionDef = actionDictionary.get(name);
if (!actionDef)
return {
type: "error",
message: `Unknown action \`${name}\`. Please refer to the list of available actions given in the introductory message.`,
};
const missingProps = Object.entries(actionDef.parameters)
.filter(
([name, parameterDef]) =>
!parameterDef.optional && !(name in parameters)
)
.map(([name]) => name);
if (missingProps.length) {
return {
type: "error",
message: `Missing required parameter${
missingProps.length > 1 ? "s" : ""
} ${missingProps.map((p) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
};
}
const extraProps = Object.keys(parameters).filter(
(p) => !(p in actionDef.parameters)
);
if (extraProps.length) {
return {
type: "error",
message: `Extraneous parameter${
extraProps.length > 1 ? "s" : ""
} ${extraProps.map((p) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
};
}
return { type: "success", action: { actionDef, thoughts, parameters } };
} catch (e: any) {
return {
type: "error",
message: e.message,
};
}
}
|
src/parse-action.ts
|
eumemic-ai-legion-4d145b3
|
[
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": "message\n% ff9d7713-0bb0-40d4-823c-5a66de48761b\n`).parameters.message\n ).toBe(\n `\nhere is a\nmulti\nline\nmessage\n`.trim()",
"score": 0.8050953149795532
},
{
"filename": "src/util.ts",
"retrieved_chunk": " return `${agentId === \"0\" ? \"Control\" : `Agent ${agentId}`}`;\n}\nexport const MULTILINE_DELIMITER = `% ${\"ff9d7713-0bb0-40d4-823c-5a66de48761b\"}`;\nexport const AVG_WORDS_PER_TOKEN = 0.75;\nexport const AVG_CHARACTERS_PER_TOKEN = 4;\nexport function countTokens(text: string) {\n return encode(text).length;\n}",
"score": 0.8001381158828735
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": "parameter\n% ff9d7713-0bb0-40d4-823c-5a66de48761b\nthoughts: Trying a multi-line parameter followed by another parameter.\n`);\n expect(parameters.message).toBe(\n `\nmulti\nline\nparameter\n`.trim()",
"score": 0.7952976226806641
},
{
"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.7859677672386169
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": " );\n});\ntest(\"parameter after multiline parameter\", () => {\n const { parameters, thoughts } = assertValid(`\nsendMessage\ntargetAgentId: 0\nmessage:\n% ff9d7713-0bb0-40d4-823c-5a66de48761b\nmulti\nline",
"score": 0.7848852872848511
}
] |
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/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.8425577878952026
},
{
"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.8416638374328613
},
{
"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.8402366638183594
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": "`.trim()\n );\n});\ntest(\"missing required parameter\", () => {\n expect(assertInvalid(\"sendMessage\\ntargetAgentId: 0\")).toBe(\n `Missing required parameter \\`message\\`. ${getUsageText(\n messaging.actions.sendMessage\n )}`\n );\n});",
"score": 0.828275203704834
},
{
"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.8053585886955261
}
] |
typescript
|
) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
};
|
import express from "express";
import { verify } from "jsonwebtoken";
import { requireAuth } from "../../middleware/auth";
import Tweet from "../../models/Tweet";
import User from "../../models/User";
import {
ICreateTweetBody,
IGenericFeatures,
IJwtDecoded,
} from "../../types/graphql";
import { IUser } from "../../types/guide";
import { formatDate } from "../../util/formatDate";
import { log } from "../../util/logging";
import { randInt } from "../../util/randUtil";
import { IUserMention } from "./user";
import { addNotification } from "../../util/notifications";
interface IUserTweetsVariables {
userId: string;
count: number;
includePromotedContent: boolean;
withQuickPromoteEligibilityTweetFields: boolean;
withVoice: boolean;
withV2Timeline: boolean;
}
interface IFavouriteTweetVariables {
tweet_id: string;
}
export async function UserTweets(req: express.Request, res: express.Response) {
const loggedInUser = req.cookies["jwt"]
? await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id,
})
: undefined;
const features = JSON.parse(
req.query.features!.toString()
) as IGenericFeatures;
const variables = JSON.parse(
req.query.variables!.toString()
) as IUserTweetsVariables;
if (!features || !variables)
return res.status(400).send({ msg: "Missing parameters" });
const user = await User.findOne({ id: variables.userId });
if (!user) return res.status(400).send({ msg: "User not found" });
const userTweets = [];
const postedTweets = Array.from(user.posted_tweet_ids);
for (const id of postedTweets) {
const tweet = await Tweet.findOne({ id_str: id });
userTweets.push({
is_translatable: false,
legacy: tweet
? Object.assign(tweet, {
favorited: loggedInUser
? loggedInUser.liked_tweet_ids.includes(tweet.id_str || "")
: false,
})
: tweet,
source: tweet?.source,
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
});
}
return res.status(200).send({
data: {
user: {
result: {
__typename: "User",
timeline_v2: {
timeline: {
instructions: [
{
type: "TimelineClearCache",
},
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified:
user.ext_is_blue_verified,
legacy: {
...(user as any)._doc,
},
profile_image_shape:
user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
},
},
});
}
export async function HomeTimeline(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const userId = req.cookies["jwt"]
? ((verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded)
.id as number)
: undefined;
const loggedInUser = await User.findOne({
id_string: userId,
});
if (!loggedInUser) return res.status(400).send({ msg: "Not authenticated" });
const userTweets = [];
const postedTweets = await Tweet.find().limit(50);
for (const tweet of postedTweets) {
const user = await User.findOne({ id_string: tweet.user_id_str });
if (!user) return res.status(400).send({ msg: "User not found" });
userTweets.push({
is_translatable: false,
legacy: Object.assign(tweet, {
favorited: loggedInUser.liked_tweet_ids.includes(tweet.id_str || ""),
}),
unmention_data: {},
unmention_info: {},
views: tweet.ext_views,
user: user,
});
}
return res.status(200).send({
data: {
home: {
home_timeline_urt: {
instructions: [
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
tweet.user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: tweet.user._id,
is_blue_verified:
tweet.user.ext_is_blue_verified,
legacy: {
...(tweet.user as any)._doc,
entities: {
user_mentions: (
tweet.legacy.entities
?.user_mentions as IUserMention[]
).map((mention) => {
return {
a: true,
};
}),
},
},
profile_image_shape:
tweet.user.ext_profile_image_shape,
rest_id: tweet.user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.legacy.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
});
}
export async function FavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (!user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids.push(variables.tweet_id);
tweet.favorite_count! += 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { favourte_tweet: "NOT DONE" } });
}
if (tweet.user_id_str !== user.id_string)
addNotification(
"%1 liked your tweet!",
"like",
tweet.user_id_str!,
user.id_string!,
tweet.id_str!
);
return res.status(200).send({ data: { favorite_tweet: "Done" } });
}
export async function UnfavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids = user.liked_tweet_ids.filter(
(id) => id !== variables.tweet_id
);
tweet.favorite_count! -= 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { unfavorite_tweet: "NOT DONE" } });
}
return res.status(200).send({ data: { unfavorite_tweet: "Done" } });
}
export async function CreateTweet(req: express.Request, res: express.Response) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const body = req.body as ICreateTweetBody;
const id = (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id as number;
const user = await User.findOne({ id });
if (!user) return res.status(400).send({ msg: "User not found" });
const user_mentions = [] as IUserMention[];
const matches = body.variables.tweet_text.matchAll(/@(\S+)/gm);
for (const match of matches) {
const withTag = match[0];
const withoutTag = match[1];
const user = await User.findOne({ screen_name: withoutTag });
user_mentions.push({
id_str: user?.id_string,
name: user?.name,
screen_name: user?.screen_name,
indices: [match.index, withTag.length + (match.index || 0)],
});
}
const tweetId = randInt(12);
const tweetData = {
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at
|
: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: {
|
hashtags: [],
symbols: [],
urls: [],
user_mentions,
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id: tweetId,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
source:
'<a href="https://mobile.twitter.com" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
};
const tweet = new Tweet({
bookmark_count: tweetData.legacy.bookmark_count,
bookmarked: tweetData.legacy.bookmarked,
conversation_id_str: tweetData.legacy.conversation_id_str,
created_at: tweetData.legacy.created_at,
display_text_range: tweetData.legacy.display_text_range,
entities: {
hashtags: tweetData.legacy.entities.hashtags,
symbols: tweetData.legacy.entities.symbols,
urls: tweetData.legacy.entities.urls,
user_mentions,
},
favorite_count: tweetData.legacy.favorite_count,
favorited: tweetData.legacy.favorited,
full_text: tweetData.legacy.full_text,
id_str: tweetData.legacy.id_str,
is_quote_status: tweetData.legacy.is_quote_status,
lang: tweetData.legacy.lang,
quote_count: tweetData.legacy.quote_count,
reply_count: tweetData.legacy.reply_count,
retweet_count: tweetData.legacy.retweet_count,
retweeted: tweetData.legacy.retweeted,
user_id_str: tweetData.legacy.user_id_str,
});
await tweet.save();
user.posted_tweet_ids.push(tweetId.toString());
await user.save();
log(`${user.name} (@${user.screen_name}) just posted a tweet:`);
log(`"${tweet.full_text}"`);
// addNotification(
// "%1 just posted a tweet!",
// "reply",
// user.id_string!,
// user.id_string!,
// tweet.id_str!
// );
return res.status(200).send({
// data: {
// create_tweet: {
// tweet_results: {
// result: {
// core: {
// user_results: {
// result: {
// __typename: "User",
// affiliates_highlighted_label:
// user.ext?.highlightedLabel?.r?.ok,
// business_account: {},
// id: user._id,
// is_blue_verified: user.ext_is_blue_verified,
// legacy: {
// created_at: user.created_at,
// default_profile: user.default_profile,
// default_profile_image: user.default_profile_image,
// description: user.description,
// entities: user.entities,
// fast_followers_count: user.fast_followers_count,
// favourites_count: user.favourites_count,
// followers_count: user.followers_count,
// friends_count: user.friends_count,
// has_custom_timelines: user.has_custom_timelines,
// is_translator: user.is_translator,
// listed_count: user.listed_count,
// location: user.location,
// media_count: user.media_count,
// name: user.name,
// normal_followers_count: user.normal_followers_count,
// pinned_tweet_ids_str: user.pinned_tweet_ids_str,
// possibly_sensitive: false,
// profile_image_url_https: user.profile_image_url_https,
// profile_interstitial_type: "",
// screen_name: user.screen_name,
// statuses_count: user.statuses_count,
// translator_type: user.translator_type,
// verified: user.verified,
// withheld_in_countries: user.withheld_in_countries,
// },
// profile_image_shape: user.ext_profile_image_shape,
// rest_id: user.id,
// },
// },
// },
// ...tweetData,
// },
// },
// },
// },
data: {
create_tweet: {
tweet_results: {
result: {
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified: user.ext_is_blue_verified,
legacy: {
created_at: user.created_at,
default_profile: user.default_profile,
default_profile_image: user.default_profile_image,
description: user.description,
entities: user.entities,
fast_followers_count: user.fast_followers_count,
favourites_count: user.favourites_count,
followers_count: user.followers_count,
friends_count: user.friends_count,
has_custom_timelines: user.has_custom_timelines,
is_translator: user.is_translator,
listed_count: user.listed_count,
location: user.location,
media_count: user.media_count,
name: user.name,
normal_followers_count: user.normal_followers_count,
pinned_tweet_ids_str: user.pinned_tweet_ids_str,
possibly_sensitive: false,
profile_image_url_https: user.profile_image_url_https,
profile_interstitial_type: "",
screen_name: user.screen_name,
statuses_count: user.statuses_count,
translator_type: user.translator_type,
verified: user.verified,
withheld_in_countries: user.withheld_in_countries,
},
profile_image_shape: user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_control: {
edit_tweet_ids: [tweetId.toString()],
editable_until_msecs: "1682984834000",
edits_remaining: "5",
is_edit_eligible: true,
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, 68],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions: (
tweet.entities!.user_mentions as Array<Array<IUserMention>>
).map((mention) => mention[0]),
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
rest_id: tweetId.toString(),
source:
'<a href="https://github.com/" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Disabled",
},
},
},
},
},
});
}
|
src/routes/gql/tweet.ts
|
not-nullptr-blue-3b2284a
|
[
{
"filename": "src/models/Tweet.ts",
"retrieved_chunk": "\t},\n\tcreated_at: {\n\t\ttype: \"String\",\n\t},\n\tdisplay_text_range: {\n\t\ttype: [\"Number\"],\n\t},\n\tentities: {\n\t\thashtags: {\n\t\t\ttype: \"Array\",",
"score": 0.8482168912887573
},
{
"filename": "src/models/Tweet.ts",
"retrieved_chunk": "\t\t\t\t\t\teditTweetIds: {\n\t\t\t\t\t\t\ttype: [\"String\"],\n\t\t\t\t\t\t},\n\t\t\t\t\t\teditableUntilMsecs: {\n\t\t\t\t\t\t\ttype: \"String\",\n\t\t\t\t\t\t},\n\t\t\t\t\t\teditsRemaining: {\n\t\t\t\t\t\t\ttype: \"Date\",\n\t\t\t\t\t\t},\n\t\t\t\t\t\tisEditEligible: {",
"score": 0.8469164371490479
},
{
"filename": "src/routes/1.1/onboarding/task.ts",
"retrieved_chunk": "\t\t\t\t\t\tfollowers_count: 0,\n\t\t\t\t\t\tfast_followers_count: 0,\n\t\t\t\t\t\tnormal_followers_count: 0,\n\t\t\t\t\t\tfriends_count: 0,\n\t\t\t\t\t\tlisted_count: 0,\n\t\t\t\t\t\tcreated_at: formatDate(new Date()),\n\t\t\t\t\t\tfavourites_count: 0,\n\t\t\t\t\t\tutc_offset: null,\n\t\t\t\t\t\ttime_zone: null,\n\t\t\t\t\t\tgeo_enabled: false,",
"score": 0.842552900314331
},
{
"filename": "src/models/Notification.ts",
"retrieved_chunk": "\t\tentities: [],\n\t\trtl: Boolean,\n\t},\n\ttemplate: {\n\t\taggregateUserActionsV1: {\n\t\t\ttargetObjects: [\n\t\t\t\t{\n\t\t\t\t\ttweet: {\n\t\t\t\t\t\tid: String,\n\t\t\t\t\t},",
"score": 0.8424415588378906
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\terrors: {},\n\t\t\t\tfetchStatus: {},\n\t\t\t},\n\t\t\ttranslationsTweets: {\n\t\t\t\tentities: {},\n\t\t\t\terrors: {},\n\t\t\t\tfetchStatus: {},\n\t\t\t},\n\t\t\tbookmarkFolders: {\n\t\t\t\tentities: {},",
"score": 0.8373143672943115
}
] |
typescript
|
: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: {
|
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.8998025059700012
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " const script = CardScript.deserialize(engine, enemy, scriptData);\n const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();\n if (!target) {\n return;\n }\n enemy.intent = {\n scriptData,\n targetCardId: target.id,\n };\n engine.broadcast.push({",
"score": 0.8924592137336731
},
{
"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.8865079283714294
},
{
"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.8705383539199829
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " })));\n if (isEnemyCard(engine.gameData, card) && card.intent?.scriptData) {\n card.intent.scriptData = CardScript.deserialize(engine, card, card.intent.scriptData).serialize();\n engine.broadcast.push({\n type: 'cardIntent',\n cardId: card.id,\n intent: card.intent,\n });\n }\n }",
"score": 0.8664915561676025
}
] |
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": " 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.8419291973114014
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " super(\n [],\n (gameData, card) =>\n CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.ChangeCpu(-1),\n CardScriptParts.RaiseMem(1),",
"score": 0.8331849575042725
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " export type ModEvent = KeyOfFilteredByValueType<CardMod, ((deps: ICardModDeps, ...args: any) => any) | undefined> & StringsStartingWith<keyof CardMod, 'on'>;\n export type ModLibrary = Record<string, ModConstructor>;\n export type AppendStackingData = ['$stack', StackingBehavior.append];\n export type NeverReplaceStackingData = ['$stack', StackingBehavior.neverReplace];\n export type RankedStackingData = ['$stack', StackingBehavior.ranked, number];\n export type ReplaceStackingData = ['$stack', StackingBehavior.replace];\n export type StackStackingData = ['$stack', StackingBehavior.stack, number];\n export type StackingData = AppendStackingData | NeverReplaceStackingData | RankedStackingData | ReplaceStackingData | StackStackingData;\n export enum StackingBehavior {\n append,",
"score": 0.8326306343078613
},
{
"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.8319120407104492
},
{
"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.8310142755508423
}
] |
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-content-v1.ts",
"retrieved_chunk": " const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);\n const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);\n super(\n [minBonus, maxBonus],\n CardScript.TargetFinders.Self,\n [\n {\n targetResolver: CardScript.TargetResolvers.RandomAlly,\n parts: [\n CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),",
"score": 0.8873834609985352
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " [secBonus],\n TargetFinders.Any(),\n [\n {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseSec(secBonus),\n ],\n }\n ],",
"score": 0.8767068386077881
},
{
"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.8734447360038757
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " const script = CardScript.deserialize(engine, enemy, scriptData);\n const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();\n if (!target) {\n return;\n }\n enemy.intent = {\n scriptData,\n targetCardId: target.id,\n };\n engine.broadcast.push({",
"score": 0.8682346343994141
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n CardScriptParts.SecDmg(secDelta),\n CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),\n CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),\n ],\n },\n {\n targetResolver: CardScript.TargetResolvers.Self,\n parts: [\n CardScriptParts.RaiseSec(secDelta),",
"score": 0.8657262325286865
}
] |
typescript
|
script = CardScript.deserialize(engine, targetCard, targetCard.intent.scriptData);
|
import { CoreScriptNames } from '../appraise';
import { IPlayerPushProvider } from '../dependencies';
import { randInt, round } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
export class CardScript {
cooldownMax = -1;
cooldownCur = 0;
readonly scriptName: string;
constructor(
private _extraScriptData: unknown[],
public targetFinder: CardScript.ITargetFinder,
public targetScriptParts: { targetResolver: CardScript.ITargetResolver, parts: CardScriptParts.IScriptPart[] }[],
) {
this.scriptName = this.constructor.name;
}
serialize() {
const retVal = [this.scriptName, ...this._extraScriptData] as CardScript.ScriptData;
(this.cooldownCur > 0 || this.cooldownMax > 0) && retVal.push(CardScript.makeCooldownData(this.cooldownMax, this.cooldownCur));
return retVal;
}
static addScript(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptData: CardScript.ScriptData) {
card.scripts.push(scriptData);
engine.broadcast.push({
type: 'scriptAdded',
cardId: card.id,
scriptData,
});
}
static areEqual(left: CardScript.ScriptData, right: CardScript.ScriptData) {
// Caveat: could collide since join() flattens array but highly unlikely
return left.join('') === right.join('');
}
static deserialize(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptData: CardScript.ScriptData) {
const scriptCtor = engine.ruleset.cardScripts?.[scriptData[0]];
if (!scriptCtor) throw new Error('script not found: ' + scriptData.join());
const script = new scriptCtor(card, ...scriptData.slice(1));
const cooldownData = CardScript.findCooldownData(scriptData);
if (cooldownData) {
script.cooldownCur = cooldownData[1];
script.cooldownMax = cooldownData[2];
}
return script;
}
static execute(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, sourceCardScript: CardScript.ScriptData, targetCard: GameEngine.ICardState) {
engine.broadcast.push({
type: 'cardExecuting',
cardId: sourceCard.id,
targetCardId: targetCard.id,
scriptData: sourceCardScript,
});
if (this.isOnCooldown(sourceCardScript)) {
throw new Error('Script is on cooldown: ' + sourceCardScript.join());
}
const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript));
const isEnemy = GameEngineUtils.isEnemyCard(engine.gameData, sourceCard);
if (!isEnemy) {
if (!scriptDataFromCard) {
throw new Error('PlayerCard does not have script: ' + sourceCardScript.join());
}
}
const cooldownData = CardScript.findCooldownData(scriptDataFromCard || sourceCardScript);
if (cooldownData) {
cooldownData[1] = cooldownData[2] + 1;
}
const script = this.deserialize(engine, sourceCard, sourceCardScript);
const targets = script.targetFinder(engine.gameData, sourceCard);
if (!isEnemy && (!targets.length || !targets.find(x => x.id === targetCard.id))) {
throw new Error('Invalid target ' + targets.map(x => x.id).join());
}
for (const pair of script.targetScriptParts) {
const resolvedTargets = pair.targetResolver(engine.gameData, sourceCard, targetCard);
for (const part of pair.parts) {
for (const resolvedTarget of resolvedTargets) {
if (resolvedTarget.isRemoved) continue;
part(engine, sourceCard, resolvedTarget);
}
}
}
engine.broadcast.push({
type: 'cardExecuted',
cardId: sourceCard.id,
targetCardId: targetCard.id,
scriptData: scriptDataFromCard || sourceCardScript,
});
}
static findCooldownData(data: CardScript.ScriptData) {
return data.find((x): x is CardScript.CooldownData => Array.isArray(x) && x[0] === '$cooldown');
}
static fromScriptName(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptName: string) {
return this.deserialize(engine, card, [scriptName]).serialize();
}
static isOnCooldown(data: CardScript.ScriptData) {
return (this.findCooldownData(data)?.[1] || 0) > 0;
}
static makeCooldownData(max: number, cur = 0): CardScript.CooldownData {
return ['$cooldown', cur, max];
}
static removeScript(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptType: CardScript.ScriptConstructor) {
const removed = card.scripts.findAndRemoveFirst(x => x[0] === scriptType.name);
if (!removed) throw new Error('script not found: ' + scriptType.name);
engine.broadcast.push({
type: 'scriptRemoved',
cardId: card.id,
removedScript: scriptType.name,
});
}
static tickCooldowns(card: GameEngine.ICardState, broadcast: IPlayerPushProvider.IPushMessage[]) {
for (const script of card.scripts) {
const cooldownData = CardScript.findCooldownData(script);
if (!cooldownData?.[1]) {
continue;
}
cooldownData[1]--;
broadcast.push({
type: 'scriptChanged',
cardId: card.id,
scriptData: script,
});
}
}
}
export namespace CardScript {
export type ScriptData = [string, ...unknown[]];
export type CooldownData = ['$cooldown', number, number];
export type ScriptConstructor = { new(card: GameEngine.ICardState, ...args: any[]): CardScript };
export type ScriptLibrary = Record<string, ScriptConstructor>;
export interface ITargetResolver {
(gameData: GameEngine.IGameData, sourceCard: GameEngine.ICardState, targetCard: GameEngine.ICardState): GameEngine.ICardState[];
}
export interface ITargetFinder {
(gameData: GameEngine.IGameData, card: GameEngine.ICardState): GameEngine.ICardState[];
}
export namespace TargetResolvers {
export const Self: ITargetResolver = (_, sourceCard) => [sourceCard];
export const Target: ITargetResolver = (_, _2, targetCard) => [targetCard];
export const TargetAndAdjacents: ITargetResolver = (gameData, _, targetCard) => {
const cards = GameEngineUtils.isEnemyCard(gameData, targetCard) ? gameData.enemies : (GameEngineUtils.findPlayerByCardId(gameData, targetCard.id).cards);
const i = cards.findIndex(x => x.id === targetCard.id);
return [cards[i], cards[i - 1], cards[i + 1]].filter(Boolean);
};
export const AllAllies: ITargetResolver = (gameData, sourceCard) => {
if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {
return TargetFinders._excludeOffline(gameData.enemies);
} else {
return TargetFinders._excludeOffline(GameEngineUtils.getPlayerCards(gameData));
}
};
export const RandomAlly: ITargetResolver = (gameData, sourceCard, targetCard) => {
return [AllAllies(gameData, sourceCard, targetCard).random()];
};
export const AllOpponents: ITargetResolver = (gameData, sourceCard) => {
if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {
return TargetFinders._excludeImperviousAndOffline(GameEngineUtils.getPlayerCards(gameData));
} else {
return TargetFinders._excludeImperviousAndOffline(gameData.enemies);
}
};
export const RandomOpponent: ITargetResolver = (gameData, sourceCard, targetCard) => {
return TargetFinders._excludeImperviousAndOffline([AllOpponents(gameData, sourceCard, targetCard).random()]);
};
}
export namespace TargetFinders {
export const Self: ITargetFinder = (_gameData, card) => [card];
export const Allies = (excludeSelf = false): ITargetFinder =>
(gameData, card) => {
let targets: GameEngine.ICardState[] = GameEngineUtils.isEnemyCard(gameData, card) ? gameData.enemies : GameEngineUtils.getPlayerCards(gameData);
excludeSelf && (targets = targets.filter(x => x.id !== card.id));
return _excludeOffline(targets);
};
export const Opponents = (ignoreTaunt = false): ITargetFinder =>
(gameData, card) => {
const targets = GameEngineUtils.isEnemyCard(gameData, card) ? GameEngineUtils.getPlayerCards(gameData) : gameData.enemies;
const standardTargets = _excludeImperviousAndOffline(targets);
if (!ignoreTaunt) {
const taunts = _filterForFirewall(standardTargets);
if (taunts.length) {
return taunts;
}
}
return standardTargets;
};
export const Any = (ignoreTaunt = false): ITargetFinder =>
(gameData, card) => [
...Opponents(ignoreTaunt)(gameData, card),
...Allies()(gameData, card),
];
export const _ModFilter = <T extends CardMod.ModLibrary, K extends (keyof T & string)>(modFilter: K[], targetFinder: ITargetFinder): ITargetFinder =>
(gameData, card) => {
const targets = targetFinder(gameData, card);
const modMatches = targets.filter(target => target.mods.find(modData => modFilter.find(x => x === modData[0])));
return _excludeImperviousAndOffline(modMatches);
};
const _excludeImpervious = (cards: GameEngine.ICardState[]) => {
return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.impervious.name));
};
export const _excludeOffline = (cards: GameEngine.ICardState[]) => {
return cards.filter(x => !x.mods.find(y => y[0] === CardMod.Content.offline.name));
};
export const _excludeImperviousAndOffline = (cards: GameEngine.ICardState[]) => _excludeImpervious(_excludeOffline(cards));
const _filterForFirewall = (cards: GameEngine.ICardState[]) => {
return cards.filter(x => x.mods.find(y => y[0] === CardMod.Content.firewall.name));
};
}
export namespace Content {
// Defines a card script - the class name is treated as the script name
export class bd_decode extends CardScript {
constructor(
// MUST always be the first parameter even if not used
card: GameEngine.ICardState,
// Not used but declared to show how the memo is passed back here, see first argument in super(...) below
_secDamage: number,
) {
const secDamage = GameEngineUtils.scaleByCpuMem(12, card.cpu);
|
const bdChance = round(GameEngineUtils.scaleByCpuMem(20, card.mem, 'high') / 100, 2);
|
const bdDamage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
// Any extra data to serialize into scriptData[1:] as a 'memo' which can serve two purposes:
// 1) the client relies on the memo to display potential card effects in the UI instead calculating it independently
// 2) memo is passed back into the constructor during deserialization, useful for dynamic AI scripts
[secDamage, bdChance, bdDamage],
// Which cards are valid targets for this card; AI will typically .random()
TargetFinders.Opponents(),
// A composition of CardScriptParts that get executed when this card is played; this allows for
// composition effects such as "((damage and debuff) to target) AND (chance to stun neighbors)":
// The first part would use the Target resolver and Attack and ApplyMod parts
// The second part would use the Neighbors resolver and curry Stun part into _Chance part
[
{
// Given a chosen target, which actual targets these parts will execute on; this allows
// a card to, for example, deal damage to the neighbors of the specified target
targetResolver: TargetResolvers.Target,
// CardScriptParts to execute on the resolved targets
parts: [
CardScriptParts.SecDmg(secDamage),
CardScriptParts._Chance(bdChance,
CardScriptParts.AddMod(
new CardMod.Content.backdoor(bdDamage),
)
),
],
}
],
);
}
}
export class bd_exploit extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const bdChance = round(GameEngineUtils.scaleByCpuMem(40, card.mem, 'more') / 100, 2);
super(
[damage, bdChance],
(gameData: GameEngine.IGameData, card: GameEngine.ICardState) => [
...TargetFinders.Opponents()(gameData, card),
...TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
TargetFinders.Opponents(true))(gameData, card),
],
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts._TargetHasMod<typeof CardMod.Content, 'backdoor'>('backdoor', mod => CardScriptParts.SecDmg(mod.stackingConfig.rank, true)),
CardScriptParts.Attack(damage),
CardScriptParts._Chance(bdChance,
CardScriptParts.AddMod(
new CardMod.Content.backdoor(damage),
)
),
],
}
],
);
}
}
export class bd_secure extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
TargetFinders.Any(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 1;
}
}
export class bf_spam extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[damage],
TargetFinders.Opponents(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.Attack(damage),
],
}
]
);
}
}
export class bf_firewall extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const modDuration = Math.ceil(card.mem / 2);
super(
[secBonus, modDuration],
TargetFinders.Self,
[
{
targetResolver: TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secBonus),
CardScriptParts.AddMod(
new CardMod.Content.firewall(modDuration),
),
],
}
],
);
this.cooldownMax = 1;
}
}
export class bf_overclock extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(17, card.cpu);
const lagChance = round((100 - GameEngineUtils.scaleByCpuMem(30, card.mem)) / 100, 2);
const lagDuration = 2;
super(
[damage, lagChance, lagDuration],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts._Chance(lagChance,
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
),
],
}
],
);
}
}
export class mw_freeware extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(12, card.cpu, 'more');
super(
[minBonus, maxBonus],
TargetFinders.Any(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 1;
}
}
export class mw_redirect extends CardScript {
constructor(card: GameEngine.ICardState) {
const tempSecBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const duration = Math.ceil(card.mem / 2);
super(
[tempSecBonus, duration],
TargetFinders.Allies(true),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.secured(tempSecBonus, duration),
),
CardScriptParts.AddMod(
new CardMod.Content.firewall(duration),
),
],
}
],
);
this.cooldownMax = 1;
}
}
export class mw_worm extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(7, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(13, card.cpu);
super(
[minDamage, maxDamage],
TargetFinders.Opponents(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
}
}
export class _attack extends CardScript {
constructor(card: GameEngine.ICardState, difficulty: number, strength: 'weak' | 'normal' | 'strong' = 'normal', cooldown = 0) {
let minDmg = 0;
let maxDmg = 0;
switch (strength) {
case 'weak':
minDmg = GameEngineUtils.scaleByCpuMem(6, card.cpu);
maxDmg = GameEngineUtils.scaleByCpuMem(8, card.cpu);
break;
case 'normal':
minDmg = GameEngineUtils.scaleByCpuMem(8, card.cpu);
maxDmg = GameEngineUtils.scaleByCpuMem(12, card.cpu);
break;
case 'strong':
minDmg = GameEngineUtils.scaleByCpuMem(11, card.cpu);
maxDmg = GameEngineUtils.scaleByCpuMem(15, card.cpu);
break;
}
minDmg = GameEngineUtils.scaleByDifficulty(minDmg, difficulty);
maxDmg = GameEngineUtils.scaleByDifficulty(maxDmg, difficulty);
super(
[difficulty, strength, cooldown, minDmg, maxDmg],
TargetFinders.Opponents(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.Attack(randInt(minDmg, maxDmg)),
],
}
],
);
this.cooldownMax = cooldown;
}
}
export class _defend extends CardScript {
constructor(card: GameEngine.ICardState, difficulty: number, strength: 'weak' | 'normal' | 'strong' = 'normal', cooldown = 0) {
let minBonus = 0;
let maxBonus = 0;
switch (strength) {
case 'weak':
minBonus = GameEngineUtils.scaleByCpuMem(4, card.cpu);
maxBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
break;
case 'normal':
minBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
maxBonus = GameEngineUtils.scaleByCpuMem(8, card.cpu);
break;
case 'strong':
minBonus = GameEngineUtils.scaleByCpuMem(8, card.cpu);
maxBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
break;
}
minBonus = GameEngineUtils.scaleByDifficulty(minBonus, difficulty);
maxBonus = GameEngineUtils.scaleByDifficulty(maxBonus, difficulty);
super(
[difficulty, strength, cooldown, minBonus, maxBonus],
TargetFinders.Allies(),
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = cooldown;
}
}
export class _firewallSelf extends CardScript {
constructor(_card: GameEngine.ICardState, duration = 1, cooldown = 0, startingCooldown = 0) {
super(
[duration, cooldown],
TargetFinders.Self,
[
{
targetResolver: TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.firewall(duration + 1),
),
],
}
],
);
this.cooldownCur = startingCooldown;
this.cooldownMax = cooldown;
}
}
export class _spawn extends CardScript {
constructor(_card: GameEngine.ICardState, enemyClass: string, spawnPosition: Parameters<typeof CardScriptParts['SpawnEnemy']>[1] = 'relLeft', generateIntent = false, cooldown = 0) {
super(
[enemyClass, spawnPosition, generateIntent, cooldown],
TargetFinders.Self,
[
{
targetResolver: TargetResolvers.Self,
parts: [
CardScriptParts.SpawnEnemy(enemyClass, spawnPosition, generateIntent),
],
}
],
);
this.cooldownMax = cooldown;
}
}
}
(Content as Record<CoreScriptNames, ScriptConstructor>);
}
|
src/game/card-scripts.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " bd_patch: class extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const secBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);\n super(\n [secBonus],\n CardScript.TargetFinders.Any(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [",
"score": 0.9005008339881897
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " },\n};\nconst _cardScripts = {\n //\n // Backdoor scripts\n //\n // Swap MEM for CPU\n bd_caching: class extends CardScript {\n constructor(_card: GameEngine.ICardState) {\n super(",
"score": 0.8887919187545776
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " bf_feedback: class extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const damage = GameEngineUtils.scaleByCpuMem(10, card.cpu);\n const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));\n super(\n [damage, cooldown],\n CardScript.TargetFinders.Self,\n [\n {\n targetResolver: CardScript.TargetResolvers.Self,",
"score": 0.8879709243774414
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " // Raise SEC\n bf_obfuscate: class extends CardScript {\n constructor(card: GameEngine.ICardState) {\n const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);\n super(\n [secBonus],\n CardScript.TargetFinders.Any(),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,",
"score": 0.8862123489379883
},
{
"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.8855006694793701
}
] |
typescript
|
const bdChance = round(GameEngineUtils.scaleByCpuMem(20, card.mem, 'high') / 100, 2);
|
import { CardMod } from '../card-mods';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
const GOLIATH_ID = 9999;
export const RulesetGoliath = {
cardMods: {
goliath_power_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_power(), deps.sourceCard);
}
},
goliath_shield_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_shield(), deps.sourceCard);
}
},
goliath_boss_ai: class extends CardMod {
override onTurnStart(deps: CardMod.ICardModDeps) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard as GameEngine.IEnemyCardState);
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
const targetId = boss.intent?.targetCardId;
if (!targetId) return;
let numAttacks = 1;
const powerBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_power);
if (powerBuff) {
const powerStacks = CardMod.getStackCount(powerBuff);
numAttacks += powerStacks;
}
for (let i = 0; i < numAttacks - 1; i++) {
GameEngineUtils.executeIntent(deps.engine, boss, true);
}
GameEngineUtils.executeIntent(deps.engine, boss);
}
override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {
if (deps.sourceCard.mem - memDmg <= 0) return;
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
let secBonus = 100;
const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);
if (shieldBuff) {
secBonus += CardMod.getStackCount(shieldBuff) * 100;
}
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);
for (const enemy of [...deps.engine.gameData.enemies]) {
if (enemy === boss) continue;
|
CardMod.addMod(deps.engine, enemy, new GameContent_v1.cardMods.optimized(1, -1), boss);
|
}
}
},
goliath_boss_power: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
},
goliath_boss_shield: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
},
},
enemyCards: {
goliath_power_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 2,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_power_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),
);
return enemy;
},
goliath_shield_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_shield_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._defend(enemy, engine.gameData.difficulty, 'weak').serialize(),
new CardScript.Content._firewallSelf(enemy, 1, 2).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: GOLIATH_ID,
enemyClass: 'goliath_boss',
cpu: 2,
mem: 4,
maxMem: 4,
sec: GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
mods: [
new RulesetGoliath.cardMods.goliath_boss_ai().serialize(),
new CardMod.Content._winOnDeath().serialize(),
],
scripts: [],
};
boss.scripts.push(
new CardScript.Content._attack(boss, engine.gameData.difficulty).serialize(),
);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
},
};
|
src/game/rulesets/goliath.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {\n CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);\n }\n GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);\n if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {\n GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n }\n }\n },\n },",
"score": 0.9090642333030701
},
{
"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.8939799666404724
},
{
"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.8817428350448608
},
{
"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.8808597326278687
},
{
"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.8805906772613525
}
] |
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": " const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);\n const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);\n super(\n [minBonus, maxBonus],\n CardScript.TargetFinders.Self,\n [\n {\n targetResolver: CardScript.TargetResolvers.RandomAlly,\n parts: [\n CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),",
"score": 0.8926287889480591
},
{
"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.8837975263595581
},
{
"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.8619191646575928
},
{
"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.858385443687439
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " {\n targetResolver: CardScript.TargetResolvers.RandomOpponent,\n parts: [\n CardScriptParts.Attack(randInt(minDamage, maxDamage)),\n ],\n }\n ],\n );\n this.cooldownMax = 1;\n }",
"score": 0.8508313894271851
}
] |
typescript
|
.RaiseSec(randInt(minBonus, maxBonus)),
],
}
|
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": " 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.8831894397735596
},
{
"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.882306694984436
},
{
"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.8811862468719482
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n CardScriptParts.SecDmg(secDelta),\n CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),\n CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),\n ],\n },\n {\n targetResolver: CardScript.TargetResolvers.Self,\n parts: [\n CardScriptParts.RaiseSec(secDelta),",
"score": 0.878645658493042
},
{
"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.8753993511199951
}
] |
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/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.8811020851135254
},
{
"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.8789592385292053
},
{
"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.8645086288452148
},
{
"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.8639425039291382
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " };\n export const _excludeImperviousAndOffline = (cards: GameEngine.ICardState[]) => _excludeImpervious(_excludeOffline(cards));\n const _filterForFirewall = (cards: GameEngine.ICardState[]) => {\n return cards.filter(x => x.mods.find(y => y[0] === CardMod.Content.firewall.name));\n };\n }\n export namespace Content {\n // Defines a card script - the class name is treated as the script name\n export class bd_decode extends CardScript {\n constructor(",
"score": 0.863892138004303
}
] |
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/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.8349191546440125
},
{
"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.8342475891113281
},
{
"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.8306320905685425
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " if (cooldownData) {\n script.cooldownCur = cooldownData[1];\n script.cooldownMax = cooldownData[2];\n }\n return script;\n }\n static execute(engine: GameEngine.IGameEngine, sourceCard: GameEngine.ICardState, sourceCardScript: CardScript.ScriptData, targetCard: GameEngine.ICardState) {\n engine.broadcast.push({\n type: 'cardExecuting',\n cardId: sourceCard.id,",
"score": 0.8201672434806824
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n (engine, _sourceCard, targetCard) => {\n const totalStats = targetCard.cpu + targetCard.mem;\n const newCpu = randInt(1, totalStats - 1);\n const cpuDelta = newCpu - targetCard.cpu;\n GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);\n const newMem = totalStats - newCpu;\n const memDelta = newMem - targetCard.mem;\n GameEngineUtils.changeMem(engine, targetCard, memDelta);\n },",
"score": 0.8170665502548218
}
] |
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-utils.ts",
"retrieved_chunk": " const script = CardScript.deserialize(engine, enemy, scriptData);\n const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();\n if (!target) {\n return;\n }\n enemy.intent = {\n scriptData,\n targetCardId: target.id,\n };\n engine.broadcast.push({",
"score": 0.8999713659286499
},
{
"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.899596631526947
},
{
"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.879629373550415
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " })));\n if (isEnemyCard(engine.gameData, card) && card.intent?.scriptData) {\n card.intent.scriptData = CardScript.deserialize(engine, card, card.intent.scriptData).serialize();\n engine.broadcast.push({\n type: 'cardIntent',\n cardId: card.id,\n intent: card.intent,\n });\n }\n }",
"score": 0.8772643804550171
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " const gameData = await _Engine.getGameData(gameId);\n const pushMessage: IPlayerPushProvider.IPushMessage[] = [{\n type: 'cardIntent',\n cardId: sourceCardId,\n intent: {\n scriptData: sourceCardScript,\n targetCardId,\n },\n playerId,\n }];",
"score": 0.8747155070304871
}
] |
typescript
|
const scriptDataFromCard = sourceCard.scripts.find(x => CardScript.areEqual(x, sourceCardScript));
|
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.959567666053772
},
{
"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.9505658149719238
},
{
"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.9448845982551575
},
{
"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.9175175428390503
},
{
"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.9006730318069458
}
] |
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.8588662147521973
},
{
"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.839219868183136
},
{
"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.8388669490814209
},
{
"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.8339444994926453
},
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " cards: { nftId: string, mintHeight: number, url: string }[];\n label: string;\n }\n export type CardDecks = {\n get: GetterPair<ICardDeck>;\n update: Updater<ICardDeck>;\n queryByDid: Query<ICardDeck['playerId'], ICardDeck>;\n };\n export interface ICoopGame {\n id: string;",
"score": 0.831229567527771
}
] |
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/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.8614416718482971
},
{
"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.8463915586471558
},
{
"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.8446820378303528
},
{
"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.8385556936264038
},
{
"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.8371050357818604
}
] |
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": " 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.8942753672599792
},
{
"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.8921189308166504
},
{
"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.8886717557907104
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " static removeScript(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptType: CardScript.ScriptConstructor) {\n const removed = card.scripts.findAndRemoveFirst(x => x[0] === scriptType.name);\n if (!removed) throw new Error('script not found: ' + scriptType.name);\n engine.broadcast.push({\n type: 'scriptRemoved',\n cardId: card.id,\n removedScript: scriptType.name,\n });\n }\n static tickCooldowns(card: GameEngine.ICardState, broadcast: IPlayerPushProvider.IPushMessage[]) {",
"score": 0.8660761117935181
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " }\n static fromScriptName(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, scriptName: string) {\n return this.deserialize(engine, card, [scriptName]).serialize();\n }\n static isOnCooldown(data: CardScript.ScriptData) {\n return (this.findCooldownData(data)?.[1] || 0) > 0;\n }\n static makeCooldownData(max: number, cur = 0): CardScript.CooldownData {\n return ['$cooldown', cur, max];\n }",
"score": 0.8649711608886719
}
] |
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/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.866034209728241
},
{
"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.8641220331192017
},
{
"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.8534619212150574
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " const script = CardScript.deserialize(engine, enemy, scriptData);\n const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();\n if (!target) {\n return;\n }\n enemy.intent = {\n scriptData,\n targetCardId: target.id,\n };\n engine.broadcast.push({",
"score": 0.8519167304039001
},
{
"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.8500178456306458
}
] |
typescript
|
public scriptData: CardScript.ScriptData,
override duration: number,
) {
|
import { clamp, round } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
export namespace GameEngineUtils {
export function addEnemy(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, spawnIndex: number, generateIntent: boolean) {
if (engine.gameData.enemies.length >= engine.gameData.maxEnemies) return;
spawnIndex = clamp(spawnIndex, 0, engine.gameData.enemies.length);
engine.gameData.enemies.splice(spawnIndex, 0, enemy);
engine.broadcast.push({
type: 'cardAdded',
enemy,
position: spawnIndex,
});
GameEngineUtils.triggerMods('onInitMod', { engine, sourceCard: enemy });
if (generateIntent) {
GameEngineUtils.generateIntent(engine, enemy);
}
return enemy;
}
export function changeCardIsUsed(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState, isUsed: boolean) {
card.isUsed = isUsed;
engine.broadcast.push({
type: 'cardIsUsedChanged',
cardId: card.id,
isUsed,
});
}
export function clearIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = undefined;
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
});
return true;
}
export function changeCpu(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, cpuDelta: number) {
card.cpu += cpuDelta;
engine.broadcast.push({
type: 'cpuChanged',
cardId: card.id,
newCpu: card.cpu,
cpuDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeMem(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, memDelta: number) {
card.mem += memDelta;
engine.broadcast.push({
type: 'memChanged',
cardId: card.id,
newMem: card.mem,
memDelta,
});
GameEngineUtils.recalculateScripts(engine, card);
}
export function changeSec(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, secDelta: number, isPassive: boolean, contextCard?: GameEngine.ICardState) {
const clampedSecDelta = (card.sec < -secDelta) ? -card.sec : secDelta;
card.sec += clampedSecDelta;
engine.broadcast.push({
type: isPassive ? 'secChange' : (secDelta < 0 ? 'secDamage' : 'secBonus'),
cardId: card.id,
newSec: card.sec,
value: secDelta,
});
if (!isPassive && contextCard) {
const player = GameEngineUtils.findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
if (player) {
(clampedSecDelta >= 0) ? (player.stats.secBonus += clampedSecDelta) : (player.stats.secDmg += -clampedSecDelta);
}
}
}
export function executeIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState, dontClearIntent = false) {
const intent = enemy.intent;
if (!intent) {
return false;
}
enemy.intent = dontClearIntent ? enemy.intent : undefined;
let targetCard: GameEngine.ICardState | undefined;
if (intent.targetCardId >= 0) {
targetCard = findCardByIdMaybe(engine.gameData, intent.targetCardId);
if (!targetCard) {
// Intent target could've been removed between intent generation and execution
return false;
}
} else {
targetCard = enemy;
}
CardScript.execute(engine, enemy, intent.scriptData, targetCard);
return true;
}
export function findCardById(gameData: GameEngine.IGameData, cardId: number) {
const card = findCardByIdMaybe(gameData, cardId);
if (card) return card;
throw new Error('card not found');
}
export function findCardByIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
const enemy = gameData.enemies.find(x => x.id === cardId);
if (enemy) return enemy;
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) {
return player.cards.find(x => x.id === cardId);
}
return;
}
export function findPlayerCardById(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (!player) throw new Error('player not found');
return player.cards.find(x => x.id === cardId)!;
}
export function findPlayerByCardId(gameData: GameEngine.IGameData, cardId: number) {
const player = findPlayerByCardIdMaybe(gameData, cardId);
if (player) return player;
throw new Error('player not found');
}
export function findPlayerByCardIdMaybe(gameData: GameEngine.IGameData, cardId: number) {
return [...gameData.players.values()].find(x => x.cards.find(x => x.id === cardId));
}
export function generateIntent(engine: GameEngine.IGameEngine, enemy: GameEngine.IEnemyCardState) {
enemy.intent = undefined;
const isOffline = !!enemy.mods.find(x => x[0] === 'offline');
if (isOffline) return;
const scriptData = enemy.scripts.filter(x => !CardScript.isOnCooldown(x)).randomOrUndefined();
if (!scriptData) {
return;
}
const script = CardScript.deserialize(engine, enemy, scriptData);
const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();
if (!target) {
return;
}
enemy.intent = {
scriptData,
targetCardId: target.id,
};
engine.broadcast.push({
type: 'cardIntent',
cardId: enemy.id,
intent: enemy.intent,
});
}
export function getEnemyIds(gameData: GameEngine.IGameData) {
return gameData.enemies.map(x => x.id);
}
export function getPlayerIds(gameData: GameEngine.IGameData, ...excludePlayer: string[]) {
return [...gameData.players.keys()].filter(x => !excludePlayer.includes(x));
}
export function getPlayerCards(gameData: GameEngine.IGameData) {
return [...gameData.players.values()].map(x => x.cards).flat();
}
export function getPlayerCardIds(gameData: GameEngine.IGameData) {
return getPlayerCards(gameData).map(x => x.id);
}
export function isEnemyCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IEnemyCardState {
return !!gameData.enemies.find(x => x.id === card.id);
}
export function isPlayerCard(gameData: GameEngine.IGameData, card: GameEngine.ICardState): card is GameEngine.IPlayerCardState {
return !isEnemyCard(gameData, card);
}
export function recalculateScripts(engine: GameEngine.IGameEngine, card: GameEngine.ICardState) {
if (card.isRemoved) return;
card.scripts = card.scripts.map(x => CardScript.deserialize(engine, card, x).serialize());
engine.broadcast.push(...card.scripts.map(x => ({
type: 'scriptChanged',
cardId: card.id,
scriptData: x,
})));
if (isEnemyCard(engine.gameData, card) && card.intent?.scriptData) {
card.intent.scriptData = CardScript.deserialize(engine, card, card.intent.scriptData).serialize();
engine.broadcast.push({
type: 'cardIntent',
cardId: card.id,
intent: card.intent,
});
}
}
export function revalidateIntents(engine: GameEngine.IGameEngine, regenerateIfInvalid: boolean) {
for (const enemy of engine.gameData.enemies) {
if (!enemy.intent || enemy.intent.targetCardId === -1) {
continue;
}
const script = CardScript.deserialize(engine, enemy, enemy.intent.scriptData);
const validTargets = script.targetFinder(engine.gameData, enemy);
if (validTargets.find(x => x.id === enemy.intent?.targetCardId)) {
continue;
}
enemy.intent = undefined;
if (regenerateIfInvalid) {
generateIntent(engine, enemy);
}
}
}
export function removeCard(engine: GameEngine.IGameEngine, card: GameEngine.ICardState, contextCard?: GameEngine.ICardState) {
if (card.isRemoved) {
return;
}
if (isEnemyCard(engine.gameData, card)) {
engine.gameData.enemies.removeFirst(card)
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
for (const enemy of [...engine.gameData.enemies]) {
if (enemy.isRemoved) continue;
triggerMods('onEnemyDestroyed', { engine, sourceCard: card, contextCard });
}
if (contextCard) {
const player = findPlayerByCardIdMaybe(engine.gameData, contextCard.id);
player && player.stats.kills++;
}
GameEngineUtils.revalidateIntents(engine, true);
} else {
const player = GameEngineUtils.findPlayerByCardId(engine.gameData, card.id);
player.cards.removeFirst(card);
engine.broadcast.push({
type: 'cardRemoved',
cardId: card.id,
});
GameEngineUtils.triggerMods('onCardDestroyed', { engine, contextCard, sourceCard: card });
card.isRemoved = true;
GameEngineUtils.revalidateIntents(engine, false);
}
}
export function scaleByCpuMem(baseValue: number, cpuMem: number, cpuMemScaling: 'normal' | 'less' | 'more' | 'minimal' | 'high' = 'normal') {
let valuePerCpu = baseValue / 2;
switch (cpuMemScaling) {
case 'high': valuePerCpu * 1.5; break;
case 'more': valuePerCpu * 1.25; break;
case 'less': valuePerCpu * .75; break;
case 'minimal': valuePerCpu * .5; break;
}
return Math.round(baseValue + ((cpuMem - 1) * valuePerCpu));
}
export function scaleByDifficulty(value: number, difficulty: number, decimals = 0) {
|
return round(value * Math.pow(1.1, difficulty - 1), decimals);
|
}
export function spawnEnemy(engine: GameEngine.IGameEngine, enemyClass: string, spawnIndex: number, generateIntent: boolean) {
const enemyFactory = engine.ruleset.enemyCards?.[enemyClass];
if (!enemyFactory) throw new Error('EnemyClass not found for spawning: ' + enemyClass);
const enemy = enemyFactory(engine);
enemy.enemyClass = enemyClass;
return addEnemy(engine, enemy, spawnIndex, generateIntent);
}
export function triggerMods<T extends CardMod.ModEvent>(ev: T, ...args: Parameters<NonNullable<CardMod[typeof ev]>>): ReturnType<NonNullable<CardMod[typeof ev]>>[] {
const deps = args[0];
const card = deps.sourceCard;
return [...card.mods]
.map(modData => (!card.isRemoved && card.mods.find(x => CardMod.areEqual(x, modData))) ? CardMod.trigger(ev, modData, ...args) : undefined)
.filter(Boolean);
}
}
|
src/game/game-engine-utils.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " maxBonus = GameEngineUtils.scaleByCpuMem(8, card.cpu);\n break;\n case 'strong':\n minBonus = GameEngineUtils.scaleByCpuMem(8, card.cpu);\n maxBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);\n break;\n }\n minBonus = GameEngineUtils.scaleByDifficulty(minBonus, difficulty);\n maxBonus = GameEngineUtils.scaleByDifficulty(maxBonus, difficulty);\n super(",
"score": 0.817137598991394
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " minDmg = GameEngineUtils.scaleByCpuMem(6, card.cpu);\n maxDmg = GameEngineUtils.scaleByCpuMem(8, card.cpu);\n break;\n case 'normal':\n minDmg = GameEngineUtils.scaleByCpuMem(8, card.cpu);\n maxDmg = GameEngineUtils.scaleByCpuMem(12, card.cpu);\n break;\n case 'strong':\n minDmg = GameEngineUtils.scaleByCpuMem(11, card.cpu);\n maxDmg = GameEngineUtils.scaleByCpuMem(15, card.cpu);",
"score": 0.801822304725647
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " };\n export const ChangeCpu = (cpuDelta: number): IScriptPart =>\n (engine, _sourceCard, targetCard) => {\n GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);\n };\n export const RaiseMem = (memBonus: number): IScriptPart =>\n (engine, _sourceCard, targetCard) => {\n targetCard.mem += memBonus;\n engine.broadcast.push({\n type: 'memBonus',",
"score": 0.8016769886016846
},
{
"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.8000888824462891
},
{
"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.7990646362304688
}
] |
typescript
|
return round(value * Math.pow(1.1, difficulty - 1), decimals);
|
import { randInt } from '../utils';
import { CardMod } from './card-mods';
import { CardScriptParts } from './card-script-parts';
import { CardScript } from './card-scripts';
import { GameEngine } from './game-engine';
import { GameEngineUtils } from './game-engine-utils';
const _cardMods = {
// Increases incoming damage
exposed: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public stackCount: number) {
super(arguments);
this.stackingConfig.stackCount = stackCount;
}
override onSecDamageIn(_deps: CardMod.ICardModDeps, _damage: number, _attacker: GameEngine.ICardState) {
return { secDmgBonus: this.stackingConfig.stackCount };
}
},
// Returns damage to attacker
feedback: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public damage: number) {
super(arguments);
this.stackingConfig.stackCount = damage;
}
override onSecDamageIn(deps: CardMod.ICardModDeps, _damage: number, attacker: GameEngine.ICardState) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, false, true)(deps.engine, deps.sourceCard, attacker);
}
},
// Increases CPU
optimized: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(cpuBonus: number, override duration: number) {
super(arguments);
this.stackingConfig.stackCount = cpuBonus;
}
override onInitMod(deps: CardMod.ICardModDeps) {
GameEngineUtils.changeCpu(deps.engine, deps.sourceCard, this.stackingConfig.stackCount);
}
override onStackMod(deps: CardMod.ICardModDeps, stackDelta: number) {
deps.sourceCard.cpu += stackDelta;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
override onRemoveMod(deps: CardMod.ICardModDeps) {
deps.sourceCard.cpu -= this.stackingConfig.stackCount;
deps.engine.broadcast.push({
type: 'cpuChanged',
cardId: deps.sourceCard.id,
newCpu: deps.sourceCard.cpu,
});
GameEngineUtils.recalculateScripts(deps.engine, deps.sourceCard);
}
},
// Damages on turn end
virus: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 0,
};
constructor(public dot: number) {
super(arguments);
this.stackingConfig.stackCount = dot;
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
CardScriptParts.SecDmg(this.stackingConfig.stackCount, true, true)(deps.engine, deps.sourceCard, deps.sourceCard);
}
},
};
const _cardScripts = {
//
// Backdoor scripts
//
// Swap MEM for CPU
|
bd_caching: class extends CardScript {
|
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(-1),
CardScriptParts.ChangeCpu(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise MEM
bd_defrag: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memBonus = 1;
super(
[memBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 4;
}
},
// Heal over time
bd_diagnostics: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const duration = 1 + Math.round(card.mem / 2);
super(
[secBonus, duration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.diagnostics(secBonus, duration)
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Attack and stun (Backdoor finisher)
bd_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const stunDuration = 1;
super(
[damage, stunDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
CardScriptParts.AddMod(
new CardMod.Content.lag(stunDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and raise CPU on kill
bd_extraction: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Opponents(true)(gameData, card)
.filter(target => !target.sec && target.mem === 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(1, true, true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.ChangeCpu(1),
],
},
],
);
}
},
// Raises CPU
bd_optimize: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Raises SEC
bd_patch: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(11, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 2;
}
},
// Steal SEC and remove Firewall (Backdoor finisher)
bd_proxy: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, card.cpu);
super(
[secDelta],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'firewall'>('firewall'),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
}
},
// Steal SEC and causes offline (Backdoor finisher)
bd_reboot: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(5, _card.cpu);
const offlineDuration = 1;
super(
[secDelta, offlineDuration],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 2;
}
},
// Cause Exposed (Backdoor finisher)
bd_trace: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(7, card.cpu);
super(
[stacks],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 2;
}
},
// Attack and remove 1 MEM
bd_tunnel: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const memDmg = 1;
super(
[memDmg],
CardScript.TargetFinders._ModFilter<typeof CardMod.Content, 'backdoor'>(['backdoor'],
CardScript.TargetFinders.Opponents(true),
),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.MemDmg(memDmg),
CardScriptParts.RemoveMod<typeof CardMod.Content, 'backdoor'>('backdoor', true),
],
}
],
);
this.cooldownMax = 3;
}
},
//
// Bruteforce scripts
//
// Swap CPU for MEM
bf_compression: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, card) =>
CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.ChangeCpu(-1),
CardScriptParts.RaiseMem(1),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Offline
bf_ddos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const offlineDuration = 1;
super(
[offlineDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.offline(offlineDuration),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Cause Lag
bf_dos: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
const lagDuration = 1;
super(
[lagDuration],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(lagDuration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
// Gain feedback
bf_feedback: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Triple SEC attack
bf_flood: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(3, card.cpu);
const numAttacks = 3;
super(
[damage, numAttacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
...Array.from(Array(numAttacks)).map(() => CardScriptParts.SecDmg(damage)),
],
}
],
);
this.cooldownMax = 2;
}
},
// AOE attack
bf_multicast: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.TargetAndAdjacents,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC
bf_obfuscate: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
super(
[secBonus],
CardScript.TargetFinders.Any(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RaiseSec(secBonus),
],
}
],
);
this.cooldownMax = 3;
}
},
// Strong attack
bf_pod: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(16, card.cpu);
super(
[damage],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(damage),
],
}
],
);
this.cooldownMax = 2;
}
},
// Raises CPU
bf_precompute: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const cpuBonus = 1;
const duration = Math.round(card.cpu / 2);
super(
[cpuBonus, duration],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.optimized(cpuBonus, duration),
),
],
}
],
);
this.cooldownMax = 4;
}
},
//
// Malware scripts
//
// Causes Lag
mw_bloatware: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[1],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new CardMod.Content.lag(1),
),
],
}
],
);
this.cooldownMax = 3;
}
},
// Swap for another card's secondary script
mw_copypaste: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, sourceCard, targetCard) => {
CardScript.removeScript(engine, sourceCard, _cardScripts.mw_copypaste);
if (!targetCard.scripts[1]) return;
CardScript.addScript(engine, sourceCard, CardScript.fromScriptName(engine, sourceCard, targetCard.scripts[1][0]));
},
],
}
],
);
}
},
// Grant Feedback
mw_honeypot: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const damage = GameEngineUtils.scaleByCpuMem(6, card.cpu);
const cooldown = Math.max(0, 4 - Math.round(card.mem / 2));
super(
[damage, cooldown],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new GameContent_v1.cardMods.feedback(damage),
),
],
}
],
);
this.cooldownMax = cooldown;
}
},
// Steal SEC
mw_leech: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const secDelta = GameEngineUtils.scaleByCpuMem(6, card.cpu);
super(
[secDelta],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.SecDmg(secDelta),
],
},
{
targetResolver: CardScript.TargetResolvers.Self,
parts: [
CardScriptParts.RaiseSec(secDelta),
],
},
],
);
this.cooldownMax = 1;
}
},
// Attack random target
mw_phishing: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minDamage = GameEngineUtils.scaleByCpuMem(9, card.cpu);
const maxDamage = GameEngineUtils.scaleByCpuMem(18, card.cpu);
super(
[minDamage, maxDamage],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomOpponent,
parts: [
CardScriptParts.Attack(randInt(minDamage, maxDamage)),
],
}
],
);
this.cooldownMax = 1;
}
},
// Redistribute CPU/MEM
mw_reimage: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Allies(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, _sourceCard, targetCard) => {
const totalStats = targetCard.cpu + targetCard.mem;
const newCpu = randInt(1, totalStats - 1);
const cpuDelta = newCpu - targetCard.cpu;
GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);
const newMem = totalStats - newCpu;
const memDelta = newMem - targetCard.mem;
GameEngineUtils.changeMem(engine, targetCard, memDelta);
},
],
}
],
);
this.cooldownMax = 1;
}
},
// Raise SEC on random ally
mw_shareware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const minBonus = GameEngineUtils.scaleByCpuMem(10, card.cpu);
const maxBonus = GameEngineUtils.scaleByCpuMem(20, card.cpu);
super(
[minBonus, maxBonus],
CardScript.TargetFinders.Self,
[
{
targetResolver: CardScript.TargetResolvers.RandomAlly,
parts: [
CardScriptParts.RaiseSec(randInt(minBonus, maxBonus)),
],
}
],
);
this.cooldownMax = 3;
}
},
// Redirect intent
mw_spoof: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.RedirectIntentRandom,
],
}
],
);
}
},
// Cause Exposed
mw_spyware: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const stacks = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[stacks],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.exposed(stacks),
),
],
}
],
);
this.cooldownMax = 1;
}
},
// Cause Virus
mw_virus: class extends CardScript {
constructor(card: GameEngine.ICardState) {
const dot = GameEngineUtils.scaleByCpuMem(4, card.cpu);
super(
[dot],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.AddMod(
new _cardMods.virus(dot),
),
],
}
],
);
this.cooldownMax = 2;
}
},
};
export const GameContent_v1 = {
cardMods: _cardMods,
cardScripts: _cardScripts,
enemyCards: {},
initGame(_engine: GameEngine.IGameEngine) {
throw new Error('not a startable scenario');
},
addAdditionalScriptsFor(engine: GameEngine.IGameEngine, card: GameEngine.IPlayerCardState) {
if (card.card.tier < 2) return;
switch (card.card.faction) {
case 'backdoor':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bd_')).random()]).serialize());
return;
case 'bruteforce':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bf_')).random()]).serialize());
return;
case 'malware':
card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('mw_')).random()]).serialize());
return;
}
},
};
(GameContent_v1 as GameEngine.IRuleset);
|
src/game/game-content-v1.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " };\n export const MemDmg = (memDmg: number): IScriptPart =>\n (engine, sourceCard, targetCard) => {\n GameEngineUtils.triggerMods('onMemDmgOut', { engine, sourceCard, contextCard: targetCard }, memDmg);\n GameEngineUtils.triggerMods('onMemDmgIn', { engine, sourceCard: targetCard, contextCard: sourceCard }, memDmg);\n if (CardMod.findModOfType(targetCard, CardMod.Content.impervious)) {\n return;\n }\n targetCard.mem -= memDmg;\n engine.broadcast.push({",
"score": 0.8658467531204224
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " {\n targetResolver: TargetResolvers.Target,\n parts: [\n CardScriptParts._TargetHasMod<typeof CardMod.Content, 'backdoor'>('backdoor', mod => CardScriptParts.SecDmg(mod.stackingConfig.rank, true)),\n CardScriptParts.Attack(damage),\n CardScriptParts._Chance(bdChance,\n CardScriptParts.AddMod(\n new CardMod.Content.backdoor(damage),\n )\n ),",
"score": 0.8642169237136841
},
{
"filename": "src/game/card-script-parts.ts",
"retrieved_chunk": " };\n export const ChangeCpu = (cpuDelta: number): IScriptPart =>\n (engine, _sourceCard, targetCard) => {\n GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);\n };\n export const RaiseMem = (memBonus: number): IScriptPart =>\n (engine, _sourceCard, targetCard) => {\n targetCard.mem += memBonus;\n engine.broadcast.push({\n type: 'memBonus',",
"score": 0.8637550473213196
},
{
"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.8559220433235168
},
{
"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.848854660987854
}
] |
typescript
|
bd_caching: class extends CardScript {
|
import * as moment from 'moment';
import { IAppraisedCard, appraiseCard } from '../appraise';
import { IDataSource, IMetricsProvider, IPlayerPushProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { SECS_IN_MIN } from '../utils';
import { CardMod } from './card-mods';
import { CardScript } from './card-scripts';
import { GameContent_v1 } from './game-content-v1';
import { GameEngineUtils } from './game-engine-utils';
export namespace GameEngine {
interface _ICommonCardState {
id: number;
cpu: number;
mem: number;
sec: number;
mods: CardMod.ModData[];
scripts: CardScript.ScriptData[];
isRemoved?: boolean;
}
export interface IGameData {
id: string;
difficulty: number;
state: 'created' | 'started' | 'players_won' | 'players_lost' | 'abandoned';
enemies: IEnemyCardState[];
maxEnemies: number;
players: Map<string, IPlayerState>;
defaultMovesPerTurn: number;
turn: number;
nextId: number;
pendingPlayers: Map<string, string[]>;
rulesetIds: string[];
}
export interface IPlayerState {
id: string;
cards: IPlayerCardState[];
endedTurn: boolean;
idleKickTime: number;
movesLeft: number;
movesPerTurn: number;
score: number;
stats: {
kills: number;
secDmg: number;
memDmg: number;
secBonus: number;
};
}
export interface IPlayerCardState extends _ICommonCardState {
card: IAppraisedCard;
isUsed: boolean;
}
export interface IEnemyCardState extends _ICommonCardState {
enemyClass: string;
intent?: { scriptData: CardScript.ScriptData, targetCardId: number };
maxMem: number;
}
export type ICardState = IPlayerCardState | IEnemyCardState;
export abstract class GameEngineError extends Error {
constructor(
public gameId: string,
) {
super();
this.message = `${this.constructor.name} processing game ${gameId}`;
}
}
export class GameNotFoundError extends GameEngineError { }
export interface IRulesetContent {
cardMods?: CardMod.ModLibrary;
cardScripts?: CardScript.ScriptLibrary;
enemyCards?: Record<string, (engine: IGameEngine) => IEnemyCardState>;
}
export interface IRuleset extends IRulesetContent {
initGame(engine: IGameEngine): void;
addAdditionalScriptsFor?(engine: GameEngine.IGameEngine, card: IPlayerCardState): void;
}
export function mergeRulesetContents(...rulesets: IRulesetContent[]): IRulesetContent {
const modLibs = rulesets.map(x => x.cardMods).filter(Boolean);
const scriptLibs = rulesets.map(x => x.cardScripts).filter(Boolean);
const enemyLibs = rulesets.map(x => x.enemyCards).filter(Boolean);
return {
cardMods: Object.fromEntries(modLibs.map(modLib => Object.keys(modLib).map(modName => [modName, modLib[modName]!] as const)).flat()),
cardScripts: Object.fromEntries(scriptLibs.map(scriptLib => Object.keys(scriptLib).map(scriptName => [scriptName, scriptLib[scriptName]!] as const)).flat()),
enemyCards: Object.fromEntries(enemyLibs.map(enemyLib => Object.keys(enemyLib).map(enemyClass => [enemyClass, enemyLib[enemyClass]!] as const)).flat()),
};
}
export type IGameEngine = InstanceType<ReturnType<typeof createGameEngineProvider>>;
}
export const createGameEngineProvider = (rulesets: Record<string, GameEngine.IRuleset>, ds: IDataSource, playerPushProvider: IPlayerPushProvider, metrics?: IMetricsProvider) => {
return class _Engine {
readonly broadcast: IPlayerPushProvider.IPushMessage[] = [];
ruleset!: GameEngine.IRuleset;
constructor(
readonly gameData: GameEngine.IGameData,
) {
const currentRuleset = rulesets[gameData.rulesetIds.at(-1)!];
if (!currentRuleset) throw new Error('invalid initial ruleSet id: ' + gameData.rulesetIds[0]);
this._setRuleset(currentRuleset);
}
private static async _withEngine(gameId: string, stateAssertion: GameEngine.IGameData['state'][], func: (engine: _Engine) => Promise<void>): Promise<GameEngine.IGameData> {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
const engine = new _Engine(gameData);
try {
if (stateAssertion.length && !stateAssertion.includes(gameData.state)) throw new Error('wrong game state, expected: ' + stateAssertion.join() + ', got: ' + gameData.state);
await func(engine);
await ds.GameData.update.exec(gameData);
} catch (e: any) {
e.broadcast = engine.broadcast;
throw e;
}
if (engine.broadcast.length) {
await Promise.all(
[...gameData.players.keys()].map(playerId => playerPushProvider.push(playerId, engine.broadcast)),
);
}
return gameData;
}
static async createGame(gameId: string, rulesetId: string, difficulty: number) {
const ruleset = rulesets[rulesetId];
if (!ruleset) throw new Error('invalid ruleSet id: ' + rulesetId);
const existingGameData = await ds.GameData.get(gameId);
if (existingGameData) throw new Error('game with id already exists: ' + gameId);
const gameData: GameEngine.IGameData = {
id: gameId,
difficulty: Math.max(1, difficulty),
state: 'created',
turn: 1,
players: new Map(),
defaultMovesPerTurn: 3,
enemies: [],
maxEnemies: 9,
nextId: 1,
pendingPlayers: new Map(),
rulesetIds: [rulesetId],
};
await ds.GameData.update.exec(gameData);
}
static async startGame(gameId: string) {
const gameData = await _Engine._withEngine(gameId, ['created'], async engine => {
for (const [playerId, cardIds] of engine.gameData.pendingPlayers) {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
engine.broadcast.push({ type: 'playerJoin', playerState });
}
engine.gameData.pendingPlayers.clear();
engine.gameData.state = 'started';
engine.broadcast.push({ type: 'gameStart' });
engine.ruleset.initGame(engine);
});
return gameData;
}
static async endGame(gameId: string) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
engine.gameData.state = 'abandoned';
engine.broadcast.push({ type: 'gameEnd' });
});
}
static async addPlayer(gameId: string, playerId: string, cardIds: string[]) {
return await _Engine._withEngine(gameId, ['created', 'started'], async engine => {
if (engine.gameData.players.has(playerId)) throw new Error('player already in game');
if (engine.gameData.players.size >= 2) throw new Error('game is full: ' + gameId);
if (engine.gameData.state === 'started') {
const playerState = await engine._createPlayerState(playerId, cardIds);
engine.gameData.players.set(playerId, playerState);
if (engine.gameData.turn >= 2) {
playerState.endedTurn = true;
playerState.movesLeft = 0;
}
engine.broadcast.push({
type: 'playerJoin',
playerState,
});
} else {
engine.gameData.pendingPlayers.set(playerId, cardIds);
}
});
}
static async removePlayer(gameId: string, playerId: string, reason: 'idle' | 'leave') {
return await _Engine._withEngine(gameId, [], async engine => {
if (!engine.gameData.players.delete(playerId)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId, reason });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
});
}
static async requestCardTargets(gameId: string, playerId: string, cardId: number, scriptName: string) {
const gameData = await _Engine.getGameData(gameId);
const card = GameEngineUtils.findPlayerCardById(gameData, cardId);
let targets = [] as number[];
try {
if (card.isUsed) {
return;
}
|
const scriptData = card.scripts.find(x => x[0] === scriptName);
|
if (!scriptData) {
throw new Error(`Script [${scriptName}] not found in card [${cardId}]`);
}
if (CardScript.isOnCooldown(scriptData)) {
return;
}
const engine = new _Engine(gameData);
const script = CardScript.deserialize(engine, card, scriptData);
targets = script.targetFinder(gameData, card).map(x => x.id);
} finally {
await playerPushProvider.push(playerId, [{
type: 'cardTargets',
cardId,
scriptName,
targetCardIds: targets,
}]);
}
}
static async intent(gameId: string, playerId: string, sourceCardId?: string, sourceCardScript?: string, targetCardId?: string) {
const gameData = await _Engine.getGameData(gameId);
const pushMessage: IPlayerPushProvider.IPushMessage[] = [{
type: 'cardIntent',
cardId: sourceCardId,
intent: {
scriptData: sourceCardScript,
targetCardId,
},
playerId,
}];
await Promise.all(
[...gameData.players.keys()].filter(x => x !== playerId).map(x => playerPushProvider?.push(x, pushMessage)),
);
}
static async makeMove(gameId: string, playerId: string, sourceCardId: number, sourceCardScript: CardScript.ScriptData, targetCardId: number) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = GameEngineUtils.findPlayerByCardId(engine.gameData, sourceCardId);
if (playerState.id !== playerId) {
throw new Error(`Player ${playerId} cannot make move on card ${sourceCardId} from owner ${playerState.id}`);
}
if (!playerState.movesLeft) {
throw new Error(`No moves left`);
}
const sourceCard = playerState.cards.find(x => x.id === sourceCardId)!;
if (sourceCard.isUsed) {
throw new Error(`Card is used`);
}
const now = moment.now();
playerState.idleKickTime = now + 2 * SECS_IN_MIN * 1000;
playerState.movesLeft--;
const targetCard = GameEngineUtils.findCardById(engine.gameData, targetCardId);
CardScript.execute(engine, sourceCard, sourceCardScript, targetCard);
GameEngineUtils.changeCardIsUsed(engine, sourceCard, true);
metrics?.playerCardPlayed(gameId, engine.gameData.rulesetIds[0] || 'unknown', playerId, sourceCard, sourceCardScript[0]);
});
}
static async toggleEndTurn(gameId: string, playerId: string) {
return await _Engine._withEngine(gameId, ['started'], async engine => {
const playerState = engine.gameData.players.get(playerId);
if (!playerState) throw new Error('player not found');
if (playerState.endedTurn) {
playerState.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: false,
});
return;
}
playerState.endedTurn = true;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId,
state: true,
});
if (![...engine.gameData.players.values()].reduce((numNotReady, playerState) => playerState.endedTurn ? numNotReady : (numNotReady + 1), 0)) {
const now = moment.now();
[...engine.gameData.players.values()].forEach(x => x.idleKickTime = now + 2 * SECS_IN_MIN * 1000);
engine.onEndTurn();
if (engine.gameData.state !== 'started') {
// Stop if the game was won/lost due to an EndTurn effect
return;
}
engine.onTurnStart();
}
});
}
static async kickTeammateIfIdle(gameId: string, kickRequestingPlayerId: string) {
let kickedPlayerId = '';
await _Engine._withEngine(gameId, ['started'], async engine => {
const playerToKick = [...engine.gameData.players.values()].find(x => x.id !== kickRequestingPlayerId) || '';
if (!playerToKick) throw new Error('kickIfIdle: player not found');
if (playerToKick.idleKickTime < moment.now()) {
if (!engine.gameData.players.delete(playerToKick.id)) throw new Error('player not found');
engine.broadcast.push({ type: 'playerLeave', playerId: playerToKick.id, reason: 'idle' });
GameEngineUtils.revalidateIntents(engine, true);
for (const remainingPlayer of engine.gameData.players.values()) {
remainingPlayer.endedTurn = false;
engine.broadcast.push({
type: 'playerToggleEndTurn',
playerId: remainingPlayer.id,
state: false,
});
}
kickedPlayerId = playerToKick.id;
}
});
return kickedPlayerId || null;
}
static async getGameData(gameId: string) {
const gameData = await ds.GameData.get(gameId);
if (!gameData) throw new GameEngine.GameNotFoundError(gameId);
return gameData;
}
private async _createPlayerState(playerId: string, cardIds: string[]): Promise<GameEngine.IPlayerState> {
const cards = (await Promise.all(cardIds.map(ExtDeps.getNft)))
.filter((resp): resp is NonNullable<typeof resp> => !!resp?.nft)
.map(resp => appraiseCard({ nftId: resp.nft.nftId, mintHeight: resp.nft.firstBlock, url: resp.nft.urls[0] || '' }));
if (cards.length !== cardIds.length) {
throw `could not resolve all cards for player ${playerId}`;
}
const player: GameEngine.IPlayerState = {
id: playerId,
cards: cards.map(card => ({
id: this.nextId(),
card,
isUsed: false,
cpu: card.cpu,
mem: card.mem,
sec: card.mem * 6 + card.cpu * 3,
mods: [],
scripts: [],
})),
endedTurn: false,
movesLeft: this.gameData.defaultMovesPerTurn,
movesPerTurn: this.gameData.defaultMovesPerTurn,
stats: {
kills: 0,
memDmg: 0,
secBonus: 0,
secDmg: 0,
},
score: 0,
idleKickTime: moment.now() + 2 * SECS_IN_MIN * 1000,
};
for (const card of player.cards) {
card.scripts = [
CardScript.fromScriptName(this, card, card.card.coreScript),
];
this.ruleset.addAdditionalScriptsFor && this.ruleset.addAdditionalScriptsFor(this, card);
}
return player;
}
findRuleset(rulesetId: string) {
return rulesets[rulesetId];
}
onTurnStart() {
this.gameData.turn++;
this.broadcast.push({
type: 'newTurn',
turn: this.gameData.turn,
});
for (const player of this.gameData.players.values()) {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
}
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of playerCards) {
GameEngineUtils.changeCardIsUsed(this, playerCard, false);
}
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: playerCard });
}
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnStart', { engine: this, sourceCard: enemy });
}
this._checkGameOver();
}
onEndTurn() {
const playerCards = GameEngineUtils.getPlayerCards(this.gameData);
for (const playerCard of [...playerCards]) {
if (!playerCards.includes(playerCard)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: playerCard });
CardScript.tickCooldowns(playerCard, this.broadcast);
}
this.broadcast.push({
type: 'playerTurnEnded',
});
for (const enemy of [...this.gameData.enemies]) {
if (!this.gameData.enemies.includes(enemy)) continue;
GameEngineUtils.triggerMods('onTurnEnd', { engine: this, sourceCard: enemy });
CardScript.tickCooldowns(enemy, this.broadcast);
}
this.broadcast.push({
type: 'enemyTurnEnded',
});
this._checkGameOver();
}
onNextWave(nextRulesetId: string) {
while (this.gameData.enemies[0]) {
GameEngineUtils.removeCard(this, this.gameData.enemies[0]);
}
[...this.gameData.players.values()].forEach(player => {
player.endedTurn = false;
player.movesLeft = player.movesPerTurn;
player.cards.forEach(card => {
card.isUsed = false;
});
});
this.gameData.turn++;
this.broadcast.push({
type: 'nextWave',
turn: this.gameData.turn,
nextRulesetId,
});
const nextRuleset = this.findRuleset(nextRulesetId);
if (!nextRuleset) {
throw new Error('invalid rulesetId: ' + nextRulesetId);
}
this.gameData.rulesetIds.push(nextRulesetId);
this._setRuleset(nextRuleset);
nextRuleset.initGame(this);
}
onWinGame() {
this.gameData.state = 'players_won';
this.broadcast.push({
type: 'players_won',
stats: [...this.gameData.players.values()].map(player => {
let score =
player.cards.length * 50
+ player.stats.kills * 25
+ player.stats.memDmg * 50
+ player.stats.secDmg
+ player.stats.secBonus * 2
+ ((this.gameData.rulesetIds.length - 1) * 2000);
score = GameEngineUtils.scaleByDifficulty(score, this.gameData.difficulty + 1);
player.score = score;
return { playerId: player.id, stats: player.stats, score };
}),
});
}
nextId() {
return this.gameData.nextId++;
}
private _checkGameOver() {
if (!GameEngineUtils.getPlayerCards(this.gameData).length) {
this.gameData.state = 'players_lost';
this.broadcast.push({
type: 'players_lost',
});
}
}
private _setRuleset(nextRuleset: GameEngine.IRuleset) {
this.ruleset = {
addAdditionalScriptsFor: GameContent_v1.addAdditionalScriptsFor,
...nextRuleset,
...GameEngine.mergeRulesetContents(
nextRuleset,
{
cardMods: CardMod.Content,
cardScripts: CardScript.Content,
},
{
cardMods: GameContent_v1.cardMods,
cardScripts: GameContent_v1.cardScripts,
enemyCards: GameContent_v1.enemyCards,
}
),
};
}
}
}
export type GameEngineProvider = ReturnType<typeof createGameEngineProvider>;
|
src/game/game-engine.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/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.8990479707717896
},
{
"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.8772901296615601
},
{
"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.876905083656311
},
{
"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.8748310804367065
},
{
"filename": "src/game/game-engine-utils.ts",
"retrieved_chunk": " const script = CardScript.deserialize(engine, enemy, scriptData);\n const target = script.targetFinder(engine.gameData, enemy).randomOrUndefined();\n if (!target) {\n return;\n }\n enemy.intent = {\n scriptData,\n targetCardId: target.id,\n };\n engine.broadcast.push({",
"score": 0.8739581108093262
}
] |
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-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.8803434371948242
},
{
"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.8715547323226929
},
{
"filename": "src/game/card-mods.ts",
"retrieved_chunk": " const mod = this.deserialize(deps.engine, modDataFromCard);\n const evnt = mod[ev];\n const evntRetVal = evnt ? (evnt as any).apply(mod, args) : undefined;\n if (deps.sourceCard.isRemoved) {\n return;\n }\n if (ev === 'onTurnStart') {\n const durationData = this.findDurationData(modDataFromCard);\n if (durationData) {\n if (durationData[1] > 1) {",
"score": 0.8660591244697571
},
{
"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.8536476492881775
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);\n CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_power(), deps.sourceCard);\n }\n },\n goliath_shield_supply: class extends CardMod {\n override onCardDestroyed(deps: CardMod.ICardModDeps) {\n const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);\n CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_shield(), deps.sourceCard);\n }\n },",
"score": 0.8535410165786743
}
] |
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/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.8574495315551758
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " case 'bruteforce':\n card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('bf_')).random()]).serialize());\n return;\n case 'malware':\n card.scripts.push(CardScript.deserialize(engine, card, [Object.keys(_cardScripts).filter(x => x.startsWith('mw_')).random()]).serialize());\n return;\n }\n },\n};\n(GameContent_v1 as GameEngine.IRuleset);",
"score": 0.8520870208740234
},
{
"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.8464689254760742
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": "import { CardMod } from '../card-mods';\nimport { CardScript } from '../card-scripts';\nimport { GameEngine } from '../game-engine';\nimport { GameEngineUtils } from '../game-engine-utils';\nexport const RulesetMfrm = {\n enemyCards: {\n intro_sentinel: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n enemyClass: 'intro_sentinel',",
"score": 0.841926097869873
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " ],\n scripts: [],\n };\n boss.scripts.push(\n new CardScript.Content._attack(boss, engine.gameData.difficulty, 'strong').serialize(),\n new RulesetStasis.cardScripts.stasis_disrupt(boss, engine.gameData.difficulty).serialize(),\n );\n engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);",
"score": 0.8345339298248291
}
] |
typescript
|
cardMods: CardMod.Content,
cardScripts: CardScript.Content,
},
{
|
import { CardMod } from '../card-mods';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
const GOLIATH_ID = 9999;
export const RulesetGoliath = {
cardMods: {
goliath_power_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_power(), deps.sourceCard);
}
},
goliath_shield_supply: class extends CardMod {
override onCardDestroyed(deps: CardMod.ICardModDeps) {
const goliath = GameEngineUtils.findCardById(deps.engine.gameData, GOLIATH_ID);
CardMod.addMod(deps.engine, goliath, new RulesetGoliath.cardMods.goliath_boss_shield(), deps.sourceCard);
}
},
goliath_boss_ai: class extends CardMod {
override onTurnStart(deps: CardMod.ICardModDeps) {
GameEngineUtils.generateIntent(deps.engine, deps.sourceCard as GameEngine.IEnemyCardState);
}
override onTurnEnd(deps: CardMod.ICardModDeps) {
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
const targetId = boss.intent?.targetCardId;
if (!targetId) return;
let numAttacks = 1;
const powerBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_power);
if (powerBuff) {
const powerStacks = CardMod.getStackCount(powerBuff);
numAttacks += powerStacks;
}
for (let i = 0; i < numAttacks - 1; i++) {
GameEngineUtils.executeIntent(deps.engine, boss, true);
}
GameEngineUtils.executeIntent(deps.engine, boss);
}
override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {
if (deps.sourceCard.mem - memDmg <= 0) return;
const boss = deps.sourceCard as GameEngine.IEnemyCardState;
let secBonus = 100;
const shieldBuff = CardMod.findModOfType(boss, RulesetGoliath.cardMods.goliath_boss_shield);
if (shieldBuff) {
secBonus += CardMod.getStackCount(shieldBuff) * 100;
}
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(secBonus, deps.engine.gameData.difficulty), false, deps.sourceCard);
for (const enemy of [...deps.engine.gameData.enemies]) {
if (enemy === boss) continue;
CardMod.addMod(deps.engine, enemy, new GameContent_v1.cardMods.optimized(1, -1), boss);
}
}
},
goliath_boss_power: class extends CardMod {
override stackingConfig = {
behavior
|
: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
|
},
goliath_boss_shield: class extends CardMod {
override stackingConfig = {
behavior: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
},
},
enemyCards: {
goliath_power_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 2,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_power_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak').serialize(),
);
return enemy;
},
goliath_shield_node: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new RulesetGoliath.cardMods.goliath_shield_supply().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._defend(enemy, engine.gameData.difficulty, 'weak').serialize(),
new CardScript.Content._firewallSelf(enemy, 1, 2).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: GOLIATH_ID,
enemyClass: 'goliath_boss',
cpu: 2,
mem: 4,
maxMem: 4,
sec: GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
mods: [
new RulesetGoliath.cardMods.goliath_boss_ai().serialize(),
new CardMod.Content._winOnDeath().serialize(),
],
scripts: [],
};
boss.scripts.push(
new CardScript.Content._attack(boss, engine.gameData.difficulty).serialize(),
);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);
},
};
|
src/game/rulesets/goliath.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/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.8669854998588562
},
{
"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.8665420413017273
},
{
"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.8661695718765259
},
{
"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.8657331466674805
},
{
"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.864054799079895
}
] |
typescript
|
: CardMod.StackingBehavior.stack as const,
stackCount: 1,
};
|
import { randInt } from '../../utils';
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetReaper = {
cardMods: {
reaper_feederCorrupted: class extends CardMod {
},
reaper_feederPower: class extends CardMod {
override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {
if (deps.sourceCard.sec - damage > 0) return;
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);
CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);
const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);
player && player.stats.kills++;
return { secDmgBonus: -9999 };
}
},
},
cardScripts: {
reaper_bossEat: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, _card) => {
return gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_feeder.name);
},
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine,
|
source, target) => {
|
GameEngineUtils.removeCard(engine, target, source);
if (target.mods.find(x => x[0] === RulesetReaper.cardMods.reaper_feederCorrupted.name)) {
GameEngineUtils.changeSec(engine, source, -50, false);
if (source.sec <= 0) {
GameEngineUtils.removeCard(engine, source);
return;
}
} else {
GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);
GameEngineUtils.changeCpu(engine, source, 1);
for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {
CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));
}
}
const highDiff = engine.gameData.difficulty >= 7;
if (engine.gameData.enemies.length <= (highDiff ? 6 : 4)) {
while (engine.gameData.enemies.findIndex(x => x.id === source.id) < (highDiff ? 4 : 3)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absLeft')(engine, source, target);
}
while (engine.gameData.enemies.length < (highDiff ? 9 : 7)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absRight')(engine, source, target);
}
}
},
],
}
],
);
}
},
},
enemyCards: {
reaper_feeder: (engine: GameEngine.IGameEngine): GameEngine.IEnemyCardState => {
return {
id: engine.nextId(),
enemyClass: 'reaper_feeder',
cpu: 0,
mem: 0,
maxMem: 0,
sec: randInt(
GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),
GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
),
mods: [
new RulesetReaper.cardMods.reaper_feederPower().serialize(),
],
scripts: [],
};
},
reaper_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_lesser_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak', 1).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_boss',
cpu: 0,
mem: 0,
maxMem: 0,
sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content._winOnDeath().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
boss.scripts.push(
new RulesetReaper.cardScripts.reaper_bossEat(boss).serialize(),
);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
},
};
|
src/game/rulesets/reaper.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [],\n (gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseMem(-1),\n CardScriptParts.ChangeCpu(1),\n ],\n }",
"score": 0.8697218894958496
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " super(\n [],\n (gameData, card) =>\n CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.ChangeCpu(-1),\n CardScriptParts.RaiseMem(1),",
"score": 0.8685118556022644
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " export const RandomAlly: ITargetResolver = (gameData, sourceCard, targetCard) => {\n return [AllAllies(gameData, sourceCard, targetCard).random()];\n };\n export const AllOpponents: ITargetResolver = (gameData, sourceCard) => {\n if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {\n return TargetFinders._excludeImperviousAndOffline(GameEngineUtils.getPlayerCards(gameData));\n } else {\n return TargetFinders._excludeImperviousAndOffline(gameData.enemies);\n }\n };",
"score": 0.8541548252105713
},
{
"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.853895902633667
},
{
"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.8503689765930176
}
] |
typescript
|
source, target) => {
|
import * as moment from 'moment';
import { createCoopHandler } from './apis/coop.api';
import { IAuthProvider, IDataSource, IPlayerPushProvider, IRateLimitProvider } from './dependencies';
import { CardMod } from './game/card-mods';
import { CardScript } from './game/card-scripts';
import { GameEngine, createGameEngineProvider } from './game/game-engine';
import { GameEngineUtils } from './game/game-engine-utils';
import { IHttpRequest, IHttpRouteHandler, StatusCodes } from './net-utils';
import { FULL_DATETIME_FORMAT } from './utils';
/**
* Main entry point
*/
// TODO: this should be replaced with node:http or expressjs
export const handleRequest = async (req: IHttpRequest) => {
const split = req.path.split('/').filter(Boolean);
const subPath = split.slice(1);
const body = req.body ? JSON.parse(req.body) : null;
const query = req.queryStringParameters || {};
let handler: IHttpRouteHandler | undefined = undefined;
switch (split[0]) {
case 'coop':
handler = coopHandler;
// ... Note: implement remaining route handlers
}
const result = handler ? (await handler(subPath, query, body, req)) : null;
return result || [StatusCodes.badRequest, { reason: 'invalid api' }];
};
/**
* Dependencies
*/
// Note: replace with an actual database
const cardDecksTable = createMockTableDualKey<IDataSource.ICardDeck>('playerId', 'createdAt');
const coopGamesTable = createMockTableSingleKey<IDataSource.ICoopGame>('id');
const playersTable = createMockTableSingleKey<IDataSource.IPlayer>('id');
const playerCoopGamesTable = createMockTableSingleKey<IDataSource.IPlayerCoopGame>('playerId');
const dataSource: IDataSource = {
CardDecks: {
...cardDecksTable,
async queryByDid(did) {
return { items: [...cardDecksTable._db.values()].filter(x => x.playerId === did) };
},
},
CoopGames: {
...coopGamesTable,
async queryByGameState(gameState) {
return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };
},
},
GameData: {
...createMockTableSingleKey<GameEngine.IGameData>('id'),
},
Players: {
...playersTable,
},
PlayerCoopGames: {
...playerCoopGamesTable,
async queryByPlayerId(playerId: string) {
return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };
},
},
Leaderboard: {
getTopN(_n) { return [] as any; },
async set(_playerId, _score) { },
},
async execUpdates(...updateRequests) {
updateRequests.forEach(x => x());
},
};
// Note: replace with an actual auth provider
const authProvider: IAuthProvider = {
generateNewSecret: () => `${Math.random()}`,
getAuthTokenForPlayer: player => player.secret,
getPlayerFromRequest: async () => [...playersTable._db.values()][0]!,
getPlayerIdFromRequest: () => [...playersTable._db.values()][0]?.id!,
};
// Note: replace with an actual push provider
const pushProvider: IPlayerPushProvider = {
async push(playerId, messages) {
console.log(`Push messages for player [${playerId}]:`);
messages.forEach(x => console.log(x));
}
};
const rateLimitProvider: IRateLimitProvider = {
async shouldRateLimitCreateGame(_playerId) {
return false;
},
async shouldRateLimitSearchGame(_playerId) {
return false;
},
};
// Note: replace with custom game content
const gameContent: GameEngine.IRuleset = {
cardMods: { /** Custom card modifiers **/ },
cardScripts: { /** Custom card scripts **/ },
initGame(engine) {
const testEnemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'testEnemy',
cpu: 1,
mem: 1,
maxMem: 1,
mods: [],
scripts: [],
sec: 10,
};
|
testEnemy.mods.push(new CardMod.Content._standardAi().serialize());
|
testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());
GameEngineUtils.addEnemy(engine, testEnemy, 0, true);
},
addAdditionalScriptsFor(_card) {
// Note: Called by GameEngine when a player is joined; this hook allows for dynamic scripts for a given card
},
};
const gameEngine = createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
const coopHandler = createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider);
/**
* Example
*/
(async () => {
/**
* Players are normally created via /players/connectDid; to keep this example concise,
* we'll inject one with CO8's DID into the mock database.
*/
const mockPlayer = {
id: 'did:chia:1sc5hxvcs26e4zsc7uvlfuc7x9sjj5aw6cu0g8vcyvscy49ffp8zqwh63tq',
activeDeckId: '',
activeGameId: '',
secret: '',
authExpiresAt: '2100-01-01',
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),
score: 0,
}
playersTable._db.set(mockPlayer.id, mockPlayer);
/**
* This calls into /coop/create which is a complex API.
* Step thru this to learn about how the route handlers work.
*/
console.log('Creating game...');
await handleRequest({
httpMethod: 'POST',
path: '/coop/create',
body: JSON.stringify({
gameVisibility: 'private',
difficulty: 1,
}),
});
console.log('Game created, gameId: ' + mockPlayer.activeGameId);
/**
* Games normally start automatically when enough players join via /coop/join or /coop/search,
* to keep this example concise, we'll start it directly via the gameEngine reference.
* Step thru this to learn about how the game engine works.
*/
console.log('Starting game...');
await gameEngine.startGame(mockPlayer.activeGameId);
})();
/**
* In-memory DB helpers
* Note: this is a mock database that only satisfies the example above and is
* not meant to be starting point for production.
*/
function createMockTableSingleKey<T extends Record<string, any>>(idKey: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id: string) {
return _db.get(id) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(item[idKey], item);
return item;
},
},
};
}
function createMockTableDualKey<T extends Record<string, any>>(id1Key: keyof T, id2Key: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id1: string, id2: string) {
return _db.get(`${id1}_${id2}`) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(`${item[id1Key]}_${item[id2Key]}`, item);
return item;
},
},
};
}
|
src/reference-example.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/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.9433038234710693
},
{
"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.9419412612915039
},
{
"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.932106614112854
},
{
"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.9235944151878357
},
{
"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.9220716953277588
}
] |
typescript
|
testEnemy.mods.push(new CardMod.Content._standardAi().serialize());
|
import * as moment from 'moment';
import { createCoopHandler } from './apis/coop.api';
import { IAuthProvider, IDataSource, IPlayerPushProvider, IRateLimitProvider } from './dependencies';
import { CardMod } from './game/card-mods';
import { CardScript } from './game/card-scripts';
import { GameEngine, createGameEngineProvider } from './game/game-engine';
import { GameEngineUtils } from './game/game-engine-utils';
import { IHttpRequest, IHttpRouteHandler, StatusCodes } from './net-utils';
import { FULL_DATETIME_FORMAT } from './utils';
/**
* Main entry point
*/
// TODO: this should be replaced with node:http or expressjs
export const handleRequest = async (req: IHttpRequest) => {
const split = req.path.split('/').filter(Boolean);
const subPath = split.slice(1);
const body = req.body ? JSON.parse(req.body) : null;
const query = req.queryStringParameters || {};
let handler: IHttpRouteHandler | undefined = undefined;
switch (split[0]) {
case 'coop':
handler = coopHandler;
// ... Note: implement remaining route handlers
}
const result = handler ? (await handler(subPath, query, body, req)) : null;
return result || [StatusCodes.badRequest, { reason: 'invalid api' }];
};
/**
* Dependencies
*/
// Note: replace with an actual database
const cardDecksTable = createMockTableDualKey<IDataSource.ICardDeck>('playerId', 'createdAt');
const coopGamesTable = createMockTableSingleKey<IDataSource.ICoopGame>('id');
const playersTable = createMockTableSingleKey<IDataSource.IPlayer>('id');
const playerCoopGamesTable = createMockTableSingleKey<IDataSource.IPlayerCoopGame>('playerId');
const dataSource: IDataSource = {
CardDecks: {
...cardDecksTable,
async queryByDid(did) {
return { items: [...cardDecksTable._db.values()].filter(x => x.playerId === did) };
},
},
CoopGames: {
...coopGamesTable,
async queryByGameState(gameState) {
return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };
},
},
GameData: {
...createMockTableSingleKey<
|
GameEngine.IGameData>('id'),
},
Players: {
|
...playersTable,
},
PlayerCoopGames: {
...playerCoopGamesTable,
async queryByPlayerId(playerId: string) {
return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };
},
},
Leaderboard: {
getTopN(_n) { return [] as any; },
async set(_playerId, _score) { },
},
async execUpdates(...updateRequests) {
updateRequests.forEach(x => x());
},
};
// Note: replace with an actual auth provider
const authProvider: IAuthProvider = {
generateNewSecret: () => `${Math.random()}`,
getAuthTokenForPlayer: player => player.secret,
getPlayerFromRequest: async () => [...playersTable._db.values()][0]!,
getPlayerIdFromRequest: () => [...playersTable._db.values()][0]?.id!,
};
// Note: replace with an actual push provider
const pushProvider: IPlayerPushProvider = {
async push(playerId, messages) {
console.log(`Push messages for player [${playerId}]:`);
messages.forEach(x => console.log(x));
}
};
const rateLimitProvider: IRateLimitProvider = {
async shouldRateLimitCreateGame(_playerId) {
return false;
},
async shouldRateLimitSearchGame(_playerId) {
return false;
},
};
// Note: replace with custom game content
const gameContent: GameEngine.IRuleset = {
cardMods: { /** Custom card modifiers **/ },
cardScripts: { /** Custom card scripts **/ },
initGame(engine) {
const testEnemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'testEnemy',
cpu: 1,
mem: 1,
maxMem: 1,
mods: [],
scripts: [],
sec: 10,
};
testEnemy.mods.push(new CardMod.Content._standardAi().serialize());
testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());
GameEngineUtils.addEnemy(engine, testEnemy, 0, true);
},
addAdditionalScriptsFor(_card) {
// Note: Called by GameEngine when a player is joined; this hook allows for dynamic scripts for a given card
},
};
const gameEngine = createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
const coopHandler = createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider);
/**
* Example
*/
(async () => {
/**
* Players are normally created via /players/connectDid; to keep this example concise,
* we'll inject one with CO8's DID into the mock database.
*/
const mockPlayer = {
id: 'did:chia:1sc5hxvcs26e4zsc7uvlfuc7x9sjj5aw6cu0g8vcyvscy49ffp8zqwh63tq',
activeDeckId: '',
activeGameId: '',
secret: '',
authExpiresAt: '2100-01-01',
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),
score: 0,
}
playersTable._db.set(mockPlayer.id, mockPlayer);
/**
* This calls into /coop/create which is a complex API.
* Step thru this to learn about how the route handlers work.
*/
console.log('Creating game...');
await handleRequest({
httpMethod: 'POST',
path: '/coop/create',
body: JSON.stringify({
gameVisibility: 'private',
difficulty: 1,
}),
});
console.log('Game created, gameId: ' + mockPlayer.activeGameId);
/**
* Games normally start automatically when enough players join via /coop/join or /coop/search,
* to keep this example concise, we'll start it directly via the gameEngine reference.
* Step thru this to learn about how the game engine works.
*/
console.log('Starting game...');
await gameEngine.startGame(mockPlayer.activeGameId);
})();
/**
* In-memory DB helpers
* Note: this is a mock database that only satisfies the example above and is
* not meant to be starting point for production.
*/
function createMockTableSingleKey<T extends Record<string, any>>(idKey: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id: string) {
return _db.get(id) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(item[idKey], item);
return item;
},
},
};
}
function createMockTableDualKey<T extends Record<string, any>>(id1Key: keyof T, id2Key: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id1: string, id2: string) {
return _db.get(`${id1}_${id2}`) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(`${item[id1Key]}_${item[id2Key]}`, item);
return item;
},
},
};
}
|
src/reference-example.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " export type 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.8747086524963379
},
{
"filename": "src/dependencies.d.ts",
"retrieved_chunk": " export type CoopGames = {\n get: GetterSingle<ICoopGame>;\n update: Updater<ICoopGame>;\n queryByGameState: Query<ICoopGame['gameState'], ICoopGame>;\n };\n export interface IPlayer {\n id: string;\n createdAt: string;\n lastSeenAt: string;\n secret: string;",
"score": 0.8681906461715698
},
{
"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.8439832329750061
},
{
"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.8364132046699524
},
{
"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.8322099447250366
}
] |
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.9538697004318237
},
{
"filename": "src/game/rulesets/stasis.ts",
"retrieved_chunk": " ],\n scripts: [],\n };\n boss.scripts.push(\n new CardScript.Content._attack(boss, engine.gameData.difficulty, 'strong').serialize(),\n new RulesetStasis.cardScripts.stasis_disrupt(boss, engine.gameData.difficulty).serialize(),\n );\n engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);",
"score": 0.9110584259033203
},
{
"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.8940218687057495
},
{
"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.8932439088821411
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " scripts: [],\n };\n boss.scripts.push(\n new CardScript.Content._attack(boss, engine.gameData.difficulty).serialize(),\n );\n engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_power_node.name, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);\n GameEngineUtils.addEnemy(engine, boss, 0, true);\n GameEngineUtils.spawnEnemy(engine, RulesetGoliath.enemyCards.goliath_shield_node.name, 0, true);",
"score": 0.888308048248291
}
] |
typescript
|
new RulesetReaper.cardScripts.reaper_bossEat(boss).serialize(),
);
|
import { randInt } from '../../utils';
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetReaper = {
cardMods: {
reaper_feederCorrupted: class extends CardMod {
},
reaper_feederPower: class extends CardMod {
override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {
if (deps.sourceCard.sec - damage > 0) return;
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);
CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);
const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);
player && player.stats.kills++;
return { secDmgBonus: -9999 };
}
},
},
cardScripts: {
reaper_bossEat: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, _card) => {
return gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_feeder.name);
},
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, source, target) => {
GameEngineUtils.removeCard(engine, target, source);
if (target.mods.find(x => x[0] === RulesetReaper.cardMods.reaper_feederCorrupted.name)) {
GameEngineUtils.changeSec(engine, source, -50, false);
if (source.sec <= 0) {
GameEngineUtils.removeCard(engine, source);
return;
}
} else {
GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);
GameEngineUtils.changeCpu(engine, source, 1);
for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {
CardMod.addMod(engine,
|
guardian, new GameContent_v1.cardMods.optimized(1, -1));
|
}
}
const highDiff = engine.gameData.difficulty >= 7;
if (engine.gameData.enemies.length <= (highDiff ? 6 : 4)) {
while (engine.gameData.enemies.findIndex(x => x.id === source.id) < (highDiff ? 4 : 3)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absLeft')(engine, source, target);
}
while (engine.gameData.enemies.length < (highDiff ? 9 : 7)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absRight')(engine, source, target);
}
}
},
],
}
],
);
}
},
},
enemyCards: {
reaper_feeder: (engine: GameEngine.IGameEngine): GameEngine.IEnemyCardState => {
return {
id: engine.nextId(),
enemyClass: 'reaper_feeder',
cpu: 0,
mem: 0,
maxMem: 0,
sec: randInt(
GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),
GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
),
mods: [
new RulesetReaper.cardMods.reaper_feederPower().serialize(),
],
scripts: [],
};
},
reaper_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_lesser_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak', 1).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_boss',
cpu: 0,
mem: 0,
maxMem: 0,
sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content._winOnDeath().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
boss.scripts.push(
new RulesetReaper.cardScripts.reaper_bossEat(boss).serialize(),
);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
},
};
|
src/game/rulesets/reaper.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/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.8841228485107422
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " parts: [\n (engine, _sourceCard, targetCard) => {\n const totalStats = targetCard.cpu + targetCard.mem;\n const newCpu = randInt(1, totalStats - 1);\n const cpuDelta = newCpu - targetCard.cpu;\n GameEngineUtils.changeCpu(engine, targetCard, cpuDelta);\n const newMem = totalStats - newCpu;\n const memDelta = newMem - targetCard.mem;\n GameEngineUtils.changeMem(engine, targetCard, memDelta);\n },",
"score": 0.8743176460266113
},
{
"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.8727403879165649
},
{
"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.8704135417938232
},
{
"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.8636165857315063
}
] |
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/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.8571906089782715
},
{
"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.853276252746582
},
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " },\n initGame(engine: GameEngine.IGameEngine) {\n const boss: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n enemyClass: 'intro_boss',\n cpu: 3,\n mem: 3,\n maxMem: 3,\n sec: GameEngineUtils.scaleByDifficulty(125, engine.gameData.difficulty),\n mods: [],",
"score": 0.8511069416999817
},
{
"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.8465366959571838
},
{
"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.8443182706832886
}
] |
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": " 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.9077552556991577
},
{
"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.8783600330352783
},
{
"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.8780015707015991
},
{
"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.8778769969940186
},
{
"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.874974250793457
}
] |
typescript
|
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
|
import { randInt } from '../../utils';
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetReaper = {
cardMods: {
reaper_feederCorrupted: class extends CardMod {
},
reaper_feederPower: class extends CardMod {
override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {
if (deps.sourceCard.sec - damage > 0) return;
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);
CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);
const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);
player && player.stats.kills++;
return { secDmgBonus: -9999 };
}
},
},
cardScripts: {
reaper_bossEat: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, _card) => {
return gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_feeder.name);
},
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(
|
engine, source, target) => {
|
GameEngineUtils.removeCard(engine, target, source);
if (target.mods.find(x => x[0] === RulesetReaper.cardMods.reaper_feederCorrupted.name)) {
GameEngineUtils.changeSec(engine, source, -50, false);
if (source.sec <= 0) {
GameEngineUtils.removeCard(engine, source);
return;
}
} else {
GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);
GameEngineUtils.changeCpu(engine, source, 1);
for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {
CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));
}
}
const highDiff = engine.gameData.difficulty >= 7;
if (engine.gameData.enemies.length <= (highDiff ? 6 : 4)) {
while (engine.gameData.enemies.findIndex(x => x.id === source.id) < (highDiff ? 4 : 3)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absLeft')(engine, source, target);
}
while (engine.gameData.enemies.length < (highDiff ? 9 : 7)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absRight')(engine, source, target);
}
}
},
],
}
],
);
}
},
},
enemyCards: {
reaper_feeder: (engine: GameEngine.IGameEngine): GameEngine.IEnemyCardState => {
return {
id: engine.nextId(),
enemyClass: 'reaper_feeder',
cpu: 0,
mem: 0,
maxMem: 0,
sec: randInt(
GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),
GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
),
mods: [
new RulesetReaper.cardMods.reaper_feederPower().serialize(),
],
scripts: [],
};
},
reaper_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_lesser_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak', 1).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_boss',
cpu: 0,
mem: 0,
maxMem: 0,
sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content._winOnDeath().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
boss.scripts.push(
new RulesetReaper.cardScripts.reaper_bossEat(boss).serialize(),
);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
},
};
|
src/game/rulesets/reaper.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " [],\n (gameData, card) => CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.mem > 1),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.RaiseMem(-1),\n CardScriptParts.ChangeCpu(1),\n ],\n }",
"score": 0.8682947158813477
},
{
"filename": "src/game/game-content-v1.ts",
"retrieved_chunk": " super(\n [],\n (gameData, card) =>\n CardScript.TargetFinders.Allies()(gameData, card).filter(x => x.cpu > 1),\n [\n {\n targetResolver: CardScript.TargetResolvers.Target,\n parts: [\n CardScriptParts.ChangeCpu(-1),\n CardScriptParts.RaiseMem(1),",
"score": 0.8655360341072083
},
{
"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.8569434285163879
},
{
"filename": "src/game/card-scripts.ts",
"retrieved_chunk": " export const RandomAlly: ITargetResolver = (gameData, sourceCard, targetCard) => {\n return [AllAllies(gameData, sourceCard, targetCard).random()];\n };\n export const AllOpponents: ITargetResolver = (gameData, sourceCard) => {\n if (GameEngineUtils.isEnemyCard(gameData, sourceCard)) {\n return TargetFinders._excludeImperviousAndOffline(GameEngineUtils.getPlayerCards(gameData));\n } else {\n return TargetFinders._excludeImperviousAndOffline(gameData.enemies);\n }\n };",
"score": 0.8560516238212585
},
{
"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.8504753708839417
}
] |
typescript
|
engine, source, target) => {
|
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetStasis = {
cardMods: {
stasis_boss_ai: class extends CardMod.Content._standardAi {
override onMemDmgIn(deps: CardMod.ICardModDeps, memDmg: number) {
if (deps.sourceCard.mem - memDmg <= 0) return;
for (const playerCard of GameEngineUtils.getPlayerCards(deps.engine.gameData)) {
CardMod.addMod(deps.engine, playerCard, new CardMod.Content.lag(1), deps.sourceCard);
}
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, GameEngineUtils.scaleByDifficulty(125, deps.engine.gameData.difficulty), false, deps.contextCard);
if (![...deps.engine.gameData.enemies].find(x => x.enemyClass === RulesetStasis.enemyCards.stasis_disruptor.name)) {
GameEngineUtils.spawnEnemy(deps.engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
}
}
},
},
enemyCards: {
stasis_disruptor: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 3,
maxMem: 3,
sec: GameEngineUtils.scaleByDifficulty(35, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
new
|
RulesetStasis.cardScripts.stasis_disrupt(enemy, engine.gameData.difficulty).serialize(),
);
|
return enemy;
},
stasis_shocker: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: '',
cpu: 1,
mem: 2,
maxMem: 2,
sec: GameEngineUtils.scaleByDifficulty(45, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
},
cardScripts: {
stasis_disrupt: class extends CardScript {
constructor(card: GameEngine.ICardState, difficulty: number) {
const dmg = GameEngineUtils.scaleByDifficulty(GameEngineUtils.scaleByCpuMem(5, card.cpu), difficulty);
super(
[difficulty, dmg],
CardScript.TargetFinders.Opponents(),
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
CardScriptParts.Attack(dmg),
CardScriptParts.AddMod(new CardMod.Content.lag(2)),
],
}
],
);
}
}
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'stasis_boss',
cpu: 3,
mem: 3,
maxMem: 3,
sec: GameEngineUtils.scaleByDifficulty(125, engine.gameData.difficulty),
mods: [
new RulesetStasis.cardMods.stasis_boss_ai().serialize(),
new CardMod.Content._winOnDeath().serialize(),
],
scripts: [],
};
boss.scripts.push(
new CardScript.Content._attack(boss, engine.gameData.difficulty, 'strong').serialize(),
new RulesetStasis.cardScripts.stasis_disrupt(boss, engine.gameData.difficulty).serialize(),
);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_shocker.name, 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.spawnEnemy(engine, RulesetStasis.enemyCards.stasis_disruptor.name, 0, true);
},
};
|
src/game/rulesets/stasis.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " 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.9358947277069092
},
{
"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.9342533349990845
},
{
"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.9328712821006775
},
{
"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.9258513450622559
},
{
"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.9089621901512146
}
] |
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": " 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.9592156410217285
},
{
"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.9478780031204224
},
{
"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.9357705116271973
},
{
"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.9354265332221985
},
{
"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.9291942119598389
}
] |
typescript
|
testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());
|
import { randInt } from '../../utils';
import { CardMod } from '../card-mods';
import { CardScriptParts } from '../card-script-parts';
import { CardScript } from '../card-scripts';
import { GameContent_v1 } from '../game-content-v1';
import { GameEngine } from '../game-engine';
import { GameEngineUtils } from '../game-engine-utils';
export const RulesetReaper = {
cardMods: {
reaper_feederCorrupted: class extends CardMod {
},
reaper_feederPower: class extends CardMod {
override onSecDamageIn(deps: CardMod.ICardModDeps, damage: number, attacker: GameEngine.ICardState) {
if (deps.sourceCard.sec - damage > 0) return;
GameEngineUtils.changeSec(deps.engine, deps.sourceCard, -deps.sourceCard.sec, true);
CardMod.removeModByName(deps.engine, deps.sourceCard, this.constructor.name, attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new RulesetReaper.cardMods.reaper_feederCorrupted(), attacker);
CardMod.addMod(deps.engine, deps.sourceCard, new CardMod.Content.impervious(), attacker);
const player = GameEngineUtils.findPlayerByCardIdMaybe(deps.engine.gameData, attacker.id);
player && player.stats.kills++;
return { secDmgBonus: -9999 };
}
},
},
cardScripts: {
reaper_bossEat: class extends CardScript {
constructor(_card: GameEngine.ICardState) {
super(
[],
(gameData, _card) => {
return gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_feeder.name);
},
[
{
targetResolver: CardScript.TargetResolvers.Target,
parts: [
(engine, source, target) => {
GameEngineUtils.removeCard(engine, target, source);
if (target.mods.find(x => x[0] === RulesetReaper.cardMods.reaper_feederCorrupted.name)) {
GameEngineUtils.changeSec(engine, source, -50, false);
if (source.sec <= 0) {
GameEngineUtils.removeCard(engine, source);
return;
}
} else {
GameEngineUtils.changeSec(engine, source, Math.round(target.sec / 2), false);
GameEngineUtils.changeCpu(engine, source, 1);
for (const guardian of engine.gameData.enemies.filter(x => x.enemyClass === RulesetReaper.enemyCards.reaper_guardian.name)) {
CardMod.addMod(engine, guardian, new GameContent_v1.cardMods.optimized(1, -1));
}
}
const highDiff = engine.gameData.difficulty >= 7;
if (engine.gameData.enemies.length <= (highDiff ? 6 : 4)) {
while (engine.gameData.enemies.findIndex(x => x.id === source.id) < (highDiff ? 4 : 3)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absLeft')(engine, source, target);
}
while (engine.gameData.enemies.length < (highDiff ? 9 : 7)) {
CardScriptParts.SpawnEnemy('reaper_feeder', 'absRight')(engine, source, target);
}
}
},
],
}
],
);
}
},
},
enemyCards: {
reaper_feeder: (engine: GameEngine.IGameEngine): GameEngine.IEnemyCardState => {
return {
id: engine.nextId(),
enemyClass: 'reaper_feeder',
cpu: 0,
mem: 0,
maxMem: 0,
sec: randInt(
GameEngineUtils.scaleByDifficulty(50, engine.gameData.difficulty),
GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),
),
mods: [
|
new RulesetReaper.cardMods.reaper_feederPower().serialize(),
],
scripts: [],
};
|
},
reaper_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),
);
return enemy;
},
reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {
const enemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_lesser_guardian',
cpu: 2,
mem: 0,
maxMem: 0,
sec: 1,
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
enemy.scripts.push(
new CardScript.Content._attack(enemy, engine.gameData.difficulty, 'weak', 1).serialize(),
);
return enemy;
},
},
initGame(engine: GameEngine.IGameEngine) {
const boss: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'reaper_boss',
cpu: 0,
mem: 0,
maxMem: 0,
sec: GameEngineUtils.scaleByDifficulty(250, engine.gameData.difficulty),
mods: [
new CardMod.Content._standardAi().serialize(),
new CardMod.Content._winOnDeath().serialize(),
new CardMod.Content.impervious().serialize(),
],
scripts: [],
};
boss.scripts.push(
new RulesetReaper.cardScripts.reaper_bossEat(boss).serialize(),
);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, boss, 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_guardian(engine), 0, true);
engine.gameData.difficulty >= 7 && GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_lesser_guardian(engine), 0, true);
GameEngineUtils.addEnemy(engine, RulesetReaper.enemyCards.reaper_feeder(engine), 0, true);
},
};
|
src/game/rulesets/reaper.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/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.9106374979019165
},
{
"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.9075499176979065
},
{
"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.9011359214782715
},
{
"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.8998703956604004
},
{
"filename": "src/game/rulesets/goliath.ts",
"retrieved_chunk": " id: GOLIATH_ID,\n enemyClass: 'goliath_boss',\n cpu: 2,\n mem: 4,\n maxMem: 4,\n sec: GameEngineUtils.scaleByDifficulty(100, engine.gameData.difficulty),\n mods: [\n new RulesetGoliath.cardMods.goliath_boss_ai().serialize(),\n new CardMod.Content._winOnDeath().serialize(),\n ],",
"score": 0.8864032030105591
}
] |
typescript
|
new RulesetReaper.cardMods.reaper_feederPower().serialize(),
],
scripts: [],
};
|
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds
|
.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
|
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
const gameData = await gameEngineProvider.getGameData(game.id);
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider.removePlayer(game.id, player.id, 'leave');
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
const rankings = await ds.Leaderboard.getTopN(20);
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort((a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
const gameData = await gameEngineProvider.startGame(game.id);
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game.gameState = `ended_${now.format(DATE_FORMAT)}`;
game.endedAt = now.format(FULL_DATETIME_FORMAT);
let gameData: GameEngine.IGameData | undefined = undefined;
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
await gameEngineProvider.endGame(game.id);
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
}
|
src/apis/coop.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/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.8912916779518127
},
{
"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.8849488496780396
},
{
"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.8761925101280212
},
{
"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.875114917755127
},
{
"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.8742427229881287
}
] |
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": " 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.9077552556991577
},
{
"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.8783600330352783
},
{
"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.8780015707015991
},
{
"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.8778769969940186
},
{
"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.874974250793457
}
] |
typescript
|
ds.Players.update.make(player),
);
|
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
|
const gameData = await gameEngineProvider.getGameData(game.id);
|
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider.removePlayer(game.id, player.id, 'leave');
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
const rankings = await ds.Leaderboard.getTopN(20);
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort((a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
const gameData = await gameEngineProvider.startGame(game.id);
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game.gameState = `ended_${now.format(DATE_FORMAT)}`;
game.endedAt = now.format(FULL_DATETIME_FORMAT);
let gameData: GameEngine.IGameData | undefined = undefined;
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
await gameEngineProvider.endGame(game.id);
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
}
|
src/apis/coop.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/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.8813090324401855
},
{
"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.8809809684753418
},
{
"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.8675231337547302
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " engine.broadcast.push({ type: 'playerLeave', playerId, reason });\n GameEngineUtils.revalidateIntents(engine, true);\n for (const remainingPlayer of engine.gameData.players.values()) {\n remainingPlayer.endedTurn = false;\n engine.broadcast.push({\n type: 'playerToggleEndTurn',\n playerId: remainingPlayer.id,\n state: false,\n });\n }",
"score": 0.8646831512451172
},
{
"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.8566068410873413
}
] |
typescript
|
const gameData = await gameEngineProvider.getGameData(game.id);
|
import * as moment from 'moment';
import { createCoopHandler } from './apis/coop.api';
import { IAuthProvider, IDataSource, IPlayerPushProvider, IRateLimitProvider } from './dependencies';
import { CardMod } from './game/card-mods';
import { CardScript } from './game/card-scripts';
import { GameEngine, createGameEngineProvider } from './game/game-engine';
import { GameEngineUtils } from './game/game-engine-utils';
import { IHttpRequest, IHttpRouteHandler, StatusCodes } from './net-utils';
import { FULL_DATETIME_FORMAT } from './utils';
/**
* Main entry point
*/
// TODO: this should be replaced with node:http or expressjs
export const handleRequest = async (req: IHttpRequest) => {
const split = req.path.split('/').filter(Boolean);
const subPath = split.slice(1);
const body = req.body ? JSON.parse(req.body) : null;
const query = req.queryStringParameters || {};
let handler: IHttpRouteHandler | undefined = undefined;
switch (split[0]) {
case 'coop':
handler = coopHandler;
// ... Note: implement remaining route handlers
}
const result = handler ? (await handler(subPath, query, body, req)) : null;
return result || [StatusCodes.badRequest, { reason: 'invalid api' }];
};
/**
* Dependencies
*/
// Note: replace with an actual database
const cardDecksTable = createMockTableDualKey<IDataSource.ICardDeck>('playerId', 'createdAt');
const coopGamesTable = createMockTableSingleKey<IDataSource.ICoopGame>('id');
const playersTable = createMockTableSingleKey<IDataSource.IPlayer>('id');
const playerCoopGamesTable = createMockTableSingleKey<IDataSource.IPlayerCoopGame>('playerId');
const dataSource: IDataSource = {
CardDecks: {
...cardDecksTable,
async queryByDid(did) {
return { items: [...cardDecksTable._db.values()].filter(x => x.playerId === did) };
},
},
CoopGames: {
...coopGamesTable,
async queryByGameState(gameState) {
return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };
},
},
GameData: {
...createMockTableSingleKey<GameEngine.IGameData>('id'),
},
Players: {
...playersTable,
},
PlayerCoopGames: {
...playerCoopGamesTable,
async queryByPlayerId(playerId: string) {
return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };
},
},
Leaderboard: {
getTopN(_n) { return [] as any; },
async set(_playerId, _score) { },
},
async execUpdates(...updateRequests) {
updateRequests.forEach(x => x());
},
};
// Note: replace with an actual auth provider
const authProvider: IAuthProvider = {
generateNewSecret: () => `${Math.random()}`,
getAuthTokenForPlayer: player => player.secret,
getPlayerFromRequest: async () => [...playersTable._db.values()][0]!,
getPlayerIdFromRequest: () => [...playersTable._db.values()][0]?.id!,
};
// Note: replace with an actual push provider
const pushProvider: IPlayerPushProvider = {
async push(playerId, messages) {
console.log(`Push messages for player [${playerId}]:`);
messages.forEach(x => console.log(x));
}
};
const rateLimitProvider: IRateLimitProvider = {
async shouldRateLimitCreateGame(_playerId) {
return false;
},
async shouldRateLimitSearchGame(_playerId) {
return false;
},
};
// Note: replace with custom game content
const gameContent: GameEngine.IRuleset = {
cardMods: { /** Custom card modifiers **/ },
cardScripts: { /** Custom card scripts **/ },
initGame(engine) {
const testEnemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'testEnemy',
cpu: 1,
mem: 1,
maxMem: 1,
mods: [],
scripts: [],
sec: 10,
};
testEnemy.mods.push(new CardMod.Content._standardAi().serialize());
testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());
GameEngineUtils.addEnemy(engine, testEnemy, 0, true);
},
addAdditionalScriptsFor(_card) {
// Note: Called by GameEngine when a player is joined; this hook allows for dynamic scripts for a given card
},
};
const gameEngine = createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
|
const coopHandler = createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider);
|
/**
* Example
*/
(async () => {
/**
* Players are normally created via /players/connectDid; to keep this example concise,
* we'll inject one with CO8's DID into the mock database.
*/
const mockPlayer = {
id: 'did:chia:1sc5hxvcs26e4zsc7uvlfuc7x9sjj5aw6cu0g8vcyvscy49ffp8zqwh63tq',
activeDeckId: '',
activeGameId: '',
secret: '',
authExpiresAt: '2100-01-01',
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),
score: 0,
}
playersTable._db.set(mockPlayer.id, mockPlayer);
/**
* This calls into /coop/create which is a complex API.
* Step thru this to learn about how the route handlers work.
*/
console.log('Creating game...');
await handleRequest({
httpMethod: 'POST',
path: '/coop/create',
body: JSON.stringify({
gameVisibility: 'private',
difficulty: 1,
}),
});
console.log('Game created, gameId: ' + mockPlayer.activeGameId);
/**
* Games normally start automatically when enough players join via /coop/join or /coop/search,
* to keep this example concise, we'll start it directly via the gameEngine reference.
* Step thru this to learn about how the game engine works.
*/
console.log('Starting game...');
await gameEngine.startGame(mockPlayer.activeGameId);
})();
/**
* In-memory DB helpers
* Note: this is a mock database that only satisfies the example above and is
* not meant to be starting point for production.
*/
function createMockTableSingleKey<T extends Record<string, any>>(idKey: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id: string) {
return _db.get(id) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(item[idKey], item);
return item;
},
},
};
}
function createMockTableDualKey<T extends Record<string, any>>(id1Key: keyof T, id2Key: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id1: string, id2: string) {
return _db.get(`${id1}_${id2}`) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(`${item[id1Key]}_${item[id2Key]}`, item);
return item;
},
},
};
}
|
src/reference-example.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/intro.ts",
"retrieved_chunk": " 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.9098170399665833
},
{
"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.9037965536117554
},
{
"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.900330662727356
},
{
"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.8940680027008057
},
{
"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.8854875564575195
}
] |
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": " 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.8791860342025757
},
{
"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.8784996867179871
},
{
"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.8751155138015747
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),\n score: 0,\n }\n playersTable._db.set(mockPlayer.id, mockPlayer);\n /**\n * This calls into /coop/create which is a complex API.\n * Step thru this to learn about how the route handlers work.\n */\n console.log('Creating game...');\n await handleRequest({",
"score": 0.8555072546005249
},
{
"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.854701578617096
}
] |
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.8817586898803711
},
{
"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.8801803588867188
},
{
"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.8736287951469421
},
{
"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.8652501106262207
},
{
"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.8615601062774658
}
] |
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": " 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.8929456472396851
},
{
"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.8703368902206421
},
{
"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.8696209192276001
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " const defaultDeck = await getOrCreateActiveDeck(player, ds);\n defaultDeck && decks.push(defaultDeck)\n }\n return [StatusCodes.ok, { decks: decks.map(deck => toClientDeck(player, deck)) }];\n }\n case 'update': {\n const schema = z.object({\n deckId: z.string(),\n deckLabel: z.string().min(1).max(20),\n nftIds: z.array(z.string().startsWith('nft1')).length(6),",
"score": 0.8588974475860596
},
{
"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.8544949293136597
}
] |
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.8824276924133301
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " engine.broadcast.push({ type: 'playerLeave', playerId, reason });\n GameEngineUtils.revalidateIntents(engine, true);\n for (const remainingPlayer of engine.gameData.players.values()) {\n remainingPlayer.endedTurn = false;\n engine.broadcast.push({\n type: 'playerToggleEndTurn',\n playerId: remainingPlayer.id,\n state: false,\n });\n }",
"score": 0.879510223865509
},
{
"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.8759410381317139
},
{
"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.8756110072135925
},
{
"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.8730935454368591
}
] |
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": " 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.8630797266960144
},
{
"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.8555778861045837
},
{
"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.8551335334777832
},
{
"filename": "src/reference-example.ts",
"retrieved_chunk": " httpMethod: 'POST',\n path: '/coop/create',\n body: JSON.stringify({\n gameVisibility: 'private',\n difficulty: 1,\n }),\n });\n console.log('Game created, gameId: ' + mockPlayer.activeGameId);\n /**\n * Games normally start automatically when enough players join via /coop/join or /coop/search,",
"score": 0.850739598274231
},
{
"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.8452332615852356
}
] |
typescript
|
toClientPlayer(player, authProvider), status: 'gamecreated' }];
|
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
const gameData = await gameEngineProvider.getGameData(game.id);
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider.removePlayer(game.id, player.id, 'leave');
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
const rankings = await ds.Leaderboard.getTopN(20);
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort((a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
|
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
|
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
const gameData = await gameEngineProvider.startGame(game.id);
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game.gameState = `ended_${now.format(DATE_FORMAT)}`;
game.endedAt = now.format(FULL_DATETIME_FORMAT);
let gameData: GameEngine.IGameData | undefined = undefined;
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
await gameEngineProvider.endGame(game.id);
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
}
|
src/apis/coop.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " if (engine.gameData.players.size >= 2) throw new Error('game is full: ' + gameId);\n if (engine.gameData.state === 'started') {\n const playerState = await engine._createPlayerState(playerId, cardIds);\n engine.gameData.players.set(playerId, playerState);\n if (engine.gameData.turn >= 2) {\n playerState.endedTurn = true;\n playerState.movesLeft = 0;\n }\n engine.broadcast.push({\n type: 'playerJoin',",
"score": 0.8541030883789062
},
{
"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.8445298671722412
},
{
"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.8444576859474182
},
{
"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.8442640900611877
},
{
"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.8386144638061523
}
] |
typescript
|
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
|
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
const gameData = await gameEngineProvider.getGameData(game.id);
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider.removePlayer(game.id, player.id, 'leave');
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
const rankings = await ds.Leaderboard.getTopN(20);
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort(
|
(a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
|
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
const gameData = await gameEngineProvider.startGame(game.id);
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game.gameState = `ended_${now.format(DATE_FORMAT)}`;
game.endedAt = now.format(FULL_DATETIME_FORMAT);
let gameData: GameEngine.IGameData | undefined = undefined;
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
await gameEngineProvider.endGame(game.id);
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
}
|
src/apis/coop.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/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.8664103746414185
},
{
"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.8609257340431213
},
{
"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.8523324728012085
},
{
"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.848915696144104
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " const defaultDeck = await getOrCreateActiveDeck(player, ds);\n defaultDeck && decks.push(defaultDeck)\n }\n return [StatusCodes.ok, { decks: decks.map(deck => toClientDeck(player, deck)) }];\n }\n case 'update': {\n const schema = z.object({\n deckId: z.string(),\n deckLabel: z.string().min(1).max(20),\n nftIds: z.array(z.string().startsWith('nft1')).length(6),",
"score": 0.8443438410758972
}
] |
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": " 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.9080268740653992
},
{
"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.9052445888519287
},
{
"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.9043747186660767
},
{
"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.8912513256072998
},
{
"filename": "src/game/rulesets/reaper.ts",
"retrieved_chunk": " enemy.scripts.push(\n new CardScript.Content._attack(enemy, engine.gameData.difficulty).serialize(),\n );\n return enemy;\n },\n reaper_lesser_guardian: (engine: GameEngine.IGameEngine) => {\n const enemy: GameEngine.IEnemyCardState = {\n id: engine.nextId(),\n enemyClass: 'reaper_lesser_guardian',\n cpu: 2,",
"score": 0.8870706558227539
}
] |
typescript
|
createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
|
import * as moment from 'moment';
import { createCoopHandler } from './apis/coop.api';
import { IAuthProvider, IDataSource, IPlayerPushProvider, IRateLimitProvider } from './dependencies';
import { CardMod } from './game/card-mods';
import { CardScript } from './game/card-scripts';
import { GameEngine, createGameEngineProvider } from './game/game-engine';
import { GameEngineUtils } from './game/game-engine-utils';
import { IHttpRequest, IHttpRouteHandler, StatusCodes } from './net-utils';
import { FULL_DATETIME_FORMAT } from './utils';
/**
* Main entry point
*/
// TODO: this should be replaced with node:http or expressjs
export const handleRequest = async (req: IHttpRequest) => {
const split = req.path.split('/').filter(Boolean);
const subPath = split.slice(1);
const body = req.body ? JSON.parse(req.body) : null;
const query = req.queryStringParameters || {};
let handler: IHttpRouteHandler | undefined = undefined;
switch (split[0]) {
case 'coop':
handler = coopHandler;
// ... Note: implement remaining route handlers
}
const result = handler ? (await handler(subPath, query, body, req)) : null;
return result || [StatusCodes.badRequest, { reason: 'invalid api' }];
};
/**
* Dependencies
*/
// Note: replace with an actual database
const cardDecksTable = createMockTableDualKey<IDataSource.ICardDeck>('playerId', 'createdAt');
const coopGamesTable = createMockTableSingleKey<IDataSource.ICoopGame>('id');
const playersTable = createMockTableSingleKey<IDataSource.IPlayer>('id');
const playerCoopGamesTable = createMockTableSingleKey<IDataSource.IPlayerCoopGame>('playerId');
const dataSource: IDataSource = {
CardDecks: {
...cardDecksTable,
async queryByDid(did) {
return { items: [...cardDecksTable._db.values()].filter(x => x.playerId === did) };
},
},
CoopGames: {
...coopGamesTable,
async queryByGameState(gameState) {
return { items: [...coopGamesTable._db.values()].filter(x => x.gameState === gameState) };
},
},
GameData: {
...createMockTableSingleKey<GameEngine.IGameData>('id'),
},
Players: {
...playersTable,
},
PlayerCoopGames: {
...playerCoopGamesTable,
async queryByPlayerId(playerId: string) {
return { items: [...playerCoopGamesTable._db.values()].filter(x => x.playerId === playerId) };
},
},
Leaderboard: {
getTopN(_n) { return [] as any; },
async set(_playerId, _score) { },
},
async execUpdates(...updateRequests) {
updateRequests.forEach(x => x());
},
};
// Note: replace with an actual auth provider
const authProvider: IAuthProvider = {
generateNewSecret: () => `${Math.random()}`,
getAuthTokenForPlayer: player => player.secret,
getPlayerFromRequest: async () => [...playersTable._db.values()][0]!,
getPlayerIdFromRequest: () => [...playersTable._db.values()][0]?.id!,
};
// Note: replace with an actual push provider
const pushProvider: IPlayerPushProvider = {
async push(playerId, messages) {
console.log(`Push messages for player [${playerId}]:`);
messages.forEach(x => console.log(x));
}
};
const rateLimitProvider: IRateLimitProvider = {
async shouldRateLimitCreateGame(_playerId) {
return false;
},
async shouldRateLimitSearchGame(_playerId) {
return false;
},
};
// Note: replace with custom game content
const gameContent: GameEngine.IRuleset = {
cardMods: { /** Custom card modifiers **/ },
cardScripts: { /** Custom card scripts **/ },
initGame(engine) {
const testEnemy: GameEngine.IEnemyCardState = {
id: engine.nextId(),
enemyClass: 'testEnemy',
cpu: 1,
mem: 1,
maxMem: 1,
mods: [],
scripts: [],
sec: 10,
};
testEnemy.mods.push(new CardMod.Content._standardAi().serialize());
testEnemy.scripts.push(new CardScript.Content._attack(testEnemy, engine.gameData.difficulty).serialize());
GameEngineUtils.addEnemy(engine, testEnemy, 0, true);
},
addAdditionalScriptsFor
|
(_card) {
|
// Note: Called by GameEngine when a player is joined; this hook allows for dynamic scripts for a given card
},
};
const gameEngine = createGameEngineProvider({ mfrm: gameContent }, dataSource, pushProvider);
const coopHandler = createCoopHandler(dataSource, gameEngine, authProvider, rateLimitProvider);
/**
* Example
*/
(async () => {
/**
* Players are normally created via /players/connectDid; to keep this example concise,
* we'll inject one with CO8's DID into the mock database.
*/
const mockPlayer = {
id: 'did:chia:1sc5hxvcs26e4zsc7uvlfuc7x9sjj5aw6cu0g8vcyvscy49ffp8zqwh63tq',
activeDeckId: '',
activeGameId: '',
secret: '',
authExpiresAt: '2100-01-01',
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
lastSeenAt: moment.utc().format(FULL_DATETIME_FORMAT),
score: 0,
}
playersTable._db.set(mockPlayer.id, mockPlayer);
/**
* This calls into /coop/create which is a complex API.
* Step thru this to learn about how the route handlers work.
*/
console.log('Creating game...');
await handleRequest({
httpMethod: 'POST',
path: '/coop/create',
body: JSON.stringify({
gameVisibility: 'private',
difficulty: 1,
}),
});
console.log('Game created, gameId: ' + mockPlayer.activeGameId);
/**
* Games normally start automatically when enough players join via /coop/join or /coop/search,
* to keep this example concise, we'll start it directly via the gameEngine reference.
* Step thru this to learn about how the game engine works.
*/
console.log('Starting game...');
await gameEngine.startGame(mockPlayer.activeGameId);
})();
/**
* In-memory DB helpers
* Note: this is a mock database that only satisfies the example above and is
* not meant to be starting point for production.
*/
function createMockTableSingleKey<T extends Record<string, any>>(idKey: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id: string) {
return _db.get(id) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(item[idKey], item);
return item;
},
},
};
}
function createMockTableDualKey<T extends Record<string, any>>(id1Key: keyof T, id2Key: keyof T) {
const _db = new Map<string, T>();
return {
_db,
async get(id1: string, id2: string) {
return _db.get(`${id1}_${id2}`) || null;
},
update: {
make(item: T) {
return () => this.exec(item);
},
async exec(item: T) {
_db.set(`${item[id1Key]}_${item[id2Key]}`, item);
return item;
},
},
};
}
|
src/reference-example.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/game/rulesets/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.9245065450668335
},
{
"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.9176234006881714
},
{
"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.910576581954956
},
{
"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.9102181792259216
},
{
"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.9028419256210327
}
] |
typescript
|
(_card) {
|
import { randomInt } from 'crypto';
import { appraiseCard } from '../appraise';
const excludedChars = ['1', 'b', 'i', 'o'];
const testSize = 1000000;
function generateId() {
let id = 'nft1'.padEnd(54, '_');
while (id.length < 62) {
const i = randomInt(0, 36);
let c: string;
if (i >= 10) {
c = String.fromCharCode(97 + i - 10);
} else {
c = String.fromCharCode(48 + i);
}
if (!excludedChars.includes(c)) {
id += c;
}
}
id = id.substring(0, 55) + (Math.random() < 0.5 ? 's' : 'q') + id.substring(56);
return id;
}
test('appraiseCard', () => {
const results = {
factions: {
backdoor: 0,
bruteforce: 0,
malware: 0,
},
scripts: {
bd_exploit: 0,
bd_decode: 0,
bd_secure: 0,
bf_firewall: 0,
bf_overclock: 0,
bf_spam: 0,
mw_redirect: 0,
mw_freeware: 0,
mw_worm: 0,
},
tiers: [0, 0, 0, 0, 0, 0, 0],
cpu: 0,
mem: 0,
};
for (let i = 0; i < testSize; i++) {
|
const card = appraiseCard({ nftId: generateId(), mintHeight: 1, url: '' });
|
results.factions[card.faction]++;
results.tiers[card.tier]++;
results.cpu += card.cpu;
results.mem += card.mem;
results.scripts[card.coreScript]++;
if (card.cpu + card.mem !== card.tier + 2) {
// This assertion is not done using expect() as it would slow down the test too much
throw new Error('CPU + MEM is expected to be Tier + 2');
}
}
expect(results.factions.bruteforce / results.factions.malware).toBeCloseTo(1, 1);
expect(results.factions.bruteforce / results.factions.backdoor).toBeCloseTo(1.1, 1);
expect(results.cpu / results.mem).toBeCloseTo(1);
expect(results.scripts.bd_decode / results.scripts.bd_exploit).toBeCloseTo(1, 1);
expect(results.scripts.bd_decode / results.scripts.bd_secure).toBeCloseTo(1, 1);
expect(results.scripts.bf_firewall / results.scripts.bf_overclock).toBeCloseTo(1, 1);
expect(results.scripts.bf_firewall / results.scripts.bf_spam).toBeCloseTo(1, 1);
expect(results.scripts.mw_redirect / results.scripts.mw_freeware).toBeCloseTo(1, 1);
expect(results.scripts.mw_redirect / results.scripts.mw_worm).toBeCloseTo(1, 1);
expect(results.tiers[1]! / testSize).toBeCloseTo(.46156);
expect(results.tiers[2]! / testSize).toBeCloseTo(.31667);
expect(results.tiers[3]! / testSize).toBeCloseTo(.16521);
expect(results.tiers[4]! / testSize).toBeCloseTo(.04849);
expect(results.tiers[5]! / testSize).toBeCloseTo(.00759, 3);
// Cannot reliably test T6 as the numbers are so small but if T1-T5 pass then by process of elimination we can assert T6 is correct
});
|
src/tests/appraise.test.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/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.8342604637145996
},
{
"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.8324292302131653
},
{
"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.8275250196456909
},
{
"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.8225973844528198
},
{
"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.8144346475601196
}
] |
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.8832105398178101
},
{
"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.8756083846092224
},
{
"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.8672600388526917
},
{
"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.8666774034500122
},
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " const newAuthExpireAt = moment.utc(now).add({ days: 14 }).format(FULL_DATETIME_FORMAT);\n if (!player) {\n const nowStr = now.format(FULL_DATETIME_FORMAT);\n player = await ds.Players.update.exec({\n id: did,\n createdAt: nowStr,\n lastSeenAt: nowStr,\n secret: newSecret,\n authExpiresAt: newAuthExpireAt,\n activeGameId: '',",
"score": 0.8648819327354431
}
] |
typescript
|
const playerId = authProvider.getPlayerIdFromRequest(req);
|
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
const gameData = await gameEngineProvider.getGameData(game.id);
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider.removePlayer(game.id, player.id, 'leave');
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
|
const rankings = await ds.Leaderboard.getTopN(20);
|
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort((a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
const gameData = await gameEngineProvider.startGame(game.id);
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game.gameState = `ended_${now.format(DATE_FORMAT)}`;
game.endedAt = now.format(FULL_DATETIME_FORMAT);
let gameData: GameEngine.IGameData | undefined = undefined;
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
await gameEngineProvider.endGame(game.id);
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
}
|
src/apis/coop.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/apis/players.api.ts",
"retrieved_chunk": " 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.8692201972007751
},
{
"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.8480944633483887
},
{
"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.8419601917266846
},
{
"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.8359089493751526
},
{
"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.8327866196632385
}
] |
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": " 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.8891488909721375
},
{
"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.8763279914855957
},
{
"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.8753247261047363
},
{
"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.8734713792800903
},
{
"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.8708309531211853
}
] |
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.893567681312561
},
{
"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.8683589100837708
},
{
"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.850334644317627
},
{
"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.846794843673706
},
{
"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.8467151522636414
}
] |
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/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.8777263164520264
},
{
"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.8704069256782532
},
{
"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.8481171131134033
},
{
"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.8478342890739441
},
{
"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.8470560312271118
}
] |
typescript
|
deck = await getOrCreateActiveDeck(player, ds);
|
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
const gameData = await gameEngineProvider.getGameData(game.id);
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider.removePlayer(game.id, player.id, 'leave');
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
const rankings = await ds.Leaderboard.getTopN(20);
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort((a
|
, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
|
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
const gameData = await gameEngineProvider.startGame(game.id);
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game.gameState = `ended_${now.format(DATE_FORMAT)}`;
game.endedAt = now.format(FULL_DATETIME_FORMAT);
let gameData: GameEngine.IGameData | undefined = undefined;
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
await gameEngineProvider.endGame(game.id);
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
}
|
src/apis/coop.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/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.8687026500701904
},
{
"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.86173415184021
},
{
"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.8516689538955688
},
{
"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.8479984402656555
},
{
"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.8461856842041016
}
] |
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": " 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.8805603981018066
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " const defaultDeck = await getOrCreateActiveDeck(player, ds);\n defaultDeck && decks.push(defaultDeck)\n }\n return [StatusCodes.ok, { decks: decks.map(deck => toClientDeck(player, deck)) }];\n }\n case 'update': {\n const schema = z.object({\n deckId: z.string(),\n deckLabel: z.string().min(1).max(20),\n nftIds: z.array(z.string().startsWith('nft1')).length(6),",
"score": 0.8655436038970947
},
{
"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.8610317707061768
},
{
"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.8598989844322205
},
{
"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.8598840236663818
}
] |
typescript
|
gameData = await ds.GameData.get(game.id);
|
import * as moment from 'moment';
import { z } from 'zod';
import { IAuthProvider, IDataSource, IMetricsProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { toClientDeck, toClientPlayer } from '../models';
import { IHttpRouteHandler, StatusCodes } from '../net-utils';
import { FULL_DATETIME_FORMAT } from '../utils';
export const createDeckHandler = (ds: IDataSource, authProvider: IAuthProvider, metrics?: IMetricsProvider): IHttpRouteHandler =>
async (path, query, body, req) => {
switch (path[0]) {
case 'activate': {
const schema = z.object({
deckId: z.string(),
});
const payload = schema.parse(body);
const player = await authProvider.getPlayerFromRequest(req);
const deck = await ds.CardDecks.get(player.id, payload.deckId);
if (!deck) return [StatusCodes.notFound];
player.activeDeckId = deck.createdAt;
await ds.Players.update.exec(player);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), deck: toClientDeck(player, deck) }];
}
case 'create': {
const schema = z.object({
deckLabel: z.string().min(1).max(20),
nftIds: z.array(z.string().startsWith('nft1')).length(6),
});
const payload = schema.parse(body);
const player = await authProvider.getPlayerFromRequest(req);
const nfts = (await Promise.all((payload.nftIds).slice(0, 6).map(ExtDeps.getNft))).filter(Boolean).map(x => x.nft);
if (nfts.length !== 6) {
return [StatusCodes.forbidden, { reason: `not enough nftIds, need 6, got ${nfts.length}` }];
}
const deck = await ds.CardDecks.update.exec({
playerId: player.id,
createdAt: moment.utc().format(FULL_DATETIME_FORMAT),
label: payload.deckLabel,
cards: nfts.map(x => ({ nftId: x.nftId, mintHeight: x.firstBlock, url: x.urls[0] || '' })),
});
|
metrics?.deckUpdated(player.id, deck.createdAt);
|
return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];
}
case 'list': {
const schema = z.object({
ct: z.string().optional(),
});
const q = schema.parse(query);
const player = await authProvider.getPlayerFromRequest(req);
const decks = await Promise.all((await ds.CardDecks.queryByDid(player.id, 10, q.ct)).items);
if (!decks.length) {
const defaultDeck = await getOrCreateActiveDeck(player, ds);
defaultDeck && decks.push(defaultDeck)
}
return [StatusCodes.ok, { decks: decks.map(deck => toClientDeck(player, deck)) }];
}
case 'update': {
const schema = z.object({
deckId: z.string(),
deckLabel: z.string().min(1).max(20),
nftIds: z.array(z.string().startsWith('nft1')).length(6),
});
const payload = schema.parse(body);
const uniqueNftIds = new Set<string>(payload.nftIds);
if (uniqueNftIds.size !== 6) {
return [StatusCodes.badRequest, { reason: 'nftIds must contain 6 unique NFT ids that belong to the player' }];
}
const player = await authProvider.getPlayerFromRequest(req);
const deck = await ds.CardDecks.get(player.id, payload.deckId);
if (!deck) {
return [StatusCodes.notFound, { reason: 'invalid deck id' }];
}
payload.deckLabel && (deck.label = deck.label);
const nfts = (await Promise.all((payload.nftIds).map(ExtDeps.getNft))).filter((x): x is NonNullable<typeof x> => x?.nft.did === player.id).map(x => x.nft);
if (nfts.length !== payload.nftIds.length) {
return [StatusCodes.notFound, { reason: 'one or more nft ids were not found, or did not belong to the player' }];
}
deck.cards = nfts.map(x => ({ nftId: x.nftId, mintHeight: x.firstBlock, url: x.urls[0] || '' }));
await ds.CardDecks.update.exec(deck);
metrics?.deckUpdated(player.id, deck.createdAt);
return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];
}
case 'activeDeck': {
const player = await authProvider.getPlayerFromRequest(req);
return [StatusCodes.ok, { deck: toClientDeck(player, await getOrCreateActiveDeck(player, ds)) }];
}
default: {
if (!path[0]) {
return;
}
const player = await authProvider.getPlayerFromRequest(req);
const deck = await ds.CardDecks.get(player.id, path[0]);
if (!deck) {
return [StatusCodes.notFound];
}
return [StatusCodes.ok, { deck: toClientDeck(player, deck) }];
}
}
};
export const getOrCreateActiveDeck = async (player: IDataSource.IPlayer, ds: IDataSource) => {
let deck = player.activeDeckId ? (await ds.CardDecks.get(player.id, player.activeDeckId)) : null;
if (deck) {
return deck;
}
const cards = (await ExtDeps.getNftsByDidOrWallet(player.id, 6))?.nfts.filter(Boolean) || [];
if (cards.length < 6) {
return null;
}
const nowStr = moment.utc().format(FULL_DATETIME_FORMAT);
player.activeDeckId = nowStr;
deck = {
playerId: player.id,
createdAt: nowStr,
cards: cards.map(x => ({ nftId: x.nftId, mintHeight: x.firstBlock, url: x.urls[0] || '' })),
label: 'default',
};
await ds.execUpdates(
ds.Players.update.make(player, true),
ds.CardDecks.update.make(deck, true),
);
return deck;
};
|
src/apis/decks.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);\n await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));\n if (payload.gameVisibility === 'solo') {\n await _onGameStart(game, false);\n }\n player.activeGameId = game.id;\n await ds.execUpdates(\n ds.CoopGames.update.make(game),\n ds.Players.update.make(player),\n );",
"score": 0.8619245886802673
},
{
"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.8616948127746582
},
{
"filename": "src/apis/coop.api.ts",
"retrieved_chunk": " const [deck, game] = await Promise.all([\n _expectValidActiveDeck(player, true),\n _expectCoopGameJoinable(teammate.activeGameId),\n ]);\n const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));\n player.activeGameId = game.id;\n game.playersIds.add(player.id);\n game.ingorePlayerIds.delete(player.id);\n await ds.execUpdates(\n ds.Players.update.make(player),",
"score": 0.8616534471511841
},
{
"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.8509106636047363
},
{
"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.8409737944602966
}
] |
typescript
|
metrics?.deckUpdated(player.id, deck.createdAt);
|
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
const gameData = await gameEngineProvider.getGameData(game.id);
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider.removePlayer(game.id, player.id, 'leave');
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
const rankings = await ds.Leaderboard.getTopN(20);
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort((a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
const gameData = await gameEngineProvider.startGame(game.id);
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map(x => ExtDeps.getNft(x.nftId)));
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game.gameState = `ended_${now.format(DATE_FORMAT)}`;
game.endedAt = now.format(FULL_DATETIME_FORMAT);
let gameData: GameEngine.IGameData | undefined = undefined;
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
|
await gameEngineProvider.endGame(game.id);
|
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
}
|
src/apis/coop.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/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.8685988187789917
},
{
"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.8609046936035156
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " turn: this.gameData.turn,\n });\n for (const player of this.gameData.players.values()) {\n player.endedTurn = false;\n player.movesLeft = player.movesPerTurn;\n }\n const playerCards = GameEngineUtils.getPlayerCards(this.gameData);\n for (const playerCard of playerCards) {\n GameEngineUtils.changeCardIsUsed(this, playerCard, false);\n }",
"score": 0.8476697206497192
},
{
"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.8465603590011597
},
{
"filename": "src/game/game-engine.ts",
"retrieved_chunk": " engine.broadcast.push({ type: 'playerLeave', playerId, reason });\n GameEngineUtils.revalidateIntents(engine, true);\n for (const remainingPlayer of engine.gameData.players.values()) {\n remainingPlayer.endedTurn = false;\n engine.broadcast.push({\n type: 'playerToggleEndTurn',\n playerId: remainingPlayer.id,\n state: false,\n });\n }",
"score": 0.8452792167663574
}
] |
typescript
|
await gameEngineProvider.endGame(game.id);
|
import { randomBytes } from 'crypto';
import * as moment from 'moment';
import { z } from 'zod';
import { appraiseCard } from '../appraise';
import { IAuthProvider, IDataSource, IMetricsProvider, IRateLimitProvider } from '../dependencies';
import { ExtDeps } from '../external-dependencies';
import { GameEngine, GameEngineProvider } from '../game/game-engine';
import { toClientPlayer } from '../models';
import { IHttpRequest, IHttpRouteHandler, RouteError, StatusCodes } from '../net-utils';
import { DATE_FORMAT, FULL_DATETIME_FORMAT } from '../utils';
import { getOrCreateActiveDeck } from './decks.api';
export const createCoopHandler = (ds: IDataSource, gameEngineProvider: GameEngineProvider, authProvider: IAuthProvider, rateLimit: IRateLimitProvider, metrics?: IMetricsProvider): IHttpRouteHandler => {
return async function handler(path, query, body, req): ReturnType<IHttpRouteHandler> {
switch (path[0]) {
case 'create': {
const schema = z.object({
gameVisibility: z.union([z.literal('public'), z.literal('private'), z.literal('solo')]),
difficulty: z.number(),
});
const payload = schema.parse(body);
const player = await _expectAuthPlayerNotInGame(req);
const deck = await _expectValidActiveDeck(player, true);
if (await rateLimit.shouldRateLimitCreateGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
const now = moment.utc();
const game: IDataSource.ICoopGame = {
id: randomBytes(16).toString('hex'),
createdAt: now.format(FULL_DATETIME_FORMAT),
difficulty: payload.difficulty,
playersIds: new Set([player.id]),
gameState: payload.gameVisibility === 'public' ? 'open' : 'private',
startedAt: '',
endedAt: '',
ingorePlayerIds: new Set(),
isCompleted: false,
_dbTtl: moment.utc(now).add({ days: 1 }).unix(),
};
const initialRulesetId = 'mfrm';
metrics?.gameCreated(game.id, player.id, initialRulesetId, payload.gameVisibility, payload.difficulty);
await gameEngineProvider.createGame(game.id, initialRulesetId, payload.difficulty);
await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
if (payload.gameVisibility === 'solo') {
await _onGameStart(game, false);
}
player.activeGameId = game.id;
await ds.execUpdates(
ds.CoopGames.update.make(game),
ds.Players.update.make(player),
);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamecreated' }];
}
case 'history': {
const playerId = authProvider.getPlayerIdFromRequest(req);
const games = await ds.PlayerCoopGames.queryByPlayerId(playerId, +(query.count || 10), query.ct ? `${query.ct}` : undefined);
return [StatusCodes.ok, games];
}
case 'join': {
const schema = z.object({
teammateDid: z.string().nonempty(),
fromMatchmaking: z.boolean().optional(),
});
const payload = schema.parse(body);
const [player, teammate] = await Promise.all([
_expectAuthPlayerNotInGame(req),
ds.Players.get(payload.teammateDid),
]);
if (!teammate?.activeGameId) {
return [StatusCodes.notFound];
}
const [deck, game] = await Promise.all([
_expectValidActiveDeck(player, true),
_expectCoopGameJoinable(teammate.activeGameId),
]);
const gameData = await gameEngineProvider.addPlayer(game.id, player.id, deck.cards.map(x => x.nftId));
player.activeGameId = game.id;
game.playersIds.add(player.id);
game.ingorePlayerIds.delete(player.id);
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
if (!game.startedAt && game.playersIds.size >= 2) {
await _onGameStart(game, !!payload.fromMatchmaking);
}
metrics?.gameJoined(game.id, gameData.turn >= 2);
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider), status: 'gamejoined' }];
}
case 'leave': {
const { player, game } = await _expectAuthPlayerInGame(req);
player.activeGameId = '';
if (!game.gameState.startsWith('ended')) {
game.playersIds.delete(player.id);
game.ingorePlayerIds.add(player.id);
}
await ds.execUpdates(
ds.Players.update.make(player),
ds.CoopGames.update.make(game),
);
try {
const gameData = await gameEngineProvider.getGameData(game.id);
const playerState = gameData.players.get(player.id);
if (!game.gameState.startsWith('ended') && playerState && gameData.state !== 'created' && gameData.turn > 1) {
const now = moment.utc().format(FULL_DATETIME_FORMAT);
await ds.PlayerCoopGames.update.exec({
playerId: player.id,
endedAt: now,
gameId: game.id,
gameResult: _getGameResult(gameData),
score: playerState.score,
teammates: _getOtherPlayerIds(player.id, game),
turns: gameData.turn,
difficulty: gameData.difficulty,
rulesetIds: gameData.rulesetIds,
}, true);
}
} catch (e: any) {
console.error(e);
}
try {
await gameEngineProvider.removePlayer(game.id, player.id, 'leave');
} catch {
// Respect the player's request to leave even if the gameData couldn't be updated for some reason
}
if (!game.playersIds.size) {
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
}
return [StatusCodes.ok, { player: toClientPlayer(player, authProvider) }];
}
case 'rankings': {
const rankings = await ds.Leaderboard.getTopN(20);
return [StatusCodes.ok, { rankings }];
}
case 'search': {
const player = await _expectAuthPlayerNotInGame(req);
// Don't need to validate nft ownership yet, either join() or create() will do this
const deck = await _expectValidActiveDeck(player, false);
let ct: any = undefined;
do {
const result = await ds.CoopGames.queryByGameState('open', 10, ct);
const games = result.items.sort((a, b) => a.ingorePlayerIds.size - b.ingorePlayerIds.size);
for (const game of games) {
if (game.playersIds.size < 2 && !game.ingorePlayerIds.has(player.id)) {
const gameData = await ds.GameData.get(game.id);
if (!gameData || !game.playersIds.size) {
// GameData already TTL'd this is a dead session
await finalizeGame(game.id, true, ds, gameEngineProvider, metrics);
continue;
}
if (gameData.players.size >= 2 || (gameData.state !== 'created' && gameData.state !== 'started')) {
// Game is full or not in a joinable state
continue;
}
if (await rateLimit.shouldRateLimitSearchGame(player.id)) {
return [StatusCodes.tooManyRequests];
}
return await handler(['join'], {}, { teammateDid: [...gameData.pendingPlayers.keys()][0] || [...gameData.players.keys()][0], fromMatchmaking: true }, req);
}
}
ct = result.ct;
} while (ct);
// No joinable game found - proceed to create a public game
const difficulty = body?.difficulty || (1 + (deck.cards.map(appraiseCard).reduce((sum, x) => sum + x.tier, 0) / deck.cards.length) | 0);
return await handler(['create'], {}, { gameVisibility: 'public', difficulty }, req);
}
case 'start': {
const { game } = await _expectAuthPlayerInGame(req);
const gameData = await ds.GameData.get(game.id);
if (gameData?.state !== 'created') {
return [StatusCodes.forbidden];
}
await _onGameStart(game, false);
return [StatusCodes.ok];
}
}
return;
}
async function _onGameStart(game: IDataSource.ICoopGame, fromMatchmaking: boolean) {
const gameData = await gameEngineProvider.startGame(game.id);
const now = moment.utc();
game.startedAt = now.format(FULL_DATETIME_FORMAT);
game._dbTtl = 9999999999;
await ds.CoopGames.update.exec(game);
metrics?.gameStarted(game.id, gameData.rulesetIds[0] || 'unknown', [...gameData.players.keys()], fromMatchmaking);
}
async function _expectAuthPlayerInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (!player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has no active game id');
const game = await ds.CoopGames.get(player.activeGameId);
if (game) {
return {
player,
game,
};
}
player.activeGameId = '';
await ds.Players.update.exec(player);
throw new RouteError(StatusCodes.forbidden, 'player is not in game');
}
async function _expectAuthPlayerNotInGame(req: IHttpRequest) {
const player = await authProvider.getPlayerFromRequest(req);
if (player.activeGameId) throw new RouteError(StatusCodes.forbidden, 'player has an active game id');
return player;
}
async function _expectCoopGameJoinable(gameId: string) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new RouteError(StatusCodes.forbidden, 'game not found');
if (game.playersIds.size >= 2) throw new RouteError(StatusCodes.forbidden, 'game is full');
if (game.endedAt) throw new RouteError(StatusCodes.forbidden, 'game has ended');
return game;
}
async function _expectValidActiveDeck(player: IDataSource.IPlayer, validateNftOwnership: boolean) {
const deck = await getOrCreateActiveDeck(player, ds);
if (!deck) throw new RouteError(StatusCodes.forbidden, 'player has no active deck');
if (validateNftOwnership) {
const nfts = await Promise.all(deck.cards.map
|
(x => ExtDeps.getNft(x.nftId)));
|
if (nfts.find(x => !x || x.nft.did !== player.id)) {
metrics?.nftOwnershipConflict(player.id);
throw new RouteError(StatusCodes.conflict, 'some cards do not belong to the did');
}
}
return deck;
}
};
export async function finalizeGame(gameId: string, removePlayers: boolean, ds: IDataSource, gameEngineProvider: GameEngineProvider, metrics?: IMetricsProvider) {
const game = await ds.CoopGames.get(gameId);
if (!game) throw new Error('game not found: ' + gameId);
if (game.gameState.startsWith('ended')) return;
const now = moment.utc();
game.gameState = `ended_${now.format(DATE_FORMAT)}`;
game.endedAt = now.format(FULL_DATETIME_FORMAT);
let gameData: GameEngine.IGameData | undefined = undefined;
let gameResult: IDataSource.IPlayerCoopGame['gameResult'] = 'unknown';
try {
gameData = await gameEngineProvider.getGameData(game.id);
gameResult = _getGameResult(gameData);
} catch { }
metrics?.gameEnded(
game.id,
gameResult,
gameData?.rulesetIds || [],
[...game.playersIds], gameData?.turn || -1, [...gameData?.players.values() || []].reduce((sum, x) => sum + x.score, 0),
);
const playerUpdates = (await Promise.all([...game.playersIds].map(async playerId => {
const player = await ds.Players.get(playerId);
if (!player) {
console.error(`_onGameEnd: player ${playerId} in ${game.id} not found`);
return;
}
if (player.activeGameId === game.id) {
removePlayers && (player.activeGameId = '');
const playerState = gameData?.players.get(playerId);
if (playerState?.score) {
player.score += playerState?.score || 0;
await ds.Leaderboard.set(player.id, player.score);
}
return [
ds.PlayerCoopGames.update.make({
playerId,
endedAt: game.endedAt,
gameId: game.id,
gameResult,
score: playerState?.score || 0,
teammates: _getOtherPlayerIds(playerId, game),
turns: gameData?.turn || -1,
difficulty: game.difficulty,
rulesetIds: gameData?.rulesetIds || [],
}, true),
ds.Players.update.make(player, true),
];
}
return;
}))).filter(Boolean).flat();
await ds.execUpdates(
...playerUpdates,
ds.CoopGames.update.make(game),
);
try {
await gameEngineProvider.endGame(game.id);
} catch {
}
}
function _getGameResult(gameData: GameEngine.IGameData): IDataSource.IPlayerCoopGame['gameResult'] {
switch (gameData.state) {
case 'abandoned': return 'abandoned';
case 'players_lost': return 'loss';
case 'players_won': return 'win';
case 'started': return 'abandoned';
default:
return 'unknown';
}
}
function _getOtherPlayerIds(playerId: string, game: IDataSource.ICoopGame) {
return [
...[...game.playersIds.keys()].filter(x => x !== playerId),
// ...[...game.ingorePlayerIds.keys()].filter(x => x !== playerId),
];
}
|
src/apis/coop.api.ts
|
chiatcg-chiatcg-server-0c3f71d
|
[
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " 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.8807199001312256
},
{
"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.8799114227294922
},
{
"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.8760335445404053
},
{
"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.8666170835494995
},
{
"filename": "src/apis/decks.api.ts",
"retrieved_chunk": " const defaultDeck = await getOrCreateActiveDeck(player, ds);\n defaultDeck && decks.push(defaultDeck)\n }\n return [StatusCodes.ok, { decks: decks.map(deck => toClientDeck(player, deck)) }];\n }\n case 'update': {\n const schema = z.object({\n deckId: z.string(),\n deckLabel: z.string().min(1).max(20),\n nftIds: z.array(z.string().startsWith('nft1')).length(6),",
"score": 0.8602919578552246
}
] |
typescript
|
(x => ExtDeps.getNft(x.nftId)));
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.