diff --git a/SerialPrograms/Source/CommonTools/ScreenMachine/ScreenObservation.h b/SerialPrograms/Source/CommonTools/ScreenMachine/ScreenObservation.h new file mode 100644 index 0000000000..737b074d77 --- /dev/null +++ b/SerialPrograms/Source/CommonTools/ScreenMachine/ScreenObservation.h @@ -0,0 +1,44 @@ +/* Screen Observation + * + * From: https://github.com/PokemonAutomation/ + * + * What one look at the game showed, as facts rather than pixels: the + * events on screen (a fade, a dialog box, a battle) and named readings. A + * console fills it from a frame with the game's detectors; a simulation + * fills it from its model and has no frame. Code that decides on an + * observation alone therefore runs in both. + * + */ + +#ifndef PokemonAutomation_CommonTools_ScreenObservation_H +#define PokemonAutomation_CommonTools_ScreenObservation_H + +#include +#include +#include +#include +#include "Common/Cpp/Time.h" +#include "CommonFramework/VideoPipeline/VideoFeed.h" +#include "CommonTools/ScreenEvents/ScreenEventTypes.h" + +namespace PokemonAutomation{ + + +// One look at the game. +struct ScreenObservation{ + // When the look was taken. Only a default; no reader treats min() as + // "not set". + WallClock when = WallClock::min(); + ScreenEvents events = {}; + // Named numbers the game's readers found, by names the game chooses; + // "heading" is degrees clockwise from north, [0, 360). + std::map> readings = {}; + // The frame looked at; none in a simulation. A state that needs it + // can only run on a console. + std::optional frame = std::nullopt; +}; + + + +} // namespace PokemonAutomation +#endif diff --git a/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryActionNotImplemented.cpp b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryActionNotImplemented.cpp new file mode 100644 index 0000000000..d50dccd657 --- /dev/null +++ b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryActionNotImplemented.cpp @@ -0,0 +1,21 @@ +/* Story Action Not Implemented + * + * From: https://github.com/PokemonAutomation/ + * + */ + +#include +#include "Pokemon_StoryActionNotImplemented.h" + +namespace PokemonAutomation{ +namespace Pokemon{ + + +StoryActionNotImplemented::StoryActionNotImplemented(std::string message) + : OperationFailedException(ErrorReportMode::NO_ERROR_REPORT, std::move(message)) +{} + + + +} // namespace Pokemon +} // namespace PokemonAutomation diff --git a/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryActionNotImplemented.h b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryActionNotImplemented.h new file mode 100644 index 0000000000..566ade4269 --- /dev/null +++ b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryActionNotImplemented.h @@ -0,0 +1,35 @@ +/* Story Action Not Implemented + * + * From: https://github.com/PokemonAutomation/ + * + */ + +#ifndef PokemonAutomation_Pokemon_StoryActionNotImplemented_H +#define PokemonAutomation_Pokemon_StoryActionNotImplemented_H + +#include +#include "CommonFramework/Exceptions/OperationFailedException.h" + +namespace PokemonAutomation{ +namespace Pokemon{ + + +// A story action the game has no code for yet, thrown with what it waits +// for instead of pressing buttons blind. A game's backend lets it end the +// run instead of reloading and trying again, since every attempt would +// fail the same way. +class StoryActionNotImplemented : public OperationFailedException{ +public: + explicit StoryActionNotImplemented(std::string message); + + // code-health: allow char_pointer -- Exception::name() returns a const char pointer in the base class + virtual const char* name() const override{ + return "StoryActionNotImplemented"; + } +}; + + + +} // namespace Pokemon +} // namespace PokemonAutomation +#endif diff --git a/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryBackend.cpp b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryBackend.cpp new file mode 100644 index 0000000000..2c4e6d074b --- /dev/null +++ b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryBackend.cpp @@ -0,0 +1,36 @@ +/* Story Backend + * + * From: https://github.com/PokemonAutomation/ + * + */ + +#include "Pokemon_StoryBackend.h" + +namespace PokemonAutomation{ +namespace Pokemon{ + + +std::string_view story_backend_kind_name(StoryBackendKind kind){ + switch (kind){ + case StoryBackendKind::CONSOLE: + return "console"; + case StoryBackendKind::SIMULATION: + return "simulation"; + case StoryBackendKind::SCRIPT: + return "script"; + } + return "unknown"; +} + +std::optional story_heading(const ScreenObservation& observation){ + const auto reading = observation.readings.find(STORY_HEADING); + if (reading == observation.readings.end()){ + return std::nullopt; + } + return reading->second; +} + + + +} // namespace Pokemon +} // namespace PokemonAutomation diff --git a/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryBackend.h b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryBackend.h new file mode 100644 index 0000000000..5c8f363eae --- /dev/null +++ b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryBackend.h @@ -0,0 +1,99 @@ +/* Story Backend + * + * From: https://github.com/PokemonAutomation/ + * + * Input and observation, nothing else: what the story engine drives. One + * per run. A console backend wraps the console's controller and video and + * builds each observation with the game's detectors; a simulation backend + * wraps a model of the game. The engine and every action run the same on + * both. + * + */ + +#ifndef PokemonAutomation_Pokemon_StoryBackend_H +#define PokemonAutomation_Pokemon_StoryBackend_H + +#include +#include +#include "Common/Cpp/CancellableScope.h" +#include "Common/Cpp/Time.h" +#include "CommonTools/ScreenMachine/ScreenObservation.h" +#include "NintendoSwitch/Controllers/NintendoSwitch_ControllerButtons.h" +#include "Pokemon/AutoStory/Pokemon_StoryOutcome.h" +#include "Pokemon/AutoStory/Types/Pokemon_StoryActionArg.h" +#include "Pokemon/Navigation/Pokemon_Grid.h" +#include "Pokemon_StoryPoseConcept.h" +#include "Pokemon_ZonePose.h" + +namespace PokemonAutomation{ +namespace Pokemon{ + + +// How fast a held direction moves the player. +enum class StoryPace{ + WALK, + RUN, +}; + +// What a backend plays on. An action declared console_only +// (StoryActionSpec) runs only on CONSOLE: it reads or presses through +// screens nothing else models (menus, a keyboard, a battle AI). +enum class StoryBackendKind{ + CONSOLE, + SIMULATION, + SCRIPT, // a scripted fake, for unit tests +}; + +// "console", "simulation", "script". +std::string_view story_backend_kind_name(StoryBackendKind kind); + +// The reading (ScreenObservation::readings) of the way the player faces in +// a game without tiles: degrees clockwise from north (straight on, for a +// camera-relative game), in [0, 360). A backend that can read it cheaply +// sets it in each observe(); otherwise a game's reader of this name does. +inline constexpr std::string_view STORY_HEADING = "heading"; + +// `observation`'s STORY_HEADING reading; none when nothing read it. +std::optional story_heading(const ScreenObservation& observation); + +// One look at the game, with where the player is when a reader knows it +// (StoryGame::readers fill `pose` and the readings). +template +struct Observation : public ScreenObservation{ + std::optional pose = std::nullopt; +}; + +// The engine's only way to the game. +// code-health: allow public_methods -- the agreed backend boundary is these low-level calls; splitting them would make every action take two objects +template +class StoryBackend{ +public: + virtual ~StoryBackend() = default; + + virtual StoryBackendKind kind() const = 0; + + virtual void press(NintendoSwitch::Button button, Milliseconds hold, Milliseconds release) = 0; + // One tile in `direction`, or a turn to face it. + virtual void tap(Direction direction) = 0; + virtual void hold(Direction direction, Milliseconds duration, StoryPace pace) = 0; + // The move stick held at `degrees` clockwise from north (straight on, + // for a camera-relative game) for `duration`, then let go for `release` + // (a turn's time to finish) like press(): the free-moving games' walk + // and turn. A tile game's hold() is this at a multiple of 90. + virtual void stick(double degrees, Milliseconds duration, Milliseconds release, StoryPace pace) = 0; + virtual void wait(Milliseconds duration) = 0; + // The game now, once every input sent so far has been done. + virtual Observation observe() = 0; + // A whole battle, from its start to the overworld. High level for now: + // a console fights with the game's battle code, a simulation with its + // battle model. `args` are the BATTLE step's. + virtual Outcome battle(const StoryActionArgs& args) = 0; + virtual void log(std::string_view line) = 0; + virtual CancellableScope& scope() = 0; +}; + + + +} // namespace Pokemon +} // namespace PokemonAutomation +#endif diff --git a/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryGame.h b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryGame.h new file mode 100644 index 0000000000..151d1a7411 --- /dev/null +++ b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryGame.h @@ -0,0 +1,139 @@ +/* Story Game + * + * From: https://github.com/PokemonAutomation/ + * + * What a game hands the story engine: its actions, its readers and its + * save, as data plus functions. No subclassing. The engine registers the + * shared built-in actions first (Pokemon_StoryBuiltinActions.h); a game's + * action with the same kind and name replaces the built-in one. + * + */ + +#ifndef PokemonAutomation_Pokemon_StoryGame_H +#define PokemonAutomation_Pokemon_StoryGame_H + +#include +#include +#include +#include +#include +#include "Pokemon/AutoStory/Pokemon_StoryCheckpointTypes.h" +#include "Pokemon/AutoStory/Pokemon_StoryOutcome.h" +#include "Pokemon/AutoStory/Types/Pokemon_StoryActionArg.h" +#include "Pokemon/AutoStory/Types/Pokemon_StoryActionSpec.h" +#include "Pokemon/AutoStory/Types/Pokemon_StoryBreakpoints.h" +#include "Pokemon/AutoStory/Types/Pokemon_StoryCheckpoint.h" +#include "Pokemon/AutoStory/Types/Pokemon_StoryStep.h" +#include "Pokemon_StoryBackend.h" + +namespace PokemonAutomation{ +namespace Pokemon{ + + +// What an action is asked to do: the step it runs (its name and why, for +// the log and for what an action tunes by step) and the step's args with +// their fallbacks filled in. Both live for the call only. +struct StoryActionCall{ + const StoryStep& step; + const StoryActionArgs& args; + // The run's pause points: an action that walks legs calls + // before_leg() before each (Pokemon_StoryBreakpoints.h). + StoryPausePoints& pause; +}; + +// An action's code: reads its call's args and drives the backend. A +// succeeded action that knows where it left the player returns that pose +// in its Outcome. +template +using StoryActionHandler = std::function& backend, const StoryActionCall& call, RunState& state)>; + +// Fills an observation's pose or readings from what the backend saw: a +// console reads the frame (OCR, templates), a simulation its model. +template +using StoryReader = std::function& backend, Observation& observation)>; + +// When the engine runs a reader. +enum class StoryReaderUse{ + // Only for a step's skip_if condition of its name: it is slow, or + // needs a screen a checkpoint need not end on (PLZA's heading waits + // for the minimap and throws without it). + ON_REQUEST, + // Also after a checkpoint whose postconditions need what it supplies: + // it is cheap and safe on any screen a checkpoint ends on. + AFTER_CHECKPOINT, +}; + +// What the engine reads the game with. A reader whose name is a step's +// skip_if condition answers it: the condition holds when the reader sets +// a non-zero reading of that name. +template +struct StoryGameReader{ + std::string name = {}; + // What it fills: "pose" (Observation::pose), a reading ("heading"), or + // every reading with a prefix ("bag.*", "flag.*"). + std::vector supplies = {}; + // Opt in to the postcondition check with AFTER_CHECKPOINT. + StoryReaderUse use = StoryReaderUse::ON_REQUEST; + // It reads a console's screen: never run on another backend. + bool console_only = false; + StoryReader read = {}; +}; + +// Whether `supplies` (StoryGameReader::supplies) covers `need`: the same +// name, or a prefix ending in "*" that `need` starts with. +inline bool story_reader_supplies(const std::vector& supplies, std::string_view need){ + for (const std::string& each : supplies){ + if (each == need){ + return true; + } + if (each.ends_with('*') && need.starts_with(std::string_view(each).substr(0, each.size() - 1))){ + return true; + } + } + return false; +} + +// An action: its spec (kind, name, args) and its code. +template +struct StoryAction{ + StoryActionSpec spec = {}; + StoryActionHandler handler = {}; +}; + +// A game, for the engine. +template +struct StoryGame{ + // "frlg", "bdsp", "plza". + std::string id = {}; + // The game's own actions, and its replacements of built-in ones. + std::vector> actions = {}; + // "pose", "bag", "heading", or a skip_if condition. + std::vector> readers = {}; + // The game's save (the menu, or a wait for an autosave) at the end of + // `checkpoint`, or at its SAVE step. The engine decides whether to call + // it (Pokemon_StoryEnginePolicy.h). + std::function& backend, const StoryCheckpoint& checkpoint)> save = {}; + // Back to the last save. A succeeded reload that knows where it left + // the player returns that pose in its Outcome. + std::function& backend)> reload = {}; + // Called as each attempt at a checkpoint starts, to reset what the game + // keeps per attempt (trainers who can see us again). Optional. + std::function begin_attempt = {}; + // What can stop a step part-way (a wild battle, a trainer who saw + // us), built for each checkpoint run. Optional. + std::function(StoryBackend& backend)> interrupts = {}; + // Where the run pauses for the user to look at the console, and what a + // pause does: the engine calls the hook with a label such as + // "12.03/5 pallet_shore" before each step, and the walk action with + // "12.03/5 pallet_shore leg 2/5 east 4 -> (10, 10)" before each leg + // (only with LEGS). Optional: with no hook, or OFF, a run never pauses. + // The hook returns when the run goes on, or when the run is cancelled. + StoryBreakpoints breakpoints = StoryBreakpoints::OFF; + StoryPauseHook pause_point = {}; +}; + + + +} // namespace Pokemon +} // namespace PokemonAutomation +#endif diff --git a/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryPoseConcept.cpp b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryPoseConcept.cpp new file mode 100644 index 0000000000..6b0e1dfa58 --- /dev/null +++ b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryPoseConcept.cpp @@ -0,0 +1,45 @@ +/* Story Pose Concept + * + * From: https://github.com/PokemonAutomation/ + * + */ + +#include +#include +#include +#include "Pokemon_StoryPoseConcept.h" + +namespace PokemonAutomation{ +namespace Pokemon{ + + +bool pose_matches(const GridPose& actual, const GridPose& target){ + if (actual.map != target.map){ + return false; + } + if (target.facing && actual.facing != target.facing){ + return false; + } + if (target.tiles.empty()){ + return true; + } + return !actual.tiles.empty() && std::all_of(actual.tiles.begin(), actual.tiles.end(), [&](const TilePos& tile){ + return std::find(target.tiles.begin(), target.tiles.end(), tile) != target.tiles.end(); + }); +} + +std::string pose_text(const GridPose& pose){ + std::string text = pose.map; + for (const TilePos& tile : pose.tiles){ + text += std::format(" {}", to_string(tile)); + } + if (pose.facing){ + text += std::format(" facing {}", direction_name(*pose.facing)); + } + return text; +} + + + +} // namespace Pokemon +} // namespace PokemonAutomation diff --git a/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryPoseConcept.h b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryPoseConcept.h new file mode 100644 index 0000000000..6969ff5290 --- /dev/null +++ b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_StoryPoseConcept.h @@ -0,0 +1,86 @@ +/* Story Pose Concept + * + * From: https://github.com/PokemonAutomation/ + * + * What the story engine needs of a game's pose type: whether a pose read + * off the game is a target, a line of text for the log, and its traits + * (StoryPoseTraits): whether the player moves tile by tile, and which kind + * of declared pose (Types/Pokemon_DeclaredPose.h) a checkpoint declares + * for it (its start, a step's end). The + * tile games (FRLG, BDSP) use GridPose; a game that moves freely brings + * its own type (PLZA: ZonePose, a zone until it has a position reader). + * + */ + +#ifndef PokemonAutomation_Pokemon_StoryPoseConcept_H +#define PokemonAutomation_Pokemon_StoryPoseConcept_H + +#include +#include +#include +#include "Pokemon/AutoStory/Types/Pokemon_DeclaredPose.h" +#include "Pokemon/AutoStory/Types/Pokemon_GridPose.h" + +namespace PokemonAutomation{ +namespace Pokemon{ + + +// What the engine may do with a pose type, beyond the concept below. Each +// pose type specializes it next to its definition: +// +// static constexpr bool TILE_MOVES; +// Whether the player moves tile by tile. Only then does a game +// get the built-in "legs" and "face" actions: a tap is a tile. +// A game with no tiles may not use the tile args (DIRECTION, LEGS, +// GRID_POSE): the lint fails a step or an action that does. +// using Declared = TileDeclared or ZoneDeclared; +// The kind of pose a checkpoint of this game declares in its JSON +// ("start", a step's "declared_after"). The lint fails a +// checkpoint that declares the other kind (check_declared()). +// +// A declared pose reaches the run as the event layer's pose +// (grid_pose_of() in Pokemon_StoryStepExecutor.h): a zone's place reads +// as a map with no tiles, and its spot and heading are not carried. They +// wait for a game with a position reader to compare them against. +template +struct StoryPoseTraits; + +// A tile game's pose: tile moves; it declares a map, tiles and a facing. +template <> +struct StoryPoseTraits{ + static constexpr bool TILE_MOVES = true; + using Declared = TileDeclared; +}; + +// A pose the engine can carry: pose_matches(actual, target) and +// pose_text(pose), found by argument-dependent lookup, and its traits. +template +concept StoryPose = std::copyable && requires(const PoseType& actual, const PoseType& target){ + { pose_matches(actual, target) } -> std::convertible_to; + { pose_text(actual) } -> std::convertible_to; + { StoryPoseTraits::TILE_MOVES } -> std::convertible_to; + typename StoryPoseTraits::Declared; +}; + +// Whether `declared` is the kind of pose a game of `PoseType` declares. +template +bool check_declared(const DeclaredPose& declared); + +template +bool check_declared(const DeclaredPose& declared){ + return std::holds_alternative::Declared>(declared); +} + +// Whether `actual` is on `target`'s map, each of its tiles is one of +// `target`'s (any tile when `target` names none), and it faces `target`'s +// facing when `target` has one. +bool pose_matches(const GridPose& actual, const GridPose& target); + +// "PalletTown (3, 4) facing north". +std::string pose_text(const GridPose& pose); + + + +} // namespace Pokemon +} // namespace PokemonAutomation +#endif diff --git a/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_ZonePose.cpp b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_ZonePose.cpp new file mode 100644 index 0000000000..3dabf2da1d --- /dev/null +++ b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_ZonePose.cpp @@ -0,0 +1,40 @@ +/* Zone Pose + * + * From: https://github.com/PokemonAutomation/ + * + */ + +#include +#include +#include "Pokemon_ZonePose.h" + +namespace PokemonAutomation{ +namespace Pokemon{ + + +bool pose_matches(const ZonePose& actual, const ZonePose& target){ + return target.zone.empty() || actual.zone == target.zone; +} + +std::string pose_text(const ZonePose& pose){ + return std::format("zone {}", (pose.zone.empty() ? std::string("unknown") : pose.zone)); +} + +double direction_degrees(Direction direction){ + switch (direction){ + case Direction::NORTH: + return 0; + case Direction::EAST: + return 90; + case Direction::SOUTH: + return 180; + case Direction::WEST: + return -90; + } + return 0; +} + + + +} // namespace Pokemon +} // namespace PokemonAutomation diff --git a/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_ZonePose.h b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_ZonePose.h new file mode 100644 index 0000000000..13993e1ef5 --- /dev/null +++ b/SerialPrograms/Source/Pokemon/AutoStory/Engine/Pokemon_ZonePose.h @@ -0,0 +1,51 @@ +/* Zone Pose + * + * From: https://github.com/PokemonAutomation/ + * + * The pose of a game with no tile grid (PLZA): the zone the player is in, + * by name, until the game has a reader of its position. A StoryPose + * (Pokemon_StoryPoseConcept.h). + * + */ + +#ifndef PokemonAutomation_Pokemon_ZonePose_H +#define PokemonAutomation_Pokemon_ZonePose_H + +#include +#include "Pokemon/AutoStory/Types/Pokemon_DeclaredPose.h" +#include "Pokemon/Navigation/Pokemon_Grid.h" +#include "Pokemon_StoryPoseConcept.h" + +namespace PokemonAutomation{ +namespace Pokemon{ + + +// Where the player is: a zone, "LumioseCity" or "HotelZ". +struct ZonePose{ + std::string zone = {}; + + bool operator==(const ZonePose& other) const = default; +}; + +// Whether `actual` is in `target`'s zone; any zone when `target` names none. +bool pose_matches(const ZonePose& actual, const ZonePose& target); + +// "zone LumioseCity". +std::string pose_text(const ZonePose& pose); + +// `direction` as degrees clockwise of straight on (0, 90, 180, -90). +double direction_degrees(Direction direction); + +// No tiles: no built-in tile walks. It declares a place, whose name is the +// zone; the spot and heading wait for a position reader. +template <> +struct StoryPoseTraits{ + static constexpr bool TILE_MOVES = false; + using Declared = ZoneDeclared; +}; + + + +} // namespace Pokemon +} // namespace PokemonAutomation +#endif diff --git a/SerialPrograms/cmake/SourceFiles.cmake b/SerialPrograms/cmake/SourceFiles.cmake index f2adf943f0..d45634744f 100644 --- a/SerialPrograms/cmake/SourceFiles.cmake +++ b/SerialPrograms/cmake/SourceFiles.cmake @@ -919,6 +919,7 @@ file(GLOB LIBRARY_SOURCES Source/CommonTools/ScreenEvents/ScreenEvents_Tests.h Source/CommonTools/ScreenEvents/ScreenEventTypes.h Source/CommonTools/ScreenEvents/ScreenFades.h + Source/CommonTools/ScreenMachine/ScreenObservation.h Source/CommonTools/StartupChecks/StartProgramChecks.cpp Source/CommonTools/StartupChecks/StartProgramChecks.h Source/CommonTools/StartupChecks/VideoResolutionCheck.cpp @@ -1467,6 +1468,15 @@ file(GLOB LIBRARY_SOURCES Source/Pokemon/AutoStory/Data/Pokemon_StoryStepJson.h Source/Pokemon/AutoStory/Data/Pokemon_StoryStepJson_Tests.cpp Source/Pokemon/AutoStory/Data/Pokemon_StoryStepJson_Tests.h + Source/Pokemon/AutoStory/Engine/Pokemon_StoryActionNotImplemented.cpp + Source/Pokemon/AutoStory/Engine/Pokemon_StoryActionNotImplemented.h + Source/Pokemon/AutoStory/Engine/Pokemon_StoryBackend.cpp + Source/Pokemon/AutoStory/Engine/Pokemon_StoryBackend.h + Source/Pokemon/AutoStory/Engine/Pokemon_StoryGame.h + Source/Pokemon/AutoStory/Engine/Pokemon_StoryPoseConcept.cpp + Source/Pokemon/AutoStory/Engine/Pokemon_StoryPoseConcept.h + Source/Pokemon/AutoStory/Engine/Pokemon_ZonePose.cpp + Source/Pokemon/AutoStory/Engine/Pokemon_ZonePose.h Source/Pokemon/AutoStory/Pokemon_AutoStory_Tests.h Source/Pokemon/AutoStory/Pokemon_BuiltinStoryActions.cpp Source/Pokemon/AutoStory/Pokemon_BuiltinStoryActions.h