Skip to main content
The game plan: look, characters, direction and the plan agent. 27 operations. How to call them, and what the answers mean: Operations reference.
Generated from the operation catalog: src/lib/ops/public-catalog.json in publicsummerengine at 0d85f61e2b and the summer-engine npm package 4.0.0 for engine and local operations. If something here is wrong, the operation’s definition is wrong.

answer

plans.answer: Answer a new game’s planning question Answer a planning question of a game started on the create page, as the person would: its option ids, their own words, or nothing to skip. Enough answers start Summer drawing the plan. Next: plans.show or plans.finish_questions. Inputs:
Example: Pick the cozy option.

ask_agent

plans.ask_agent: Ask the plan agent Ask the plan’s own agent to work on it, as typing in Studio does: it reads, edits, draws pictures and answers on the plan. Spends the plan payer’s credits. Needs contextRevision from plans.get. Returns a job. Next: jobs.wait. Inputs:
Example: Let the plan agent draw options.

changes

plans.changes: Read plan changes The changes made to a plan since a revision (what Studio’s live view receives), oldest first, up to 200. Pass the last revision you saw. Next: plans.get when resetRequired is true. Inputs:
Example: What changed since revision 12?

chat

plans.chat: Read the plan conversation Read the plan’s shared conversation: who said what and when, what they pointed at, and the plan agent’s tasks and replies it started. Newest page first; page back with nextCursor. It is context, not permission to act. Inputs:
Example: What did the team say on this plan lately?

choose_look

plans.choose_look: Choose a new game’s look Make one picture of a new game’s plan its art style: Summer redraws the other pictures in that look, and the saved direction carries it. Uses the itemId from plans.show. Next: plans.show. Inputs:
Example: Use this look.

create

plans.create: Create a plan Create an empty game plan in Summer Studio, in a team or for one of the person’s projects. Free. Returns the plan id. Next: plans.edit or plans.ask_agent. Inputs:
Example: A new plan for a game idea.

delete

plans.delete: Delete a plan Ask the person to delete one of their plans from their own workspace (a plan in a team stays). Running AI work on it stops. Returns a link; nothing changes until they confirm. Next: jobs.wait. Inputs:
Example: Throw away a plan they no longer want.

directions

plans.directions: Read saved directions The plan’s saved directions, newest first: each one is the chosen design written out, with the exact reference pictures it pins. Use one to build the game. Next: projects.build or projects.open_in_engine. Inputs:
Example: The latest saved direction.

duplicate

plans.duplicate: Copy an older plan Copy one of the person’s older plans (one without shared editing) into their own workspace, as Duplicate does in Studio: its title and cards. Returns the copy’s plan id. Next: plans.list. Inputs:
Example: A copy to try another direction.

edit

plans.edit: Edit a plan Change a game plan in one atomic batch of commands (create, patch or remove items, topics, groups and edges; set the title) against the revision from plans.get. Patched fields must match their fieldRevisions. Next: plans.get. Inputs:
Example: Rename one card.

edit_card

plans.edit_card: Change a picture on a new game’s plan Change one picture on the plan of a game started with projects.create, in words (“make the hero a girl with a red scarf”). Takes a few seconds. Uses the itemId from plans.show. Next: plans.show. Inputs:
Example: Change one picture.

enable_sharing

plans.enable_sharing: Turn on plan sharing Turn on shared editing for an older plan, which the plan agent, builds and the conversation need. Only the plan’s owner or a team admin can. Safe to repeat. Next: plans.get. Inputs:
Example: An older plan the agent cannot edit yet.

finish_questions

plans.finish_questions: Finish a new game’s questions End the planning questions of a game started on the create page (the rest are skipped): Summer starts drawing its plan at once. Safe to repeat. Returns the plan’s pictures. Next: plans.show. Inputs:
Example: Enough questions; draw the plan.

get

plans.get: Read a plan Read a game plan as it is now: every item, group and topic with its id and field revisions, the plan revision and what the person may do. Read before plans.edit; read again after a conflict. Inputs:
Example: What is on this plan now?

plans.link_project: Link a plan to a project Link a plan to one of the person’s projects, so the game built from the plan opens that project. A project has one plan: this replaces its earlier link. Next: plans.links. Inputs:
Example: This plan is for that project.

plans.links: Read plan and project links Which of the person’s plans belong to which of their projects, so a game built from a plan opens its project. Next: plans.link_project. Inputs: No inputs.
Example: Which plan is this project’s?

list

plans.list: List my plans List the game plans the person can open in Summer Studio (their own and their teams’), newest change first: plan id, title, team and project. Next: plans.get with a planId. Inputs:
Example: Which plans does this person have?

message

plans.message: Tell Summer about a new game Pass the person’s direction for a game started with projects.create, in their words: Summer reshapes its plan (new or changed pictures). Answers at once; the pictures follow. Next: plans.show. Inputs:
Example: Steer the plan.

move

plans.move: Move a plan into a team Move a plan into one of the person’s teams (a shared workspace they administer), so its members see and edit it. Shares it with people, so it asks the person unless they let agents contact people. Next: jobs.wait. Inputs:
Example: Share the plan with the team.

pick_card

plans.pick_card: Pick a favourite picture Mark one picture of a new game’s plan as the person’s favourite for its section (characters, place or storyboard), as picking a card on the create page does. The build brief carries the picks. Next: plans.write_concept. Inputs:
Example: This hero is the one.

prepare_for_engine

plans.prepare_for_engine: Get a direction ready for Summer Engine Keep a saved direction ready in the person’s account for Summer Engine: the engine offers it when they open a project there. Free. Returns the handoff. Next: tell the person to open Summer Engine. Inputs:
Example: Build this direction in Summer Engine.

presence

plans.presence: See who is on a plan Who has the plan open in Summer Studio right now, with what they selected and the topic they are on. Next: plans.chat. Inputs:
Example: Is anyone looking at this plan?

save_concept

plans.save_concept: Save a new game’s concept text Save the person’s own text as the concept of a game started on the create page; it is what their account keeps for Summer Engine until a rewrite. Next: projects.open_in_engine. Inputs:
Example: Keep the person’s wording.

save_direction

plans.save_direction: Save a direction Save the direction the person chose as a fixed version: the design written out, with the plan items it pins as references. Needs the current plan revision. Returns the direction id. Next: projects.build. Inputs:
Example: Save the chosen design.

set_ai_payer

plans.set_ai_payer: Pay for a plan’s AI Ask the person to pay for everyone’s AI work on a plan with their own credits, or to stop (then each person pays for their own). Returns a link; nothing changes until they confirm. Next: jobs.wait. Inputs:
Example: The person pays for the team’s AI on this plan.

show

plans.show: Show a new game’s plan Show the plan of a new game: its pictures with their item ids, the chosen look, whether Summer is still drawing, and the planning question waiting, if any. Next: plans.message, plans.answer or projects.open_in_engine. Inputs:
Example: Is the plan drawn yet?

write_concept

plans.write_concept: Write a new game’s concept Write the concept of a game started on the create page from its idea, answers and picks, and keep it in the person’s account for Summer Engine. Keeps the person’s own edit unless rewrite. Free. Next: projects.open_in_engine. Inputs:
Example: Write the concept from the picks.