diff --git a/.gitignore b/.gitignore
index 8c66a73..76a500d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,4 +4,6 @@ concept/
 resources/
 release/
 out/
-external/
\ No newline at end of file
+external/
+.codex
+AGENTS.md
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9c25837..549cbbf 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -108,17 +108,15 @@ set (TINYXML2_SOURCES ${TINYXML2_DIR}/tinyxml2.cpp)
 
 file(GLOB PROJECT_SRC CONFIGURE_DEPENDS
 	        include/*.cpp
+	        src/developer/*.cpp
 	        src/*.cpp
 	        src/render/*.cpp
 	        src/resource/*.cpp
-	        src/resource/xml/*.cpp
 	        src/state/*.cpp
 	        src/state/play/*.cpp
 	        src/state/play/menu/*.cpp
-	        src/state/play/menu/arcade/*.cpp
 	        src/state/play/item/*.cpp
 	        src/state/select/*.cpp
-	        src/entity/*.cpp
 	        src/window/*.cpp
 	        src/util/*.cpp
 	        src/util/imgui/*.cpp
diff --git a/MODDING.md b/MODDING.md
index dac8a77..31fd0a3 100644
--- a/MODDING.md
+++ b/MODDING.md
@@ -14,13 +14,13 @@ My process for making characters is that they're typically comprised of many "ce
 
 If you'd like a quick primer on how to use either program, check either of [these](https://www.youtube.com/watch?v=qU_GMo2l7NY) [videos](https://www.youtube.com/watch?v=QiXVM6Gwzlw) out. Much of the information is interchangeable between the programs, though both are a little out of date on their current version.
 
-Stage-specific character animations are controlled by `AnimationAppendID` on each stage in `character.xml`. The base stage uses no suffix. Later stages append that stage's configured suffix.
+Stage-specific character animations are controlled by `AppendStringForAnimations` on each stage in `character.xml`. The base stage uses no suffix. Later stages append that stage's configured suffix.
 
 Example:
 
 - stage 1: `Look`
-- stage 2 with `AnimationAppendID="Stage2"`: `LookStage2`
-- stage 5 with `AnimationAppendID="Stage5"`: `LookStage5`
+- stage 2 with `AppendStringForAnimations="Stage2"`: `LookStage2`
+- stage 5 with `AppendStringForAnimations="Stage5"`: `LookStage5`
 
 Animation references in XML should still use just the base name like `Look`, `Neutral`, or `Eat`. The game appends the current stage's suffix automatically.
 
@@ -43,7 +43,6 @@ Shweet's Sim uses a collection of [XML](https://en.wikipedia.org/wiki/XML) files
 - items.xml
 - menu.xml
 - strings.xml
-- skill_check.xml
 
 The game currently expects `character.xml`. The rest are optional in the sense that the loader will warn and continue if some are missing, but most real characters will want nearly all of them.
 
@@ -57,10 +56,14 @@ If you're making your own character, your best bet would probably be just to cop
 ### Areas
 #### TextureRootPath (path)
 Working folder/directory of textures the areas will use.
+#### Anm2RootPath (path)
+Working folder/directory of anm2 files the areas will use. If omitted, TextureRootPath is used.
 
 #### Area
 #### Texture (path)
 The file path of the area's texture (background).
+#### Anm2 (path)
+The file path of the area's animated background. If this is set, it is used instead of Texture.
 #### Gravity (float)
 Gravity the area has; applies to items' velocities per tick.
 #### Friction (float)
@@ -86,45 +89,43 @@ Character's "anm2" file (uses TextureRootPath); should have all the character's
 A general description of the character; will show in the Select screen.
 #### Credits (string)
 Credits text shown in the Select screen's Credits tab.
-#### Weight (double, kilograms)
+#### WeightKilograms (double)
 The character's starting weight, in kilograms.
-#### WeightMax (double, kilograms)
+#### WeightMaxKilograms (double)
 Maximum weight the character can reach.
-#### Capacity (double, calories)
+#### CapacityCalories (double)
 The character's starting capacity, in calories.
-#### CapacityMin (double, calories)
+#### CapacityMinCalories (double)
 The character's minimum capacity, in calories.
-#### CapacityMax (double, calories)
+#### CapacityMaxCalories (double)
 Maximum base capacity.
-#### CapacityMaxMultiplier (double)
+#### CapacityOverstuffedMultiplier (double)
 Multiplier used when computing the effective full threshold from current base capacity.
 #### CapacityIfOverStuffedOnDigestBonus (double, multiplier)
 Additional capacity gained on digest when the character was over base capacity.
 #### CaloriesToKilogram (double)
 Determines how many calories become a kilogram (1 cal -> X kg).
-#### DigestionRate (double, percent/tick)
-The base digestion rate, in percent per tick (60 ticks per second).
-#### DigestionRateMin (double, percent/tick)
-The minimum digestion rate for the character, in percent per tick.
-#### DigestionRateMax (double, percent/tick)
-The maximum digestion rate for the character, in percent per tick.
+#### DigestionRatePerSecond (double, percent/second)
+The base digestion rate, in percent per second.
+#### DigestionRatePerSecondMin (double, percent/second)
+The minimum digestion rate for the character, in percent per second.
+#### DigestionRatePerSecondMax (double, percent/second)
+The maximum digestion rate for the character, in percent per second.
 #### DigestionTimerMax (int, ticks)
 When digesting, the digestion bar will count down, and then when it hits 0, the current calories will be digested. This determines how long this takes, in ticks.
-#### EatSpeed (double)
+#### EatSpeedMultiplier (double)
 A multiplier that speeds/slows down the eating animation, at base.
-#### EatSpeedMin (double)
+#### EatSpeedMinMultiplier (double)
 Determines the minimum eating speed multiplier.
-#### EatSpeedMax (double)
+#### EatSpeedMaxMultiplier (double)
 Determines the maximum eating speed multiplier.
 #### BlinkChance (double, percent)
 Chance each tick to trigger a blink override.
 #### GurgleChance (double, percent)
 Determines how often the character will gurgle (see the Gurgle sounds later) per tick. 
-#### GurgleCapacityMultiplier (double)
+#### GurgleChanceFromCapacityMultiplier (double)
 Per the character's capacity, multiplies the character's gurgle chance based on the percent of capacity filled (based on max capacity). Higher capacity = higher gurgle chance, using this number at maximum.
-#### TextBlipPeriodBase (int)
-How many displayed dialogue characters elapse between blip sounds. `3` means every third displayed character.
-#### DialoguePoolID (string)
+#### DialoguePool (string)
 Determines the character's base dialogue options (for the "How are you feeling?" option in Chat). This is effectively "Stage 1"'s dialogue; each stage should have its own dialogue pool (see later). Also see dialogue.xml for how "Pools" work.
 #### ColorR, ColorG, ColorB (float, 0-1)
 UI accent color for the character.
@@ -140,13 +141,13 @@ ID of spritesheet that the alternate spritesheet will replace in the character's
 Chance of rolling for the alternate spritesheet on starting a new game, in percent.
 ### Stages
 A "stage" represents each visual change of the character as the weight increases. By default, there's always one stage; adding more here will add additional stages.
-#### Threshold (float, kilograms)
+#### ThresholdKilograms (float)
 The weight threshold to reach this stage, in kilograms.
 #### AreaID (int)
 Reserved for background switching. Parsed, but not currently used by gameplay.
-#### DialoguePoolID (string)
+#### DialoguePool (string)
 Determines the stage's dialogue options (for the "How are you feeling?" option in Chat). Also see dialogue.xml for how "Pools" work.
-#### AnimationAppendID (string)
+#### AppendStringForAnimations (string)
 Suffix appended to base animation names while this stage is active. Usually `Stage2`, `Stage3`, etc.
 ### Animations
 The character's animations. Know that a lot of character animations are typically easily played/activated through Dialogue; this is just for animations that aren't reliant on that system. Know that _these animations should just be the base name_; all animations are expected to have a stage number after them, so don't include the number for these.
@@ -160,9 +161,9 @@ When over capacity, this idle animation will be used instead.
 When going to a new stage after digestion and going over a stage's threshold, this animation will play.
 #### Animation
 The name of the animation to be used for each of these.
-### Overrides
-"Overrides" are the term I use for when some animations will be tweaked by the game engine for effect (blinking and talking being the ones used). There are two elements; "Talk" and "Blink" for this. Typically, how this is handled is that each animation with have an invisible blinking/talking layer (just the graphic that blinks), which will change when called for. Again, review the .anm2 format for what a "layer" is. All that's sourced is just the spritesheet crop in these cases; so don't worry about how the blink/talk layers are set up.
-### Override
+### AnimationOverrides
+"AnimationOverrides" are the term I use for when some animations will be tweaked by the game engine for effect (blinking and talking being the ones used). There are two elements; "Talk" and "Blink" for this. Typically, how this is handled is that each animation with have an invisible blinking/talking layer (just the graphic that blinks), which will change when called for. Again, review the .anm2 format for what a "layer" is. All that's sourced is just the spritesheet crop in these cases; so don't worry about how the blink/talk layers are set up.
+### Talk / Blink
 #### LayerSource (string)
 The layer in the animation which will be sourced for the override.
 #### LayerDestination (string)
@@ -174,7 +175,7 @@ An "eat area" is where the food should be dragged to. I'm pretty much expecting
 The null area in the animation where food will be checked for. Again, review the .anm2 format.
 #### Animation (string)
 The animation that will play when food is dragged to it.
-#### Event (string)
+#### EventToActivate (string)
 The event that will be checked for, detrermining the time the food is actually eaten/chewed. Again, review the .anm2 format.
 ### ExpandAreas
 The areas which will expand based on capacity percent; usually a stomach. This adds additional scale onto the layer of an animation. This also can scale a null as well.
@@ -184,51 +185,63 @@ ExpandAreas are presently hardcoded to scale with both capacity and weight at a
 The layer of the animation that will expand.
 #### Null (string)
 The null of the animation that will expand.
-#### ScaleAdd (float, percent)
+#### ScaleMultiplierMaximum (float, percent)
 The scale that will be added at maximum. Know that scale is a percent; a {100, 100} scale is the default and is the normal scale of an animation.
-### InteractAreas
-The areas on a character which can be interacted with; usually for belly rubs, kisses, etc.
+### InteractAreaTypes
+Default behavior for each interaction type. These entries should not have `Null`; they define shared cursor animations, sounds, particles, and bonuses for concrete `InteractAreas`.
 ### InteractArea
-#### Type ("Rub", "Kiss", "Smack")
-Three types are presently hard-coded in, but this is kind of hacky and custom support for different interactions may later be added. The cursor will need to be set from the "Tools" in order for each interact area to be activated.
-#### Null (string)
-The null in which the interact area can be triggered. Again, review the .anm2 format.
-#### Layer (string; optional)
-Layer used for scale-effect interactions such as smacks.
+#### Type (string)
+The interaction type name. Concrete interact areas with the same `Type` inherit unspecified values from this definition.
+#### GlyphFromIconFont (string)
+The icon-font glyph used for this interaction in the tools bar.
+#### IsHold (bool)
+If true, the interaction is held rather than clicked once.
 #### AnimationCursorHover (string)
 The animation the cursor will play when hovering over the interact area. 
 #### AnimationCursorActive (string)
 The animation the cursor will play when holding down click over the interact area.
-#### DialoguePoolID (string)
-The dialogue pool which will be drawn from when activating an interact area (see dialogue.xml).
-#### DialoguePoolIDFull (string)
-Dialogue pool used when the character is over capacity.
-#### IsHold (bool)
-If true, the interaction is held rather than clicked once.
-#### DigestionBonusRub (float)
-Digestion bonus applied repeatedly while rubbing.
-#### DigestionBonusClick (float)
+#### DigestionBonusOnHover (float)
+Digestion bonus applied repeatedly while hovering with a held interaction.
+#### DigestionBonusOnClick (float)
 Digestion bonus applied when a click-based interaction lands.
-#### Time (float)
-Used by click effects such as smacks.
+#### TimeTicks (float)
+Used by click effects such as smacks. If omitted, the engine uses a short default duration.
+#### TimeToActivateNewDialogueTicks (int)
+Ticks that must pass without this interact area being interacted with before it can start a new dialogue.
 #### ScaleEffectAmplitude (float)
 Visual scale effect amount for click interactions.
 #### ScaleEffectCycles (float)
 How many oscillations the scale effect performs.
+### InteractAreas
+The concrete areas on a character which can be interacted with; usually for belly rubs, kisses, etc.
+### InteractArea
+#### Type (string)
+The interaction type to use. This should match one of the entries in `InteractAreaTypes`.
+#### Null (string)
+The null in which the interact area can be triggered. Again, review the .anm2 format.
+#### Layer (string; optional)
+Layer used for scale-effect interactions such as smacks.
+#### DialoguePool (string)
+The dialogue pool which will be drawn from when activating an interact area (see dialogue.xml).
+#### DialoguePoolFull (string)
+Dialogue pool used when the character is over capacity.
 ### Sound
 An interact area can play multiple sounds when interacting; add additional Sound elements to achieve this. Don't worry about repeatedly-loaded sounds; the game will cache them beforehand for efficiency.
 #### Path (path)
 The path of the sound being used.
-### Sounds
-Sounds that play in some contexts.
-### Blip
-Dialogue blip sounds. One is played periodically while text reveals.
+### Particle
+An interact area can trigger multiple particle effects.
+#### Type (string)
+The particle type from `particles.xml`.
+### Actions
+Sounds that play in character-level contexts. Each action can contain multiple `Sound` elements.
 ### Digest
 Sounds that will play when the character begins digesting (digestion bar full).
 ### Gurgle
-Ambient sounds that will play randomly based on capacity; see GurgleChance and GurgleCapacityMultiplier above.
-#### Sound (path)
-The path of the sound for the specific sound type.
+Ambient sounds that will play randomly based on capacity; see GurgleChance and GurgleChanceFromCapacityMultiplier above.
+### Sound
+#### Path (path)
+The path of the sound for the specific action.
 
 ## cursor.xml
 Determines the cursor appearance and behavior.
@@ -253,24 +266,47 @@ The cursor's zoom animation, when zooming in/out with the mouse wheel.
 The cursor's return animation, when holding right click to return an item to the inventory (or to dispose of it if chewed.)
 #### Animation (string)
 The animation the cursor will use in these contexts.
-### Sounds
-Know that multiple of these sounds can be defined for each context.
+### Actions
+Know that multiple sounds can be defined for each action by adding `Sound` children.
 ### Grab
 The sound that will play when grabbing an item.
 ### Release
 The sound that will play when releasing an item.
 ### Throw
 The sound that will play when throwing an item (releasing when dragging quickly).
-#### Sound (path)
+### Sound
+#### Path (path)
 The path of the sound for these respective contexts.
 
 ## dialogue.xml
 The collection of character dialogue; likely the biggest file, depending on your needs. 
 ### Dialogue
+#### SoundRootPath (path)
+Working folder/directory of where dialogue sounds will be contained within.
+#### DelayTicks (int)
+How many update ticks pass before the next dialogue character is revealed.
+#### BlipDelayTicks (int)
+How many displayed dialogue characters elapse between blip sounds. `3` means every third displayed character.
+### TextPlayback
+Groups the dialogue text reveal settings.
+### Blip
+Dialogue blip sound. One is played periodically while text reveals. Add one or more `Sound` children.
+### Sound
+#### Path (path)
+The path to the sound that will play, based on SoundRootPath.
+### DelayCharacters
+Groups character-specific delay rules.
+### DelayCharacter
+#### Character (string)
+The character that should add an extra delay while text reveals.
+#### DelayTicks (int)
+Extra update ticks to pause after this character.
+#### IsDisableTalk (bool)
+If true, the talking override pauses during this character's delay.
 ### Entries
 ### Entry
 Each bit of dialogue is referred to as an "entry".
-#### ID (string)
+#### Label (string)
 Name for the entry. Other entries will rely on this for dialogue chains.
 #### Next (string)
 The ID of the entry that will follow after this one. If no Next entry, the text will not continue. Make sure to connect these.
@@ -278,6 +314,8 @@ The ID of the entry that will follow after this one. If no Next entry, the text
 The actual dialogue content of the entry. Should support Unicode, provided the font contains the characters.
 #### Animation (string)
 A character animation that will play at the beginning of the dialogue. This may be expanded into the future to allow animations to play dynamically per dialogue index. Again, make sure it's just the base name for the animation, no stage numbers.
+### Effects
+Dialogue effects can be added as child elements of an `Entry`. `Small` and `Big` are fixed text scale effects. `Oscillation`, `Shake`, and `Screenshake` use engine defaults for their strength/timing values; do not write `Amplitude`, `Frequency`, `Period`, `Magnitude`, or `TimeTicks` for those effects. `Scale` and `Rainbow` are no longer supported.
 ### Choice
 Dialogue can be branching; simply added "Choice" elements into the Entry element.
 #### Next (string)
@@ -287,74 +325,74 @@ The text of the choice; will appear as a series of buttons in the text window.
 ### Pools
 A "pool" of dialogue refers to a collection of entries that can be randomly picked in some contexts.
 ### Pool
-#### ID (string)
+#### Label (string)
 The name of the dialogue pool; can be referenced elsewhere.
-### PoolEntry
-### ID (string)
+### Entry
+### Entry (string)
 The name of the entry; to be added to the pool.
 
 ### Start
 This dialogue will play upon a new game, once its animation has concluded.
 #### Animation (string)
 The name of the animation that will be played.
-#### ID (string)
+#### Label (string)
 The name of the entry that will be played.
 ### End
 The dialogue that will play upon completion of the game (character hitting max stage).
-#### ID (string)
+#### Label (string)
 The name of the entry that will be played.
 ### Help
 The dialogue that will be play when the player presses the "Help" button in "Chat".
-#### ID (string)
+#### Label (string)
 The name of the entry that will be played.
 
 ### StageUp
 Dialogue that will play after a character undergoes a stage up.
-#### PoolID (string)
+#### Pool (string)
 The name of the pool that entries will be drawn from.
 ### Random
 The dialogue that will be play when the player presses the "Let's chat!" button in "Chat".
-#### PoolID (string)
+#### Pool (string)
 The name of the pool that entries will be drawn from.
 ### Feed
 The dialogue that will be play when the user begins holding a food item.
-#### PoolID (string)
+#### Pool (string)
 The name of the pool that entries will be drawn from.
 ### FeedFull
 The dialogue that will be play when the user begins holding a food item, when the character is over capacity.
-#### PoolID (string)
+#### Pool (string)
 The name of the pool that entries will be drawn from.
 ### Eat
 The dialogue that will be play after the character finishes a food item.
-#### PoolID (string)
+#### Pool (string)
 The name of the pool that entries will be drawn from.
 ### EatFull
 The dialogue that will be play after the character finishes a food item, when the character is over capacity.
-#### PoolID (string)
+#### Pool (string)
 The name of the pool that entries will be drawn from.
 ### Full
 The dialogue that will be play when the character is completely full and will deny the user feeding them.
-#### PoolID (string)
+#### Pool (string)
 The name of the pool that entries will be drawn from.
 ### Throw
 The dialogue that will be play when the user throws food.
-#### PoolID (string)
+#### Pool (string)
 The name of the pool that entries will be drawn from.
 ### LowCapacity
 The dialogue that will be play when the character is presented a food item completely over their maximum capacity.
-#### PoolID (string)
+#### Pool (string)
 The name of the pool that entries will be drawn from.
 ### Digest
 The dialogue that will be play when digesting is finished.
-#### PoolID (string)
+#### Pool (string)
 The name of the pool that entries will be drawn from.
 ### FoodTaken
 The dialogue that will play when food is removed from the null area during a character's eating animation.
-#### PoolID (string)
+#### Pool (string)
 The name of the pool that entries will be drawn from.
 ### FoodTakenFull
 The dialogue that will play when food is removed from the null area during a character's eating animation, when the character is over capacity.
-#### PoolID (string)
+#### Pool (string)
 The name of the pool that entries will be drawn from.
 
 ## items.xml
@@ -372,23 +410,18 @@ The base anm2 file that items will use. Items can technically have their own .an
 When items are chewed, play this animation family. The game looks for `Chew0`, `Chew1`, `Chew2`, and so on inside the item's `.anm2`.
 #### Animation (string)
 The name of the animation. Only the base part ("Chew", usually)
-### Sounds
-The various item sounds. Multiple of the same element can be defined to randomly play from a selection.
+### Actions
+The various item actions. Each action can contain multiple `Sound` elements to randomly play from a selection.
 ### Bounce
 The sound that will play when an item is bounced (hitting a floor/wall/ceiling with velocity).
-#### Sound (path)
-The path to the sound that will play, based on SoundRootPath.
 ### Dispose
 The sound that will play when an item is disposed of (when an item has chewed and is right clicked).
-#### Sound (path)
-The path to the sound that will play, based on SoundRootPath.
 ### Summon
 The sound that will play when an item is spawned (clicking on it in inventory).
-#### Sound (path)
-The path to the sound that will play, based on SoundRootPath.
 ### Return
 The sound that will play when an item is returned to inventory (right clicking on it in world).
-#### Sound (path)
+### Sound
+#### Path (path)
 The path to the sound that will play, based on SoundRootPath.
 ### Categories
 The kinds of items present. Will appear in inventory tooltips.
@@ -408,9 +441,9 @@ Different rarities of item. Shows in inventory and each can have their own drop
 #### Name (string)
 Name of the rarity.
 #### Chance (float, percent)
-Base chance of finding an item in the Skill Check reward logic.
+Relative rarity weight for item systems.
 #### Sound (path)
-Sound that will play when an item is found in the Skill Check minigame.
+Sound that will play when an item of this rarity is awarded.
 #### IsHidden (bool)
 If true, items with this rarity will not be previewed in the inventory, unlesss possessed. Assumed false if not present.
 ### Items
@@ -463,8 +496,6 @@ Optional item UI color. Missing components default to `0` if any color component
 The name of another item that this item will be able to be upgraded to.
 #### UpgradeCount (int; optional)
 The amount of this item it will take to upgrade to the upgrade item specified in UpgradeID.
-#### IsSkillCheckReward (bool; optional)
-The item can be given as a Skill Check reward.
 #### IsToggleSpritesheet (bool; optional)
 When used in the inventory, will toggle the character's spritesheet (in Pokemon terms, toggling normal/shiny palettes).
 
@@ -475,105 +506,31 @@ See [`src/resource/xml/strings.hpp`](src/resource/xml/strings.hpp) for how strin
 ## menu.xml
 Determines menu and general UI appearance and behavior.
 
-### MenuSchema
+### Menu
 #### SoundRootPath (path)
 Working folder/directory of where used sounds will be contained within.
 #### FontRootPath (path)
 Working folder/directory of where used fonts will be contained within.
 #### Font (path)
 The font the menu will use, based on FontRootPath.
-#### Rounding (float)
+#### ButtonRounding (float)
 The rounding of corners the UI will use.
-### Sounds
-Menu sounds.
+### Actions
+Menu sound actions. Each action can contain one or more `Sound` elements.
 ### Open
 Will play when opening a sliding menu panel.
-#### Sound (path)
-The sound that will play, based on SoundRootPath.
 ### Close
 Will play when closing a sliding menu panel.
-#### Sound (path)
-The sound that will play, based on SoundRootPath.
 ### Hover
 Will play when hovering over a widget in a menu.
-#### Sound (path)
-The sound that will play, based on SoundRootPath.
 ### Select
 Will play when clicking on a widget in a menu.
-#### Sound (path)
-The sound that will play, based on SoundRootPath.
 ### CheatsActivated
 Sound that will play after entering a special code to activate cheats.
-#### Sound (path)
+### Sound
+#### Path (path)
 The sound that will play, based on SoundRootPath.
 
-## skill_check.xml
-Determines behavior and appearance of the "Skill Check" minigame.
-
-### SkillCheck
-#### SoundRootPath (path)
-Working folder/directory of where used sounds will be contained within.
-#### RewardScore (int)
-The score where a rewarded item will be given (see items.xml)
-#### RewardScoreBonus (float, percent)
-Based on the player's score, will add additional bonus to being rewarded items.
-#### RewardGradeBonus (float, percent)
-Based on the player's grades for a round of play, will add additional bonus to being rewarded items.
-#### SpeedMin (float, unit/tick)
-The beginning/base speed of the bar in the minigame.
-#### SpeedMax (float, unit/tick)
-The maximum speed the bar in the minigame can achieve.
-#### SpeedScoreBonus (float)
-The additional speed of the bar based on the player's score.
-#### RangeBase (float)
-A "range" is each area in the minigame that can be hit. This is the base size of one. Per each grade, it's halved. Range size decreases as minigame progresses.
-#### RangeMin (float)
-The minimum size of a range; achievable at high scores.
-#### RangeScoreBonus (float)
-Really a negative. The range size will decrease this much per point of score.
-#### EndTimerMax (int)
-The period of time between plays of the minigame.
-#### EndTimerFailureMax (int)
-When a player fails (no ranges hit), the minigame will pause for this amount of time before restarting.
-### Sounds
-### Fall
-The sound that plays when an item falls from being rewarded.
-#### Sound (path)
-The sound that will play, based on SoundRootPath.
-### ScoreLoss
-The sound that plays when the bar goes over the edge and loops, deducting a point.
-#### Sound (path)
-The sound that will play, based on SoundRootPath.
-### HighScore
-The sound that plays when the player achieves a high score. Only heard when a high score has been set during the play session.
-#### Sound (path)
-The sound that will play, based on SoundRootPath.
-### HighScoreLoss
-The sound that plays when the player has achieved a high score, and then fails.
-#### Sound (path)
-The sound that will play, based on SoundRootPath.
-### RewardScore
-The sound that plays when the player has hit the reward score.
-#### Sound (path)
-The sound that will play, based on SoundRootPath.
-### Grades
-A "grade" is a rank the player can get. This determines the count of ranges in the minigame; each range corresponds to a grade.
-### Grade
-#### Name (string)
-The name of the grade; will appear when the player hits its respective range in the minigame.
-#### NamePlural (string)
-The plural name of the grade; will appear in Stats.
-#### Value (int)
-The reward value of the grade, in points.
-#### Weight (float)
-The "weight" of the grade; used to determine accuracy score in Stats.
-#### IsFailure (bool)
-If the player hits this grade's respective range, will count as failure.
-#### DialoguePoolID (string; optional)
-If the player hits this grade, the character will speak dialogue from this pool (see dialogue.xml)
-#### Sound (path)
-This sound will play when the grade is hit.
-
 # Saves
 
 Outside of resources, Shweet's Sim also has a few files it writes outside of the game. You will find these in %AppData%/shweets-sim on Windows and ~/.local/share/shweets-sim on Linux.
@@ -584,6 +541,8 @@ Stores general game settings and configuration; beyond invididual characters.
 Determines measurement system (kg/lb).
 ### Volume (int, percent)
 Master volume.
+### IsAudioMuted (bool)
+If true, all audio is muted.
 ### ColorR, ColorG, ColorB (float, 0-1)
 Red/Green/Blue components of menu color.
 ### WindowX, WindowY (int)
@@ -601,15 +560,15 @@ Determines if the game has been completed (character's max stage has been reache
 Determines if the character's spritesheet is using the alternate version (in Pokemon, would be the "shiny" version
 
 ### Character
-#### Weight (float)
+#### WeightKilograms (float)
 Character's current weight, in kilograms.
 #### Calories (float)
 Character's current consumed calories.
-#### Capacity (float)
-Character's capacity, in calories. Remember, max capacity effectively is capacity * CapacityMaxMultiplier (from character.xml) 
-#### DigestionRate (float, percent)
-Character's digestion rate in percent, per game tick (game ticks 60 times per second).
-#### EatSpeed (float)
+#### CapacityCalories (float)
+Character's capacity, in calories. Remember, max capacity effectively is capacity * CapacityOverstuffedMultiplier (from character.xml) 
+#### DigestionRatePerSecond (float, percent/second)
+Character's digestion rate in percent per second.
+#### EatSpeedMultiplier (float)
 Eat speed multiplier for the character's Eat animation.
 #### IsDigesting (bool)
 Determines if character is currently digesting (when the bar is going down)
@@ -621,20 +580,6 @@ When digestion bar is going down, this is the remaining time to 0 (in ticks)
 Total calories consumed by the character, per save file.
 #### TotalFoodItemsEaten (int)
 How many food items have been completely consumed by the character, per save file.
-### SkillCheck
-#### TotalPlays (int)
-How many times the Skill Check minigame has been attempted.
-#### HighScore (int)
-Highest score the player has achieved in the Skill Check minigame.
-#### BestCombo (int)
-Highest combo the player has achieved (how many successful hits the player has gotten in one session)
-#### Grades
-Play grades are the ratings the game gives based on where the player hit.
-##### ID (int)
-ID of grade being tracked (see skill_check.xml)
-##### Count (int)
-How many times the grade has been hit.
-
 ### Inventory
 Items.
 #### ID (int)
diff --git a/src/developer/console.cpp b/src/developer/console.cpp
new file mode 100644
index 0000000..d208883
--- /dev/null
+++ b/src/developer/console.cpp
@@ -0,0 +1,337 @@
+#include "console.hpp"
+
+#include <algorithm>
+#include <charconv>
+#include <format>
+#include <string_view>
+#include <utility>
+
+#include <imgui.h>
+#include <misc/cpp/imgui_stdlib.h>
+
+#include "../resources.hpp"
+#include "../state/play.hpp"
+
+namespace game::developer
+{
+  namespace console
+  {
+#define GAME_CONSOLE_COMMANDS(X)                                                                                       \
+  X(ANIMATIONS, "animations", "animations", true)                                                                     \
+  X(CAPACITY, "capacity", "capacity <calories>", true)                                                                \
+  X(CHARACTER, "character", "character <archive>", false)                                                             \
+  X(CHARACTERS, "characters", "characters", false)                                                                    \
+  X(DIGEST, "digest", "digest", true)                                                                                 \
+  X(DIGESTION, "digestion", "digestion <% per second>", true)                                                         \
+  X(DIALOGUE, "dialogue", "dialogue", true)                                                                           \
+  X(EAT_SPEED, "eat_speed", "eat_speed <multiplier>", true)                                                           \
+  X(GIVE, "give", "give <item_id> <quantity>", true)                                                                  \
+  X(HELP, "help", "help", false)                                                                                      \
+  X(ITEMS, "items", "items", true)                                                                                    \
+  X(MENU, "menu", "menu", true)                                                                                       \
+  X(PLAY_ANIMATION, "play_animation", "play_animation <animation>", true)                                             \
+  X(PLAY_DIALOGUE, "play_dialogue", "play_dialogue <label>", true)                                                    \
+  X(RELOAD, "reload", "reload", false)                                                                                \
+  X(STAGE, "stage", "stage <stage>", true)                                                                            \
+  X(WEIGHT, "weight", "weight <kilograms>", true)
+
+    enum class Command
+    {
+#define GAME_CONSOLE_COMMAND_ENUM(SYMBOL, ...) SYMBOL,
+      GAME_CONSOLE_COMMANDS(GAME_CONSOLE_COMMAND_ENUM)
+#undef GAME_CONSOLE_COMMAND_ENUM
+          UNKNOWN
+    };
+
+    struct CommandInfo
+    {
+      Command command{};
+      std::string_view name{};
+      std::string_view usage{};
+      bool isGameOnly{};
+    };
+
+    constexpr CommandInfo COMMANDS[]{
+#define GAME_CONSOLE_COMMAND_INFO(SYMBOL, NAME, USAGE, IS_GAME_ONLY)                                                   \
+  {.command = Command::SYMBOL, .name = NAME, .usage = USAGE, .isGameOnly = IS_GAME_ONLY},
+        GAME_CONSOLE_COMMANDS(GAME_CONSOLE_COMMAND_INFO)
+#undef GAME_CONSOLE_COMMAND_INFO
+    };
+
+#undef GAME_CONSOLE_COMMANDS
+
+    constexpr auto HISTORY_MIN_HEIGHT = 1.0f;
+    constexpr auto SCROLL_BOTTOM = 1.0f;
+    constexpr auto SCROLL_EPSILON = 1.0f;
+    constexpr auto INPUT_FLAGS = ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_CallbackHistory;
+    constexpr auto ARG_VALUE = 1;
+    constexpr auto ARG_QUANTITY = ARG_VALUE + 1;
+    constexpr auto HISTORY_PREVIOUS = -1;
+    constexpr auto HISTORY_NEXT = 1;
+
+    const CommandInfo* command_info_find(std::string_view name)
+    {
+      for (auto& command : COMMANDS)
+        if (command.name == name) return &command;
+      return nullptr;
+    }
+
+    int int_parse(std::string_view value)
+    {
+      int result{};
+      if (value.empty()) return result;
+      std::from_chars(value.data(), value.data() + value.size(), result);
+      return result;
+    }
+
+    float float_parse(std::string_view value)
+    {
+      float result{};
+      if (value.empty()) return result;
+      std::from_chars(value.data(), value.data() + value.size(), result);
+      return result;
+    }
+
+    std::vector<std::string_view> args_get(const std::string& input)
+    {
+      std::vector<std::string_view> result{};
+      auto view = std::string_view{input};
+      while (!view.empty())
+      {
+        auto start = view.find_first_not_of(' ');
+        if (start == std::string_view::npos) break;
+        view.remove_prefix(start);
+        auto end = view.find(' ');
+        result.emplace_back(view.substr(0, end));
+        if (end == std::string_view::npos) break;
+        view.remove_prefix(end);
+      }
+      return result;
+    }
+
+    int input_callback(ImGuiInputTextCallbackData* data)
+    {
+      auto* console = static_cast<Console*>(data->UserData);
+      auto offset = data->EventKey == ImGuiKey_UpArrow     ? HISTORY_PREVIOUS
+                    : data->EventKey == ImGuiKey_DownArrow ? HISTORY_NEXT
+                                                           : 0;
+      if (offset == 0) return 0;
+      auto& historyInput = console->command_history_offset(offset);
+      data->DeleteChars(0, data->BufTextLen);
+      data->InsertChars(0, historyInput.c_str());
+      return 0;
+    }
+  }
+
+  using namespace console;
+
+  void Console::focus_request() { isFocusRequested = true; }
+
+  void Console::history_push(std::string value) { history.emplace_back(std::move(value)); }
+
+  void Console::command_history_push()
+  {
+    if (input.empty()) return;
+    if (commandHistory.empty() || commandHistory.back() != input) commandHistory.emplace_back(input);
+    commandHistoryIndex = (int)commandHistory.size();
+  }
+
+  const std::string& Console::command_history_offset(int offset)
+  {
+    static const std::string EMPTY{};
+    if (commandHistory.empty()) return EMPTY;
+    if (commandHistoryIndex < 0) commandHistoryIndex = (int)commandHistory.size();
+    commandHistoryIndex = std::clamp(commandHistoryIndex + offset, 0, (int)commandHistory.size());
+    return commandHistoryIndex >= (int)commandHistory.size() ? EMPTY : commandHistory[commandHistoryIndex];
+  }
+
+  void Console::help_print(bool isGame)
+  {
+    history_push("Commands:");
+    for (auto& command : COMMANDS)
+      if (isGame || !command.isGameOnly) history_push(std::format("  {}", command.usage));
+  }
+
+  void Console::command_execute(Resources& resources, state::Play* play)
+  {
+    action = {};
+    auto args = args_get(input);
+    if (args.empty()) return;
+
+    auto isGame = play != nullptr;
+    auto* info = command_info_find(args.front());
+    if (!info)
+    {
+      history_push(std::format("Unknown command: {}", args.front()));
+      return;
+    }
+    if (info->isGameOnly && !isGame)
+    {
+      history_push(std::format("Command unavailable outside game: {}", info->name));
+      return;
+    }
+
+    switch (info->command)
+    {
+      case Command::ANIMATIONS:
+      {
+        history_push("Animations:");
+        for (int i = 0; i < (int)play->character.animations.size(); ++i)
+          history_push(std::format("  {} {}", i, play->character.animations[i].name));
+        break;
+      }
+      case Command::CAPACITY:
+      {
+        play->character.capacity = float_parse(args.size() > ARG_VALUE ? args[ARG_VALUE] : std::string_view{});
+        history_push(std::format("Capacity set to {} kcal.", play->character.capacity));
+        break;
+      }
+      case Command::CHARACTER:
+      {
+        auto key = args.size() > ARG_VALUE ? std::string{args[ARG_VALUE]} : std::string{};
+        action.character = resources.character_index_get(key);
+        history_push(std::format("Character set to {}.", key));
+        break;
+      }
+      case Command::CHARACTERS:
+      {
+        history_push("Characters:");
+        for (int i = 0; i < (int)resources.characters.size(); ++i)
+          history_push(std::format("  {}", resources.character_key_get(i)));
+        break;
+      }
+      case Command::DIGEST:
+      {
+        play->character.isDigesting = true;
+        play->character.digestionTimer = 1;
+        history_push("Digesting.");
+        break;
+      }
+      case Command::DIGESTION:
+      {
+        auto digestion = float_parse(args.size() > ARG_VALUE ? args[ARG_VALUE] : std::string_view{});
+        play->character.digestionRate = digestion / Entity::UPDATE_RATE;
+        history_push(std::format("Digestion set to {}%/sec.", digestion));
+        break;
+      }
+      case Command::DIALOGUE:
+      {
+        history_push("Dialogue:");
+        for (auto& [label, index] : play->character.data.dialogue.entryIDMap)
+          history_push(std::format("  {}", label));
+        break;
+      }
+      case Command::PLAY_DIALOGUE:
+      {
+        auto label = args.size() > ARG_VALUE ? std::string{args[ARG_VALUE]} : std::string{};
+        auto* entry = play->character.data.dialogue.dialogue_entry_get(label);
+        play->text.set(entry, play->character);
+        history_push(std::format("Playing dialogue: {}", label));
+        break;
+      }
+      case Command::EAT_SPEED:
+      {
+        play->character.eatSpeed = float_parse(args.size() > ARG_VALUE ? args[ARG_VALUE] : std::string_view{});
+        history_push(std::format("Eat speed set to {}x.", play->character.eatSpeed));
+        break;
+      }
+      case Command::GIVE:
+      {
+        auto itemID = int_parse(args.size() > ARG_VALUE ? args[ARG_VALUE] : std::string_view{});
+        auto quantity = int_parse(args.size() > ARG_QUANTITY ? args[ARG_QUANTITY] : std::string_view{});
+        play->menu.inventory.values[itemID] += quantity;
+        history_push(std::format("Gave item {} x{}.", itemID, quantity));
+        break;
+      }
+      case Command::HELP:
+        help_print(isGame);
+        break;
+      case Command::ITEMS:
+      {
+        auto& items = play->character.data.itemSchema.items;
+        history_push("Items:");
+        for (int i = 0; i < (int)items.size(); ++i)
+          history_push(std::format("  {} {}", i, items[i].name));
+        break;
+      }
+      case Command::MENU:
+      {
+        action.isMenu = true;
+        history_push("Returning to menu.");
+        break;
+      }
+      case Command::PLAY_ANIMATION:
+      {
+        auto animation = args.size() > ARG_VALUE ? std::string{args[ARG_VALUE]} : std::string{};
+        play->character.play(
+            {.animation = animation, .mode = Entity::PLAY_FORCE, .interrupt = Entity::Interrupt::ALWAYS});
+        history_push(std::format("Playing animation: {}", animation));
+        break;
+      }
+      case Command::RELOAD:
+      {
+        if (play)
+        {
+          auto key = resources.character_key_get(play->characterIndex);
+          play->save(resources);
+          resources.characters_refresh();
+          play->characterIndex = resources.character_index_get(key);
+          play->set(resources, play->characterIndex, state::Play::CONTINUE);
+        }
+        else
+          resources.characters_refresh();
+        history_push(std::format("Reloaded character archives: {}", resources.characters.size()));
+        break;
+      }
+      case Command::STAGE:
+      {
+        auto stage = int_parse(args.size() > ARG_VALUE ? args[ARG_VALUE] : std::string_view{});
+        play->character.stage = stage - 1;
+        play->character.weight = play->character.stage_threshold_get(play->character.stage);
+        history_push(std::format("Stage set to {}.", stage));
+        break;
+      }
+      case Command::WEIGHT:
+      {
+        play->character.weight = float_parse(args.size() > ARG_VALUE ? args[ARG_VALUE] : std::string_view{});
+        history_push(std::format("Weight set to {} kg.", play->character.weight));
+        break;
+      }
+      case Command::UNKNOWN:
+        break;
+    }
+  }
+
+  void Console::update(Resources& resources, state::Play* play)
+  {
+    auto historySize = ImGui::GetContentRegionAvail();
+    historySize.y = std::max(HISTORY_MIN_HEIGHT,
+                             historySize.y - ImGui::GetFrameHeight() - ImGui::GetStyle().ItemSpacing.y);
+
+    if (ImGui::BeginChild("##Console History", historySize, ImGuiChildFlags_Borders))
+    {
+      for (auto& entry : history)
+        ImGui::TextUnformatted(entry.c_str());
+
+      if (ImGui::GetScrollY() >= ImGui::GetScrollMaxY() - SCROLL_EPSILON)
+        ImGui::SetScrollHereY(SCROLL_BOTTOM);
+    }
+    ImGui::EndChild();
+
+    if (isFocusRequested)
+    {
+      ImGui::SetKeyboardFocusHere();
+      isFocusRequested = false;
+    }
+
+    ImGui::SetNextItemWidth(-FLT_MIN);
+    if (ImGui::InputText("##Console Input", &input, INPUT_FLAGS, input_callback, this) && !input.empty())
+    {
+      history_push(std::format("> {}", input));
+      command_history_push();
+      command_execute(resources, play);
+      input.clear();
+      isFocusRequested = true;
+    }
+  }
+}
diff --git a/src/developer/console.hpp b/src/developer/console.hpp
new file mode 100644
index 0000000..f605c7c
--- /dev/null
+++ b/src/developer/console.hpp
@@ -0,0 +1,53 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+struct ImGuiInputTextCallbackData;
+
+namespace game
+{
+  class Resources;
+}
+
+namespace game::state
+{
+  class Play;
+}
+
+namespace game::developer
+{
+  namespace console
+  {
+    int input_callback(ImGuiInputTextCallbackData*);
+  }
+
+  class Console
+  {
+    friend int console::input_callback(ImGuiInputTextCallbackData*);
+
+    std::vector<std::string> history{};
+    std::vector<std::string> commandHistory{};
+    std::string input{};
+    int commandHistoryIndex{-1};
+    bool isFocusRequested{};
+
+    void history_push(std::string);
+    void command_history_push();
+    const std::string& command_history_offset(int offset);
+    void help_print(bool isGame);
+    void command_execute(Resources&, state::Play*);
+
+  public:
+    struct Action
+    {
+      int character{-1};
+      bool isMenu{};
+    };
+
+    Action action{};
+
+    void focus_request();
+    void update(Resources&, state::Play*);
+  };
+}
diff --git a/src/developer/document.cpp b/src/developer/document.cpp
new file mode 100644
index 0000000..f77b74e
--- /dev/null
+++ b/src/developer/document.cpp
@@ -0,0 +1,168 @@
+#include "document.hpp"
+
+#include <array>
+#include <format>
+
+namespace game::developer
+{
+  namespace
+  {
+    using Schema = resource::xml::Schema;
+    using Element = Schema::Element;
+
+    static constexpr std::array elementTypeNames{
+#define GAME_DEVELOPER_ELEMENT_TYPE_NAME(NAME, ENUM) std::pair{Element::ENUM, std::string_view{#NAME}},
+        GAME_SCHEMA_ELEMENT_TYPES(GAME_DEVELOPER_ELEMENT_TYPE_NAME)
+#undef GAME_DEVELOPER_ELEMENT_TYPE_NAME
+    };
+
+    std::string type_name_get(Element::Type type)
+    {
+      for (auto [mappedType, name] : elementTypeNames)
+        if (mappedType == type) return std::string{name};
+      return "Element";
+    }
+
+    std::string element_name_get(const Schema& schema, int index)
+    {
+      if (index < 0 || index >= (int)schema.elements.size()) return "element";
+      auto& element = schema.elements[index];
+      auto typeName = type_name_get(element.type);
+      if (!element.idString.empty()) return std::format("{} '{}'", typeName, element.idString);
+      if (!element.name.empty()) return std::format("{} '{}'", typeName, element.name);
+      return typeName;
+    }
+
+    void snapshot_push(std::vector<Document::Snapshot>& snapshots, Document::Snapshot snapshot)
+    {
+      static constexpr auto MAX_SNAPSHOTS = 100;
+      snapshots.emplace_back(std::move(snapshot));
+      if ((int)snapshots.size() > MAX_SNAPSHOTS) snapshots.erase(snapshots.begin());
+    }
+  }
+
+  Document::SchemaFile* Document::schema_file_get(std::string_view filename)
+  {
+    for (auto& schema : schemas)
+      if (schema.filename == filename) return &schema;
+    return nullptr;
+  }
+
+  const Document::SchemaFile* Document::schema_file_get(std::string_view filename) const
+  {
+    for (auto& schema : schemas)
+      if (schema.filename == filename) return &schema;
+    return nullptr;
+  }
+
+  Document::SchemaFile* Document::dialogue_schema_get() { return schema_file_get("dialogue.xml"); }
+
+  const Document::SchemaFile* Document::dialogue_schema_get() const { return schema_file_get("dialogue.xml"); }
+
+  bool Document::can_undo() const { return !undo.empty(); }
+  bool Document::can_redo() const { return !redo.empty(); }
+
+  void Document::edit_snapshot_begin()
+  {
+    auto* dialogueSchema = dialogue_schema_get();
+    if (!pendingEditSnapshot && dialogueSchema) pendingEditSnapshot = dialogueSchema->schema;
+  }
+
+  resource::xml::Schema Document::edit_snapshot_take_or(resource::xml::Schema fallback)
+  {
+    if (!pendingEditSnapshot) return fallback;
+    auto snapshot = std::move(*pendingEditSnapshot);
+    pendingEditSnapshot.reset();
+    return snapshot;
+  }
+
+  void Document::edit_snapshot_clear() { pendingEditSnapshot.reset(); }
+
+  void Document::snapshot_push(resource::xml::Schema snapshot, std::string message)
+  {
+    developer::snapshot_push(undo, {.schema = std::move(snapshot), .message = std::move(message)});
+    redo.clear();
+    isDirty = true;
+  }
+
+  std::string Document::undo_apply()
+  {
+    if (undo.empty()) return {};
+    auto* dialogueSchema = dialogue_schema_get();
+    if (!dialogueSchema) return {};
+
+    auto snapshot = std::move(undo.back());
+    undo.pop_back();
+    developer::snapshot_push(redo, {.schema = dialogueSchema->schema, .message = snapshot.message});
+    dialogueSchema->schema = std::move(snapshot.schema);
+    isDirty = true;
+    return snapshot.message;
+  }
+
+  std::string Document::redo_apply()
+  {
+    if (redo.empty()) return {};
+    auto* dialogueSchema = dialogue_schema_get();
+    if (!dialogueSchema) return {};
+
+    auto snapshot = std::move(redo.back());
+    redo.pop_back();
+    developer::snapshot_push(undo, {.schema = dialogueSchema->schema, .message = snapshot.message});
+    dialogueSchema->schema = std::move(snapshot.schema);
+    isDirty = true;
+    return snapshot.message;
+  }
+
+  void Document::history_clear()
+  {
+    undo.clear();
+    redo.clear();
+  }
+
+  std::string Document::change_message_get(const Schema& before, const Schema& after)
+  {
+    if (after.elements.size() > before.elements.size())
+    {
+      for (int i = 0; i < (int)after.elements.size(); ++i)
+      {
+        auto serialized = after.element_serialize(i);
+        auto existed = false;
+        for (int beforeIndex = 0; beforeIndex < (int)before.elements.size(); ++beforeIndex)
+        {
+          if (before.element_serialize(beforeIndex) != serialized) continue;
+          existed = true;
+          break;
+        }
+        if (!existed) return std::format("Add {}", element_name_get(after, i));
+      }
+      return "Add element";
+    }
+
+    if (after.elements.size() < before.elements.size())
+    {
+      for (int i = 0; i < (int)before.elements.size(); ++i)
+      {
+        auto serialized = before.element_serialize(i);
+        auto exists = false;
+        for (int afterIndex = 0; afterIndex < (int)after.elements.size(); ++afterIndex)
+        {
+          if (after.element_serialize(afterIndex) != serialized) continue;
+          exists = true;
+          break;
+        }
+        if (!exists) return std::format("Delete {}", element_name_get(before, i));
+      }
+      return "Delete element";
+    }
+
+    for (int i = 0; i < (int)before.elements.size(); ++i)
+    {
+      if (before.element_serialize(i) == after.element_serialize(i)) continue;
+      if (before.elements[i].type != after.elements[i].type)
+        return std::format("Change {} to {}", element_name_get(before, i), element_name_get(after, i));
+      return std::format("Change {}", element_name_get(after, i));
+    }
+
+    return "Change schema";
+  }
+}
diff --git a/src/developer/document.hpp b/src/developer/document.hpp
new file mode 100644
index 0000000..dee418f
--- /dev/null
+++ b/src/developer/document.hpp
@@ -0,0 +1,58 @@
+#pragma once
+
+#include <filesystem>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "../resource/schema.hpp"
+#include "editor.hpp"
+
+namespace game::developer
+{
+  class Document
+  {
+  public:
+    struct SchemaFile
+    {
+      std::string filename{};
+      std::string label{};
+      std::filesystem::path path{};
+      resource::xml::Schema::Element::Type type{resource::xml::Schema::Element::UNKNOWN};
+      resource::xml::Schema schema{};
+      bool isExists{};
+      bool isValid{};
+    };
+
+    struct Snapshot
+    {
+      resource::xml::Schema schema{};
+      std::string message{};
+    };
+
+    std::filesystem::path path{};
+    std::vector<SchemaFile> schemas{};
+    Editor editor{};
+    std::vector<Snapshot> undo{};
+    std::vector<Snapshot> redo{};
+    std::optional<resource::xml::Schema> pendingEditSnapshot{};
+    bool isDirty{};
+
+    SchemaFile* schema_file_get(std::string_view filename);
+    const SchemaFile* schema_file_get(std::string_view filename) const;
+    SchemaFile* dialogue_schema_get();
+    const SchemaFile* dialogue_schema_get() const;
+    bool can_undo() const;
+    bool can_redo() const;
+    void edit_snapshot_begin();
+    resource::xml::Schema edit_snapshot_take_or(resource::xml::Schema);
+    void edit_snapshot_clear();
+    void snapshot_push(resource::xml::Schema, std::string);
+    std::string undo_apply();
+    std::string redo_apply();
+    void history_clear();
+
+    static std::string change_message_get(const resource::xml::Schema& before, const resource::xml::Schema& after);
+  };
+}
diff --git a/src/developer/editor.cpp b/src/developer/editor.cpp
new file mode 100644
index 0000000..fd64956
--- /dev/null
+++ b/src/developer/editor.cpp
@@ -0,0 +1,2308 @@
+#include "editor.hpp"
+
+#include <algorithm>
+#include <cstdio>
+#include <format>
+#include <optional>
+#include <sstream>
+#include <string_view>
+#include <vector>
+
+#include <imgui.h>
+#include <imgui_internal.h>
+#include <tinyxml2/tinyxml2.h>
+
+#include "../util/imgui.hpp"
+#include "../util/imgui/dialogue_text.hpp"
+#include "../util/imgui/input_string.hpp"
+#include "../util/imgui/path_widget.hpp"
+#include "../util/imgui/selectable_renamable.hpp"
+#include "../util/imgui/sound_widget.hpp"
+#include "../util/imgui/widget.hpp"
+
+namespace game::developer
+{
+  namespace editor_detail
+  {
+    using Schema = resource::xml::Schema;
+    using Element = Schema::Element;
+    using editor_schema::child_insert_after;
+    using editor_schema::document_history_context_menu_draw;
+
+#define DIALOGUE_EFFECT_TYPES(X)                                                                                       \
+  X(ANIMATION, "Animation", false)                                                                                     \
+  X(BIG, "Big", true)                                                                                                  \
+  X(COLOR, "Color", true)                                                                                              \
+  X(DELAY, "Delay", false)                                                                                             \
+  X(OSCILLATION, "Oscillation", true)                                                                                  \
+  X(SCREEN_SHAKE, "Screenshake", false)                                                                                \
+  X(SHAKE, "Shake", true)                                                                                              \
+  X(SMALL, "Small", true)                                                                                              \
+  X(SOUND, "Sound", false)
+
+    enum class DialogueEffectType
+    {
+#define DIALOGUE_EFFECT_TYPE_DECLARE(kind, label, ranged) kind,
+      DIALOGUE_EFFECT_TYPES(DIALOGUE_EFFECT_TYPE_DECLARE)
+#undef DIALOGUE_EFFECT_TYPE_DECLARE
+          UNKNOWN,
+    };
+
+    struct DialogueEffectInfo
+    {
+      DialogueEffectType type{};
+      std::string_view name{};
+      bool isRanged{};
+    };
+
+    constexpr DialogueEffectInfo DIALOGUE_EFFECT_INFO[]{
+#define DIALOGUE_EFFECT_INFO_DECLARE(kind, label, ranged)                                                              \
+  {.type = DialogueEffectType::kind, .name = label, .isRanged = ranged},
+        DIALOGUE_EFFECT_TYPES(DIALOGUE_EFFECT_INFO_DECLARE)
+#undef DIALOGUE_EFFECT_INFO_DECLARE
+    };
+
+    constexpr auto CENTER_RATIO = 0.5f;
+    constexpr auto CHOICE_BUTTON_ACTIVE_MULTIPLIER = 1.3f;
+    constexpr auto CHOICE_BUTTON_COLOR_MAX = 0.9f;
+    constexpr auto CHOICE_BUTTON_HOVER_MULTIPLIER = 1.6f;
+    constexpr auto CHOICE_BUTTON_ROUNDING = 10.0f;
+    constexpr auto CHOICE_BUTTON_STYLE_COLOR_COUNT = 3;
+    constexpr auto CHOICE_BUTTON_STYLE_VAR_COUNT = 2;
+    constexpr auto COLOR_COMPONENT_FULL = 1.0f;
+    constexpr auto COLOR_EFFECT_DEFAULT_BLUE = 0.25f;
+    constexpr auto COLOR_EFFECT_DEFAULT_GREEN = 0.25f;
+    constexpr auto DELAY_MIN = 1;
+    constexpr auto DIALOGUE_CHILD_TABLE_COLUMNS = 4;
+    constexpr auto DIALOGUE_DELAY_DEFAULT = 4;
+    constexpr auto EFFECT_FIELD_PAIR_COUNT = 2.0f;
+    constexpr auto EFFECT_INDEX_FAST_STEP = 10;
+    constexpr auto EFFECT_INDEX_STEP = 1;
+    constexpr auto ENTRY_CONTENT_SPACING_COUNT = 4.0f;
+    constexpr auto ENTRY_DIALOGUE_HEIGHT_RATIO = 0.15f;
+    constexpr auto ENTRY_ENTITY_HEIGHT_RATIO = 0.47f;
+    constexpr auto ENTRY_PLAYER_PADDING_COUNT = 2.0f;
+    constexpr auto ENTRY_TEXT_EDITOR_HEIGHT_RATIO = 0.10f;
+    constexpr auto LEFT_PANEL_MIN_WIDTH = 240.0f;
+    constexpr auto LEFT_PANEL_WIDTH_RATIO = 0.40f;
+    constexpr auto NAME_COLOR_DEFAULT = 0.498039f;
+    constexpr auto NEXT_INDICATOR_HALF_RATIO = 0.35f;
+    constexpr auto NEXT_INDICATOR_OFFSET_RATIO = 0.12f;
+    constexpr auto NEXT_INDICATOR_SPEED = 2.0f;
+    constexpr auto OSCILLATION_AMPLITUDE_DEFAULT = 2.0f;
+    constexpr auto OSCILLATION_FREQUENCY_DEFAULT = 1.0f;
+    constexpr auto OSCILLATION_PERIOD_DEFAULT = 1.0f;
+    constexpr auto PREVIEW_RATE = 60.0f;
+    constexpr auto PROPERTY_ITEM_MIN_WIDTH = 60.0f;
+    constexpr auto SCREEN_SHAKE_PREVIEW_MAGNITUDE_DEFAULT = 0.03f;
+    constexpr auto SCREEN_SHAKE_TIME_TICKS_DEFAULT = 15;
+    constexpr auto SCROLL_ITEM_CENTER_Y = 0.5f;
+    constexpr auto SELECTION_OVERLAY_ALPHA = 0.90f;
+    constexpr auto SHAKE_AMPLITUDE_DEFAULT = 1.0f;
+    constexpr auto SHAKE_FREQUENCY_DEFAULT = 30.0f;
+    constexpr auto SHAKE_PERIOD_DEFAULT = 0.08f;
+    constexpr auto SOUND_WIDGET_WIDTH = 48.0f;
+    constexpr auto TAB_COLOR_DIM_MULTIPLIER = 0.55f;
+    constexpr auto TAB_COLOR_HOVER_MULTIPLIER = 0.75f;
+    constexpr auto TAB_STYLE_COLOR_COUNT = 3;
+    constexpr auto TEXT_SCALE_BIG = 1.25f;
+    constexpr auto TEXT_SCALE_SMALL = 0.75f;
+    constexpr auto WIDGET_MIN_SIZE = 1.0f;
+
+    const DialogueEffectInfo* dialogue_effect_info_find(std::string_view type)
+    {
+      for (auto& info : DIALOGUE_EFFECT_INFO)
+        if (info.name == type) return &info;
+      return nullptr;
+    }
+
+    DialogueEffectType dialogue_effect_type_get(std::string_view type)
+    {
+      auto* info = dialogue_effect_info_find(type);
+      return info ? info->type : DialogueEffectType::UNKNOWN;
+    }
+
+    void scroll_to_item_if_requested(int& target, int index)
+    {
+      if (target != index) return;
+      ImGui::SetScrollHereY(SCROLL_ITEM_CENTER_Y);
+      target = -1;
+    }
+
+    bool dialogue_effect_is(const Element& element) { return element.type == Element::EFFECT; }
+
+    bool dialogue_effect_type_is_ranged(std::string_view type)
+    {
+      auto* info = dialogue_effect_info_find(type);
+      return !info || info->isRanged;
+    }
+
+    bool dialogue_effect_is_ranged(const Element& effect) { return dialogue_effect_type_is_ranged(effect.typeString); }
+
+    void dialogue_effect_defaults_apply(Element& effect)
+    {
+      if (effect.typeString.empty()) effect.typeString = "Oscillation";
+      switch (dialogue_effect_type_get(effect.typeString))
+      {
+        case DialogueEffectType::COLOR:
+          if (effect.color == glm::vec3{})
+            effect.color = glm::vec3{COLOR_COMPONENT_FULL, COLOR_EFFECT_DEFAULT_GREEN, COLOR_EFFECT_DEFAULT_BLUE};
+          break;
+        case DialogueEffectType::BIG:
+        case DialogueEffectType::SMALL:
+          break;
+        case DialogueEffectType::OSCILLATION:
+          break;
+        case DialogueEffectType::SHAKE:
+          break;
+        case DialogueEffectType::SCREEN_SHAKE:
+          break;
+        case DialogueEffectType::DELAY:
+          if (effect.delayTicks <= 0) effect.delayTicks = DIALOGUE_DELAY_DEFAULT;
+          break;
+        default:
+          break;
+      }
+    }
+
+    struct ReferenceInfo
+    {
+      const Schema* schema{};
+      const std::filesystem::path* path{};
+      std::string name{};
+      std::string anm2{};
+      std::string anm2RootPath{};
+      std::string anm2Path{};
+      std::string blip{};
+      std::string soundRootPath{};
+      std::string font{};
+      std::string fontRootPath{};
+      std::string fontPath{};
+      glm::vec3 color{1.0f, 1.0f, 1.0f};
+      bool isHasColor{};
+      const resource::Audio* blipAudio{};
+    };
+
+    std::filesystem::path resource_absolute_path_get(const std::filesystem::path& schemaPath,
+                                                     const std::string& rootPath, const std::string& path)
+    {
+      return util::imgui::path_absolute_get(schemaPath, rootPath, path);
+    }
+
+    std::string resource_display_path_get(const std::filesystem::path& schemaPath, const std::string& rootPath,
+                                          const std::string& path)
+    {
+      return util::imgui::path_display_get(schemaPath, rootPath, path);
+    }
+
+    std::string resource_store_path_get(const std::filesystem::path& schemaPath, const std::string& rootPath,
+                                        const std::filesystem::path& path)
+    {
+      return util::imgui::path_store_get(schemaPath, rootPath, path);
+    }
+
+    void sound_effect_entry_rebuild(const std::filesystem::path& schemaPath, const std::string& rootPath,
+                                    Element& effect)
+    {
+      if (effect.sound.empty())
+      {
+        effect.soundEntry = {};
+        return;
+      }
+      auto path = resource_absolute_path_get(schemaPath, rootPath, effect.sound);
+      effect.soundEntry = resource::xml::Schema::SoundEntry{.path = effect.sound, .sound = resource::Audio(path)};
+    }
+
+    std::vector<int> elements_of_type_get(const Schema& schema, Element::Type type)
+    {
+      std::vector<int> result{};
+      auto containerType = type == Element::ENTRY  ? Element::ENTRIES
+                           : type == Element::POOL ? Element::POOLS
+                                                   : Element::UNKNOWN;
+      if (containerType != Element::UNKNOWN)
+      {
+        auto containerIt = schema.elementsByType.find(containerType);
+        if (containerIt != schema.elementsByType.end() && !containerIt->second.empty())
+        {
+          auto i = containerIt->second.front();
+          if (i < 0 || i >= (int)schema.elements.size()) return result;
+          for (auto child : schema.elements[i].children)
+            if (child >= 0 && child < (int)schema.elements.size() && schema.elements[child].type == type)
+              result.emplace_back(child);
+          return result;
+        }
+      }
+      if (auto* root = schema.root())
+      {
+        for (auto child : root->children)
+          if (child >= 0 && child < (int)schema.elements.size() && schema.elements[child].type == type)
+            result.emplace_back(child);
+        if (!result.empty()) return result;
+      }
+      auto typeIt = schema.elementsByType.find(type);
+      if (typeIt != schema.elementsByType.end()) result = typeIt->second;
+      return result;
+    }
+
+    std::string entry_label_get(const Element& entry)
+    {
+      if (!entry.idString.empty()) return entry.idString;
+      if (!entry.name.empty()) return entry.name;
+      return "<entry>";
+    }
+
+    std::string pool_label_get(const Element& pool)
+    {
+      if (!pool.idString.empty()) return pool.idString;
+      if (!pool.name.empty()) return pool.name;
+      return "<pool>";
+    }
+
+    const Editor::LoadedSchema* loaded_schema_get(std::span<const Editor::LoadedSchema> loadedSchemas,
+                                                  Element::Type type)
+    {
+      for (auto& loaded : loadedSchemas)
+      {
+        if (!loaded.schema) continue;
+        auto* root = loaded.schema->root();
+        if (root && root->type == type) return &loaded;
+      }
+      return nullptr;
+    }
+
+    std::optional<ReferenceInfo> reference_info_get(const Editor::LoadedSchema* loaded)
+    {
+      if (!loaded || !loaded->schema) return std::nullopt;
+
+      ReferenceInfo info{};
+      info.schema = loaded->schema;
+      info.path = loaded->path;
+      for (auto& element : loaded->schema->elements)
+      {
+        if (info.anm2RootPath.empty())
+        {
+          if (!element.anm2RootPath.empty())
+            info.anm2RootPath = element.anm2RootPath;
+          else if (!element.textureRootPath.empty())
+            info.anm2RootPath = element.textureRootPath;
+        }
+        if (info.soundRootPath.empty() && !element.soundRootPath.empty()) info.soundRootPath = element.soundRootPath;
+        if (info.fontRootPath.empty() && !element.fontRootPath.empty()) info.fontRootPath = element.fontRootPath;
+        if (info.font.empty() && !element.font.empty()) info.font = element.font;
+        if (info.name.empty() && !element.name.empty()) info.name = element.name;
+        if (!info.isHasColor && element.color != glm::vec3{})
+        {
+          info.color = element.color;
+          info.isHasColor = true;
+        }
+        if (info.anm2.empty())
+        {
+          if (!element.anm2.empty())
+            info.anm2 = element.anm2;
+          else if (!element.baseAnm2.empty())
+            info.anm2 = element.baseAnm2;
+          if (!info.anm2.empty() && element.anm2Entry.is_valid()) info.anm2Path = element.anm2Entry.path;
+        }
+        if (info.blip.empty() && element.type == Element::BLIP)
+        {
+          if (!element.sound.empty())
+            info.blip = element.sound;
+          else if (!element.path.empty())
+            info.blip = element.path;
+          else if (element.soundEntry.is_valid())
+            info.blip = element.soundEntry.path;
+          if (element.soundEntry.is_valid()) info.blipAudio = &element.soundEntry.sound;
+        }
+      }
+
+      if (auto* root = loaded->schema->root())
+      {
+        if (info.anm2RootPath.empty())
+        {
+          if (!root->anm2RootPath.empty())
+            info.anm2RootPath = root->anm2RootPath;
+          else if (!root->textureRootPath.empty())
+            info.anm2RootPath = root->textureRootPath;
+        }
+        if (info.soundRootPath.empty()) info.soundRootPath = root->soundRootPath;
+        if (info.fontRootPath.empty()) info.fontRootPath = root->fontRootPath;
+        if (info.font.empty()) info.font = root->font;
+        if (info.name.empty()) info.name = root->name;
+        if (info.anm2.empty() && !root->anm2.empty())
+        {
+          info.anm2 = root->anm2;
+          if (root->anm2Entry.is_valid()) info.anm2Path = root->anm2Entry.path;
+        }
+        if (info.blip.empty())
+        {
+          auto* textPlayback = loaded->schema->child_get(*root, Element::TEXT_PLAYBACK);
+          auto* blipElement = textPlayback ? loaded->schema->child_get(*textPlayback, Element::BLIP) : nullptr;
+          auto* sound = blipElement ? loaded->schema->child_get(*blipElement, Element::SOUND) : nullptr;
+          if (sound && !sound->path.empty()) info.blip = sound->path;
+        }
+        if (info.blip.empty())
+        {
+          if (auto* blip = root->soundBlip.get())
+          {
+            info.blip = "<cached blip>";
+            info.blipAudio = blip;
+          }
+        }
+      }
+
+      if (info.anm2Path.empty() && loaded->path && !info.anm2.empty())
+        info.anm2Path = resource_absolute_path_get(*loaded->path, info.anm2RootPath, info.anm2).string();
+      if (info.fontPath.empty() && loaded->path && !info.font.empty())
+        info.fontPath = resource_absolute_path_get(*loaded->path, info.fontRootPath, info.font).string();
+      return info;
+    }
+
+    int container_index_get(const Schema& schema, Element::Type type)
+    {
+      auto it = schema.elementsByType.find(type);
+      if (it != schema.elementsByType.end() && !it->second.empty()) return it->second.front();
+      return schema.root() ? 0 : -1;
+    }
+
+    int unique_element_id_get(const Schema& schema, std::string_view prefix)
+    {
+      auto id = 1;
+      auto exists = [&](const std::string& candidate)
+      { return std::ranges::any_of(schema.elements, [&](auto& element) { return element.idString == candidate; }); };
+      while (exists(std::format("{}{}", prefix, id)))
+        ++id;
+      return id;
+    }
+
+    editor_schema::ElementActionOptions element_action_options_get(int parent, int target, Element::Type type,
+                                                                 bool isInsertVisible = true,
+                                                                 bool isClearVisible = false,
+                                                                 bool isClearEnabled = false)
+    {
+      return {.parent = parent,
+              .target = target,
+              .after = target,
+              .pasteParent = parent,
+              .pasteAfter = target,
+              .type = type,
+              .isInsertVisible = isInsertVisible,
+              .isInsertEnabled = isInsertVisible,
+              .isClearVisible = isClearVisible,
+              .isClearEnabled = isClearEnabled};
+    }
+
+    bool element_selected_has(int selected, const std::vector<int>& selectedElements, int index)
+    {
+      return selected == index || std::ranges::find(selectedElements, index) != selectedElements.end();
+    }
+
+    void element_selection_set(int& selected, std::vector<int>& selectedElements, int index)
+    {
+      selected = index;
+      selectedElements = index >= 0 ? std::vector<int>{index} : std::vector<int>{};
+    }
+
+    void element_selection_toggle(int& selected, std::vector<int>& selectedElements, int index)
+    {
+      auto it = std::ranges::find(selectedElements, index);
+      if (it == selectedElements.end() && selected == index)
+        selected = selectedElements.empty() ? -1 : selectedElements.back();
+      else if (it == selectedElements.end())
+        selectedElements.emplace_back(index);
+      else
+        selectedElements.erase(it);
+      selected = selectedElements.empty() ? -1 : selectedElements.back();
+    }
+
+    void element_selection_range_set(Schema& schema, int& selected, std::vector<int>& selectedElements, int index)
+    {
+      if (selected < 0 || selected >= (int)schema.elements.size() ||
+          schema.elements[selected].parent != schema.elements[index].parent)
+      {
+        element_selection_set(selected, selectedElements, index);
+        return;
+      }
+
+      auto& siblings = schema.elements[schema.elements[index].parent].children;
+      auto begin = std::ranges::find(siblings, selected);
+      auto end = std::ranges::find(siblings, index);
+      if (begin == siblings.end() || end == siblings.end())
+      {
+        element_selection_set(selected, selectedElements, index);
+        return;
+      }
+
+      selectedElements.clear();
+      if (end < begin) std::swap(begin, end);
+      for (auto it = begin; it <= end; ++it)
+        selectedElements.emplace_back(*it);
+      selected = index;
+    }
+
+    std::vector<int> selected_elements_get(Schema& schema, int selected, const std::vector<int>& selectedElements,
+                                           Element::Type type)
+    {
+      std::vector<int> result{};
+      auto add = [&](int index)
+      {
+        if (index <= 0 || index >= (int)schema.elements.size()) return;
+        if (schema.elements[index].type != type) return;
+        if (std::ranges::find(result, index) == result.end()) result.emplace_back(index);
+      };
+      for (auto index : selectedElements)
+        add(index);
+      add(selected);
+      if (result.empty()) return result;
+
+      auto parent = schema.elements[result.front()].parent;
+      if (parent >= 0 && parent < (int)schema.elements.size())
+      {
+        std::vector<int> sorted{};
+        for (auto child : schema.elements[parent].children)
+          if (std::ranges::find(result, child) != result.end()) sorted.emplace_back(child);
+        return sorted;
+      }
+
+      std::ranges::sort(result);
+      return result;
+    }
+
+    std::string xml_element_text_get(tinyxml2::XMLElement* element)
+    {
+      tinyxml2::XMLPrinter printer{};
+      element->Accept(&printer);
+      return printer.CStr();
+    }
+
+    std::string selected_elements_serialize(Schema& schema, int selected, const std::vector<int>& selectedElements,
+                                            Element::Type type)
+    {
+      auto elements = selected_elements_get(schema, selected, selectedElements, type);
+      if (elements.empty()) return {};
+      if (elements.size() == 1) return schema.element_serialize(elements.front());
+
+      std::ostringstream stream{};
+      stream << "<EditorElements>";
+      for (auto index : elements)
+        stream << schema.element_serialize(index);
+      stream << "</EditorElements>";
+      return stream.str();
+    }
+
+    bool selected_elements_erase(Schema& schema, int& selected, std::vector<int>& selectedElements, Element::Type type)
+    {
+      auto elements = selected_elements_get(schema, selected, selectedElements, type);
+      if (elements.empty()) return false;
+
+      std::ranges::sort(elements, std::greater{});
+      auto isDirty = false;
+      for (auto index : elements)
+        if (schema.element_erase(index)) isDirty = true;
+      selected = -1;
+      selectedElements.clear();
+      return isDirty;
+    }
+
+    bool selected_elements_cut(util::Clipboard& clipboard, Schema& schema, int& selected,
+                               std::vector<int>& selectedElements, Element::Type type)
+    {
+      auto text = selected_elements_serialize(schema, selected, selectedElements, type);
+      if (text.empty()) return false;
+      clipboard.cut(text);
+      return selected_elements_erase(schema, selected, selectedElements, type);
+    }
+
+    bool selected_elements_copy(util::Clipboard& clipboard, Schema& schema, int selected,
+                                const std::vector<int>& selectedElements, Element::Type type)
+    {
+      auto text = selected_elements_serialize(schema, selected, selectedElements, type);
+      if (text.empty()) return false;
+      clipboard.copy(text);
+      return true;
+    }
+
+    int elements_paste(util::Clipboard& clipboard, Schema& schema, int parent, int beforeSibling)
+    {
+      auto* text = clipboard.get();
+      if (!text || !*text) return -1;
+
+      tinyxml2::XMLDocument document{};
+      if (document.Parse(text) == tinyxml2::XML_SUCCESS && document.RootElement() &&
+          std::string_view{document.RootElement()->Name()} == "EditorElements")
+      {
+        auto selected = -1;
+        for (auto* child = document.RootElement()->FirstChildElement(); child; child = child->NextSiblingElement())
+        {
+          auto inserted = schema.element_insert_xml(xml_element_text_get(child), parent, beforeSibling);
+          if (inserted >= 0) selected = inserted;
+        }
+        return selected;
+      }
+
+      return editor_schema::element_paste(clipboard, schema, parent, beforeSibling);
+    }
+
+    bool selected_elements_duplicate(Schema& schema, int& selected, std::vector<int>& selectedElements,
+                                     Element::Type type)
+    {
+      auto elements = selected_elements_get(schema, selected, selectedElements, type);
+      if (elements.empty()) return false;
+
+      auto last = -1;
+      auto after = elements.back();
+      selectedElements.clear();
+      for (auto index : elements)
+      {
+        auto duplicated = editor_schema::element_duplicate(schema, schema.elements[index].parent, index, after, type);
+        if (duplicated < 0) continue;
+        selectedElements.emplace_back(duplicated);
+        selected = duplicated;
+        after = duplicated;
+        last = duplicated;
+      }
+      return last >= 0;
+    }
+
+    bool elements_move(Schema& schema, const std::vector<int>& selectedElements, int parent, int beforeSibling)
+    {
+      if (selectedElements.empty()) return false;
+      auto isDirty = false;
+      for (auto index : selectedElements)
+      {
+        if (index == beforeSibling) continue;
+        if (schema.element_move(index, parent, beforeSibling)) isDirty = true;
+      }
+      return isDirty;
+    }
+
+    int sibling_after_get(Schema& schema, int parent, int sibling)
+    {
+      if (parent < 0 || parent >= (int)schema.elements.size()) return -1;
+      auto& siblings = schema.elements[parent].children;
+      auto it = std::ranges::find(siblings, sibling);
+      if (it == siblings.end() || it + 1 == siblings.end()) return -1;
+      return *(it + 1);
+    }
+
+    bool sibling_drag_drop_draw(Schema& schema, int index, const char* payloadName, const char* label,
+                                const std::vector<int>* selectedElements = nullptr)
+    {
+      auto isDirty = false;
+      if (ImGui::BeginDragDropSource())
+      {
+        ImGui::SetDragDropPayload(payloadName, &index, sizeof(index));
+        ImGui::TextUnformatted(label);
+        ImGui::EndDragDropSource();
+      }
+      if (ImGui::BeginDragDropTarget())
+      {
+        if (auto* payload = ImGui::AcceptDragDropPayload(payloadName))
+        {
+          auto source = payload && payload->Data ? *(const int*)payload->Data : -1;
+          if (source >= 0 && source < (int)schema.elements.size() && source != index)
+          {
+            auto parent = schema.elements[index].parent;
+            auto beforeSibling = index;
+            if (parent >= 0 && parent < (int)schema.elements.size() && schema.elements[source].parent == parent)
+            {
+              auto& siblings = schema.elements[parent].children;
+              auto sourceIt = std::ranges::find(siblings, source);
+              auto targetIt = std::ranges::find(siblings, index);
+              if (sourceIt != siblings.end() && targetIt != siblings.end() && sourceIt < targetIt)
+              {
+                auto afterTarget = targetIt + 1;
+                beforeSibling = afterTarget == siblings.end() ? -1 : *afterTarget;
+              }
+            }
+            if (selectedElements && std::ranges::find(*selectedElements, source) != selectedElements->end())
+              isDirty = elements_move(schema, *selectedElements, parent, beforeSibling);
+            else if (schema.element_move(source, parent, beforeSibling))
+              isDirty = true;
+          }
+        }
+        ImGui::EndDragDropTarget();
+      }
+      return isDirty;
+    }
+
+    int entry_insert(Schema& schema, int after = -1)
+    {
+      auto parent = container_index_get(schema, Element::ENTRIES);
+      auto& entry = schema.element_add(Element::ENTRY, parent);
+      entry.idString = std::format("New{}", unique_element_id_get(schema, "New"));
+      auto index = (int)schema.elements.size() - 1;
+      child_insert_after(schema, parent, index, after);
+      schema.indices_refresh();
+      return index;
+    }
+
+    std::vector<int> dialogue_effect_indices_get(const Schema& schema, const Element& entry)
+    {
+      std::vector<int> result{};
+      for (auto child : entry.children)
+      {
+        if (child < 0 || child >= (int)schema.elements.size()) continue;
+        if (dialogue_effect_is(schema.elements[child])) result.emplace_back(child);
+      }
+      return result;
+    }
+
+    std::vector<int> dialogue_choice_indices_get(const Schema& schema, const Element& entry)
+    {
+      std::vector<int> result{};
+      for (auto child : entry.children)
+      {
+        if (child < 0 || child >= (int)schema.elements.size()) continue;
+        if (schema.elements[child].type == Element::CHOICE) result.emplace_back(child);
+      }
+      return result;
+    }
+
+    std::vector<int> dialogue_child_indices_get(const Schema& schema, const Element& entry)
+    {
+      std::vector<int> result{};
+      for (auto child : entry.children)
+      {
+        if (child < 0 || child >= (int)schema.elements.size()) continue;
+        if (schema.elements[child].type == Element::CHOICE || dialogue_effect_is(schema.elements[child]))
+          result.emplace_back(child);
+      }
+      return result;
+    }
+
+    Element::Type dialogue_child_type_get(const Schema& schema, int index)
+    {
+      if (index < 0 || index >= (int)schema.elements.size()) return Element::UNKNOWN;
+      if (schema.elements[index].type == Element::CHOICE) return Element::CHOICE;
+      if (dialogue_effect_is(schema.elements[index])) return Element::EFFECT;
+      return Element::UNKNOWN;
+    }
+
+    int dialogue_child_selected_get(const Editor& editor)
+    {
+      if (editor.selectedChoice >= 0) return editor.selectedChoice;
+      if (editor.selectedEffect >= 0) return editor.selectedEffect;
+      return -1;
+    }
+
+    void dialogue_child_select(Editor& editor, const Schema& schema, int index)
+    {
+      auto type = dialogue_child_type_get(schema, index);
+      editor.selectedChoice = type == Element::CHOICE ? index : -1;
+      editor.selectedEffect = type == Element::EFFECT ? index : -1;
+      if (type == Element::CHOICE) editor.scrollToChoice = index;
+      if (type == Element::EFFECT) editor.scrollToEffect = index;
+    }
+
+    void dialogue_child_clear(Editor& editor)
+    {
+      editor.selectedChoice = -1;
+      editor.selectedEffect = -1;
+    }
+
+    bool dialogue_child_type_set(Editor& editor, Schema& schema, int entryIndex, int index,
+                                 std::string_view type)
+    {
+      if (index < 0 || index >= (int)schema.elements.size()) return false;
+      auto& child = schema.elements[index];
+      if (type == "Choice")
+      {
+        if (child.type == Element::CHOICE) return false;
+        child.type = Element::CHOICE;
+        if (child.text.empty()) child.text = "Choice";
+        schema.indices_refresh();
+        dialogue_child_select(editor, schema, index);
+        return true;
+      }
+
+      auto isNewEffect = child.type != Element::EFFECT;
+      if (!isNewEffect && child.typeString == type) return false;
+      child.type = Element::EFFECT;
+      child.typeString = type;
+      if (isNewEffect && entryIndex >= 0 && entryIndex < (int)schema.elements.size())
+      {
+        auto textLength = util::imgui::utf8_char_count(schema.elements[entryIndex].text);
+        child.start = std::clamp(editor.textSelectionStart, 0, textLength);
+        child.end = std::clamp(editor.textSelectionEnd, 0, textLength);
+        if (child.end < child.start) std::swap(child.start, child.end);
+        if (dialogue_effect_type_is_ranged(type) && child.start == child.end)
+          child.end = std::min(textLength, child.start + 1);
+        if (!dialogue_effect_type_is_ranged(type)) child.end = child.start;
+      }
+      dialogue_effect_defaults_apply(child);
+      schema.indices_refresh();
+      dialogue_child_select(editor, schema, index);
+      return true;
+    }
+
+    std::vector<util::imgui::DialogueEffectSpan> dialogue_effect_spans_get(const Schema& schema, const Element& entry)
+    {
+      std::vector<util::imgui::DialogueEffectSpan> result{};
+      for (auto index : dialogue_effect_indices_get(schema, entry))
+      {
+        auto& effect = schema.elements[index];
+        switch (dialogue_effect_type_get(effect.typeString))
+        {
+          case DialogueEffectType::COLOR:
+            result.push_back({.type = util::imgui::DialogueEffectSpan::COLOR,
+                              .start = effect.start,
+                              .end = effect.end,
+                              .color = effect.color});
+            break;
+          case DialogueEffectType::BIG:
+            result.push_back({.type = util::imgui::DialogueEffectSpan::TEXT_SCALE,
+                              .start = effect.start,
+                              .end = effect.end,
+                              .textScale = TEXT_SCALE_BIG});
+            break;
+          case DialogueEffectType::SMALL:
+            result.push_back({.type = util::imgui::DialogueEffectSpan::TEXT_SCALE,
+                              .start = effect.start,
+                              .end = effect.end,
+                              .textScale = TEXT_SCALE_SMALL});
+            break;
+          case DialogueEffectType::OSCILLATION:
+            result.push_back(
+                {.type = util::imgui::DialogueEffectSpan::OSCILLATE,
+                 .start = effect.start,
+                 .end = effect.end,
+                 .frequency = OSCILLATION_FREQUENCY_DEFAULT,
+                 .amplitude = OSCILLATION_AMPLITUDE_DEFAULT});
+            break;
+          case DialogueEffectType::SHAKE:
+            result.push_back({.type = util::imgui::DialogueEffectSpan::SHAKE,
+                              .start = effect.start,
+                              .end = effect.end,
+                              .frequency = SHAKE_FREQUENCY_DEFAULT,
+                              .amplitude = SHAKE_AMPLITUDE_DEFAULT});
+            break;
+          default:
+            break;
+        }
+      }
+      return result;
+    }
+
+    int dialogue_effect_insert(Schema& schema, int entryIndex, int after, std::string_view type, int start, int end)
+    {
+      if (entryIndex < 0 || entryIndex >= (int)schema.elements.size()) return -1;
+      auto textLength = util::imgui::utf8_char_count(schema.elements[entryIndex].text);
+      start = std::clamp(start, 0, textLength);
+      end = std::clamp(end, 0, textLength);
+      if (end < start) std::swap(start, end);
+      auto isRanged = dialogue_effect_type_is_ranged(type);
+      if (isRanged && start == end) end = std::min(textLength, start + 1);
+      if (!isRanged) end = start;
+
+      auto& effect = schema.element_add(Element::EFFECT, entryIndex);
+      effect.typeString = type;
+      effect.start = start;
+      effect.end = end;
+      dialogue_effect_defaults_apply(effect);
+      auto index = (int)schema.elements.size() - 1;
+      child_insert_after(schema, entryIndex, index, after);
+      schema.indices_refresh();
+      return index;
+    }
+
+    void dialogue_preview_start_effects_apply(Editor& editor, const Schema& schema, const Element& entry,
+                                              int index)
+    {
+      for (auto effectIndex : dialogue_effect_indices_get(schema, entry))
+      {
+        auto& effect = schema.elements[effectIndex];
+        if (effect.start != index) continue;
+        switch (dialogue_effect_type_get(effect.typeString))
+        {
+          case DialogueEffectType::DELAY:
+            editor.previewBaseDelay = std::max(DELAY_MIN, effect.delayTicks);
+            editor.previewDelay = editor.previewBaseDelay;
+            break;
+          case DialogueEffectType::ANIMATION:
+            editor.previewAnimationRequest = effect.animation;
+            editor.previewNeedsAnimationPlay = true;
+            break;
+          case DialogueEffectType::SCREEN_SHAKE:
+          {
+            editor.previewCanvas.canvas.shake(SCREEN_SHAKE_PREVIEW_MAGNITUDE_DEFAULT, SCREEN_SHAKE_TIME_TICKS_DEFAULT);
+            break;
+          }
+          case DialogueEffectType::SOUND:
+            if (effect.soundEntry.is_valid()) effect.soundEntry.sound.play();
+            break;
+          default:
+            break;
+        }
+      }
+    }
+
+    std::string_view dialogue_char_get(std::string_view text, int index)
+    {
+      auto* start = text.data();
+      auto* end = start + text.size();
+      auto* charStart = util::imgui::utf8_advance_chars(start, end, index);
+      auto* charEnd = util::imgui::utf8_advance_chars(charStart, end, 1);
+      return charEnd > charStart ? std::string_view(charStart, charEnd - charStart) : std::string_view{};
+    }
+
+    struct DialogueDelayCharacter
+    {
+      int delay{};
+      bool isDisableTalk{};
+    };
+
+    DialogueDelayCharacter dialogue_delay_character_get(const Schema& schema, std::string_view text, int index,
+                                                        int fallback)
+    {
+      auto value = dialogue_char_get(text, index);
+      auto* root = schema.root();
+      if (value.empty() || !root) return {.delay = fallback};
+      auto* textPlayback = schema.child_get(*root, Element::TEXT_PLAYBACK);
+      auto* delayCharacters = textPlayback ? schema.child_get(*textPlayback, Element::DELAY_CHARACTERS) : nullptr;
+      if (!delayCharacters) return {.delay = fallback};
+
+      for (auto* delayCharacter : schema.children_get(*delayCharacters, Element::DELAY_CHARACTER))
+      {
+        if (delayCharacter->character == value)
+          return {.delay = fallback + std::max(0, delayCharacter->delayTicks),
+                  .isDisableTalk = delayCharacter->isDisableTalk};
+      }
+      return {.delay = fallback};
+    }
+
+    void dialogue_preview_entry_set(Editor& editor, Schema& schema, int entryIndex, bool isPlay)
+    {
+      if (entryIndex < 0 || entryIndex >= (int)schema.elements.size()) return;
+      auto* entry = &schema.elements[entryIndex];
+      if (entry->type != Element::ENTRY) return;
+      editor.mode = Editor::ENTRY;
+      editor.selectedEntry = entryIndex;
+      editor.selectedPoolEntry = -1;
+      editor.selectedChoice = -1;
+      editor.selectedEffect = -1;
+      editor.textSelectionStart = 0;
+      editor.textSelectionEnd = 0;
+      editor.textSelectionStartByte = 0;
+      editor.textSelectionEndByte = 0;
+      editor.previewIndex = 0;
+      editor.previewTimer = 0.0f;
+      editor.previewBaseDelay = std::max(DELAY_MIN, editor.delay);
+      editor.previewDelay = editor.previewBaseDelay;
+      editor.isPreviewBlipQueued = false;
+      editor.isPlaying = isPlay && util::imgui::utf8_char_count(entry->text) > 0;
+      editor.previewNeedsAnimationPlay = true;
+      if (editor.isPlaying) dialogue_preview_start_effects_apply(editor, schema, *entry, editor.previewIndex);
+    }
+
+    void dialogue_preview_skipped_effects_apply(Editor& editor, const Schema& schema, const Element& entry,
+                                                int fromExclusive, int toInclusive)
+    {
+      if (toInclusive <= fromExclusive) return;
+      for (int index = fromExclusive + 1; index <= toInclusive; ++index)
+        dialogue_preview_start_effects_apply(editor, schema, entry, index);
+    }
+
+    int dialogue_choice_insert(Schema& schema, int entryIndex, int after = -1)
+    {
+      if (entryIndex < 0 || entryIndex >= (int)schema.elements.size()) return -1;
+      auto& choice = schema.element_add(Element::CHOICE, entryIndex);
+      choice.text = "Choice";
+      auto index = (int)schema.elements.size() - 1;
+      child_insert_after(schema, entryIndex, index, after);
+      schema.indices_refresh();
+      return index;
+    }
+
+    bool dialogue_child_insert_menu_draw(Editor& editor, Schema& schema, int entryIndex, int after)
+    {
+      if (!ImGui::BeginMenu("Insert")) return false;
+
+      auto isDirty = false;
+      if (ImGui::MenuItem("Choice"))
+      {
+        editor.selectedChoice = dialogue_choice_insert(schema, entryIndex, after);
+        if (editor.selectedChoice >= 0)
+        {
+          editor.selectedEffect = -1;
+          editor.scrollToChoice = editor.selectedChoice;
+          isDirty = true;
+        }
+      }
+#define DIALOGUE_EFFECT_MENU_DRAW(kind, label, ranged)                                                                 \
+  if (ImGui::MenuItem(label))                                                                                          \
+  {                                                                                                                    \
+    auto end = ranged ? editor.textSelectionEnd : editor.textSelectionStart;                                           \
+    editor.selectedEffect = dialogue_effect_insert(schema, entryIndex, after, label, editor.textSelectionStart, end);  \
+    if (editor.selectedEffect >= 0) editor.selectedChoice = -1;                                                        \
+    if (editor.selectedEffect >= 0) editor.scrollToEffect = editor.selectedEffect;                                     \
+    isDirty = editor.selectedEffect >= 0;                                                                              \
+  }
+      DIALOGUE_EFFECT_TYPES(DIALOGUE_EFFECT_MENU_DRAW)
+#undef DIALOGUE_EFFECT_MENU_DRAW
+
+      ImGui::EndMenu();
+      return isDirty;
+    }
+
+    bool dialogue_child_type_combo_draw(Editor& editor, Schema& schema, int entryIndex, int index)
+    {
+      if (index < 0 || index >= (int)schema.elements.size()) return false;
+      auto& child = schema.elements[index];
+      auto preview = child.type == Element::CHOICE ? "Choice" : child.typeString.c_str();
+      auto isDirty = false;
+      ImGui::SetNextItemWidth(-FLT_MIN);
+      if (ImGui::BeginCombo("##Type", preview))
+      {
+        if (ImGui::Selectable("Choice", child.type == Element::CHOICE))
+          isDirty = dialogue_child_type_set(editor, schema, entryIndex, index, "Choice") || isDirty;
+#define DIALOGUE_EFFECT_TYPE_SELECT_DRAW(kind, label, ranged)                                                          \
+  if (ImGui::Selectable(label, child.type == Element::EFFECT && child.typeString == label))                            \
+    isDirty = dialogue_child_type_set(editor, schema, entryIndex, index, label) || isDirty;
+        DIALOGUE_EFFECT_TYPES(DIALOGUE_EFFECT_TYPE_SELECT_DRAW)
+#undef DIALOGUE_EFFECT_TYPE_SELECT_DRAW
+        ImGui::EndCombo();
+      }
+      return isDirty;
+    }
+
+    void text_selection_overlay_draw(std::string_view text, int selectionStart, int selectionEnd, const ImVec2& rectMin,
+                                     const ImVec2& rectMax, const ImVec2& scroll)
+    {
+      if (selectionStart == selectionEnd) return;
+      if (selectionEnd < selectionStart) std::swap(selectionStart, selectionEnd);
+      selectionStart = std::clamp(selectionStart, 0, (int)text.size());
+      selectionEnd = std::clamp(selectionEnd, 0, (int)text.size());
+      if (selectionStart == selectionEnd) return;
+
+      auto* drawList = ImGui::GetWindowDrawList();
+      auto& style = ImGui::GetStyle();
+      auto lineHeight = ImGui::GetTextLineHeight();
+      auto origin = ImVec2(rectMin.x + style.FramePadding.x - scroll.x, rectMin.y + style.FramePadding.y - scroll.y);
+      auto color = ImGui::GetColorU32(ImGuiCol_TextSelectedBg, SELECTION_OVERLAY_ALPHA);
+
+      drawList->PushClipRect(rectMin, rectMax, true);
+      auto lineStartByte = 0;
+      auto lineIndex = 0;
+      while (lineStartByte <= (int)text.size())
+      {
+        auto lineEndByte = lineStartByte;
+        while (lineEndByte < (int)text.size() && text[lineEndByte] != '\n')
+          ++lineEndByte;
+
+        auto selectedStart = std::max(selectionStart, lineStartByte);
+        auto selectedEnd = std::min(selectionEnd, lineEndByte);
+        if (selectedStart < selectedEnd)
+        {
+          auto* lineStart = text.data() + lineStartByte;
+          auto* selectedStartPtr = text.data() + selectedStart;
+          auto* selectedEndPtr = text.data() + selectedEnd;
+          auto x0 = origin.x + ImGui::CalcTextSize(lineStart, selectedStartPtr).x;
+          auto x1 = origin.x + ImGui::CalcTextSize(lineStart, selectedEndPtr).x;
+          auto y0 = origin.y + lineHeight * lineIndex;
+          drawList->AddRectFilled(ImVec2(x0, y0), ImVec2(x1, y0 + lineHeight), color);
+        }
+
+        if (lineEndByte >= (int)text.size()) break;
+        lineStartByte = lineEndByte + 1;
+        ++lineIndex;
+      }
+      drawList->PopClipRect();
+    }
+
+    int pool_insert(Schema& schema, int after = -1)
+    {
+      auto parent = container_index_get(schema, Element::POOLS);
+      auto& pool = schema.element_add(Element::POOL, parent);
+      pool.idString = std::format("NewPool{}", unique_element_id_get(schema, "NewPool"));
+      auto index = (int)schema.elements.size() - 1;
+      child_insert_after(schema, parent, index, after);
+      schema.indices_refresh();
+      return index;
+    }
+
+    void entry_tooltip_draw(const Schema& schema, const Element& entry)
+    {
+      if (!ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNormal)) return;
+      auto choiceCount = (int)dialogue_choice_indices_get(schema, entry).size();
+      auto effectCount = (int)dialogue_effect_indices_get(schema, entry).size();
+      auto isAnimationVisible = !entry.animation.empty();
+      auto isCountVisible = choiceCount > 0 || effectCount > 0;
+      auto isSummaryVisible = isAnimationVisible || isCountVisible;
+      ImGui::BeginTooltip();
+      ImGui::TextUnformatted(entry_label_get(entry).c_str());
+      if (isSummaryVisible)
+      {
+        ImGui::Separator();
+        if (isAnimationVisible) ImGui::Text("Animation: %s", entry.animation.c_str());
+        if (choiceCount > 0 && effectCount > 0)
+          ImGui::Text("%d %s, %d %s", choiceCount, choiceCount == 1 ? "choice" : "choices", effectCount,
+                      effectCount == 1 ? "effect" : "effects");
+        else if (choiceCount > 0)
+          ImGui::Text("%d %s", choiceCount, choiceCount == 1 ? "choice" : "choices");
+        else if (effectCount > 0)
+          ImGui::Text("%d %s", effectCount, effectCount == 1 ? "effect" : "effects");
+      }
+      if (!entry.text.empty())
+      {
+        if (isSummaryVisible) ImGui::Separator();
+        ImGui::TextUnformatted(entry.text.c_str());
+      }
+      ImGui::EndTooltip();
+    }
+
+    Element* selected_get(Schema& schema, int index)
+    {
+      return index >= 0 && index < (int)schema.elements.size() ? &schema.elements[index] : nullptr;
+    }
+
+    int element_index_get(const Schema& schema, const Element* element)
+    {
+      if (!element) return -1;
+      for (int i = 0; i < (int)schema.elements.size(); ++i)
+        if (&schema.elements[i] == element) return i;
+      return -1;
+    }
+
+    bool element_is_type(const Schema& schema, int index, Element::Type type)
+    {
+      return index >= 0 && index < (int)schema.elements.size() && schema.elements[index].type == type;
+    }
+
+    void indices_refresh(Schema& schema) { schema.indices_refresh(); }
+
+    bool entry_combo_draw(const char* label, Schema& schema, std::string& value)
+    {
+      auto isDirty = false;
+      auto entries = elements_of_type_get(schema, Element::ENTRY);
+      auto preview = value.empty() ? "<none>" : value.c_str();
+      if (ImGui::BeginCombo(label, preview))
+      {
+        if (ImGui::Selectable("<none>", value.empty()))
+        {
+          value.clear();
+          isDirty = true;
+        }
+        for (auto index : entries)
+        {
+          auto& entry = schema.elements[index];
+          auto entryLabel = entry_label_get(entry);
+          auto isSelected = value == entry.idString;
+          if (ImGui::Selectable(entryLabel.c_str(), isSelected))
+          {
+            value = entry.idString;
+            isDirty = true;
+          }
+          entry_tooltip_draw(schema, entry);
+        }
+        ImGui::EndCombo();
+      }
+      return isDirty;
+    }
+
+    bool pool_entry_delete(Schema& schema, int poolIndex, int poolEntryIndex)
+    {
+      if (poolIndex < 0 || poolIndex >= (int)schema.elements.size()) return false;
+      auto& children = schema.elements[poolIndex].children;
+      auto it = std::ranges::find(children, poolEntryIndex);
+      if (it == children.end()) return false;
+      children.erase(it);
+      return schema.element_erase(poolEntryIndex);
+    }
+
+    int pool_entry_insert(Schema& schema, int poolIndex, const std::string& entryID, int after = -1)
+    {
+      if (poolIndex < 0 || poolIndex >= (int)schema.elements.size()) return -1;
+      auto& poolEntry = schema.element_add(Element::POOL_ENTRY, poolIndex);
+      poolEntry.idString = entryID;
+      auto index = (int)schema.elements.size() - 1;
+      child_insert_after(schema, poolIndex, index, after);
+      schema.indices_refresh();
+      return index;
+    }
+
+    bool pool_entry_insert_menu_draw(Schema& schema, int poolIndex, int after, const std::vector<int>& entries,
+                                     int& selectedPoolEntry, int& scrollToPoolEntry)
+    {
+      if (!ImGui::BeginMenu("Insert")) return false;
+
+      auto isDirty = false;
+      for (auto entryIndex : entries)
+      {
+        auto& entry = schema.elements[entryIndex];
+        auto label = entry_label_get(entry);
+        if (ImGui::MenuItem(label.c_str()))
+        {
+          selectedPoolEntry = pool_entry_insert(schema, poolIndex, entry.idString, after);
+          scrollToPoolEntry = selectedPoolEntry;
+          isDirty = selectedPoolEntry >= 0;
+        }
+        entry_tooltip_draw(schema, entry);
+      }
+      ImGui::EndMenu();
+      return isDirty;
+    }
+
+    void entity_preview_update(Editor& editor, Resources& resources, const Schema& schema,
+                               const ReferenceInfo* reference, Element& entry, ImVec2 size)
+    {
+      auto anm2Path = reference ? reference->anm2Path : std::string{};
+      if (editor.previewAnm2Path != anm2Path)
+      {
+        editor.previewAnm2Path = anm2Path;
+        if (reference && reference->schema)
+        {
+          editor.previewCharacter = {};
+          editor.previewCharacter.schema = *reference->schema;
+          editor.previewEntity = Entity(editor.previewCharacter, {});
+        }
+        else
+        {
+          editor.previewCharacter = {};
+          editor.previewEntity = {};
+        }
+        editor.previewCanvas.clear();
+        editor.previewAnimation.clear();
+        editor.previewAnimationRequest.clear();
+        editor.previewNeedsAnimationPlay = editor.isPlaying;
+      }
+
+      if (!editor.previewEntity.isValid) return;
+
+      auto animation = editor.previewAnimationRequest.empty() ? entry.animation : editor.previewAnimationRequest;
+      if (editor.previewNeedsAnimationPlay)
+      {
+        editor.previewAnimation = animation;
+        editor.previewAnimationRequest.clear();
+        editor.previewCanvas.clear();
+        if (!animation.empty())
+        {
+          editor.previewEntity.play(
+              {.animation = animation, .appendID = editor.animationAppendID, .mode = Entity::PLAY_FORCE});
+        }
+        editor.previewNeedsAnimationPlay = false;
+      }
+      auto delayCharacter =
+          dialogue_delay_character_get(schema, entry.text, editor.previewIndex - 1, editor.previewDelay);
+      editor.previewEntity.isTalking = editor.isPlaying &&
+                                       editor.previewIndex < util::imgui::utf8_char_count(entry.text) &&
+                                       !delayCharacter.isDisableTalk;
+      editor.previewEntity.update();
+
+      auto& canvas = editor.previewCanvas.render(resources, editor.previewEntity, size);
+      canvas.update();
+      auto imageSize = editor.previewCanvas.imageSize;
+      auto cursor = ImGui::GetCursorPos();
+      ImGui::SetCursorPos(ImVec2(cursor.x + (size.x * CENTER_RATIO) - (imageSize.x * CENTER_RATIO),
+                                 cursor.y + (size.y * CENTER_RATIO) - (imageSize.y * CENTER_RATIO)));
+      auto imageCursor = ImGui::GetCursorPos();
+      auto shakeOffset = editor.previewCanvas.shake_offset_get();
+      ImGui::SetCursorPos(ImVec2(imageCursor.x + shakeOffset.x, imageCursor.y + shakeOffset.y));
+      ImGui::Image(canvas.texture, imageSize);
+    }
+#undef DIALOGUE_EFFECT_TYPES
+  }
+
+  using namespace editor_detail;
+
+  bool Editor::update(Resources& resources, Schema& schema, const std::filesystem::path& schemaPath,
+                              util::Dialog& dialog, std::span<const LoadedSchema> loadedSchemas)
+  {
+    auto isDirty = false;
+    auto* root = schema.root();
+    if (!root)
+    {
+      ImGui::TextUnformatted("No schema root.");
+      return false;
+    }
+
+    if (pendingSetting == PENDING_SOUND && dialog.is_selected(util::Dialog::SCHEMA_SOUND_OPEN))
+    {
+      if (pendingSoundEffect >= 0 && pendingSoundEffect < (int)schema.elements.size())
+      {
+        auto& effect = schema.elements[pendingSoundEffect];
+        effect.sound = resource_store_path_get(schemaPath, root->soundRootPath, dialog.path);
+        sound_effect_entry_rebuild(schemaPath, root->soundRootPath, effect);
+        isDirty = true;
+      }
+      pendingSoundEffect = -1;
+      pendingSetting = PENDING_NONE;
+      dialog.reset();
+    }
+
+    auto referenceInfo = reference_info_get(loaded_schema_get(loadedSchemas, Element::CHARACTER));
+    auto* reference = referenceInfo ? &*referenceInfo : nullptr;
+    auto menuInfo = reference_info_get(loaded_schema_get(loadedSchemas, Element::MENU));
+    previewBlip = root->soundBlip.get();
+    if (!previewBlip && reference && reference->blipAudio) previewBlip = reference->blipAudio;
+    nameColor = reference && reference->isHasColor ? reference->color : glm::vec3{NAME_COLOR_DEFAULT};
+
+    if (menuInfo && menuInfo->path && !menuInfo->font.empty() &&
+        (fontPath != menuInfo->font || fontRootPath != menuInfo->fontRootPath || fontSchemaPath != *menuInfo->path))
+    {
+      fontPath = menuInfo->font;
+      fontRootPath = menuInfo->fontRootPath;
+      fontSchemaPath = *menuInfo->path;
+      previewFont = resource::Font(resource_absolute_path_get(fontSchemaPath, fontRootPath, fontPath));
+    }
+    else if ((!menuInfo || !menuInfo->path || menuInfo->font.empty()) &&
+             (!fontPath.empty() || !fontRootPath.empty() || !fontSchemaPath.empty()))
+    {
+      fontPath.clear();
+      fontRootPath.clear();
+      fontSchemaPath.clear();
+      previewFont = {};
+    }
+
+    auto entries = elements_of_type_get(schema, Element::ENTRY);
+    auto pools = elements_of_type_get(schema, Element::POOL);
+    if (!element_is_type(schema, selectedEntry, Element::ENTRY)) selectedEntry = -1;
+    if (!element_is_type(schema, selectedPool, Element::POOL)) selectedPool = -1;
+    selectedEntries.erase(std::remove_if(selectedEntries.begin(), selectedEntries.end(),
+                                         [&](int index) { return !element_is_type(schema, index, Element::ENTRY); }),
+                          selectedEntries.end());
+    selectedPools.erase(std::remove_if(selectedPools.begin(), selectedPools.end(),
+                                       [&](int index) { return !element_is_type(schema, index, Element::POOL); }),
+                        selectedPools.end());
+    if (!element_is_type(schema, selectedPoolEntry, Element::POOL_ENTRY)) selectedPoolEntry = -1;
+    if (!element_is_type(schema, selectedChoice, Element::CHOICE)) selectedChoice = -1;
+    if (selectedEffect < 0 || selectedEffect >= (int)schema.elements.size() ||
+        !dialogue_effect_is(schema.elements[selectedEffect]))
+      selectedEffect = -1;
+    if (selectedEntry < 0 && !entries.empty()) selectedEntry = entries.front();
+    if (selectedPool < 0 && !pools.empty()) selectedPool = pools.front();
+    delay = root->delayTicks > 0 ? std::max(DELAY_MIN, root->delayTicks) : std::max(DELAY_MIN, delay);
+    if (root->delayTicks <= 0) root->delayTicks = delay;
+    blipDelay = root->blipDelayTicks > 0 ? std::max(DELAY_MIN, root->blipDelayTicks) : std::max(DELAY_MIN, blipDelay);
+    if (root->blipDelayTicks <= 0) root->blipDelayTicks = blipDelay;
+
+    auto available = ImGui::GetContentRegionAvail();
+    auto leftWidth = std::max(LEFT_PANEL_MIN_WIDTH, available.x * LEFT_PANEL_WIDTH_RATIO);
+    auto rightWidth = std::max(WIDGET_MIN_SIZE, available.x - leftWidth - ImGui::GetStyle().ItemSpacing.x);
+
+    ImGui::BeginChild("dialogue-left", ImVec2(leftWidth, 0.0f));
+    auto settingsHeight = ImGui::GetFrameHeightWithSpacing();
+
+    if (ImGui::BeginChild("dialogue-settings", ImVec2(0.0f, settingsHeight), ImGuiChildFlags_None,
+                          ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse))
+    {
+      util::imgui::input_string("AppendStringForAnimations", animationAppendID);
+    }
+    ImGui::EndChild();
+
+    if (ImGui::BeginChild("dialogue-lists", ImVec2(0.0f, 0.0f)))
+    {
+      if (ImGui::BeginTabBar("dialogue-lists-tabs"))
+      {
+        if (ImGui::BeginTabItem("Entries"))
+        {
+          if (ImGui::BeginChild("dialogue-entries-list", ImVec2(0.0f, 0.0f)))
+          {
+            auto entriesListChanged = false;
+            auto hoveredEntry = -1;
+            auto entriesShortcutScope = ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows) ||
+                                        ImGui::IsWindowHovered(ImGuiHoveredFlags_ChildWindows);
+            auto entriesParent = container_index_get(schema, Element::ENTRIES);
+            auto entryInsert = [&](int after) { return entry_insert(schema, after); };
+            auto entrySelect = [&](int)
+            {
+              mode = ENTRY;
+              scrollToEntry = selectedEntry;
+            };
+            auto entryMenuDraw = [&](int target)
+            {
+              auto actionDirty = false;
+              auto targetValid = element_is_type(schema, target, Element::ENTRY);
+
+              if (ImGui::MenuItem("Insert"))
+              {
+                selectedEntry = entryInsert(target);
+                element_selection_set(selectedEntry, selectedEntries, selectedEntry);
+                entrySelect(selectedEntry);
+                actionDirty = selectedEntry >= 0;
+              }
+              if (ImGui::MenuItem("Duplicate", nullptr, false, targetValid))
+                actionDirty =
+                    selected_elements_duplicate(schema, selectedEntry, selectedEntries, Element::ENTRY) || actionDirty;
+              if (ImGui::MenuItem("Delete", "Del", false, targetValid))
+                actionDirty =
+                    selected_elements_erase(schema, selectedEntry, selectedEntries, Element::ENTRY) || actionDirty;
+              ImGui::Separator();
+              if (ImGui::MenuItem("Cut", "Ctrl+X", false, targetValid))
+                actionDirty =
+                    selected_elements_cut(clipboard, schema, selectedEntry, selectedEntries, Element::ENTRY) ||
+                    actionDirty;
+              if (ImGui::MenuItem("Copy", "Ctrl+C", false, targetValid))
+                selected_elements_copy(clipboard, schema, target, selectedEntries, Element::ENTRY);
+              if (ImGui::MenuItem("Paste", "Ctrl+V", false, entriesParent >= 0))
+              {
+                auto pasted =
+                    elements_paste(clipboard, schema, entriesParent, sibling_after_get(schema, entriesParent, target));
+                if (pasted >= 0)
+                {
+                  element_selection_set(selectedEntry, selectedEntries, pasted);
+                  entrySelect(pasted);
+                  actionDirty = true;
+                }
+              }
+              return actionDirty;
+            };
+            if (ImGui::BeginPopupContextWindow("entries-context",
+                                               ImGuiPopupFlags_MouseButtonRight | ImGuiPopupFlags_NoOpenOverItems))
+            {
+              if (entryMenuDraw(selectedEntry))
+              {
+                isDirty = true;
+                entriesListChanged = true;
+              }
+              document_history_context_menu_draw();
+              ImGui::EndPopup();
+            }
+            for (auto index : entries)
+            {
+              if (entriesListChanged) break;
+              auto& entry = schema.elements[index];
+              auto isSelected = mode == ENTRY && element_selected_has(selectedEntry, selectedEntries, index);
+              auto renameResult =
+                  util::imgui::selectable_renamable(std::format("entry-{}", index).c_str(), entry.idString, "<entry>",
+                                                    isSelected, ImGuiSelectableFlags_SelectOnRelease);
+              if (renameResult.selected && !ImGui::IsDragDropActive() &&
+                  !ImGui::IsMouseDragPastThreshold(ImGuiMouseButton_Left))
+              {
+                mode = ENTRY;
+                auto& io = ImGui::GetIO();
+                if (io.KeyCtrl)
+                  element_selection_toggle(selectedEntry, selectedEntries, index);
+                else if (io.KeyShift)
+                  element_selection_range_set(schema, selectedEntry, selectedEntries, index);
+                else
+                  element_selection_set(selectedEntry, selectedEntries, index);
+                selectedPoolEntry = -1;
+                selectedChoice = -1;
+                selectedEffect = -1;
+                textSelectionStart = 0;
+                textSelectionEnd = 0;
+                textSelectionStartByte = 0;
+                textSelectionEndByte = 0;
+                previewIndex = 0;
+                previewTimer = 0.0f;
+                previewBaseDelay = std::max(DELAY_MIN, delay);
+                previewDelay = previewBaseDelay;
+                isPreviewBlipQueued = false;
+                isPlaying = util::imgui::utf8_char_count(entry.text) > 0;
+                previewNeedsAnimationPlay = true;
+                if (isPlaying) dialogue_preview_start_effects_apply(*this, schema, entry, previewIndex);
+              }
+              if (renameResult.renamed)
+              {
+                indices_refresh(schema);
+                isDirty = true;
+              }
+              scroll_to_item_if_requested(scrollToEntry, index);
+              if (ImGui::IsItemHovered()) hoveredEntry = index;
+              if (sibling_drag_drop_draw(schema, index, "DIALOGUE_ENTRY", entry_label_get(entry).c_str(),
+                                         &selectedEntries))
+              {
+                isDirty = true;
+                entriesListChanged = true;
+              }
+              if (ImGui::BeginPopupContextItem())
+              {
+                if (!element_selected_has(selectedEntry, selectedEntries, index))
+                  element_selection_set(selectedEntry, selectedEntries, index);
+                if (entryMenuDraw(index))
+                {
+                  isDirty = true;
+                  entriesListChanged = true;
+                }
+                document_history_context_menu_draw();
+                ImGui::EndPopup();
+              }
+              if (entriesListChanged) break;
+              entry_tooltip_draw(schema, entry);
+            }
+            if (!entriesListChanged && entriesShortcutScope)
+            {
+              auto target = hoveredEntry >= 0 ? hoveredEntry : selectedEntry;
+              if (element_is_type(schema, target, Element::ENTRY))
+              {
+                if (editor_schema::shortcut_is_pressed(ImGuiKey_Delete))
+                {
+                  if (!element_selected_has(selectedEntry, selectedEntries, target))
+                    element_selection_set(selectedEntry, selectedEntries, target);
+                  entriesListChanged = selected_elements_erase(schema, selectedEntry, selectedEntries, Element::ENTRY);
+                }
+                else if (editor_schema::shortcut_is_pressed(ImGuiMod_Ctrl | ImGuiKey_X))
+                {
+                  if (!element_selected_has(selectedEntry, selectedEntries, target))
+                    element_selection_set(selectedEntry, selectedEntries, target);
+                  entriesListChanged =
+                      selected_elements_cut(clipboard, schema, selectedEntry, selectedEntries, Element::ENTRY);
+                }
+                else if (editor_schema::shortcut_is_pressed(ImGuiMod_Ctrl | ImGuiKey_C))
+                {
+                  if (!element_selected_has(selectedEntry, selectedEntries, target))
+                    element_selection_set(selectedEntry, selectedEntries, target);
+                  selected_elements_copy(clipboard, schema, target, selectedEntries, Element::ENTRY);
+                }
+                else if (editor_schema::shortcut_is_pressed(ImGuiMod_Ctrl | ImGuiKey_V))
+                {
+                  auto pasted = elements_paste(clipboard, schema, entriesParent,
+                                               sibling_after_get(schema, entriesParent, target));
+                  if (pasted >= 0)
+                  {
+                    element_selection_set(selectedEntry, selectedEntries, pasted);
+                    entrySelect(pasted);
+                    entriesListChanged = true;
+                  }
+                }
+                if (entriesListChanged) isDirty = true;
+              }
+            }
+          }
+          ImGui::EndChild();
+          ImGui::EndTabItem();
+        }
+
+        if (ImGui::BeginTabItem("Pools"))
+        {
+          if (ImGui::BeginChild("dialogue-pools-list", ImVec2(0.0f, 0.0f)))
+          {
+            auto poolsListChanged = false;
+            auto hoveredPool = -1;
+            auto poolsShortcutScope = ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows) ||
+                                      ImGui::IsWindowHovered(ImGuiHoveredFlags_ChildWindows);
+            auto poolsParent = container_index_get(schema, Element::POOLS);
+            auto poolInsert = [&](int after) { return pool_insert(schema, after); };
+            auto poolSelect = [&](int)
+            {
+              mode = POOL;
+              selectedPoolEntry = -1;
+              scrollToPool = selectedPool;
+            };
+            auto poolMenuDraw = [&](int target)
+            {
+              auto actionDirty = false;
+              auto targetValid = element_is_type(schema, target, Element::POOL);
+
+              if (ImGui::MenuItem("Insert"))
+              {
+                selectedPool = poolInsert(target);
+                element_selection_set(selectedPool, selectedPools, selectedPool);
+                poolSelect(selectedPool);
+                actionDirty = selectedPool >= 0;
+              }
+              if (ImGui::MenuItem("Duplicate", nullptr, false, targetValid))
+                actionDirty =
+                    selected_elements_duplicate(schema, selectedPool, selectedPools, Element::POOL) || actionDirty;
+              if (ImGui::MenuItem("Delete", "Del", false, targetValid))
+                actionDirty =
+                    selected_elements_erase(schema, selectedPool, selectedPools, Element::POOL) || actionDirty;
+              ImGui::Separator();
+              if (ImGui::MenuItem("Cut", "Ctrl+X", false, targetValid))
+                actionDirty =
+                    selected_elements_cut(clipboard, schema, selectedPool, selectedPools, Element::POOL) || actionDirty;
+              if (ImGui::MenuItem("Copy", "Ctrl+C", false, targetValid))
+                selected_elements_copy(clipboard, schema, target, selectedPools, Element::POOL);
+              if (ImGui::MenuItem("Paste", "Ctrl+V", false, poolsParent >= 0))
+              {
+                auto pasted =
+                    elements_paste(clipboard, schema, poolsParent, sibling_after_get(schema, poolsParent, target));
+                if (pasted >= 0)
+                {
+                  element_selection_set(selectedPool, selectedPools, pasted);
+                  poolSelect(pasted);
+                  actionDirty = true;
+                }
+              }
+              return actionDirty;
+            };
+            if (ImGui::BeginPopupContextWindow("pools-context",
+                                               ImGuiPopupFlags_MouseButtonRight | ImGuiPopupFlags_NoOpenOverItems))
+            {
+              if (poolMenuDraw(selectedPool))
+              {
+                isDirty = true;
+                poolsListChanged = true;
+              }
+              document_history_context_menu_draw();
+              ImGui::EndPopup();
+            }
+            for (auto index : pools)
+            {
+              if (poolsListChanged) break;
+              auto& pool = schema.elements[index];
+              auto isSelected = mode == POOL && element_selected_has(selectedPool, selectedPools, index);
+              auto renameResult =
+                  util::imgui::selectable_renamable(std::format("pool-{}", index).c_str(), pool.idString, "<pool>",
+                                                    isSelected, ImGuiSelectableFlags_SelectOnRelease);
+              if (renameResult.selected && !ImGui::IsDragDropActive() &&
+                  !ImGui::IsMouseDragPastThreshold(ImGuiMouseButton_Left))
+              {
+                mode = POOL;
+                auto& io = ImGui::GetIO();
+                if (io.KeyCtrl)
+                  element_selection_toggle(selectedPool, selectedPools, index);
+                else if (io.KeyShift)
+                  element_selection_range_set(schema, selectedPool, selectedPools, index);
+                else
+                  element_selection_set(selectedPool, selectedPools, index);
+                selectedPoolEntry = -1;
+              }
+              if (renameResult.renamed)
+              {
+                indices_refresh(schema);
+                isDirty = true;
+              }
+              scroll_to_item_if_requested(scrollToPool, index);
+              if (ImGui::IsItemHovered()) hoveredPool = index;
+              if (sibling_drag_drop_draw(schema, index, "DIALOGUE_POOL", pool_label_get(pool).c_str(), &selectedPools))
+              {
+                isDirty = true;
+                poolsListChanged = true;
+              }
+              if (ImGui::BeginPopupContextItem())
+              {
+                if (!element_selected_has(selectedPool, selectedPools, index))
+                  element_selection_set(selectedPool, selectedPools, index);
+                if (poolMenuDraw(index))
+                {
+                  isDirty = true;
+                  poolsListChanged = true;
+                }
+                document_history_context_menu_draw();
+                ImGui::EndPopup();
+              }
+              if (poolsListChanged) break;
+            }
+            if (!poolsListChanged && poolsShortcutScope)
+            {
+              auto target = hoveredPool >= 0 ? hoveredPool : selectedPool;
+              if (element_is_type(schema, target, Element::POOL))
+              {
+                if (editor_schema::shortcut_is_pressed(ImGuiKey_Delete))
+                {
+                  if (!element_selected_has(selectedPool, selectedPools, target))
+                    element_selection_set(selectedPool, selectedPools, target);
+                  poolsListChanged = selected_elements_erase(schema, selectedPool, selectedPools, Element::POOL);
+                }
+                else if (editor_schema::shortcut_is_pressed(ImGuiMod_Ctrl | ImGuiKey_X))
+                {
+                  if (!element_selected_has(selectedPool, selectedPools, target))
+                    element_selection_set(selectedPool, selectedPools, target);
+                  poolsListChanged =
+                      selected_elements_cut(clipboard, schema, selectedPool, selectedPools, Element::POOL);
+                }
+                else if (editor_schema::shortcut_is_pressed(ImGuiMod_Ctrl | ImGuiKey_C))
+                {
+                  if (!element_selected_has(selectedPool, selectedPools, target))
+                    element_selection_set(selectedPool, selectedPools, target);
+                  selected_elements_copy(clipboard, schema, target, selectedPools, Element::POOL);
+                }
+                else if (editor_schema::shortcut_is_pressed(ImGuiMod_Ctrl | ImGuiKey_V))
+                {
+                  auto pasted =
+                      elements_paste(clipboard, schema, poolsParent, sibling_after_get(schema, poolsParent, target));
+                  if (pasted >= 0)
+                  {
+                    element_selection_set(selectedPool, selectedPools, pasted);
+                    poolSelect(pasted);
+                    poolsListChanged = true;
+                  }
+                }
+                if (poolsListChanged) isDirty = true;
+              }
+            }
+          }
+          ImGui::EndChild();
+          ImGui::EndTabItem();
+        }
+        ImGui::EndTabBar();
+      }
+    }
+    ImGui::EndChild();
+    ImGui::EndChild();
+
+    ImGui::SameLine();
+
+    ImGui::PushID("dialogue-right");
+    ImGui::BeginGroup();
+    if (mode == ENTRY)
+    {
+      auto* entry = selected_get(schema, selectedEntry);
+      if (!entry)
+      {
+        ImGui::TextUnformatted("No dialogue entry selected.");
+      }
+      else
+      {
+        auto rightAvailable = ImVec2(rightWidth, ImGui::GetContentRegionAvail().y);
+        auto spacing = ImGui::GetStyle().ItemSpacing.y;
+        auto playerHeight = ImGui::GetFrameHeight() + ImGui::GetStyle().WindowPadding.y * ENTRY_PLAYER_PADDING_COUNT;
+        auto contentHeight =
+            std::max(WIDGET_MIN_SIZE, rightAvailable.y - playerHeight - spacing * ENTRY_CONTENT_SPACING_COUNT);
+        auto entityHeight = contentHeight * ENTRY_ENTITY_HEIGHT_RATIO;
+        auto dialogueHeight = contentHeight * ENTRY_DIALOGUE_HEIGHT_RATIO;
+        auto editorHeight = contentHeight * ENTRY_TEXT_EDITOR_HEIGHT_RATIO;
+        auto propertiesHeight = std::max(WIDGET_MIN_SIZE, contentHeight - entityHeight - dialogueHeight - editorHeight);
+
+        if (ImGui::BeginChild("dialogue-entity", ImVec2(rightWidth, entityHeight), ImGuiChildFlags_Borders))
+        {
+          entity_preview_update(*this, resources, schema, reference, *entry, ImGui::GetContentRegionAvail());
+        }
+        ImGui::EndChild();
+
+        ImGui::PushFont(resources.font.get(), resource::Font::SMALL);
+        if (ImGui::BeginChild("dialogue-display", ImVec2(rightWidth, dialogueHeight), ImGuiChildFlags_Borders))
+        {
+          auto maxIndex = util::imgui::utf8_char_count(entry->text);
+          auto shownCount = std::min(previewIndex, maxIndex);
+          auto tabName = reference && !reference->name.empty() ? reference->name : std::string{"Dialogue"};
+          auto* dialogueFont = previewFont.is_valid() ? previewFont.get() : ImGui::GetFont();
+          ImGui::PushStyleColor(ImGuiCol_Tab,
+                                ImVec4(nameColor.r * TAB_COLOR_DIM_MULTIPLIER, nameColor.g * TAB_COLOR_DIM_MULTIPLIER,
+                                       nameColor.b * TAB_COLOR_DIM_MULTIPLIER, 1.0f));
+          ImGui::PushStyleColor(ImGuiCol_TabHovered, ImVec4(nameColor.r * TAB_COLOR_HOVER_MULTIPLIER,
+                                                            nameColor.g * TAB_COLOR_HOVER_MULTIPLIER,
+                                                            nameColor.b * TAB_COLOR_HOVER_MULTIPLIER, 1.0f));
+          ImGui::PushStyleColor(ImGuiCol_TabSelected, ImVec4(nameColor.r, nameColor.g, nameColor.b, 1.0f));
+          ImGui::PushFont(dialogueFont, resource::Font::NORMAL);
+          if (ImGui::BeginTabBar("dialogue-name-tab", ImGuiTabBarFlags_NoCloseWithMiddleMouseButton))
+          {
+            if (ImGui::BeginTabItem(tabName.c_str())) ImGui::EndTabItem();
+            ImGui::EndTabBar();
+          }
+          ImGui::PopFont();
+          ImGui::PopStyleColor(TAB_STYLE_COLOR_COUNT);
+          ImGui::PushFont(dialogueFont, resource::Font::NORMAL);
+          auto effects = dialogue_effect_spans_get(schema, *entry);
+          util::imgui::dialogue_text_draw(entry->text, shownCount, effects, textColor, (float)ImGui::GetTime());
+          ImGui::PopFont();
+
+          auto displayAdvance =
+              ImGui::IsWindowHovered() && ImGui::IsMouseReleased(ImGuiMouseButton_Left) && !ImGui::IsAnyItemHovered();
+          if (shownCount >= maxIndex)
+          {
+            auto choices = schema.children_get(*entry, Element::CHOICE);
+            if (!choices.empty())
+            {
+              ImGui::PushFont(previewFont.is_valid() ? previewFont.get() : ImGui::GetFont(), resource::Font::NORMAL);
+              auto contentMin = ImVec2(ImGui::GetWindowPos().x + ImGui::GetWindowContentRegionMin().x,
+                                       ImGui::GetWindowPos().y + ImGui::GetWindowContentRegionMin().y);
+              auto contentMax = ImVec2(ImGui::GetWindowPos().x + ImGui::GetWindowContentRegionMax().x,
+                                       ImGui::GetWindowPos().y + ImGui::GetWindowContentRegionMax().y);
+              auto buttonY = contentMax.y - ImGui::GetFrameHeight();
+              auto separatorY = buttonY - ImGui::GetStyle().ItemSpacing.y;
+              ImGui::GetWindowDrawList()->AddLine(ImVec2(contentMin.x, separatorY), ImVec2(contentMax.x, separatorY),
+                                                  ImGui::GetColorU32(ImGuiCol_Separator));
+              ImGui::SetCursorScreenPos(ImVec2(contentMin.x, buttonY));
+              auto buttonSize = util::imgui::row_widget_size_get((int)choices.size());
+              ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, CHOICE_BUTTON_ROUNDING);
+              ImGui::PushStyleVar(ImGuiStyleVar_GrabRounding, CHOICE_BUTTON_ROUNDING);
+              ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(nameColor.r, nameColor.g, nameColor.b, 1.0f));
+              ImGui::PushStyleColor(
+                  ImGuiCol_ButtonHovered,
+                  ImVec4(std::min(nameColor.r * CHOICE_BUTTON_HOVER_MULTIPLIER, CHOICE_BUTTON_COLOR_MAX),
+                         std::min(nameColor.g * CHOICE_BUTTON_HOVER_MULTIPLIER, CHOICE_BUTTON_COLOR_MAX),
+                         std::min(nameColor.b * CHOICE_BUTTON_HOVER_MULTIPLIER, CHOICE_BUTTON_COLOR_MAX), 1.0f));
+              ImGui::PushStyleColor(
+                  ImGuiCol_ButtonActive,
+                  ImVec4(std::min(nameColor.r * CHOICE_BUTTON_ACTIVE_MULTIPLIER, CHOICE_BUTTON_COLOR_MAX),
+                         std::min(nameColor.g * CHOICE_BUTTON_ACTIVE_MULTIPLIER, CHOICE_BUTTON_COLOR_MAX),
+                         std::min(nameColor.b * CHOICE_BUTTON_ACTIVE_MULTIPLIER, CHOICE_BUTTON_COLOR_MAX), 1.0f));
+              for (auto index = 0; index < (int)choices.size(); ++index)
+              {
+                auto* choice = choices[index];
+                auto label = choice->text.empty() ? "<choice>" : choice->text.c_str();
+                ImGui::PushID(index);
+                if (WIDGET_FX(ImGui::Button(label, buttonSize)))
+                {
+                  if (auto* next = schema.dialogue_entry_get(*choice))
+                    dialogue_preview_entry_set(*this, schema, element_index_get(schema, next), true);
+                }
+                ImGui::SetItemTooltip("%s", label);
+                ImGui::PopID();
+                if (index + 1 < (int)choices.size()) ImGui::SameLine();
+              }
+              ImGui::PopStyleColor(CHOICE_BUTTON_STYLE_COLOR_COUNT);
+              ImGui::PopStyleVar(CHOICE_BUTTON_STYLE_VAR_COUNT);
+              ImGui::PopFont();
+            }
+            else if (displayAdvance && !entry->next.empty())
+            {
+              if (auto* next = schema.dialogue_entry_get(*entry))
+              {
+                dialogue_preview_entry_set(*this, schema, element_index_get(schema, next), true);
+              }
+            }
+            if (!entry->next.empty())
+            {
+              auto indicatorSize = ImVec2(ImGui::GetTextLineHeightWithSpacing(), ImGui::GetTextLineHeightWithSpacing());
+              auto contentMax = ImVec2(ImGui::GetWindowPos().x + ImGui::GetWindowContentRegionMax().x,
+                                       ImGui::GetWindowPos().y + ImGui::GetWindowContentRegionMax().y);
+              ImGui::SetCursorScreenPos(ImVec2(contentMax.x - indicatorSize.x, contentMax.y - indicatorSize.y));
+              auto cursorPos = ImGui::GetCursorScreenPos();
+              auto offset = std::sin((float)ImGui::GetTime() * NEXT_INDICATOR_SPEED) *
+                            (indicatorSize.x * NEXT_INDICATOR_OFFSET_RATIO);
+              auto center = ImVec2(cursorPos.x + (indicatorSize.x * CENTER_RATIO) + offset,
+                                   cursorPos.y + (indicatorSize.y * CENTER_RATIO));
+              auto half = std::min(indicatorSize.x, indicatorSize.y) * NEXT_INDICATOR_HALF_RATIO;
+              auto tip = ImVec2(center.x + half, center.y);
+              auto baseA = ImVec2(center.x - half, center.y - half);
+              auto baseB = ImVec2(center.x - half, center.y + half);
+              auto color = ImGui::GetColorU32(ImGuiCol_Text);
+              ImGui::GetWindowDrawList()->AddTriangleFilled(tip, baseA, baseB, color);
+              ImGui::InvisibleButton("##next-indicator", indicatorSize);
+            }
+          }
+          else if (displayAdvance)
+          {
+            dialogue_preview_skipped_effects_apply(*this, schema, *entry, previewIndex, maxIndex);
+            previewIndex = maxIndex;
+            previewTimer = 0.0f;
+            isPreviewBlipQueued = false;
+            isPlaying = false;
+          }
+        }
+        ImGui::EndChild();
+        ImGui::PopFont();
+        entry = selected_get(schema, selectedEntry);
+        if (!entry)
+        {
+          ImGui::EndGroup();
+          ImGui::PopID();
+          return isDirty;
+        }
+
+        if (ImGui::BeginChild("dialogue-text-editor", ImVec2(rightWidth, editorHeight), ImGuiChildFlags_Borders))
+        {
+          auto textResult =
+              util::imgui::input_string_multiline_result("##entry-text", entry->text, ImVec2(-FLT_MIN, -FLT_MIN));
+          auto textEditorRectMin = ImGui::GetItemRectMin();
+          auto textEditorRectMax = ImGui::GetItemRectMax();
+
+          auto textEditorRightClicked = ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Right);
+          auto textEditorScroll = ImVec2{};
+          if (auto* inputState = ImGui::GetInputTextState(ImGui::GetItemID()))
+          {
+            textEditorScroll = inputState->Scroll;
+            auto selectionStart = inputState->GetSelectionStart();
+            auto selectionEnd = inputState->GetSelectionEnd();
+            if (selectionEnd < selectionStart) std::swap(selectionStart, selectionEnd);
+            if (selectionStart != selectionEnd)
+            {
+              textSelectionStartByte = selectionStart;
+              textSelectionEndByte = selectionEnd;
+              textSelectionStart = util::imgui::utf8_byte_to_char_index(entry->text, selectionStart);
+              textSelectionEnd = util::imgui::utf8_byte_to_char_index(entry->text, selectionEnd);
+            }
+            else if (textEditorRightClicked && textSelectionStartByte != textSelectionEndByte)
+            {
+              inputState->WantReloadUserBuf = true;
+              inputState->ReloadSelectionStart = textSelectionStartByte;
+              inputState->ReloadSelectionEnd = textSelectionEndByte;
+            }
+            else if (!textEditorRightClicked)
+            {
+              textSelectionStartByte = selectionStart;
+              textSelectionEndByte = selectionEnd;
+              textSelectionStart = util::imgui::utf8_byte_to_char_index(entry->text, selectionStart);
+              textSelectionEnd = util::imgui::utf8_byte_to_char_index(entry->text, selectionEnd);
+            }
+          }
+          if ((textEditorRightClicked || ImGui::IsPopupOpen("text-editor-context") ||
+               ImGui::IsPopupOpen("text-editor-item-context")) &&
+              textSelectionStartByte != textSelectionEndByte)
+            text_selection_overlay_draw(entry->text, textSelectionStartByte, textSelectionEndByte, textEditorRectMin,
+                                        textEditorRectMax, textEditorScroll);
+
+          if (ImGui::BeginPopupContextItem("text-editor-item-context"))
+          {
+            if (dialogue_child_insert_menu_draw(*this, schema, selectedEntry, dialogue_child_selected_get(*this)))
+              isDirty = true;
+            if (selectedEffect >= 0) scrollToEffect = selectedEffect;
+            document_history_context_menu_draw();
+            ImGui::EndPopup();
+          }
+
+          if (ImGui::BeginPopupContextWindow("text-editor-context", ImGuiPopupFlags_MouseButtonRight))
+          {
+            if (dialogue_child_insert_menu_draw(*this, schema, selectedEntry, dialogue_child_selected_get(*this)))
+              isDirty = true;
+            if (selectedEffect >= 0) scrollToEffect = selectedEffect;
+            document_history_context_menu_draw();
+            ImGui::EndPopup();
+          }
+
+          entry = selected_get(schema, selectedEntry);
+          if (!entry)
+          {
+            ImGui::EndChild();
+            ImGui::EndGroup();
+            ImGui::PopID();
+            return isDirty;
+          }
+
+          if (textResult.changed || textResult.committed)
+          {
+            auto textLength = util::imgui::utf8_char_count(entry->text);
+            if (isPlaying)
+              previewIndex = std::min(previewIndex, textLength);
+            else
+              previewIndex = textLength;
+            if (textResult.committed) isDirty = true;
+          }
+        }
+        ImGui::EndChild();
+
+        if (ImGui::BeginChild("dialogue-properties", ImVec2(rightWidth, propertiesHeight), ImGuiChildFlags_Borders))
+        {
+          auto propertiesShortcutScope = ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows) ||
+                                         ImGui::IsWindowHovered(ImGuiHoveredFlags_ChildWindows);
+          auto availableWidth = ImGui::GetContentRegionAvail().x;
+          auto spacingX = ImGui::GetStyle().ItemSpacing.x;
+          auto innerSpacingX = ImGui::GetStyle().ItemInnerSpacing.x;
+          auto idLabelWidth = ImGui::CalcTextSize("Label").x + innerSpacingX;
+          auto nextLabelWidth = ImGui::CalcTextSize("Next").x + innerSpacingX;
+          auto itemWidth = std::max(PROPERTY_ITEM_MIN_WIDTH,
+                                    (availableWidth - spacingX - idLabelWidth - nextLabelWidth) * CENTER_RATIO);
+          auto choices = dialogue_choice_indices_get(schema, *entry);
+          ImGui::SetNextItemWidth(itemWidth);
+          if (util::imgui::input_string("Label", entry->idString))
+          {
+            indices_refresh(schema);
+            isDirty = true;
+          }
+          ImGui::SameLine();
+          ImGui::BeginDisabled(!choices.empty());
+          ImGui::SetNextItemWidth(itemWidth);
+          if (entry_combo_draw("Next", schema, entry->next)) isDirty = true;
+          ImGui::EndDisabled();
+          ImGui::Separator();
+          if (util::imgui::input_string("Animation", entry->animation))
+          {
+            isDirty = true;
+          }
+          if (ImGui::BeginChild("dialogue-children-child", ImVec2(0.0f, 0.0f)))
+          {
+            auto isChildrenStructureChanged = false;
+            auto isEffectsChanged = false;
+            auto hoveredChild = -1;
+            auto children = dialogue_child_indices_get(schema, *entry);
+            auto childrenRectMin = ImGui::GetCursorScreenPos();
+            auto childInsert = [&](int) { return -1; };
+            auto childSelect = [&](int index) { dialogue_child_select(*this, schema, index); };
+            auto childClear = [&]() { dialogue_child_clear(*this); };
+            auto childActionDraw = [&](int target)
+            {
+              auto type = dialogue_child_type_get(schema, target);
+              auto selectedChild = dialogue_child_selected_get(*this);
+              auto options =
+                  element_action_options_get(selectedEntry, target, type, false, true, type != Element::UNKNOWN);
+              options.isPasteEnabled = type != Element::UNKNOWN;
+              return editor_schema::element_context_menu_draw(clipboard, schema, options, selectedChild, childInsert,
+                                                            childSelect, childClear);
+            };
+
+            if (ImGui::BeginTable("dialogue-children", DIALOGUE_CHILD_TABLE_COLUMNS,
+                                  ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable |
+                                      ImGuiTableFlags_SizingStretchSame))
+            {
+              ImGui::TableSetupColumn("Type", ImGuiTableColumnFlags_WidthStretch, 1.0f);
+              ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch, 1.0f);
+              ImGui::TableSetupColumn("Start / Next", ImGuiTableColumnFlags_WidthStretch, 1.0f);
+              ImGui::TableSetupColumn("End", ImGuiTableColumnFlags_WidthStretch, 1.0f);
+              for (auto childIndex : children)
+              {
+                if (childIndex < 0 || childIndex >= (int)schema.elements.size()) continue;
+                auto& child = schema.elements[childIndex];
+                ImGui::PushID(childIndex);
+                ImGui::TableNextRow();
+
+                ImGui::TableNextColumn();
+                auto previousType = child.type;
+                auto childLabel = child.type == Element::CHOICE ? "Choice" : child.typeString.c_str();
+                auto isChildHovered = false;
+                auto isChildClicked = false;
+                auto isChildContextRequested = false;
+                if (dialogue_child_type_combo_draw(*this, schema, selectedEntry, childIndex))
+                {
+                  isDirty = true;
+                  if (child.type == Element::EFFECT) isEffectsChanged = true;
+                  if (child.type != previousType) isChildrenStructureChanged = true;
+                }
+                scroll_to_item_if_requested(scrollToChoice, childIndex);
+                scroll_to_item_if_requested(scrollToEffect, childIndex);
+                isChildHovered = ImGui::IsItemHovered();
+                isChildClicked = ImGui::IsItemClicked();
+                isChildContextRequested = isChildHovered && ImGui::IsMouseClicked(ImGuiMouseButton_Right);
+                if (sibling_drag_drop_draw(schema, childIndex, "DIALOGUE_CHILD", childLabel))
+                {
+                  isDirty = true;
+                  isChildrenStructureChanged = true;
+                }
+
+                auto contextSpaceWidth = ImGui::GetContentRegionAvail().x;
+                if (contextSpaceWidth > WIDGET_MIN_SIZE)
+                {
+                  ImGui::SameLine(0.0f, 0.0f);
+                  ImGui::InvisibleButton("##Child Context Space", ImVec2(contextSpaceWidth, ImGui::GetFrameHeight()));
+                  isChildHovered = ImGui::IsItemHovered() || isChildHovered;
+                  isChildClicked = ImGui::IsItemClicked() || isChildClicked;
+                  isChildContextRequested = (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Right)) ||
+                                            isChildContextRequested;
+                  if (sibling_drag_drop_draw(schema, childIndex, "DIALOGUE_CHILD", childLabel))
+                  {
+                    isDirty = true;
+                    isChildrenStructureChanged = true;
+                  }
+                }
+
+                if (isChildHovered) hoveredChild = childIndex;
+                if (isChildClicked) dialogue_child_select(*this, schema, childIndex);
+                if (isChildContextRequested) ImGui::OpenPopup("child-context");
+                if (ImGui::BeginPopup("child-context"))
+                {
+                  dialogue_child_select(*this, schema, childIndex);
+                  auto isRowStructureChanged = false;
+                  if (dialogue_child_insert_menu_draw(*this, schema, selectedEntry, childIndex))
+                  {
+                    isDirty = true;
+                    isChildrenStructureChanged = true;
+                    isRowStructureChanged = true;
+                  }
+                  auto action = childActionDraw(childIndex);
+                  if (action.isDirty) isDirty = true;
+                  if (action.isStructureChanged) isChildrenStructureChanged = true;
+                  if (action.isStructureChanged) isRowStructureChanged = true;
+                  document_history_context_menu_draw();
+                  ImGui::EndPopup();
+                  if (isRowStructureChanged)
+                  {
+                    ImGui::PopID();
+                    break;
+                  }
+                }
+
+                ImGui::TableNextColumn();
+                if (child.type == Element::CHOICE)
+                {
+                  ImGui::SetNextItemWidth(-FLT_MIN);
+                  if (util::imgui::input_string("##Choice Text", child.text)) isDirty = true;
+                }
+                else
+                {
+                  switch (dialogue_effect_type_get(child.typeString))
+                  {
+                    case DialogueEffectType::ANIMATION:
+                      ImGui::SetNextItemWidth(-FLT_MIN);
+                      if (util::imgui::input_string("##Value", child.animation)) isEffectsChanged = true;
+                      break;
+                    case DialogueEffectType::DELAY:
+                      ImGui::SetNextItemWidth(-FLT_MIN);
+                      if (ImGui::InputInt("##Value", &child.delayTicks)) isEffectsChanged = true;
+                      break;
+                    case DialogueEffectType::OSCILLATION:
+                    case DialogueEffectType::SHAKE:
+                    case DialogueEffectType::BIG:
+                    case DialogueEffectType::SMALL:
+                      break;
+                    case DialogueEffectType::SCREEN_SHAKE:
+                      break;
+                    case DialogueEffectType::SOUND:
+                    {
+                      auto* root = schema.root();
+                      auto rootPath = root ? root->soundRootPath : std::string{};
+                      if (!child.sound.empty() && child.soundEntry.path != child.sound)
+                        sound_effect_entry_rebuild(schemaPath, rootPath, child);
+                      auto displayPath = resource_display_path_get(schemaPath, rootPath, child.sound);
+                      auto suffixWidth = SOUND_WIDGET_WIDTH;
+                      auto pathWidth = std::max(WIDGET_MIN_SIZE, ImGui::GetContentRegionAvail().x - suffixWidth -
+                                                                     ImGui::GetStyle().ItemSpacing.x);
+                      if (util::imgui::path_widget("##Sound Value", child.sound, displayPath, ImVec2(pathWidth, 0.0f)))
+                      {
+                        pendingSetting = PENDING_SOUND;
+                        pendingSoundEffect = childIndex;
+                        dialog.file_open(util::Dialog::SCHEMA_SOUND_OPEN);
+                      }
+                      ImGui::SameLine();
+                      auto isMissing = !child.sound.empty() && !child.soundEntry.sound.is_valid();
+                      if (util::imgui::sound_widget("##Sound Play", isMissing))
+                      {
+                        if (!child.soundEntry.sound.is_valid()) sound_effect_entry_rebuild(schemaPath, rootPath, child);
+                        if (child.soundEntry.sound.is_valid()) child.soundEntry.sound.play();
+                      }
+                      break;
+                    }
+                    default:
+                      ImGui::SetNextItemWidth(-FLT_MIN);
+                      if (ImGui::ColorEdit3("##Value", &child.color.x)) isEffectsChanged = true;
+                      break;
+                  }
+                }
+
+                ImGui::TableNextColumn();
+                if (child.type == Element::CHOICE)
+                {
+                  ImGui::SetNextItemWidth(-FLT_MIN);
+                  if (entry_combo_draw("##Choice Next", schema, child.next)) isDirty = true;
+                }
+                else
+                {
+                  ImGui::TextUnformatted("Start");
+                  ImGui::SameLine();
+                  ImGui::SetNextItemWidth(-FLT_MIN);
+                  if (ImGui::InputInt("##Start", &child.start, EFFECT_INDEX_STEP, EFFECT_INDEX_FAST_STEP))
+                    isEffectsChanged = true;
+                }
+
+                ImGui::TableNextColumn();
+                if (child.type == Element::CHOICE)
+                {
+                  ImGui::TextUnformatted("-");
+                }
+                else if (dialogue_effect_is_ranged(child))
+                {
+                  ImGui::TextUnformatted("End");
+                  ImGui::SameLine();
+                  ImGui::SetNextItemWidth(-FLT_MIN);
+                  if (ImGui::InputInt("##End", &child.end, EFFECT_INDEX_STEP, EFFECT_INDEX_FAST_STEP))
+                    isEffectsChanged = true;
+                }
+
+                ImGui::PopID();
+                if (isChildrenStructureChanged) break;
+              }
+              ImGui::EndTable();
+            }
+            auto childrenRectMax = ImGui::GetCursorScreenPos();
+            auto isChildrenShortcutScope =
+                propertiesShortcutScope && ImGui::IsMouseHoveringRect(childrenRectMin, childrenRectMax);
+            if (ImGui::IsMouseHoveringRect(childrenRectMin, childrenRectMax) &&
+                ImGui::BeginPopupContextWindow("children-context",
+                                               ImGuiPopupFlags_MouseButtonRight | ImGuiPopupFlags_NoOpenOverItems))
+            {
+              auto target = dialogue_child_selected_get(*this);
+              if (dialogue_child_insert_menu_draw(*this, schema, selectedEntry, target))
+              {
+                isDirty = true;
+                isChildrenStructureChanged = true;
+              }
+              auto action = childActionDraw(target);
+              if (action.isDirty) isDirty = true;
+              if (action.isStructureChanged) isChildrenStructureChanged = true;
+              document_history_context_menu_draw();
+              ImGui::EndPopup();
+            }
+            if (isChildrenShortcutScope)
+            {
+              auto target = hoveredChild >= 0 ? hoveredChild : dialogue_child_selected_get(*this);
+              auto type = dialogue_child_type_get(schema, target);
+              auto selectedChild = dialogue_child_selected_get(*this);
+              auto options = element_action_options_get(selectedEntry, target, type, false);
+              options.isPasteEnabled = type != Element::UNKNOWN;
+              auto action = editor_schema::element_shortcuts_apply(clipboard, schema, options, selectedChild, childSelect,
+                                                                 childClear);
+              if (action.isDirty) isDirty = true;
+              if (action.isStructureChanged) isChildrenStructureChanged = true;
+            }
+            if (isChildrenStructureChanged)
+            {
+              entry = selected_get(schema, selectedEntry);
+              if (!entry)
+              {
+                ImGui::EndChild();
+                ImGui::EndChild();
+                ImGui::EndGroup();
+                ImGui::PopID();
+                return isDirty;
+              }
+            }
+
+            if (isEffectsChanged)
+            {
+              entry = selected_get(schema, selectedEntry);
+              if (!entry)
+              {
+                ImGui::EndChild();
+                ImGui::EndChild();
+                ImGui::EndGroup();
+                ImGui::PopID();
+                return isDirty;
+              }
+              for (auto effectIndex : dialogue_effect_indices_get(schema, *entry))
+              {
+                auto& effect = schema.elements[effectIndex];
+                dialogue_effect_defaults_apply(effect);
+                switch (dialogue_effect_type_get(effect.typeString))
+                {
+                  case DialogueEffectType::DELAY:
+                    effect.delayTicks = std::max(DELAY_MIN, effect.delayTicks);
+                    break;
+                  case DialogueEffectType::OSCILLATION:
+                  case DialogueEffectType::SHAKE:
+                  case DialogueEffectType::SCREEN_SHAKE:
+                  case DialogueEffectType::BIG:
+                  case DialogueEffectType::SMALL:
+                    break;
+                  default:
+                    break;
+                }
+              }
+              isDirty = true;
+            }
+          }
+          ImGui::EndChild();
+        }
+        ImGui::EndChild();
+
+        if (ImGui::BeginChild("dialogue-player", ImVec2(rightWidth, playerHeight), ImGuiChildFlags_Borders))
+        {
+          auto playPauseWidth =
+              ImGui::CalcTextSize("Pause").x + ImGui::GetStyle().FramePadding.x * ENTRY_PLAYER_PADDING_COUNT;
+          if (ImGui::Button(isPlaying ? "Pause" : "Play", ImVec2(playPauseWidth, 0.0f)))
+          {
+            if (isPlaying)
+              isPlaying = false;
+            else
+            {
+              if (previewIndex >= util::imgui::utf8_char_count(entry->text)) previewIndex = 0;
+              previewTimer = 0.0f;
+              previewBaseDelay = std::max(DELAY_MIN, delay);
+              previewDelay = previewBaseDelay;
+              isPreviewBlipQueued = false;
+              isPlaying = true;
+              previewNeedsAnimationPlay = true;
+              dialogue_preview_start_effects_apply(*this, schema, *entry, previewIndex);
+            }
+          }
+          ImGui::SameLine();
+          auto maxIndex = util::imgui::utf8_char_count(entry->text);
+          if (isPlaying && previewIndex < maxIndex)
+          {
+            previewTimer += ImGui::GetIO().DeltaTime;
+            auto secondsPerIndex = std::max(DELAY_MIN, previewDelay) / PREVIEW_RATE;
+            while (previewTimer >= secondsPerIndex && previewIndex < maxIndex)
+            {
+              previewTimer -= secondsPerIndex;
+              ++previewIndex;
+              previewDelay = previewBaseDelay;
+              dialogue_preview_start_effects_apply(*this, schema, *entry, previewIndex);
+              auto delayCharacter = dialogue_delay_character_get(schema, entry->text, previewIndex - 1, previewDelay);
+              previewDelay = delayCharacter.delay;
+              auto isBlipStep = blipDelay > 0 && previewIndex % blipDelay == 0;
+              if (delayCharacter.isDisableTalk)
+              {
+                if (isBlipStep) isPreviewBlipQueued = true;
+              }
+              else if (isBlipStep || isPreviewBlipQueued)
+              {
+                if (previewBlip && previewBlip->is_valid()) previewBlip->play();
+                isPreviewBlipQueued = false;
+              }
+              secondsPerIndex = std::max(DELAY_MIN, previewDelay) / PREVIEW_RATE;
+            }
+          }
+          if (previewIndex >= maxIndex)
+          {
+            isPlaying = false;
+            isPreviewBlipQueued = false;
+          }
+          ImGui::SetNextItemWidth(-FLT_MIN);
+          if (ImGui::SliderInt("##dialogue-index", &previewIndex, 0, maxIndex))
+          {
+            previewTimer = 0.0f;
+            isPlaying = false;
+            previewBaseDelay = std::max(DELAY_MIN, delay);
+            previewDelay = previewBaseDelay;
+            isPreviewBlipQueued = false;
+          }
+        }
+        ImGui::EndChild();
+      }
+    }
+    else
+    {
+      auto* pool = selected_get(schema, selectedPool);
+      if (!pool)
+      {
+        ImGui::TextUnformatted("No dialogue pool selected.");
+      }
+      else if (ImGui::BeginChild("pool-entries", ImVec2(rightWidth, 0.0f), ImGuiChildFlags_Borders))
+      {
+        auto poolEntriesShortcutScope = ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows) ||
+                                        ImGui::IsWindowHovered(ImGuiHoveredFlags_ChildWindows);
+        auto hoveredPoolEntry = -1;
+        if (util::imgui::input_string("Name", pool->idString))
+        {
+          indices_refresh(schema);
+          isDirty = true;
+        }
+        ImGui::Separator();
+        if (ImGui::BeginPopupContextWindow("pool-context",
+                                           ImGuiPopupFlags_MouseButtonRight | ImGuiPopupFlags_NoOpenOverItems))
+        {
+          if (pool_entry_insert_menu_draw(schema, selectedPool, selectedPoolEntry, entries, selectedPoolEntry,
+                                          scrollToPoolEntry))
+            isDirty = true;
+          if (ImGui::MenuItem("Delete", "Del", false, selectedPoolEntry >= 0))
+          {
+            if (pool_entry_delete(schema, selectedPool, selectedPoolEntry))
+            {
+              selectedPoolEntry = -1;
+              isDirty = true;
+            }
+          }
+          document_history_context_menu_draw();
+          ImGui::EndPopup();
+        }
+        auto children = pool->children;
+        for (auto childIndex : children)
+        {
+          if (childIndex < 0 || childIndex >= (int)schema.elements.size()) continue;
+          auto& poolEntry = schema.elements[childIndex];
+          if (poolEntry.type != Element::POOL_ENTRY) continue;
+          auto label = poolEntry.idString.empty() ? "<entry>" : poolEntry.idString.c_str();
+          if (ImGui::Selectable(label, selectedPoolEntry == childIndex)) selectedPoolEntry = childIndex;
+          scroll_to_item_if_requested(scrollToPoolEntry, childIndex);
+          if (ImGui::IsItemHovered()) hoveredPoolEntry = childIndex;
+          if (sibling_drag_drop_draw(schema, childIndex, "DIALOGUE_POOL_ENTRY", label))
+          {
+            selectedPoolEntry = childIndex;
+            isDirty = true;
+          }
+          if (ImGui::BeginPopupContextItem())
+          {
+            if (pool_entry_insert_menu_draw(schema, selectedPool, childIndex, entries, selectedPoolEntry,
+                                            scrollToPoolEntry))
+              isDirty = true;
+            if (ImGui::MenuItem("Delete", "Del"))
+            {
+              if (pool_entry_delete(schema, selectedPool, childIndex))
+              {
+                selectedPoolEntry = -1;
+                isDirty = true;
+              }
+            }
+            document_history_context_menu_draw();
+            ImGui::EndPopup();
+          }
+          if (auto* entry = schema.dialogue_entry_get(poolEntry.idString)) entry_tooltip_draw(schema, *entry);
+        }
+        if (poolEntriesShortcutScope && editor_schema::shortcut_is_pressed(ImGuiKey_Delete))
+        {
+          auto target = hoveredPoolEntry >= 0 ? hoveredPoolEntry : selectedPoolEntry;
+          if (target >= 0 && pool_entry_delete(schema, selectedPool, target))
+          {
+            selectedPoolEntry = -1;
+            isDirty = true;
+          }
+        }
+      }
+      ImGui::EndChild();
+    }
+    ImGui::EndGroup();
+    ImGui::PopID();
+
+    return isDirty;
+  }
+}
diff --git a/src/developer/editor.hpp b/src/developer/editor.hpp
new file mode 100644
index 0000000..f2fbd98
--- /dev/null
+++ b/src/developer/editor.hpp
@@ -0,0 +1,400 @@
+#pragma once
+
+#include <algorithm>
+#include <filesystem>
+#include <functional>
+#include <span>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <glm/glm.hpp>
+#include <imgui.h>
+#include <imgui_internal.h>
+
+#include "../resource/audio.hpp"
+#include "../resource/character.hpp"
+#include "../resource/font.hpp"
+#include "../resource/schema.hpp"
+#include "../entity.hpp"
+#include "../resources.hpp"
+#include "../util/clipboard.hpp"
+#include "../util/dialog.hpp"
+#include "../util/imgui/entity_canvas.hpp"
+
+namespace game::developer
+{
+  extern bool gIsDocumentUndoMenuRequested;
+  extern bool gIsDocumentRedoMenuRequested;
+
+  namespace editor_schema
+  {
+    using Schema = resource::xml::Schema;
+    using Element = Schema::Element;
+
+    struct ElementTypeInfo
+    {
+      std::string_view xmlName{};
+      Element::Type type{};
+    };
+
+    constexpr ElementTypeInfo ELEMENT_TYPES[]{
+#define GAME_SCHEMA_DEVELOPER_ELEMENT_TYPE(NAME, ENUM) {#NAME, Element::ENUM},
+        GAME_SCHEMA_ELEMENT_TYPES(GAME_SCHEMA_DEVELOPER_ELEMENT_TYPE)
+#undef GAME_SCHEMA_DEVELOPER_ELEMENT_TYPE
+    };
+
+    struct ElementActionOptions
+    {
+      int parent{-1};
+      int target{-1};
+      int after{-1};
+      int pasteParent{-1};
+      int pasteAfter{-2};
+      Element::Type type{Element::UNKNOWN};
+      bool isInsertVisible{};
+      bool isInsertEnabled{};
+      bool isDuplicateEnabled{true};
+      bool isDeleteEnabled{true};
+      bool isClearVisible{};
+      bool isClearEnabled{};
+      bool isPasteEnabled{true};
+    };
+
+    struct ElementActionResult
+    {
+      bool isDirty{};
+      bool isStructureChanged{};
+    };
+
+    inline const ElementTypeInfo& element_type_info_get(Element::Type type)
+    {
+      for (auto& info : ELEMENT_TYPES)
+        if (info.type == type) return info;
+      return ELEMENT_TYPES[0];
+    }
+
+    inline bool shortcut_is_pressed(ImGuiKeyChord chord)
+    {
+      auto& io = ImGui::GetIO();
+      return !io.WantTextInput && !ImGui::IsAnyItemActive() &&
+             ImGui::Shortcut(chord, ImGuiInputFlags_RouteGlobal | ImGuiInputFlags_RouteOverFocused);
+    }
+
+    inline void document_history_context_menu_draw()
+    {
+      ImGui::Separator();
+      if (ImGui::MenuItem("Undo", "Ctrl+Z")) gIsDocumentUndoMenuRequested = true;
+      if (ImGui::MenuItem("Redo", "Ctrl+Shift+Z")) gIsDocumentRedoMenuRequested = true;
+    }
+
+    inline bool element_index_is_valid(const Schema& schema, int index)
+    {
+      return index >= 0 && index < (int)schema.elements.size();
+    }
+
+    inline void child_insert_after(Schema& schema, int parent, int child, int after)
+    {
+      if (!element_index_is_valid(schema, parent)) return;
+      auto& children = schema.elements[parent].children;
+      auto childIt = std::ranges::find(children, child);
+      if (childIt == children.end()) return;
+      auto value = *childIt;
+      children.erase(childIt);
+      auto afterIt = std::ranges::find(children, after);
+      if (afterIt == children.end())
+        children.emplace_back(value);
+      else
+        children.insert(afterIt + 1, value);
+    }
+
+    inline int element_paste(util::Clipboard& clipboard, Schema& schema, int parent, int after,
+                             Element::Type expected = Element::UNKNOWN)
+    {
+      auto index = schema.element_insert_xml(clipboard.get(), parent);
+      if (index < 0) return -1;
+      if (expected != Element::UNKNOWN && schema.elements[index].type != expected)
+      {
+        schema.element_erase(index);
+        return -1;
+      }
+      child_insert_after(schema, parent, index, after);
+      schema.indices_refresh();
+      return index;
+    }
+
+    inline int element_duplicate(Schema& schema, int parent, int source, int after,
+                                 Element::Type expected = Element::UNKNOWN)
+    {
+      if (!element_index_is_valid(schema, source)) return -1;
+      if (parent < 0) parent = schema.elements[source].parent;
+      if (!element_index_is_valid(schema, parent)) return -1;
+      auto index = schema.element_insert_xml(schema.element_serialize(source), parent);
+      if (index < 0) return -1;
+      if (expected != Element::UNKNOWN && schema.elements[index].type != expected)
+      {
+        schema.element_erase(index);
+        return -1;
+      }
+      child_insert_after(schema, parent, index, after);
+      schema.indices_refresh();
+      return index;
+    }
+
+    inline void element_copy(util::Clipboard& clipboard, const Schema& schema, int index)
+    {
+      if (element_index_is_valid(schema, index)) clipboard.copy(schema.element_serialize(index));
+    }
+
+    inline bool element_cut(util::Clipboard& clipboard, Schema& schema, int index)
+    {
+      if (!element_index_is_valid(schema, index)) return false;
+      clipboard.cut(schema.element_serialize(index));
+      return schema.element_erase(index);
+    }
+
+    inline bool children_clear(Schema& schema, int parent, Element::Type type)
+    {
+      if (!element_index_is_valid(schema, parent)) return false;
+      std::vector<int> indices{};
+      for (auto child : schema.elements[parent].children)
+      {
+        if (!element_index_is_valid(schema, child)) continue;
+        if (schema.elements[child].type == type) indices.emplace_back(child);
+      }
+      if (indices.empty()) return false;
+
+      std::ranges::sort(indices, std::greater{});
+      auto isDirty = false;
+      for (auto index : indices)
+        if (schema.element_erase(index)) isDirty = true;
+      return isDirty;
+    }
+
+    template <typename Insert, typename Select, typename Clear>
+    ElementActionResult element_context_menu_draw(util::Clipboard& clipboard, Schema& schema,
+                                                  const ElementActionOptions& options, int& selected, Insert insert,
+                                                  Select select, Clear clear)
+    {
+      ElementActionResult result{};
+      auto isTargetValid = element_index_is_valid(schema, options.target);
+      auto pasteParent = options.pasteParent >= 0 ? options.pasteParent : options.parent;
+      auto pasteAfter = options.pasteAfter >= -1 ? options.pasteAfter : options.after;
+
+      if (options.isInsertVisible && ImGui::MenuItem("Insert", nullptr, false, options.isInsertEnabled))
+      {
+        selected = insert(options.after);
+        if (selected >= 0)
+        {
+          select(selected);
+          result.isDirty = true;
+          result.isStructureChanged = true;
+        }
+      }
+      if (ImGui::MenuItem("Duplicate", nullptr, false, options.isDuplicateEnabled && isTargetValid))
+      {
+        selected = element_duplicate(schema, options.parent, options.target, options.after, options.type);
+        if (selected >= 0)
+        {
+          select(selected);
+          result.isDirty = true;
+          result.isStructureChanged = true;
+        }
+      }
+      if (ImGui::MenuItem("Delete", "Del", false, options.isDeleteEnabled && isTargetValid))
+      {
+        if (schema.element_erase(options.target))
+        {
+          clear();
+          result.isDirty = true;
+          result.isStructureChanged = true;
+        }
+      }
+      if (options.isClearVisible && ImGui::MenuItem("Clear", nullptr, false, options.isClearEnabled))
+      {
+        if (children_clear(schema, options.parent, options.type))
+        {
+          clear();
+          result.isDirty = true;
+          result.isStructureChanged = true;
+        }
+      }
+      ImGui::Separator();
+      if (ImGui::MenuItem("Cut", "Ctrl+X", false, options.isDeleteEnabled && isTargetValid))
+      {
+        if (element_cut(clipboard, schema, options.target))
+        {
+          clear();
+          result.isDirty = true;
+          result.isStructureChanged = true;
+        }
+      }
+      if (ImGui::MenuItem("Copy", "Ctrl+C", false, isTargetValid)) element_copy(clipboard, schema, options.target);
+      if (ImGui::MenuItem("Paste", "Ctrl+V", false, options.isPasteEnabled && element_index_is_valid(schema, pasteParent)))
+      {
+        selected = element_paste(clipboard, schema, pasteParent, pasteAfter, options.type);
+        if (selected >= 0)
+        {
+          select(selected);
+          result.isDirty = true;
+          result.isStructureChanged = true;
+        }
+      }
+      return result;
+    }
+
+    template <typename Select, typename Clear>
+    ElementActionResult element_shortcuts_apply(util::Clipboard& clipboard, Schema& schema,
+                                                const ElementActionOptions& options, int& selected, Select select,
+                                                Clear clear)
+    {
+      ElementActionResult result{};
+      auto isTargetValid = element_index_is_valid(schema, options.target);
+      auto pasteParent = options.pasteParent >= 0 ? options.pasteParent : options.parent;
+      auto pasteAfter = options.pasteAfter >= -1 ? options.pasteAfter : options.after;
+
+      if (options.isDeleteEnabled && isTargetValid && shortcut_is_pressed(ImGuiKey_Delete))
+      {
+        if (schema.element_erase(options.target))
+        {
+          clear();
+          result.isDirty = true;
+          result.isStructureChanged = true;
+        }
+      }
+      else if (options.isDeleteEnabled && isTargetValid && shortcut_is_pressed(ImGuiMod_Ctrl | ImGuiKey_X))
+      {
+        if (element_cut(clipboard, schema, options.target))
+        {
+          clear();
+          result.isDirty = true;
+          result.isStructureChanged = true;
+        }
+      }
+      else if (isTargetValid && shortcut_is_pressed(ImGuiMod_Ctrl | ImGuiKey_C))
+      {
+        element_copy(clipboard, schema, options.target);
+      }
+      else if (options.isPasteEnabled && element_index_is_valid(schema, pasteParent) &&
+               shortcut_is_pressed(ImGuiMod_Ctrl | ImGuiKey_V))
+      {
+        selected = element_paste(clipboard, schema, pasteParent, pasteAfter, options.type);
+        if (selected >= 0)
+        {
+          select(selected);
+          result.isDirty = true;
+          result.isStructureChanged = true;
+        }
+      }
+      return result;
+    }
+
+    inline void attribute_order_ensure(Element& element, std::string_view symbol)
+    {
+      if (std::ranges::find(element.attributeOrder, symbol) == element.attributeOrder.end())
+        element.attributeOrder.emplace_back(symbol);
+    }
+
+    inline void attribute_order_remove(Element& element, std::string_view symbol)
+    {
+      element.attributeOrder.erase(std::remove(element.attributeOrder.begin(), element.attributeOrder.end(), symbol),
+                                   element.attributeOrder.end());
+    }
+
+    template <typename Insert, typename Clear, typename Paste>
+    bool attribute_context_menu_draw(util::Clipboard& clipboard, const std::string& assignments, Insert insert,
+                                     Clear clear, Paste paste)
+    {
+      auto isDirty = insert();
+      ImGui::BeginDisabled();
+      ImGui::MenuItem("Duplicate");
+      if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled))
+        ImGui::SetTooltip("XML attributes are unique by name.");
+      ImGui::EndDisabled();
+      if (ImGui::MenuItem("Delete", "Del"))
+      {
+        clear();
+        isDirty = true;
+      }
+      ImGui::Separator();
+      if (ImGui::MenuItem("Cut", "Ctrl+X"))
+      {
+        clipboard.cut(assignments);
+        clear();
+        isDirty = true;
+      }
+      if (ImGui::MenuItem("Copy", "Ctrl+C")) clipboard.copy(assignments);
+      if (ImGui::MenuItem("Paste", "Ctrl+V") && paste(clipboard.get())) isDirty = true;
+      return isDirty;
+    }
+  }
+
+  class Editor
+  {
+  public:
+    struct LoadedSchema
+    {
+      const std::filesystem::path* path{};
+      const resource::xml::Schema* schema{};
+    };
+
+    enum Mode
+    {
+      ENTRY,
+      POOL
+    };
+
+    enum PendingSetting
+    {
+      PENDING_NONE,
+      PENDING_SOUND
+    };
+
+    Mode mode{ENTRY};
+    int selectedEntry{-1};
+    int selectedPool{-1};
+    std::vector<int> selectedEntries{};
+    std::vector<int> selectedPools{};
+    int selectedPoolEntry{-1};
+    int selectedChoice{-1};
+    int selectedEffect{-1};
+    int scrollToEntry{-1};
+    int scrollToPool{-1};
+    int scrollToPoolEntry{-1};
+    int scrollToChoice{-1};
+    int scrollToEffect{-1};
+    int textSelectionStart{};
+    int textSelectionEnd{};
+    int textSelectionStartByte{};
+    int textSelectionEndByte{};
+    int previewIndex{};
+    int pendingSoundEffect{-1};
+    bool isPlaying{};
+    bool previewNeedsAnimationPlay{};
+    bool isPreviewBlipQueued{};
+    float previewTimer{};
+    int previewBaseDelay{4};
+    int previewDelay{4};
+    int delay{4};
+    int blipDelay{4};
+    glm::vec3 nameColor{0.498039f, 0.498039f, 0.498039f};
+    glm::vec3 textColor{1.0f, 1.0f, 1.0f};
+    PendingSetting pendingSetting{PENDING_NONE};
+    resource::xml::Character previewCharacter{};
+    util::Clipboard clipboard{};
+    resource::Font previewFont{};
+    const resource::Audio* previewBlip{};
+    Entity previewEntity{};
+    util::imgui::widget::EntityCanvas previewCanvas{};
+    std::string animationAppendID{};
+    std::string fontPath{};
+    std::string fontRootPath{};
+    std::filesystem::path fontSchemaPath{};
+    std::string previewAnm2Path{};
+    std::string previewAnimation{};
+    std::string previewAnimationRequest{};
+
+    bool update(Resources&, resource::xml::Schema&, const std::filesystem::path&, util::Dialog&,
+                std::span<const LoadedSchema>);
+  };
+}
diff --git a/src/developer/window.cpp b/src/developer/window.cpp
new file mode 100644
index 0000000..5d5a5d2
--- /dev/null
+++ b/src/developer/window.cpp
@@ -0,0 +1,536 @@
+#include "window.hpp"
+
+#include <algorithm>
+#include <format>
+#include <fstream>
+#include <vector>
+
+#include <imgui.h>
+#include <imgui_internal.h>
+
+#include "../log.hpp"
+#include "../util/physfs.hpp"
+#include "../util/preferences.hpp"
+
+namespace game::developer
+{
+  bool gIsDocumentUndoMenuRequested{};
+  bool gIsDocumentRedoMenuRequested{};
+
+  namespace window_detail
+  {
+    constexpr auto RECENT_FILES_MAX = 10;
+    constexpr auto CENTER_RATIO = 0.5f;
+    constexpr auto DEVELOPER_WINDOW_SIZE_RATIO = 0.75f;
+    constexpr auto INFO_SCHEMA_TABLE_COLUMNS = 4;
+    constexpr auto DEVELOPER_WINDOW_FLAGS = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoSavedSettings;
+    constexpr auto EDITOR_CHILD_FLAGS = ImGuiWindowFlags_MenuBar;
+    constexpr auto DIALOGUE_SCHEMA_FILENAME = "dialogue.xml";
+
+    using Schema = resource::xml::Schema;
+    using Element = Schema::Element;
+
+#define GAME_DEVELOPER_SCHEMA_FILES(X)                                                                                \
+  X(CHARACTER, "character.xml", "Character", Element::CHARACTER)                                                      \
+  X(DIALOGUE, "dialogue.xml", "Dialogue", Element::DIALOGUE)                                                         \
+  X(ITEMS, "items.xml", "Items", Element::ITEM_SCHEMA)                                                               \
+  X(AREAS, "areas.xml", "Areas", Element::AREAS)                                                                     \
+  X(MENU, "menu.xml", "Menu", Element::MENU)                                                                         \
+  X(CURSOR, "cursor.xml", "Cursor", Element::CURSOR)                                                                 \
+  X(PARTICLES, "particles.xml", "Particles", Element::PARTICLES)                                                     \
+  X(STRINGS, "strings.xml", "Strings", Element::STRINGS)
+
+    struct SchemaInfo
+    {
+      std::string_view filename{};
+      std::string_view label{};
+      Element::Type type{};
+    };
+
+    constexpr SchemaInfo SCHEMA_INFOS[]{
+#define GAME_DEVELOPER_SCHEMA_INFO(SYMBOL, FILENAME, LABEL, TYPE) {.filename = FILENAME, .label = LABEL, .type = TYPE},
+        GAME_DEVELOPER_SCHEMA_FILES(GAME_DEVELOPER_SCHEMA_INFO)
+#undef GAME_DEVELOPER_SCHEMA_INFO
+    };
+
+    std::filesystem::path path_normalized_get(const std::filesystem::path& path)
+    {
+      std::error_code error{};
+      auto normalized = std::filesystem::weakly_canonical(path, error);
+      if (!error) return normalized;
+      return std::filesystem::absolute(path, error).lexically_normal();
+    }
+
+    std::filesystem::path recent_file_path_get() { return util::preferences::path() / "recent.txt"; }
+
+    std::string document_path_label_get(const std::filesystem::path& path)
+    {
+      auto filename = path.filename();
+      if (filename.empty()) return path.string();
+      return filename.string();
+    }
+
+    bool shortcut_is_pressed(ImGuiKeyChord chord)
+    {
+      auto& io = ImGui::GetIO();
+      return !io.WantTextInput && !ImGui::IsAnyItemActive() &&
+             ImGui::Shortcut(chord, ImGuiInputFlags_RouteGlobal | ImGuiInputFlags_RouteOverFocused);
+    }
+
+#undef GAME_DEVELOPER_SCHEMA_FILES
+  }
+
+  using namespace window_detail;
+
+  void Window::recent_files_load()
+  {
+    if (isRecentFilesLoaded) return;
+    isRecentFilesLoaded = true;
+    recentFiles.clear();
+
+    std::ifstream file(recent_file_path_get());
+    if (!file.is_open()) return;
+
+    std::string line{};
+    while (std::getline(file, line))
+    {
+      if (line.empty()) continue;
+      recentFiles.push_back(path_normalized_get(line));
+      if ((int)recentFiles.size() >= RECENT_FILES_MAX) break;
+    }
+  }
+
+  void Window::recent_files_save()
+  {
+    auto recentPath = recent_file_path_get();
+    if (recentPath.empty()) return;
+    std::error_code error{};
+    if (!recentPath.parent_path().empty()) std::filesystem::create_directories(recentPath.parent_path(), error);
+
+    std::ofstream file(recentPath, std::ios::trunc);
+    if (!file.is_open())
+    {
+      logger.warning(std::format("Failed to write {}", recentPath.string()));
+      return;
+    }
+
+    for (auto& path : recentFiles)
+      file << path.string() << '\n';
+  }
+
+  void Window::recent_file_push(const std::filesystem::path& path)
+  {
+    recent_files_load();
+    auto normalized = path_normalized_get(path);
+    if (normalized.empty()) return;
+
+    std::erase_if(recentFiles, [&](const auto& recent) { return recent == normalized; });
+    recentFiles.insert(recentFiles.begin(), normalized);
+    if ((int)recentFiles.size() > RECENT_FILES_MAX) recentFiles.resize(RECENT_FILES_MAX);
+    recent_files_save();
+  }
+
+  Document Window::document_load(const std::filesystem::path& path)
+  {
+    Document document{};
+    document.path = path_normalized_get(path);
+
+    for (auto& info : SCHEMA_INFOS)
+    {
+      Document::SchemaFile schemaFile{};
+      schemaFile.filename = info.filename;
+      schemaFile.label = info.label;
+      schemaFile.type = info.type;
+      schemaFile.path = document.path / schemaFile.filename;
+      schemaFile.isExists = std::filesystem::is_regular_file(schemaFile.path);
+      if (schemaFile.isExists)
+      {
+        schemaFile.isValid = schemaFile.schema.load(schemaFile.path);
+        auto* root = schemaFile.schema.root();
+        if (!root || root->type != schemaFile.type) schemaFile.isValid = false;
+      }
+      document.schemas.emplace_back(std::move(schemaFile));
+    }
+
+    return document;
+  }
+
+  void Window::folder_open(const std::filesystem::path& path)
+  {
+    auto normalizedPath = path_normalized_get(path);
+    std::error_code error{};
+    if (!std::filesystem::is_directory(normalizedPath, error))
+    {
+      logger.warning(std::format("Ignored {}", normalizedPath.string()));
+      return;
+    }
+
+    auto it = std::ranges::find_if(documents, [&](const auto& document) { return document.path == normalizedPath; });
+    if (it != documents.end())
+    {
+      *it = document_load(normalizedPath);
+      it->history_clear();
+      it->isDirty = false;
+      selectedDocument = (int)std::distance(documents.begin(), it);
+      logger.info(std::format("Opened {}", normalizedPath.string()));
+      toasts.push(std::format("Opened {}", normalizedPath.string()));
+    }
+    else
+    {
+      documents.push_back(document_load(normalizedPath));
+      selectedDocument = (int)documents.size() - 1;
+      logger.info(std::format("Opened {}", normalizedPath.string()));
+      toasts.push(std::format("Opened {}", normalizedPath.string()));
+    }
+    recent_file_push(normalizedPath);
+  }
+
+  void Window::save(int index)
+  {
+    if (index < 0 || index >= (int)documents.size()) return;
+    auto& document = documents[index];
+    auto* dialogue = document.dialogue_schema_get();
+    if (!dialogue || !dialogue->isExists)
+    {
+      toasts.push("No dialogue.xml to save");
+      return;
+    }
+
+    logger.info(std::format("Wrote to {}", dialogue->path.string()));
+    dialogue->schema.serialize(dialogue->path);
+    documents[index].isDirty = false;
+    toasts.push(std::format("Wrote to {}", dialogue->path.string()));
+    recent_file_push(documents[index].path);
+  }
+
+  void Window::export_to(int index, const std::filesystem::path& path)
+  {
+    if (index < 0 || index >= (int)documents.size()) return;
+    if (documents[index].isDirty) save(index);
+    auto destination = path_normalized_get(path);
+    if (util::physfs::archive_write(documents[index].path, destination))
+      toasts.push(std::format("Exported {}", destination.string()));
+    else
+      toasts.push(std::format("Failed to export {}", destination.string()));
+  }
+
+  void Window::close(int index)
+  {
+    if (index < 0 || index >= (int)documents.size()) return;
+    auto label = document_path_label_get(documents[index].path);
+    documents.erase(documents.begin() + index);
+    selectedDocument = documents.empty() ? 0 : std::clamp(index, 0, (int)documents.size() - 1);
+    toasts.push(std::format("Closed {}", label));
+  }
+
+  void Window::undo(int index)
+  {
+    if (index < 0 || index >= (int)documents.size()) return;
+    auto& document = documents[index];
+    if (!document.can_undo()) return;
+
+    auto message = document.undo_apply();
+    if (!message.empty()) toasts.push(std::format("Undo: {}", message));
+  }
+
+  void Window::redo(int index)
+  {
+    if (index < 0 || index >= (int)documents.size()) return;
+    auto& document = documents[index];
+    if (!document.can_redo()) return;
+
+    auto message = document.redo_apply();
+    if (!message.empty()) toasts.push(std::format("Redo: {}", message));
+  }
+
+  void Window::dropped_file_open(const char* path)
+  {
+    if (!path) return;
+    folder_open(path);
+  }
+
+  void Window::editor_shortcuts_update()
+  {
+    if (shortcut_is_pressed(ImGuiMod_Ctrl | ImGuiKey_O)) dialog.folder_open(util::Dialog::SCHEMA_FOLDER_OPEN);
+    if (shortcut_is_pressed(ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_Z))
+      redo(selectedDocument);
+    else if (shortcut_is_pressed(ImGuiMod_Ctrl | ImGuiKey_Z))
+      undo(selectedDocument);
+    if (shortcut_is_pressed(ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_S))
+      dialog.file_save(util::Dialog::DOCUMENT_EXPORT);
+    else if (shortcut_is_pressed(ImGuiMod_Ctrl | ImGuiKey_S))
+      save(selectedDocument);
+    if (shortcut_is_pressed(ImGuiMod_Ctrl | ImGuiKey_W)) close(selectedDocument);
+  }
+
+  void Window::dialog_selection_update()
+  {
+    if (dialog.is_selected(util::Dialog::SCHEMA_FOLDER_OPEN))
+    {
+      folder_open(dialog.path);
+      dialog.reset();
+    }
+    else if (dialog.is_selected(util::Dialog::DOCUMENT_EXPORT))
+    {
+      export_to(selectedDocument, dialog.path);
+      dialog.reset();
+    }
+  }
+
+  void Window::editor_menu_update()
+  {
+    if (!ImGui::BeginMenuBar()) return;
+
+    if (ImGui::BeginMenu("File"))
+    {
+      if (ImGui::MenuItem("Open Folder", "Ctrl+O")) dialog.folder_open(util::Dialog::SCHEMA_FOLDER_OPEN);
+      if (ImGui::BeginMenu("Open Recent", !recentFiles.empty()))
+      {
+        for (int recentIndex = 0; recentIndex < (int)recentFiles.size(); ++recentIndex)
+        {
+          ImGui::PushID(recentIndex);
+          auto label = recentFiles[recentIndex].string();
+          if (ImGui::MenuItem(label.c_str())) folder_open(recentFiles[recentIndex]);
+          ImGui::PopID();
+        }
+        ImGui::EndMenu();
+      }
+      if (ImGui::MenuItem("Save", "Ctrl+S", false, selectedDocument >= 0 && selectedDocument < (int)documents.size()))
+        save(selectedDocument);
+      if (ImGui::MenuItem("Export", "Ctrl+Shift+S", false,
+                          selectedDocument >= 0 && selectedDocument < (int)documents.size()))
+        dialog.file_save(util::Dialog::DOCUMENT_EXPORT);
+      if (ImGui::MenuItem("Close", "Ctrl+W", false, selectedDocument >= 0 && selectedDocument < (int)documents.size()))
+        close(selectedDocument);
+      ImGui::EndMenu();
+    }
+    if (ImGui::BeginMenu("Edit"))
+    {
+      auto isCanUndo =
+          selectedDocument >= 0 && selectedDocument < (int)documents.size() && documents[selectedDocument].can_undo();
+      auto isCanRedo =
+          selectedDocument >= 0 && selectedDocument < (int)documents.size() && documents[selectedDocument].can_redo();
+      if (ImGui::MenuItem("Undo", "Ctrl+Z", false, isCanUndo)) undo(selectedDocument);
+      if (ImGui::MenuItem("Redo", "Ctrl+Shift+Z", false, isCanRedo)) redo(selectedDocument);
+      ImGui::EndMenu();
+    }
+    ImGui::EndMenuBar();
+  }
+
+  void Window::editor_documents_update(Resources& resources)
+  {
+    if (documents.empty() || !ImGui::BeginTabBar("schemas", ImGuiTabBarFlags_Reorderable)) return;
+
+    auto closeRequest = -1;
+    for (int i = 0; i < (int)documents.size(); ++i)
+    {
+      ImGui::PushID(i);
+      auto label = document_path_label_get(documents[i].path) + (documents[i].isDirty ? " *" : "");
+      label += std::format("###{}", documents[i].path.string());
+
+      auto isOpen = true;
+      auto isTabOpen = ImGui::BeginTabItem(label.c_str(), &isOpen);
+      if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNormal))
+        ImGui::SetTooltip("%s", documents[i].path.string().c_str());
+
+      if (isTabOpen)
+      {
+        selectedDocument = i;
+        if (ImGui::BeginTabBar("##Document Tabs"))
+        {
+          if (ImGui::BeginTabItem("Info"))
+          {
+            document_info_update(documents[i]);
+            ImGui::EndTabItem();
+          }
+          if (ImGui::BeginTabItem("Dialogue"))
+          {
+            document_dialogue_update(resources, documents[i]);
+            ImGui::EndTabItem();
+          }
+          ImGui::EndTabBar();
+        }
+        ImGui::EndTabItem();
+      }
+      if (!isOpen) closeRequest = i;
+      ImGui::PopID();
+    }
+    ImGui::EndTabBar();
+    if (closeRequest >= 0) close(closeRequest);
+  }
+
+  void Window::document_info_update(const Document& document)
+  {
+    if (!ImGui::BeginTable("##Schema Info", INFO_SCHEMA_TABLE_COLUMNS, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg))
+      return;
+
+    ImGui::TableSetupColumn("Schema");
+    ImGui::TableSetupColumn("File");
+    ImGui::TableSetupColumn("Exists");
+    ImGui::TableSetupColumn("Valid");
+    ImGui::TableHeadersRow();
+
+    for (auto& schema : document.schemas)
+    {
+      ImGui::TableNextRow();
+      ImGui::TableNextColumn();
+      ImGui::TextUnformatted(schema.label.c_str());
+      ImGui::TableNextColumn();
+      ImGui::TextUnformatted(schema.filename.c_str());
+      ImGui::TableNextColumn();
+      ImGui::TextUnformatted(schema.isExists ? "Yes" : "No");
+      ImGui::TableNextColumn();
+      ImGui::TextUnformatted(schema.isValid ? "Yes" : "No");
+    }
+
+    ImGui::EndTable();
+  }
+
+  void Window::document_dialogue_update(Resources& resources, Document& document)
+  {
+    auto* dialogue = document.dialogue_schema_get();
+    if (!dialogue || !dialogue->isExists)
+    {
+      ImGui::TextUnformatted("No dialogue.xml found.");
+      return;
+    }
+    if (!dialogue->isValid)
+    {
+      ImGui::TextUnformatted("dialogue.xml is not valid.");
+      return;
+    }
+
+    if (ImGui::IsAnyItemActive()) document.edit_snapshot_begin();
+    std::vector<Editor::LoadedSchema> loadedSchemas{};
+    for (auto& schemaFile : document.schemas)
+    {
+      if (!schemaFile.isValid) continue;
+      loadedSchemas.push_back({.path = &schemaFile.path, .schema = &schemaFile.schema});
+    }
+
+    auto before = dialogue->schema;
+    if (document.editor.update(resources, dialogue->schema, dialogue->path, dialog, loadedSchemas))
+    {
+      before = document.edit_snapshot_take_or(std::move(before));
+      if (before.element_serialize(0) != dialogue->schema.element_serialize(0))
+      {
+        auto message = Document::change_message_get(before, dialogue->schema);
+        document.snapshot_push(std::move(before), message);
+      }
+      else
+        document.isDirty = true;
+    }
+    else if (!ImGui::IsAnyItemActive())
+      document.edit_snapshot_clear();
+  }
+
+  void Window::editor_update(Resources& resources)
+  {
+    if (ImGui::BeginChild("##Editor", ImVec2(), ImGuiChildFlags_None, EDITOR_CHILD_FLAGS))
+    {
+      editor_menu_update();
+
+      if (ImGui::BeginPopupContextWindow("developer-context",
+                                         ImGuiPopupFlags_MouseButtonRight | ImGuiPopupFlags_NoOpenOverItems))
+      {
+        auto isCanUndo =
+            selectedDocument >= 0 && selectedDocument < (int)documents.size() && documents[selectedDocument].can_undo();
+        auto isCanRedo =
+            selectedDocument >= 0 && selectedDocument < (int)documents.size() && documents[selectedDocument].can_redo();
+        if (ImGui::MenuItem("Undo", "Ctrl+Z", false, isCanUndo)) isContextUndoRequested = true;
+        if (ImGui::MenuItem("Redo", "Ctrl+Shift+Z", false, isCanRedo)) isContextRedoRequested = true;
+        ImGui::EndPopup();
+      }
+
+      editor_documents_update(resources);
+    }
+    ImGui::EndChild();
+  }
+
+  void Window::update(Resources& resources, SDL_Window* window, state::Play* play)
+  {
+    dialog.window_set(window);
+
+    if (!resources.isDeveloper && shortcut_is_pressed(ImGuiKey_GraveAccent))
+    {
+      resources.isDeveloper = true;
+      if (selectedTab == Tab::CONSOLE) console.focus_request();
+    }
+
+    if (!resources.isDeveloper)
+    {
+      isDeveloperOpen = false;
+      return;
+    }
+
+    recent_files_load();
+
+    auto* viewport = ImGui::GetMainViewport();
+    auto windowSize =
+        ImVec2(viewport->WorkSize.x * DEVELOPER_WINDOW_SIZE_RATIO, viewport->WorkSize.y * DEVELOPER_WINDOW_SIZE_RATIO);
+    auto windowPosition = ImVec2(viewport->WorkPos.x + (viewport->WorkSize.x * CENTER_RATIO),
+                                 viewport->WorkPos.y + (viewport->WorkSize.y * CENTER_RATIO));
+    ImGui::SetNextWindowPos(windowPosition, ImGuiCond_Appearing, ImVec2(CENTER_RATIO, CENTER_RATIO));
+    ImGui::SetNextWindowSize(windowSize, ImGuiCond_Appearing);
+
+    if (!isDeveloperOpen)
+    {
+      ImGui::SetNextWindowFocus();
+      if (selectedTab == Tab::CONSOLE) console.focus_request();
+    }
+    isDeveloperOpen = true;
+
+    isContextUndoRequested = false;
+    isContextRedoRequested = false;
+    action = {};
+    console.action = {};
+    gIsDocumentUndoMenuRequested = false;
+    gIsDocumentRedoMenuRequested = false;
+
+    if (selectedTab == Tab::EDITOR) editor_shortcuts_update();
+    dialog_selection_update();
+
+    auto gameStyle = ImGui::GetStyle();
+    ImGui::GetStyle() = ImGuiStyle{};
+    ImGui::StyleColorsDark();
+    ImGui::PushFont(resources.font.get(), resource::Font::SMALL);
+
+    if (ImGui::Begin("Developer", &resources.isDeveloper, DEVELOPER_WINDOW_FLAGS))
+    {
+      auto isFocused = ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows);
+      if (isFocused && (shortcut_is_pressed(ImGuiKey_GraveAccent) || shortcut_is_pressed(ImGuiKey_Escape)))
+        resources.isDeveloper = false;
+
+      if (ImGui::BeginTabBar("##Developer Tabs"))
+      {
+        auto isWasConsole = selectedTab == Tab::CONSOLE;
+        if (ImGui::BeginTabItem("Console"))
+        {
+          selectedTab = Tab::CONSOLE;
+          if (!isWasConsole) console.focus_request();
+          console.update(resources, play);
+          ImGui::EndTabItem();
+        }
+        if (ImGui::BeginTabItem("Editor"))
+        {
+          selectedTab = Tab::EDITOR;
+          editor_update(resources);
+          ImGui::EndTabItem();
+        }
+        ImGui::EndTabBar();
+      }
+    }
+    ImGui::End();
+
+    if (gIsDocumentUndoMenuRequested) isContextUndoRequested = true;
+    if (gIsDocumentRedoMenuRequested) isContextRedoRequested = true;
+    action = console.action;
+    if (isContextUndoRequested) undo(selectedDocument);
+    if (isContextRedoRequested) redo(selectedDocument);
+
+    toasts.update();
+
+    ImGui::PopFont();
+    ImGui::GetStyle() = gameStyle;
+  }
+}
diff --git a/src/developer/window.hpp b/src/developer/window.hpp
new file mode 100644
index 0000000..d4c53ef
--- /dev/null
+++ b/src/developer/window.hpp
@@ -0,0 +1,64 @@
+#pragma once
+
+#include <filesystem>
+#include <string>
+#include <vector>
+
+#include "../resources.hpp"
+#include "../state/play/toasts.hpp"
+#include "../util/dialog.hpp"
+#include "console.hpp"
+#include "document.hpp"
+
+namespace game::state
+{
+  class Play;
+}
+
+namespace game::developer
+{
+  class Window
+  {
+    enum class Tab
+    {
+      CONSOLE,
+      EDITOR
+    };
+
+    std::vector<Document> documents{};
+    Console console{};
+    util::Dialog dialog{};
+    state::play::Toasts toasts{};
+    std::vector<std::filesystem::path> recentFiles{};
+    Tab selectedTab{Tab::CONSOLE};
+    int selectedDocument{};
+    bool isContextUndoRequested{};
+    bool isContextRedoRequested{};
+    bool isRecentFilesLoaded{};
+    bool isDeveloperOpen{};
+
+    void folder_open(const std::filesystem::path&);
+    void save(int index);
+    void export_to(int index, const std::filesystem::path&);
+    void close(int index);
+    void undo(int index);
+    void redo(int index);
+    Document document_load(const std::filesystem::path&);
+    void editor_update(Resources&);
+    void editor_shortcuts_update();
+    void editor_menu_update();
+    void editor_documents_update(Resources&);
+    void document_info_update(const Document&);
+    void document_dialogue_update(Resources&, Document&);
+    void dialog_selection_update();
+    void recent_files_load();
+    void recent_files_save();
+    void recent_file_push(const std::filesystem::path&);
+
+  public:
+    Console::Action action{};
+
+    void dropped_file_open(const char*);
+    void update(Resources&, SDL_Window*, state::Play*);
+  };
+}
diff --git a/src/entity.cpp b/src/entity.cpp
new file mode 100644
index 0000000..b7359df
--- /dev/null
+++ b/src/entity.cpp
@@ -0,0 +1,982 @@
+#include "entity.hpp"
+
+#include "util/imgui.hpp"
+#include "util/map.hpp"
+#include "util/math.hpp"
+#include "util/unordered_map.hpp"
+#include "util/vector.hpp"
+
+#include <algorithm>
+#include <cmath>
+
+#include <glm/glm.hpp>
+
+#include "log.hpp"
+
+#include <imgui.h>
+
+namespace game
+{
+  constexpr auto CHARACTER_VALUE_ZERO = 0.0f;
+
+  float value_clamp(float value, float minimum, float maximum)
+  {
+    auto rangeMin = std::min(minimum, maximum);
+    auto rangeMax = std::max(minimum, maximum);
+    if (!std::isfinite(value)) return rangeMin;
+    return std::clamp(value, rangeMin, rangeMax);
+  }
+
+  int value_clamp(int value, int minimum, int maximum)
+  {
+    auto rangeMin = std::min(minimum, maximum);
+    auto rangeMax = std::max(minimum, maximum);
+    return std::clamp(value, rangeMin, rangeMax);
+  }
+
+  Entity::Override::Override(int _id, Entity::Anm2::Type _type, Entity::Override::Mode _mode,
+                             Entity::FrameOptional _frame, std::optional<float> _time,
+                             Entity::Override::Function _function, float _cycles)
+      : id(_id), type(_type), mode(_mode), frame(_frame), time(_time), function(_function), cycles(_cycles)
+  {
+    frameBase = _frame;
+    timeStart = _time;
+  }
+
+  Entity::Entity(const Entity&) = default;
+  Entity::Entity(Entity&&) noexcept = default;
+  Entity& Entity::operator=(const Entity&) = default;
+  Entity& Entity::operator=(Entity&&) noexcept = default;
+
+  Entity::Entity(Entity::Anm2 _anm2, glm::vec2 _position, Mode playMode, float startAtTime, int startAnimationIndex)
+  {
+    anm2_set(_anm2);
+    position = _position;
+    this->mode = playMode;
+    this->startTime = startAtTime;
+    if (startAnimationIndex != -1)
+      play({.index = startAnimationIndex, .time = startAtTime, .mode = playMode});
+    else
+      play({.index = defaultAnimationID, .time = startAtTime, .mode = playMode});
+    pending_animation_apply();
+  }
+
+  void Entity::anm2_set(const resource::xml::Anm2& anm2)
+  {
+    fps = anm2.fps;
+    spritesheets = anm2.spritesheets;
+    layers = anm2.layers;
+    nulls = anm2.nulls;
+    events = anm2.events;
+    sounds = anm2.sounds;
+    layerMap = anm2.layerMap;
+    nullMap = anm2.nullMap;
+    eventMap = anm2.eventMap;
+    defaultAnimation = anm2.defaultAnimation;
+    defaultAnimationID = anm2.defaultAnimationID;
+    animations = anm2.animations;
+    animationMap = anm2.animationMap;
+    animationMapReverse = anm2.animationMapReverse;
+    invalidAnimations.clear();
+    path = anm2.path;
+    isValid = anm2.isValid;
+    flags = anm2.flags;
+  }
+
+  Entity::Anm2::Animation* Entity::animation_get(int index)
+  {
+    if (index == -1) index = animationIndex;
+    if (animationMapReverse.contains(index)) return &animations[index];
+    return nullptr;
+  }
+
+  Entity::Anm2::Animation* Entity::animation_get(const std::string& name)
+  {
+    if (animationMap.contains(name)) return &animations[animationMap[name]];
+    return nullptr;
+  }
+
+  bool Entity::is_playing(const std::string& name)
+  {
+    if (name.empty())
+      return state == PLAYING;
+    else
+      return state == PLAYING && animationMap[name] == animationIndex;
+  }
+
+  int Entity::animation_index_get(const std::string& name)
+  {
+    if (animationMap.contains(name)) return animationMap[name];
+    return -1;
+  }
+
+  Entity::Anm2::Item* Entity::item_get(Entity::Anm2::Type type, int id, int checkAnimationIndex)
+  {
+    if (checkAnimationIndex == -1) checkAnimationIndex = this->animationIndex;
+    if (auto animation = animation_get(checkAnimationIndex))
+    {
+      switch (type)
+      {
+        case Entity::Anm2::ROOT:
+          return &animation->rootAnimation;
+          break;
+        case Entity::Anm2::LAYER:
+          return util::unordered_map::find(animation->layerAnimations, id);
+        case Entity::Anm2::NULL_:
+          return util::map::find(animation->nullAnimations, id);
+          break;
+        case Entity::Anm2::TRIGGER:
+          return &animation->triggers;
+        default:
+          return nullptr;
+      }
+    }
+
+    return nullptr;
+  }
+
+  Entity::Anm2::Frame Entity::frame_generate(Entity::Anm2::Item& item, float frameTime, Entity::Anm2::Type type, int id)
+  {
+    auto override_handle = [&](Entity::Anm2::Frame& overrideFrame, Entity::Anm2::Type overrideType, int overrideID)
+    {
+      auto vec2_set = [](glm::vec2& destination, const Entity::Anm2::FrameOptional::Vec2& source)
+      {
+        if (source.x.has_value()) destination.x = *source.x;
+        if (source.y.has_value()) destination.y = *source.y;
+      };
+      auto vec2_add = [](glm::vec2& destination, const Entity::Anm2::FrameOptional::Vec2& source)
+      {
+        if (source.x.has_value()) destination.x += *source.x;
+        if (source.y.has_value()) destination.y += *source.y;
+      };
+      auto vec3_set = [](glm::vec3& destination, const Entity::Anm2::FrameOptional::Vec3& source)
+      {
+        if (source.x.has_value()) destination.x = *source.x;
+        if (source.y.has_value()) destination.y = *source.y;
+        if (source.z.has_value()) destination.z = *source.z;
+      };
+      auto vec4_set = [](glm::vec4& destination, const Entity::Anm2::FrameOptional::Vec4& source)
+      {
+        if (source.x.has_value()) destination.x = *source.x;
+        if (source.y.has_value()) destination.y = *source.y;
+        if (source.z.has_value()) destination.z = *source.z;
+        if (source.w.has_value()) destination.w = *source.w;
+      };
+
+      for (auto& override : overrides)
+      {
+        if (override.type != overrideType) continue;
+        if (override.id != overrideID) continue;
+
+        auto& source = override.frame;
+
+        switch (override.mode)
+        {
+          case Override::SET:
+            vec2_set(overrideFrame.position, source.position);
+            vec2_set(overrideFrame.pivot, source.pivot);
+            vec2_set(overrideFrame.size, source.size);
+            vec2_set(overrideFrame.scale, source.scale);
+            vec2_set(overrideFrame.crop, source.crop);
+            if (source.rotation.has_value()) overrideFrame.rotation = *source.rotation;
+            vec4_set(overrideFrame.tint, source.tint);
+            vec3_set(overrideFrame.colorOffset, source.colorOffset);
+            if (source.isInterpolated.has_value())
+            {
+              overrideFrame.isInterpolated = *source.isInterpolated;
+              overrideFrame.interpolation =
+                  *source.isInterpolated ? Entity::Anm2::Frame::LINEAR : Entity::Anm2::Frame::INTERPOLATION_NONE;
+            }
+            if (source.interpolation.has_value())
+            {
+              overrideFrame.interpolation = *source.interpolation;
+              overrideFrame.isInterpolated = overrideFrame.interpolation != Entity::Anm2::Frame::INTERPOLATION_NONE;
+            }
+            if (source.isVisible.has_value()) overrideFrame.isVisible = *source.isVisible;
+            break;
+          case Override::ADD:
+            vec2_add(overrideFrame.scale, source.scale);
+            break;
+          default:
+            break;
+        }
+      }
+    };
+
+    return Entity::Anm2::frame_generate(item, frameTime, type, id, override_handle);
+  }
+
+  void Entity::animation_start(int index, const AnimationRequest& request)
+  {
+    if (!util::vector::in_bounds(animations, index)) return;
+    if (request.mode != PLAY_FORCE && index == animationIndex) return;
+
+    this->playedEventID = -1;
+    this->playedTriggers.clear();
+
+    this->mode = request.mode;
+    this->speedMultiplier = request.speedMultiplier;
+    this->animationIndex = index;
+    this->time = request.time;
+    if (request.mode != SET) state = PLAYING;
+  }
+
+  void Entity::play(AnimationRequest request)
+  {
+    if (entityType == CHARACTER && isStageUp) return;
+    if (!request.animation.empty()) request.animation += request.appendID;
+    pendingAnimation = std::move(request);
+  }
+
+  bool Entity::is_animation_request() const { return !pendingAnimation.empty() || !nextAnimation.empty(); }
+
+  void Entity::pending_animation_apply()
+  {
+    if (pendingAnimation.empty()) return;
+    animation_request_apply(pendingAnimation);
+    pendingAnimation = AnimationRequest{};
+  }
+
+  bool Entity::animation_request_apply(AnimationRequest& request)
+  {
+    if (request.empty()) return true;
+
+    auto index = request.index;
+    if (index == -1)
+    {
+      if (!animationMap.contains(request.animation))
+      {
+        if (!invalidAnimations.contains(request.animation))
+        {
+          logger.error(std::string("Animation \"" + request.animation + "\" does not exist! Unable to play!"));
+          invalidAnimations.insert(request.animation);
+        }
+        return true;
+      }
+      index = animationMap.at(request.animation);
+    }
+
+    auto* currentAnm2Animation = animation_get();
+    auto isCurrentLoop = currentAnm2Animation && currentAnm2Animation->isLoop;
+
+    switch (request.transition)
+    {
+      case Transition::AFTER_CURRENT:
+        if (state != STOPPED && !isCurrentLoop)
+        {
+          nextAnimation = request;
+          return true;
+        }
+        break;
+      case Transition::IF_IDLE:
+        if (state != STOPPED && !isCurrentLoop) return true;
+        break;
+      case Transition::NOW:
+      default:
+        break;
+    }
+
+    auto canInterrupt = request.interrupt == Interrupt::ALWAYS || currentAnimation.interrupt != Interrupt::NEVER;
+    if (!canInterrupt) return true;
+
+    if (state == STOPPED || index != animationIndex || request.mode == PLAY_FORCE)
+    {
+      animation_start(index, request);
+      currentAnimation = request;
+    }
+
+    return true;
+  }
+
+  void Entity::animation_update()
+  {
+    if (state == Entity::STOPPED)
+    {
+      if (!nextAnimation.empty())
+      {
+        auto request = nextAnimation;
+        request.transition = Transition::NOW;
+        nextAnimation = AnimationRequest{};
+        animation_request_apply(request);
+      }
+      currentAnimation = AnimationRequest{};
+    }
+
+    if (auto animation = animation_get(); animation && animation->isLoop) currentAnimation = AnimationRequest{};
+
+    auto animation = animation_get();
+    if (!animation || animation->frameNum == 1 || mode == SET || state == STOPPED) return;
+
+    playedEventID = -1;
+
+    for (auto& trigger : animation->triggers.frames)
+    {
+      if (!playedTriggers.contains(trigger.atFrame) && time >= trigger.atFrame)
+      {
+        if (!trigger.soundIDs.empty())
+        {
+          auto id = trigger.soundIDs[(int)util::math::random_max((float)trigger.soundIDs.size())];
+          if (auto sound = util::map::find(sounds, id)) sound->audio.play();
+        }
+        playedTriggers.insert((int)trigger.atFrame);
+        playedEventID = trigger.eventID;
+      }
+    }
+
+    auto increment = (fps / UPDATE_RATE) * speedMultiplier;
+    time += increment;
+
+    if (time >= animation->frameNum)
+    {
+      if (animation->isLoop)
+        time = 0.0f;
+      else
+        state = STOPPED;
+
+      playedTriggers.clear();
+    }
+
+    for (int i = 0; i < (int)overrides.size();)
+    {
+      auto& override_ = overrides[i];
+
+      if (override_.function) override_.function(override_);
+
+      if (override_.time.has_value())
+      {
+        *override_.time -= 1.0f;
+        if (*override_.time <= 0.0f)
+        {
+          overrides.erase(overrides.begin() + i);
+          continue;
+        }
+      }
+      i++;
+    }
+  }
+
+  glm::vec4 Entity::null_frame_rect(int nullID, int checkAnimationIndex, float checkTime)
+  {
+    constexpr glm::ivec2 CORNERS[4] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
+
+    if (nullID == -1) return glm::vec4(NAN);
+    auto item = item_get(Entity::Anm2::NULL_, nullID, checkAnimationIndex);
+    if (!item) return glm::vec4(NAN);
+
+    if (checkAnimationIndex == -1) checkAnimationIndex = animationIndex;
+    if (checkTime < 0.0f) checkTime = time;
+
+    auto animation = animation_get(checkAnimationIndex);
+    if (!animation) return glm::vec4(NAN);
+
+    auto root = frame_generate(animation->rootAnimation, checkTime, Entity::Anm2::ROOT);
+
+    auto frame = frame_generate(*item, checkTime, Entity::Anm2::NULL_, nullID);
+    if (!frame.isVisible) return glm::vec4(NAN);
+
+    auto rootModel = util::math::quad_model_no_size_get(root.position + position, root.pivot,
+                                                        util::math::to_unit(root.scale), root.rotation);
+    auto frameModel =
+        util::math::quad_model_get(frame.scale, frame.position, frame.scale * 0.5f, glm::vec2(1.0f), frame.rotation);
+    auto model = rootModel * frameModel;
+
+    float minX = std::numeric_limits<float>::infinity();
+    float minY = std::numeric_limits<float>::infinity();
+    float maxX = -std::numeric_limits<float>::infinity();
+    float maxY = -std::numeric_limits<float>::infinity();
+
+    for (auto& corner : CORNERS)
+    {
+      glm::vec4 world = model * glm::vec4(corner, 0.0f, 1.0f);
+      minX = std::min(minX, world.x);
+      minY = std::min(minY, world.y);
+      maxX = std::max(maxX, world.x);
+      maxY = std::max(maxY, world.y);
+    }
+
+    return glm::vec4(minX, minY, maxX - minX, maxY - minY);
+  }
+
+  void Entity::render(resource::Shader& textureShader, resource::Shader& rectShader, Canvas& canvas)
+  {
+    if (!isVisible) return;
+
+    auto animation = animation_get();
+    if (!animation) return;
+
+    auto root = frame_generate(animation->rootAnimation, time, Entity::Anm2::ROOT);
+
+    auto rootModel = util::math::quad_model_no_size_get(root.position + position, root.pivot,
+                                                        util::math::to_unit(root.scale), root.rotation);
+
+    for (auto& i : animation->layerOrder)
+    {
+      auto& layerAnimation = animation->layerAnimations[i];
+      if (!layerAnimation.isVisible) continue;
+
+      auto layer = util::map::find(layers, i);
+      if (!layer) continue;
+
+      auto spritesheet = util::map::find(spritesheets, layer->spritesheetID);
+      if (!spritesheet) continue;
+
+      auto frame = frame_generate(layerAnimation, time, Entity::Anm2::LAYER, i);
+      if (!frame.isVisible) continue;
+
+      auto model = util::math::quad_model_get(frame.size, frame.position, frame.pivot, util::math::to_unit(frame.scale),
+                                              frame.rotation);
+      model = rootModel * model;
+
+      auto& texture = spritesheet->texture;
+      if (!texture.is_valid()) return;
+
+      auto tint = frame.tint * root.tint;
+      auto colorOffset = frame.colorOffset + root.colorOffset;
+
+      auto inset = glm::vec2(0);
+      auto uvMin = (frame.crop + inset) / glm::vec2(texture.size);
+      auto uvMax = (frame.crop + frame.size - inset) / glm::vec2(texture.size);
+      auto uvVertices = util::math::uv_vertices_get(uvMin, uvMax);
+
+      canvas.texture_render(textureShader, texture.id, model, tint, colorOffset, uvVertices.data());
+    }
+
+    if (isShowNulls)
+    {
+      for (int i = 0; i < (int)animation->nullAnimations.size(); i++)
+      {
+        auto& nullAnimation = animation->nullAnimations[i];
+        if (!nullAnimation.isVisible) continue;
+
+        auto frame = frame_generate(nullAnimation, time, Entity::Anm2::NULL_, i);
+        if (!frame.isVisible) continue;
+
+        auto model = util::math::quad_model_get(frame.scale, frame.position, frame.scale * 0.5f, glm::vec2(1.0f),
+                                                frame.rotation);
+        model = rootModel * model;
+
+        canvas.rect_render(rectShader, model);
+      }
+    }
+  }
+
+  glm::vec4 Entity::rect()
+  {
+    constexpr glm::ivec2 CORNERS[4] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
+
+    auto animation = animation_get();
+
+    float minX = std::numeric_limits<float>::infinity();
+    float minY = std::numeric_limits<float>::infinity();
+    float maxX = -std::numeric_limits<float>::infinity();
+    float maxY = -std::numeric_limits<float>::infinity();
+    bool any = false;
+
+    if (!animation) return glm::vec4(-NAN);
+
+    for (float t = 0.0f; t < (float)animation->frameNum; t += 1.0f)
+    {
+      glm::mat4 transform(1.0f);
+
+      auto root = frame_generate(animation->rootAnimation, t, Entity::Anm2::ROOT);
+      transform *= util::math::quad_model_no_size_get(root.position + position, root.pivot,
+                                                      util::math::to_unit(root.scale), root.rotation);
+
+      for (auto& [id, layerAnimation] : animation->layerAnimations)
+      {
+        if (!layerAnimation.isVisible) continue;
+
+        auto frame = frame_generate(layerAnimation, t, Entity::Anm2::LAYER, id);
+
+        if (frame.size == glm::vec2() || !frame.isVisible) continue;
+
+        auto layerTransform = transform * util::math::quad_model_get(frame.size, frame.position, frame.pivot,
+                                                                     util::math::to_unit(frame.scale), frame.rotation);
+        for (auto& corner : CORNERS)
+        {
+          glm::vec4 world = layerTransform * glm::vec4(corner, 0.0f, 1.0f);
+          minX = std::min(minX, world.x);
+          minY = std::min(minY, world.y);
+          maxX = std::max(maxX, world.x);
+          maxY = std::max(maxY, world.y);
+          any = true;
+        }
+      }
+    }
+
+    if (!any) return glm::vec4(-NAN);
+    return {minX, minY, maxX - minX, maxY - minY};
+  }
+
+  bool Entity::is_animation_finished()
+  {
+    if (auto animation = animation_get())
+    {
+      if (animation->isLoop) return true;
+      if (time > animation->frameNum) return true;
+    }
+    return false;
+  }
+
+  void Entity::consume_played_event() { playedEventID = -1; }
+
+  void Entity::update()
+  {
+    switch (entityType)
+    {
+      case CHARACTER:
+        character_update();
+        break;
+      case CURSOR:
+        if (cursorState == DEFAULT && pendingAnimation.empty())
+          pendingAnimation = {.animation = defaultAnimation, .transition = Transition::IF_IDLE};
+        pending_animation_apply();
+        animation_update();
+        cursorState = DEFAULT;
+        position = positionOverride.value_or(util::imgui::to_vec2(ImGui::GetMousePos()));
+        positionOverride.reset();
+        break;
+      case AUTOCURSOR:
+        if (cursorState == DEFAULT && pendingAnimation.empty())
+          pendingAnimation = {.animation = defaultAnimation, .transition = Transition::IF_IDLE};
+        pending_animation_apply();
+        animation_update();
+        cursorState = DEFAULT;
+        positionOverride.reset();
+        break;
+      case ITEM:
+        pending_animation_apply();
+        animation_update();
+        position += velocity;
+        *overrides[rotationOverrideID].frame.rotation += angularVelocity;
+        break;
+      case ACTOR:
+      default:
+        pending_animation_apply();
+        animation_update();
+        break;
+    }
+
+    if (isRemoveOnAnimationEnd && state == STOPPED) isToBeDeleted = true;
+  }
+
+  Entity::Entity(resource::xml::Character& _data, glm::ivec2 _position)
+      : Entity(_data.root()->anm2Entry.anm2, _position)
+  {
+    entityType = CHARACTER;
+    data = _data;
+    auto* root = data.root();
+
+    auto* saveRoot = data.save.root();
+    auto* saveCharacter = saveRoot && saveRoot->type == resource::xml::Schema::Element::SAVE
+                              ? data.save.child_get(*saveRoot, resource::xml::Schema::Element::CHARACTER)
+                              : nullptr;
+
+    capacity = saveCharacter ? saveCharacter->capacityCalories : (double)root->capacityCalories;
+    weight = saveCharacter ? saveCharacter->weightKilograms : (double)root->weightKilograms;
+    digestionRate = saveCharacter ? saveCharacter->digestionRate : (double)root->digestionRate;
+    eatSpeed = saveCharacter ? saveCharacter->eatSpeedMultiplier : (double)root->eatSpeedMultiplier;
+
+    calories = saveCharacter ? saveCharacter->calories : 0;
+
+    isDigesting = saveCharacter ? saveCharacter->isDigesting : false;
+    digestionProgress = saveCharacter ? saveCharacter->digestionProgress : 0;
+    digestionTimer = saveCharacter ? saveCharacter->digestionTimer : 0;
+    character_values_clamp();
+
+    auto* overridesRoot = data.overrides_root();
+    auto* talk = overridesRoot ? data.child_get(*overridesRoot, resource::xml::Schema::Element::TALK) : nullptr;
+    auto talkSource = talk ? data.layer_id_get(talk->layerSource) : -1;
+    auto talkDestination = talk ? data.layer_id_get(talk->layerDestination) : -1;
+    talkOverrideID =
+        util::vector::push_index(overrides, Entity::Override(talkDestination, Entity::Anm2::LAYER, Override::SET));
+    for (auto& animation : animations)
+    {
+      if (!animation.layerAnimations.contains(talkSource))
+        animationTalkDurations.emplace_back(-1);
+      else
+        animationTalkDurations.emplace_back(Entity::Anm2::item_length(&animation.layerAnimations.at(talkSource)));
+    }
+
+    auto* blink = overridesRoot ? data.child_get(*overridesRoot, resource::xml::Schema::Element::BLINK) : nullptr;
+    auto blinkSource = blink ? data.layer_id_get(blink->layerSource) : -1;
+    auto blinkDestination = blink ? data.layer_id_get(blink->layerDestination) : -1;
+    blinkOverrideID =
+        util::vector::push_index(overrides, Entity::Override(blinkDestination, Entity::Anm2::LAYER, Override::SET));
+    for (auto& animation : animations)
+    {
+      if (!animation.layerAnimations.contains(blinkSource))
+        animationBlinkDurations.emplace_back(-1);
+      else
+        animationBlinkDurations.emplace_back(Entity::Anm2::item_length(&animation.layerAnimations.at(blinkSource)));
+    }
+
+    auto expandAreas = data.expand_areas_get();
+    for (int i = 0; i < (int)expandAreas.size(); i++)
+    {
+      auto* expandArea = expandAreas[i];
+      expandAreaOverrideLayerIDs[i] = util::vector::push_index(
+          overrides, Entity::Override(data.layer_id_get(expandArea->layer), Entity::Anm2::LAYER, Override::ADD));
+      expandAreaOverrideNullIDs[i] = util::vector::push_index(
+          overrides, Entity::Override(data.null_id_get(expandArea->null), Entity::Anm2::NULL_, Override::ADD));
+    }
+
+    auto interactAreas = data.interact_areas_get();
+    for (int i = 0; i < (int)interactAreas.size(); i++)
+    {
+      auto* interactArea = interactAreas[i];
+      auto layerID = data.layer_id_get(interactArea->layer);
+      if (layerID != -1) interactAreaOverrides[i] = Entity::Override(layerID, Entity::Anm2::LAYER, Override::ADD);
+    }
+
+    stage = stage_get();
+    expand_areas_apply();
+  }
+
+  float Entity::weight_get(util::measurement::System system)
+  {
+    return system == util::measurement::IMPERIAL ? weight * (double)util::measurement::KG_TO_LB : weight;
+  }
+
+  int Entity::stage_from_weight_get(float checkWeight) const
+  {
+    auto stages = data.stages_get();
+    if (stages.empty()) return 0;
+    if (checkWeight <= data.root()->weightKilograms) return 0;
+
+    for (int i = 0; i < (int)stages.size(); i++)
+      if (checkWeight < stages[i]->thresholdKilograms) return i;
+
+    return stage_max_get();
+  }
+
+  int Entity::stage_get() const { return stage_from_weight_get(weight); }
+
+  int Entity::stage_max_get() const { return (int)data.stages_get().size(); }
+
+  int Entity::stage_count_get() const { return stage_max_get() + 1; }
+
+  float Entity::stage_threshold_get(int stageIndex, util::measurement::System system) const
+  {
+    if (stageIndex == -1) stageIndex = this->stage;
+
+    double threshold = data.root()->weightKilograms;
+
+    auto stages = data.stages_get();
+    if (!stages.empty())
+    {
+      if (stageIndex <= 0)
+        threshold = data.root()->weightKilograms;
+      else if (stageIndex >= stage_max_get())
+        threshold = stages.back()->thresholdKilograms;
+      else
+        threshold = stages[stageIndex - 1]->thresholdKilograms;
+    }
+
+    return system == util::measurement::IMPERIAL ? threshold * (double)util::measurement::KG_TO_LB : threshold;
+  }
+
+  float Entity::stage_threshold_next_get(util::measurement::System system) const
+  {
+    return stage_threshold_get(stage + 1, system);
+  }
+
+  float Entity::stage_progress_get()
+  {
+    auto currentStage = stage_get();
+    if (currentStage >= stage_max_get()) return 1.0;
+
+    auto currentThreshold = stage_threshold_get(currentStage);
+    auto nextThreshold = stage_threshold_get(currentStage + 1);
+    if (nextThreshold <= currentThreshold) return 1.0;
+
+    return (weight - currentThreshold) / (nextThreshold - currentThreshold);
+  }
+
+  float Entity::digestion_rate_get() { return digestionRate * UPDATE_RATE; }
+
+  float Entity::max_capacity() const { return capacity * data.root()->capacityOverstuffedMultiplier; }
+  bool Entity::is_over_capacity() const { return calories > capacity; }
+  bool Entity::is_max_capacity() const { return calories >= max_capacity(); }
+  float Entity::capacity_percent_get() const
+  {
+    auto capacityMax = max_capacity();
+    return capacityMax > CHARACTER_VALUE_ZERO ? calories / capacityMax : CHARACTER_VALUE_ZERO;
+  }
+
+  void Entity::character_values_clamp()
+  {
+    if (entityType != CHARACTER) return;
+    auto* root = data.root();
+    if (!root) return;
+
+    weight = value_clamp(weight, root->weightKilograms, root->weightMaxKilograms);
+    capacity = value_clamp(capacity, root->capacityMinCalories, root->capacityMaxCalories);
+    digestionRate = value_clamp(digestionRate, root->digestionRateMin, root->digestionRateMax);
+    eatSpeed = value_clamp(eatSpeed, root->eatSpeedMinMultiplier, root->eatSpeedMaxMultiplier);
+    calories = value_clamp(calories, CHARACTER_VALUE_ZERO, std::max(CHARACTER_VALUE_ZERO, max_capacity()));
+    digestionProgress = value_clamp(digestionProgress, CHARACTER_VALUE_ZERO, DIGESTION_MAX);
+    digestionTimer = value_clamp(digestionTimer, 0, std::max(0, root->digestionTimerMax));
+    totalCaloriesConsumed = std::max(CHARACTER_VALUE_ZERO, totalCaloriesConsumed);
+    totalFoodItemsEaten = std::max(0, totalFoodItemsEaten);
+    stage = value_clamp(stage_get(), 0, stage_max_get());
+  }
+
+  std::string Entity::animation_append_id_get() const
+  {
+    if (stage <= 0) return {};
+    auto stageIndex = stage - 1;
+    auto stages = data.stages_get();
+    if (stageIndex < 0 || stageIndex >= (int)stages.size()) return {};
+    return stages[stageIndex]->animationAppendID;
+  }
+
+  void Entity::expand_areas_apply()
+  {
+    auto stageProgress = stage_progress_get();
+    auto digestionTimerMax = std::max(1, data.root()->digestionTimerMax);
+    auto capacityProgress =
+        isDigesting ? capacity_percent_get() * (double)digestionTimer / digestionTimerMax : capacity_percent_get();
+
+    auto expandAreas = data.expand_areas_get();
+    for (int i = 0; i < (int)expandAreas.size(); i++)
+    {
+      auto* expandArea = expandAreas[i];
+      auto& overrideLayer = overrides[expandAreaOverrideLayerIDs[i]];
+      auto& overrideNull = overrides[expandAreaOverrideNullIDs[i]];
+
+      auto stageScaleAdd = ((double)expandArea->scaleAdd * stageProgress) * 0.5;
+      auto capacityScaleAdd = ((double)expandArea->scaleAdd * capacityProgress) * 0.5;
+
+      auto scaleAdd =
+          glm::clamp(glm::vec2(), glm::vec2(stageScaleAdd + capacityScaleAdd), glm::vec2(expandArea->scaleAdd));
+      overrideLayer.frame.scale = scaleAdd;
+      overrideNull.frame.scale = scaleAdd;
+    }
+  }
+
+  void Entity::character_update()
+  {
+    character_values_clamp();
+
+    isJustStageUp = false;
+    isJustStageFinal = false;
+    isJustDigested = false;
+
+    if (state == Entity::STOPPED)
+    {
+      if (isStageUp)
+      {
+        if (stage >= (int)data.stages_get().size())
+          isJustStageFinal = true;
+        else
+          isJustStageUp = true;
+
+        isStageUp = false;
+      }
+
+      if (nextAnimation.empty() && !isTalking)
+        play({.animation = idle_animation_get(), .appendID = animation_append_id_get()});
+    }
+
+    pending_animation_apply();
+    animation_update();
+
+    if (isDigesting)
+    {
+      digestionTimer--;
+
+      if (digestionTimer <= 0)
+      {
+        auto increment = calories * data.root()->caloriesToKilogram;
+        auto nextWeight = glm::clamp(weight + increment, data.root()->weightKilograms, data.root()->weightMaxKilograms);
+
+        if (is_over_capacity())
+        {
+          auto capacityMaxCalorieDifference = (calories - capacity);
+          auto overCapacityPercent = capacityMaxCalorieDifference / (max_capacity() - capacity);
+          auto capacityIncrement = (double)((overCapacityPercent * data.root()->capacityIfOverStuffedOnDigestBonus) *
+                                            capacityMaxCalorieDifference);
+          capacity = glm::clamp(capacity + capacityIncrement, (double)data.root()->capacityMinCalories,
+                                (double)data.root()->capacityMaxCalories);
+        }
+
+        totalCaloriesConsumed += calories;
+        calories = 0;
+
+        if (auto nextStage = stage_from_weight_get((double)nextWeight); nextStage > stage_from_weight_get(weight))
+        {
+          nextAnimation = AnimationRequest{};
+          currentAnimation = AnimationRequest{};
+          play({.animation = data.animation_get(resource::xml::Schema::Element::STAGE_UP),
+                .appendID = animation_append_id_get(),
+                .interrupt = Interrupt::NEVER});
+          stage = nextStage;
+          isStageUp = true;
+        }
+        else
+          isJustDigested = true;
+
+        weight = (double)nextWeight;
+
+        isDigesting = false;
+        digestionTimer = data.root()->digestionTimerMax;
+        digestionProgress = 0;
+      }
+    }
+    else
+    {
+      if (calories > 0) digestionProgress += digestionRate;
+      if (digestionProgress >= DIGESTION_MAX)
+      {
+        isDigesting = true;
+        digestionTimer = data.root()->digestionTimerMax;
+        data.schema.root()->soundDigest.play();
+      }
+    }
+
+    character_values_clamp();
+
+    if (util::math::random_percent_roll(util::math::to_percent(
+            data.root()->gurgleChance * (capacity_percent_get() * data.root()->gurgleChanceFromCapacityMultiplier))))
+      data.schema.root()->soundGurgle.play();
+
+    stage = stage_get();
+    expand_areas_apply();
+
+    auto& talkOverride = overrides[talkOverrideID];
+
+    if (isTalking)
+    {
+      auto talk_reset = [&]()
+      {
+        isTalking = false;
+        talkTimer = 0.0;
+        talkOverride.frame = FrameOptional();
+      };
+
+      auto* talk = data.overrides_root() ? data.child_get(*data.overrides_root(), resource::xml::Schema::Element::TALK)
+                                         : nullptr;
+      auto id = talk ? data.layer_id_get(talk->layerSource) : -1;
+      auto& layerAnimations = animation_get()->layerAnimations;
+
+      if (layerAnimations.contains(id) && animationTalkDurations.at(animationIndex) > -1)
+      {
+        auto& layerAnimation = layerAnimations.at(id);
+
+        if (!layerAnimation.frames.empty())
+        {
+          auto frame = frame_generate(layerAnimation, talkTimer, Entity::Anm2::LAYER, id);
+
+          talkOverride.frame.crop = frame.crop;
+          talkOverride.frame.size = frame.size;
+          talkOverride.frame.pivot = frame.pivot;
+
+          talkTimer += 0.5f;
+
+          if (talkTimer > animationTalkDurations.at(animationIndex)) talkTimer = 0.0;
+        }
+        else
+          talk_reset();
+      }
+      else
+        talk_reset();
+    }
+    else
+      talkOverride.frame = {};
+
+    auto& blinkOverride = overrides[blinkOverrideID];
+
+    if (auto blinkDuration = animationBlinkDurations[animationIndex]; blinkDuration != 1)
+    {
+      if (util::math::random_percent_roll(data.root()->blinkChance)) isBlinking = true;
+
+      if (isBlinking)
+      {
+        auto blink_reset = [&]()
+        {
+          isBlinking = false;
+          blinkTimer = 0.0;
+          blinkOverride.frame = FrameOptional();
+        };
+
+        auto* blink = data.overrides_root()
+                          ? data.child_get(*data.overrides_root(), resource::xml::Schema::Element::BLINK)
+                          : nullptr;
+        auto id = blink ? data.layer_id_get(blink->layerSource) : -1;
+        auto& layerAnimations = animation_get()->layerAnimations;
+
+        if (layerAnimations.contains(id))
+        {
+          auto& layerAnimation = layerAnimations.at(id);
+
+          if (!layerAnimation.frames.empty())
+          {
+            auto frame = frame_generate(layerAnimation, blinkTimer, Entity::Anm2::LAYER, id);
+
+            blinkOverride.frame.crop = frame.crop;
+            blinkOverride.frame.size = frame.size;
+            blinkOverride.frame.pivot = frame.pivot;
+
+            blinkTimer += 0.5f;
+
+            if (blinkTimer >= blinkDuration) blink_reset();
+          }
+          else
+            blink_reset();
+        }
+        else
+          blink_reset();
+      }
+    }
+  }
+
+  std::string Entity::idle_animation_get() const
+  {
+    if (isStageUp) return {};
+    auto idle = data.animation_get(resource::xml::Schema::Element::IDLE);
+    auto idleFull = data.animation_get(resource::xml::Schema::Element::IDLE_FULL);
+    return is_over_capacity() && !idleFull.empty() ? idleFull : idle;
+  }
+
+  void Entity::spritesheet_set(SpritesheetType type)
+  {
+    switch (type)
+    {
+      case NORMAL:
+        if (auto* alternate = data.alternate_spritesheet())
+          spritesheets.at(alternate->id).texture = data.root()->anm2Entry.anm2.spritesheets.at(alternate->id).texture;
+        break;
+      case ALTERNATE:
+        if (auto* alternate = data.alternate_spritesheet())
+          spritesheets.at(alternate->id).texture = alternate->textureEntry.texture;
+        break;
+      default:
+        break;
+    }
+
+    spritesheetType = type;
+  }
+
+  Entity::Entity(Entity::Anm2 _anm2, glm::ivec2 _position, int _schemaID, int _durability, int _animationIndex,
+                 glm::vec2 _velocity, float _rotation)
+  {
+    anm2_set(_anm2);
+    position = _position;
+    schemaID = _schemaID;
+    durability = _durability;
+    velocity = _velocity;
+    entityType = ITEM;
+    mode = SET;
+    startTime = 0.0f;
+    if (_animationIndex != -1)
+      play({.index = _animationIndex, .mode = SET});
+    else
+      play({.index = defaultAnimationID, .mode = SET});
+    pending_animation_apply();
+
+    rotationOverrideID = util::vector::push_index(
+        overrides, Override(-1, Entity::Anm2::ROOT, Override::SET, Entity::Anm2::FrameOptional{.rotation = _rotation}));
+  }
+
+}
diff --git a/src/entity.hpp b/src/entity.hpp
new file mode 100644
index 0000000..e6aaf99
--- /dev/null
+++ b/src/entity.hpp
@@ -0,0 +1,251 @@
+#pragma once
+
+#include <unordered_set>
+
+#include "render/canvas.hpp"
+#include "resource/character.hpp"
+#include "util/measurement.hpp"
+
+namespace game
+{
+  enum EntityType
+  {
+    ACTOR,
+    CHARACTER,
+    CURSOR,
+    AUTOCURSOR,
+    ITEM,
+    PARTICLE
+  };
+
+  class Entity
+  {
+  public:
+    using Anm2 = resource::xml::Anm2;
+    using FrameOptional = Anm2::FrameOptional;
+
+    static constexpr auto UPDATE_RATE = 60.0f;
+    static constexpr auto DIGESTION_MAX = 100.0f;
+
+    enum Mode
+    {
+      PLAY,
+      PLAY_FORCE,
+      SET,
+    };
+
+    enum State
+    {
+      STOPPED,
+      PLAYING
+    };
+
+    enum class Transition
+    {
+      NOW,
+      AFTER_CURRENT,
+      IF_IDLE
+    };
+
+    enum class Interrupt
+    {
+      IF_ALLOWED,
+      ALWAYS,
+      NEVER
+    };
+
+    enum CursorState
+    {
+      DEFAULT,
+      HOVER,
+      ACTION
+    };
+
+    enum SpritesheetType
+    {
+      NORMAL,
+      ALTERNATE
+    };
+
+    class Override
+    {
+    public:
+      enum Mode
+      {
+        SET,
+        ADD
+      };
+
+      using Function = void (*)(Override&);
+
+      int id{-1};
+      Anm2::Type type{Anm2::NONE};
+      Mode mode{SET};
+      FrameOptional frame{};
+      std::optional<float> time{};
+      Function function{nullptr};
+
+      FrameOptional frameBase{};
+      std::optional<float> timeStart{};
+
+      float cycles{};
+
+      Override() = default;
+      Override(int, Anm2::Type, Mode, FrameOptional = {}, std::optional<float> = std::nullopt, Function = nullptr,
+               float = 0);
+    };
+
+    struct AnimationRequest
+    {
+      std::string animation{};
+      std::string appendID{};
+      int index{-1};
+      float time{};
+      float speedMultiplier{1.0f};
+      Mode mode{PLAY};
+      Transition transition{Transition::NOW};
+      Interrupt interrupt{Interrupt::IF_ALLOWED};
+
+      inline bool empty() const { return animation.empty() && index == -1; };
+    };
+
+    EntityType entityType{ACTOR};
+
+    int fps{30};
+    std::map<int, Anm2::Spritesheet> spritesheets{};
+    std::map<int, Anm2::Layer> layers{};
+    std::map<int, Anm2::Null> nulls{};
+    std::map<int, Anm2::Event> events{};
+    std::map<int, Anm2::Sound> sounds{};
+    std::unordered_map<std::string, int> layerMap{};
+    std::unordered_map<std::string, int> nullMap{};
+    std::unordered_map<std::string, int> eventMap{};
+    std::string defaultAnimation{};
+    int defaultAnimationID{-1};
+    std::vector<Anm2::Animation> animations{};
+    std::unordered_map<std::string, int> animationMap{};
+    std::unordered_map<int, std::string> animationMapReverse{};
+    std::unordered_set<std::string> invalidAnimations{};
+    std::string path{};
+    bool isValid{};
+    Anm2::Flags flags{};
+
+    State state{STOPPED};
+    Mode mode{PLAY};
+    glm::vec2 position{};
+    float time{};
+    bool isShowNulls{};
+    bool isVisible{true};
+    int animationIndex{-1};
+    int playedEventID{-1};
+    float startTime{};
+    float speedMultiplier{};
+    AnimationRequest pendingAnimation{};
+    AnimationRequest currentAnimation{};
+    AnimationRequest nextAnimation{};
+    std::unordered_set<int> playedTriggers{};
+    std::vector<Override> overrides{};
+
+    resource::xml::Character data;
+    float weight{};
+    int stage{0};
+    float calories{};
+    float capacity{};
+    float digestionProgress{};
+    float digestionRate{0.05f};
+    int digestionTimer{};
+    bool isDigesting{};
+    bool isJustDigested{};
+    float eatSpeed{1.0f};
+    float totalCaloriesConsumed{};
+    int totalFoodItemsEaten{};
+    int talkOverrideID{};
+    float talkTimer{};
+    bool isTalking{};
+    std::vector<int> animationTalkDurations{};
+    int blinkOverrideID{};
+    float blinkTimer{};
+    bool isBlinking{};
+    std::vector<int> animationBlinkDurations{};
+    bool isStageUp{};
+    bool isStageUpDuring{};
+    bool isJustStageUp{};
+    bool isJustStageFinal{};
+    SpritesheetType spritesheetType{};
+    std::map<int, Override> interactAreaOverrides{};
+    std::unordered_map<int, int> expandAreaOverrideLayerIDs{};
+    std::unordered_map<int, int> expandAreaOverrideNullIDs{};
+
+    CursorState cursorState{DEFAULT};
+    int interactTypeID{-1};
+    std::optional<glm::vec2> positionOverride{};
+
+    bool isToBeDeleted{};
+    bool isRemoveOnAnimationEnd{};
+    bool isHeld{};
+    int schemaID{};
+    int rotationOverrideID{};
+    int durability{};
+    glm::vec2 velocity{};
+    float angularVelocity{};
+    float phase{};
+    float magnetTime{};
+    bool isCollected{};
+    bool isMagnetized{};
+
+    Entity() = default;
+    Entity(const Entity&);
+    Entity(Entity&&) noexcept;
+    Entity& operator=(const Entity&);
+    Entity& operator=(Entity&&) noexcept;
+    Entity(resource::xml::Anm2, glm::vec2 position = {}, Mode = PLAY, float time = 0.0f, int animationIndex = -1);
+    Entity(resource::xml::Character&, glm::ivec2);
+    Entity(resource::xml::Anm2, glm::ivec2 position, int id, int durability = 0, int animationIndex = -1,
+           glm::vec2 velocity = {}, float rotation = 0.0f);
+
+    bool is_playing(const std::string& name = {});
+    glm::vec4 null_frame_rect(int = -1, int animationIndex = -1, float time = -1.0f);
+    glm::vec4 rect();
+    int animation_index_get(const std::string&);
+    resource::xml::Anm2::Animation* animation_get(const std::string&);
+    resource::xml::Anm2::Animation* animation_get(int = -1);
+    resource::xml::Anm2::Frame frame_generate(resource::xml::Anm2::Item&, float, resource::xml::Anm2::Type,
+                                              int id = -1);
+    resource::xml::Anm2::Item* item_get(resource::xml::Anm2::Type, int = -1, int = -1);
+    void consume_played_event();
+    void play(AnimationRequest);
+    bool is_animation_request() const;
+    bool is_animation_finished();
+    void render(resource::Shader& textureShader, resource::Shader& rectShader, Canvas&);
+
+    float weight_get(util::measurement::System = util::measurement::METRIC);
+    float digestion_rate_get();
+    float capacity_percent_get() const;
+    float max_capacity() const;
+    bool is_over_capacity() const;
+    bool is_max_capacity() const;
+    int stage_get() const;
+    int stage_from_weight_get(float weight) const;
+    int stage_max_get() const;
+    int stage_count_get() const;
+    float stage_progress_get();
+    float stage_threshold_get(int stage = -1, util::measurement::System = util::measurement::METRIC) const;
+    float stage_threshold_next_get(util::measurement::System = util::measurement::METRIC) const;
+    void expand_areas_apply();
+    void spritesheet_set(SpritesheetType);
+    std::string idle_animation_get() const;
+    std::string animation_append_id_get() const;
+
+    void update();
+
+  private:
+    void anm2_set(const resource::xml::Anm2&);
+    void animation_start(int, const AnimationRequest&);
+    bool animation_request_apply(AnimationRequest&);
+    void pending_animation_apply();
+    void animation_update();
+    void character_values_clamp();
+    void character_update();
+  };
+
+}
diff --git a/src/entity/actor.cpp b/src/entity/actor.cpp
deleted file mode 100644
index 7a34a64..0000000
--- a/src/entity/actor.cpp
+++ /dev/null
@@ -1,490 +0,0 @@
-#include "actor.hpp"
-
-#include "../util/map.hpp"
-#include "../util/math.hpp"
-#include "../util/unordered_map.hpp"
-#include "../util/vector.hpp"
-
-#include <cstddef>
-#include <glm/glm.hpp>
-
-#include "../log.hpp"
-
-#include <imgui.h>
-
-using namespace glm;
-using namespace game::util;
-using namespace game::resource::xml;
-
-namespace game::entity
-{
-  Actor::Override::Override(int _id, Anm2::Type _type, Actor::Override::Mode _mode, FrameOptional _frame,
-                            std::optional<float> _time, Actor::Override::Function _function, float _cycles)
-      : id(_id), type(_type), mode(_mode), frame(_frame), time(_time), function(_function), cycles(_cycles)
-  {
-    frameBase = _frame;
-    timeStart = _time;
-  }
-
-  Actor::Actor(const Actor&) = default;
-  Actor::Actor(Actor&&) noexcept = default;
-  Actor& Actor::operator=(const Actor&) = default;
-  Actor& Actor::operator=(Actor&&) noexcept = default;
-
-  Actor::Actor(Anm2 _anm2, vec2 _position, Mode playMode, float startAtTime, int startAnimationIndex)
-      : Anm2(_anm2), position(_position)
-  {
-    this->mode = playMode;
-    this->startTime = startAtTime;
-    if (startAnimationIndex != -1)
-      play(startAnimationIndex, playMode, startAtTime);
-    else
-      play_default_animation(playMode, startAtTime);
-  }
-
-  Anm2::Animation* Actor::animation_get(int index)
-  {
-    if (index == -1) index = animationIndex;
-    if (animationMapReverse.contains(index)) return &animations[index];
-    return nullptr;
-  }
-
-  Anm2::Animation* Actor::animation_get(const std::string& name)
-  {
-    if (animationMap.contains(name)) return &animations[animationMap[name]];
-    return nullptr;
-  }
-
-  bool Actor::is_playing(const std::string& name)
-  {
-    if (name.empty())
-      return state == PLAYING;
-    else
-      return state == PLAYING && animationMap[name] == animationIndex;
-  }
-
-  int Actor::animation_index_get(const std::string& name)
-  {
-    if (animationMap.contains(name)) return animationMap[name];
-    return -1;
-  }
-
-  Anm2::Item* Actor::item_get(Anm2::Type type, int id, int checkAnimationIndex)
-  {
-    if (checkAnimationIndex == -1) checkAnimationIndex = this->animationIndex;
-    if (auto animation = animation_get(checkAnimationIndex))
-    {
-      switch (type)
-      {
-        case Anm2::ROOT:
-          return &animation->rootAnimation;
-          break;
-        case Anm2::LAYER:
-          return unordered_map::find(animation->layerAnimations, id);
-        case Anm2::NULL_:
-          return map::find(animation->nullAnimations, id);
-          break;
-        case Anm2::TRIGGER:
-          return &animation->triggers;
-        default:
-          return nullptr;
-      }
-    }
-
-    return nullptr;
-  }
-
-  int Actor::item_length(Anm2::Item* item)
-  {
-    if (!item) return -1;
-
-    int duration{};
-    for (auto& frame : item->frames)
-      duration += frame.duration;
-    return duration;
-  }
-
-  Anm2::Frame Actor::frame_generate(Anm2::Item& item, float frameTime, Anm2::Type type, int id)
-  {
-    Anm2::Frame frame{};
-    frame.isVisible = false;
-
-    if (item.frames.empty()) return frame;
-
-    frameTime = frameTime < 0.0f ? 0.0f : frameTime;
-
-    Anm2::Frame* frameNext = nullptr;
-    Anm2::Frame frameNextCopy{};
-    int durationCurrent = 0;
-    int durationNext = 0;
-
-    for (int i = 0; i < (int)item.frames.size(); i++)
-    {
-      Anm2::Frame& checkFrame = item.frames[i];
-
-      frame = checkFrame;
-
-      durationNext += frame.duration;
-
-      if (frameTime >= durationCurrent && frameTime < durationNext)
-      {
-        if (i + 1 < (int)item.frames.size())
-        {
-          frameNext = &item.frames[i + 1];
-          frameNextCopy = *frameNext;
-        }
-        else
-          frameNext = nullptr;
-        break;
-      }
-
-      durationCurrent += frame.duration;
-    }
-
-    auto override_handle = [&](Anm2::Frame& overrideFrame)
-    {
-      auto vec2_set = [](glm::vec2& destination, const Anm2::FrameOptional::Vec2& source)
-      {
-        if (source.x.has_value()) destination.x = *source.x;
-        if (source.y.has_value()) destination.y = *source.y;
-      };
-      auto vec2_add = [](glm::vec2& destination, const Anm2::FrameOptional::Vec2& source)
-      {
-        if (source.x.has_value()) destination.x += *source.x;
-        if (source.y.has_value()) destination.y += *source.y;
-      };
-      auto vec3_set = [](glm::vec3& destination, const Anm2::FrameOptional::Vec3& source)
-      {
-        if (source.x.has_value()) destination.x = *source.x;
-        if (source.y.has_value()) destination.y = *source.y;
-        if (source.z.has_value()) destination.z = *source.z;
-      };
-      auto vec4_set = [](glm::vec4& destination, const Anm2::FrameOptional::Vec4& source)
-      {
-        if (source.x.has_value()) destination.x = *source.x;
-        if (source.y.has_value()) destination.y = *source.y;
-        if (source.z.has_value()) destination.z = *source.z;
-        if (source.w.has_value()) destination.w = *source.w;
-      };
-
-      for (auto& override : overrides)
-      {
-        if (override.type != type) continue;
-        if (override.id != id) continue;
-
-        auto& source = override.frame;
-
-        switch (override.mode)
-        {
-          case Override::SET:
-            vec2_set(overrideFrame.position, source.position);
-            vec2_set(overrideFrame.pivot, source.pivot);
-            vec2_set(overrideFrame.size, source.size);
-            vec2_set(overrideFrame.scale, source.scale);
-            vec2_set(overrideFrame.crop, source.crop);
-            if (source.rotation.has_value()) overrideFrame.rotation = *source.rotation;
-            vec4_set(overrideFrame.tint, source.tint);
-            vec3_set(overrideFrame.colorOffset, source.colorOffset);
-            if (source.isInterpolated.has_value()) overrideFrame.isInterpolated = *source.isInterpolated;
-            if (source.isVisible.has_value()) overrideFrame.isVisible = *source.isVisible;
-            break;
-          case Override::ADD:
-            vec2_add(overrideFrame.scale, source.scale);
-            break;
-          default:
-            break;
-        }
-      }
-    };
-
-    override_handle(frame);
-    if (frameNext) override_handle(frameNextCopy);
-
-    if (frame.isInterpolated && frameNext && frame.duration > 1)
-    {
-      auto interpolation = (frameTime - durationCurrent) / (durationNext - durationCurrent);
-
-      frame.rotation = glm::mix(frame.rotation, frameNextCopy.rotation, interpolation);
-      frame.position = glm::mix(frame.position, frameNextCopy.position, interpolation);
-      frame.scale = glm::mix(frame.scale, frameNextCopy.scale, interpolation);
-      frame.colorOffset = glm::mix(frame.colorOffset, frameNextCopy.colorOffset, interpolation);
-      frame.tint = glm::mix(frame.tint, frameNextCopy.tint, interpolation);
-    }
-
-    return frame;
-  }
-
-  void Actor::play(int index, Mode playMode, float startAtTime, float speedMultiplierValue)
-  {
-    if (!vector::in_bounds(animations, index)) return;
-    if (playMode != PLAY_FORCE && index == animationIndex) return;
-
-    this->playedEventID = -1;
-    this->playedTriggers.clear();
-
-    this->speedMultiplier = speedMultiplierValue;
-    this->animationIndex = index;
-    this->time = startAtTime;
-    if (playMode == PLAY) state = PLAYING;
-  }
-
-  void Actor::queue_play(QueuedPlay newQueuedPlay) { queuedPlay = newQueuedPlay; }
-  void Actor::queue_default_animation() { queue_play({defaultAnimation}); }
-
-  void Actor::play(const std::string& name, Mode playMode, float startAtTime, float speedMultiplierValue)
-  {
-    if (animationMap.contains(name))
-      play(animationMap.at(name), playMode, startAtTime, speedMultiplierValue);
-    else
-      logger.error(std::string("Animation \"" + name + "\" does not exist! Unable to play!"));
-  }
-
-  void Actor::play_default_animation(Mode playMode, float startAtTime, float speedMultiplierValue)
-  {
-    play(defaultAnimationID, playMode, startAtTime, speedMultiplierValue);
-  }
-
-  void Actor::tick()
-  {
-    if (state == Actor::STOPPED)
-    {
-      if (!nextQueuedPlay.empty())
-      {
-        queuedPlay = nextQueuedPlay;
-        queuedPlay.isPlayAfterAnimation = false;
-        nextQueuedPlay = QueuedPlay{};
-      }
-      currentQueuedPlay = QueuedPlay{};
-    }
-
-    if (auto animation = animation_get(); animation && animation->isLoop) currentQueuedPlay = QueuedPlay{};
-
-    if (!queuedPlay.empty())
-    {
-      if (!animationMap.contains(queuedPlay.animation))
-      {
-        logger.error(std::string("Animation \"" + queuedPlay.animation + "\" does not exist! Unable to play!"));
-        if (!defaultAnimation.empty()) queue_default_animation();
-      }
-      else
-      {
-        auto& index = animationMap.at(queuedPlay.animation);
-        if (queuedPlay.isPlayAfterAnimation)
-          nextQueuedPlay = queuedPlay;
-        else if ((state == STOPPED || index != animationIndex) && currentQueuedPlay.isInterruptible)
-        {
-          play(queuedPlay.animation, queuedPlay.mode, queuedPlay.time, queuedPlay.speedMultiplier);
-          currentQueuedPlay = queuedPlay;
-        }
-        queuedPlay = QueuedPlay{};
-      }
-    }
-
-    auto animation = animation_get();
-    if (!animation || animation->frameNum == 1 || mode == SET || state == STOPPED) return;
-
-    playedEventID = -1;
-
-    for (auto& trigger : animation->triggers.frames)
-    {
-      if (!playedTriggers.contains(trigger.atFrame) && time >= trigger.atFrame)
-      {
-        auto id = trigger.soundIDs[(int)math::random_max((float)trigger.soundIDs.size())];
-        if (auto sound = map::find(sounds, id)) sound->audio.play();
-        playedTriggers.insert((int)trigger.atFrame);
-        playedEventID = trigger.eventID;
-      }
-    }
-
-    auto increment = (fps / TICK_RATE) * speedMultiplier;
-    time += increment;
-
-    if (time >= animation->frameNum)
-    {
-      if (animation->isLoop)
-        time = 0.0f;
-      else
-        state = STOPPED;
-
-      playedTriggers.clear();
-    }
-
-    for (int i = 0; i < (int)overrides.size();)
-    {
-      auto& override_ = overrides[i];
-
-      if (override_.function) override_.function(override_);
-
-      if (override_.time.has_value())
-      {
-        *override_.time -= 1.0f;
-        if (*override_.time <= 0.0f)
-        {
-          overrides.erase(overrides.begin() + i);
-          continue;
-        }
-      }
-      i++;
-    }
-  }
-
-  glm::vec4 Actor::null_frame_rect(int nullID)
-  {
-    constexpr ivec2 CORNERS[4] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
-
-    if (nullID == -1) return glm::vec4(NAN);
-    auto item = item_get(Anm2::NULL_, nullID);
-    if (!item) return glm::vec4(NAN);
-
-    auto animation = animation_get();
-    if (!animation) return glm::vec4(NAN);
-
-    auto root = frame_generate(animation->rootAnimation, time, Anm2::ROOT);
-
-    auto frame = frame_generate(*item, time, Anm2::NULL_, nullID);
-    if (!frame.isVisible) return glm::vec4(NAN);
-
-    auto rootModel =
-        math::quad_model_no_size_get(root.position + position, root.pivot, math::to_unit(root.scale), root.rotation);
-    auto frameModel = math::quad_model_get(frame.scale, frame.position, frame.scale * 0.5f, vec2(1.0f), frame.rotation);
-    auto model = rootModel * frameModel;
-
-    float minX = std::numeric_limits<float>::infinity();
-    float minY = std::numeric_limits<float>::infinity();
-    float maxX = -std::numeric_limits<float>::infinity();
-    float maxY = -std::numeric_limits<float>::infinity();
-
-    for (auto& corner : CORNERS)
-    {
-      vec4 world = model * vec4(corner, 0.0f, 1.0f);
-      minX = std::min(minX, world.x);
-      minY = std::min(minY, world.y);
-      maxX = std::max(maxX, world.x);
-      maxY = std::max(maxY, world.y);
-    }
-
-    return glm::vec4(minX, minY, maxX - minX, maxY - minY);
-  }
-
-  void Actor::render(resource::Shader& textureShader, resource::Shader& rectShader, Canvas& canvas)
-  {
-    if (!isVisible) return;
-
-    auto animation = animation_get();
-    if (!animation) return;
-
-    auto root = frame_generate(animation->rootAnimation, time, Anm2::ROOT);
-
-    auto rootModel =
-        math::quad_model_no_size_get(root.position + position, root.pivot, math::to_unit(root.scale), root.rotation);
-
-    for (auto& i : animation->layerOrder)
-    {
-      auto& layerAnimation = animation->layerAnimations[i];
-      if (!layerAnimation.isVisible) continue;
-
-      auto layer = map::find(layers, i);
-      if (!layer) continue;
-
-      auto spritesheet = map::find(spritesheets, layer->spritesheetID);
-      if (!spritesheet) continue;
-
-      auto frame = frame_generate(layerAnimation, time, Anm2::LAYER, i);
-      if (!frame.isVisible) continue;
-
-      auto model =
-          math::quad_model_get(frame.size, frame.position, frame.pivot, math::to_unit(frame.scale), frame.rotation);
-      model = rootModel * model;
-
-      auto& texture = spritesheet->texture;
-      if (!texture.is_valid()) return;
-
-      auto tint = frame.tint * root.tint;
-      auto colorOffset = frame.colorOffset + root.colorOffset;
-
-      auto inset = vec2(0);
-      auto uvMin = (frame.crop + inset) / vec2(texture.size);
-      auto uvMax = (frame.crop + frame.size - inset) / vec2(texture.size);
-      auto uvVertices = math::uv_vertices_get(uvMin, uvMax);
-
-      canvas.texture_render(textureShader, texture.id, model, tint, colorOffset, uvVertices.data());
-    }
-
-    if (isShowNulls)
-    {
-      for (int i = 0; i < (int)animation->nullAnimations.size(); i++)
-      {
-        auto& nullAnimation = animation->nullAnimations[i];
-        if (!nullAnimation.isVisible) continue;
-
-        auto frame = frame_generate(nullAnimation, time, Anm2::NULL_, i);
-        if (!frame.isVisible) continue;
-
-        auto model = math::quad_model_get(frame.scale, frame.position, frame.scale * 0.5f, vec2(1.0f), frame.rotation);
-        model = rootModel * model;
-
-        canvas.rect_render(rectShader, model);
-      }
-    }
-  }
-
-  vec4 Actor::rect()
-  {
-    constexpr ivec2 CORNERS[4] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
-
-    auto animation = animation_get();
-
-    float minX = std::numeric_limits<float>::infinity();
-    float minY = std::numeric_limits<float>::infinity();
-    float maxX = -std::numeric_limits<float>::infinity();
-    float maxY = -std::numeric_limits<float>::infinity();
-    bool any = false;
-
-    if (!animation) return vec4(-NAN);
-
-    for (float t = 0.0f; t < (float)animation->frameNum; t += 1.0f)
-    {
-      mat4 transform(1.0f);
-
-      auto root = frame_generate(animation->rootAnimation, t, Anm2::ROOT);
-      transform *=
-          math::quad_model_no_size_get(root.position + position, root.pivot, math::to_unit(root.scale), root.rotation);
-
-      for (auto& [id, layerAnimation] : animation->layerAnimations)
-      {
-        if (!layerAnimation.isVisible) continue;
-
-        auto frame = frame_generate(layerAnimation, t, Anm2::LAYER, id);
-
-        if (frame.size == vec2() || !frame.isVisible) continue;
-
-        auto layerTransform = transform * math::quad_model_get(frame.size, frame.position, frame.pivot,
-                                                               math::to_unit(frame.scale), frame.rotation);
-        for (auto& corner : CORNERS)
-        {
-          vec4 world = layerTransform * vec4(corner, 0.0f, 1.0f);
-          minX = std::min(minX, world.x);
-          minY = std::min(minY, world.y);
-          maxX = std::max(maxX, world.x);
-          maxY = std::max(maxY, world.y);
-          any = true;
-        }
-      }
-    }
-
-    if (!any) return vec4(-NAN);
-    return {minX, minY, maxX - minX, maxY - minY};
-  }
-
-  bool Actor::is_animation_finished()
-  {
-    if (auto animation = animation_get())
-    {
-      if (animation->isLoop) return true;
-      if (time > animation->frameNum) return true;
-    }
-    return false;
-  }
-
-  void Actor::consume_played_event() { playedEventID = -1; }
-};
diff --git a/src/entity/actor.hpp b/src/entity/actor.hpp
deleted file mode 100644
index 9993270..0000000
--- a/src/entity/actor.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-#pragma once
-
-#include <unordered_set>
-
-#include "../render/canvas.hpp"
-#include "../resource/xml/anm2.hpp"
-
-namespace game::entity
-{
-  class Actor : public resource::xml::Anm2
-  {
-  public:
-    static constexpr auto TICK_RATE = 30.0f;
-
-    enum Mode
-    {
-      PLAY,
-      PLAY_FORCE,
-      SET,
-    };
-
-    enum State
-    {
-      STOPPED,
-      PLAYING
-    };
-
-    class Override
-    {
-    private:
-    public:
-      enum Mode
-      {
-        SET,
-        ADD
-      };
-
-      using Function = void (*)(Override&);
-
-      int id{-1};
-      Anm2::Type type{Anm2::NONE};
-      Mode mode{SET};
-      FrameOptional frame{};
-      std::optional<float> time{};
-      Function function{nullptr};
-
-      FrameOptional frameBase{};
-      std::optional<float> timeStart{};
-
-      float cycles{};
-
-      Override() = default;
-      Override(int, Anm2::Type, Mode, FrameOptional = {}, std::optional<float> = std::nullopt, Function = nullptr,
-               float = 0);
-    };
-
-    struct QueuedPlay
-    {
-      std::string animation{};
-      float time{};
-      float speedMultiplier{1.0f};
-      Mode mode{PLAY};
-      bool isInterruptible{true};
-      bool isPlayAfterAnimation{false};
-
-      inline bool empty() { return animation.empty(); };
-    };
-
-    State state{STOPPED};
-    Mode mode{PLAY};
-
-    glm::vec2 position{};
-    float time{};
-    bool isShowNulls{};
-    bool isVisible{true};
-    int animationIndex{-1};
-    int playedEventID{-1};
-    float startTime{};
-    float speedMultiplier{};
-
-    QueuedPlay queuedPlay{};
-    QueuedPlay currentQueuedPlay{};
-    QueuedPlay nextQueuedPlay{};
-
-    std::unordered_set<int> playedTriggers{};
-    std::vector<Override> overrides{};
-
-    Actor() = default;
-    Actor(const Actor&);
-    Actor(Actor&&) noexcept;
-    Actor& operator=(const Actor&);
-    Actor& operator=(Actor&&) noexcept;
-    Actor(resource::xml::Anm2, glm::vec2 position = {}, Mode = PLAY, float time = 0.0f, int animationIndex = -1);
-    bool is_playing(const std::string& name = {});
-    glm::vec4 null_frame_rect(int = -1);
-    glm::vec4 rect();
-    int animation_index_get(const std::string&);
-    int item_length(resource::xml::Anm2::Item*);
-    resource::xml::Anm2::Animation* animation_get(const std::string&);
-    resource::xml::Anm2::Animation* animation_get(int = -1);
-    resource::xml::Anm2::Frame frame_generate(resource::xml::Anm2::Item&, float, resource::xml::Anm2::Type,
-                                              int id = -1);
-    resource::xml::Anm2::Item* item_get(resource::xml::Anm2::Type, int = -1, int = -1);
-    void consume_played_event();
-    void play(const std::string& animation, Mode = PLAY, float time = 0.0f, float speedMultiplier = 1.0f);
-    void play(int index, Mode = PLAY, float time = 0.0f, float speedMultiplier = 1.0f);
-    void play_default_animation(Mode = PLAY, float = 0.0f, float = 1.0f);
-    void queue_default_animation();
-    void queue_play(QueuedPlay);
-    bool is_animation_finished();
-    void render(resource::Shader& textureShader, resource::Shader& rectShader, Canvas&);
-    void tick();
-  };
-}
diff --git a/src/entity/character.cpp b/src/entity/character.cpp
deleted file mode 100644
index 2427246..0000000
--- a/src/entity/character.cpp
+++ /dev/null
@@ -1,380 +0,0 @@
-#include "character.hpp"
-
-#include <format>
-
-#include "../util/math.hpp"
-#include "../util/vector.hpp"
-
-using namespace game::util;
-using namespace glm;
-
-namespace game::entity
-{
-  Character::Character(const Character&) = default;
-  Character::Character(Character&&) noexcept = default;
-  Character& Character::operator=(const Character&) = default;
-  Character& Character::operator=(Character&&) noexcept = default;
-
-  Character::Character(resource::xml::Character& _data, glm::ivec2 _position) : Actor(_data.anm2, _position)
-  {
-    data = _data;
-
-    auto& save = data.save;
-    auto saveIsValid = save.is_valid();
-
-    capacity = saveIsValid ? save.capacity : (double)data.capacity;
-    weight = saveIsValid ? save.weight : (double)data.weight;
-    digestionRate = saveIsValid ? save.digestionRate : (double)data.digestionRate;
-    eatSpeed = saveIsValid ? save.eatSpeed : (double)data.eatSpeed;
-
-    calories = saveIsValid ? save.calories : 0;
-
-    isDigesting = saveIsValid ? save.isDigesting : false;
-    digestionProgress = saveIsValid ? save.digestionProgress : 0;
-    digestionTimer = saveIsValid ? save.digestionTimer : 0;
-
-    auto& talkSource = data.talkOverride.layerSource;
-    auto& talkDestination = data.talkOverride.layerDestination;
-    talkOverrideID = vector::push_index(overrides, Actor::Override(talkDestination, Anm2::LAYER, Override::SET));
-    for (auto& animation : animations)
-    {
-      if (!animation.layerAnimations.contains(talkSource))
-        animationTalkDurations.emplace_back(-1);
-      else
-        animationTalkDurations.emplace_back(item_length(&animation.layerAnimations.at(talkSource)));
-    }
-
-    auto& blinkSource = data.blinkOverride.layerSource;
-    auto& blinkDestination = data.blinkOverride.layerDestination;
-    blinkOverrideID = vector::push_index(overrides, Actor::Override(blinkDestination, Anm2::LAYER, Override::SET));
-    for (auto& animation : animations)
-    {
-      if (!animation.layerAnimations.contains(blinkSource))
-        animationBlinkDurations.emplace_back(-1);
-      else
-        animationBlinkDurations.emplace_back(item_length(&animation.layerAnimations.at(blinkSource)));
-    }
-
-    for (int i = 0; i < (int)data.expandAreas.size(); i++)
-    {
-      auto& expandArea = data.expandAreas[i];
-      expandAreaOverrideLayerIDs[i] =
-          vector::push_index(overrides, Actor::Override(expandArea.layerID, Anm2::LAYER, Override::ADD));
-      expandAreaOverrideNullIDs[i] =
-          vector::push_index(overrides, Actor::Override(expandArea.nullID, Anm2::NULL_, Override::ADD));
-    }
-
-    for (int i = 0; i < (int)data.interactAreas.size(); i++)
-    {
-      auto& interactArea = data.interactAreas[i];
-      if (interactArea.layerID != -1)
-        interactAreaOverrides[i] = Actor::Override(interactArea.layerID, Anm2::LAYER, Override::ADD);
-    }
-
-    stage = stage_get();
-    expand_areas_apply();
-  }
-
-  float Character::weight_get(measurement::System system)
-  {
-    return system == measurement::IMPERIAL ? weight * (double)measurement::KG_TO_LB : weight;
-  }
-
-  int Character::stage_from_weight_get(float checkWeight) const
-  {
-    if (data.stages.empty()) return 0;
-    if (checkWeight <= data.weight) return 0;
-
-    for (int i = 0; i < (int)data.stages.size(); i++)
-      if (checkWeight < data.stages[i].threshold) return i;
-
-    return stage_max_get();
-  }
-
-  int Character::stage_get() const { return stage_from_weight_get(weight); }
-
-  int Character::stage_max_get() const { return (int)data.stages.size(); }
-
-  float Character::stage_threshold_get(int stageIndex, measurement::System system) const
-  {
-    if (stageIndex == -1) stageIndex = this->stage;
-
-    double threshold = data.weight;
-
-    if (!data.stages.empty())
-    {
-      if (stageIndex <= 0)
-        threshold = data.weight;
-      else if (stageIndex >= stage_max_get())
-        threshold = data.stages.back().threshold;
-      else
-        threshold = data.stages[stageIndex - 1].threshold;
-    }
-
-    return system == measurement::IMPERIAL ? threshold * (double)measurement::KG_TO_LB : threshold;
-  }
-
-  float Character::stage_threshold_next_get(measurement::System system) const
-  {
-    return stage_threshold_get(stage + 1, system);
-  }
-
-  float Character::stage_progress_get()
-  {
-    auto currentStage = stage_get();
-    if (currentStage >= stage_max_get()) return 1.0;
-
-    auto currentThreshold = stage_threshold_get(currentStage);
-    auto nextThreshold = stage_threshold_get(currentStage + 1);
-    if (nextThreshold <= currentThreshold) return 1.0;
-
-    return (weight - currentThreshold) / (nextThreshold - currentThreshold);
-  }
-
-  float Character::digestion_rate_get() { return digestionRate * 60.0; }
-
-  float Character::max_capacity() const { return capacity * data.capacityMaxMultiplier; }
-  bool Character::is_over_capacity() const { return calories > capacity; }
-  bool Character::is_max_capacity() const { return calories >= max_capacity(); }
-  float Character::capacity_percent_get() const { return calories / max_capacity(); }
-
-  std::string Character::animation_append_id_get() const
-  {
-    if (stage <= 0) return {};
-    auto stageIndex = stage - 1;
-    if (stageIndex < 0 || stageIndex >= (int)data.stages.size()) return {};
-    return data.stages[stageIndex].animationAppendID;
-  }
-
-  std::string Character::animation_name_convert(const std::string& name)
-  {
-    auto appendID = animation_append_id_get();
-    return appendID.empty() ? name : name + appendID;
-  }
-  void Character::play_convert(const std::string& animation, Mode playMode, float startAtTime,
-                               float speedMultiplierValue)
-  {
-    play(animation_name_convert(animation), playMode, startAtTime, speedMultiplierValue);
-  }
-
-  void Character::expand_areas_apply()
-  {
-    auto stageProgress = stage_progress_get();
-    auto capacityProgress = isDigesting ? (double)calories / max_capacity() * (double)digestionTimer / data.digestionTimerMax
-                                        : calories / max_capacity();
-
-    for (int i = 0; i < (int)data.expandAreas.size(); i++)
-    {
-      auto& expandArea = data.expandAreas[i];
-      auto& overrideLayer = overrides[expandAreaOverrideLayerIDs[i]];
-      auto& overrideNull = overrides[expandAreaOverrideNullIDs[i]];
-
-      auto stageScaleAdd = ((double)expandArea.scaleAdd * stageProgress) * 0.5;
-      auto capacityScaleAdd = ((double)expandArea.scaleAdd * capacityProgress) * 0.5;
-
-      auto scaleAdd =
-          glm::clamp(glm::vec2(), glm::vec2(stageScaleAdd + capacityScaleAdd), glm::vec2(expandArea.scaleAdd));
-      overrideLayer.frame.scale = scaleAdd;
-      overrideNull.frame.scale = scaleAdd;
-    }
-  }
-
-  void Character::update()
-  {
-    isJustStageUp = false;
-    isJustStageFinal = false;
-    isJustDigested = false;
-  }
-
-  void Character::tick()
-  {
-    if (state == Actor::STOPPED)
-    {
-      if (isStageUp)
-      {
-        if (stage >= (int)data.stages.size())
-          isJustStageFinal = true;
-        else
-          isJustStageUp = true;
-
-        isStageUp = false;
-      }
-
-      if (nextQueuedPlay.empty() && !isTalking) queue_idle_animation();
-    }
-
-    Actor::tick();
-
-    if (isDigesting)
-    {
-      digestionTimer--;
-
-      if (digestionTimer <= 0)
-      {
-        auto increment = calories * data.caloriesToKilogram;
-        auto nextWeight = glm::clamp(weight + increment, data.weight, data.weightMax);
-
-        if (is_over_capacity())
-        {
-          auto capacityMaxCalorieDifference = (calories - capacity);
-          auto overCapacityPercent = capacityMaxCalorieDifference / (max_capacity() - capacity);
-          auto capacityIncrement =
-              (double)((overCapacityPercent * data.capacityIfOverStuffedOnDigestBonus) * capacityMaxCalorieDifference);
-          capacity = glm::clamp(capacity + capacityIncrement, (double)data.capacityMin, (double)data.capacityMax);
-        }
-
-        totalCaloriesConsumed += calories;
-        calories = 0;
-
-        if (auto nextStage = stage_from_weight_get((double)nextWeight); nextStage > stage_from_weight_get(weight))
-        {
-          queuedPlay = QueuedPlay{};
-          nextQueuedPlay = QueuedPlay{};
-          currentQueuedPlay = QueuedPlay{};
-          queue_play({.animation = data.animations.stageUp, .isInterruptible = false});
-          stage = nextStage;
-          isStageUp = true;
-        }
-        else
-          isJustDigested = true;
-
-        weight = (double)nextWeight;
-
-        isDigesting = false;
-        digestionTimer = data.digestionTimerMax;
-        digestionProgress = 0;
-      }
-    }
-    else
-    {
-      if (calories > 0) digestionProgress += digestionRate;
-      if (digestionProgress >= DIGESTION_MAX)
-      {
-        isDigesting = true;
-        digestionTimer = data.digestionTimerMax;
-        data.sounds.digest.play();
-      }
-    }
-
-    if (math::random_percent_roll(
-            math::to_percent(data.gurgleChance * (capacity_percent_get() * data.gurgleCapacityMultiplier))))
-      data.sounds.gurgle.play();
-
-    stage = stage_get();
-    expand_areas_apply();
-
-    auto& talkOverride = overrides[talkOverrideID];
-
-    if (isTalking)
-    {
-      auto talk_reset = [&]()
-      {
-        isTalking = false;
-        talkTimer = 0.0;
-        talkOverride.frame = FrameOptional();
-      };
-
-      auto& id = data.talkOverride.layerSource;
-      auto& layerAnimations = animation_get()->layerAnimations;
-
-      if (layerAnimations.contains(id) && animationTalkDurations.at(animationIndex) > -1)
-      {
-        auto& layerAnimation = layerAnimations.at(data.talkOverride.layerSource);
-
-        if (!layerAnimation.frames.empty())
-        {
-          auto frame = frame_generate(layerAnimation, talkTimer, Anm2::LAYER, id);
-
-          talkOverride.frame.crop = frame.crop;
-          talkOverride.frame.size = frame.size;
-          talkOverride.frame.pivot = frame.pivot;
-
-          talkTimer += 1.0;
-
-          if (talkTimer > animationTalkDurations.at(animationIndex)) talkTimer = 0.0;
-        }
-        else
-          talk_reset();
-      }
-      else
-        talk_reset();
-    }
-    else
-      talkOverride.frame = {};
-
-    auto& blinkOverride = overrides[blinkOverrideID];
-
-    if (auto blinkDuration = animationBlinkDurations[animationIndex]; blinkDuration != 1)
-    {
-      if (math::random_percent_roll(data.blinkChance)) isBlinking = true;
-
-      if (isBlinking)
-      {
-        auto blink_reset = [&]()
-        {
-          isBlinking = false;
-          blinkTimer = 0.0;
-          blinkOverride.frame = FrameOptional();
-        };
-
-        auto& id = data.blinkOverride.layerSource;
-        auto& layerAnimations = animation_get()->layerAnimations;
-
-        if (layerAnimations.contains(id))
-        {
-          auto& layerAnimation = layerAnimations.at(data.blinkOverride.layerSource);
-
-          if (!layerAnimation.frames.empty())
-          {
-            auto frame = frame_generate(layerAnimation, blinkTimer, Anm2::LAYER, id);
-
-            blinkOverride.frame.crop = frame.crop;
-            blinkOverride.frame.size = frame.size;
-            blinkOverride.frame.pivot = frame.pivot;
-
-            blinkTimer += 1.0;
-
-            if (blinkTimer >= blinkDuration) blink_reset();
-          }
-          else
-            blink_reset();
-        }
-        else
-          blink_reset();
-      }
-    }
-  }
-
-  void Character::queue_play(QueuedPlay play)
-  {
-    if (isStageUp) return;
-    queuedPlay = play;
-    queuedPlay.animation = animation_name_convert(queuedPlay.animation);
-  }
-
-  void Character::queue_idle_animation()
-  {
-    if (isStageUp) return;
-    if (data.animations.idle.empty()) return;
-    queue_play(
-        {is_over_capacity() && !data.animations.idleFull.empty() ? data.animations.idleFull : data.animations.idle});
-  }
-
-  void Character::spritesheet_set(SpritesheetType type)
-  {
-    switch (type)
-    {
-      case NORMAL:
-        spritesheets.at(data.alternateSpritesheet.id).texture =
-            data.anm2.spritesheets.at(data.alternateSpritesheet.id).texture;
-        break;
-      case ALTERNATE:
-        spritesheets.at(data.alternateSpritesheet.id).texture = data.alternateSpritesheet.texture;
-        break;
-      default:
-        break;
-    }
-
-    spritesheetType = type;
-  }
-}
diff --git a/src/entity/character.hpp b/src/entity/character.hpp
deleted file mode 100644
index 8606db0..0000000
--- a/src/entity/character.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#pragma once
-
-#include "../resource/xml/character.hpp"
-#include "../util/measurement.hpp"
-
-#include "actor.hpp"
-
-namespace game::entity
-{
-  class Character : public Actor
-  {
-  public:
-    static constexpr auto DIGESTION_MAX = 100.0f;
-
-    enum SpritesheetType
-    {
-      NORMAL,
-      ALTERNATE
-    };
-
-    resource::xml::Character data;
-
-    float weight{};
-    int stage{0};
-    float calories{};
-    float capacity{};
-
-    float digestionProgress{};
-    float digestionRate{0.05f};
-    int digestionTimer{};
-    bool isDigesting{};
-    bool isJustDigested{};
-
-    float eatSpeed{1.0f};
-
-    float totalCaloriesConsumed{};
-    int totalFoodItemsEaten{};
-
-    int talkOverrideID{};
-    float talkTimer{};
-    bool isTalking{};
-    std::vector<int> animationTalkDurations{};
-
-    int blinkOverrideID{};
-    float blinkTimer{};
-    bool isBlinking{};
-    std::vector<int> animationBlinkDurations{};
-
-    bool isStageUp{};
-    bool isStageUpDuring{};
-    bool isJustStageUp{};
-    bool isJustStageFinal{};
-
-    SpritesheetType spritesheetType{};
-
-    std::map<int, Override> interactAreaOverrides{};
-
-    std::unordered_map<int, int> expandAreaOverrideLayerIDs{};
-    std::unordered_map<int, int> expandAreaOverrideNullIDs{};
-
-    Character() = default;
-    Character(const Character&);
-    Character(Character&&) noexcept;
-    Character& operator=(const Character&);
-    Character& operator=(Character&&) noexcept;
-    Character(resource::xml::Character&, glm::ivec2);
-
-    float weight_get(util::measurement::System = util::measurement::METRIC);
-    float digestion_rate_get();
-    float capacity_percent_get() const;
-    float max_capacity() const;
-    bool is_over_capacity() const;
-    bool is_max_capacity() const;
-
-    int stage_get() const;
-    int stage_from_weight_get(float weight) const;
-    int stage_max_get() const;
-    float stage_progress_get();
-    float stage_threshold_get(int stage = -1, util::measurement::System = util::measurement::METRIC) const;
-    float stage_threshold_next_get(util::measurement::System = util::measurement::METRIC) const;
-
-    void expand_areas_apply();
-    void spritesheet_set(SpritesheetType);
-    void update();
-    void tick();
-    void play_convert(const std::string&, Mode = PLAY, float time = 0.0f, float speedMultiplier = 1.0f);
-    void queue_idle_animation();
-    void queue_play(QueuedPlay);
-
-    std::string animation_append_id_get() const;
-    std::string animation_name_convert(const std::string& name);
-  };
-}
diff --git a/src/entity/cursor.cpp b/src/entity/cursor.cpp
deleted file mode 100644
index 5784e46..0000000
--- a/src/entity/cursor.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "cursor.hpp"
-
-#include "../util/imgui.hpp"
-
-using namespace game::util;
-using namespace glm;
-
-namespace game::entity
-{
-  Cursor::Cursor(Anm2& anm2) : Actor(anm2, imgui::to_vec2(ImGui::GetMousePos())) {}
-  void Cursor::tick()
-  {
-    Actor::tick();
-    queue_default_animation();
-  }
-
-  void Cursor::update()
-  {
-    state = DEFAULT;
-    position = imgui::to_vec2(ImGui::GetMousePos());
-  }
-}
diff --git a/src/entity/cursor.hpp b/src/entity/cursor.hpp
deleted file mode 100644
index 8fdd473..0000000
--- a/src/entity/cursor.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "actor.hpp"
-
-namespace game::entity
-{
-  class Cursor : public Actor
-  {
-  public:
-    enum State
-    {
-      DEFAULT,
-      HOVER,
-      ACTION
-    };
-
-    State state{DEFAULT};
-    int interactTypeID{-1};
-
-    Cursor() = default;
-    Cursor(resource::xml::Anm2&);
-    void tick();
-    void update();
-  };
-}
diff --git a/src/entity/item.cpp b/src/entity/item.cpp
deleted file mode 100644
index 3a40b81..0000000
--- a/src/entity/item.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "item.hpp"
-
-#include <imgui.h>
-
-#include "../util/vector.hpp"
-
-using game::resource::xml::Anm2;
-using namespace game::util;
-using namespace glm;
-
-namespace game::entity
-{
-  Item::Item(Anm2 _anm2, glm::ivec2 _position, int _schemaID, int _durability, int _animationIndex, glm::vec2 _velocity,
-             float _rotation)
-      : Actor(_anm2, _position, SET, 0.0f, _animationIndex), schemaID(_schemaID), durability(_durability),
-        velocity(_velocity)
-  {
-
-    rotationOverrideID =
-        vector::push_index(overrides, Override(-1, Anm2::ROOT, Override::SET, Anm2::FrameOptional{.rotation = _rotation}));
-  }
-
-  void Item::update()
-  {
-    auto& rotationOverride = overrides[rotationOverrideID];
-
-    position += velocity;
-
-    *rotationOverride.frame.rotation += angularVelocity;
-  }
-}
diff --git a/src/entity/item.hpp b/src/entity/item.hpp
deleted file mode 100644
index 77c76e8..0000000
--- a/src/entity/item.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#pragma once
-
-#include "../resource/xml/item.hpp"
-
-#include "actor.hpp"
-
-namespace game::entity
-{
-  class Item : public Actor
-  {
-  public:
-    bool isToBeDeleted{};
-    bool isHeld{};
-
-    int schemaID{};
-    int rotationOverrideID{};
-    int durability{};
-
-    glm::vec2 velocity{};
-    float angularVelocity{};
-
-    Item(resource::xml::Anm2, glm::ivec2 position, int id, int durability = 0, int animationIndex = -1,
-         glm::vec2 velocity = {}, float rotation = 0.0f);
-    void update();
-  };
-}
diff --git a/src/loader.cpp b/src/loader.cpp
index 05f02a8..f8722e3 100644
--- a/src/loader.cpp
+++ b/src/loader.cpp
@@ -20,8 +20,9 @@
 #include <physfs.h>
 
 #include "resource/audio.hpp"
-#include "resource/xml/settings.hpp"
+#include "resource/schema.hpp"
 #include "util/imgui/style.hpp"
+#include "util/imgui/io.hpp"
 #include "util/preferences.hpp"
 
 #ifdef __EMSCRIPTEN__
@@ -50,7 +51,9 @@ namespace game
     util::web_filesystem::init_and_wait();
 #endif
 
-    settings = resource::xml::Settings(preferences::path() / "settings.xml");
+    settings = resource::xml::Schema(preferences::path() / "settings.xml");
+    if (!settings.root() || settings.root()->type != resource::xml::Schema::Element::SETTINGS) settings.settings_default();
+    auto* settingsRoot = settings.root();
 
     logger.info("Initializing...");
 
@@ -91,13 +94,13 @@ namespace game
     SDL_PropertiesID windowProperties = SDL_CreateProperties();
 
     SDL_SetStringProperty(windowProperties, SDL_PROP_WINDOW_CREATE_TITLE_STRING, "Shweet's Sim");
-    SDL_SetNumberProperty(windowProperties, SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER, (long)settings.windowSize.x);
-    SDL_SetNumberProperty(windowProperties, SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER, (long)settings.windowSize.y);
+    SDL_SetNumberProperty(windowProperties, SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER, (long)settingsRoot->windowSize.x);
+    SDL_SetNumberProperty(windowProperties, SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER, (long)settingsRoot->windowSize.y);
 
     SDL_SetNumberProperty(windowProperties, SDL_PROP_WINDOW_CREATE_X_NUMBER,
-                          settings.windowPosition.x == 0 ? SDL_WINDOWPOS_CENTERED : (long)settings.windowPosition.x);
+                          settingsRoot->windowPosition.x == 0 ? SDL_WINDOWPOS_CENTERED : (long)settingsRoot->windowPosition.x);
     SDL_SetNumberProperty(windowProperties, SDL_PROP_WINDOW_CREATE_Y_NUMBER,
-                          settings.windowPosition.y == 0 ? SDL_WINDOWPOS_CENTERED : (long)settings.windowPosition.y);
+                          settingsRoot->windowPosition.y == 0 ? SDL_WINDOWPOS_CENTERED : (long)settingsRoot->windowPosition.y);
 
     SDL_SetBooleanProperty(windowProperties, SDL_PROP_WINDOW_CREATE_RESIZABLE_BOOLEAN, true);
     SDL_SetBooleanProperty(windowProperties, SDL_PROP_WINDOW_CREATE_OPENGL_BOOLEAN, true);
@@ -200,10 +203,12 @@ namespace game
 
     logger.info("Initialized Dear ImGui OpenGL backend");
 
-    imgui::style::color_set(settings.color);
+    imgui::style::color_set(settingsRoot->color);
     imgui::style::widget_set();
+    imgui::io::keyboard_repeat_set();
     math::random_seed_set();
-    resource::Audio::volume_set((float)settings.volume / 100);
+    resource::Audio::volume_set((float)settingsRoot->volume / 100);
+    resource::Audio::mute_set(settingsRoot->isAudioMuted);
   }
 
   Loader::~Loader()
diff --git a/src/loader.hpp b/src/loader.hpp
index e9eb869..2ab3f96 100644
--- a/src/loader.hpp
+++ b/src/loader.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "resource/xml/settings.hpp"
+#include "resource/schema.hpp"
 #include <SDL3/SDL.h>
 #include <glm/ext/vector_float2.hpp>
 
@@ -12,7 +12,7 @@ namespace game
     SDL_Window* window{};
     SDL_GLContext context{};
     bool isError{};
-    resource::xml::Settings settings;
+    resource::xml::Schema settings;
 
     Loader(int argc, const char** argv);
     ~Loader();
diff --git a/src/render/canvas.cpp b/src/render/canvas.cpp
index 4428951..bf8a752 100644
--- a/src/render/canvas.cpp
+++ b/src/render/canvas.cpp
@@ -277,18 +277,18 @@ namespace game
     shakeOffset = {math::random_in_range(-magnitude, magnitude), math::random_in_range(-magnitude, magnitude)};
   }
 
-  void Canvas::tick()
+  void Canvas::update()
   {
-    static constexpr auto SHAKE_LERP_FACTOR = 0.35f;
-    static constexpr auto SHAKE_DECAY = 0.85f;
+    static constexpr auto SHAKE_LERP_FACTOR = 0.72f;
+    static constexpr auto SHAKE_DECAY = 0.97f;
     static constexpr auto SHAKE_EPSILON = 0.1f;
 
     if (shakeTimer > 0)
     {
       shakeTimer--;
 
-      auto magnitude = glm::length(shakeOffset) * SHAKE_DECAY;
       auto timerFactor = (float)shakeTimer / (float)std::max(1, shakeTimerMax);
+      auto magnitude = std::max(glm::length(shakeOffset) * SHAKE_DECAY, SHAKE_MAGNITUDE * timerFactor);
       auto target =
           glm::vec2(math::random_in_range(-magnitude, magnitude), math::random_in_range(-magnitude, magnitude)) *
           timerFactor;
diff --git a/src/render/canvas.hpp b/src/render/canvas.hpp
index fef8818..5ec7e33 100644
--- a/src/render/canvas.hpp
+++ b/src/render/canvas.hpp
@@ -31,8 +31,8 @@ namespace game
 
   public:
     static constexpr glm::vec4 CLEAR_COLOR = {0, 0, 0, 0};
-    static constexpr float SHAKE_MAGNITUDE = 0.05f;
-    static constexpr float SHAKE_TIME_TICKS = 60;
+    static constexpr float SHAKE_MAGNITUDE = 0.1f;
+    static constexpr float SHAKE_TIME_TICKS = 30;
 
     enum Flag
     {
@@ -70,7 +70,7 @@ namespace game
     void rect_render(resource::Shader&, glm::mat4&, glm::vec4 = glm::vec4(0, 0, 1, 1)) const;
     void render(resource::Shader&, glm::mat4&, glm::vec4 = glm::vec4(1.0f), glm::vec3 = {}) const;
     void shake(float magnitude = SHAKE_MAGNITUDE, int timeTicks = SHAKE_TIME_TICKS);
-    void tick();
+    void update();
     void bind();
     void size_set(glm::ivec2 size);
     void clear(glm::vec4 color = CLEAR_COLOR);
diff --git a/src/resource/anm2.cpp b/src/resource/anm2.cpp
new file mode 100644
index 0000000..6c02807
--- /dev/null
+++ b/src/resource/anm2.cpp
@@ -0,0 +1,642 @@
+#include "anm2.hpp"
+
+#include "../util/physfs.hpp"
+#include "../util/working_directory.hpp"
+
+#include "../log.hpp"
+
+#include <array>
+#include <cstring>
+#include <format>
+#include <ranges>
+
+using namespace tinyxml2;
+using namespace game::util;
+
+namespace game::resource::xml
+{
+  namespace
+  {
+    XMLError document_load(const physfs::Path& path, XMLDocument& document)
+    {
+      if (!path.is_valid())
+      {
+        logger.error(std::format("Failed to open XML document: {} ({})", path.c_str(), physfs::error_get()));
+        return XML_ERROR_FILE_NOT_FOUND;
+      }
+
+      auto buffer = path.read();
+      if (buffer.empty())
+      {
+        logger.error(std::format("Failed to read XML document: {} ({})", path.c_str(), physfs::error_get()));
+        return XML_ERROR_FILE_COULD_NOT_BE_OPENED;
+      }
+
+      auto result = document.Parse((const char*)buffer.data(), buffer.size());
+      if (result != XML_SUCCESS)
+        logger.error(std::format("Failed to parse XML document: {} ({})", path.c_str(), document.ErrorStr()));
+
+      return result;
+    }
+
+    XMLError query_string_attribute(XMLElement* element, const char* attribute, std::string* value)
+    {
+      const char* temp = nullptr;
+      auto result = element->QueryStringAttribute(attribute, &temp);
+      if (result == XML_SUCCESS && temp && value) *value = temp;
+      return result;
+    }
+
+    XMLError query_color_attribute(XMLElement* element, const char* attribute, float* value)
+    {
+      int temp{};
+      auto result = element->QueryIntAttribute(attribute, &temp);
+      if (result == XML_SUCCESS && value) *value = (temp / 255.0f);
+      return result;
+    }
+
+    Anm2::Frame::Interpolation interpolation_get(XMLElement* element)
+    {
+      if (!element) return Anm2::Frame::INTERPOLATION_NONE;
+
+      auto* value = element->Attribute("Interpolated");
+      if (!value) return Anm2::Frame::INTERPOLATION_NONE;
+
+      if (std::strcmp(value, "true") == 0 || std::strcmp(value, "1") == 0) return Anm2::Frame::LINEAR;
+      if (std::strcmp(value, "false") == 0 || std::strcmp(value, "0") == 0) return Anm2::Frame::INTERPOLATION_NONE;
+      if (std::strcmp(value, "EaseIn") == 0) return Anm2::Frame::EASE_IN;
+      if (std::strcmp(value, "EaseOut") == 0) return Anm2::Frame::EASE_OUT;
+      if (std::strcmp(value, "EaseInOut") == 0) return Anm2::Frame::EASE_IN_OUT;
+      return Anm2::Frame::INTERPOLATION_NONE;
+    }
+
+    void attributes_parse(XMLElement* element, Anm2::Element& parsed)
+    {
+      if (!element) return;
+
+      query_string_attribute(element, "CreatedBy", &parsed.createdBy);
+      query_string_attribute(element, "CreatedOn", &parsed.createdOn);
+      query_string_attribute(element, "DefaultAnimation", &parsed.defaultAnimation);
+      query_string_attribute(element, "Name", &parsed.name);
+      query_string_attribute(element, "Path", &parsed.path);
+
+      element->QueryIntAttribute("Id", &parsed.id);
+      element->QueryIntAttribute("LayerId", &parsed.layerID);
+      element->QueryIntAttribute("NullId", &parsed.nullID);
+      element->QueryIntAttribute("SpritesheetId", &parsed.spritesheetID);
+      element->QueryIntAttribute("EventId", &parsed.eventID);
+      element->QueryIntAttribute("RegionId", &parsed.regionID);
+      element->QueryIntAttribute("GroupId", &parsed.groupID);
+      element->QueryIntAttribute("AtFrame", &parsed.atFrame);
+      element->QueryIntAttribute("FrameNum", &parsed.frameNum);
+      element->QueryIntAttribute("Fps", &parsed.fps);
+      element->QueryIntAttribute("Version", &parsed.version);
+      element->QueryIntAttribute("Delay", &parsed.delay);
+
+      element->QueryFloatAttribute("XCrop", &parsed.crop.x);
+      element->QueryFloatAttribute("YCrop", &parsed.crop.y);
+      element->QueryFloatAttribute("XPosition", &parsed.position.x);
+      element->QueryFloatAttribute("YPosition", &parsed.position.y);
+      element->QueryFloatAttribute("XPivot", &parsed.pivot.x);
+      element->QueryFloatAttribute("YPivot", &parsed.pivot.y);
+      element->QueryFloatAttribute("Width", &parsed.size.x);
+      element->QueryFloatAttribute("Height", &parsed.size.y);
+      element->QueryFloatAttribute("XScale", &parsed.scale.x);
+      element->QueryFloatAttribute("YScale", &parsed.scale.y);
+      element->QueryFloatAttribute("Rotation", &parsed.rotation);
+
+      query_color_attribute(element, "RedTint", &parsed.tint.r);
+      query_color_attribute(element, "GreenTint", &parsed.tint.g);
+      query_color_attribute(element, "BlueTint", &parsed.tint.b);
+      query_color_attribute(element, "AlphaTint", &parsed.tint.a);
+      query_color_attribute(element, "RedOffset", &parsed.colorOffset.r);
+      query_color_attribute(element, "GreenOffset", &parsed.colorOffset.g);
+      query_color_attribute(element, "BlueOffset", &parsed.colorOffset.b);
+
+      element->QueryBoolAttribute("Visible", &parsed.isVisible);
+      element->QueryBoolAttribute("ShowRect", &parsed.isShowRect);
+      element->QueryBoolAttribute("Loop", &parsed.isLoop);
+      element->QueryBoolAttribute("Expanded", &parsed.isExpanded);
+    }
+
+    Anm2::Element element_parse(XMLElement* element)
+    {
+      Anm2::Element parsed{};
+      if (!element) return parsed;
+
+      parsed.type = Anm2::Element::type_get(element->Name());
+      if (parsed.type == Anm2::Element::UNKNOWN) return parsed;
+
+      attributes_parse(element, parsed);
+
+      for (auto* child = element->FirstChildElement(); child; child = child->NextSiblingElement())
+        if (auto parsedChild = element_parse(child); parsedChild.type != Anm2::Element::UNKNOWN)
+          parsed.children.emplace_back(std::move(parsedChild));
+
+      return parsed;
+    }
+  }
+
+  Anm2::Element::Type Anm2::Element::type_get(std::string_view tag)
+  {
+    static constexpr std::array<std::pair<Type, std::string_view>, TYPE_COUNT - 1> TAGS{{
+        {ACTOR, "AnimatedActor"},
+        {INFO, "Info"},
+        {CONTENT, "Content"},
+        {SPRITESHEETS, "Spritesheets"},
+        {SPRITESHEET, "Spritesheet"},
+        {REGION, "Region"},
+        {LAYERS, "Layers"},
+        {LAYER_ELEMENT, "Layer"},
+        {NULLS, "Nulls"},
+        {NULL_ELEMENT, "Null"},
+        {EVENTS, "Events"},
+        {EVENT, "Event"},
+        {SOUNDS, "Sounds"},
+        {SOUND_ELEMENT, "Sound"},
+        {ANIMATIONS, "Animations"},
+        {ANIMATION, "Animation"},
+        {ROOT_ANIMATION, "RootAnimation"},
+        {LAYER_ANIMATIONS, "LayerAnimations"},
+        {LAYER_ANIMATION, "LayerAnimation"},
+        {NULL_ANIMATIONS, "NullAnimations"},
+        {NULL_ANIMATION, "NullAnimation"},
+        {GROUP, "Group"},
+        {TRIGGERS, "Triggers"},
+        {TRIGGER_ELEMENT, "Trigger"},
+        {FRAME, "Frame"},
+    }};
+
+    for (auto [type, typeTag] : TAGS)
+      if (typeTag == tag) return type;
+    return UNKNOWN;
+  }
+
+  Anm2::Element* Anm2::Element::child_get(Type type, std::size_t index)
+  {
+    std::size_t current{};
+    for (auto& child : children)
+      if (child.type == type && current++ == index) return &child;
+    return nullptr;
+  }
+
+  const Anm2::Element* Anm2::Element::child_get(Type type, std::size_t index) const
+  {
+    std::size_t current{};
+    for (auto& child : children)
+      if (child.type == type && current++ == index) return &child;
+    return nullptr;
+  }
+
+  std::vector<Anm2::Element*> Anm2::Element::children_get(Type type)
+  {
+    std::vector<Element*> result{};
+    for (auto& child : children)
+      if (child.type == type) result.emplace_back(&child);
+    return result;
+  }
+
+  std::vector<const Anm2::Element*> Anm2::Element::children_get(Type type) const
+  {
+    std::vector<const Element*> result{};
+    for (auto& child : children)
+      if (child.type == type) result.emplace_back(&child);
+    return result;
+  }
+
+  Anm2::Anm2(const Anm2&) = default;
+  Anm2::Anm2(Anm2&&) = default;
+  Anm2& Anm2::operator=(const Anm2&) = default;
+  Anm2& Anm2::operator=(Anm2&&) = default;
+
+  void Anm2::init(XMLDocument& document, Flags anm2Flags, const physfs::Path& archive)
+  {
+    this->flags = anm2Flags;
+
+    auto element = document.RootElement();
+    if (!element) return;
+    root = element_parse(element);
+
+    auto parse_frame = [&](XMLElement* element, Type type, int spritesheetID = -1)
+    {
+      Frame frame{};
+      if (!element) return frame;
+
+      if (type != TRIGGER)
+      {
+        element->QueryFloatAttribute("XPosition", &frame.position.x);
+        element->QueryFloatAttribute("YPosition", &frame.position.y);
+        if (type == LAYER)
+        {
+          auto isRegionFrame = element->FindAttribute("RegionId") && spritesheets.contains(spritesheetID);
+          if (isRegionFrame)
+          {
+            auto& spritesheet = spritesheets.at(spritesheetID);
+            element->QueryIntAttribute("RegionId", &frame.regionID);
+            if (auto region = spritesheet.regions.find(frame.regionID); region != spritesheet.regions.end())
+            {
+              frame.crop = region->second.crop;
+              frame.size = region->second.size;
+              frame.pivot = region->second.origin == Spritesheet::Region::Origin::CENTER
+                                ? glm::vec2(glm::ivec2(frame.size * 0.5f))
+                            : region->second.origin == Spritesheet::Region::Origin::TOP_LEFT ? glm::vec2{}
+                                                                                             : region->second.pivot;
+            }
+            else
+              isRegionFrame = false;
+          }
+          if (!isRegionFrame)
+          {
+            element->QueryFloatAttribute("XPivot", &frame.pivot.x);
+            element->QueryFloatAttribute("YPivot", &frame.pivot.y);
+            element->QueryFloatAttribute("XCrop", &frame.crop.x);
+            element->QueryFloatAttribute("YCrop", &frame.crop.y);
+            element->QueryFloatAttribute("Width", &frame.size.x);
+            element->QueryFloatAttribute("Height", &frame.size.y);
+          }
+        }
+        element->QueryFloatAttribute("XScale", &frame.scale.x);
+        element->QueryFloatAttribute("YScale", &frame.scale.y);
+        element->QueryIntAttribute("Delay", &frame.duration);
+        element->QueryBoolAttribute("Visible", &frame.isVisible);
+        query_color_attribute(element, "RedTint", &frame.tint.r);
+        query_color_attribute(element, "GreenTint", &frame.tint.g);
+        query_color_attribute(element, "BlueTint", &frame.tint.b);
+        query_color_attribute(element, "AlphaTint", &frame.tint.a);
+        query_color_attribute(element, "RedOffset", &frame.colorOffset.r);
+        query_color_attribute(element, "GreenOffset", &frame.colorOffset.g);
+        query_color_attribute(element, "BlueOffset", &frame.colorOffset.b);
+        element->QueryFloatAttribute("Rotation", &frame.rotation);
+        frame.interpolation = interpolation_get(element);
+        frame.isInterpolated = frame.interpolation != Frame::INTERPOLATION_NONE;
+      }
+      else
+      {
+        int soundID{};
+        if (element->QueryIntAttribute("SoundId", &soundID) == XML_SUCCESS) frame.soundIDs.emplace_back(soundID);
+
+        for (auto child = element->FirstChildElement("Sound"); child; child = child->NextSiblingElement("Sound"))
+        {
+          child->QueryIntAttribute("Id", &soundID);
+          frame.soundIDs.emplace_back(soundID);
+        }
+
+        element->QueryIntAttribute("EventId", &frame.eventID);
+        element->QueryIntAttribute("AtFrame", &frame.atFrame);
+      }
+
+      return frame;
+    };
+
+    auto parse_item = [&](XMLElement* element, Type type, int& id)
+    {
+      Item item{};
+      if (!element) return item;
+
+      if (type == LAYER) element->QueryIntAttribute("LayerId", &id);
+      if (type == NULL_) element->QueryIntAttribute("NullId", &id);
+
+      element->QueryBoolAttribute("Visible", &item.isVisible);
+
+      auto spritesheetID = -1;
+      if (type == LAYER)
+        if (auto layer = layers.find(id); layer != layers.end()) spritesheetID = layer->second.spritesheetID;
+
+      for (auto child = type == TRIGGER ? element->FirstChildElement("Trigger") : element->FirstChildElement("Frame");
+           child; child = type == TRIGGER ? child->NextSiblingElement("Trigger") : child->NextSiblingElement("Frame"))
+        item.frames.emplace_back(parse_frame(child, type, spritesheetID));
+
+      return item;
+    };
+
+    auto parse_animation = [&](XMLElement* element)
+    {
+      Animation animation{};
+      if (!element) return animation;
+
+      query_string_attribute(element, "Name", &animation.name);
+      element->QueryIntAttribute("FrameNum", &animation.frameNum);
+      element->QueryBoolAttribute("Loop", &animation.isLoop);
+
+      int id{-1};
+
+      if (auto rootAnimationElement = element->FirstChildElement("RootAnimation"))
+        animation.rootAnimation = parse_item(rootAnimationElement, ROOT, id);
+
+      auto track_elements_parse = [](auto&& self, XMLElement* parent, const char* tag, auto&& callback) -> void
+      {
+        for (auto child = parent->FirstChildElement(); child; child = child->NextSiblingElement())
+        {
+          auto name = child->Name();
+          if (name && std::strcmp(name, tag) == 0)
+            callback(child);
+          else if (name && std::strcmp(name, "Group") == 0)
+            self(self, child, tag, callback);
+        }
+      };
+
+      if (auto layerAnimationsElement = element->FirstChildElement("LayerAnimations"))
+      {
+        track_elements_parse(track_elements_parse, layerAnimationsElement, "LayerAnimation", [&](XMLElement* child)
+        {
+          auto layerAnimation = parse_item(child, LAYER, id);
+          animation.layerOrder.push_back(id);
+          animation.layerAnimations.emplace(id, std::move(layerAnimation));
+        });
+      }
+
+      if (auto nullAnimationsElement = element->FirstChildElement("NullAnimations"))
+      {
+        track_elements_parse(track_elements_parse, nullAnimationsElement, "NullAnimation", [&](XMLElement* child)
+        {
+          auto nullAnimation = parse_item(child, NULL_, id);
+          animation.nullAnimations.emplace(id, std::move(nullAnimation));
+        });
+      }
+
+      if (auto triggersElement = element->FirstChildElement("Triggers"))
+        animation.triggers = parse_item(triggersElement, TRIGGER, id);
+
+      return animation;
+    };
+
+    if (auto infoElement = element->FirstChildElement("Info")) infoElement->QueryIntAttribute("Fps", &fps);
+
+    if (auto contentElement = element->FirstChildElement("Content"))
+    {
+      if (auto spritesheetsElement = contentElement->FirstChildElement("Spritesheets"))
+      {
+        for (auto child = spritesheetsElement->FirstChildElement("Spritesheet"); child;
+             child = child->NextSiblingElement("Spritesheet"))
+        {
+          int spritesheetId{};
+          Spritesheet spritesheet{};
+          child->QueryIntAttribute("Id", &spritesheetId);
+          query_string_attribute(child, "Path", &spritesheet.path);
+
+          if ((this->flags & NO_SPRITESHEETS) != 0)
+            spritesheet.texture = Texture();
+          else if (!archive.empty())
+            spritesheet.texture = Texture(physfs::Path(archive + "/" + spritesheet.path));
+          else
+            spritesheet.texture = Texture(std::filesystem::path(spritesheet.path));
+
+          for (auto regionChild = child->FirstChildElement("Region"); regionChild;
+               regionChild = regionChild->NextSiblingElement("Region"))
+          {
+            Spritesheet::Region region{};
+            int regionID{};
+
+            regionChild->QueryIntAttribute("Id", &regionID);
+            query_string_attribute(regionChild, "Name", &region.name);
+            regionChild->QueryFloatAttribute("XCrop", &region.crop.x);
+            regionChild->QueryFloatAttribute("YCrop", &region.crop.y);
+            regionChild->QueryFloatAttribute("Width", &region.size.x);
+            regionChild->QueryFloatAttribute("Height", &region.size.y);
+
+            if (regionChild->FindAttribute("Origin"))
+            {
+              std::string origin{};
+              query_string_attribute(regionChild, "Origin", &origin);
+              region.origin = origin == "Center"    ? Spritesheet::Region::CENTER
+                              : origin == "TopLeft" ? Spritesheet::Region::TOP_LEFT
+                                                    : Spritesheet::Region::CUSTOM;
+            }
+            else
+            {
+              regionChild->QueryFloatAttribute("XPivot", &region.pivot.x);
+              regionChild->QueryFloatAttribute("YPivot", &region.pivot.y);
+            }
+
+            spritesheet.regions.emplace(regionID, std::move(region));
+            spritesheet.regionOrder.emplace_back(regionID);
+          }
+
+          spritesheets.emplace(spritesheetId, std::move(spritesheet));
+        }
+      }
+
+      if (auto layersElement = contentElement->FirstChildElement("Layers"))
+      {
+        for (auto child = layersElement->FirstChildElement("Layer"); child; child = child->NextSiblingElement("Layer"))
+        {
+          int layerId{};
+          Layer layer{};
+          child->QueryIntAttribute("Id", &layerId);
+          query_string_attribute(child, "Name", &layer.name);
+          child->QueryIntAttribute("SpritesheetId", &layer.spritesheetID);
+          layerMap[layer.name] = layerId;
+          layers.emplace(layerId, std::move(layer));
+        }
+      }
+
+      if (auto nullsElement = contentElement->FirstChildElement("Nulls"))
+      {
+        for (auto child = nullsElement->FirstChildElement("Null"); child; child = child->NextSiblingElement("Null"))
+        {
+          int nullId{};
+          Null null{};
+          child->QueryIntAttribute("Id", &nullId);
+          query_string_attribute(child, "Name", &null.name);
+          child->QueryBoolAttribute("ShowRect", &null.isShowRect);
+          nullMap[null.name] = nullId;
+          nulls.emplace(nullId, std::move(null));
+        }
+      }
+
+      if (auto eventsElement = contentElement->FirstChildElement("Events"))
+      {
+        for (auto child = eventsElement->FirstChildElement("Event"); child; child = child->NextSiblingElement("Event"))
+        {
+          int eventId{};
+          Event event{};
+          child->QueryIntAttribute("Id", &eventId);
+          query_string_attribute(child, "Name", &event.name);
+          eventMap[event.name] = eventId;
+          events.emplace(eventId, std::move(event));
+        }
+      }
+
+      if (auto soundsElement = contentElement->FirstChildElement("Sounds"))
+      {
+        for (auto child = soundsElement->FirstChildElement("Sound"); child; child = child->NextSiblingElement("Sound"))
+        {
+          int soundId{};
+          Sound sound{};
+          child->QueryIntAttribute("Id", &soundId);
+          query_string_attribute(child, "Path", &sound.path);
+          if ((this->flags & NO_SOUNDS) != 0)
+            sound.audio = Audio();
+          else if (!archive.empty())
+            sound.audio = Audio(physfs::Path(archive + "/" + sound.path));
+          else
+            sound.audio = Audio(std::filesystem::path(sound.path));
+          sounds.emplace(soundId, std::move(sound));
+        }
+      }
+    }
+
+    if (auto animationsElement = element->FirstChildElement("Animations"))
+    {
+      query_string_attribute(animationsElement, "DefaultAnimation", &defaultAnimation);
+
+      for (auto child = animationsElement->FirstChildElement("Animation"); child;
+           child = child->NextSiblingElement("Animation"))
+      {
+        if ((this->flags & DEFAULT_ANIMATION_ONLY) != 0)
+        {
+          std::string name{};
+          query_string_attribute(child, "Name", &name);
+          if (name == defaultAnimation)
+          {
+            animations.emplace_back(parse_animation(child));
+            break;
+          }
+        }
+        else
+          animations.emplace_back(parse_animation(child));
+      }
+
+      for (int i = 0; i < (int)animations.size(); i++)
+      {
+        auto& animation = animations[i];
+        animationMap[animation.name] = i;
+        animationMapReverse[i] = animation.name;
+      }
+
+      if (animationMap.contains(defaultAnimation))
+        defaultAnimationID = animationMap[defaultAnimation];
+      else
+        defaultAnimationID = -1;
+    }
+
+    isValid = true;
+  }
+
+  Anm2::Anm2(const std::filesystem::path& path, Flags anm2Flags)
+  {
+    XMLDocument document;
+    auto pathString = path.string();
+
+    if (document.LoadFile(pathString.c_str()) != XML_SUCCESS)
+    {
+      logger.error(std::format("Failed to initialize anm2: {} ({})", pathString, document.ErrorStr()));
+      isValid = false;
+      return;
+    }
+
+    WorkingDirectory workingDirectory(path, WorkingDirectory::FILE);
+
+    this->path = path.string();
+
+    init(document, anm2Flags);
+
+    logger.info(std::format("Initialized anm2: {}", pathString));
+  }
+
+  Anm2::Anm2(const physfs::Path& path, Flags anm2Flags)
+  {
+    XMLDocument document;
+
+    if (document_load(path, document) != XML_SUCCESS)
+    {
+      isValid = false;
+      return;
+    }
+
+    this->path = path;
+    init(document, anm2Flags, path.directory_get());
+
+    logger.info(std::format("Initialized anm2: {}", path.c_str()));
+  }
+
+  bool Anm2::is_valid() const { return isValid; }
+
+  int Anm2::item_length(const Item* item)
+  {
+    if (!item) return -1;
+
+    int duration{};
+    for (auto& frame : item->frames)
+      duration += frame.duration;
+    return duration;
+  }
+
+  float Anm2::interpolation_apply(Frame::Interpolation interpolation, float value)
+  {
+    value = glm::clamp(value, 0.0f, 1.0f);
+
+    switch (interpolation)
+    {
+      case Frame::LINEAR:
+        return value;
+      case Frame::EASE_IN:
+        return value * value;
+      case Frame::EASE_OUT:
+        return 1.0f - ((1.0f - value) * (1.0f - value));
+      case Frame::EASE_IN_OUT:
+        return value * value * (3.0f - 2.0f * value);
+      case Frame::INTERPOLATION_NONE:
+      default:
+        return 0.0f;
+    }
+  }
+
+  Anm2::Frame Anm2::frame_generate(Item& item, float frameTime, Type type, int id,
+                                   const std::function<void(Frame&, Type, int)>& frameOverride)
+  {
+    Frame frame{};
+    frame.isVisible = false;
+
+    if (item.frames.empty()) return frame;
+
+    frameTime = frameTime < 0.0f ? 0.0f : frameTime;
+
+    Frame* frameNext = nullptr;
+    Frame frameNextCopy{};
+    int durationCurrent = 0;
+    int durationNext = 0;
+
+    for (int i = 0; i < (int)item.frames.size(); i++)
+    {
+      Frame& checkFrame = item.frames[i];
+
+      frame = checkFrame;
+      durationNext += frame.duration;
+
+      if (frameTime >= durationCurrent && frameTime < durationNext)
+      {
+        if (i + 1 < (int)item.frames.size())
+        {
+          frameNext = &item.frames[i + 1];
+          frameNextCopy = *frameNext;
+        }
+        else
+          frameNext = nullptr;
+        break;
+      }
+
+      durationCurrent += frame.duration;
+    }
+
+    if (frameOverride)
+    {
+      frameOverride(frame, type, id);
+      if (frameNext) frameOverride(frameNextCopy, type, id);
+    }
+
+    if (frame.interpolation != Frame::INTERPOLATION_NONE && frameNext && frame.duration > 1)
+    {
+      auto interpolation =
+          interpolation_apply(frame.interpolation, (frameTime - durationCurrent) / (durationNext - durationCurrent));
+
+      frame.rotation = glm::mix(frame.rotation, frameNextCopy.rotation, interpolation);
+      frame.position = glm::mix(frame.position, frameNextCopy.position, interpolation);
+      frame.scale = glm::mix(frame.scale, frameNextCopy.scale, interpolation);
+      frame.colorOffset = glm::mix(frame.colorOffset, frameNextCopy.colorOffset, interpolation);
+      frame.tint = glm::mix(frame.tint, frameNextCopy.tint, interpolation);
+    }
+
+    return frame;
+  }
+}
diff --git a/src/resource/xml/anm2.hpp b/src/resource/anm2.hpp
similarity index 66%
rename from src/resource/xml/anm2.hpp
rename to src/resource/anm2.hpp
index 3af7ff4..6526d10 100644
--- a/src/resource/xml/anm2.hpp
+++ b/src/resource/anm2.hpp
@@ -1,20 +1,22 @@
 #pragma once
 
+#include <functional>
 #include <optional>
 #include <tinyxml2/tinyxml2.h>
 
 #include <filesystem>
 #include <map>
+#include <string_view>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include <glm/glm.hpp>
 
-#include "../audio.hpp"
-#include "../texture.hpp"
+#include "audio.hpp"
+#include "texture.hpp"
 
-#include "../../util/physfs.hpp"
+#include "../util/physfs.hpp"
 
 namespace game::resource::xml
 {
@@ -39,6 +41,82 @@ namespace game::resource::xml
 
     using Flags = int;
 
+    struct Element
+    {
+      enum Type
+      {
+        UNKNOWN,
+        ACTOR,
+        INFO,
+        CONTENT,
+        SPRITESHEETS,
+        SPRITESHEET,
+        REGION,
+        LAYERS,
+        LAYER_ELEMENT,
+        NULLS,
+        NULL_ELEMENT,
+        EVENTS,
+        EVENT,
+        SOUNDS,
+        SOUND_ELEMENT,
+        ANIMATIONS,
+        ANIMATION,
+        ROOT_ANIMATION,
+        LAYER_ANIMATIONS,
+        LAYER_ANIMATION,
+        NULL_ANIMATIONS,
+        NULL_ANIMATION,
+        GROUP,
+        TRIGGERS,
+        TRIGGER_ELEMENT,
+        FRAME,
+        TYPE_COUNT
+      };
+
+      Type type{UNKNOWN};
+      std::vector<Element> children{};
+
+      std::string createdBy{};
+      std::string createdOn{};
+      std::string defaultAnimation{};
+      std::string name{};
+      std::string path{};
+
+      int id{-1};
+      int layerID{-1};
+      int nullID{-1};
+      int spritesheetID{-1};
+      int eventID{-1};
+      int regionID{-1};
+      int groupID{-1};
+      int atFrame{-1};
+      int frameNum{};
+      int fps{30};
+      int version{};
+      int delay{1};
+
+      glm::vec2 crop{};
+      glm::vec2 position{};
+      glm::vec2 pivot{};
+      glm::vec2 size{};
+      glm::vec2 scale{100.0f, 100.0f};
+      float rotation{};
+      glm::vec4 tint{1.0f, 1.0f, 1.0f, 1.0f};
+      glm::vec3 colorOffset{};
+
+      bool isVisible{true};
+      bool isShowRect{};
+      bool isLoop{};
+      bool isExpanded{true};
+
+      Element* child_get(Type, std::size_t index = 0);
+      const Element* child_get(Type, std::size_t index = 0) const;
+      std::vector<Element*> children_get(Type);
+      std::vector<const Element*> children_get(Type) const;
+      static Type type_get(std::string_view);
+    };
+
     struct Spritesheet
     {
       struct Region
@@ -89,16 +167,26 @@ namespace game::resource::xml
 
     struct Frame
     {
+      enum Interpolation
+      {
+        INTERPOLATION_NONE,
+        LINEAR,
+        EASE_IN,
+        EASE_OUT,
+        EASE_IN_OUT
+      };
+
       glm::vec2 crop{};
       glm::vec2 position{};
       glm::vec2 pivot{};
       glm::vec2 size{};
       glm::vec2 scale{100, 100};
       float rotation{};
-      int duration{};
+      int duration{1};
       glm::vec4 tint{1.0f, 1.0f, 1.0f, 1.0f};
       glm::vec3 colorOffset{};
       bool isInterpolated{};
+      Interpolation interpolation{INTERPOLATION_NONE};
       int eventID{-1};
       int regionID{-1};
       std::vector<int> soundIDs{};
@@ -169,6 +257,7 @@ namespace game::resource::xml
       Vec4 tint{};
       Vec3 colorOffset{};
       std::optional<bool> isInterpolated{};
+      std::optional<Frame::Interpolation> interpolation{};
       std::optional<bool> isVisible{};
     };
 
@@ -211,6 +300,7 @@ namespace game::resource::xml
     std::string path{};
     bool isValid{};
     Flags flags{};
+    Element root{};
 
     Anm2() = default;
     Anm2(const Anm2&);
@@ -221,6 +311,10 @@ namespace game::resource::xml
     Anm2(const util::physfs::Path&, Flags = 0);
 
     bool is_valid() const;
+    static int item_length(const Item*);
+    static float interpolation_apply(Frame::Interpolation, float);
+    static Frame frame_generate(Item&, float, Type = NONE, int id = -1,
+                                const std::function<void(Frame&, Type, int)>& = {});
 
   private:
     void init(tinyxml2::XMLDocument& document, Flags anm2Flags, const util::physfs::Path& archive = {});
diff --git a/src/resource/audio.cpp b/src/resource/audio.cpp
index 53bdf5a..91f6b2c 100644
--- a/src/resource/audio.cpp
+++ b/src/resource/audio.cpp
@@ -47,8 +47,19 @@ namespace game::resource
 
   void Audio::volume_set(float volume)
   {
-    auto mixer = mixer_get();
-    MIX_SetMasterGain(mixer, volume);
+    Audio::volume = volume;
+    gain_apply();
+  }
+
+  void Audio::mute_set(bool isMuted)
+  {
+    Audio::isMuted = isMuted;
+    gain_apply();
+  }
+
+  void Audio::gain_apply()
+  {
+    MIX_SetMasterGain(mixer_get(), isMuted ? 0.0f : volume);
   }
 
   Audio::Audio(const std::filesystem::path& path)
@@ -66,7 +77,7 @@ namespace game::resource
     cache_set(key, internal);
     if (internal) logger.info(std::format("Initialized audio: {}", pathString));
 
-    if (!internal) logger.info(std::format("Failed to intialize audio: {} ({})", pathString, SDL_GetError()));
+    if (!internal) logger.error(std::format("Failed to initialize audio: {} ({})", pathString, SDL_GetError()));
   }
 
   Audio::Audio(const physfs::Path& path)
@@ -102,7 +113,7 @@ namespace game::resource
     if (internal)
       logger.info(std::format("Initialized audio: {}", path.c_str()));
     else
-      logger.info(std::format("Failed to intialize audio: {} ({})", path.c_str(), SDL_GetError()));
+      logger.error(std::format("Failed to initialize audio: {} ({})", path.c_str(), SDL_GetError()));
   }
 
   Audio::Audio(const Audio& other)
diff --git a/src/resource/audio.hpp b/src/resource/audio.hpp
index b1d99cd..aadb8b9 100644
--- a/src/resource/audio.hpp
+++ b/src/resource/audio.hpp
@@ -11,10 +11,13 @@ namespace game::resource
   class Audio
   {
     static MIX_Mixer* mixer_get();
+    static void gain_apply();
     void unload();
 
     std::shared_ptr<MIX_Audio> internal{};
     mutable MIX_Track* track{nullptr};
+    static inline float volume{1.0f};
+    static inline bool isMuted{};
 
   public:
     Audio() = default;
@@ -30,5 +33,6 @@ namespace game::resource
     void stop() const;
     bool is_playing() const;
     static void volume_set(float volume);
+    static void mute_set(bool isMuted);
   };
 }
diff --git a/src/resource/character.cpp b/src/resource/character.cpp
new file mode 100644
index 0000000..94c7a2d
--- /dev/null
+++ b/src/resource/character.cpp
@@ -0,0 +1,226 @@
+#include "character.hpp"
+
+#include "../log.hpp"
+#include "../util/preferences.hpp"
+
+#include <format>
+
+using namespace game::util;
+
+namespace game::resource::xml
+{
+  const Schema::Element* interact_area_default_get(const Character& character, const Schema::Element& area)
+  {
+    if (area.type != Schema::Element::INTERACT_AREA || area.typeString.empty() || area.null.empty()) return nullptr;
+    auto* rootElement = character.root();
+    auto* areas = rootElement ? character.schema.child_get(*rootElement, Schema::Element::INTERACT_AREA_TYPES) : nullptr;
+    if (!areas) return nullptr;
+    for (auto* candidate : character.schema.children_get(*areas, Schema::Element::INTERACT_AREA))
+      if (candidate && candidate->typeString == area.typeString) return candidate;
+    return nullptr;
+  }
+
+  int map_id_get(const std::unordered_map<std::string, int>& map, const std::string& name)
+  {
+    auto it = map.find(name);
+    return it == map.end() ? -1 : it->second;
+  }
+
+  Character::Character(const std::filesystem::path& path)
+  {
+    physfs::Archive archive(path, path.filename().string());
+
+    if (!archive.is_valid())
+    {
+      logger.error(std::format("Failed to initialize character from PhysicsFS archive: {} ({})", path.string(),
+                               physfs::error_get()));
+      return;
+    }
+
+    physfs::Path characterPath(archive + "/" + "character.xml");
+
+    if (!characterPath.is_valid()) return;
+
+    schema = Schema(characterPath);
+    auto* root = schema.root();
+    if (root)
+    {
+      auto dialoguePath = physfs::Path(archive + "/" + "dialogue.xml");
+
+      if (!dialoguePath.is_valid())
+        logger.warning(std::format("No character dialogue.xml file found: {}", path.string()));
+      else
+        dialogue = Schema(dialoguePath);
+    }
+
+    if (auto itemSchemaPath = physfs::Path(archive + "/" + "items.xml"); itemSchemaPath.is_valid())
+      itemSchema = Schema(itemSchemaPath);
+    else
+      logger.warning(std::format("No character items.xml file found: {}", path.string()));
+
+    if (auto areaSchemaPath = physfs::Path(archive + "/" + "areas.xml"); areaSchemaPath.is_valid())
+      areaSchema = Schema(areaSchemaPath);
+    else
+      logger.warning(std::format("No character areas.xml file found: {}", path.string()));
+
+    if (auto menuSchemaPath = physfs::Path(archive + "/" + "menu.xml"); menuSchemaPath.is_valid())
+      menuSchema = Schema(menuSchemaPath);
+    else
+      logger.warning(std::format("No character menu.xml file found: {}", path.string()));
+
+    if (auto cursorSchemaPath = physfs::Path(archive + "/" + "cursor.xml"); cursorSchemaPath.is_valid())
+      cursorSchema = Schema(cursorSchemaPath);
+    else
+      logger.warning(std::format("No character cursor.xml file found: {}", path.string()));
+
+    if (auto particleSchemaPath = physfs::Path(archive + "/" + "particles.xml"); particleSchemaPath.is_valid())
+      particleSchema = Schema(particleSchemaPath);
+    else
+      logger.warning(std::format("No character particles.xml file found: {}", path.string()));
+
+    if (auto stringsPath = physfs::Path(archive + "/" + "strings.xml"); stringsPath.is_valid())
+      strings = Strings(stringsPath);
+
+    logger.info(std::format("Initialized character: {}", root ? root->name : ""));
+
+    this->path = path;
+    save = Schema(save_path_get());
+  }
+
+  Schema::Element* Character::root() { return schema.root(); }
+  const Schema::Element* Character::root() const { return schema.root(); }
+  Schema::Element* Character::alternate_spritesheet()
+  {
+    auto* rootElement = root();
+    return rootElement ? schema.child_get(*rootElement, Schema::Element::ALTERNATE_SPRITESHEET) : nullptr;
+  }
+  const Schema::Element* Character::alternate_spritesheet() const
+  {
+    auto* rootElement = root();
+    return rootElement ? schema.child_get(*rootElement, Schema::Element::ALTERNATE_SPRITESHEET) : nullptr;
+  }
+
+  const Schema::Element* Character::animations_root() const
+  {
+    auto* rootElement = root();
+    return rootElement ? schema.child_get(*rootElement, Schema::Element::ANIMATIONS) : nullptr;
+  }
+
+  const Schema::Element* Character::overrides_root() const
+  {
+    auto* rootElement = root();
+    return rootElement ? schema.child_get(*rootElement, Schema::Element::ANIMATION_OVERRIDES) : nullptr;
+  }
+
+  const Schema::Element* Character::child_get(const Schema::Element& element, Schema::Element::Type type, int index) const
+  {
+    return schema.child_get(element, type, index);
+  }
+
+  std::vector<const Schema::Element*> Character::children_get(const Schema::Element& element,
+                                                              Schema::Element::Type type) const
+  {
+    auto result = schema.children_get(element, type);
+    if (type != Schema::Element::PARTICLE || !result.empty()) return result;
+    auto* defaults = interact_area_default_get(*this, element);
+    if (!defaults) return result;
+    return schema.children_get(*defaults, type);
+  }
+
+  std::vector<const Schema::Element*> Character::stages_get() const
+  {
+    auto* rootElement = root();
+    auto* stages = rootElement ? schema.child_get(*rootElement, Schema::Element::STAGES) : nullptr;
+    return stages ? schema.children_get(*stages, Schema::Element::STAGE) : std::vector<const Schema::Element*>{};
+  }
+
+  int Character::stage_count_get() const { return (int)stages_get().size() + 1; }
+
+  std::vector<const Schema::Element*> Character::expand_areas_get() const
+  {
+    auto* rootElement = root();
+    auto* areas = rootElement ? schema.child_get(*rootElement, Schema::Element::EXPAND_AREAS) : nullptr;
+    return areas ? schema.children_get(*areas, Schema::Element::EXPAND_AREA) : std::vector<const Schema::Element*>{};
+  }
+
+  std::vector<const Schema::Element*> Character::eat_areas_get() const
+  {
+    auto* rootElement = root();
+    auto* areas = rootElement ? schema.child_get(*rootElement, Schema::Element::EAT_AREAS) : nullptr;
+    return areas ? schema.children_get(*areas, Schema::Element::EAT_AREA) : std::vector<const Schema::Element*>{};
+  }
+
+  std::vector<const Schema::Element*> Character::interact_area_types_get() const
+  {
+    auto* rootElement = root();
+    auto* areas = rootElement ? schema.child_get(*rootElement, Schema::Element::INTERACT_AREA_TYPES) : nullptr;
+    return areas ? schema.children_get(*areas, Schema::Element::INTERACT_AREA) : std::vector<const Schema::Element*>{};
+  }
+
+  std::vector<const Schema::Element*> Character::interact_areas_get() const
+  {
+    auto* rootElement = root();
+    auto* areas = rootElement ? schema.child_get(*rootElement, Schema::Element::INTERACT_AREAS) : nullptr;
+    return areas ? schema.children_get(*areas, Schema::Element::INTERACT_AREA) : std::vector<const Schema::Element*>{};
+  }
+
+  std::vector<std::string> Character::interact_type_names_get() const
+  {
+    std::vector<std::string> names{};
+    for (auto* area : interact_area_types_get())
+    {
+      if (!area || area->typeString.empty()) continue;
+      if (std::ranges::find(names, area->typeString) == names.end()) names.push_back(area->typeString);
+    }
+    return names;
+  }
+
+  std::string Character::animation_get(Schema::Element::Type type) const
+  {
+    auto* animations = animations_root();
+    auto* animation = animations ? schema.child_get(*animations, type) : nullptr;
+    return animation ? animation->animation : "";
+  }
+
+  int Character::dialogue_pool_id_get(const std::string& poolID) const
+  {
+    return poolID.empty() ? -1 : dialogue.dialogue_pool_id_get(poolID);
+  }
+
+  int Character::layer_id_get(const std::string& name) const
+  {
+    return root() ? map_id_get(root()->anm2Entry.anm2.layerMap, name) : -1;
+  }
+  int Character::null_id_get(const std::string& name) const
+  {
+    return root() ? map_id_get(root()->anm2Entry.anm2.nullMap, name) : -1;
+  }
+  int Character::event_id_get(const std::string& name) const
+  {
+    return root() ? map_id_get(root()->anm2Entry.anm2.eventMap, name) : -1;
+  }
+
+  int Character::interact_type_id_get(const std::string& name) const
+  {
+    auto names = interact_type_names_get();
+    for (int i = 0; i < (int)names.size(); i++)
+      if (names[i] == name) return i;
+    return -1;
+  }
+
+  int Character::stage_pool_id_get(int stage) const
+  {
+    if (stage <= 0) return dialogue_pool_id_get(root() ? root()->dialoguePoolID : "");
+    auto stages = stages_get();
+    auto index = stage - 1;
+    return index >= 0 && index < (int)stages.size() ? dialogue_pool_id_get(stages[index]->dialoguePoolID) : -1;
+  }
+
+  std::filesystem::path Character::save_path_get()
+  {
+    auto savePath = path.stem();
+    savePath = preferences::path() / "saves" / savePath.replace_extension(".save");
+    std::filesystem::create_directories(savePath.parent_path());
+    return savePath;
+  }
+}
diff --git a/src/resource/character.hpp b/src/resource/character.hpp
new file mode 100644
index 0000000..cb919b2
--- /dev/null
+++ b/src/resource/character.hpp
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <filesystem>
+#include <string>
+#include <vector>
+
+#include "schema.hpp"
+#include "strings.hpp"
+
+namespace game::resource::xml
+{
+  class Character
+  {
+  public:
+    Schema schema{};
+    Schema areaSchema{};
+    Schema dialogue{};
+    Schema itemSchema{};
+    Schema menuSchema{};
+    Schema cursorSchema{};
+    Schema particleSchema{};
+    Strings strings{};
+
+    Schema save{};
+
+    std::filesystem::path path{};
+
+    Character() = default;
+    Character(const std::filesystem::path&);
+    Schema::Element* root();
+    const Schema::Element* root() const;
+    Schema::Element* alternate_spritesheet();
+    const Schema::Element* alternate_spritesheet() const;
+    const Schema::Element* animations_root() const;
+    const Schema::Element* overrides_root() const;
+    const Schema::Element* child_get(const Schema::Element&, Schema::Element::Type type, int index = 0) const;
+    std::vector<const Schema::Element*> children_get(const Schema::Element&, Schema::Element::Type type) const;
+    std::vector<const Schema::Element*> stages_get() const;
+    int stage_count_get() const;
+    std::vector<const Schema::Element*> expand_areas_get() const;
+    std::vector<const Schema::Element*> eat_areas_get() const;
+    std::vector<const Schema::Element*> interact_area_types_get() const;
+    std::vector<const Schema::Element*> interact_areas_get() const;
+    std::vector<std::string> interact_type_names_get() const;
+    std::string animation_get(Schema::Element::Type type) const;
+    int dialogue_pool_id_get(const std::string& poolID) const;
+    int layer_id_get(const std::string&) const;
+    int null_id_get(const std::string&) const;
+    int event_id_get(const std::string&) const;
+    int interact_type_id_get(const std::string&) const;
+    int stage_pool_id_get(int stage) const;
+    std::filesystem::path save_path_get();
+  };
+}
diff --git a/src/resource/font.cpp b/src/resource/font.cpp
index c393fd8..39f8d5a 100644
--- a/src/resource/font.cpp
+++ b/src/resource/font.cpp
@@ -39,7 +39,10 @@ namespace game::resource
     internal = ImGui::GetIO().Fonts->AddFontFromFileTTF(pathString.c_str(), size, &config);
 
     if (internal)
+    {
+      valid = true;
       logger.info(std::format("Initialized font: {}", pathString));
+    }
     else
     {
       logger.error(std::format("Failed to initialize font: {}", pathString));
@@ -96,7 +99,10 @@ namespace game::resource
     internal = ImGui::GetIO().Fonts->AddFontFromMemoryTTF(buffer.data(), (int)buffer.size(), size, &config);
 
     if (internal)
+    {
+      valid = true;
       logger.info(std::format("Initialized font: {}", path.c_str()));
+    }
     else
     {
       logger.error(std::format("Failed to initialize font: {}", path.c_str()));
@@ -109,4 +115,6 @@ namespace game::resource
   }
 
   ImFont* Font::get() { return internal; };
+
+  bool Font::is_valid() const { return valid; }
 }
diff --git a/src/resource/font.hpp b/src/resource/font.hpp
index ceb31e7..35da167 100644
--- a/src/resource/font.hpp
+++ b/src/resource/font.hpp
@@ -11,16 +11,19 @@ namespace game::resource
   class Font
   {
     ImFont* internal{};
+    bool valid{};
 
   public:
+    static constexpr auto SMALL = 16;
     static constexpr auto NORMAL = 20;
-    static constexpr auto HEADER_1 = 24;
+    static constexpr auto HEADER_1 = 40;
     static constexpr auto HEADER_2 = 30;
-    static constexpr auto HEADER_3 = 40;
+    static constexpr auto HEADER_3 = 24;
 
     Font() = default;
     Font(const std::filesystem::path&, float = NORMAL);
     Font(const util::physfs::Path&, float = NORMAL);
     ImFont* get();
+    bool is_valid() const;
   };
 }
diff --git a/src/resource/schema.cpp b/src/resource/schema.cpp
new file mode 100644
index 0000000..5bec003
--- /dev/null
+++ b/src/resource/schema.cpp
@@ -0,0 +1,1438 @@
+#include "schema.hpp"
+
+#include "../log.hpp"
+#include "../util/string.hpp"
+#include "../util/vector.hpp"
+
+#include <algorithm>
+#include <filesystem>
+#include <format>
+#include <string_view>
+#include <tinyxml2/tinyxml2.h>
+
+using namespace tinyxml2;
+
+namespace game::resource::xml
+{
+  std::string* Schema::AnimationEntryCollection::get()
+  {
+    if (empty()) return nullptr;
+    return &at(util::vector::random_index_weighted(*this, [](const auto& entry) { return entry.weight; })).animation;
+  }
+
+  const Audio* Schema::SoundEntryCollection::get() const
+  {
+    if (empty()) return nullptr;
+    auto index =
+        util::vector::random_index_weighted(*this, [](const auto* entry) { return entry ? entry->weight : 0.0f; });
+    return index < 0 || !at(index) ? nullptr : &at(index)->sound;
+  }
+
+  void Schema::SoundEntryCollection::play() const
+  {
+    if (empty()) return;
+    auto audio = get();
+    if (!audio) return;
+
+    for (auto* entry : *this)
+      if (entry && &entry->sound != audio) entry->sound.stop();
+
+    audio->play();
+  }
+
+  namespace
+  {
+    XMLError query_result_merge(XMLError result, XMLError next) { return result == XML_SUCCESS ? next : result; }
+
+    XMLError document_load(const util::physfs::Path& path, XMLDocument& document)
+    {
+      if (!path.is_valid())
+      {
+        logger.error(std::format("Failed to open XML document: {} ({})", path.c_str(), util::physfs::error_get()));
+        return XML_ERROR_FILE_NOT_FOUND;
+      }
+
+      auto buffer = path.read();
+
+      if (buffer.empty())
+      {
+        logger.error(std::format("Failed to read XML document: {} ({})", path.c_str(), util::physfs::error_get()));
+        return XML_ERROR_FILE_COULD_NOT_BE_OPENED;
+      }
+
+      auto result = document.Parse((const char*)buffer.data(), buffer.size());
+      if (result != XML_SUCCESS)
+        logger.error(std::format("Failed to parse XML document: {} ({})", path.c_str(), document.ErrorStr()));
+
+      return result;
+    }
+
+    XMLError query_color_attribute(XMLElement* element, const char* attribute, float* value)
+    {
+      int temp{};
+      auto result = element->QueryIntAttribute(attribute, &temp);
+      if (result == XML_SUCCESS && value) *value = (temp / 255.0f);
+      return result;
+    }
+
+    XMLError query_ivec2(XMLElement* element, const char* attributeX, const char* attributeY, glm::ivec2& value)
+    {
+      auto result = element->QueryIntAttribute(attributeX, &value.x);
+      result = query_result_merge(result, element->QueryIntAttribute(attributeY, &value.y));
+      return result;
+    }
+
+    XMLError query_vec2(XMLElement* element, const char* attributeX, const char* attributeY, glm::vec2& value)
+    {
+      auto result = element->QueryFloatAttribute(attributeX, &value.x);
+      result = query_result_merge(result, element->QueryFloatAttribute(attributeY, &value.y));
+      return result;
+    }
+
+    XMLError query_vec3(XMLElement* element, const char* attributeX, const char* attributeY, const char* attributeZ,
+                        glm::vec3& value)
+    {
+      auto result = element->QueryFloatAttribute(attributeX, &value.x);
+      result = query_result_merge(result, element->QueryFloatAttribute(attributeY, &value.y));
+      result = query_result_merge(result, element->QueryFloatAttribute(attributeZ, &value.z));
+      return result;
+    }
+
+    XMLError set_ivec2_attribute(XMLElement* element, const char* attributeX, const char* attributeY,
+                                 const glm::ivec2& value)
+    {
+      element->SetAttribute(attributeX, value.x);
+      element->SetAttribute(attributeY, value.y);
+      return XML_SUCCESS;
+    }
+
+    XMLError set_vec2_attribute(XMLElement* element, const char* attributeX, const char* attributeY,
+                                const glm::vec2& value)
+    {
+      element->SetAttribute(attributeX, value.x);
+      element->SetAttribute(attributeY, value.y);
+      return XML_SUCCESS;
+    }
+
+    XMLError set_vec3_attribute(XMLElement* element, const char* attributeX, const char* attributeY,
+                                const char* attributeZ, const glm::vec3& value)
+    {
+      element->SetAttribute(attributeX, value.x);
+      element->SetAttribute(attributeY, value.y);
+      element->SetAttribute(attributeZ, value.z);
+      return XML_SUCCESS;
+    }
+
+    struct TypeName
+    {
+      std::string_view name{};
+      Schema::Element::Type type{};
+    };
+
+    constexpr auto UPDATES_PER_SECOND = 60.0f;
+
+#define GAME_SCHEMA_DIALOGUE_EFFECT_TYPES(X)                                                                          \
+  X(Animation)                                                                                                         \
+  X(Big)                                                                                                               \
+  X(Color)                                                                                                             \
+  X(Delay)                                                                                                             \
+  X(Oscillation)                                                                                                       \
+  X(Screenshake)                                                                                                       \
+  X(Shake)                                                                                                             \
+  X(Small)                                                                                                             \
+  X(Sound)
+
+    constexpr TypeName TYPE_MAP[]{
+#define GAME_SCHEMA_ELEMENT_TYPE_NAME(NAME, ENUM) {#NAME, Schema::Element::ENUM},
+        GAME_SCHEMA_ELEMENT_TYPES(GAME_SCHEMA_ELEMENT_TYPE_NAME)
+#undef GAME_SCHEMA_ELEMENT_TYPE_NAME
+    };
+
+    Schema::Element::Type type_get(const char* name)
+    {
+      if (!name) return Schema::Element::UNKNOWN;
+      auto view = std::string_view{name};
+      for (auto [mappedName, mappedType] : TYPE_MAP)
+        if (mappedName == view) return mappedType;
+      return Schema::Element::UNKNOWN;
+    }
+
+    bool dialogue_effect_name_is(std::string_view name)
+    {
+#define GAME_SCHEMA_DIALOGUE_EFFECT_NAME_MATCH(NAME)                                                                   \
+  if (name == #NAME) return true;
+      GAME_SCHEMA_DIALOGUE_EFFECT_TYPES(GAME_SCHEMA_DIALOGUE_EFFECT_NAME_MATCH)
+#undef GAME_SCHEMA_DIALOGUE_EFFECT_NAME_MATCH
+      return false;
+    }
+#undef GAME_SCHEMA_DIALOGUE_EFFECT_TYPES
+
+    const char* attribute_symbol_get(std::string_view name)
+    {
+#define GAME_SCHEMA_ATTRIBUTE_SYMBOL_MATCH(KIND, KEY, KEY_2, KEY_3, MEMBER)                                            \
+  if (name == KEY || (std::string_view{KEY_2}.size() > 0 && name == KEY_2) ||                                          \
+      (std::string_view{KEY_3}.size() > 0 && name == KEY_3))                                                           \
+    return #MEMBER;
+      GAME_SCHEMA_ELEMENT_ATTRIBUTES(GAME_SCHEMA_ATTRIBUTE_SYMBOL_MATCH)
+#undef GAME_SCHEMA_ATTRIBUTE_SYMBOL_MATCH
+      return nullptr;
+    }
+
+    void attribute_order_read(XMLElement* xml, Schema::Element& element)
+    {
+      element.attributeOrder.clear();
+      for (auto* attribute = xml->FirstAttribute(); attribute; attribute = attribute->Next())
+      {
+        auto* symbol = attribute_symbol_get(attribute->Name());
+        if (!symbol) continue;
+        if (std::ranges::find(element.attributeOrder, symbol) == element.attributeOrder.end())
+          element.attributeOrder.emplace_back(symbol);
+      }
+    }
+
+    void query_string(XMLElement* xml, const char* attribute, std::string& value)
+    {
+      const char* result = nullptr;
+      if (xml->QueryStringAttribute(attribute, &result) == XML_SUCCESS && result) value = result;
+    }
+
+    void query_bool(XMLElement* xml, const char* attribute, bool& value)
+    {
+      if (!xml->FindAttribute(attribute)) return;
+      std::string text{};
+      query_string(xml, attribute, text);
+      text = util::string::to_lower(text);
+      value = text == "true" || text == "1";
+    }
+
+    std::string path_join(std::string base, const std::string& child)
+    {
+      if (base.empty()) return child;
+      if (child.empty()) return base;
+      if (base.back() != '/') base.push_back('/');
+      base += child;
+      return base;
+    }
+
+    std::string path_join(std::string archive, const std::string& rootPath, const std::string& child)
+    {
+      if (!rootPath.empty()) archive = path_join(std::move(archive), rootPath);
+      return path_join(std::move(archive), child);
+    }
+
+    struct Context
+    {
+      std::string archive{};
+      std::filesystem::path filesystemBase{};
+      std::string anm2RootPath{};
+      std::string textureRootPath{};
+      std::string soundRootPath{};
+      std::string fontRootPath{};
+      Schema::Anm2Entry baseAnm2{};
+      int itemSpritesheetID{};
+      bool isDialogue{};
+    };
+
+    std::string resource_path_get(const Context& context, const std::string& rootPath, const std::string& path)
+    {
+      auto value = std::filesystem::path(path);
+      if (value.is_absolute()) return value.string();
+
+      auto root = std::filesystem::path(rootPath);
+      auto pathIt = value.begin();
+      auto rootIt = root.begin();
+      while (rootIt != root.end() && pathIt != value.end() && *rootIt == *pathIt)
+      {
+        ++rootIt;
+        ++pathIt;
+      }
+      auto alreadyIncludesRoot = rootIt == root.end();
+
+      if (!context.archive.empty())
+        return alreadyIncludesRoot ? path_join(context.archive, path) : path_join(context.archive, rootPath, path);
+      return (context.filesystemBase / (alreadyIncludesRoot ? value : root / value)).string();
+    }
+
+    bool relative_path_is_local(const std::filesystem::path& path)
+    {
+      if (path.empty() || path.is_absolute()) return false;
+      for (auto& part : path)
+        if (part == "..") return false;
+      return true;
+    }
+
+    std::filesystem::path root_prefix_strip(const std::filesystem::path& rootPath, const std::filesystem::path& path)
+    {
+      if (rootPath.empty()) return path;
+
+      auto root = rootPath.lexically_normal();
+      auto value = path.lexically_normal();
+      auto rootIt = root.begin();
+      auto valueIt = value.begin();
+      while (rootIt != root.end() && valueIt != value.end() && *rootIt == *valueIt)
+      {
+        ++rootIt;
+        ++valueIt;
+      }
+      if (rootIt != root.end()) return path;
+
+      std::filesystem::path result{};
+      for (; valueIt != value.end(); ++valueIt)
+        result /= *valueIt;
+      return result.empty() ? path : result;
+    }
+
+    std::string resource_source_path_get(const Context& context, const std::string& rootPath, const std::string& path)
+    {
+      if (path.empty()) return {};
+
+      auto value = std::filesystem::path(path).lexically_normal();
+      auto root = std::filesystem::path(rootPath).lexically_normal();
+      if (!value.is_absolute()) return root_prefix_strip(root, value).generic_string();
+
+      if (!context.filesystemBase.empty())
+      {
+        std::error_code error{};
+        auto base = root.empty() ? context.filesystemBase : context.filesystemBase / root;
+        auto relative = std::filesystem::relative(value, base, error);
+        if (!error && relative_path_is_local(relative)) return relative.generic_string();
+
+        error.clear();
+        relative = std::filesystem::relative(value, context.filesystemBase, error);
+        if (!error && relative_path_is_local(relative)) return root_prefix_strip(root, relative).generic_string();
+      }
+
+      return value.generic_string();
+    }
+
+    Schema::TextureEntry query_texture_entry(const std::string& path, const Context& context)
+    {
+      Schema::TextureEntry texture{};
+      texture.path = resource_source_path_get(context, context.textureRootPath, path);
+      auto resolvedPath = resource_path_get(context, context.textureRootPath, texture.path);
+      texture.texture = context.archive.empty() ? Texture(resolvedPath) : Texture(util::physfs::Path(resolvedPath));
+      return texture;
+    }
+
+    Schema::SoundEntry query_sound_entry(const std::string& path, const Context& context)
+    {
+      Schema::SoundEntry sound{};
+      sound.path = resource_source_path_get(context, context.soundRootPath, path);
+      auto resolvedPath = resource_path_get(context, context.soundRootPath, sound.path);
+      sound.sound = context.archive.empty() ? Audio(resolvedPath) : Audio(util::physfs::Path(resolvedPath));
+      return sound;
+    }
+
+    Schema::FontEntry query_font_entry(const std::string& path, const Context& context)
+    {
+      Schema::FontEntry font{};
+      font.path = resource_source_path_get(context, context.fontRootPath, path);
+      auto resolvedPath = resource_path_get(context, context.fontRootPath, font.path);
+      font.font = context.archive.empty() ? Font(resolvedPath) : Font(util::physfs::Path(resolvedPath));
+      return font;
+    }
+
+    Schema::Anm2Entry query_anm2_entry(const std::string& path, const Context& context)
+    {
+      Schema::Anm2Entry anm2{};
+      auto rootPath = context.anm2RootPath.empty() ? context.textureRootPath : context.anm2RootPath;
+      anm2.path = resource_source_path_get(context, rootPath, path);
+      auto resolvedPath = resource_path_get(context, rootPath, anm2.path);
+      anm2.anm2 = context.archive.empty() ? Anm2(resolvedPath) : Anm2(util::physfs::Path(resolvedPath));
+      return anm2;
+    }
+
+    void parse_attributes(XMLElement* xml, Schema::Element& element, const Context& context)
+    {
+      Context resourceContext = context;
+
+#define GAME_SCHEMA_QUERY_ATTRIBUTE_STRING(KEY, KEY_2, KEY_3, MEMBER) query_string(xml, KEY, element.MEMBER);
+#define GAME_SCHEMA_QUERY_ATTRIBUTE_STRING_TARGET(KEY, KEY_2, KEY_3, MEMBER) query_string(xml, KEY, element.MEMBER);
+#define GAME_SCHEMA_QUERY_ATTRIBUTE_INT_RW(KEY, KEY_2, KEY_3, MEMBER) xml->QueryIntAttribute(KEY, &element.MEMBER);
+#define GAME_SCHEMA_QUERY_ATTRIBUTE_INT_RO(KEY, KEY_2, KEY_3, MEMBER) xml->QueryIntAttribute(KEY, &element.MEMBER);
+#define GAME_SCHEMA_QUERY_ATTRIBUTE_FLOAT(KEY, KEY_2, KEY_3, MEMBER) xml->QueryFloatAttribute(KEY, &element.MEMBER);
+#define GAME_SCHEMA_QUERY_ATTRIBUTE_FLOAT_PER_SECOND(KEY, KEY_2, KEY_3, MEMBER)                                       \
+  {                                                                                                                    \
+    float value{};                                                                                                     \
+    if (xml->QueryFloatAttribute(KEY, &value) == XML_SUCCESS) element.MEMBER = value / UPDATES_PER_SECOND;             \
+  }
+#define GAME_SCHEMA_QUERY_ATTRIBUTE_VEC2(KEY, KEY_2, KEY_3, MEMBER) query_vec2(xml, KEY, KEY_2, element.MEMBER);
+#define GAME_SCHEMA_QUERY_ATTRIBUTE_IVEC2(KEY, KEY_2, KEY_3, MEMBER) query_ivec2(xml, KEY, KEY_2, element.MEMBER);
+#define GAME_SCHEMA_QUERY_ATTRIBUTE_VEC3(KEY, KEY_2, KEY_3, MEMBER) query_vec3(xml, KEY, KEY_2, KEY_3, element.MEMBER);
+#define GAME_SCHEMA_QUERY_ATTRIBUTE_COLOR_RO(KEY, KEY_2, KEY_3, MEMBER)                                                \
+  query_color_attribute(xml, KEY, &element.MEMBER);
+#define GAME_SCHEMA_QUERY_ATTRIBUTE_BOOL(KEY, KEY_2, KEY_3, MEMBER) query_bool(xml, KEY, element.MEMBER);
+#define GAME_SCHEMA_QUERY_ATTRIBUTE_BOOL_FALSE(KEY, KEY_2, KEY_3, MEMBER) query_bool(xml, KEY, element.MEMBER);
+#define GAME_SCHEMA_QUERY_ATTRIBUTE(KIND, KEY, KEY_2, KEY_3, MEMBER)                                                   \
+  GAME_SCHEMA_QUERY_ATTRIBUTE_##KIND(KEY, KEY_2, KEY_3, MEMBER)
+      GAME_SCHEMA_ELEMENT_ATTRIBUTES(GAME_SCHEMA_QUERY_ATTRIBUTE)
+#undef GAME_SCHEMA_QUERY_ATTRIBUTE
+#undef GAME_SCHEMA_QUERY_ATTRIBUTE_BOOL_FALSE
+#undef GAME_SCHEMA_QUERY_ATTRIBUTE_BOOL
+#undef GAME_SCHEMA_QUERY_ATTRIBUTE_COLOR_RO
+#undef GAME_SCHEMA_QUERY_ATTRIBUTE_VEC3
+#undef GAME_SCHEMA_QUERY_ATTRIBUTE_IVEC2
+#undef GAME_SCHEMA_QUERY_ATTRIBUTE_VEC2
+#undef GAME_SCHEMA_QUERY_ATTRIBUTE_FLOAT_PER_SECOND
+#undef GAME_SCHEMA_QUERY_ATTRIBUTE_FLOAT
+#undef GAME_SCHEMA_QUERY_ATTRIBUTE_INT_RO
+#undef GAME_SCHEMA_QUERY_ATTRIBUTE_INT_RW
+#undef GAME_SCHEMA_QUERY_ATTRIBUTE_STRING_TARGET
+#undef GAME_SCHEMA_QUERY_ATTRIBUTE_STRING
+
+      if (element.type == Schema::Element::POOL_ENTRY) query_string(xml, "Entry", element.idString);
+
+      if (!element.textureRootPath.empty()) resourceContext.textureRootPath = element.textureRootPath;
+      if (!element.anm2RootPath.empty())
+        resourceContext.anm2RootPath = element.anm2RootPath;
+      else if (resourceContext.anm2RootPath.empty())
+        resourceContext.anm2RootPath = resourceContext.textureRootPath;
+      if (!element.soundRootPath.empty()) resourceContext.soundRootPath = element.soundRootPath;
+      if (!element.fontRootPath.empty()) resourceContext.fontRootPath = element.fontRootPath;
+
+      if (!element.texture.empty())
+        element.texture = resource_source_path_get(resourceContext, resourceContext.textureRootPath, element.texture);
+      if (!element.portrait.path.empty())
+        element.portrait.path =
+            resource_source_path_get(resourceContext, resourceContext.textureRootPath, element.portrait.path);
+      if (!element.render.path.empty())
+        element.render.path =
+            resource_source_path_get(resourceContext, resourceContext.textureRootPath, element.render.path);
+      if (!element.sound.empty())
+        element.sound = resource_source_path_get(resourceContext, resourceContext.soundRootPath, element.sound);
+      if (element.type == Schema::Element::SOUND && !element.path.empty())
+        element.path = resource_source_path_get(resourceContext, resourceContext.soundRootPath, element.path);
+      if (!element.font.empty())
+        element.font = resource_source_path_get(resourceContext, resourceContext.fontRootPath, element.font);
+      if (!element.iconsFont.empty())
+        element.iconsFont = resource_source_path_get(resourceContext, resourceContext.fontRootPath, element.iconsFont);
+      auto anm2RootPath =
+          resourceContext.anm2RootPath.empty() ? resourceContext.textureRootPath : resourceContext.anm2RootPath;
+      if (!element.baseAnm2.empty())
+        element.baseAnm2 = resource_source_path_get(resourceContext, anm2RootPath, element.baseAnm2);
+      if (!element.anm2.empty()) element.anm2 = resource_source_path_get(resourceContext, anm2RootPath, element.anm2);
+
+      if (!element.texture.empty()) element.textureEntry = query_texture_entry(element.texture, resourceContext);
+      if (!element.portrait.path.empty())
+        element.portrait = query_texture_entry(element.portrait.path, resourceContext);
+      if (!element.render.path.empty()) element.render = query_texture_entry(element.render.path, resourceContext);
+      if (!element.sound.empty()) element.soundEntry = query_sound_entry(element.sound, resourceContext);
+      if (element.type == Schema::Element::SOUND && !element.path.empty())
+        element.soundEntry = query_sound_entry(element.path, resourceContext);
+      if (!element.font.empty()) element.fontEntry = query_font_entry(element.font, resourceContext);
+      if (!element.iconsFont.empty()) element.iconsFontEntry = query_font_entry(element.iconsFont, resourceContext);
+      if (!element.baseAnm2.empty()) element.anm2Entry = query_anm2_entry(element.baseAnm2, resourceContext);
+      if (!element.anm2.empty()) element.anm2Entry = query_anm2_entry(element.anm2, resourceContext);
+      if (element.type == Schema::Element::ITEM && !element.anm2Entry.is_valid() && resourceContext.baseAnm2.is_valid())
+        element.anm2Entry = resourceContext.baseAnm2;
+      if (element.type == Schema::Element::ITEM && element.textureEntry.is_valid() &&
+          element.anm2Entry.anm2.spritesheets.contains(resourceContext.itemSpritesheetID))
+        element.anm2Entry.anm2.spritesheets.at(resourceContext.itemSpritesheetID).texture =
+            element.textureEntry.texture;
+    }
+
+    void parse_tree(XMLElement* xml, Schema& schema, int parent, Context context)
+    {
+      if (!xml) return;
+
+      Schema::Element element{};
+      auto name = std::string_view{xml->Name()};
+      auto parentType = parent >= 0 ? schema.elements[parent].type : Schema::Element::UNKNOWN;
+      auto isDialogueEffectParent = parentType == Schema::Element::ENTRY || parentType == Schema::Element::ENTRIES;
+      element.type =
+          context.isDialogue && parentType == Schema::Element::POOL && name == "Entry"
+              ? Schema::Element::POOL_ENTRY
+          : context.isDialogue && isDialogueEffectParent && dialogue_effect_name_is(name) ? Schema::Element::EFFECT
+                                                                                         : type_get(xml->Name());
+      element.parent = parent;
+      attribute_order_read(xml, element);
+      parse_attributes(xml, element, context);
+      if (context.isDialogue && element.type == Schema::Element::EFFECT && element.typeString.empty())
+        element.typeString = name;
+
+      if (!element.textureRootPath.empty())
+      {
+        context.textureRootPath = element.textureRootPath;
+        if (context.anm2RootPath.empty()) context.anm2RootPath = element.textureRootPath;
+      }
+      if (!element.anm2RootPath.empty()) context.anm2RootPath = element.anm2RootPath;
+      if (!element.soundRootPath.empty()) context.soundRootPath = element.soundRootPath;
+      if (!element.fontRootPath.empty()) context.fontRootPath = element.fontRootPath;
+      if (!element.baseAnm2.empty() && element.anm2Entry.is_valid()) context.baseAnm2 = element.anm2Entry;
+      if (element.type == Schema::Element::ITEMS) context.itemSpritesheetID = element.spritesheetID;
+      if (element.type == Schema::Element::DIALOGUE) context.isDialogue = true;
+
+      auto index = (int)schema.elements.size();
+      schema.elements.emplace_back(std::move(element));
+      if (parent >= 0) schema.elements[parent].children.emplace_back(index);
+
+      auto childCount = 0;
+      for (auto child = xml->FirstChildElement(); child; child = child->NextSiblingElement())
+        ++childCount;
+      schema.elements[index].children.reserve(childCount);
+
+      for (auto child = xml->FirstChildElement(); child; child = child->NextSiblingElement())
+        parse_tree(child, schema, index, context);
+    }
+
+    void element_attributes_write(XMLDocument& document, XMLElement* xml, const Schema::Element& element,
+                                  const Context& context)
+    {
+      auto set_string = [&](const char* name, const std::string& value)
+      {
+        if (!value.empty()) xml->SetAttribute(name, value.c_str());
+      };
+
+      auto set_nonzero = [&](const char* name, auto value)
+      {
+        if (value != decltype(value){}) xml->SetAttribute(name, value);
+      };
+
+      auto resource_string_get = [&](std::string_view symbol, const std::string& value)
+      {
+        if (symbol == "texture" || symbol == "portrait.path" || symbol == "render.path")
+          return resource_source_path_get(context, context.textureRootPath, value);
+        if (symbol == "sound" || (symbol == "path" && element.type == Schema::Element::SOUND))
+          return resource_source_path_get(context, context.soundRootPath, value);
+        if (symbol == "font" || symbol == "iconsFont")
+          return resource_source_path_get(context, context.fontRootPath, value);
+        if (symbol == "anm2" || symbol == "baseAnm2")
+        {
+          auto rootPath = context.anm2RootPath.empty() ? context.textureRootPath : context.anm2RootPath;
+          return resource_source_path_get(context, rootPath, value);
+        }
+        return value;
+      };
+
+      auto write_attribute = [&](std::string_view symbol)
+      {
+        auto isEffect = element.type == Schema::Element::EFFECT;
+        auto isEffectOscillation = isEffect && element.typeString == "Oscillation";
+        auto isEffectShake = isEffect && element.typeString == "Shake";
+        auto isEffectScreenshake = isEffect && element.typeString == "Screenshake";
+        if ((isEffectOscillation || isEffectShake) &&
+            (symbol == "amplitude" || symbol == "frequency" || symbol == "period"))
+          return true;
+        if (isEffectScreenshake && (symbol == "magnitude" || symbol == "timeTicks")) return true;
+        if (symbol == "end" && element.type == Schema::Element::EFFECT &&
+            (element.typeString == "Animation" || element.typeString == "Delay"))
+          return true;
+        if (symbol == "typeString" && element.type == Schema::Element::EFFECT)
+          return true;
+        if (symbol == "idString" && element.type == Schema::Element::POOL_ENTRY)
+        {
+          set_string("Entry", element.idString);
+          return true;
+        }
+#define GAME_SCHEMA_WRITE_ATTRIBUTE_STRING(KEY, KEY_2, KEY_3, MEMBER)                                                  \
+  set_string(KEY, resource_string_get(#MEMBER, element.MEMBER));
+#define GAME_SCHEMA_WRITE_ATTRIBUTE_STRING_TARGET(KEY, KEY_2, KEY_3, MEMBER)                                           \
+  set_string(KEY, resource_string_get(#MEMBER, element.MEMBER));
+#define GAME_SCHEMA_WRITE_ATTRIBUTE_INT_RW(KEY, KEY_2, KEY_3, MEMBER) set_nonzero(KEY, element.MEMBER);
+#define GAME_SCHEMA_WRITE_ATTRIBUTE_INT_RO(KEY, KEY_2, KEY_3, MEMBER)
+#define GAME_SCHEMA_WRITE_ATTRIBUTE_FLOAT(KEY, KEY_2, KEY_3, MEMBER) set_nonzero(KEY, element.MEMBER);
+#define GAME_SCHEMA_WRITE_ATTRIBUTE_FLOAT_PER_SECOND(KEY, KEY_2, KEY_3, MEMBER)                                        \
+  set_nonzero(KEY, element.MEMBER * UPDATES_PER_SECOND);
+#define GAME_SCHEMA_WRITE_ATTRIBUTE_VEC2(KEY, KEY_2, KEY_3, MEMBER)                                                    \
+  if (element.MEMBER != glm::vec2{}) set_vec2_attribute(xml, KEY, KEY_2, element.MEMBER);
+#define GAME_SCHEMA_WRITE_ATTRIBUTE_IVEC2(KEY, KEY_2, KEY_3, MEMBER)                                                   \
+  if (element.MEMBER != glm::ivec2{}) set_ivec2_attribute(xml, KEY, KEY_2, element.MEMBER);
+#define GAME_SCHEMA_WRITE_ATTRIBUTE_VEC3(KEY, KEY_2, KEY_3, MEMBER)                                                    \
+  if (element.MEMBER != glm::vec3{}) set_vec3_attribute(xml, KEY, KEY_2, KEY_3, element.MEMBER);
+#define GAME_SCHEMA_WRITE_ATTRIBUTE_COLOR_RO(KEY, KEY_2, KEY_3, MEMBER)
+#define GAME_SCHEMA_WRITE_ATTRIBUTE_BOOL(KEY, KEY_2, KEY_3, MEMBER)                                                    \
+  if (element.MEMBER) xml->SetAttribute(KEY, "true");
+#define GAME_SCHEMA_WRITE_ATTRIBUTE_BOOL_FALSE(KEY, KEY_2, KEY_3, MEMBER)                                              \
+  if (!element.MEMBER) xml->SetAttribute(KEY, "false");
+#define GAME_SCHEMA_WRITE_ATTRIBUTE(KIND, KEY, KEY_2, KEY_3, MEMBER)                                                   \
+  if (symbol == #MEMBER)                                                                                               \
+  {                                                                                                                    \
+    GAME_SCHEMA_WRITE_ATTRIBUTE_##KIND(KEY, KEY_2, KEY_3, MEMBER) return true;                                         \
+  }
+        GAME_SCHEMA_ELEMENT_ATTRIBUTES(GAME_SCHEMA_WRITE_ATTRIBUTE)
+#undef GAME_SCHEMA_WRITE_ATTRIBUTE
+#undef GAME_SCHEMA_WRITE_ATTRIBUTE_BOOL_FALSE
+#undef GAME_SCHEMA_WRITE_ATTRIBUTE_BOOL
+#undef GAME_SCHEMA_WRITE_ATTRIBUTE_COLOR_RO
+#undef GAME_SCHEMA_WRITE_ATTRIBUTE_VEC3
+#undef GAME_SCHEMA_WRITE_ATTRIBUTE_IVEC2
+#undef GAME_SCHEMA_WRITE_ATTRIBUTE_VEC2
+#undef GAME_SCHEMA_WRITE_ATTRIBUTE_FLOAT_PER_SECOND
+#undef GAME_SCHEMA_WRITE_ATTRIBUTE_FLOAT
+#undef GAME_SCHEMA_WRITE_ATTRIBUTE_INT_RO
+#undef GAME_SCHEMA_WRITE_ATTRIBUTE_INT_RW
+#undef GAME_SCHEMA_WRITE_ATTRIBUTE_STRING_TARGET
+#undef GAME_SCHEMA_WRITE_ATTRIBUTE_STRING
+        return false;
+      };
+
+      std::vector<std::string_view> written{};
+      written.reserve(element.attributeOrder.size());
+      for (auto& symbol : element.attributeOrder)
+      {
+        if (write_attribute(symbol)) written.emplace_back(symbol);
+      }
+
+#define GAME_SCHEMA_WRITE_ORDERED_ATTRIBUTE(KIND, KEY, KEY_2, KEY_3, MEMBER)                                           \
+  if (std::ranges::find(written, std::string_view{#MEMBER}) == written.end()) write_attribute(#MEMBER);
+      GAME_SCHEMA_ELEMENT_ATTRIBUTES(GAME_SCHEMA_WRITE_ORDERED_ATTRIBUTE)
+#undef GAME_SCHEMA_WRITE_ORDERED_ATTRIBUTE
+      (void)document;
+    }
+
+    const char* element_name_get(Schema::Element::Type type)
+    {
+      if (type == Schema::Element::POOL_ENTRY) return "Entry";
+      for (auto [name, mappedType] : TYPE_MAP)
+        if (mappedType == type) return name.data();
+      return "Unknown";
+    }
+
+    XMLElement* element_write(XMLDocument& document, const Schema& schema, int index, Context context = {})
+    {
+      auto& source = schema.elements.at(index);
+      auto xml = document.NewElement(source.type == Schema::Element::EFFECT && !source.typeString.empty()
+                                         ? source.typeString.c_str()
+                                         : element_name_get(source.type));
+
+      if (!source.textureRootPath.empty())
+      {
+        context.textureRootPath = source.textureRootPath;
+        if (context.anm2RootPath.empty()) context.anm2RootPath = source.textureRootPath;
+      }
+      if (!source.anm2RootPath.empty()) context.anm2RootPath = source.anm2RootPath;
+      if (!source.soundRootPath.empty()) context.soundRootPath = source.soundRootPath;
+      if (!source.fontRootPath.empty()) context.fontRootPath = source.fontRootPath;
+
+      element_attributes_write(document, xml, source, context);
+      for (auto child : source.children)
+        xml->InsertEndChild(element_write(document, schema, child, context));
+      return xml;
+    }
+
+    void animation_entry_add(Schema::Element& element, Schema::AnimationEntryCollection& collection)
+    {
+      if (element.animation.empty()) return;
+      collection.push_back({.animation = element.animation, .weight = element.weight == 0.0f ? 1.0f : element.weight});
+    }
+
+    void sound_entry_add(Schema::Element& element, Schema::SoundEntryCollection& collection)
+    {
+      if (!element.soundEntry.is_valid()) return;
+      element.soundEntry.weight = element.weight == 0.0f ? 1.0f : element.weight;
+      collection.push_back(&element.soundEntry);
+    }
+
+    void sound_entries_add(const Schema::SoundEntryCollection& source, Schema::SoundEntryCollection& collection)
+    {
+      for (auto* entry : source)
+        if (entry) collection.push_back(entry);
+    }
+
+    bool element_attribute_has(const Schema::Element& element, std::string_view attribute)
+    {
+      return std::ranges::find(element.attributeOrder, attribute) != element.attributeOrder.end();
+    }
+
+    bool element_child_has(const Schema& schema, const Schema::Element& element, Schema::Element::Type type)
+    {
+      for (auto child : element.children)
+        if (child >= 0 && child < (int)schema.elements.size() && schema.elements[child].type == type) return true;
+      return false;
+    }
+
+    void interact_area_defaults_apply(Schema& schema)
+    {
+      auto* root = schema.root();
+      auto* areas = root ? schema.child_get(*root, Schema::Element::INTERACT_AREAS) : nullptr;
+      auto* types = root ? schema.child_get(*root, Schema::Element::INTERACT_AREA_TYPES) : nullptr;
+      if (!areas) return;
+      if (!types) return;
+
+      std::unordered_map<std::string, Schema::Element*> defaults{};
+      for (auto* area : schema.children_get(*types, Schema::Element::INTERACT_AREA))
+      {
+        if (!area || area->typeString.empty()) continue;
+        defaults[area->typeString] = area;
+      }
+
+      for (auto* area : schema.children_get(*areas, Schema::Element::INTERACT_AREA))
+      {
+        if (!area || area->typeString.empty() || area->null.empty()) continue;
+        auto it = defaults.find(area->typeString);
+        if (it == defaults.end()) continue;
+        auto* base = it->second;
+
+#define GAME_SCHEMA_INTERACT_AREA_DEFAULTS(X)                                                                          \
+  X(animation)                                                                                                         \
+  X(animationCursorActive)                                                                                             \
+  X(animationCursorHover)                                                                                              \
+  X(digestionBonusOnClick)                                                                                             \
+  X(digestionBonusOnHover)                                                                                             \
+  X(iconGlyph)                                                                                                         \
+  X(isHold)                                                                                                            \
+  X(layer)                                                                                                             \
+  X(scaleEffectAmplitude)                                                                                              \
+  X(scaleEffectCycles)                                                                                                 \
+  X(timeTicks)                                                                                                         \
+  X(timeToActivateNewDialogueTicks)
+#define GAME_SCHEMA_INTERACT_AREA_DEFAULT_APPLY(MEMBER)                                                                \
+  if (!element_attribute_has(*area, #MEMBER) && area->MEMBER == decltype(area->MEMBER){}) area->MEMBER = base->MEMBER;
+        GAME_SCHEMA_INTERACT_AREA_DEFAULTS(GAME_SCHEMA_INTERACT_AREA_DEFAULT_APPLY)
+#undef GAME_SCHEMA_INTERACT_AREA_DEFAULT_APPLY
+#undef GAME_SCHEMA_INTERACT_AREA_DEFAULTS
+
+        if (!element_child_has(schema, *area, Schema::Element::SOUND))
+          area->soundEntries = base->soundEntries;
+      }
+    }
+
+#define GAME_SCHEMA_ACTION_SOUNDS(X)                                                                                   \
+  X(BOUNCE, soundBounce)                                                                                               \
+  X(CHEATS_ACTIVATED, soundCheatsActivated)                                                                            \
+  X(CLOSE, soundClose)                                                                                                 \
+  X(COLLECT, soundCollect)                                                                                             \
+  X(DIGEST, soundDigest)                                                                                               \
+  X(DISPOSE, soundDispose)                                                                                             \
+  X(GRAB, soundGrab)                                                                                                   \
+  X(GURGLE, soundGurgle)                                                                                               \
+  X(HOVER, soundHover)                                                                                                 \
+  X(KILL, soundKill)                                                                                                   \
+  X(LEVEL_UP, soundLevelUp)                                                                                             \
+  X(LEVEL_UP_READY, soundLevelUpReady)                                                                                  \
+  X(OPEN, soundOpen)                                                                                                   \
+  X(RELEASE, soundRelease)                                                                                             \
+  X(SELECT, soundSelect)                                                                                               \
+  X(SUMMON, soundSummon)                                                                                               \
+  X(THROW, soundThrow)                                                                                                 \
+  X(RETURN_, soundReturn)                                                                                              \
+  X(UPGRADE, soundUpgrade)                                                                                             \
+  X(UPGRADE_FAIL, soundUpgradeFail)
+
+    void cache_refresh(Schema& schema)
+    {
+      schema.areas.clear();
+      schema.categories.clear();
+      schema.rarities.clear();
+      schema.flavors.clear();
+      schema.items.clear();
+      schema.anm2s.clear();
+      schema.rarityIDs.clear();
+      schema.pools.clear();
+      schema.stringToIDMap.clear();
+      schema.idToStringMap.clear();
+      schema.elementsByType.clear();
+      schema.baseAnm2 = {};
+      schema.font = {};
+      schema.iconsFont = {};
+      schema.durability = 2;
+      schema.quantityMax = 99;
+      schema.rounding = 0.0f;
+
+      auto* root = schema.root();
+      if (!root) return;
+
+      schema.elementsByType.reserve(schema.elements.size());
+      for (int i = 0; i < (int)schema.elements.size(); i++)
+        schema.elementsByType[schema.elements[i].type].push_back(i);
+
+      auto type_count = [&](Schema::Element::Type type)
+      {
+        auto it = schema.elementsByType.find(type);
+        return it == schema.elementsByType.end() ? 0 : (int)it->second.size();
+      };
+
+      schema.areas.reserve(type_count(Schema::Element::AREA));
+      schema.categories.reserve(type_count(Schema::Element::CATEGORY));
+      schema.rarities.reserve(type_count(Schema::Element::RARITY));
+      schema.flavors.reserve(type_count(Schema::Element::FLAVOR));
+      schema.items.reserve(type_count(Schema::Element::ITEM));
+      schema.anm2s.reserve(type_count(Schema::Element::ITEM));
+      schema.rarityIDs.reserve(type_count(Schema::Element::RARITY));
+
+      root->animationGrab = {};
+      root->animationHover = {};
+      root->animationIdle = {};
+      root->animationClick = {};
+      root->animationPan = {};
+      root->animationReturn = {};
+      root->animationZoom = {};
+      root->soundBlip = {};
+      root->soundBounce = {};
+      root->soundCheatsActivated = {};
+      root->soundClose = {};
+      root->soundCollect = {};
+      root->soundDigest = {};
+      root->soundDispose = {};
+      root->soundGrab = {};
+      root->soundGurgle = {};
+      root->soundHover = {};
+      root->soundKill = {};
+      root->soundLevelUp = {};
+      root->soundLevelUpReady = {};
+      root->soundOpen = {};
+      root->soundRelease = {};
+      root->soundReturn = {};
+      root->soundSelect = {};
+      root->soundSummon = {};
+      root->soundThrow = {};
+      root->soundUpgrade = {};
+      root->soundUpgradeFail = {};
+      root->animationChew = {};
+
+      for (auto& element : schema.elements)
+      {
+        element.soundEntries = {};
+        for (auto childID : element.children)
+        {
+          auto& child = schema.elements.at(childID);
+          if (child.type == Schema::Element::SOUND) sound_entry_add(child, element.soundEntries);
+        }
+      }
+      interact_area_defaults_apply(schema);
+
+      schema.baseAnm2 = root->anm2Entry.anm2;
+      schema.font = root->fontEntry.font;
+      schema.iconsFont = root->iconsFontEntry.font;
+      schema.rounding = root->rounding;
+
+      if (auto* animations = schema.child_get(*root, Schema::Element::ANIMATIONS))
+      {
+        if (auto* element = schema.child_get(*animations, Schema::Element::IDLE))
+          animation_entry_add(*element, root->animationIdle);
+        if (auto* element = schema.child_get(*animations, Schema::Element::CLICK))
+          animation_entry_add(*element, root->animationClick);
+        if (auto* element = schema.child_get(*animations, Schema::Element::HOVER))
+          animation_entry_add(*element, root->animationHover);
+        if (auto* element = schema.child_get(*animations, Schema::Element::GRAB))
+          animation_entry_add(*element, root->animationGrab);
+        if (auto* element = schema.child_get(*animations, Schema::Element::PAN))
+          animation_entry_add(*element, root->animationPan);
+        if (auto* element = schema.child_get(*animations, Schema::Element::ZOOM))
+          animation_entry_add(*element, root->animationZoom);
+        if (auto* element = schema.child_get(*animations, Schema::Element::RETURN_))
+          animation_entry_add(*element, root->animationReturn);
+        if (auto* element = schema.child_get(*animations, Schema::Element::CHEW))
+          root->animationChew = element->animation;
+      }
+
+      if (auto* sounds = schema.child_get(*root, Schema::Element::SOUNDS))
+      {
+        for (auto* element : schema.children_get(*sounds, Schema::Element::BLIP))
+          sound_entry_add(*element, root->soundBlip);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::BOUNCE))
+          sound_entry_add(*element, root->soundBounce);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::CHEATS_ACTIVATED))
+          sound_entry_add(*element, root->soundCheatsActivated);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::CLOSE))
+          sound_entry_add(*element, root->soundClose);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::COLLECT))
+          sound_entry_add(*element, root->soundCollect);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::DIGEST))
+          sound_entry_add(*element, root->soundDigest);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::DISPOSE))
+          sound_entry_add(*element, root->soundDispose);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::GRAB))
+          sound_entry_add(*element, root->soundGrab);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::GURGLE))
+          sound_entry_add(*element, root->soundGurgle);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::HOVER))
+          sound_entry_add(*element, root->soundHover);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::KILL))
+          sound_entry_add(*element, root->soundKill);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::LEVEL_UP))
+          sound_entry_add(*element, root->soundLevelUp);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::LEVEL_UP_READY))
+          sound_entry_add(*element, root->soundLevelUpReady);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::OPEN))
+          sound_entry_add(*element, root->soundOpen);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::RELEASE))
+          sound_entry_add(*element, root->soundRelease);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::RETURN_))
+          sound_entry_add(*element, root->soundReturn);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::SELECT))
+          sound_entry_add(*element, root->soundSelect);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::SUMMON))
+          sound_entry_add(*element, root->soundSummon);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::THROW))
+          sound_entry_add(*element, root->soundThrow);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::UPGRADE))
+          sound_entry_add(*element, root->soundUpgrade);
+        for (auto* element : schema.children_get(*sounds, Schema::Element::UPGRADE_FAIL))
+          sound_entry_add(*element, root->soundUpgradeFail);
+      }
+      if (auto* actions = schema.child_get(*root, Schema::Element::ACTIONS))
+      {
+#define GAME_SCHEMA_ACTION_SOUND_CACHE(TYPE, MEMBER)                                                                   \
+  for (auto* action : schema.children_get(*actions, Schema::Element::TYPE))                                            \
+    for (auto* element : schema.children_get(*action, Schema::Element::SOUND))                                         \
+      sound_entry_add(*element, root->MEMBER);
+        GAME_SCHEMA_ACTION_SOUNDS(GAME_SCHEMA_ACTION_SOUND_CACHE)
+#undef GAME_SCHEMA_ACTION_SOUND_CACHE
+      }
+#undef GAME_SCHEMA_ACTION_SOUNDS
+      if (auto* textPlayback = schema.child_get(*root, Schema::Element::TEXT_PLAYBACK))
+        if (auto* blip = schema.child_get(*textPlayback, Schema::Element::BLIP))
+          sound_entries_add(blip->soundEntries, root->soundBlip);
+      for (auto* element : schema.children_get(*root, Schema::Element::BLIP))
+        sound_entry_add(*element, root->soundBlip);
+
+      for (auto* element : schema.get_all(Schema::Element::AREA))
+        schema.areas.push_back({.texture = element->textureEntry.texture,
+                                .anm2 = element->anm2Entry.anm2,
+                                .gravity = element->gravity == 0.0f ? 0.95f : element->gravity,
+                                .friction = element->friction == 0.0f ? 0.80f : element->friction,
+                                .airResistance = element->airResistance == 0.0f ? 0.975f : element->airResistance});
+      if (root->type == Schema::Element::AREAS && schema.areas.empty()) schema.areas.emplace_back();
+
+      for (auto* element : schema.get_all(Schema::Element::CATEGORY))
+        schema.categories.push_back({.name = element->name, .isEdible = element->isEdible});
+
+      for (auto* element : schema.get_all(Schema::Element::RARITY))
+      {
+        schema.rarityIDs.push_back((int)schema.rarities.size());
+        schema.rarities.push_back({.name = element->name.empty() ? "???" : element->name,
+                                   .weight = element->weight,
+                                   .isHidden = element->isHidden,
+                                   .sound = element->soundEntry.sound});
+      }
+
+      for (auto* element : schema.get_all(Schema::Element::FLAVOR))
+        schema.flavors.push_back({.name = element->name.empty() ? "???" : element->name});
+
+      if (auto* itemsRoot = schema.get(Schema::Element::ITEMS))
+      {
+        if (itemsRoot->durability != 0) schema.durability = itemsRoot->durability;
+        if (itemsRoot->quantityMax != 0) schema.quantityMax = itemsRoot->quantityMax;
+      }
+
+      auto itemElements = schema.get_all(Schema::Element::ITEM);
+      for (auto* element : itemElements)
+      {
+        if (element->parent < 0 || schema.elements[element->parent].type != Schema::Element::ITEMS) continue;
+        auto itemID = (int)schema.stringToIDMap.size();
+        schema.stringToIDMap[element->name] = itemID;
+        schema.idToStringMap[itemID] = element->name;
+      }
+
+      for (auto* element : itemElements)
+      {
+        if (element->parent < 0 || schema.elements[element->parent].type != Schema::Element::ITEMS) continue;
+        Schema::ItemEntry item{};
+        item.name = element->name.empty() ? "???" : element->name;
+        item.description = element->description.empty() ? "???" : element->description;
+        item.categoryID = schema.categoryMap.contains(element->category) ? schema.categoryMap[element->category] : -1;
+        item.rarityID = schema.rarityMap.contains(element->rarity) ? schema.rarityMap[element->rarity] : -1;
+        item.isFlavor = schema.flavorMap.contains(element->flavor);
+        if (item.isFlavor) item.flavorID = schema.flavorMap[element->flavor];
+        item.isCalories = element->calories != 0.0f;
+        item.calories = element->calories;
+        item.isCapacityBonus = element->capacityBonus != 0.0f;
+        item.capacityBonus = element->capacityBonus;
+        item.isDigestionBonus = element->digestionBonus != 0.0f;
+        item.digestionBonus = element->digestionBonus;
+        item.isEatSpeedBonus = element->eatSpeedBonus != 0.0f;
+        item.eatSpeedBonus = element->eatSpeedBonus;
+        item.isGravity = element->gravity != 0.0f;
+        item.gravity = element->gravity;
+        item.isDurability = element->durability != 0;
+        item.durability = element->durability;
+        item.isColor = element->color != glm::vec3{};
+        item.color = element->color;
+        if (!element->upgradeID.empty() && schema.stringToIDMap.contains(element->upgradeID))
+        {
+          item.isUpgradeID = true;
+          item.upgradeID = schema.stringToIDMap[element->upgradeID];
+        }
+        item.isUpgradeCount = element->upgradeCount != 0;
+        item.upgradeCount = element->upgradeCount;
+        item.isToggleSpritesheet = element->isToggleSpritesheet;
+        schema.pools[item.rarityID].push_back((int)schema.items.size());
+        schema.anm2s.push_back(element->anm2Entry.anm2);
+        schema.items.push_back(std::move(item));
+      }
+    }
+
+  }
+
+  Schema::Schema(const Schema& other) { *this = other; }
+  Schema::Schema(Schema&& other) noexcept { *this = std::move(other); }
+  Schema::Schema(const std::filesystem::path& path) { load(path); }
+  Schema::Schema(const util::physfs::Path& path) { load(path); }
+
+  Schema& Schema::operator=(const Schema& other)
+  {
+    if (this == &other) return *this;
+
+    elements = other.elements;
+    isValid = other.isValid;
+    indices_refresh();
+    cache_refresh(*this);
+    return *this;
+  }
+
+  Schema& Schema::operator=(Schema&& other) noexcept
+  {
+    if (this == &other) return *this;
+
+    elements = std::move(other.elements);
+    isValid = other.isValid;
+    indices_refresh();
+    cache_refresh(*this);
+
+    other.elements.clear();
+    other.isValid = false;
+    other.indices_refresh();
+    cache_refresh(other);
+    return *this;
+  }
+
+  bool Schema::Element::is_valid() const { return type != UNKNOWN; }
+  bool Schema::Element::is_last() const { return next.empty() && children.empty(); }
+
+  bool Schema::load(const std::filesystem::path& path)
+  {
+    elements.clear();
+    isValid = false;
+
+    XMLDocument document;
+    auto pathString = path.string();
+    auto result = document.LoadFile(pathString.c_str());
+    if (result == XML_ERROR_FILE_NOT_FOUND || result == XML_ERROR_FILE_COULD_NOT_BE_OPENED) return false;
+    if (result != XML_SUCCESS)
+    {
+      logger.error(std::format("Failed to load Schema XML: {} ({})", pathString, document.ErrorStr()));
+      return false;
+    }
+
+    Context context{};
+    context.filesystemBase = path.parent_path();
+    parse_tree(document.RootElement(), *this, -1, context);
+    indices_refresh();
+    cache_refresh(*this);
+    isValid = !elements.empty();
+    return isValid;
+  }
+
+  bool Schema::load(const util::physfs::Path& path)
+  {
+    elements.clear();
+    isValid = false;
+
+    XMLDocument document;
+    if (document_load(path, document) != XML_SUCCESS)
+    {
+      logger.error(std::format("Failed to load Schema XML: {}", path.c_str()));
+      return false;
+    }
+
+    Context context{};
+    context.archive = path.directory_get();
+    parse_tree(document.RootElement(), *this, -1, context);
+    indices_refresh();
+    cache_refresh(*this);
+    isValid = !elements.empty();
+    return isValid;
+  }
+
+  bool Schema::load_archive(const std::filesystem::path& path, const std::string& innerPath)
+  {
+    elements.clear();
+    isValid = false;
+
+    util::physfs::Archive archive(path, path.filename().string());
+    if (!archive.is_valid())
+    {
+      logger.error(std::format("Failed to load Schema archive: {}", path.string()));
+      return false;
+    }
+
+    auto xmlPath = util::physfs::Path(std::string(archive) + "/" + innerPath);
+    XMLDocument document;
+    if (document_load(xmlPath, document) != XML_SUCCESS)
+    {
+      logger.error(std::format("Failed to load Schema archive XML: {}", xmlPath.c_str()));
+      return false;
+    }
+
+    Context context{};
+    context.archive = archive;
+    parse_tree(document.RootElement(), *this, -1, context);
+    indices_refresh();
+    cache_refresh(*this);
+    isValid = !elements.empty();
+    return isValid;
+  }
+
+  void Schema::settings_default()
+  {
+    elements.clear();
+    Element root{};
+    root.type = Element::SETTINGS;
+    root.measurementSystem = "Metric";
+    root.volume = 50;
+    root.isAudioMuted = false;
+    root.color = {0.120f, 0.515f, 0.115f};
+    root.windowSize = {1600, 900};
+    root.isUseCharacterColor = true;
+    elements.emplace_back(std::move(root));
+    indices_refresh();
+    cache_refresh(*this);
+    isValid = true;
+  }
+
+  void Schema::serialize(const std::filesystem::path& path) const
+  {
+    auto rootElement = root();
+    if (!rootElement) return;
+
+    XMLDocument document;
+    Context context{};
+    context.filesystemBase = path.parent_path();
+    document.InsertEndChild(element_write(document, *this, 0, context));
+    auto pathString = path.string();
+    if (document.SaveFile(pathString.c_str()) != XML_SUCCESS)
+      logger.error(std::format("Failed to save schema: {} ({})", pathString, document.ErrorStr()));
+  }
+
+  bool Schema::is_valid() const { return isValid; }
+
+  Schema::Element* Schema::root() { return elements.empty() ? nullptr : &elements.front(); }
+  const Schema::Element* Schema::root() const { return elements.empty() ? nullptr : &elements.front(); }
+
+  Schema::Element& Schema::element_add(Element::Type type, int parent)
+  {
+    Element element{};
+    element.type = type;
+    element.parent = parent;
+    auto index = (int)elements.size();
+    elements.emplace_back(std::move(element));
+    elementsByType[type].push_back(index);
+    if (parent >= 0) elements.at(parent).children.emplace_back(index);
+    isValid = true;
+    return elements.back();
+  }
+
+  bool Schema::element_erase(int index)
+  {
+    if (index <= 0 || index >= (int)elements.size()) return false;
+
+    std::vector<bool> erase(elements.size());
+    auto mark = [&](auto&& self, int current) -> void
+    {
+      if (current < 0 || current >= (int)elements.size() || erase[current]) return;
+      erase[current] = true;
+      for (auto child : elements[current].children)
+        self(self, child);
+    };
+    mark(mark, index);
+
+    std::vector<int> remap(elements.size(), -1);
+    std::vector<Element> kept{};
+    kept.reserve(elements.size());
+    for (int i = 0; i < (int)elements.size(); ++i)
+    {
+      if (erase[i]) continue;
+      remap[i] = (int)kept.size();
+      kept.emplace_back(std::move(elements[i]));
+    }
+
+    for (auto& element : kept)
+    {
+      if (element.parent >= 0) element.parent = remap[element.parent];
+
+      std::vector<int> children{};
+      children.reserve(element.children.size());
+      for (auto child : element.children)
+        if (child >= 0 && child < (int)remap.size() && remap[child] >= 0) children.emplace_back(remap[child]);
+      element.children = std::move(children);
+    }
+
+    elements = std::move(kept);
+    indices_refresh();
+    cache_refresh(*this);
+    isValid = !elements.empty();
+    return true;
+  }
+
+  int Schema::element_insert_xml(const std::string& text, int parent, int beforeSibling)
+  {
+    XMLDocument document;
+    if (document.Parse(text.c_str()) != XML_SUCCESS || !document.RootElement()) return -1;
+    if (parent < -1 || parent >= (int)elements.size()) return -1;
+    if (parent < 0 && !elements.empty()) return -1;
+
+    auto index = (int)elements.size();
+    Context context{};
+    parse_tree(document.RootElement(), *this, parent, context);
+
+    if (parent >= 0 && beforeSibling >= 0)
+    {
+      auto& children = elements[parent].children;
+      auto inserted = std::ranges::find(children, index);
+      auto before = std::ranges::find(children, beforeSibling);
+      if (inserted != children.end() && before != children.end() && inserted != before)
+      {
+        auto value = *inserted;
+        children.erase(inserted);
+        before = std::ranges::find(children, beforeSibling);
+        children.insert(before, value);
+      }
+    }
+
+    indices_refresh();
+    cache_refresh(*this);
+    isValid = !elements.empty();
+    return index;
+  }
+
+  bool Schema::element_move(int index, int parent, int beforeSibling)
+  {
+    if (index <= 0 || index >= (int)elements.size()) return false;
+    if (parent < 0 || parent >= (int)elements.size()) return false;
+    if (index == parent || index == beforeSibling) return false;
+
+    for (auto ancestor = parent; ancestor >= 0; ancestor = elements[ancestor].parent)
+      if (ancestor == index) return false;
+
+    auto oldParent = elements[index].parent;
+    if (oldParent >= 0)
+    {
+      auto& oldSiblings = elements[oldParent].children;
+      oldSiblings.erase(std::remove(oldSiblings.begin(), oldSiblings.end(), index), oldSiblings.end());
+    }
+
+    auto& siblings = elements[parent].children;
+    auto before = beforeSibling >= 0 ? std::ranges::find(siblings, beforeSibling) : siblings.end();
+    siblings.insert(before, index);
+    elements[index].parent = parent;
+
+    indices_refresh();
+    cache_refresh(*this);
+    return true;
+  }
+
+  std::string Schema::element_serialize(int index) const
+  {
+    if (index < 0 || index >= (int)elements.size()) return {};
+
+    XMLDocument document;
+    document.InsertEndChild(element_write(document, *this, index));
+
+    XMLPrinter printer{};
+    document.Print(&printer);
+    return printer.CStr();
+  }
+
+  Schema::Element* Schema::get(Element::Type type, int index)
+  {
+    auto it = elementsByType.find(type);
+    if (it == elementsByType.end() || index < 0 || index >= (int)it->second.size()) return nullptr;
+    return &elements.at(it->second.at(index));
+  }
+
+  const Schema::Element* Schema::get(Element::Type type, int index) const
+  {
+    auto it = elementsByType.find(type);
+    if (it == elementsByType.end() || index < 0 || index >= (int)it->second.size()) return nullptr;
+    return &elements.at(it->second.at(index));
+  }
+
+  std::vector<Schema::Element*> Schema::get_all(Element::Type type)
+  {
+    std::vector<Element*> result{};
+    auto it = elementsByType.find(type);
+    if (it == elementsByType.end()) return result;
+    result.reserve(it->second.size());
+    for (auto index : it->second)
+      result.emplace_back(&elements.at(index));
+    return result;
+  }
+
+  std::vector<const Schema::Element*> Schema::get_all(Element::Type type) const
+  {
+    std::vector<const Element*> result{};
+    auto it = elementsByType.find(type);
+    if (it == elementsByType.end()) return result;
+    result.reserve(it->second.size());
+    for (auto index : it->second)
+      result.emplace_back(&elements.at(index));
+    return result;
+  }
+
+  Schema::Element* Schema::child_get(Element& element, Element::Type type, int index)
+  {
+    for (auto child : element.children)
+    {
+      auto& candidate = elements.at(child);
+      if (candidate.type != type) continue;
+      if (index-- == 0) return &candidate;
+    }
+    return nullptr;
+  }
+
+  const Schema::Element* Schema::child_get(const Element& element, Element::Type type, int index) const
+  {
+    for (auto child : element.children)
+    {
+      auto& candidate = elements.at(child);
+      if (candidate.type != type) continue;
+      if (index-- == 0) return &candidate;
+    }
+    return nullptr;
+  }
+
+  std::vector<Schema::Element*> Schema::children_get(Element& element, Element::Type type)
+  {
+    std::vector<Element*> result{};
+    for (auto child : element.children)
+      if (auto& candidate = elements.at(child); candidate.type == type) result.emplace_back(&candidate);
+    return result;
+  }
+
+  std::vector<const Schema::Element*> Schema::children_get(const Element& element, Element::Type type) const
+  {
+    std::vector<const Element*> result{};
+    for (auto child : element.children)
+      if (auto& candidate = elements.at(child); candidate.type == type) result.emplace_back(&candidate);
+    return result;
+  }
+
+  Schema::Element* Schema::dialogue_entry_get(int id)
+  {
+    if (id < 0 || id >= (int)elements.size()) return nullptr;
+    auto idIt = entryIDMapReverse.find(id);
+    return idIt == entryIDMapReverse.end() ? nullptr : dialogue_entry_get(idIt->second);
+  }
+
+  Schema::Element* Schema::dialogue_entry_get(const std::string& id)
+  {
+    auto it = entryIDMap.find(id);
+    return it == entryIDMap.end() ? nullptr : &elements.at(it->second);
+  }
+
+  Schema::Element* Schema::dialogue_entry_get(Element& reference)
+  {
+    if (!reference.next.empty()) return dialogue_entry_get(reference.next);
+    if (!reference.idString.empty()) return dialogue_entry_get(reference.idString);
+    return nullptr;
+  }
+
+  Schema::Element* Schema::dialogue_pool_entry_get(int poolID)
+  {
+    if (poolID < 0) return nullptr;
+    auto poolIt = std::ranges::find_if(poolMap, [&](auto& entry) { return entry.second == poolID; });
+    if (poolIt == poolMap.end()) return nullptr;
+    return dialogue_pool_entry_get(poolIt->first);
+  }
+
+  Schema::Element* Schema::dialogue_pool_entry_get(const std::string& poolID)
+  {
+    auto poolIt = poolMap.find(poolID);
+    if (poolIt == poolMap.end()) return nullptr;
+
+    auto& pool = elements.at(poolIt->second);
+    auto entries = children_get(pool, Element::POOL_ENTRY);
+    if (entries.empty()) return nullptr;
+
+    auto picked = entries.at(selectionCounter++ % entries.size());
+    return dialogue_entry_get(picked->idString);
+  }
+
+  Schema::Element* Schema::dialogue_pool_entry_get(Element& reference)
+  {
+    if (!reference.dialoguePoolID.empty()) return dialogue_pool_entry_get(reference.dialoguePoolID);
+    if (reference.poolID.empty()) return nullptr;
+    return dialogue_pool_entry_get(reference.poolID);
+  }
+
+  int Schema::dialogue_entry_id_get(const std::string& id) const
+  {
+    auto it = entryIDMap.find(id);
+    return it == entryIDMap.end() ? -1 : it->second;
+  }
+
+  int Schema::dialogue_pool_id_get(const std::string& id) const
+  {
+    auto it = poolMap.find(id);
+    return it == poolMap.end() ? -1 : it->second;
+  }
+
+  Schema::Element* Schema::item_get(int id)
+  {
+    auto it = itemIDMapReverse.find(id);
+    return it == itemIDMapReverse.end() ? nullptr : item_get(it->second);
+  }
+
+  Schema::Element* Schema::item_get(const std::string& id)
+  {
+    auto it = itemIDMap.find(id);
+    return it == itemIDMap.end() ? nullptr : &elements.at(it->second);
+  }
+
+  int Schema::item_id_get(const std::string& id) const
+  {
+    auto it = itemIDMap.find(id);
+    return it == itemIDMap.end() ? -1 : it->second;
+  }
+
+  std::vector<int>* Schema::item_pool_get(int rarityID)
+  {
+    auto it = itemPoolsByRarity.find(rarityID);
+    return it == itemPoolsByRarity.end() ? nullptr : &it->second;
+  }
+
+  void Schema::indices_refresh()
+  {
+    entryIDMap.clear();
+    entryIDMapReverse.clear();
+    poolMap.clear();
+    categoryMap.clear();
+    rarityMap.clear();
+    flavorMap.clear();
+    itemIDMap.clear();
+    itemIDMapReverse.clear();
+    itemPoolsByRarity.clear();
+    entrySelectionOrder.clear();
+    selectionCounter = 0;
+
+    int entryID{};
+    int poolID{};
+    int categoryID{};
+    int rarityID{};
+    int flavorID{};
+    int itemID{};
+
+    for (int i = 0; i < (int)elements.size(); i++)
+    {
+      auto& element = elements[i];
+      if (element.type == Element::ENTRY && !element.idString.empty())
+      {
+        entryIDMap[element.idString] = i;
+        entryIDMapReverse[entryID++] = element.idString;
+      }
+      else if (element.type == Element::POOL && !element.idString.empty())
+      {
+        poolMap[element.idString] = i;
+        poolID++;
+      }
+      else if (element.type == Element::CATEGORY)
+        categoryMap[element.name] = categoryID++;
+      else if (element.type == Element::RARITY)
+        rarityMap[element.name] = rarityID++;
+      else if (element.type == Element::FLAVOR)
+        flavorMap[element.name] = flavorID++;
+      else if (element.type == Element::ITEM && !element.name.empty())
+      {
+        itemIDMap[element.name] = i;
+        itemIDMapReverse[itemID] = element.name;
+        auto rarity = rarityMap.contains(element.rarity) ? rarityMap[element.rarity] : -1;
+        itemPoolsByRarity[rarity].push_back(i);
+        itemID++;
+      }
+    }
+
+    entrySelectionOrder.assign(entryIDMap.size(), -1);
+    (void)poolID;
+  }
+}
diff --git a/src/resource/schema.hpp b/src/resource/schema.hpp
new file mode 100644
index 0000000..08a394e
--- /dev/null
+++ b/src/resource/schema.hpp
@@ -0,0 +1,743 @@
+#pragma once
+
+#include <filesystem>
+#include <map>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+
+#include <glm/glm.hpp>
+
+#include "../util/physfs.hpp"
+#include "anm2.hpp"
+#include "audio.hpp"
+#include "font.hpp"
+#include "texture.hpp"
+
+#define GAME_SCHEMA_ELEMENT_TYPES(X)                                                                                   \
+  X(Actions, ACTIONS)                                                                                                  \
+  X(AlternateSpritesheet, ALTERNATE_SPRITESHEET)                                                                       \
+  X(Animation, ANIMATION)                                                                                              \
+  X(Animations, ANIMATIONS)                                                                                            \
+  X(AnimationOverrides, ANIMATION_OVERRIDES)                                                                           \
+  X(Anm2, ANM2)                                                                                                        \
+  X(Area, AREA)                                                                                                        \
+  X(Areas, AREAS)                                                                                                      \
+  X(Blink, BLINK)                                                                                                      \
+  X(Blip, BLIP)                                                                                                        \
+  X(Bounce, BOUNCE)                                                                                                    \
+  X(Categories, CATEGORIES)                                                                                            \
+  X(Category, CATEGORY)                                                                                                \
+  X(Character, CHARACTER)                                                                                              \
+  X(CheatsActivated, CHEATS_ACTIVATED)                                                                                 \
+  X(Chew, CHEW)                                                                                                        \
+  X(Choice, CHOICE)                                                                                                    \
+  X(Click, CLICK)                                                                                                      \
+  X(Close, CLOSE)                                                                                                      \
+  X(Collect, COLLECT)                                                                                                  \
+  X(Color, COLOR)                                                                                                      \
+  X(Colors, COLORS)                                                                                                    \
+  X(Content, CONTENT)                                                                                                  \
+  X(Cursor, CURSOR)                                                                                                    \
+  X(DelayCharacter, DELAY_CHARACTER)                                                                                   \
+  X(DelayCharacters, DELAY_CHARACTERS)                                                                                 \
+  X(Dialogue, DIALOGUE)                                                                                                \
+  X(Digest, DIGEST)                                                                                                    \
+  X(Dispose, DISPOSE)                                                                                                  \
+  X(Eat, EAT)                                                                                                          \
+  X(EatArea, EAT_AREA)                                                                                                 \
+  X(EatAreas, EAT_AREAS)                                                                                               \
+  X(EatFull, EAT_FULL)                                                                                                 \
+  X(Effect, EFFECT)                                                                                                    \
+  X(Effects, EFFECTS)                                                                                                  \
+  X(End, END)                                                                                                          \
+  X(Enemy, ENEMY)                                                                                                      \
+  X(Entries, ENTRIES)                                                                                                  \
+  X(Entry, ENTRY)                                                                                                      \
+  X(Event, EVENT)                                                                                                      \
+  X(Events, EVENTS)                                                                                                    \
+  X(ExpandArea, EXPAND_AREA)                                                                                           \
+  X(ExpandAreas, EXPAND_AREAS)                                                                                         \
+  X(Feed, FEED)                                                                                                        \
+  X(FeedFull, FEED_FULL)                                                                                               \
+  X(FinishFood, FINISH_FOOD)                                                                                           \
+  X(Flavor, FLAVOR)                                                                                                    \
+  X(Flavors, FLAVORS)                                                                                                  \
+  X(Follower, FOLLOWER)                                                                                                \
+  X(FoodTaken, FOOD_TAKEN)                                                                                             \
+  X(FoodTakenFull, FOOD_TAKEN_FULL)                                                                                    \
+  X(Frame, FRAME)                                                                                                      \
+  X(Full, FULL)                                                                                                        \
+  X(Grab, GRAB)                                                                                                        \
+  X(Gurgle, GURGLE)                                                                                                    \
+  X(Help, HELP)                                                                                                        \
+  X(Home, HOME)                                                                                                        \
+  X(Hover, HOVER)                                                                                                      \
+  X(Hurt, HURT)                                                                                                        \
+  X(Idle, IDLE)                                                                                                        \
+  X(IdleFull, IDLE_FULL)                                                                                               \
+  X(Info, INFO)                                                                                                        \
+  X(InteractArea, INTERACT_AREA)                                                                                       \
+  X(InteractAreas, INTERACT_AREAS)                                                                                     \
+  X(InteractAreaTypes, INTERACT_AREA_TYPES)                                                                            \
+  X(Inventory, INVENTORY)                                                                                              \
+  X(Item, ITEM)                                                                                                        \
+  X(Items, ITEMS)                                                                                                      \
+  X(ItemSchema, ITEM_SCHEMA)                                                                                           \
+  X(Kill, KILL)                                                                                                        \
+  X(Layer, LAYER)                                                                                                      \
+  X(LayerAnimation, LAYER_ANIMATION)                                                                                   \
+  X(LayerAnimations, LAYER_ANIMATIONS)                                                                                 \
+  X(Layers, LAYERS)                                                                                                    \
+  X(LevelUp, LEVEL_UP)                                                                                                 \
+  X(LevelUpReady, LEVEL_UP_READY)                                                                                      \
+  X(LowCapacity, LOW_CAPACITY)                                                                                         \
+  X(Menu, MENU)                                                                                                        \
+  X(New, NEW)                                                                                                          \
+  X(Null, NULL_)                                                                                                       \
+  X(NullAnimation, NULL_ANIMATION)                                                                                     \
+  X(NullAnimations, NULL_ANIMATIONS)                                                                                   \
+  X(Nulls, NULLS)                                                                                                      \
+  X(Open, OPEN)                                                                                                        \
+  X(Pan, PAN)                                                                                                          \
+  X(Particle, PARTICLE)                                                                                                \
+  X(Particles, PARTICLES)                                                                                              \
+  X(Play, PLAY)                                                                                                        \
+  X(Player, PLAYER)                                                                                                    \
+  X(Pool, POOL)                                                                                                        \
+  X(PoolEntry, POOL_ENTRY)                                                                                             \
+  X(Pools, POOLS)                                                                                                      \
+  X(PostDigest, POST_DIGEST)                                                                                           \
+  X(Random, RANDOM)                                                                                                    \
+  X(Rarities, RARITIES)                                                                                                \
+  X(Rarity, RARITY)                                                                                                    \
+  X(Region, REGION)                                                                                                    \
+  X(Release, RELEASE)                                                                                                  \
+  X(Return, RETURN_)                                                                                                   \
+  X(RootAnimation, ROOT_ANIMATION)                                                                                     \
+  X(Save, SAVE)                                                                                                        \
+  X(Select, SELECT)                                                                                                    \
+  X(Settings, SETTINGS)                                                                                                \
+  X(Sound, SOUND)                                                                                                      \
+  X(Sounds, SOUNDS)                                                                                                    \
+  X(Spritesheet, SPRITESHEET)                                                                                          \
+  X(Spritesheets, SPRITESHEETS)                                                                                        \
+  X(Stage, STAGE)                                                                                                      \
+  X(Stages, STAGES)                                                                                                    \
+  X(StageUp, STAGE_UP)                                                                                                 \
+  X(Start, START)                                                                                                      \
+  X(String, STRING)                                                                                                    \
+  X(Strings, STRINGS)                                                                                                  \
+  X(Summon, SUMMON)                                                                                                    \
+  X(Talk, TALK)                                                                                                        \
+  X(Text, TEXT)                                                                                                        \
+  X(TextPlayback, TEXT_PLAYBACK)                                                                                       \
+  X(Throw, THROW)                                                                                                      \
+  X(Trigger, TRIGGER)                                                                                                  \
+  X(Triggers, TRIGGERS)                                                                                                \
+  X(Unknown, UNKNOWN)                                                                                                  \
+  X(Upgrade, UPGRADE)                                                                                                  \
+  X(UpgradeFail, UPGRADE_FAIL)                                                                                         \
+  X(Warning, WARNING)                                                                                                  \
+  X(Zoom, ZOOM)
+#define GAME_SCHEMA_ELEMENT_FIELDS(X, DATA)                                                                            \
+  X(DATA, MEMBER_ATTRIBUTE, airResistance, float, "Air Resistance", FLOAT,     \
+    "AirResistance", "", "", airResistance)                                                                            \
+  X(DATA, ATTRIBUTE, tint.a, void, "Alpha Tint", COLOR_RO,     \
+    "AlphaTint", "", "", tint.a)                                                                                       \
+  X(DATA, MEMBER_ATTRIBUTE, amplitude, float, "Amplitude", FLOAT, "Amplitude", "", "",           \
+    amplitude)                                                                                                         \
+  X(DATA, MEMBER_ATTRIBUTE, animation, std::string, "Animation", STRING, "Animation", "", "", animation)            \
+  X(DATA, MEMBER_ATTRIBUTE, animationAppendID, std::string, "Append String For Animations", STRING, "AppendStringForAnimations", "", "", animationAppendID) \
+  X(DATA, MEMBER_ATTRIBUTE, animationCursorActive, std::string, "Animation Cursor Active", STRING, "AnimationCursorActive", "", "",                      \
+    animationCursorActive)                                                                                             \
+  X(DATA, MEMBER_ATTRIBUTE, animationCursorHover, std::string, "Animation Cursor Hover", STRING, "AnimationCursorHover", "", "",                      \
+    animationCursorHover)                                                                                              \
+  X(DATA, MEMBER_ATTRIBUTE, anm2, std::string, "ANM2", STRING,    \
+    "Anm2", "", "", anm2)                                                                                              \
+  X(DATA, MEMBER_ATTRIBUTE, anm2RootPath, std::string, "ANM2 Root Path", STRING, "Anm2RootPath", "", "", anm2RootPath)              \
+  X(DATA, MEMBER_ATTRIBUTE, areaID, int, "Area ID", INT_RW, "AreaID", "",    \
+    "", areaID)                                                                                                        \
+  X(DATA, MEMBER_ATTRIBUTE, atFrame, int, "At Frame", INT_RW, "AtFrame",  \
+    "", "", atFrame)                                                                                                   \
+  X(DATA, MEMBER_ATTRIBUTE, baseAnm2, std::string, "Base ANM2",       \
+    STRING, "BaseAnm2", "", "", baseAnm2)                                                                              \
+  X(DATA, MEMBER_ATTRIBUTE, blinkChance, float, "Blink Chance", FLOAT,     \
+    "BlinkChance", "", "", blinkChance)                                                                                \
+  X(DATA, MEMBER_ATTRIBUTE, blipDelayTicks, int, "Blip Delay Ticks", INT_RW, "BlipDelayTicks", "", "",              \
+    blipDelayTicks)                                                                                                    \
+  X(DATA, ATTRIBUTE, colorOffset.b, void, "Blue Offset",       \
+    COLOR_RO, "BlueOffset", "", "", colorOffset.b)                                                                     \
+  X(DATA, ATTRIBUTE, tint.b, void, "Blue Tint", COLOR_RO,      \
+    "BlueTint", "", "", tint.b)                                                                                        \
+  X(DATA, MEMBER_ATTRIBUTE, calories, float, "Calories", FLOAT, "Calories", "", "",   \
+    calories)                                                                                                          \
+  X(DATA, MEMBER_ATTRIBUTE, caloriesToKilogram, float, "Calories To Kilogram", FLOAT, "CaloriesToKilogram", "", "", caloriesToKilogram)     \
+  X(DATA, MEMBER_ATTRIBUTE, capacityCalories, float, "Capacity Calories",     \
+    FLOAT, "CapacityCalories", "", "", capacityCalories)                                                              \
+  X(DATA, MEMBER_ATTRIBUTE, capacityBonus, float, "Capacity Bonus", FLOAT,   \
+    "CapacityBonus", "", "", capacityBonus)                                                                            \
+  X(DATA, MEMBER_ATTRIBUTE, capacityIfOverStuffedOnDigestBonus, float, "Capacity If Overstuffed On Digest Bonus", FLOAT, "CapacityIfOverStuffedOnDigestBonus", "", "",  \
+    capacityIfOverStuffedOnDigestBonus)                                                                                \
+  X(DATA, MEMBER_ATTRIBUTE, capacityMaxCalories, float, "Capacity Max Calories", \
+    FLOAT, "CapacityMaxCalories", "", "", capacityMaxCalories)                                                        \
+  X(DATA, MEMBER_ATTRIBUTE, capacityOverstuffedMultiplier, float, "Capacity Overstuffed Multiplier", FLOAT, "CapacityOverstuffedMultiplier", "", "",              \
+    capacityOverstuffedMultiplier)                                                                                     \
+  X(DATA, MEMBER_ATTRIBUTE, capacityMinCalories, float, "Capacity Min Calories", \
+    FLOAT, "CapacityMinCalories", "", "", capacityMinCalories)                                                        \
+  X(DATA, MEMBER_ATTRIBUTE, category, std::string, "Category", STRING,     \
+    "Category", "", "", category)                                                                                      \
+  X(DATA, MEMBER_ATTRIBUTE, character, std::string, "Character", STRING, "Character", "", "", character)             \
+  X(DATA, MEMBER_ATTRIBUTE, chanceOnNewGame, float, "Chance On New Game", FLOAT, "ChanceOnNewGame", "", "", chanceOnNewGame)           \
+  X(DATA, MEMBER_ATTRIBUTE, color, glm::vec3, "Color", VEC3, "ColorR", "ColorG", "ColorB", color)  \
+  X(DATA, MEMBER_ATTRIBUTE, count, int, "Count", INT_RW, "Count", "", "", count)             \
+  X(DATA, MEMBER_ATTRIBUTE, credits, std::string, "Credits",       \
+    STRING, "Credits", "", "", credits)                                                                                \
+  X(DATA, MEMBER_ATTRIBUTE, death, std::string, "Death", STRING, "Death", "",  \
+    "", death)                                                                                                         \
+  X(DATA, MEMBER_ATTRIBUTE, deathDialoguePoolID, std::string, "Death Dialogue Pool", STRING, "DeathDialoguePool", "", "", deathDialoguePoolID)               \
+  X(DATA, MEMBER_ATTRIBUTE, delayTicks, int, "Delay Ticks", INT_RW,            \
+    "DelayTicks", "", "", delayTicks)                                                                                 \
+  X(DATA, MEMBER_ATTRIBUTE, defaultAnimation, std::string, "Default Animation", STRING, "DefaultAnimation", "", "",               \
+    defaultAnimation)                                                                                                  \
+  X(DATA, MEMBER_ATTRIBUTE, description, std::string, "Description", STRING,       \
+    "Description", "", "", description)                                                                                \
+  X(DATA, MEMBER_ATTRIBUTE, dialoguePoolID, std::string, "Dialogue Pool", STRING, "DialoguePool", "", "", dialoguePoolID)               \
+  X(DATA, MEMBER_ATTRIBUTE, dialoguePoolIDFull, std::string, "Dialogue Pool Full", STRING, "DialoguePoolFull", "", "", dialoguePoolIDFull)          \
+  X(DATA, MEMBER_ATTRIBUTE, digestionBonus, float, "Digestion Bonus",       \
+    FLOAT, "DigestionBonus", "", "", digestionBonus)                                                                   \
+  X(DATA, MEMBER_ATTRIBUTE, digestionBonusOnClick, float, "Digestion Bonus On Click", FLOAT, "DigestionBonusOnClick", "", "", digestionBonusOnClick)        \
+  X(DATA, MEMBER_ATTRIBUTE, digestionBonusOnHover, float, "Digestion Bonus On Hover", FLOAT, "DigestionBonusOnHover", "", "", digestionBonusOnHover)        \
+  X(DATA, MEMBER_ATTRIBUTE, digestionProgress, float, "Digestion Progress",       \
+    FLOAT, "DigestionProgress", "", "", digestionProgress)                                                             \
+  X(DATA, MEMBER_ATTRIBUTE, digestionRate, float, "Digestion Rate Per Second",        \
+    FLOAT_PER_SECOND,                                                                                                  \
+    "DigestionRatePerSecond", "", "", digestionRate)                                                                   \
+  X(DATA, MEMBER_ATTRIBUTE, digestionRateMax, float, "Digestion Rate Per Second Max",                                                                                   \
+    FLOAT_PER_SECOND, "DigestionRatePerSecondMax", "", "", digestionRateMax)                                           \
+  X(DATA, MEMBER_ATTRIBUTE, digestionRateMin, float, "Digestion Rate Per Second Min",                                                                                   \
+    FLOAT_PER_SECOND, "DigestionRatePerSecondMin", "", "", digestionRateMin)                                           \
+  X(DATA, MEMBER_ATTRIBUTE, digestionTimer, int, "Digestion Timer", INT_RW,          \
+    "DigestionTimer", "", "", digestionTimer)                                                                          \
+  X(DATA, MEMBER_ATTRIBUTE, digestionTimerMax, int, "Digestion Timer Max", INT_RW,   \
+    "DigestionTimerMax", "", "", digestionTimerMax)                                                                    \
+  X(DATA, MEMBER_ATTRIBUTE, durability, int, "Durability", INT_RW, "Durability", \
+    "", "", durability)                                                                                                \
+  X(DATA, MEMBER_ATTRIBUTE, eatSpeedMultiplier, float, "Eat Speed Multiplier",     \
+    FLOAT, "EatSpeedMultiplier", "", "", eatSpeedMultiplier)                                                          \
+  X(DATA, MEMBER_ATTRIBUTE, eatSpeedBonus, float, "Eat Speed Bonus",     \
+    FLOAT, "EatSpeedBonus", "", "", eatSpeedBonus)                                                                     \
+  X(DATA, MEMBER_ATTRIBUTE, eatSpeedMaxMultiplier, float, "Eat Speed Max Multiplier", FLOAT, "EatSpeedMaxMultiplier", "", "", eatSpeedMaxMultiplier)                \
+  X(DATA, MEMBER_ATTRIBUTE, eatSpeedMinMultiplier, float, "Eat Speed Min Multiplier", FLOAT, "EatSpeedMinMultiplier", "", "", eatSpeedMinMultiplier)                \
+  X(DATA, MEMBER_ATTRIBUTE, end, int, "End", INT_RW, "End",    \
+    "", "", end)                                                                                                       \
+  X(DATA, MEMBER_ATTRIBUTE, event, std::string, "Event To Activate", STRING,                                                            \
+    "EventToActivate", "", "", event)                                                                                  \
+  X(DATA, MEMBER_ATTRIBUTE, eventID, int, "Event ID", INT_RW, "EventId", "",    \
+    "", eventID)                                                                                                       \
+  X(DATA, MEMBER_ATTRIBUTE, flavor, std::string, "Flavor", STRING, "Flavor", \
+    "", "", flavor)                                                                                                    \
+  X(DATA, MEMBER_ATTRIBUTE, font, std::string, "Font", STRING, "Font",  \
+    "", "", font)                                                                                                      \
+  X(DATA, MEMBER_ATTRIBUTE, fontRootPath, std::string, "Font Root Path", STRING, "FontRootPath", "", "", fontRootPath)              \
+  X(DATA, MEMBER_ATTRIBUTE, frameNum, int, "Frame Number", INT_RW, "FrameNum",  \
+    "", "", frameNum)                                                                                                  \
+  X(DATA, MEMBER_ATTRIBUTE, frequency, float, "Frequency", \
+    FLOAT, "Frequency", "", "", frequency)                                                                             \
+  X(DATA, MEMBER_ATTRIBUTE, friction, float, "Friction", FLOAT, "Friction", "", \
+    "", friction)                                                                                                      \
+  X(DATA, MEMBER_ATTRIBUTE, gravity, float, "Gravity", FLOAT,          \
+    "Gravity", "", "", gravity)                                                                                        \
+  X(DATA, ATTRIBUTE, colorOffset.g, void, "Green Offset",      \
+    COLOR_RO, "GreenOffset", "", "", colorOffset.g)                                                                    \
+  X(DATA, ATTRIBUTE, tint.g, void, "Green Tint", COLOR_RO,     \
+    "GreenTint", "", "", tint.g)                                                                                       \
+  X(DATA, MEMBER_ATTRIBUTE, gurgleChanceFromCapacityMultiplier, float, "Gurgle Chance From Capacity Multiplier", FLOAT, "GurgleChanceFromCapacityMultiplier", "", "",       \
+    gurgleChanceFromCapacityMultiplier)                                                                                \
+  X(DATA, MEMBER_ATTRIBUTE, gurgleChance, float, "Gurgle Chance", FLOAT,      \
+    "GurgleChance", "", "", gurgleChance)                                                                              \
+  X(DATA, MEMBER_ATTRIBUTE, hitboxNull, std::string, "Hitbox Null",   \
+    STRING, "HitboxNull", "", "", hitboxNull)                                                                          \
+  X(DATA, MEMBER_ATTRIBUTE, hurtDialoguePoolID, std::string, "Hurt Dialogue Pool", STRING, "HurtDialoguePool", "", "", hurtDialoguePoolID)                  \
+  X(DATA, MEMBER_ATTRIBUTE, iconGlyph, std::string, "Glyph From Icon Font", STRING, "GlyphFromIconFont", "", "", iconGlyph)             \
+  X(DATA, MEMBER_ATTRIBUTE, iconsFont, std::string, "Icons Font",  \
+    STRING, "IconsFont", "", "", iconsFont)                                                                            \
+  X(DATA, MEMBER_ATTRIBUTE, id, int, "ID", INT_RO, "Id", "", "", id)                      \
+  X(DATA, ATTRIBUTE, id, int, "ID", INT_RW, "ID", "", "", id)                             \
+  X(DATA, MEMBER_ATTRIBUTE, idString, std::string, "Label", STRING, "Label", "", "", idString)       \
+  X(DATA, MEMBER_ATTRIBUTE, idleString, std::string, "Idle", STRING, "Idle",    \
+    "", "", idleString)                                                                                                \
+  X(DATA, MEMBER_ATTRIBUTE, interpolated, bool, "Interpolated", BOOL, \
+    "Interpolated", "", "", interpolated)                                                                              \
+  X(DATA, MEMBER_ATTRIBUTE, isAlternateSpritesheet, bool, "Is Alternate Spritesheet", BOOL, "IsAlternateSpritesheet", "", "",                     \
+    isAlternateSpritesheet)                                                                                            \
+  X(DATA, MEMBER_ATTRIBUTE, isDigesting, bool, "Is Digesting",  \
+    BOOL, "IsDigesting", "", "", isDigesting)                                                                          \
+  X(DATA, MEMBER_ATTRIBUTE, isDisableTalk, bool, "Is Disable Talk", BOOL, "IsDisableTalk", "",  \
+    "", isDisableTalk)                                                                                                 \
+  X(DATA, MEMBER_ATTRIBUTE, isEdible, bool, "Is Edible", BOOL, "IsEdible", \
+    "", "", isEdible)                                                                                                  \
+  X(DATA, MEMBER_ATTRIBUTE, isHidden, bool, "Is Hidden",      \
+    BOOL, "IsHidden", "", "", isHidden)                                                                                \
+  X(DATA, MEMBER_ATTRIBUTE, isHold, bool, "Is Hold", BOOL, "IsHold",   \
+    "", "", isHold)                                                                                                    \
+  X(DATA, MEMBER_ATTRIBUTE, isPostgame, bool, "Is Postgame",      \
+    BOOL, "IsPostgame", "", "", isPostgame)                                                                            \
+  X(DATA, MEMBER_ATTRIBUTE, isToggleSpritesheet, bool, "Is Toggle Spritesheet", BOOL, "IsToggleSpritesheet", "", "", isToggleSpritesheet)      \
+  X(DATA, MEMBER_ATTRIBUTE, isAudioMuted, bool, "Is Audio Muted", BOOL,               \
+    "IsAudioMuted", "", "", isAudioMuted)                                                                             \
+  X(DATA, MEMBER_ATTRIBUTE, isUseCharacterColor, bool, "Is Use Character Color", BOOL, "IsUseCharacterColor", "", "", isUseCharacterColor)    \
+  X(DATA, MEMBER_ATTRIBUTE, layer, std::string, "Layer", STRING,        \
+    "Layer", "", "", layer)                                                                                            \
+  X(DATA, MEMBER_ATTRIBUTE, layerDestination, std::string, "Layer Destination", STRING, "LayerDestination", "", "", layerDestination)               \
+  X(DATA, MEMBER_ATTRIBUTE, layerID, int, "Layer ID", INT_RW, "LayerId", "", "",     \
+    layerID)                                                                                                           \
+  X(DATA, MEMBER_ATTRIBUTE, layerSource, std::string, "Layer Source",        \
+    STRING, "LayerSource", "", "", layerSource)                                                                        \
+  X(DATA, MEMBER_ATTRIBUTE, lastCharacter, std::string, "Last Character", STRING, "LastCharacter", "", "", lastCharacter)                          \
+  X(DATA, MEMBER_ATTRIBUTE, isLoop, bool, "Loop", BOOL, "Loop", "",    \
+    "", isLoop)                                                                                                        \
+  X(DATA, MEMBER_ATTRIBUTE, magnitude, float, "Magnitude", FLOAT,   \
+    "Magnitude", "", "", magnitude)                                                                                    \
+  X(DATA, MEMBER_ATTRIBUTE, measurementSystem, std::string, "Measurement System", STRING, "MeasurementSystem", "", "", measurementSystem)                \
+  X(DATA, MEMBER_ATTRIBUTE, name, std::string, "Name", STRING,        \
+    "Name", "", "", name)                                                                                              \
+  X(DATA, MEMBER_ATTRIBUTE, next, std::string, "Next", STRING, "Next", "", \
+    "", next)                                                                                                          \
+  X(DATA, MEMBER_ATTRIBUTE, null, std::string, "Null", STRING, "Null",   \
+    "", "", null)                                                                                                      \
+  X(DATA, MEMBER_ATTRIBUTE, nullID, int, "Null ID", INT_RW, "NullId", "", "", nullID) \
+  X(DATA, MEMBER_ATTRIBUTE, overrideTintLayer, std::string, "Override Tint Layer", STRING, "OverrideTintLayer", "", "", overrideTintLayer)       \
+  X(DATA, MEMBER_ATTRIBUTE, path, std::string, "Path", STRING, "Path", "",  \
+    "", path)                                                                                                          \
+  X(DATA, MEMBER_ATTRIBUTE, period, float, "Period",       \
+    FLOAT, "Period", "", "", period)                                                                                   \
+  X(DATA, MEMBER_ATTRIBUTE, poolID, std::string, "Pool", STRING, "Pool", "",      \
+    "", poolID)                                                                                                        \
+  X(DATA, ATTRIBUTE, portrait.path, void, "Portrait",          \
+    STRING_TARGET, "Portrait", "", "", portrait.path)                                                                  \
+  X(DATA, MEMBER_ATTRIBUTE, position, glm::vec2, "Position", VEC2, "PositionX",       \
+    "PositionY", "", position)                                                                                         \
+  X(DATA, MEMBER_ATTRIBUTE, quantity, int, "Quantity", INT_RW, "Quantity", "", "",      \
+    quantity)                                                                                                          \
+  X(DATA, MEMBER_ATTRIBUTE, quantityMax, int, "Quantity Max", INT_RW,             \
+    "QuantityMax", "", "", quantityMax)                                                                                \
+  X(DATA, MEMBER_ATTRIBUTE, rarity, std::string, "Rarity", STRING, "Rarity", \
+    "", "", rarity)                                                                                                    \
+  X(DATA, ATTRIBUTE, colorOffset.r, void, "Red Offset",        \
+    COLOR_RO, "RedOffset", "", "", colorOffset.r)                                                                      \
+  X(DATA, ATTRIBUTE, tint.r, void, "Red Tint", COLOR_RO,       \
+    "RedTint", "", "", tint.r)                                                                                         \
+  X(DATA, MEMBER_ATTRIBUTE, regionID, int, "Region ID", INT_RW,         \
+    "RegionId", "", "", regionID)                                                                                      \
+  X(DATA, ATTRIBUTE, render.path, void, "Render",              \
+    STRING_TARGET, "Render", "", "", render.path)                                                                      \
+  X(DATA, MEMBER_ATTRIBUTE, rotation, float, "Rotation", FLOAT, "Rotation", "",    \
+    "", rotation)                                                                                                      \
+  X(DATA, MEMBER_ATTRIBUTE, rotationSpeed, float, "Rotation Speed", FLOAT, "RotationSpeed", \
+    "", "", rotationSpeed)                                                                                             \
+  X(DATA, MEMBER_ATTRIBUTE, rotationSpeedFriction, float, "Rotation Speed Friction", FLOAT, "RotationSpeedFriction", "", "", rotationSpeedFriction)               \
+  X(DATA, MEMBER_ATTRIBUTE, rotationSpeedMax, float, "Rotation Speed Max", FLOAT,           \
+    "RotationSpeedMax", "", "", rotationSpeedMax)                                                                      \
+  X(DATA, MEMBER_ATTRIBUTE, rounding, float, "Button Rounding", FLOAT, "ButtonRounding", \
+    "", "", rounding)                                                                                                  \
+  X(DATA, MEMBER_ATTRIBUTE, scaleAdd, float, "Scale Multiplier Maximum", FLOAT,                                                                \
+    "ScaleMultiplierMaximum", "", "", scaleAdd)                                                                        \
+  X(DATA, MEMBER_ATTRIBUTE, scaleEffectAmplitude, float, "Scale Effect Amplitude", FLOAT, "ScaleEffectAmplitude", "", "", scaleEffectAmplitude)                 \
+  X(DATA, MEMBER_ATTRIBUTE, scaleEffectCycles, float, "Scale Effect Cycles",   \
+    FLOAT, "ScaleEffectCycles", "", "", scaleEffectCycles)                                                             \
+  X(DATA, MEMBER_ATTRIBUTE, isShowRect, bool, "Show Rect",    \
+    BOOL, "ShowRect", "", "", isShowRect)                                                                              \
+  X(DATA, MEMBER_ATTRIBUTE, sound, std::string, "Sound", STRING, "Sound", "", "", \
+    sound)                                                                                                             \
+  X(DATA, MEMBER_ATTRIBUTE, soundRootPath, std::string, "Sound Root Path", STRING, "SoundRootPath", "", "", soundRootPath)           \
+  X(DATA, MEMBER_ATTRIBUTE, spawn, std::string, "Spawn",        \
+    STRING, "Spawn", "", "", spawn)                                                                                    \
+  X(DATA, MEMBER_ATTRIBUTE, spawnChanceBase, float, "Spawn Chance Base",     \
+    FLOAT, "SpawnChanceBase", "", "", spawnChanceBase)                                                                 \
+  X(DATA, MEMBER_ATTRIBUTE, spawnChanceScoreBonus, float, "Spawn Chance Score Bonus", FLOAT, "SpawnChanceScoreBonus", "", "", spawnChanceScoreBonus)                  \
+  X(DATA, MEMBER_ATTRIBUTE, spawnPadding, float, "Spawn Padding", FLOAT,               \
+    "SpawnPadding", "", "", spawnPadding)                                                                              \
+  X(DATA, MEMBER_ATTRIBUTE, speed, float, "Speed", FLOAT, "Speed", "", "", speed)             \
+  X(DATA, MEMBER_ATTRIBUTE, speedGainBase, float, "Speed Gain Base",      \
+    FLOAT, "SpeedGainBase", "", "", speedGainBase)                                                                     \
+  X(DATA, MEMBER_ATTRIBUTE, speedGainScoreBonus, float, "Speed Gain Score Bonus",      \
+    FLOAT, "SpeedGainScoreBonus", "", "", speedGainScoreBonus)                                                         \
+  X(DATA, MEMBER_ATTRIBUTE, speedMax, float, "Speed Max", FLOAT, "SpeedMax", "", "", speedMax) \
+  X(DATA, MEMBER_ATTRIBUTE, speedMin, float, "Speed Min", FLOAT, "SpeedMin", "", "", speedMin) \
+  X(DATA, MEMBER_ATTRIBUTE, spritesheetID, int, "Spritesheet ID", INT_RW,      \
+    "SpritesheetId", "", "", spritesheetID)                                                                            \
+  X(DATA, MEMBER_ATTRIBUTE, start, int, "Start", INT_RW,     \
+    "Start", "", "", start)                                                                                            \
+  X(DATA, MEMBER_ATTRIBUTE, startTime, int, "Start Time", INT_RW, "StartTime",  \
+    "", "", startTime)                                                                                                 \
+  X(DATA, MEMBER_ATTRIBUTE, targetAcceleration, float, "Target Acceleration", FLOAT, "TargetAcceleration", "", "", targetAcceleration)                 \
+  X(DATA, MEMBER_ATTRIBUTE, text, std::string, "Text", STRING,        \
+    "Text", "", "", text)                                                                                              \
+  X(DATA, MEMBER_ATTRIBUTE, texture, std::string, "Texture", STRING, \
+    "Texture", "", "", texture)                                                                                        \
+  X(DATA, MEMBER_ATTRIBUTE, textureRootPath, std::string, "Texture Root Path", STRING, "TextureRootPath", "", "", textureRootPath)     \
+  X(DATA, MEMBER_ATTRIBUTE, thresholdKilograms, float, "Threshold Kilograms", FLOAT,  \
+    "ThresholdKilograms", "", "", thresholdKilograms)                                                                  \
+  X(DATA, MEMBER_ATTRIBUTE, ticksSurvived, int, "Ticks Survived", INT_RW,                \
+    "TicksSurvived", "", "", ticksSurvived)                                                                            \
+  X(DATA, MEMBER_ATTRIBUTE, timeTicks, float, "Time Ticks", FLOAT, "TimeTicks", \
+    "", "", timeTicks)                                                                                                 \
+  X(DATA, MEMBER_ATTRIBUTE, timeAfterHurt, int, "Time After Hurt", INT_RW,        \
+    "TimeAfterHurt", "", "", timeAfterHurt)                                                                            \
+  X(DATA, MEMBER_ATTRIBUTE, timeToActivateNewDialogueTicks, int, "Time To Activate New Dialogue Ticks", INT_RW, "TimeToActivateNewDialogueTicks", "", "",  \
+    timeToActivateNewDialogueTicks)                                                                                         \
+  X(DATA, MEMBER_ATTRIBUTE, title, std::string, "Title", STRING, "Title",  \
+    "", "", title)                                                                                                     \
+  X(DATA, MEMBER_ATTRIBUTE, totalCaloriesConsumed, float, "Total Calories Consumed", FLOAT, "TotalCaloriesConsumed", "", "", totalCaloriesConsumed)                \
+  X(DATA, MEMBER_ATTRIBUTE, totalFoodItemsEaten, int, "Total Food Items Eaten",     \
+    INT_RW, "TotalFoodItemsEaten", "", "", totalFoodItemsEaten)                                                        \
+  X(DATA, MEMBER_ATTRIBUTE, typeString, std::string, "Type", STRING, "Type", "",   \
+    "", typeString)                                                                                                    \
+  X(DATA, MEMBER_ATTRIBUTE, upgradeCount, int, "Upgrade Count", INT_RW,     \
+    "UpgradeCount", "", "", upgradeCount)                                                                              \
+  X(DATA, MEMBER_ATTRIBUTE, upgradeID, std::string, "Upgrade ID",       \
+    STRING, "UpgradeID", "", "", upgradeID)                                                                            \
+  X(DATA, MEMBER_ATTRIBUTE, value, int, "Value", INT_RW, "Value", "", "", value)             \
+  X(DATA, MEMBER_ATTRIBUTE, velocity, glm::vec2, "Velocity", VEC2, "VelocityX",       \
+    "VelocityY", "", velocity)                                                                                         \
+  X(DATA, MEMBER_ATTRIBUTE, isVisible, bool, "Visible", BOOL_FALSE,         \
+    "Visible", "", "", isVisible)                                                                                      \
+  X(DATA, MEMBER_ATTRIBUTE, volume, int, "Volume", INT_RW, "Volume", "", "", volume)          \
+  X(DATA, MEMBER_ATTRIBUTE, weight, float, "Weight", FLOAT, "Weight", "", "",      \
+    weight)                                                                                                            \
+  X(DATA, MEMBER_ATTRIBUTE, weightKilograms, float, "Weight Kilograms", FLOAT,         \
+    "WeightKilograms", "", "", weightKilograms)                                                                       \
+  X(DATA, MEMBER_ATTRIBUTE, weightMaxKilograms, float, "Weight Max Kilograms", FLOAT,  \
+    "WeightMaxKilograms", "", "", weightMaxKilograms)                                                                 \
+  X(DATA, MEMBER_ATTRIBUTE, size, glm::vec2, "Size", VEC2, "Width", "Height", "", size)              \
+  X(DATA, MEMBER_ATTRIBUTE, windowSize, glm::ivec2, "Window Size", IVEC2, "WindowW", "WindowH",  \
+    "", windowSize)                                                                                                    \
+  X(DATA, MEMBER_ATTRIBUTE, windowPosition, glm::vec2, "Window Position", VEC2, "WindowX",   \
+    "WindowY", "", windowPosition)                                                                                     \
+  X(DATA, MEMBER_ATTRIBUTE, crop, glm::vec2, "Crop", VEC2, "XCrop", "YCrop", "", crop)         \
+  X(DATA, MEMBER_ATTRIBUTE, pivot, glm::vec2, "Pivot", VEC2, "XPivot", "YPivot", "", pivot)     \
+  X(DATA, MEMBER_ATTRIBUTE, framePosition, glm::vec2, "Frame Position", VEC2,  \
+    "XPosition", "YPosition", "", framePosition)                                                                       \
+  X(DATA, MEMBER_ATTRIBUTE, scale, glm::vec2, "Scale", VEC2, "XScale", "YScale", "", scale)         \
+  X(DATA, MEMBER_ATTRIBUTE, zoom, float, "Zoom", FLOAT, "Zoom", "", "", zoom)           \
+  X(DATA, MEMBER, animationChew, std::string, "Animation Chew", NONE, "",  \
+    "", "", animationChew)                                                                                             \
+  X(DATA, MEMBER, animationClick, AnimationEntryCollection, "Animation Click", NONE, "", "", "", animationClick)                                \
+  X(DATA, MEMBER, animationGrab, AnimationEntryCollection, "Animation Grab", NONE, "", "", "", animationGrab)                                  \
+  X(DATA, MEMBER, animationHover, AnimationEntryCollection, "Animation Hover", NONE, "", "", "", animationHover)                                \
+  X(DATA, MEMBER, animationIdle, AnimationEntryCollection, "Animation Idle", NONE, "", "", "", animationIdle)                                  \
+  X(DATA, MEMBER, animationPan, AnimationEntryCollection, "Animation Pan", NONE, "", "", "", animationPan)                                    \
+  X(DATA, MEMBER, animationReturn, AnimationEntryCollection, "Animation Return", NONE, "", "", "", animationReturn)                              \
+  X(DATA, MEMBER, animationZoom, AnimationEntryCollection, "Animation Zoom", NONE, "", "", "", animationZoom)                                  \
+  X(DATA, MEMBER, anm2Entry, Anm2Entry, "ANM2 Entry", NONE, "", "", "",     \
+    anm2Entry)                                                                                                         \
+  X(DATA, MEMBER, children, std::vector<int>, "Children", NONE, "", "",   \
+    "", children)                                                                                                      \
+  X(DATA, MEMBER, colorOffset, glm::vec3, "Color Offset", NONE,    \
+    "", "", "", colorOffset)                                                                                           \
+  X(DATA, MEMBER, fontEntry, FontEntry, "Font Entry", NONE, "", "", "",     \
+    fontEntry)                                                                                                         \
+  X(DATA, MEMBER, iconsFontEntry, FontEntry, "Icons Font Entry", NONE, \
+    "", "", "", iconsFontEntry)                                                                                        \
+  X(DATA, MEMBER, parent, int, "Parent", NONE, "", "",   \
+    "", parent)                                                                                                        \
+  X(DATA, MEMBER, portrait, TextureEntry, "Portrait", NONE, "", \
+    "", "", portrait)                                                                                                  \
+  X(DATA, MEMBER, render, TextureEntry, "Render", NONE, "", "",   \
+    "", render)                                                                                                        \
+  X(DATA, MEMBER, soundBlip, SoundEntryCollection, "Sound Blip", NONE, "", "", "", \
+    soundBlip)                                                                                                         \
+  X(DATA, MEMBER, soundBounce, SoundEntryCollection, "Sound Bounce", NONE, "",   \
+    "", "", soundBounce)                                                                                               \
+  X(DATA, MEMBER, soundCheatsActivated, SoundEntryCollection, "Sound Cheats Activated", NONE, "", "", "", soundCheatsActivated)                            \
+  X(DATA, MEMBER, soundClose, SoundEntryCollection, "Sound Close", NONE, "", "",  \
+    "", soundClose)                                                                                                    \
+  X(DATA, MEMBER, soundCollect, SoundEntryCollection, "Sound Collect", NONE,    \
+    "", "", "", soundCollect)                                                                                          \
+  X(DATA, MEMBER, soundDigest, SoundEntryCollection, "Sound Digest", NONE, "",   \
+    "", "", soundDigest)                                                                                               \
+  X(DATA, MEMBER, soundDispose, SoundEntryCollection, "Sound Dispose", NONE,    \
+    "", "", "", soundDispose)                                                                                          \
+  X(DATA, MEMBER, soundEntries, SoundEntryCollection, "Sound Entries", NONE, "", "", "", soundEntries)                                  \
+  X(DATA, MEMBER, soundEntry, SoundEntry, "Sound Entry", NONE, "", "", "", \
+    soundEntry)                                                                                                        \
+  X(DATA, MEMBER, soundGrab, SoundEntryCollection, "Sound Grab", NONE, "", "", "", \
+    soundGrab)                                                                                                         \
+  X(DATA, MEMBER, soundGurgle, SoundEntryCollection, "Sound Gurgle", NONE, "",   \
+    "", "", soundGurgle)                                                                                               \
+  X(DATA, MEMBER, soundHover, SoundEntryCollection, "Sound Hover", NONE, "", "",  \
+    "", soundHover)                                                                                                    \
+  X(DATA, MEMBER, soundKill, SoundEntryCollection, "Sound Kill", NONE, "", "", "", \
+    soundKill)                                                                                                         \
+  X(DATA, MEMBER, soundLevelUp, SoundEntryCollection, "Sound Level Up", NONE,  \
+    "", "", "", soundLevelUp)                                                                                          \
+  X(DATA, MEMBER, soundLevelUpReady, SoundEntryCollection, "Sound Level Up Ready", NONE, "", "", "", soundLevelUpReady)                                 \
+  X(DATA, MEMBER, soundOpen, SoundEntryCollection, "Sound Open", NONE, "", "", "", \
+    soundOpen)                                                                                                         \
+  X(DATA, MEMBER, soundRelease, SoundEntryCollection, "Sound Release", NONE,    \
+    "", "", "", soundRelease)                                                                                          \
+  X(DATA, MEMBER, soundReturn, SoundEntryCollection, "Sound Return", NONE, "",   \
+    "", "", soundReturn)                                                                                               \
+  X(DATA, MEMBER, soundSelect, SoundEntryCollection, "Sound Select", NONE, "",   \
+    "", "", soundSelect)                                                                                               \
+  X(DATA, MEMBER, soundSummon, SoundEntryCollection, "Sound Summon", NONE, "",   \
+    "", "", soundSummon)                                                                                               \
+  X(DATA, MEMBER, soundThrow, SoundEntryCollection, "Sound Throw", NONE, "", "",  \
+    "", soundThrow)                                                                                                    \
+  X(DATA, MEMBER, soundUpgrade, SoundEntryCollection, "Sound Upgrade", NONE,    \
+    "", "", "", soundUpgrade)                                                                                          \
+  X(DATA, MEMBER, soundUpgradeFail, SoundEntryCollection, "Sound Upgrade Fail", NONE, "", "", "", soundUpgradeFail)                                 \
+  X(DATA, MEMBER, textureEntry, TextureEntry, "Texture Entry", NONE, "", \
+    "", "", textureEntry)                                                                                              \
+  X(DATA, MEMBER, tint, glm::vec4, "Tint", NONE, "", "", "", tint)        \
+  X(DATA, MEMBER, type, Type, "Type", NONE, "", "", "", type)
+
+#define GAME_SCHEMA_ELEMENT_MEMBER_DISPATCH(DATA, CATEGORY, SYMBOL, TYPE, NAME, KIND, KEY, KEY_2, KEY_3, MEMBER)      \
+  GAME_SCHEMA_ELEMENT_MEMBER_DISPATCH_##CATEGORY(DATA, SYMBOL, TYPE, NAME, KIND, KEY, KEY_2, KEY_3, MEMBER)
+#define GAME_SCHEMA_ELEMENT_MEMBER_DISPATCH_MEMBER(DATA, SYMBOL, TYPE, NAME, KIND, KEY, KEY_2, KEY_3, MEMBER)         \
+  DATA(SYMBOL, TYPE, NAME)
+#define GAME_SCHEMA_ELEMENT_MEMBER_DISPATCH_MEMBER_ATTRIBUTE(DATA, SYMBOL, TYPE, NAME, KIND, KEY, KEY_2, KEY_3,        \
+                                                             MEMBER)                                                   \
+  DATA(SYMBOL, TYPE, NAME)
+#define GAME_SCHEMA_ELEMENT_MEMBER_DISPATCH_ATTRIBUTE(DATA, SYMBOL, TYPE, NAME, KIND, KEY, KEY_2, KEY_3, MEMBER)
+#define GAME_SCHEMA_ELEMENT_MEMBERS(X) GAME_SCHEMA_ELEMENT_FIELDS(GAME_SCHEMA_ELEMENT_MEMBER_DISPATCH, X)
+
+#define GAME_SCHEMA_ELEMENT_ATTRIBUTE_DISPATCH(DATA, CATEGORY, SYMBOL, TYPE, NAME, KIND, KEY, KEY_2, KEY_3, MEMBER)   \
+  GAME_SCHEMA_ELEMENT_ATTRIBUTE_DISPATCH_##CATEGORY(DATA, SYMBOL, TYPE, NAME, KIND, KEY, KEY_2, KEY_3, MEMBER)
+#define GAME_SCHEMA_ELEMENT_ATTRIBUTE_DISPATCH_MEMBER(DATA, SYMBOL, TYPE, NAME, KIND, KEY, KEY_2, KEY_3, MEMBER)
+#define GAME_SCHEMA_ELEMENT_ATTRIBUTE_DISPATCH_MEMBER_ATTRIBUTE(DATA, SYMBOL, TYPE, NAME, KIND, KEY, KEY_2, KEY_3,     \
+                                                                MEMBER)                                                \
+  DATA(KIND, KEY, KEY_2, KEY_3, MEMBER)
+#define GAME_SCHEMA_ELEMENT_ATTRIBUTE_DISPATCH_ATTRIBUTE(DATA, SYMBOL, TYPE, NAME, KIND, KEY, KEY_2, KEY_3, MEMBER)   \
+  DATA(KIND, KEY, KEY_2, KEY_3, MEMBER)
+#define GAME_SCHEMA_ELEMENT_ATTRIBUTES(X) GAME_SCHEMA_ELEMENT_FIELDS(GAME_SCHEMA_ELEMENT_ATTRIBUTE_DISPATCH, X)
+
+namespace game::resource::xml
+{
+  struct Schema
+  {
+    struct TextureEntry
+    {
+      std::string path{};
+      Texture texture{};
+
+      bool is_valid() const { return texture.is_valid(); }
+    };
+
+    struct SoundEntry
+    {
+      std::string path{};
+      Audio sound{};
+      float weight{};
+
+      bool is_valid() const { return sound.is_valid(); }
+    };
+
+    struct FontEntry
+    {
+      std::string path{};
+      Font font{};
+
+      bool is_valid() const { return font.is_valid(); }
+    };
+
+    struct Anm2Entry
+    {
+      std::string path{};
+      Anm2 anm2{};
+
+      bool is_valid() const { return anm2.is_valid(); }
+    };
+
+    struct AnimationEntry
+    {
+      std::string animation{};
+      float weight{};
+    };
+
+    struct AnimationEntryCollection : std::vector<AnimationEntry>
+    {
+      std::string* get();
+    };
+
+    struct SoundEntryCollection : std::vector<SoundEntry*>
+    {
+      const Audio* get() const;
+      void play() const;
+    };
+
+    struct AreaEntry
+    {
+      Texture texture{};
+      Anm2 anm2{};
+      float gravity{};
+      float friction{};
+      float airResistance{};
+    };
+
+    struct Category
+    {
+      std::string name{};
+      bool isEdible{};
+    };
+
+    struct Rarity
+    {
+      std::string name{};
+      float weight{};
+      bool isHidden{};
+      Audio sound{};
+    };
+
+    struct Flavor
+    {
+      std::string name{};
+    };
+
+    struct ItemEntry
+    {
+      std::string name{};
+      std::string description{};
+      int categoryID{-1};
+      int rarityID{-1};
+      int flavorID{-1};
+      bool isFlavor{};
+      bool isCalories{};
+      bool isCapacityBonus{};
+      bool isDigestionBonus{};
+      bool isEatSpeedBonus{};
+      bool isGravity{};
+      bool isDurability{};
+      bool isColor{};
+      bool isUpgradeID{};
+      bool isUpgradeCount{};
+      bool isToggleSpritesheet{};
+      float calories{};
+      float capacityBonus{};
+      float digestionBonus{};
+      float eatSpeedBonus{};
+      float gravity{};
+      int durability{};
+      glm::vec3 color{};
+      int upgradeID{-1};
+      int upgradeCount{};
+    };
+
+    struct Element
+    {
+      enum Type
+      {
+#define GAME_SCHEMA_DECLARE_ELEMENT_TYPE(NAME, ENUM) ENUM,
+        GAME_SCHEMA_ELEMENT_TYPES(GAME_SCHEMA_DECLARE_ELEMENT_TYPE)
+#undef GAME_SCHEMA_DECLARE_ELEMENT_TYPE
+      };
+
+      struct MemberInfo
+      {
+        std::string_view symbol{};
+        std::string_view type{};
+        std::string_view name{};
+      };
+
+#define GAME_SCHEMA_DECLARE_ELEMENT_MEMBER(SYMBOL, TYPE, NAME) TYPE SYMBOL{};
+      GAME_SCHEMA_ELEMENT_MEMBERS(GAME_SCHEMA_DECLARE_ELEMENT_MEMBER)
+#undef GAME_SCHEMA_DECLARE_ELEMENT_MEMBER
+      std::vector<std::string> attributeOrder{};
+
+      inline static constexpr MemberInfo memberInfos[]{
+#define GAME_SCHEMA_ELEMENT_MEMBER_INFO(SYMBOL, TYPE, NAME) {#SYMBOL, #TYPE, NAME},
+          GAME_SCHEMA_ELEMENT_MEMBERS(GAME_SCHEMA_ELEMENT_MEMBER_INFO)
+#undef GAME_SCHEMA_ELEMENT_MEMBER_INFO
+      };
+
+      Element()
+      {
+        tint = glm::vec4(1.0f);
+        isVisible = true;
+        type = UNKNOWN;
+        parent = -1;
+      }
+
+      bool is_valid() const;
+      bool is_last() const;
+    };
+
+    using Pool = std::vector<int>;
+
+    std::vector<Element> elements{};
+    bool isValid{};
+    std::map<std::string, int> entryIDMap{};
+    std::map<int, std::string> entryIDMapReverse{};
+    std::map<std::string, int> poolMap{};
+    std::unordered_map<std::string, int> categoryMap{};
+    std::unordered_map<std::string, int> rarityMap{};
+    std::unordered_map<std::string, int> flavorMap{};
+    std::unordered_map<std::string, int> itemIDMap{};
+    std::unordered_map<int, std::string> itemIDMapReverse{};
+    std::unordered_map<int, std::vector<int>> itemPoolsByRarity{};
+    std::vector<long long> entrySelectionOrder{};
+    long long selectionCounter{};
+    std::vector<AreaEntry> areas{};
+    std::vector<Category> categories{};
+    std::vector<Rarity> rarities{};
+    std::vector<Flavor> flavors{};
+    std::vector<ItemEntry> items{};
+    std::vector<Anm2> anm2s{};
+    std::vector<int> rarityIDs{};
+    std::unordered_map<int, Pool> pools{};
+    std::unordered_map<std::string, int> stringToIDMap{};
+    std::unordered_map<int, std::string> idToStringMap{};
+    std::unordered_map<Element::Type, std::vector<int>> elementsByType{};
+    Anm2 baseAnm2{};
+    Font font{};
+    Font iconsFont{};
+    int durability{2};
+    int quantityMax{99};
+    float rounding{};
+
+    Schema() = default;
+    Schema(const Schema&);
+    Schema(Schema&&) noexcept;
+    explicit Schema(const std::filesystem::path&);
+    explicit Schema(const util::physfs::Path&);
+    Schema& operator=(const Schema&);
+    Schema& operator=(Schema&&) noexcept;
+
+    bool load(const std::filesystem::path&);
+    bool load(const util::physfs::Path&);
+    bool load_archive(const std::filesystem::path&, const std::string& innerPath);
+    void settings_default();
+    void serialize(const std::filesystem::path&) const;
+    bool is_valid() const;
+    Element* root();
+    const Element* root() const;
+    Element& element_add(Element::Type type, int parent = -1);
+    bool element_erase(int index);
+    int element_insert_xml(const std::string& text, int parent, int beforeSibling = -1);
+    bool element_move(int index, int parent, int beforeSibling = -1);
+    std::string element_serialize(int index) const;
+    Element* get(Element::Type type, int index = 0);
+    const Element* get(Element::Type type, int index = 0) const;
+    std::vector<Element*> get_all(Element::Type);
+    std::vector<const Element*> get_all(Element::Type) const;
+    Element* child_get(Element& element, Element::Type type, int index = 0);
+    const Element* child_get(const Element& element, Element::Type type, int index = 0) const;
+    std::vector<Element*> children_get(Element& element, Element::Type type);
+    std::vector<const Element*> children_get(const Element& element, Element::Type type) const;
+    Element* dialogue_entry_get(int id);
+    Element* dialogue_entry_get(const std::string& id);
+    Element* dialogue_entry_get(Element& reference);
+    Element* dialogue_pool_entry_get(int poolID);
+    Element* dialogue_pool_entry_get(const std::string& poolID);
+    Element* dialogue_pool_entry_get(Element& reference);
+    int dialogue_entry_id_get(const std::string& id) const;
+    int dialogue_pool_id_get(const std::string& id) const;
+    Element* item_get(int id);
+    Element* item_get(const std::string& id);
+    int item_id_get(const std::string& id) const;
+    std::vector<int>* item_pool_get(int rarityID);
+    void indices_refresh();
+  };
+}
diff --git a/src/resource/xml/strings.cpp b/src/resource/strings.cpp
similarity index 52%
rename from src/resource/xml/strings.cpp
rename to src/resource/strings.cpp
index 65064e0..1d9f0e9 100644
--- a/src/resource/xml/strings.cpp
+++ b/src/resource/strings.cpp
@@ -1,9 +1,9 @@
 #include "strings.hpp"
 
-#include "../../log.hpp"
-#include "util.hpp"
+#include "../log.hpp"
 
 #include <format>
+#include <tinyxml2/tinyxml2.h>
 
 using namespace tinyxml2;
 
@@ -11,6 +11,36 @@ namespace game::resource::xml
 {
   namespace
   {
+    XMLError document_load(const util::physfs::Path& path, XMLDocument& document)
+    {
+      if (!path.is_valid())
+      {
+        logger.error(std::format("Failed to open XML document: {} ({})", path.c_str(), util::physfs::error_get()));
+        return XML_ERROR_FILE_NOT_FOUND;
+      }
+
+      auto buffer = path.read();
+      if (buffer.empty())
+      {
+        logger.error(std::format("Failed to read XML document: {} ({})", path.c_str(), util::physfs::error_get()));
+        return XML_ERROR_FILE_COULD_NOT_BE_OPENED;
+      }
+
+      auto result = document.Parse((const char*)buffer.data(), buffer.size());
+      if (result != XML_SUCCESS)
+        logger.error(std::format("Failed to parse XML document: {} ({})", path.c_str(), document.ErrorStr()));
+
+      return result;
+    }
+
+    XMLError query_string_attribute(XMLElement* element, const char* attribute, std::string* value)
+    {
+      const char* temp = nullptr;
+      auto result = element->QueryStringAttribute(attribute, &temp);
+      if (result == XML_SUCCESS && temp && value) *value = temp;
+      return result;
+    }
+
     std::string definition_element_name_get(const Strings::Definition& definition)
     {
       std::string name = definition.attribute;
diff --git a/src/resource/xml/strings.hpp b/src/resource/strings.hpp
similarity index 68%
rename from src/resource/xml/strings.hpp
rename to src/resource/strings.hpp
index 34e3751..d4a2fe7 100644
--- a/src/resource/xml/strings.hpp
+++ b/src/resource/strings.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../../util/physfs.hpp"
+#include "../util/physfs.hpp"
 
 #include <array>
 #include <string>
@@ -9,21 +9,30 @@ namespace game::resource::xml
 {
 #define GAME_XML_STRING_LIST(X)                                                                                        \
   X(MenuTabInteract, "TextMenuTabInteract", "Interact")                                                                \
-  X(MenuTabArcade, "TextMenuTabArcade", "Arcade")                                                                      \
+  X(MenuTabGather, "TextMenuTabGather", "Gather")                                                                      \
   X(MenuTabInventory, "TextMenuTabInventory", "Inventory")                                                             \
   X(MenuTabSettings, "TextMenuTabSettings", "Settings")                                                                \
   X(MenuTabCheats, "TextMenuTabCheats", "Cheats")                                                                      \
   X(MenuOpenTooltip, "TextMenuOpenTooltip", "Open Main Menu")                                                          \
+  X(MenuOpenFullscreenTooltip, "TextMenuOpenFullscreenTooltip", "Open Fullscreen Main Menu")                           \
+  X(MenuRestoreTooltip, "TextMenuRestoreTooltip", "Restore Main Menu")                                                 \
   X(MenuCloseTooltip, "TextMenuCloseTooltip", "Close Main Menu")                                                       \
   X(InteractChatButton, "TextInteractChatButton", "Let's chat!")                                                       \
   X(InteractHelpButton, "TextInteractHelpButton", "Help")                                                              \
   X(InteractFeelingButton, "TextInteractFeelingButton", "How are you feeling?")                                        \
+  X(InteractStats, "TextInteractStats", "Stats")                                                                       \
   X(InteractWeightFormat, "TextInteractWeightFormat", "Weight: %0.2f %s (Stage: %i)")                                  \
   X(InteractCapacityFormat, "TextInteractCapacityFormat", "Capacity: %0.0f kcal (Max: %0.0f kcal)")                    \
   X(InteractDigestionRateFormat, "TextInteractDigestionRateFormat", "Digestion Rate: %0.2f%%/sec")                     \
   X(InteractEatingSpeedFormat, "TextInteractEatingSpeedFormat", "Eating Speed: %0.2fx")                                \
   X(InteractTotalCaloriesFormat, "TextInteractTotalCaloriesFormat", "Total Calories Consumed: %0.0f kcal")             \
   X(InteractTotalFoodItemsFormat, "TextInteractTotalFoodItemsFormat", "Total Food Items Eaten: %i")                    \
+  X(SettingsWindow, "TextSettingsWindow", "Window")                                                                    \
+  X(SettingsWindowMode, "TextSettingsWindowMode", "Mode")                                                              \
+  X(SettingsWindowModeTooltip, "TextSettingsWindowModeTooltip",                                                        \
+    "Switch between windowed and fullscreen display.\n(Shortcut: F)")                                                  \
+  X(SettingsWindowed, "TextSettingsWindowed", "Windowed")                                                              \
+  X(SettingsFullscreen, "TextSettingsFullscreen", "Fullscreen")                                                        \
   X(SettingsMeasurementSystem, "TextSettingsMeasurementSystem", "Measurement System")                                  \
   X(SettingsMetric, "TextSettingsMetric", "Metric")                                                                    \
   X(SettingsMetricTooltip, "TextSettingsMetricTooltip", "Use kilograms (kg).")                                         \
@@ -32,6 +41,8 @@ namespace game::resource::xml
   X(SettingsSound, "TextSettingsSound", "Sound")                                                                       \
   X(SettingsVolume, "TextSettingsVolume", "Volume")                                                                    \
   X(SettingsVolumeTooltip, "TextSettingsVolumeTooltip", "Adjust master volume.")                                       \
+  X(SettingsMute, "TextSettingsMute", "Mute")                                                                          \
+  X(SettingsMuteTooltip, "TextSettingsMuteTooltip", "Mute all audio.\n(Shortcut: M)")                                  \
   X(SettingsAppearance, "TextSettingsAppearance", "Appearance")                                                        \
   X(SettingsUseCharacterColor, "TextSettingsUseCharacterColor", "Use Character Color")                                 \
   X(SettingsUseCharacterColorTooltip, "TextSettingsUseCharacterColorTooltip",                                          \
@@ -50,7 +61,7 @@ namespace game::resource::xml
   X(ToolsHomeTooltip, "TextToolsHomeTooltip", "Reset camera view.\n(Shortcut: Home)")                                  \
   X(ToolsOpenTooltip, "TextToolsOpenTooltip", "Open Tools")                                                            \
   X(ToolsCloseTooltip, "TextToolsCloseTooltip", "Close Tools")                                                         \
-  X(InventoryEmptyHint, "TextInventoryEmptyHint", "Check the \"Arcade\" tab to earn rewards!")                         \
+  X(InventoryEmptyHint, "TextInventoryEmptyHint", "No items yet.")                                                     \
   X(InventoryFlavorFormat, "TextInventoryFlavorFormat", "Flavor: %s")                                                  \
   X(InventoryCaloriesFormat, "TextInventoryCaloriesFormat", "%0.0f kcal")                                              \
   X(InventoryDurabilityFormat, "TextInventoryDurabilityFormat", "Durability: %i")                                      \
@@ -64,48 +75,18 @@ namespace game::resource::xml
   X(InventoryUpgradePreviewFormat, "TextInventoryUpgradePreviewFormat", "Upgrade: %ix -> %s")                          \
   X(InventoryUnknown, "TextInventoryUnknown", "???")                                                                   \
   X(InventorySpawnButton, "TextInventorySpawnButton", "Spawn")                                                         \
+  X(InventoryEnableAutofeedButton, "TextInventoryEnableAutofeedButton", "Enable Autofeed")                            \
+  X(InventoryDisableAutofeedButton, "TextInventoryDisableAutofeedButton", "Disable Autofeed")                         \
+  X(InventoryEnableAutofeedTooltip, "TextInventoryEnableAutofeedTooltip",                                              \
+    "Serve the character food and assist in digestion automatically.")                                                 \
+  X(InventoryDisableAutofeedTooltip, "TextInventoryDisableAutofeedTooltip",                                            \
+    "Return to manual interaction.")                                                                                  \
   X(InventoryUpgradeButton, "TextInventoryUpgradeButton", "Upgrade")                                                   \
   X(InventoryUpgradeAllButton, "TextInventoryUpgradeAllButton", "Upgrade All")                                         \
   X(InventoryUpgradeNoPath, "TextInventoryUpgradeNoPath", "This item cannot be upgraded.")                             \
   X(InventoryUpgradeNeedsTemplate, "TextInventoryUpgradeNeedsTemplate", "Needs {}x to upgrade into {}!")               \
   X(InventoryUpgradeOneTemplate, "TextInventoryUpgradeOneTemplate", "Use {}x to upgrade into 1x {}.")                  \
   X(InventoryUpgradeAllTemplate, "TextInventoryUpgradeAllTemplate", "Use {}x to upgrade into {}x {}.")                 \
-  X(ArcadeSkillCheckName, "TextArcadeSkillCheckName", "Skill Check")                                                   \
-  X(ArcadeSkillCheckDescription, "TextArcadeSkillCheckDescription",                                                    \
-    "Test your timing! Aim for specific zones for rewards.")                                                           \
-  X(ArcadeDungeonName, "TextArcadeDungeonName", "Dungeon")                                                             \
-  X(ArcadeDungeonDescription, "TextArcadeDungeonDescription",                                                          \
-    "A placeholder dungeon adventure entry. Use this as a template for a future arcade game.")                         \
-  X(ArcadeOrbitName, "TextArcadeOrbitName", "Orbit")                                                                   \
-  X(ArcadeOrbitDescription, "TextArcadeOrbitDescription",                                                              \
-    "Move colored objects orbiting around the cursor into similarly colored enemies!")                                 \
-  X(ArcadeHowToPlay, "TextArcadeHowToPlay", "How to Play")                                                             \
-  X(ArcadeSkillCheckHowToPlay, "TextArcadeSkillCheckHowToPlay",                                                        \
-    "Press Space or click to stop the line inside the colored target zones.\nEach success builds score and combo, "    \
-    "and high scores improve your reward chances, while increasing game speed and tightening the zones.\nMissing the " \
-    "colored zones ends the run.")                                                                                     \
-  X(ArcadeDungeonHowToPlay, "TextArcadeDungeonHowToPlay",                                                              \
-    "This is currently a template page.\nUse it to prototype dungeon rules, rewards, room flow, and UI layout.")      \
-  X(ArcadeOrbitHowToPlay, "TextArcadeOrbitHowToPlay",                                                                  \
-    "Control an object with your cursor.\nThere will be colored, orbiting objects around it.\nUse the mouse buttons "  \
-    "to move the objects around your orbit.\nEnemies will appear with the same color as the orbiting objects.\nMatch " \
-    "the colors of the orbiting objects into the same colored enemies for score.\nOver time, more colors will be "     \
-    "added nearby the cursor, and more enemies will appear.\nEnemies will also get faster with time.\nHow long can "   \
-    "you survive?!")                                                                                                   \
-  X(ArcadeDungeonTemplateTitle, "TextArcadeDungeonTemplateTitle", "Dungeon Template")                                  \
-  X(ArcadeDungeonTemplateBody, "TextArcadeDungeonTemplateBody",                                                        \
-    "This screen is a placeholder for the Dungeon arcade game.\nAdd room generation, encounters, rewards, and any "   \
-    "character-specific hooks here.\nUse the Back button below to return to the arcade menu.")                         \
-  X(ArcadeScoreFormat, "TextArcadeScoreFormat", "Score: %i pts")                                                       \
-  X(ArcadeScoreComboFormat, "TextArcadeScoreComboFormat", "Score: %i pts (%ix)")                                       \
-  X(ArcadePlayButton, "TextArcadePlayButton", "Play")                                                                  \
-  X(ArcadeInfoButton, "TextArcadeInfoButton", "Info")                                                                  \
-  X(ArcadeBackButton, "TextArcadeBackButton", "Back")                                                                  \
-  X(ArcadeStats, "TextArcadeStats", "Stats")                                                                           \
-  X(ArcadeBestScoreFormat, "TextArcadeBestScoreFormat", "Best: %i pts")                                                \
-  X(ArcadeBestScoreComboFormat, "TextArcadeBestScoreComboFormat", "Best: %i pts (%ix)")                               \
-  X(ArcadeTotalSkillChecksFormat, "TextArcadeTotalSkillChecksFormat", "Rounds Attempted: %i")                          \
-  X(ArcadeAccuracyFormat, "TextArcadeAccuracyFormat", "Accuracy: %0.2f%%")                                             \
   X(InfoProgressMax, "TextInfoProgressMax", "MAX")                                                                     \
   X(InfoProgressToNextStage, "TextInfoProgressToNextStage", "To Next Stage")                                           \
   X(InfoStageProgressFormat, "TextInfoStageProgressFormat", "Stage: %i/%i (%0.1f%%)")                                  \
@@ -119,21 +100,13 @@ namespace game::resource::xml
   X(InfoGiveFoodToStartDigesting, "TextInfoGiveFoodToStartDigesting", "Give food to start digesting!")                 \
   X(InfoDigestionRateFormat, "TextInfoDigestionRateFormat", "Rate: %0.2f%% / sec")                                     \
   X(InfoEatingSpeedFormat, "TextInfoEatingSpeedFormat", "Eating Speed: %0.2fx")                                        \
-  X(SkillCheckInstructions, "TextSkillCheckInstructions",                                                              \
-    "Match the line to the colored areas with Space/click! Better performance, better rewards!")                       \
-  X(ArcadeScoreLoss, "TextArcadeScoreLoss", "-1")                                                                      \
-  X(ArcadeRewardToast, "TextArcadeRewardToast", "Fantastic score! Congratulations!")                                   \
-  X(ArcadeHighScoreToast, "TextArcadeHighScoreToast", "High Score!")                                                   \
-  X(ArcadeMenuBackButtonTooltip, "TextArcadeMenuBackButtonTooltip", "Progress will not be saved!")                     \
-  X(SkillCheckGradeSuccessTemplate, "TextSkillCheckGradeSuccessTemplate", "{} (+{})")                                  \
-  X(ArcadeMenuBackButton, "TextArcadeMenuBackButton", "Menu")                                                          \
   X(CheatsCalories, "TextCheatsCalories", "Calories")                                                                  \
   X(CheatsCapacity, "TextCheatsCapacity", "Capacity")                                                                  \
   X(CheatsWeight, "TextCheatsWeight", "Weight")                                                                        \
   X(CheatsWeightFormat, "TextCheatsWeightFormat", "%0.2f kg")                                                          \
   X(CheatsStage, "TextCheatsStage", "Stage")                                                                           \
   X(CheatsDigestionRate, "TextCheatsDigestionRate", "Digestion Rate")                                                  \
-  X(CheatsDigestionRateFormat, "TextCheatsDigestionRateFormat", "%0.2f% / tick")                                       \
+  X(CheatsDigestionRateFormat, "TextCheatsDigestionRateFormat", "%0.2f%% / sec")                                      \
   X(CheatsEatSpeed, "TextCheatsEatSpeed", "Eat Speed")                                                                 \
   X(CheatsEatSpeedFormat, "TextCheatsEatSpeedFormat", "%0.2fx")                                                        \
   X(CheatsDigestButton, "TextCheatsDigestButton", "Digest")                                                            \
diff --git a/src/resource/xml/animation_entry.cpp b/src/resource/xml/animation_entry.cpp
deleted file mode 100644
index 86e7999..0000000
--- a/src/resource/xml/animation_entry.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "animation_entry.hpp"
-
-#include "../../util/vector.hpp"
-
-namespace game::resource::xml
-{
-  std::string* AnimationEntryCollection::get()
-  {
-    if (empty()) return nullptr;
-    return &at(util::vector::random_index_weighted(*this, [](const auto& entry) { return entry.weight; })).animation;
-  }
-}
diff --git a/src/resource/xml/animation_entry.hpp b/src/resource/xml/animation_entry.hpp
deleted file mode 100644
index f5cae86..0000000
--- a/src/resource/xml/animation_entry.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-// Handles animation entries in .xml files. "Weight" value determines weight of being randomly selected.
-
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace game::resource::xml
-{
-  class AnimationEntry
-  {
-  public:
-    std::string animation{};
-    float weight{1.0f};
-  };
-
-  class AnimationEntryCollection : public std::vector<AnimationEntry>
-  {
-  public:
-    std::string* get();
-  };
-
-}
diff --git a/src/resource/xml/anm2.cpp b/src/resource/xml/anm2.cpp
deleted file mode 100644
index d3c21b5..0000000
--- a/src/resource/xml/anm2.cpp
+++ /dev/null
@@ -1,340 +0,0 @@
-#include "anm2.hpp"
-#include "util.hpp"
-
-#include "../../util/working_directory.hpp"
-
-#include "../../log.hpp"
-
-#include <format>
-#include <ranges>
-
-using namespace tinyxml2;
-using namespace game::util;
-
-namespace game::resource::xml
-{
-  Anm2::Anm2(const Anm2&) = default;
-  Anm2::Anm2(Anm2&&) = default;
-  Anm2& Anm2::operator=(const Anm2&) = default;
-  Anm2& Anm2::operator=(Anm2&&) = default;
-
-  void Anm2::init(XMLDocument& document, Flags anm2Flags, const physfs::Path& archive)
-  {
-    this->flags = anm2Flags;
-
-    auto element = document.RootElement();
-    if (!element) return;
-
-    auto parse_frame = [&](XMLElement* element, Type type, int spritesheetID = -1)
-    {
-      Frame frame{};
-      if (!element) return frame;
-
-      if (type != TRIGGER)
-      {
-        element->QueryFloatAttribute("XPosition", &frame.position.x);
-        element->QueryFloatAttribute("YPosition", &frame.position.y);
-        if (type == LAYER)
-        {
-          if (element->FindAttribute("RegionId") && spritesheets.contains(spritesheetID))
-          {
-            auto& spritesheet = spritesheets.at(spritesheetID);
-            element->QueryIntAttribute("RegionId", &frame.regionID);
-            auto& region = spritesheet.regions.at(frame.regionID);
-            frame.crop = region.crop;
-            frame.size = region.size;
-            frame.pivot = region.origin == Spritesheet::Region::Origin::CENTER
-                              ? glm::vec2(glm::ivec2(frame.size * 0.5f))
-                          : region.origin == Spritesheet::Region::Origin::TOP_LEFT ? glm::vec2{}
-                                                                                   : region.pivot;
-          }
-          else
-          {
-            element->QueryFloatAttribute("XPivot", &frame.pivot.x);
-            element->QueryFloatAttribute("YPivot", &frame.pivot.y);
-            element->QueryFloatAttribute("XCrop", &frame.crop.x);
-            element->QueryFloatAttribute("YCrop", &frame.crop.y);
-            element->QueryFloatAttribute("Width", &frame.size.x);
-            element->QueryFloatAttribute("Height", &frame.size.y);
-          }
-        }
-        element->QueryFloatAttribute("XScale", &frame.scale.x);
-        element->QueryFloatAttribute("YScale", &frame.scale.y);
-        element->QueryIntAttribute("Delay", &frame.duration);
-        element->QueryBoolAttribute("Visible", &frame.isVisible);
-        xml::query_color_attribute(element, "RedTint", &frame.tint.r);
-        xml::query_color_attribute(element, "GreenTint", &frame.tint.g);
-        xml::query_color_attribute(element, "BlueTint", &frame.tint.b);
-        xml::query_color_attribute(element, "AlphaTint", &frame.tint.a);
-        xml::query_color_attribute(element, "RedOffset", &frame.colorOffset.r);
-        xml::query_color_attribute(element, "GreenOffset", &frame.colorOffset.g);
-        xml::query_color_attribute(element, "BlueOffset", &frame.colorOffset.b);
-        element->QueryFloatAttribute("Rotation", &frame.rotation);
-        element->QueryBoolAttribute("Interpolated", &frame.isInterpolated);
-      }
-      else
-      {
-        for (auto child = element->FirstChildElement("Sound"); child; child = child->NextSiblingElement("Sound"))
-        {
-          int soundID{};
-          child->QueryIntAttribute("Id", &soundID);
-          frame.soundIDs.emplace_back(soundID);
-        }
-
-        element->QueryIntAttribute("EventId", &frame.eventID);
-        element->QueryIntAttribute("AtFrame", &frame.atFrame);
-      }
-
-      return frame;
-    };
-
-    auto parse_item = [&](XMLElement* element, Type type, int& id)
-    {
-      Item item{};
-      if (!element) return item;
-
-      if (type == LAYER) element->QueryIntAttribute("LayerId", &id);
-      if (type == NULL_) element->QueryIntAttribute("NullId", &id);
-
-      element->QueryBoolAttribute("Visible", &item.isVisible);
-
-      for (auto child = type == TRIGGER ? element->FirstChildElement("Trigger") : element->FirstChildElement("Frame");
-           child; child = type == TRIGGER ? child->NextSiblingElement("Trigger") : child->NextSiblingElement("Frame"))
-        item.frames.emplace_back(parse_frame(child, type, type == LAYER ? layers.at(id).spritesheetID : -1));
-
-      return item;
-    };
-
-    auto parse_animation = [&](XMLElement* element)
-    {
-      Animation animation{};
-      if (!element) return animation;
-
-      xml::query_string_attribute(element, "Name", &animation.name);
-      element->QueryIntAttribute("FrameNum", &animation.frameNum);
-      element->QueryBoolAttribute("Loop", &animation.isLoop);
-
-      int id{-1};
-
-      if (auto rootAnimationElement = element->FirstChildElement("RootAnimation"))
-        animation.rootAnimation = parse_item(rootAnimationElement, ROOT, id);
-
-      if (auto layerAnimationsElement = element->FirstChildElement("LayerAnimations"))
-      {
-        for (auto child = layerAnimationsElement->FirstChildElement("LayerAnimation"); child;
-             child = child->NextSiblingElement("LayerAnimation"))
-        {
-          auto layerAnimation = parse_item(child, LAYER, id);
-          animation.layerOrder.push_back(id);
-          animation.layerAnimations.emplace(id, std::move(layerAnimation));
-        }
-      }
-
-      if (auto nullAnimationsElement = element->FirstChildElement("NullAnimations"))
-      {
-        for (auto child = nullAnimationsElement->FirstChildElement("NullAnimation"); child;
-             child = child->NextSiblingElement("NullAnimation"))
-        {
-          auto nullAnimation = parse_item(child, NULL_, id);
-          animation.nullAnimations.emplace(id, std::move(nullAnimation));
-        }
-      }
-
-      if (auto triggersElement = element->FirstChildElement("Triggers"))
-        animation.triggers = parse_item(triggersElement, TRIGGER, id);
-
-      return animation;
-    };
-
-    if (auto infoElement = element->FirstChildElement("Info")) infoElement->QueryIntAttribute("Fps", &fps);
-
-    if (auto contentElement = element->FirstChildElement("Content"))
-    {
-      if (auto spritesheetsElement = contentElement->FirstChildElement("Spritesheets"))
-      {
-        for (auto child = spritesheetsElement->FirstChildElement("Spritesheet"); child;
-             child = child->NextSiblingElement("Spritesheet"))
-        {
-          int spritesheetId{};
-          Spritesheet spritesheet{};
-          child->QueryIntAttribute("Id", &spritesheetId);
-          xml::query_string_attribute(child, "Path", &spritesheet.path);
-
-          if ((this->flags & NO_SPRITESHEETS) != 0)
-            spritesheet.texture = Texture();
-          else if (!archive.empty())
-            spritesheet.texture = Texture(physfs::Path(archive + "/" + spritesheet.path));
-          else
-            spritesheet.texture = Texture(std::filesystem::path(spritesheet.path));
-
-          for (auto regionChild = child->FirstChildElement("Region"); regionChild;
-               regionChild = regionChild->NextSiblingElement("Region"))
-          {
-            Spritesheet::Region region{};
-            int regionID{};
-
-            regionChild->QueryIntAttribute("Id", &regionID);
-            xml::query_string_attribute(regionChild, "Name", &region.name);
-            regionChild->QueryFloatAttribute("XCrop", &region.crop.x);
-            regionChild->QueryFloatAttribute("YCrop", &region.crop.y);
-            regionChild->QueryFloatAttribute("Width", &region.size.x);
-            regionChild->QueryFloatAttribute("Height", &region.size.y);
-
-            if (regionChild->FindAttribute("Origin"))
-            {
-              std::string origin{};
-              xml::query_string_attribute(regionChild, "Origin", &origin);
-              region.origin = origin == "Center"    ? Spritesheet::Region::CENTER
-                              : origin == "TopLeft" ? Spritesheet::Region::TOP_LEFT
-                                                    : Spritesheet::Region::CUSTOM;
-            }
-            else
-            {
-              regionChild->QueryFloatAttribute("XPivot", &region.pivot.x);
-              regionChild->QueryFloatAttribute("YPivot", &region.pivot.y);
-            }
-
-            spritesheet.regions.emplace(regionID, std::move(region));
-            spritesheet.regionOrder.emplace_back(regionID);
-          }
-
-          spritesheets.emplace(spritesheetId, std::move(spritesheet));
-        }
-      }
-
-      if (auto layersElement = contentElement->FirstChildElement("Layers"))
-      {
-        for (auto child = layersElement->FirstChildElement("Layer"); child; child = child->NextSiblingElement("Layer"))
-        {
-          int layerId{};
-          Layer layer{};
-          child->QueryIntAttribute("Id", &layerId);
-          xml::query_string_attribute(child, "Name", &layer.name);
-          child->QueryIntAttribute("SpritesheetId", &layer.spritesheetID);
-          layerMap[layer.name] = layerId;
-          layers.emplace(layerId, std::move(layer));
-        }
-      }
-
-      if (auto nullsElement = contentElement->FirstChildElement("Nulls"))
-      {
-        for (auto child = nullsElement->FirstChildElement("Null"); child; child = child->NextSiblingElement("Null"))
-        {
-          int nullId{};
-          Null null{};
-          child->QueryIntAttribute("Id", &nullId);
-          xml::query_string_attribute(child, "Name", &null.name);
-          child->QueryBoolAttribute("ShowRect", &null.isShowRect);
-          nullMap[null.name] = nullId;
-          nulls.emplace(nullId, std::move(null));
-        }
-      }
-
-      if (auto eventsElement = contentElement->FirstChildElement("Events"))
-      {
-        for (auto child = eventsElement->FirstChildElement("Event"); child; child = child->NextSiblingElement("Event"))
-        {
-          int eventId{};
-          Event event{};
-          child->QueryIntAttribute("Id", &eventId);
-          xml::query_string_attribute(child, "Name", &event.name);
-          eventMap[event.name] = eventId;
-          events.emplace(eventId, std::move(event));
-        }
-      }
-
-      if (auto soundsElement = contentElement->FirstChildElement("Sounds"))
-      {
-        for (auto child = soundsElement->FirstChildElement("Sound"); child; child = child->NextSiblingElement("Sound"))
-        {
-          int soundId{};
-          Sound sound{};
-          child->QueryIntAttribute("Id", &soundId);
-          xml::query_string_attribute(child, "Path", &sound.path);
-          if ((this->flags & NO_SOUNDS) != 0)
-            sound.audio = Audio();
-          else if (!archive.empty())
-            sound.audio = Audio(physfs::Path(archive + "/" + sound.path));
-          else
-            sound.audio = Audio(std::filesystem::path(sound.path));
-          sounds.emplace(soundId, std::move(sound));
-        }
-      }
-    }
-
-    if (auto animationsElement = element->FirstChildElement("Animations"))
-    {
-      xml::query_string_attribute(animationsElement, "DefaultAnimation", &defaultAnimation);
-
-      for (auto child = animationsElement->FirstChildElement("Animation"); child;
-           child = child->NextSiblingElement("Animation"))
-      {
-        if ((this->flags & DEFAULT_ANIMATION_ONLY) != 0)
-        {
-          std::string name{};
-          xml::query_string_attribute(child, "Name", &name);
-          if (name == defaultAnimation)
-          {
-            animations.emplace_back(parse_animation(child));
-            break;
-          }
-        }
-        else
-          animations.emplace_back(parse_animation(child));
-      }
-
-      for (int i = 0; i < (int)animations.size(); i++)
-      {
-        auto& animation = animations[i];
-        animationMap[animation.name] = i;
-        animationMapReverse[i] = animation.name;
-      }
-
-      if (animationMap.contains(defaultAnimation))
-        defaultAnimationID = animationMap[defaultAnimation];
-      else
-        defaultAnimationID = -1;
-    }
-
-    isValid = true;
-  }
-
-  Anm2::Anm2(const std::filesystem::path& path, Flags anm2Flags)
-  {
-    XMLDocument document;
-    auto pathString = path.string();
-
-    if (document.LoadFile(pathString.c_str()) != XML_SUCCESS)
-    {
-      logger.error(std::format("Failed to initialize anm2: {} ({})", pathString, document.ErrorStr()));
-      isValid = false;
-      return;
-    }
-
-    WorkingDirectory workingDirectory(path, WorkingDirectory::FILE);
-
-    this->path = path.string();
-
-    init(document, anm2Flags);
-
-    logger.info(std::format("Initialized anm2: {}", pathString));
-  }
-
-  Anm2::Anm2(const physfs::Path& path, Flags anm2Flags)
-  {
-    XMLDocument document;
-
-    if (xml::document_load(path, document) != XML_SUCCESS)
-    {
-      isValid = false;
-      return;
-    }
-
-    this->path = path;
-    init(document, anm2Flags, path.directory_get());
-
-    logger.info(std::format("Initialized anm2: {}", path.c_str()));
-  }
-
-  bool Anm2::is_valid() const { return isValid; }
-}
diff --git a/src/resource/xml/area.cpp b/src/resource/xml/area.cpp
deleted file mode 100644
index 73f8cb5..0000000
--- a/src/resource/xml/area.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "area.hpp"
-
-#include "../../log.hpp"
-#include <format>
-
-#include "util.hpp"
-
-using namespace tinyxml2;
-using namespace game::util;
-
-namespace game::resource::xml
-{
-  Area::Area(const physfs::Path& path)
-  {
-    XMLDocument document;
-
-    if (document_load(path, document) != XML_SUCCESS)
-    {
-      logger.error(std::format("Unable to initialize area schema: {} ({})", path.c_str(), document.ErrorStr()));
-      return;
-    }
-
-    auto archive = path.directory_get();
-
-    if (auto root = document.RootElement())
-    {
-      std::string textureRootPath{};
-      query_string_attribute(root, "TextureRootPath", &textureRootPath);
-
-      for (auto child = root->FirstChildElement("Area"); child; child = child->NextSiblingElement("Area"))
-      {
-        Entry area{};
-
-        query_texture(child, "Texture", archive, textureRootPath, area.texture);
-        child->QueryFloatAttribute("Gravity", &area.gravity);
-        child->QueryFloatAttribute("Friction", &area.friction);
-
-        areas.emplace_back(std::move(area));
-      }
-    }
-
-    if (areas.empty()) areas.emplace_back(Entry());
-
-    isValid = true;
-
-    logger.info(std::format("Initialized area schema: {}", path.c_str()));
-  }
-
-  bool Area::is_valid() const { return isValid; };
-}
diff --git a/src/resource/xml/area.hpp b/src/resource/xml/area.hpp
deleted file mode 100644
index 862517d..0000000
--- a/src/resource/xml/area.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-
-#include <vector>
-
-#include "../texture.hpp"
-#include "../../util/physfs.hpp"
-
-namespace game::resource::xml
-{
-  class Area
-  {
-  public:
-    struct Entry
-    {
-      Texture texture{};
-      float gravity{0.95f};
-      float friction{0.80f};
-      float airResistance{0.975f};
-    };
-
-    std::vector<Entry> areas{};
-    bool isValid{};
-
-    Area() = default;
-    Area(const util::physfs::Path&);
-
-    bool is_valid() const;
-  };
-}
diff --git a/src/resource/xml/character.cpp b/src/resource/xml/character.cpp
deleted file mode 100644
index 618b465..0000000
--- a/src/resource/xml/character.cpp
+++ /dev/null
@@ -1,258 +0,0 @@
-#include "character.hpp"
-
-#include <tinyxml2/tinyxml2.h>
-
-#include "../../log.hpp"
-#include "../../util/preferences.hpp"
-#include "util.hpp"
-
-#include <format>
-
-using namespace tinyxml2;
-using namespace game::util;
-
-namespace game::resource::xml
-{
-  Character::Character(const std::filesystem::path& path)
-  {
-    XMLDocument document;
-
-    physfs::Archive archive(path, path.filename().string());
-
-    if (!archive.is_valid())
-    {
-      logger.error(std::format("Failed to initialize character from PhysicsFS archive: {} ({})", path.string(),
-                               physfs::error_get()));
-      return;
-    }
-
-    physfs::Path characterPath(archive + "/" + "character.xml");
-
-    if (document_load(characterPath, document) != XML_SUCCESS) return;
-
-    if (auto root = document.RootElement())
-    {
-      std::string textureRootPath{};
-      query_string_attribute(root, "TextureRootPath", &textureRootPath);
-
-      std::string soundRootPath{};
-      query_string_attribute(root, "SoundRootPath", &soundRootPath);
-
-      query_anm2(root, "Anm2", archive, textureRootPath, anm2);
-      query_string_attribute(root, "Name", &name);
-
-      query_vec3(root, "ColorR", "ColorG", "ColorB", color);
-
-      root->QueryDoubleAttribute("Weight", &weight);
-      root->QueryDoubleAttribute("WeightMax", &weightMax);
-
-      root->QueryDoubleAttribute("Capacity", &capacity);
-      root->QueryDoubleAttribute("CapacityMin", &capacityMin);
-      root->QueryDoubleAttribute("CapacityMax", &capacityMax);
-      root->QueryDoubleAttribute("CapacityMaxMultiplier", &capacityMaxMultiplier);
-      root->QueryDoubleAttribute("CapacityIfOverStuffedOnDigestBonus", &capacityIfOverStuffedOnDigestBonus);
-
-      root->QueryDoubleAttribute("CaloriesToKilogram", &caloriesToKilogram);
-
-      root->QueryDoubleAttribute("DigestionRate", &digestionRate);
-      root->QueryDoubleAttribute("DigestionRateMin", &digestionRateMin);
-      root->QueryDoubleAttribute("DigestionRateMax", &digestionRateMax);
-      root->QueryIntAttribute("DigestionTimerMax", &digestionTimerMax);
-
-      root->QueryDoubleAttribute("EatSpeed", &eatSpeed);
-      root->QueryDoubleAttribute("EatSpeedMin", &eatSpeedMin);
-      root->QueryDoubleAttribute("EatSpeedMax", &eatSpeedMax);
-
-      root->QueryDoubleAttribute("BlinkChance", &blinkChance);
-      root->QueryDoubleAttribute("GurgleChance", &gurgleChance);
-      root->QueryDoubleAttribute("GurgleCapacityMultiplier", &gurgleCapacityMultiplier);
-
-      root->QueryIntAttribute("TextBlipPeriodBase", &textBlipPeriodBase);
-
-      auto dialoguePath = physfs::Path(archive + "/" + "dialogue.xml");
-
-      if (!dialoguePath.is_valid())
-        logger.warning(std::format("No character dialogue.xml file found: {}", path.string()));
-      else
-        dialogue = Dialogue(dialoguePath);
-
-      dialogue.query_pool_id(root, "DialoguePoolID", pool.id);
-
-      if (auto element = root->FirstChildElement("AlternateSpritesheet"))
-      {
-        query_texture(element, "Texture", archive, textureRootPath, alternateSpritesheet.texture);
-        query_sound(element, "Sound", archive, soundRootPath, alternateSpritesheet.sound);
-        element->QueryIntAttribute("ID", &alternateSpritesheet.id);
-        element->QueryFloatAttribute("ChanceOnNewGame", &alternateSpritesheet.chanceOnNewGame);
-      }
-
-      if (auto element = root->FirstChildElement("Animations"))
-      {
-        query_animation_entry_collection(element, "FinishFood", animations.finishFood);
-        query_animation_entry_collection(element, "PostDigest", animations.postDigest);
-
-        if (auto child = element->FirstChildElement("Idle"))
-          query_string_attribute(child, "Animation", &animations.idle);
-
-        if (auto child = element->FirstChildElement("IdleFull"))
-          query_string_attribute(child, "Animation", &animations.idleFull);
-
-        if (auto child = element->FirstChildElement("StageUp"))
-          query_string_attribute(child, "Animation", &animations.stageUp);
-      }
-
-      if (auto element = root->FirstChildElement("Sounds"))
-      {
-        query_sound_entry_collection(element, "Blip", archive, soundRootPath, sounds.blip);
-        query_sound_entry_collection(element, "Digest", archive, soundRootPath, sounds.digest);
-        query_sound_entry_collection(element, "Gurgle", archive, soundRootPath, sounds.gurgle);
-      }
-
-      if (auto element = root->FirstChildElement("Overrides"))
-      {
-        if (auto child = element->FirstChildElement("Talk"))
-        {
-          query_layer_id(child, "LayerSource", anm2, talkOverride.layerSource);
-          query_layer_id(child, "LayerDestination", anm2, talkOverride.layerDestination);
-        }
-
-        if (auto child = element->FirstChildElement("Blink"))
-        {
-          query_layer_id(child, "LayerSource", anm2, blinkOverride.layerSource);
-          query_layer_id(child, "LayerDestination", anm2, blinkOverride.layerDestination);
-        }
-      }
-
-      if (auto element = root->FirstChildElement("Stages"))
-      {
-        for (auto child = element->FirstChildElement("Stage"); child; child = child->NextSiblingElement("Stage"))
-        {
-          Stage stage{};
-          child->QueryFloatAttribute("Threshold", &stage.threshold);
-          child->QueryIntAttribute("AreaID", &stage.areaID);
-          dialogue.query_pool_id(child, "DialoguePoolID", stage.pool.id);
-          query_string_attribute(child, "AnimationAppendID", &stage.animationAppendID);
-          stages.emplace_back(std::move(stage));
-        }
-      }
-
-      if (auto element = root->FirstChildElement("EatAreas"))
-      {
-        for (auto child = element->FirstChildElement("EatArea"); child; child = child->NextSiblingElement("EatArea"))
-        {
-          EatArea eatArea{};
-          query_null_id(child, "Null", anm2, eatArea.nullID);
-          query_event_id(child, "Event", anm2, eatArea.eventID);
-          query_string_attribute(child, "Animation", &eatArea.animation);
-
-          eatAreas.emplace_back(std::move(eatArea));
-        }
-      }
-
-      if (auto element = root->FirstChildElement("ExpandAreas"))
-      {
-        for (auto child = element->FirstChildElement("ExpandArea"); child;
-             child = child->NextSiblingElement("ExpandArea"))
-        {
-          ExpandArea expandArea{};
-
-          query_layer_id(child, "Layer", anm2, expandArea.layerID);
-          query_null_id(child, "Null", anm2, expandArea.nullID);
-          child->QueryFloatAttribute("ScaleAdd", &expandArea.scaleAdd);
-
-          expandAreas.emplace_back(std::move(expandArea));
-        }
-      }
-
-      if (auto element = root->FirstChildElement("InteractAreas"))
-      {
-        auto interact_type_id_get = [&](const std::string& typeName)
-        {
-          for (int i = 0; i < (int)interactTypeNames.size(); i++)
-            if (interactTypeNames[i] == typeName) return i;
-
-          interactTypeNames.emplace_back(typeName);
-          return (int)interactTypeNames.size() - 1;
-        };
-
-        for (auto child = element->FirstChildElement("InteractArea"); child;
-             child = child->NextSiblingElement("InteractArea"))
-        {
-          InteractArea interactArea{};
-
-          if (child->FindAttribute("Layer")) query_layer_id(child, "Layer", anm2, interactArea.layerID);
-
-          query_null_id(child, "Null", anm2, interactArea.nullID);
-          query_string_attribute(child, "AnimationCursorHover", &interactArea.animationCursorHover);
-          query_string_attribute(child, "AnimationCursorActive", &interactArea.animationCursorActive);
-          query_sound_entry_collection(child, "Sound", archive, soundRootPath, interactArea.sound, "Path");
-          dialogue.query_pool_id(child, "DialoguePoolID", interactArea.pool.id);
-          dialogue.query_pool_id(child, "DialoguePoolIDFull", interactArea.poolFull.id);
-          query_bool_attribute(child, "IsHold", &interactArea.isHold);
-          child->QueryFloatAttribute("DigestionBonusRub", &interactArea.digestionBonusRub);
-          child->QueryFloatAttribute("DigestionBonusClick", &interactArea.digestionBonusClick);
-          child->QueryFloatAttribute("Time", &interactArea.time);
-          child->QueryFloatAttribute("ScaleEffectAmplitude", &interactArea.scaleEffectAmplitude);
-          child->QueryFloatAttribute("ScaleEffectCycles", &interactArea.scaleEffectCycles);
-
-          std::string typeString{};
-          query_string_attribute(child, "Type", &typeString);
-          if (!typeString.empty()) interactArea.typeID = interact_type_id_get(typeString);
-
-          interactAreas.emplace_back(std::move(interactArea));
-        }
-      }
-    }
-
-    if (auto itemSchemaPath = physfs::Path(archive + "/" + "items.xml"); itemSchemaPath.is_valid())
-      itemSchema = Item(itemSchemaPath);
-    else
-      logger.warning(std::format("No character items.xml file found: {}", path.string()));
-
-    if (auto areaSchemaPath = physfs::Path(archive + "/" + "areas.xml"); areaSchemaPath.is_valid())
-      areaSchema = Area(areaSchemaPath);
-    else
-      logger.warning(std::format("No character areas.xml file found: {}", path.string()));
-
-    if (auto menuSchemaPath = physfs::Path(archive + "/" + "menu.xml"); menuSchemaPath.is_valid())
-      menuSchema = Menu(menuSchemaPath);
-    else
-      logger.warning(std::format("No character menu.xml file found: {}", path.string()));
-
-    if (auto cursorSchemaPath = physfs::Path(archive + "/" + "cursor.xml"); cursorSchemaPath.is_valid())
-      cursorSchema = Cursor(cursorSchemaPath);
-    else
-      logger.warning(std::format("No character cursor.xml file found: {}", path.string()));
-
-    if (auto skillCheckSchemaPath = physfs::Path(archive + "/" + "skill_check.xml"); skillCheckSchemaPath.is_valid())
-      skillCheckSchema = SkillCheck(skillCheckSchemaPath, dialogue);
-    else
-      logger.warning(std::format("No character skill_check.xml file found: {}", path.string()));
-
-    if (auto dungeonSchemaPath = physfs::Path(archive + "/" + "dungeon.xml"); dungeonSchemaPath.is_valid())
-      dungeonSchema = Dungeon(dungeonSchemaPath);
-    else
-      logger.warning(std::format("No character dungeon.xml file found: {}", path.string()));
-
-    if (auto orbitSchemaPath = physfs::Path(archive + "/" + "orbit.xml"); orbitSchemaPath.is_valid())
-      orbitSchema = Orbit(orbitSchemaPath, dialogue);
-    else
-      logger.warning(std::format("No character orbit.xml file found: {}", path.string()));
-
-    if (auto stringsPath = physfs::Path(archive + "/" + "strings.xml"); stringsPath.is_valid())
-      strings = Strings(stringsPath);
-
-    logger.info(std::format("Initialized character: {}", name));
-
-    this->path = path;
-    save = Save(save_path_get());
-  }
-
-  std::filesystem::path Character::save_path_get()
-  {
-    auto savePath = path.stem();
-    savePath = preferences::path() / "saves" / savePath.replace_extension(".save");
-    std::filesystem::create_directories(savePath.parent_path());
-    return savePath;
-  }
-}
diff --git a/src/resource/xml/character.hpp b/src/resource/xml/character.hpp
deleted file mode 100644
index ded2429..0000000
--- a/src/resource/xml/character.hpp
+++ /dev/null
@@ -1,154 +0,0 @@
-#pragma once
-
-#include <filesystem>
-#include <vector>
-
-#include "../audio.hpp"
-#include "animation_entry.hpp"
-#include "anm2.hpp"
-#include "area.hpp"
-#include "cursor.hpp"
-#include "dialogue.hpp"
-#include "dungeon.hpp"
-#include "item.hpp"
-#include "menu.hpp"
-#include "orbit.hpp"
-#include "save.hpp"
-#include "skill_check.hpp"
-#include "strings.hpp"
-
-namespace game::resource::xml
-{
-  class Character
-  {
-  public:
-    struct Stage
-    {
-      float threshold{};
-      int areaID{};
-      Dialogue::PoolReference pool{-1};
-      std::string animationAppendID{};
-    };
-
-    struct EatArea
-    {
-      int nullID{-1};
-      int eventID{-1};
-      std::string animation{};
-    };
-
-    struct ExpandArea
-    {
-      int layerID{-1};
-      int nullID{-1};
-      float scaleAdd{};
-    };
-
-    struct InteractArea
-    {
-      std::string animationCursorActive{};
-      std::string animationCursorHover{};
-      SoundEntryCollection sound{};
-
-      int nullID{-1};
-      int layerID{-1};
-      int typeID{-1};
-      bool isHold{};
-      Dialogue::PoolReference pool{-1};
-      Dialogue::PoolReference poolFull{-1};
-
-      float digestionBonusRub{};
-      float digestionBonusClick{};
-      float time{};
-      float scaleEffectAmplitude{};
-      float scaleEffectCycles{};
-    };
-
-    struct Animations
-    {
-      AnimationEntryCollection finishFood{};
-      AnimationEntryCollection postDigest{};
-
-      std::string idle{};
-      std::string idleFull{};
-      std::string stageUp{};
-    };
-
-    struct Sounds
-    {
-      SoundEntryCollection blip{};
-      SoundEntryCollection gurgle{};
-      SoundEntryCollection digest{};
-    };
-
-    struct Override
-    {
-      int layerSource{};
-      int layerDestination{};
-    };
-
-    struct AlternateSpritesheet
-    {
-      Texture texture{};
-      Audio sound{};
-      int id{-1};
-      float chanceOnNewGame{0.001f};
-    };
-
-    Anm2 anm2{};
-    Area areaSchema{};
-    Dialogue dialogue{};
-    Item itemSchema{};
-    Menu menuSchema{};
-    Cursor cursorSchema{};
-    SkillCheck skillCheckSchema{};
-    Dungeon dungeonSchema{};
-    Orbit orbitSchema{};
-    Strings strings{};
-
-    Save save{};
-
-    Animations animations{};
-    Override talkOverride{};
-    Override blinkOverride{};
-
-    Sounds sounds{};
-
-    glm::vec3 color{0.120f, 0.515f, 0.115f};
-
-    std::vector<Stage> stages{};
-    std::vector<ExpandArea> expandAreas{};
-    std::vector<EatArea> eatAreas{};
-    std::vector<std::string> interactTypeNames{};
-    std::vector<InteractArea> interactAreas{};
-
-    AlternateSpritesheet alternateSpritesheet{};
-
-    std::string name{};
-    std::filesystem::path path{};
-    double weight{50};
-    double weightMax{1000};
-    double capacity{2000.0};
-    double capacityMin{2000.0};
-    double capacityMax{99999.0};
-    double capacityMaxMultiplier{1.5};
-    double capacityIfOverStuffedOnDigestBonus{0.25};
-    double caloriesToKilogram{1000.0};
-    double digestionRate{0.05};
-    double digestionRateMin{0.0};
-    double digestionRateMax{0.25};
-    int digestionTimerMax{60};
-    int textBlipPeriodBase{3};
-    double eatSpeed{1.0};
-    double eatSpeedMin{1.0};
-    double eatSpeedMax{3.0};
-    double blinkChance{1.0};
-    double gurgleChance{1.0};
-    double gurgleCapacityMultiplier{1.0};
-    Dialogue::PoolReference pool{-1};
-
-    Character() = default;
-    Character(const std::filesystem::path&);
-    std::filesystem::path save_path_get();
-  };
-}
diff --git a/src/resource/xml/character_preview.cpp b/src/resource/xml/character_preview.cpp
deleted file mode 100644
index 7cb8568..0000000
--- a/src/resource/xml/character_preview.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-#include "character_preview.hpp"
-
-#include <tinyxml2/tinyxml2.h>
-
-#include "../../log.hpp"
-#include "../../util/preferences.hpp"
-#include "util.hpp"
-
-#include <format>
-
-using namespace tinyxml2;
-using namespace game::util;
-
-namespace game::resource::xml
-{
-  CharacterPreview::CharacterPreview(const std::filesystem::path& path)
-  {
-    XMLDocument document;
-
-    physfs::Archive archive(path, path.filename().string());
-
-    if (!archive.is_valid())
-    {
-      logger.error(std::format("Failed to initialize character preview from PhysicsFS archive: {} ({})", path.string(),
-                               physfs::error_get()));
-      return;
-    }
-
-    physfs::Path characterPath(archive + "/" + "character.xml");
-
-    if (document_load(characterPath, document) != XML_SUCCESS) return;
-
-    if (auto root = document.RootElement())
-    {
-      std::string textureRootPath{};
-      query_string_attribute(root, "TextureRootPath", &textureRootPath);
-
-      query_anm2(root, "Anm2", archive, textureRootPath, anm2, Anm2::NO_SOUNDS | Anm2::DEFAULT_ANIMATION_ONLY);
-      query_texture(root, "Render", archive, textureRootPath, render);
-      query_texture(root, "Portrait", archive, textureRootPath, portrait);
-
-      query_string_attribute(root, "Name", &name);
-      query_string_attribute(root, "Description", &description);
-      query_string_attribute(root, "Credits", &credits);
-      query_vec3(root, "ColorR", "ColorG", "ColorB", color);
-      root->QueryFloatAttribute("Weight", &weight);
-
-      if (auto element = root->FirstChildElement("Stages"))
-        for (auto child = element->FirstChildElement("Stage"); child; child = child->NextSiblingElement("Stage"))
-          stages++;
-    }
-
-    this->path = path;
-    save = Save(save_path_get());
-    isValid = true;
-
-    logger.info(std::format("Initialized character preview: {}", name));
-  }
-
-  std::filesystem::path CharacterPreview::save_path_get()
-  {
-    auto savePath = path.stem();
-    savePath = preferences::path() / "saves" / savePath.replace_extension(".save");
-    std::filesystem::create_directories(savePath.parent_path());
-    return savePath;
-  }
-
-  bool CharacterPreview::is_valid() const { return isValid; }
-}
diff --git a/src/resource/xml/character_preview.hpp b/src/resource/xml/character_preview.hpp
deleted file mode 100644
index 4f4c52e..0000000
--- a/src/resource/xml/character_preview.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#pragma once
-
-#include <filesystem>
-#include <glm/glm.hpp>
-#include <string>
-#include <vector>
-
-#include "anm2.hpp"
-#include "save.hpp"
-
-namespace game::resource::xml
-{
-  class CharacterPreview
-  {
-  public:
-    struct Stage
-    {
-      float threshold{};
-      int dialoguePoolID{-1};
-    };
-
-    Anm2 anm2{};
-    Texture portrait{};
-    Texture render{};
-    Save save{};
-    glm::vec3 color{0.120f, 0.515f, 0.115f};
-
-    int stages{1};
-
-    std::string name{};
-    std::string credits{};
-    std::string description{};
-    std::filesystem::path path{};
-    float weight{50};
-
-    bool isValid{};
-
-    CharacterPreview() = default;
-    CharacterPreview(const std::filesystem::path&);
-
-    std::filesystem::path save_path_get();
-    bool is_valid() const;
-  };
-}
diff --git a/src/resource/xml/cursor.cpp b/src/resource/xml/cursor.cpp
deleted file mode 100644
index 42a5991..0000000
--- a/src/resource/xml/cursor.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "cursor.hpp"
-
-#include "../../log.hpp"
-
-#include <format>
-
-using namespace tinyxml2;
-using namespace game::util;
-
-namespace game::resource::xml
-{
-  Cursor::Cursor(const physfs::Path& path)
-  {
-    XMLDocument document;
-
-    if (document_load(path, document) != XML_SUCCESS)
-    {
-      logger.error(std::format("Unable to initialize cursor schema: {} ({})", path.c_str(), document.ErrorStr()));
-      return;
-    }
-
-    auto archive = path.directory_get();
-
-    if (auto root = document.RootElement())
-    {
-      std::string textureRootPath{};
-      query_string_attribute(root, "TextureRootPath", &textureRootPath);
-
-      std::string soundRootPath{};
-      query_string_attribute(root, "SoundRootPath", &soundRootPath);
-
-      query_anm2(root, "Anm2", archive, textureRootPath, anm2);
-
-      if (auto element = root->FirstChildElement("Animations"))
-      {
-        query_animation_entry_collection(element, "Idle", animations.idle);
-        query_animation_entry_collection(element, "Hover", animations.hover);
-        query_animation_entry_collection(element, "Grab", animations.grab);
-        query_animation_entry_collection(element, "Pan", animations.pan);
-        query_animation_entry_collection(element, "Zoom", animations.zoom);
-        query_animation_entry_collection(element, "Return", animations.return_);
-      }
-
-      if (auto element = root->FirstChildElement("Sounds"))
-      {
-        query_sound_entry_collection(element, "Grab", archive, soundRootPath, sounds.grab);
-        query_sound_entry_collection(element, "Release", archive, soundRootPath, sounds.release);
-        query_sound_entry_collection(element, "Throw", archive, soundRootPath, sounds.throw_);
-      }
-    }
-
-    isValid = true;
-
-    logger.info(std::format("Initialized area schema: {}", path.c_str()));
-  }
-
-  bool Cursor::is_valid() const { return isValid; };
-}
diff --git a/src/resource/xml/cursor.hpp b/src/resource/xml/cursor.hpp
deleted file mode 100644
index 1e759d9..0000000
--- a/src/resource/xml/cursor.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-#include "util.hpp"
-
-namespace game::resource::xml
-{
-  class Cursor
-  {
-  public:
-    struct Animations
-    {
-      AnimationEntryCollection idle{};
-      AnimationEntryCollection hover{};
-      AnimationEntryCollection grab{};
-      AnimationEntryCollection pan{};
-      AnimationEntryCollection zoom{};
-      AnimationEntryCollection return_{};
-    };
-
-    struct Sounds
-    {
-      SoundEntryCollection grab{};
-      SoundEntryCollection release{};
-      SoundEntryCollection throw_{};
-    };
-
-    Animations animations{};
-    Sounds sounds{};
-    Anm2 anm2{};
-
-    bool isValid{};
-
-    Cursor() = default;
-    Cursor(const util::physfs::Path&);
-
-    bool is_valid() const;
-  };
-}
diff --git a/src/resource/xml/dialogue.cpp b/src/resource/xml/dialogue.cpp
deleted file mode 100644
index 8d8d88a..0000000
--- a/src/resource/xml/dialogue.cpp
+++ /dev/null
@@ -1,196 +0,0 @@
-#include "dialogue.hpp"
-#include "util.hpp"
-
-#include "../../log.hpp"
-#include "../../util/math.hpp"
-
-#include <algorithm>
-#include <format>
-
-using namespace tinyxml2;
-using namespace game::util;
-
-namespace game::resource::xml
-{
-  void Dialogue::query_entry_id(XMLElement* element, const char* name, int& id)
-  {
-    std::string entryID{};
-    query_string_attribute(element, name, &entryID);
-    if (entryIDMap.contains(entryID))
-      id = entryIDMap.at(entryID);
-    else if (entryID.empty())
-      entryID = -1;
-    else
-    {
-      logger.warning("Dialogue entries does not contain: " + entryID);
-      id = -1;
-    }
-  }
-
-  void Dialogue::query_pool_id(XMLElement* element, const char* name, int& id)
-  {
-    std::string poolID{};
-    query_string_attribute(element, name, &poolID);
-    if (poolMap.contains(poolID))
-      id = poolMap.at(poolID);
-    else if (poolID.empty())
-      poolID = -1;
-    else
-    {
-      logger.warning("Dialogue pools does not contain: " + poolID);
-      id = -1;
-    }
-  }
-
-  Dialogue::Dialogue(const physfs::Path& path)
-  {
-
-    XMLDocument document;
-
-    if (document_load(path, document) != XML_SUCCESS)
-    {
-      logger.error(std::format("Unable to initialize dialogue: {} ({})", path.c_str(), document.ErrorStr()));
-      return;
-    }
-
-    if (auto root = document.RootElement())
-    {
-      if (auto element = root->FirstChildElement("Entries"))
-      {
-        int id{};
-
-        for (auto child = element->FirstChildElement("Entry"); child; child = child->NextSiblingElement("Entry"))
-        {
-          std::string stringID{};
-          query_string_attribute(child, "ID", &stringID);
-          entryIDMap.emplace(stringID, id);
-          entryIDMapReverse.emplace(id, stringID);
-          id++;
-        }
-
-        id = 0;
-
-        for (auto child = element->FirstChildElement("Entry"); child; child = child->NextSiblingElement("Entry"))
-        {
-          Entry entry{};
-
-          entry.name = entryIDMapReverse.at(id);
-
-          query_string_attribute(child, "Text", &entry.text);
-
-          query_string_attribute(child, "Animation", &entry.animation);
-
-          if (child->FindAttribute("Next"))
-          {
-            std::string nextID{};
-            query_string_attribute(child, "Next", &nextID);
-            if (!entryIDMap.contains(nextID))
-              logger.warning(std::format("Dialogue: next ID does not point to a valid Entry! ({})", nextID));
-            else
-              entry.nextID = entryIDMap.at(nextID);
-          }
-
-          for (auto choiceChild = child->FirstChildElement("Choice"); choiceChild;
-               choiceChild = choiceChild->NextSiblingElement("Choice"))
-          {
-            Choice choice{};
-            query_entry_id(choiceChild, "Next", choice.nextID);
-            query_string_attribute(choiceChild, "Text", &choice.text);
-            entry.choices.emplace_back(std::move(choice));
-          }
-
-          entries.emplace_back(std::move(entry));
-
-          id++;
-        }
-
-        entrySelectionOrder.assign(entries.size(), -1);
-      }
-
-      if (auto element = root->FirstChildElement("Pools"))
-      {
-        int id{};
-
-        for (auto child = element->FirstChildElement("Pool"); child; child = child->NextSiblingElement("Pool"))
-        {
-          Pool pool{};
-          std::string stringID{};
-          query_string_attribute(child, "ID", &stringID);
-          poolMap[stringID] = id;
-          pools.emplace_back(pool);
-          id++;
-        }
-
-        id = 0;
-
-        for (auto child = element->FirstChildElement("Pool"); child; child = child->NextSiblingElement("Pool"))
-        {
-          auto& pool = pools.at(id);
-
-          for (auto entryChild = child->FirstChildElement("PoolEntry"); entryChild;
-               entryChild = entryChild->NextSiblingElement("PoolEntry"))
-          {
-            int entryID{};
-            query_entry_id(entryChild, "ID", entryID);
-            pool.emplace_back(entryID);
-          }
-
-          id++;
-        }
-
-        logger.info(std::format("Initialized dialogue: {}", path.c_str()));
-        isValid = true;
-      }
-
-      if (auto element = root->FirstChildElement("Start"))
-      {
-        query_entry_id(element, "ID", start.id);
-        query_string_attribute(element, "Animation", &start.animation);
-      }
-      if (auto element = root->FirstChildElement("End")) query_entry_id(element, "ID", end.id);
-      if (auto element = root->FirstChildElement("Help")) query_entry_id(element, "ID", help.id);
-
-      if (auto element = root->FirstChildElement("Digest")) query_pool_id(element, "PoolID", digest.id);
-      if (auto element = root->FirstChildElement("Eat")) query_pool_id(element, "PoolID", eat.id);
-      if (auto element = root->FirstChildElement("EatFull")) query_pool_id(element, "PoolID", eatFull.id);
-      if (auto element = root->FirstChildElement("Feed")) query_pool_id(element, "PoolID", feed.id);
-      if (auto element = root->FirstChildElement("FeedFull")) query_pool_id(element, "PoolID", feedFull.id);
-      if (auto element = root->FirstChildElement("FoodTaken")) query_pool_id(element, "PoolID", foodTaken.id);
-      if (auto element = root->FirstChildElement("FoodTakenFull")) query_pool_id(element, "PoolID", foodTakenFull.id);
-      if (auto element = root->FirstChildElement("Full")) query_pool_id(element, "PoolID", full.id);
-      if (auto element = root->FirstChildElement("LowCapacity")) query_pool_id(element, "PoolID", lowCapacity.id);
-      if (auto element = root->FirstChildElement("Random")) query_pool_id(element, "PoolID", random.id);
-      if (auto element = root->FirstChildElement("Throw")) query_pool_id(element, "PoolID", throw_.id);
-      if (auto element = root->FirstChildElement("StageUp")) query_pool_id(element, "PoolID", stageUp.id);
-    }
-  }
-
-  int Dialogue::entry_pick(Pool& pool)
-  {
-    if (pool.empty()) return -1;
-
-    std::vector<int> unselected{};
-    for (auto id : pool)
-      if (id >= 0 && id < (int)entrySelectionOrder.size() && entrySelectionOrder[id] < 0) unselected.emplace_back(id);
-
-    std::vector<int> candidates = unselected.empty() ? std::vector<int>(pool.begin(), pool.end()) : unselected;
-    if (candidates.empty()) return -1;
-
-    auto oldestOrder = entrySelectionOrder[candidates.front()];
-    for (auto id : candidates)
-      oldestOrder = std::min(oldestOrder, entrySelectionOrder[id]);
-
-    std::vector<int> oldestCandidates{};
-    for (auto id : candidates)
-      if (entrySelectionOrder[id] == oldestOrder) oldestCandidates.emplace_back(id);
-
-    auto pickedID = oldestCandidates.at(rand() % oldestCandidates.size());
-    entrySelectionOrder[pickedID] = selectionCounter++;
-    return pickedID;
-  }
-  Dialogue::Entry* Dialogue::get(int id) { return &entries.at(id); }
-  Dialogue::Entry* Dialogue::get(Dialogue::EntryReference& entry) { return &entries.at(entry.id); }
-  Dialogue::Entry* Dialogue::get(const std::string& string) { return &entries.at(entryIDMap.at(string)); }
-  Dialogue::Entry* Dialogue::get(Dialogue::PoolReference& pool) { return &entries.at(entry_pick(pools.at(pool.id))); }
-  Dialogue::Entry* Dialogue::get(Dialogue::Pool& pool) { return &entries.at(entry_pick(pool)); }
-}
diff --git a/src/resource/xml/dialogue.hpp b/src/resource/xml/dialogue.hpp
deleted file mode 100644
index 36d5083..0000000
--- a/src/resource/xml/dialogue.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-#pragma once
-
-#include <tinyxml2.h>
-
-#include <string>
-
-#include <map>
-#include <vector>
-
-#include "../../util/physfs.hpp"
-
-namespace game::resource::xml
-{
-  class Dialogue
-  {
-  public:
-    struct Choice
-    {
-      std::string text{};
-      int nextID{-1};
-    };
-
-    struct Entry
-    {
-      std::string name{};
-      std::string animation{};
-      std::string text{};
-      std::vector<Choice> choices{};
-      int nextID{-1};
-
-      inline bool is_last() const { return choices.empty() && nextID == -1; };
-    };
-
-    struct EntryReference
-    {
-      int id{-1};
-      std::string animation{};
-
-      inline bool is_valid() const { return id != -1; };
-    };
-
-    class PoolReference
-    {
-    public:
-      int id{-1};
-      inline bool is_valid() const { return id != -1; };
-    };
-
-    class Pool : public std::vector<int> {};
-
-    std::map<std::string, int> entryIDMap;
-    std::map<int, std::string> entryIDMapReverse;
-    std::vector<Entry> entries{};
-
-    std::vector<Pool> pools{};
-    std::map<std::string, int> poolMap{};
-    std::vector<long long> entrySelectionOrder{};
-    long long selectionCounter{};
-
-    EntryReference start{-1};
-    EntryReference end{-1};
-    EntryReference help{-1};
-    PoolReference digest{-1};
-    PoolReference eatFull{-1};
-    PoolReference eat{-1};
-    PoolReference feedFull{-1};
-    PoolReference feed{-1};
-    PoolReference foodTakenFull{-1};
-    PoolReference foodTaken{-1};
-    PoolReference full{-1};
-    PoolReference random{-1};
-    PoolReference lowCapacity{-1};
-    PoolReference throw_{-1};
-    PoolReference stageUp{-1};
-
-    bool isValid{};
-
-    Dialogue() = default;
-    Dialogue(const util::physfs::Path&);
-    Entry* get(const std::string&);
-    Entry* get(int id);
-    Entry* get(Dialogue::EntryReference&);
-    Entry* get(Dialogue::Pool&);
-    Entry* get(Dialogue::PoolReference&);
-    int entry_pick(Pool&);
-    void query_entry_id(tinyxml2::XMLElement* element, const char* name, int& id);
-    void query_pool_id(tinyxml2::XMLElement* element, const char* name, int& id);
-    inline bool is_valid() const { return isValid; };
-  };
-}
diff --git a/src/resource/xml/dungeon.cpp b/src/resource/xml/dungeon.cpp
deleted file mode 100644
index 9b14df7..0000000
--- a/src/resource/xml/dungeon.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "dungeon.hpp"
-
-#include "../../log.hpp"
-#include "util.hpp"
-
-#include <format>
-
-using namespace tinyxml2;
-
-namespace game::resource::xml
-{
-  Dungeon::Dungeon(const util::physfs::Path& path)
-  {
-    XMLDocument document;
-
-    if (document_load(path, document) != XML_SUCCESS)
-    {
-      logger.error(std::format("Unable to initialize dungeon schema: {} ({})", path.c_str(), document.ErrorStr()));
-      return;
-    }
-
-    if (auto root = document.RootElement())
-    {
-      if (std::string_view(root->Name()) != "Dungeon")
-      {
-        logger.error(std::format("Dungeon schema root element is not Dungeon: {}", path.c_str()));
-        return;
-      }
-
-      query_string_attribute(root, "Title", &title);
-      query_string_attribute(root, "Description", &description);
-    }
-
-    isValid = true;
-    logger.info(std::format("Initialized dungeon schema: {}", path.c_str()));
-  }
-
-  bool Dungeon::is_valid() const { return isValid; };
-}
diff --git a/src/resource/xml/dungeon.hpp b/src/resource/xml/dungeon.hpp
deleted file mode 100644
index 972f041..0000000
--- a/src/resource/xml/dungeon.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#include "../../util/physfs.hpp"
-
-#include <string>
-
-namespace game::resource::xml
-{
-  class Dungeon
-  {
-  public:
-    std::string title{"Dungeon"};
-    std::string description{"Template dungeon schema."};
-    bool isValid{};
-
-    Dungeon() = default;
-    Dungeon(const util::physfs::Path&);
-
-    bool is_valid() const;
-  };
-}
diff --git a/src/resource/xml/item.cpp b/src/resource/xml/item.cpp
deleted file mode 100644
index a9203d5..0000000
--- a/src/resource/xml/item.cpp
+++ /dev/null
@@ -1,193 +0,0 @@
-#include "item.hpp"
-
-#include <ranges>
-#include <tinyxml2.h>
-
-#include <algorithm>
-#include <utility>
-
-#include "../../log.hpp"
-
-#include <format>
-
-#include "util.hpp"
-
-using namespace tinyxml2;
-using namespace game::util;
-
-namespace game::resource::xml
-{
-  Item::Item(const physfs::Path& path)
-  {
-    XMLDocument document;
-
-    if (document_load(path, document) != XML_SUCCESS)
-    {
-      logger.error(std::format("Unable to initialize item schema: {} ({})", path.c_str(), document.ErrorStr()));
-      return;
-    }
-
-    auto archive = path.directory_get();
-
-    if (auto root = document.RootElement())
-    {
-      std::string textureRootPath{};
-      query_string_attribute(root, "TextureRootPath", &textureRootPath);
-
-      std::string soundRootPath{};
-      query_string_attribute(root, "SoundRootPath", &soundRootPath);
-
-      query_anm2(root, "BaseAnm2", archive, textureRootPath, baseAnm2, Anm2::NO_SPRITESHEETS);
-
-      if (auto element = root->FirstChildElement("Categories"))
-      {
-        for (auto child = element->FirstChildElement("Category"); child; child = child->NextSiblingElement("Category"))
-        {
-          Category category{};
-          query_string_attribute(child, "Name", &category.name);
-          query_bool_attribute(child, "IsEdible", &category.isEdible);
-          categoryMap[category.name] = (int)categories.size();
-          categories.push_back(category);
-        }
-      }
-
-      if (auto element = root->FirstChildElement("Rarities"))
-      {
-        for (auto child = element->FirstChildElement("Rarity"); child; child = child->NextSiblingElement("Rarity"))
-        {
-          Rarity rarity{};
-
-          query_string_attribute(child, "Name", &rarity.name);
-          child->QueryFloatAttribute("Weight", &rarity.weight);
-          query_bool_attribute(child, "IsHidden", &rarity.isHidden);
-
-          query_sound(child, "Sound", archive, soundRootPath, rarity.sound);
-
-          rarityMap[rarity.name] = (int)rarities.size();
-          rarities.emplace_back(std::move(rarity));
-        }
-      }
-
-      if (auto element = root->FirstChildElement("Flavors"))
-      {
-        for (auto child = element->FirstChildElement("Flavor"); child; child = child->NextSiblingElement("Flavor"))
-        {
-          Flavor flavor{};
-          query_string_attribute(child, "Name", &flavor.name);
-          flavorMap[flavor.name] = (int)flavors.size();
-          flavors.push_back(flavor);
-        }
-      }
-
-      if (auto element = root->FirstChildElement("Animations"))
-      {
-        if (auto child = element->FirstChildElement("Chew"))
-          query_string_attribute(child, "Animation", &animations.chew);
-      }
-
-      if (auto element = root->FirstChildElement("Sounds"))
-      {
-        query_sound_entry_collection(element, "Bounce", archive, soundRootPath, sounds.bounce);
-        query_sound_entry_collection(element, "Dispose", archive, soundRootPath, sounds.dispose);
-        query_sound_entry_collection(element, "Return", archive, soundRootPath, sounds.return_);
-        query_sound_entry_collection(element, "Summon", archive, soundRootPath, sounds.summon);
-        query_sound_entry_collection(element, "Upgrade", archive, soundRootPath, sounds.upgrade);
-        query_sound_entry_collection(element, "UpgradeFail", archive, soundRootPath, sounds.upgradeFail);
-      }
-
-      if (auto element = root->FirstChildElement("Items"))
-      {
-        int id{};
-
-        for (auto child = element->FirstChildElement("Item"); child; child = child->NextSiblingElement("Item"))
-        {
-          std::string name{};
-          query_string_attribute(child, "Name", &name);
-          stringToIDMap[name] = id;
-          idToStringMap[id] = name;
-          id++;
-        }
-      }
-
-      if (auto element = root->FirstChildElement("Items"))
-      {
-        std::string itemTextureRootPath{};
-        query_string_attribute(element, "TextureRootPath", &itemTextureRootPath);
-
-        element->QueryIntAttribute("Durability", &durability);
-        element->QueryIntAttribute("QuantityMax", &quantityMax);
-
-        for (auto child = element->FirstChildElement("Item"); child; child = child->NextSiblingElement("Item"))
-        {
-          Entry item{};
-
-          query_string_attribute(child, "Name", &item.name);
-          query_string_attribute(child, "Description", &item.description);
-
-          query_float_optional_attribute(child, "Calories", item.calories);
-          query_float_optional_attribute(child, "CapacityBonus", item.capacityBonus);
-          query_optional_vec3(child, "ColorR", "ColorG", "ColorB", item.color);
-          query_float_optional_attribute(child, "DigestionBonus", item.digestionBonus);
-          query_float_optional_attribute(child, "EatSpeedBonus", item.eatSpeedBonus);
-          query_float_optional_attribute(child, "Gravity", item.gravity);
-
-          query_int_optional_attribute(child, "Durability", item.durability);
-
-          if (child->FindAttribute("UpgradeID"))
-          {
-            std::string upgradeIDString{};
-            query_string_attribute(child, "UpgradeID", &upgradeIDString);
-
-            if (!upgradeIDString.empty() && stringToIDMap.contains(upgradeIDString))
-              item.upgradeID = stringToIDMap[upgradeIDString];
-            else if (upgradeIDString.empty())
-              logger.warning(std::format("Empty UpgradeID ({})", item.name));
-            else
-              logger.warning(std::format("Could not find item ID for UpgradeID: {} ({})", upgradeIDString, item.name));
-
-            query_int_optional_attribute(child, "UpgradeCount", item.upgradeCount);
-          }
-
-          query_bool_attribute(child, "IsSkillCheckReward", &item.isSkillCheckReward);
-          query_bool_attribute(child, "IsToggleSpritesheet", &item.isToggleSpritesheet);
-
-          std::string categoryString{};
-          query_string_attribute(child, "Category", &categoryString);
-          item.categoryID = categoryMap.contains(categoryString) ? categoryMap[categoryString] : -1;
-
-          std::string rarityString{};
-          query_string_attribute(child, "Rarity", &rarityString);
-          item.rarityID = rarityMap.contains(rarityString) ? rarityMap[rarityString] : -1;
-
-          std::string flavorString{};
-          query_string_attribute(child, "Flavor", &flavorString);
-          if (flavorMap.contains(flavorString)) item.flavorID = flavorMap[flavorString];
-
-          Texture texture{};
-          query_texture(child, "Texture", archive, itemTextureRootPath, texture);
-
-          Anm2 anm2{baseAnm2};
-          if (child->FindAttribute("Anm2")) query_anm2(child, "Anm2", archive, textureRootPath, anm2);
-          anm2.spritesheets.at(0).texture = std::move(texture);
-          anm2s.emplace_back(std::move(anm2));
-          items.emplace_back(std::move(item));
-        }
-      }
-    }
-
-    for (int i = 0; i < (int)items.size(); i++)
-    {
-      auto& item = items[i];
-      pools[item.rarityID].emplace_back(i);
-      if (item.isSkillCheckReward) skillCheckRewardItemPool.emplace_back(i);
-    }
-
-    for (int i = 0; i < (int)rarities.size(); i++)
-      rarityIDs.emplace_back(i);
-
-    isValid = true;
-    logger.info(std::format("Initialized item schema: {}", path.c_str()));
-  }
-
-  bool Item::is_valid() const { return isValid; };
-}
diff --git a/src/resource/xml/item.hpp b/src/resource/xml/item.hpp
deleted file mode 100644
index e0836f7..0000000
--- a/src/resource/xml/item.hpp
+++ /dev/null
@@ -1,108 +0,0 @@
-#pragma once
-
-#include <filesystem>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include <glm/glm.hpp>
-
-#include "../audio.hpp"
-#include "anm2.hpp"
-#include "sound_entry.hpp"
-
-namespace game::resource::xml
-{
-  class Item
-  {
-  public:
-    static constexpr auto UNDEFINED = "???";
-
-    struct Category
-    {
-      std::string name{};
-      bool isEdible{};
-    };
-
-    struct Rarity
-    {
-      std::string name{UNDEFINED};
-      float weight{};
-      bool isHidden{};
-      Audio sound{};
-    };
-
-    struct Flavor
-    {
-      std::string name{UNDEFINED};
-    };
-
-    struct Entry
-    {
-      std::string name{UNDEFINED};
-      std::string description{UNDEFINED};
-      int categoryID{};
-      int rarityID{};
-      std::optional<int> upgradeCount{};
-      std::optional<int> upgradeID{};
-      std::optional<int> flavorID;
-      std::optional<float> calories{};
-      std::optional<float> capacityBonus{};
-      std::optional<glm::vec3> color{};
-      std::optional<float> eatSpeedBonus{};
-      std::optional<float> digestionBonus{};
-      std::optional<float> gravity{};
-      std::optional<int> durability{};
-      bool isSkillCheckReward{};
-      bool isToggleSpritesheet{};
-    };
-
-    struct Animations
-    {
-      std::string chew{};
-    };
-
-    struct Sounds
-    {
-      SoundEntryCollection bounce{};
-      SoundEntryCollection return_{};
-      SoundEntryCollection dispose{};
-      SoundEntryCollection summon{};
-      SoundEntryCollection upgrade{};
-      SoundEntryCollection upgradeFail{};
-    };
-
-    std::unordered_map<std::string, int> categoryMap{};
-    std::unordered_map<std::string, int> rarityMap{};
-    std::unordered_map<std::string, int> flavorMap{};
-    std::unordered_map<std::string, int> stringToIDMap{};
-    std::unordered_map<int, std::string> idToStringMap{};
-
-    using Pool = std::vector<int>;
-
-    std::vector<Category> categories{};
-    std::vector<Rarity> rarities{};
-    std::vector<Flavor> flavors{};
-    std::vector<Entry> items{};
-    std::vector<Anm2> anm2s{};
-
-    std::vector<int> rarityIDs{};
-    std::unordered_map<int, Pool> pools{};
-    Pool skillCheckRewardItemPool{};
-
-    Animations animations{};
-    Sounds sounds{};
-    Anm2 baseAnm2{};
-    int durability{2};
-    int quantityMax{99};
-
-    bool isValid{};
-
-    Item() = default;
-    Item(const std::filesystem::path&);
-    Item(const util::physfs::Path&);
-
-    bool is_valid() const;
-  };
-}
diff --git a/src/resource/xml/menu.cpp b/src/resource/xml/menu.cpp
deleted file mode 100644
index 57262b7..0000000
--- a/src/resource/xml/menu.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "menu.hpp"
-
-#include "../../log.hpp"
-
-#include <format>
-
-#include "util.hpp"
-
-using namespace tinyxml2;
-using namespace game::util;
-
-namespace game::resource::xml
-{
-  Menu::Menu(const physfs::Path& path)
-  {
-    XMLDocument document;
-
-    if (document_load(path, document) != XML_SUCCESS)
-    {
-      logger.error(std::format("Unable to initialize menu schema: {} ({})", path.c_str(), document.ErrorStr()));
-      return;
-    }
-
-    auto archive = path.directory_get();
-
-    if (auto root = document.RootElement())
-    {
-      std::string soundRootPath{};
-      query_string_attribute(root, "SoundRootPath", &soundRootPath);
-
-      std::string fontRootPath{};
-      query_string_attribute(root, "FontRootPath", &fontRootPath);
-
-      query_font(root, "Font", archive, fontRootPath, font);
-      root->QueryFloatAttribute("Rounding", &rounding);
-
-      if (auto element = root->FirstChildElement("Sounds"))
-      {
-        query_sound_entry_collection(element, "Open", archive, soundRootPath, sounds.open);
-        query_sound_entry_collection(element, "Close", archive, soundRootPath, sounds.close);
-        query_sound_entry_collection(element, "Hover", archive, soundRootPath, sounds.hover);
-        query_sound_entry_collection(element, "Select", archive, soundRootPath, sounds.select);
-        query_sound_entry_collection(element, "CheatsActivated", archive, soundRootPath, sounds.cheatsActivated);
-      }
-    }
-
-    isValid = true;
-
-    logger.info(std::format("Initialized menu schema: {}", path.c_str()));
-  }
-
-  bool Menu::is_valid() const { return isValid; };
-}
diff --git a/src/resource/xml/menu.hpp b/src/resource/xml/menu.hpp
deleted file mode 100644
index 8194ccb..0000000
--- a/src/resource/xml/menu.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-
-#include "../../util/physfs.hpp"
-#include "../font.hpp"
-#include "sound_entry.hpp"
-
-namespace game::resource::xml
-{
-  class Menu
-  {
-  public:
-    struct Sounds
-    {
-      SoundEntryCollection open{};
-      SoundEntryCollection close{};
-      SoundEntryCollection hover{};
-      SoundEntryCollection select{};
-      SoundEntryCollection cheatsActivated{};
-    };
-
-    Sounds sounds{};
-    Font font{};
-    float rounding{};
-
-    bool isValid{};
-
-    Menu() = default;
-    Menu(const util::physfs::Path&);
-
-    bool is_valid() const;
-  };
-}
diff --git a/src/resource/xml/orbit.cpp b/src/resource/xml/orbit.cpp
deleted file mode 100644
index 444e710..0000000
--- a/src/resource/xml/orbit.cpp
+++ /dev/null
@@ -1,134 +0,0 @@
-#include "orbit.hpp"
-
-#include "../../log.hpp"
-#include "util.hpp"
-
-#include <format>
-
-using namespace tinyxml2;
-using namespace game::util;
-
-namespace game::resource::xml
-{
-  Orbit::Orbit(const util::physfs::Path& path, Dialogue& dialogue)
-  {
-    XMLDocument document;
-
-    if (document_load(path, document) != XML_SUCCESS)
-    {
-      logger.error(std::format("Unable to initialize orbit schema: {} ({})", path.c_str(), document.ErrorStr()));
-      return;
-    }
-
-    auto archive = path.directory_get();
-
-    if (auto root = document.RootElement())
-    {
-      std::string textureRootPath{};
-      query_string_attribute(root, "TextureRootPath", &textureRootPath);
-
-      std::string soundRootPath{};
-      query_string_attribute(root, "SoundRootPath", &soundRootPath);
-
-      if (std::string_view(root->Name()) != "Orbit")
-      {
-        logger.error(std::format("Orbit schema root element is not Orbit: {}", path.c_str()));
-        return;
-      }
-
-      root->QueryIntAttribute("StartTime", &startTime);
-      root->QueryFloatAttribute("RewardChanceBase", &rewardChanceBase);
-      root->QueryFloatAttribute("RewardChanceScoreBonus", &rewardChanceScoreBonus);
-      root->QueryFloatAttribute("RewardRollChanceBase", &rewardRollChanceBase);
-      root->QueryFloatAttribute("RewardRollScoreBonus", &rewardRollScoreBonus);
-      dialogue.query_pool_id(root, "HurtDialoguePoolID", poolHurt.id);
-      dialogue.query_pool_id(root, "DeathDialoguePoolID", poolDeath.id);
-
-      if (auto element = root->FirstChildElement("Player"))
-      {
-        query_anm2(element, "Anm2", archive, textureRootPath, player.anm2);
-        query_string_attribute(element, "HitboxNull", &player.hitboxNull);
-        element->QueryFloatAttribute("FollowerRadius", &player.followerRadius);
-        element->QueryFloatAttribute("TargetAcceleration", &player.targetAcceleration);
-        element->QueryFloatAttribute("RotationSpeed", &player.rotationSpeed);
-        element->QueryFloatAttribute("RotationSpeedMax", &player.rotationSpeedMax);
-        element->QueryFloatAttribute("RotationSpeedFriction", &player.rotationSpeedFriction);
-        element->QueryIntAttribute("TimeAfterHurt", &player.timeAfterHurt);
-
-        if (auto animationsElement = element->FirstChildElement("Animations"))
-        {
-          query_string_attribute(animationsElement, "Idle", &player.animations.idle);
-          query_string_attribute(animationsElement, "Spawn", &player.animations.spawn);
-          query_string_attribute(animationsElement, "Death", &player.animations.death);
-        }
-      }
-
-      if (auto element = root->FirstChildElement("Follower"))
-      {
-        query_anm2(element, "Anm2", archive, textureRootPath, follower.anm2);
-        query_string_attribute(element, "HitboxNull", &follower.hitboxNull);
-        element->QueryFloatAttribute("TargetAcceleration", &follower.targetAcceleration);
-        query_string_attribute(element, "OverrideTintLayer", &follower.overrideTintLayer);
-
-        if (auto animationsElement = element->FirstChildElement("Animations"))
-        {
-          query_string_attribute(animationsElement, "Idle", &follower.animations.idle);
-          query_string_attribute(animationsElement, "Spawn", &follower.animations.spawn);
-          query_string_attribute(animationsElement, "Death", &follower.animations.death);
-        }
-      }
-
-      if (auto element = root->FirstChildElement("Enemy"))
-      {
-        query_anm2(element, "Anm2", archive, textureRootPath, enemy.anm2);
-        query_string_attribute(element, "HitboxNull", &enemy.hitboxNull);
-        element->QueryFloatAttribute("Speed", &enemy.speed);
-        element->QueryFloatAttribute("SpeedScoreBonus", &enemy.speedScoreBonus);
-        element->QueryFloatAttribute("SpeedGainBase", &enemy.speedGainBase);
-        element->QueryFloatAttribute("SpeedGainScoreBonus", &enemy.speedGainScoreBonus);
-        element->QueryFloatAttribute("SpawnChanceBase", &enemy.spawnChanceBase);
-        element->QueryFloatAttribute("SpawnChanceScoreBonus", &enemy.spawnChanceScoreBonus);
-        element->QueryFloatAttribute("SpawnPadding", &enemy.spawnPadding);
-        query_string_attribute(element, "OverrideTintLayer", &enemy.overrideTintLayer);
-
-        if (auto animationsElement = element->FirstChildElement("Animations"))
-        {
-          query_string_attribute(animationsElement, "Idle", &enemy.animations.idle);
-          query_string_attribute(animationsElement, "Spawn", &enemy.animations.spawn);
-          query_string_attribute(animationsElement, "Death", &enemy.animations.death);
-        }
-      }
-
-      if (auto element = root->FirstChildElement("Warning"))
-      {
-        query_anm2(element, "Anm2", archive, textureRootPath, warning.anm2);
-        query_string_attribute(element, "OverrideTintLayer", &warning.overrideTintLayer);
-      }
-
-      if (auto element = root->FirstChildElement("Colors"))
-      {
-        for (auto child = element->FirstChildElement("Color"); child; child = child->NextSiblingElement("Color"))
-        {
-          Color color{};
-          query_vec3(child, "ColorR", "ColorG", "ColorB", color.value);
-          child->QueryIntAttribute("ScoreThreshold", &color.scoreThreshold);
-          dialogue.query_pool_id(child, "DialoguePoolID", color.pool.id);
-          colors.emplace_back(std::move(color));
-        }
-      }
-
-      if (auto element = root->FirstChildElement("Sounds"))
-      {
-        query_sound_entry_collection(element, "LevelUp", archive, soundRootPath, sounds.levelUp);
-        query_sound_entry_collection(element, "Hurt", archive, soundRootPath, sounds.hurt);
-        query_sound_entry_collection(element, "HighScore", archive, soundRootPath, sounds.highScore);
-        query_sound_entry_collection(element, "HighScoreLoss", archive, soundRootPath, sounds.highScoreLoss);
-      }
-    }
-
-    isValid = true;
-    logger.info(std::format("Initialized orbit schema: {}", path.c_str()));
-  }
-
-  bool Orbit::is_valid() const { return isValid; };
-}
diff --git a/src/resource/xml/orbit.hpp b/src/resource/xml/orbit.hpp
deleted file mode 100644
index fed02c0..0000000
--- a/src/resource/xml/orbit.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#pragma once
-
-#include "dialogue.hpp"
-#include "util.hpp"
-
-namespace game::resource::xml
-{
-  class Orbit
-  {
-  public:
-    struct Sounds
-    {
-      SoundEntryCollection levelUp{};
-      SoundEntryCollection hurt{};
-      SoundEntryCollection highScore{};
-      SoundEntryCollection highScoreLoss{};
-    };
-
-    struct Animations
-    {
-      std::string idle{};
-      std::string spawn{};
-      std::string death{};
-    };
-
-    struct Player
-    {
-      Anm2 anm2{};
-      Animations animations{};
-      std::string hitboxNull{"Hitbox"};
-      float followerRadius{};
-      float targetAcceleration{6.0f};
-      float rotationSpeed{0.01f};
-      float rotationSpeedMax{0.10f};
-      float rotationSpeedFriction{0.85f};
-      int timeAfterHurt{30};
-    };
-
-    struct Follower
-    {
-      Anm2 anm2{};
-      Animations animations{};
-      std::string hitboxNull{"Hitbox"};
-      float targetAcceleration{4.0f};
-      std::string overrideTintLayer{"Default"};
-    };
-
-    struct Enemy
-    {
-      Anm2 anm2{};
-      Animations animations{};
-      std::string hitboxNull{"Hitbox"};
-      float speed{4.0f};
-      float speedScoreBonus{0.001f};
-      float speedGainBase{0.01f};
-      float speedGainScoreBonus{0.001f};
-      float spawnChanceBase{0.35f};
-      float spawnChanceScoreBonus{0.05f};
-      float spawnPadding{8.0f};
-      std::string overrideTintLayer{"Default"};
-    };
-
-    struct Warning
-    {
-      Anm2 anm2{};
-      std::string overrideTintLayer{"Default"};
-    };
-
-    struct Color
-    {
-      glm::vec3 value{};
-      int scoreThreshold{};
-      Dialogue::PoolReference pool{};
-    };
-
-    Player player{};
-    Follower follower{};
-    Enemy enemy{};
-    Warning warning{};
-    Sounds sounds{};
-
-    Dialogue::PoolReference poolHurt{};
-    Dialogue::PoolReference poolDeath{};
-
-    float rewardChanceBase{0.001f};
-    float rewardChanceScoreBonus{0.001f};
-    float rewardRollChanceBase{1.0f};
-    float rewardRollScoreBonus{};
-
-    std::vector<Color> colors{};
-    int startTime{30};
-
-    bool isValid{};
-
-    Orbit() = default;
-    Orbit(const util::physfs::Path&, Dialogue&);
-
-    bool is_valid() const;
-  };
-}
diff --git a/src/resource/xml/save.cpp b/src/resource/xml/save.cpp
deleted file mode 100644
index 387ac22..0000000
--- a/src/resource/xml/save.cpp
+++ /dev/null
@@ -1,195 +0,0 @@
-#include "save.hpp"
-#include "util.hpp"
-
-#include <tinyxml2/tinyxml2.h>
-
-#include "../../log.hpp"
-
-#include <format>
-
-#ifdef __EMSCRIPTEN__
-  #include "../../util/web_filesystem.hpp"
-#endif
-
-using namespace game::util;
-
-using namespace tinyxml2;
-
-namespace game::resource::xml
-{
-  Save::Save(const std::filesystem::path& path)
-  {
-    XMLDocument document;
-    auto pathString = path.string();
-
-    auto result = document.LoadFile(pathString.c_str());
-
-    if (result == XML_ERROR_FILE_NOT_FOUND || result == XML_ERROR_FILE_COULD_NOT_BE_OPENED) return;
-
-    if (result != XML_SUCCESS)
-    {
-      logger.error(std::format("Could not initialize character save file: {} ({})", pathString, document.ErrorStr()));
-      return;
-    }
-
-    if (auto root = document.RootElement())
-    {
-      query_bool_attribute(root, "IsPostgame", &isPostgame);
-      query_bool_attribute(root, "IsAlternateSpritesheet", &isAlternateSpritesheet);
-
-      if (auto element = root->FirstChildElement("Character"))
-      {
-
-        element->QueryFloatAttribute("Weight", &weight);
-        element->QueryFloatAttribute("Calories", &calories);
-        element->QueryFloatAttribute("Capacity", &capacity);
-        element->QueryFloatAttribute("DigestionRate", &digestionRate);
-        element->QueryFloatAttribute("EatSpeed", &eatSpeed);
-        query_bool_attribute(element, "IsDigesting", &isDigesting);
-        element->QueryFloatAttribute("DigestionProgress", &digestionProgress);
-        element->QueryIntAttribute("DigestionTimer", &digestionTimer);
-        element->QueryFloatAttribute("TotalCaloriesConsumed", &totalCaloriesConsumed);
-        element->QueryIntAttribute("TotalFoodItemsEaten", &totalFoodItemsEaten);
-      }
-
-      auto skillCheckElement = root->FirstChildElement("SkillCheck");
-      if (!skillCheckElement) skillCheckElement = root->FirstChildElement("Play");
-      if (skillCheckElement)
-      {
-        skillCheckElement->QueryIntAttribute("TotalPlays", &skillCheck.totalPlays);
-        skillCheckElement->QueryIntAttribute("HighScore", &skillCheck.highScore);
-        skillCheckElement->QueryIntAttribute("BestCombo", &skillCheck.bestCombo);
-
-        if (auto child = skillCheckElement->FirstChildElement("Grades"))
-        {
-          for (auto gradeChild = child->FirstChildElement("Grade"); gradeChild;
-               gradeChild = gradeChild->NextSiblingElement("Grade"))
-          {
-            int id{};
-            gradeChild->QueryIntAttribute("ID", &id);
-            gradeChild->QueryIntAttribute("Count", &skillCheck.gradeCounts[id]);
-          }
-        }
-      }
-
-      if (auto orbitElement = root->FirstChildElement("Orbit"))
-      {
-        orbitElement->QueryIntAttribute("HighScore", &orbit.highScore);
-      }
-
-      if (auto inventoryElement = root->FirstChildElement("Inventory"))
-      {
-        for (auto child = inventoryElement->FirstChildElement("Item"); child; child = child->NextSiblingElement("Item"))
-        {
-          int id{};
-          int quantity{};
-          child->QueryIntAttribute("ID", &id);
-          child->QueryIntAttribute("Quantity", &quantity);
-
-          inventory[id] = quantity;
-        }
-      }
-
-      if (auto itemsElement = root->FirstChildElement("Items"))
-      {
-        for (auto child = itemsElement->FirstChildElement("Item"); child; child = child->NextSiblingElement("Item"))
-        {
-          Item item{};
-          child->QueryIntAttribute("ID", &item.id);
-          child->QueryIntAttribute("Durability", &item.durability);
-          child->QueryFloatAttribute("PositionX", &item.position.x);
-          child->QueryFloatAttribute("PositionY", &item.position.y);
-          child->QueryFloatAttribute("VelocityX", &item.velocity.x);
-          child->QueryFloatAttribute("VelocityY", &item.velocity.y);
-          child->QueryFloatAttribute("Rotation", &item.rotation);
-          items.emplace_back(std::move(item));
-        }
-      }
-    }
-
-    logger.info(std::format("Initialized character save file: {}", pathString));
-
-    isValid = true;
-  }
-
-  bool Save::is_valid() const { return isValid; }
-
-  void Save::serialize(const std::filesystem::path& path)
-  {
-    XMLDocument document;
-    auto pathString = path.string();
-
-    auto element = document.NewElement("Save");
-    element->SetAttribute("IsPostgame", isPostgame ? "true" : "false");
-    element->SetAttribute("IsAlternateSpritesheet", isAlternateSpritesheet ? "true" : "false");
-
-    auto characterElement = element->InsertNewChildElement("Character");
-    characterElement->SetAttribute("Weight", weight);
-    characterElement->SetAttribute("Calories", calories);
-    characterElement->SetAttribute("Capacity", capacity);
-    characterElement->SetAttribute("DigestionRate", digestionRate);
-    characterElement->SetAttribute("EatSpeed", eatSpeed);
-    characterElement->SetAttribute("IsDigesting", isDigesting ? "true" : "false");
-    characterElement->SetAttribute("DigestionProgress", digestionProgress);
-    characterElement->SetAttribute("DigestionTimer", digestionTimer);
-    characterElement->SetAttribute("TotalCaloriesConsumed", totalCaloriesConsumed);
-    characterElement->SetAttribute("TotalFoodItemsEaten", totalFoodItemsEaten);
-
-    auto skillCheckElement = element->InsertNewChildElement("SkillCheck");
-
-    skillCheckElement->SetAttribute("TotalPlays", skillCheck.totalPlays);
-    skillCheckElement->SetAttribute("HighScore", skillCheck.highScore);
-    skillCheckElement->SetAttribute("BestCombo", skillCheck.bestCombo);
-
-    auto gradesElement = skillCheckElement->InsertNewChildElement("Grades");
-
-    for (auto& [i, count] : skillCheck.gradeCounts)
-    {
-      auto gradeElement = gradesElement->InsertNewChildElement("Grade");
-      gradeElement->SetAttribute("ID", i);
-      gradeElement->SetAttribute("Count", count);
-    }
-
-    auto orbitElement = element->InsertNewChildElement("Orbit");
-    orbitElement->SetAttribute("HighScore", orbit.highScore);
-
-    auto inventoryElement = element->InsertNewChildElement("Inventory");
-
-    for (auto& [id, quantity] : inventory)
-    {
-      auto itemElement = inventoryElement->InsertNewChildElement("Item");
-
-      itemElement->SetAttribute("ID", id);
-      itemElement->SetAttribute("Quantity", quantity);
-    }
-
-    auto itemsElement = element->InsertNewChildElement("Items");
-
-    for (auto& item : items)
-    {
-      auto itemElement = itemsElement->InsertNewChildElement("Item");
-
-      itemElement->SetAttribute("ID", item.id);
-      itemElement->SetAttribute("Durability", item.durability);
-      itemElement->SetAttribute("PositionX", item.position.x);
-      itemElement->SetAttribute("PositionY", item.position.y);
-      itemElement->SetAttribute("VelocityX", item.velocity.x);
-      itemElement->SetAttribute("VelocityY", item.velocity.y);
-      itemElement->SetAttribute("Rotation", item.rotation);
-    }
-
-    document.InsertFirstChild(element);
-
-    if (document.SaveFile(pathString.c_str()) != XML_SUCCESS)
-    {
-      logger.error(std::format("Failed to save character save file: {} ({})", pathString, document.ErrorStr()));
-      return;
-    }
-
-    logger.info(std::format("Saved character save file: {}", pathString));
-
-#ifdef __EMSCRIPTEN__
-    web_filesystem::flush_async();
-#endif
-  }
-}
diff --git a/src/resource/xml/save.hpp b/src/resource/xml/save.hpp
deleted file mode 100644
index 15e3f9c..0000000
--- a/src/resource/xml/save.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#pragma once
-
-#include <filesystem>
-
-#include <map>
-#include <vector>
-
-#include <glm/glm.hpp>
-
-namespace game::resource::xml
-{
-  class Save
-  {
-  public:
-    struct SkillCheck
-    {
-      int totalPlays{};
-      int highScore{};
-      int bestCombo{};
-      std::map<int, int> gradeCounts{};
-    };
-
-    struct Orbit
-    {
-      int highScore{};
-    };
-
-    struct Item
-    {
-      int id{};
-      int durability{};
-      glm::vec2 position{};
-      glm::vec2 velocity{};
-      float rotation{};
-    };
-
-    float weight{};
-    float calories{};
-    float capacity{};
-    float eatSpeed{};
-    float digestionRate{};
-    float digestionProgress{};
-    int digestionTimer{};
-    bool isDigesting{};
-
-    bool isAlternateSpritesheet{};
-
-    float totalCaloriesConsumed{};
-    int totalFoodItemsEaten{};
-    SkillCheck skillCheck{};
-    Orbit orbit{};
-
-    std::map<int, int> inventory;
-    std::vector<Item> items;
-
-    bool isPostgame{};
-
-    bool isValid{};
-
-    Save() = default;
-    Save(const std::filesystem::path&);
-    void serialize(const std::filesystem::path&);
-    bool is_valid() const;
-  };
-}
diff --git a/src/resource/xml/settings.cpp b/src/resource/xml/settings.cpp
deleted file mode 100644
index 559c66e..0000000
--- a/src/resource/xml/settings.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#include "settings.hpp"
-#include "util.hpp"
-
-#include <tinyxml2/tinyxml2.h>
-
-#include "../../log.hpp"
-
-#include <format>
-
-#ifdef __EMSCRIPTEN__
-  #include "../../util/web_filesystem.hpp"
-#endif
-
-using namespace tinyxml2;
-using namespace game::util;
-
-namespace game::resource::xml
-{
-  Settings::Settings(const std::filesystem::path& path)
-  {
-    XMLDocument document;
-    auto pathString = path.string();
-
-    if (document.LoadFile(pathString.c_str()) != XML_SUCCESS)
-    {
-      logger.error(std::format("Could not initialize character save file: {} ({})", pathString, document.ErrorStr()));
-      return;
-    }
-
-    if (auto root = document.RootElement())
-    {
-      std::string measurementSystemString{};
-      query_string_attribute(root, "MeasurementSystem", &measurementSystemString);
-      measurementSystem = measurementSystemString == "Imperial" ? measurement::IMPERIAL : measurement::METRIC;
-      root->QueryIntAttribute("Volume", &volume);
-      query_vec3(root, "ColorR", "ColorG", "ColorB", color);
-      query_vec2(root, "WindowX", "WindowY", windowPosition);
-      query_ivec2(root, "WindowW", "WindowH", windowSize);
-      query_bool_attribute(root, "IsUseCharacterColor", &isUseCharacterColor);
-    }
-
-    logger.info(std::format("Initialized settings: {}", pathString));
-
-    isValid = true;
-  }
-
-  bool Settings::is_valid() const { return isValid; }
-
-  void Settings::serialize(const std::filesystem::path& path)
-  {
-    XMLDocument document;
-    auto pathString = path.string();
-
-    auto element = document.NewElement("Settings");
-
-    element->SetAttribute("MeasurementSystem", measurementSystem == measurement::IMPERIAL ? "Imperial" : "Metric");
-    element->SetAttribute("Volume", volume);
-    set_vec3_attribute(element, "ColorR", "ColorG", "ColorB", color);
-    set_vec2_attribute(element, "WindowX", "WindowY", windowPosition);
-    set_ivec2_attribute(element, "WindowW", "WindowH", windowSize);
-    set_bool_attribute(element, "IsUseCharacterColor", isUseCharacterColor);
-
-    document.InsertFirstChild(element);
-
-    if (document.SaveFile(pathString.c_str()) != XML_SUCCESS)
-    {
-      logger.info(std::format("Failed to initialize settings: {} ({})", pathString, document.ErrorStr()));
-      return;
-    }
-
-    logger.info(std::format("Saved settings: {}", pathString));
-
-#ifdef __EMSCRIPTEN__
-    web_filesystem::flush_async();
-#endif
-  }
-}
diff --git a/src/resource/xml/settings.hpp b/src/resource/xml/settings.hpp
deleted file mode 100644
index 630da58..0000000
--- a/src/resource/xml/settings.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#pragma once
-
-#include "../../util/measurement.hpp"
-#include <filesystem>
-
-#include <glm/glm.hpp>
-
-namespace game::resource::xml
-{
-  class Settings
-  {
-  public:
-    static constexpr auto VOLUME_MIN = 0;
-    static constexpr auto VOLUME_MAX = 100;
-
-    enum Mode
-    {
-      LOADER,
-      IMGUI
-    };
-
-    util::measurement::System measurementSystem{util::measurement::METRIC};
-    int volume{50};
-    bool isUseCharacterColor{true};
-
-    glm::vec3 color{0.120f, 0.120f, 0.120f};
-    glm::ivec2 windowSize{1600, 900};
-    glm::vec2 windowPosition{};
-
-    bool isValid{};
-
-    Settings() = default;
-    Settings(const std::filesystem::path&);
-    void serialize(const std::filesystem::path&);
-    bool is_valid() const;
-  };
-}
diff --git a/src/resource/xml/skill_check.cpp b/src/resource/xml/skill_check.cpp
deleted file mode 100644
index ea0cc12..0000000
--- a/src/resource/xml/skill_check.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#include "skill_check.hpp"
-
-#include "../../log.hpp"
-#include "util.hpp"
-
-#include <format>
-
-using namespace tinyxml2;
-using namespace game::util;
-
-namespace game::resource::xml
-{
-  SkillCheck::SkillCheck(const physfs::Path& path, Dialogue& dialogue)
-  {
-    XMLDocument document;
-
-    if (document_load(path, document) != XML_SUCCESS)
-    {
-      return;
-    }
-
-    auto archive = path.directory_get();
-
-    if (auto root = document.RootElement())
-    {
-      std::string soundRootPath{};
-      query_string_attribute(root, "SoundRootPath", &soundRootPath);
-
-      root->QueryIntAttribute("RewardScore", &rewardScore);
-      root->QueryFloatAttribute("RewardChanceBase", &rewardChanceBase);
-      root->QueryFloatAttribute("RewardChanceScoreBonus", &rewardChanceScoreBonus);
-      root->QueryFloatAttribute("RewardRollChanceBase", &rewardRollChanceBase);
-      root->QueryFloatAttribute("RewardRollScoreBonus", &rewardRollScoreBonus);
-      root->QueryFloatAttribute("RewardRollGradeBonus", &rewardRollGradeBonus);
-      root->QueryFloatAttribute("ZoneBase", &zoneBase);
-      root->QueryFloatAttribute("ZoneMin", &zoneMin);
-      root->QueryFloatAttribute("ZoneScoreBonus", &zoneScoreBonus);
-      root->QueryFloatAttribute("SpeedMin", &speedMin);
-      root->QueryFloatAttribute("SpeedMax", &speedMax);
-      root->QueryFloatAttribute("SpeedScoreBonus", &speedScoreBonus);
-      root->QueryIntAttribute("EndTimerMax", &endTimerMax);
-      root->QueryIntAttribute("EndTimerFailureMax", &endTimerFailureMax);
-
-      if (auto element = root->FirstChildElement("Sounds"))
-      {
-        query_sound_entry_collection(element, "Fall", archive, soundRootPath, sounds.fall);
-        query_sound_entry_collection(element, "ScoreLoss", archive, soundRootPath, sounds.scoreLoss);
-        query_sound_entry_collection(element, "HighScore", archive, soundRootPath, sounds.highScore);
-        query_sound_entry_collection(element, "HighScoreLoss", archive, soundRootPath, sounds.highScoreLoss);
-        query_sound_entry_collection(element, "RewardScore", archive, soundRootPath, sounds.rewardScore);
-      }
-
-      if (auto element = root->FirstChildElement("Grades"))
-      {
-        for (auto child = element->FirstChildElement("Grade"); child; child = child->NextSiblingElement("Grade"))
-        {
-          Grade grade{};
-          query_string_attribute(child, "Name", &grade.name);
-          query_string_attribute(child, "NamePlural", &grade.namePlural);
-          child->QueryIntAttribute("Value", &grade.value);
-          child->QueryFloatAttribute("Weight", &grade.weight);
-          query_bool_attribute(child, "IsFailure", &grade.isFailure);
-          query_sound(child, "Sound", archive, soundRootPath, grade.sound);
-          dialogue.query_pool_id(child, "DialoguePoolID", grade.pool.id);
-          grades.emplace_back(std::move(grade));
-        }
-      }
-    }
-
-    isValid = true;
-    logger.info(std::format("Initialized skill check schema: {}", path.c_str()));
-  }
-
-  bool SkillCheck::is_valid() const { return isValid; };
-}
diff --git a/src/resource/xml/skill_check.hpp b/src/resource/xml/skill_check.hpp
deleted file mode 100644
index 47dff62..0000000
--- a/src/resource/xml/skill_check.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "util.hpp"
-
-#include "dialogue.hpp"
-
-namespace game::resource::xml
-{
-  class SkillCheck
-  {
-  public:
-    struct Grade
-    {
-      std::string name{};
-      std::string namePlural{};
-      int value{};
-      float weight{};
-      bool isFailure{};
-      Audio sound{};
-      Dialogue::PoolReference pool{};
-    };
-
-    struct Sounds
-    {
-      SoundEntryCollection fall{};
-      SoundEntryCollection highScore{};
-      SoundEntryCollection highScoreLoss{};
-      SoundEntryCollection rewardScore{};
-      SoundEntryCollection scoreLoss{};
-    };
-
-    Sounds sounds{};
-    std::vector<Grade> grades{};
-
-    float rewardChanceBase{0.01f};
-    float rewardChanceScoreBonus{0.01f};
-    float rewardRollChanceBase{1.0f};
-    float rewardRollScoreBonus{0.05f};
-    float rewardRollGradeBonus{0.05f};
-    float speedMin{0.005f};
-    float speedMax{0.075f};
-    float speedScoreBonus{0.000025f};
-    float zoneBase{0.75f};
-    float zoneMin{0.10f};
-    float zoneScoreBonus{0.0005f};
-    int endTimerMax{20};
-    int endTimerFailureMax{60};
-    int rewardScore{999};
-
-    bool isValid{};
-
-    SkillCheck() = default;
-    SkillCheck(const util::physfs::Path&, Dialogue&);
-
-    bool is_valid() const;
-  };
-}
diff --git a/src/resource/xml/sound_entry.cpp b/src/resource/xml/sound_entry.cpp
deleted file mode 100644
index 027da0c..0000000
--- a/src/resource/xml/sound_entry.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "sound_entry.hpp"
-
-#include "../../util/vector.hpp"
-
-namespace game::resource::xml
-{
-  Audio* SoundEntryCollection::get()
-  {
-    if (empty()) return nullptr;
-    return &at(util::vector::random_index_weighted(*this, [](const auto& entry) { return entry.weight; })).sound;
-  }
-
-  void SoundEntryCollection::play()
-  {
-    if (empty()) return;
-    if (auto audio = get()) audio->play();
-  }
-}
diff --git a/src/resource/xml/sound_entry.hpp b/src/resource/xml/sound_entry.hpp
deleted file mode 100644
index baaf3f1..0000000
--- a/src/resource/xml/sound_entry.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-// Handles sound entries in .xml files. "Weight" value determines weight of being randomly selected.
-
-#pragma once
-
-#include "../audio.hpp"
-
-namespace game::resource::xml
-{
-  class SoundEntry
-  {
-  public:
-    Audio sound{};
-    float weight{1.0f};
-
-    inline void play() { sound.play(); };
-  };
-
-  class SoundEntryCollection : public std::vector<SoundEntry>
-  {
-  public:
-    Audio* get();
-    void play();
-  };
-}
diff --git a/src/resource/xml/util.cpp b/src/resource/xml/util.cpp
deleted file mode 100644
index b19be8a..0000000
--- a/src/resource/xml/util.cpp
+++ /dev/null
@@ -1,301 +0,0 @@
-#include "util.hpp"
-
-#include <format>
-
-#include "../../util/physfs.hpp"
-#include "../../util/string.hpp"
-
-#include "../../log.hpp"
-
-using namespace tinyxml2;
-using namespace game::util;
-
-namespace game::resource::xml
-{
-  XMLError query_result_merge(XMLError result, XMLError next) { return result == XML_SUCCESS ? next : result; }
-
-  XMLError query_string_attribute(XMLElement* element, const char* attribute, std::string* value)
-  {
-    const char* temp = nullptr;
-    auto result = element->QueryStringAttribute(attribute, &temp);
-    if (result == XML_SUCCESS && temp && value) *value = temp;
-    return result;
-  }
-
-  XMLError query_bool_attribute(XMLElement* element, const char* attribute, bool* value)
-  {
-    std::string temp{};
-    auto result = query_string_attribute(element, attribute, &temp);
-    temp = string::to_lower(temp);
-    if (value) *value = temp == "true" || temp == "1" ? true : false;
-    return result;
-  }
-
-  XMLError query_path_attribute(XMLElement* element, const char* attribute, std::filesystem::path* value)
-  {
-    std::string temp{};
-    auto result = query_string_attribute(element, attribute, &temp);
-    if (value) *value = std::filesystem::path(temp);
-    return result;
-  }
-
-  XMLError query_color_attribute(XMLElement* element, const char* attribute, float* value)
-  {
-    int temp{};
-    auto result = element->QueryIntAttribute(attribute, &temp);
-    if (result == XML_SUCCESS && value) *value = (temp / 255.0f);
-    return result;
-  }
-
-  XMLError query_ivec2(XMLElement* element, const char* attributeX, const char* attributeY, glm::ivec2& value)
-  {
-    auto result = element->QueryIntAttribute(attributeX, &value.x);
-    result = query_result_merge(result, element->QueryIntAttribute(attributeY, &value.y));
-    return result;
-  }
-
-  XMLError query_vec2(XMLElement* element, const char* attributeX, const char* attributeY, glm::vec2& value)
-  {
-    auto result = element->QueryFloatAttribute(attributeX, &value.x);
-    result = query_result_merge(result, element->QueryFloatAttribute(attributeY, &value.y));
-    return result;
-  }
-
-  XMLError query_vec3(XMLElement* element, const char* attributeX, const char* attributeY, const char* attributeZ,
-                      glm::vec3& value)
-  {
-    auto result = element->QueryFloatAttribute(attributeX, &value.x);
-    result = query_result_merge(result, element->QueryFloatAttribute(attributeY, &value.y));
-    result = query_result_merge(result, element->QueryFloatAttribute(attributeZ, &value.z));
-    return result;
-  }
-
-  XMLError set_bool_attribute(XMLElement* element, const char* attribute, bool value)
-  {
-    element->SetAttribute(attribute, value ? "true" : "false");
-    return XML_SUCCESS;
-  }
-
-  XMLError set_ivec2_attribute(XMLElement* element, const char* attributeX, const char* attributeY,
-                               const glm::ivec2& value)
-  {
-    element->SetAttribute(attributeX, value.x);
-    element->SetAttribute(attributeY, value.y);
-    return XML_SUCCESS;
-  }
-
-  XMLError set_vec2_attribute(XMLElement* element, const char* attributeX, const char* attributeY,
-                              const glm::vec2& value)
-  {
-    element->SetAttribute(attributeX, value.x);
-    element->SetAttribute(attributeY, value.y);
-    return XML_SUCCESS;
-  }
-
-  XMLError set_vec3_attribute(XMLElement* element, const char* attributeX, const char* attributeY,
-                              const char* attributeZ, const glm::vec3& value)
-  {
-    element->SetAttribute(attributeX, value.x);
-    element->SetAttribute(attributeY, value.y);
-    element->SetAttribute(attributeZ, value.z);
-    return XML_SUCCESS;
-  }
-
-  XMLError query_float_optional_attribute(XMLElement* element, const char* attribute, std::optional<float>& value)
-  {
-    value.emplace();
-    auto result = element->QueryFloatAttribute(attribute, &*value);
-    if (result == XML_NO_ATTRIBUTE) value.reset();
-    return result;
-  }
-
-  XMLError query_int_optional_attribute(XMLElement* element, const char* attribute, std::optional<int>& value)
-  {
-    value.emplace();
-    auto result = element->QueryIntAttribute(attribute, &*value);
-    if (result == XML_NO_ATTRIBUTE) value.reset();
-    return result;
-  }
-
-  XMLError query_optional_vec3(XMLElement* element, const char* attributeX, const char* attributeY,
-                               const char* attributeZ, std::optional<glm::vec3>& value)
-  {
-    auto hasX = element->FindAttribute(attributeX);
-    auto hasY = element->FindAttribute(attributeY);
-    auto hasZ = element->FindAttribute(attributeZ);
-
-    if (!hasX && !hasY && !hasZ)
-    {
-      value.reset();
-      return XML_NO_ATTRIBUTE;
-    }
-
-    value = glm::vec3();
-    auto result = XML_SUCCESS;
-
-    if (hasX) result = query_result_merge(result, element->QueryFloatAttribute(attributeX, &value->x));
-    if (hasY) result = query_result_merge(result, element->QueryFloatAttribute(attributeY, &value->y));
-    if (hasZ) result = query_result_merge(result, element->QueryFloatAttribute(attributeZ, &value->z));
-
-    return result;
-  }
-
-  XMLError document_load(const physfs::Path& path, XMLDocument& document)
-  {
-    if (!path.is_valid())
-    {
-      logger.error(std::format("Failed to open XML document: {} ({})", path.c_str(), physfs::error_get()));
-      return XML_ERROR_FILE_NOT_FOUND;
-    }
-
-    auto buffer = path.read();
-
-    if (buffer.empty())
-    {
-      logger.error(std::format("Failed to read XML document: {} ({})", path.c_str(), physfs::error_get()));
-      return XML_ERROR_FILE_COULD_NOT_BE_OPENED;
-    }
-
-    auto result = document.Parse((const char*)buffer.data(), buffer.size());
-    if (result != XML_SUCCESS)
-      logger.error(std::format("Failed to parse XML document: {} ({})", path.c_str(), document.ErrorStr()));
-
-    return result;
-  }
-
-  XMLError query_event_id(XMLElement* element, const char* name, const Anm2& anm2, int& eventID)
-  {
-    std::string string{};
-    auto result = query_string_attribute(element, name, &string);
-    if (result != XML_SUCCESS) return result;
-
-    if (anm2.eventMap.contains(string))
-    {
-      eventID = anm2.eventMap.at(string);
-      return XML_SUCCESS;
-    }
-    else
-    {
-      logger.error(std::format("Could not query anm2 event ID: {} ({})", string, anm2.path));
-      eventID = -1;
-      return XML_ERROR_PARSING_ATTRIBUTE;
-    }
-  }
-
-  XMLError query_layer_id(XMLElement* element, const char* name, const Anm2& anm2, int& layerID)
-  {
-    std::string string{};
-    auto result = query_string_attribute(element, name, &string);
-    if (result != XML_SUCCESS) return result;
-
-    if (anm2.layerMap.contains(string))
-    {
-      layerID = anm2.layerMap.at(string);
-      return XML_SUCCESS;
-    }
-    else
-    {
-      logger.error(std::format("Could not query anm2 layer ID: {} ({})", string, anm2.path));
-      layerID = -1;
-      return XML_ERROR_PARSING_ATTRIBUTE;
-    }
-  }
-
-  XMLError query_null_id(XMLElement* element, const char* name, const Anm2& anm2, int& nullID)
-  {
-    std::string string{};
-    auto result = query_string_attribute(element, name, &string);
-    if (result != XML_SUCCESS) return result;
-
-    if (anm2.nullMap.contains(string))
-    {
-      nullID = anm2.nullMap.at(string);
-      return XML_SUCCESS;
-    }
-    else
-    {
-      logger.error(std::format("Could not query anm2 null ID: {} ({})", string, anm2.path));
-      nullID = -1;
-      return XML_ERROR_PARSING_ATTRIBUTE;
-    }
-  }
-
-  XMLError query_anm2(XMLElement* element, const char* name, const std::string& archive, const std::string& rootPath,
-                      Anm2& anm2, Anm2::Flags flags)
-  {
-    std::string string{};
-    auto result = query_string_attribute(element, name, &string);
-    if (result != XML_SUCCESS) return result;
-
-    anm2 = Anm2(physfs::Path(archive + "/" + rootPath + "/" + string), flags);
-    return XML_SUCCESS;
-  }
-
-  XMLError query_texture(XMLElement* element, const char* name, const std::string& archive, const std::string& rootPath,
-                         Texture& texture)
-  {
-    std::string string{};
-    auto result = query_string_attribute(element, name, &string);
-    if (result != XML_SUCCESS) return result;
-
-    texture = Texture(physfs::Path(archive + "/" + rootPath + "/" + string));
-    return XML_SUCCESS;
-  }
-
-  XMLError query_sound(XMLElement* element, const char* name, const std::string& archive, const std::string& rootPath,
-                       Audio& sound)
-  {
-    std::string string{};
-    auto result = query_string_attribute(element, name, &string);
-    if (result != XML_SUCCESS) return result;
-
-    sound = Audio(physfs::Path(archive + "/" + rootPath + "/" + string));
-    return XML_SUCCESS;
-  }
-
-  XMLError query_font(XMLElement* element, const char* name, const std::string& archive, const std::string& rootPath,
-                      Font& font)
-  {
-    std::string string{};
-    auto result = query_string_attribute(element, name, &string);
-    if (result != XML_SUCCESS) return result;
-
-    font = Font(physfs::Path(archive + "/" + rootPath + "/" + string));
-    return XML_SUCCESS;
-  }
-
-  XMLError query_animation_entry(XMLElement* element, AnimationEntry& animationEntry)
-  {
-    auto result = query_string_attribute(element, "Animation", &animationEntry.animation);
-    result = query_result_merge(result, element->QueryFloatAttribute("Weight", &animationEntry.weight));
-    return result;
-  }
-
-  XMLError query_animation_entry_collection(XMLElement* element, const char* name,
-                                            AnimationEntryCollection& animationEntryCollection)
-  {
-    auto result = XML_SUCCESS;
-    for (auto child = element->FirstChildElement(name); child; child = child->NextSiblingElement(name))
-      result = query_result_merge(result, query_animation_entry(child, animationEntryCollection.emplace_back()));
-    return result;
-  }
-
-  XMLError query_sound_entry(XMLElement* element, const std::string& archive, const std::string& rootPath,
-                             SoundEntry& soundEntry, const std::string& attributeName)
-  {
-    auto result = query_sound(element, attributeName.c_str(), archive, rootPath, soundEntry.sound);
-    result = query_result_merge(result, element->QueryFloatAttribute("Weight", &soundEntry.weight));
-    return result;
-  }
-
-  XMLError query_sound_entry_collection(XMLElement* element, const char* name, const std::string& archive,
-                                        const std::string& rootPath, SoundEntryCollection& soundEntryCollection,
-                                        const std::string& attributeName)
-  {
-    auto result = XML_SUCCESS;
-    for (auto child = element->FirstChildElement(name); child; child = child->NextSiblingElement(name))
-      result = query_result_merge(
-          result, query_sound_entry(child, archive, rootPath, soundEntryCollection.emplace_back(), attributeName));
-    return result;
-  }
-}
diff --git a/src/resource/xml/util.hpp b/src/resource/xml/util.hpp
deleted file mode 100644
index 9ab135e..0000000
--- a/src/resource/xml/util.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#pragma once
-
-#include <filesystem>
-#include <optional>
-#include <string>
-
-#include <glm/glm.hpp>
-#include <tinyxml2.h>
-
-#include "animation_entry.hpp"
-#include "sound_entry.hpp"
-
-#include "../../util/physfs.hpp"
-#include "../font.hpp"
-#include "anm2.hpp"
-
-namespace game::resource::xml
-{
-  tinyxml2::XMLError query_string_attribute(tinyxml2::XMLElement*, const char*, std::string*);
-  tinyxml2::XMLError query_bool_attribute(tinyxml2::XMLElement*, const char*, bool*);
-  tinyxml2::XMLError query_path_attribute(tinyxml2::XMLElement*, const char*, std::filesystem::path*);
-  tinyxml2::XMLError query_color_attribute(tinyxml2::XMLElement*, const char*, float*);
-  tinyxml2::XMLError query_ivec2(tinyxml2::XMLElement*, const char*, const char*, glm::ivec2&);
-  tinyxml2::XMLError query_vec2(tinyxml2::XMLElement*, const char*, const char*, glm::vec2&);
-  tinyxml2::XMLError query_vec3(tinyxml2::XMLElement*, const char*, const char*, const char*, glm::vec3&);
-  tinyxml2::XMLError set_bool_attribute(tinyxml2::XMLElement*, const char*, bool);
-  tinyxml2::XMLError set_ivec2_attribute(tinyxml2::XMLElement*, const char*, const char*, const glm::ivec2&);
-  tinyxml2::XMLError set_vec2_attribute(tinyxml2::XMLElement*, const char*, const char*, const glm::vec2&);
-  tinyxml2::XMLError set_vec3_attribute(tinyxml2::XMLElement*, const char*, const char*, const char*,
-                                        const glm::vec3&);
-  tinyxml2::XMLError query_float_optional_attribute(tinyxml2::XMLElement* element, const char* attribute,
-                                                    std::optional<float>& value);
-  tinyxml2::XMLError query_int_optional_attribute(tinyxml2::XMLElement* element, const char* attribute,
-                                                  std::optional<int>& value);
-  tinyxml2::XMLError query_optional_vec3(tinyxml2::XMLElement* element, const char* attributeX, const char* attributeY,
-                                         const char* attributeZ, std::optional<glm::vec3>& value);
-
-  tinyxml2::XMLError query_event_id(tinyxml2::XMLElement* element, const char* name, const Anm2& anm2, int& eventID);
-  tinyxml2::XMLError query_layer_id(tinyxml2::XMLElement* element, const char* name, const Anm2& anm2, int& layerID);
-  tinyxml2::XMLError query_null_id(tinyxml2::XMLElement* element, const char* name, const Anm2& anm2, int& nullID);
-
-  tinyxml2::XMLError query_anm2(tinyxml2::XMLElement* element, const char* name, const std::string& archive,
-                                const std::string& rootPath, Anm2& anm2, Anm2::Flags flags = {});
-  tinyxml2::XMLError query_texture(tinyxml2::XMLElement* element, const char* name, const std::string& archive,
-                                   const std::string& rootPath, Texture& texture);
-  tinyxml2::XMLError query_sound(tinyxml2::XMLElement* element, const char* name, const std::string& archive,
-                                 const std::string& rootPath, Audio& sound);
-  tinyxml2::XMLError query_font(tinyxml2::XMLElement* element, const char* name, const std::string& archive,
-                                const std::string& rootPath, Font& font);
-
-  tinyxml2::XMLError query_animation_entry(tinyxml2::XMLElement* element, AnimationEntry& animationEntry);
-  tinyxml2::XMLError query_animation_entry_collection(tinyxml2::XMLElement* element, const char* name,
-                                                      AnimationEntryCollection& animationEntryCollection);
-
-  tinyxml2::XMLError query_sound_entry(tinyxml2::XMLElement* element, const std::string& archive,
-                                       const std::string& rootPath, SoundEntry& soundEntry,
-                                       const std::string& attributeName = "Sound");
-  tinyxml2::XMLError query_sound_entry_collection(tinyxml2::XMLElement* element, const char* name,
-                                                  const std::string& archive, const std::string& rootPath,
-                                                  SoundEntryCollection& soundEntryCollection,
-                                                  const std::string& attributeName = "Sound");
-
-  tinyxml2::XMLError document_load(const util::physfs::Path&, tinyxml2::XMLDocument&);
-}
diff --git a/src/resources.cpp b/src/resources.cpp
index 991ffda..953659c 100644
--- a/src/resources.cpp
+++ b/src/resources.cpp
@@ -3,6 +3,9 @@
 #include "util/preferences.hpp"
 #include "log.hpp"
 
+#include <algorithm>
+#include <format>
+
 using namespace game::resource;
 using namespace game::util;
 
@@ -13,41 +16,82 @@ namespace game
     for (int i = 0; i < shader::COUNT; i++)
       shaders[i] = Shader(shader::INFO[i].vertex, shader::INFO[i].fragment);
 
-    std::string CHARACTERS_DIRECTORY{"resources/characters"}; 
+    characters_refresh();
+  }
+
+  void Resources::characters_refresh()
+  {
+    static constexpr auto CHARACTERS_DIRECTORY = "resources/characters";
+
+    characterPreviews.clear();
+    characterSaves.clear();
+    characters.clear();
+
     std::error_code ec{};
 
     if (!std::filesystem::is_directory(CHARACTERS_DIRECTORY, ec))
     {
       if (ec)
-        logger.warning("Failed to read characters directory: " + CHARACTERS_DIRECTORY + " (" + ec.message() + ")");
+        logger.warning(std::format("Failed to read characters directory: {} ({})", CHARACTERS_DIRECTORY, ec.message()));
       else
-        logger.warning("Characters directory not found: " + CHARACTERS_DIRECTORY);
+        logger.warning(std::format("Characters directory not found: {}", CHARACTERS_DIRECTORY));
       return;
     }
 
-    for (auto& entry : std::filesystem::recursive_directory_iterator(CHARACTERS_DIRECTORY))
-      if (entry.is_regular_file() && entry.path().extension() == ".zip") characterPreviews.emplace_back(entry.path());
-    characters.resize(characterPreviews.size());
+    std::vector<std::filesystem::path> archives{};
+    for (auto& entry : std::filesystem::recursive_directory_iterator(CHARACTERS_DIRECTORY, ec))
+      if (!ec && entry.is_regular_file(ec) && entry.path().extension() == ".zip") archives.emplace_back(entry.path());
+
+    std::ranges::sort(archives);
+    for (auto& path : archives)
+    {
+      auto& preview = characterPreviews.emplace_back();
+      preview.load_archive(path, "character.xml");
+
+      auto& character = characters.emplace_back(path);
+      characterSaves.emplace_back(character.save_path_get());
+    }
+
+    logger.info(std::format("Refreshed character archives: {}", characters.size()));
   }
 
   void Resources::volume_set(float vol) { Audio::volume_set(vol); }
+  void Resources::audio_mute_set(bool isMuted) { Audio::mute_set(isMuted); }
 
-  resource::xml::Character& Resources::character_get(int index)
+  resource::xml::Character& Resources::character_get(int index) { return characters.at(index); }
+
+  resource::xml::Schema& Resources::character_preview_get(int index) { return characterPreviews.at(index); }
+
+  int Resources::character_index_get(const std::string& key) const
   {
-    if (!characters.at(index).has_value())
-    {
-      characters[index].emplace(characterPreviews.at(index).path);
-      characters[index]->save = characterPreviews.at(index).save;
-    }
-    return *characters[index];
+    for (int i = 0; i < (int)characters.size(); i++)
+      if (characters[i].path.stem().string() == key) return i;
+    return -1;
   }
 
-  resource::xml::CharacterPreview& Resources::character_preview_get(int index) { return characterPreviews.at(index); }
+  std::string Resources::character_key_get(int index) const { return characters.at(index).path.stem().string(); }
 
-  void Resources::character_save_set(int index, const resource::xml::Save& save)
+  void Resources::last_character_save(int index)
   {
-    characterPreviews.at(index).save = save;
-    if (characters.at(index).has_value()) characters[index]->save = save;
+    if (index < 0 || index >= (int)characters.size()) return;
+    if (auto* settingsRoot = settings.root()) settingsRoot->lastCharacter = character_key_get(index);
+  }
+
+  void Resources::last_character_clear()
+  {
+    if (auto* settingsRoot = settings.root()) settingsRoot->lastCharacter.clear();
+  }
+
+  void Resources::character_save_set(int index, const resource::xml::Schema& save)
+  {
+    characterSaves.at(index) = save;
+    characters.at(index).save = save;
+  }
+
+  void Resources::character_save_clear(int index)
+  {
+    characterSaves.at(index) = resource::xml::Schema();
+    characters.at(index).save = resource::xml::Schema();
   }
 
   Resources::~Resources() { settings.serialize(preferences::path() / "settings.xml"); }
diff --git a/src/resources.hpp b/src/resources.hpp
index 5d77975..5f72dd4 100644
--- a/src/resources.hpp
+++ b/src/resources.hpp
@@ -1,12 +1,9 @@
 #pragma once
 
-#include <optional>
-
+#include "resource/character.hpp"
 #include "resource/font.hpp"
+#include "resource/schema.hpp"
 #include "resource/shader.hpp"
-#include "resource/xml/character.hpp"
-#include "resource/xml/character_preview.hpp"
-#include "resource/xml/settings.hpp"
 
 namespace game
 {
@@ -15,18 +12,28 @@ namespace game
   public:
     resource::Shader shaders[resource::shader::COUNT];
     resource::Font font{"resources/font/font.ttf"};
-    resource::xml::Settings settings;
+    resource::xml::Schema settings;
 
-    std::vector<resource::xml::CharacterPreview> characterPreviews{};
-    std::vector<std::optional<resource::xml::Character>> characters{};
+    std::vector<resource::xml::Schema> characterPreviews{};
+    std::vector<resource::xml::Schema> characterSaves{};
+    std::vector<resource::xml::Character> characters{};
+
+    bool isDeveloper{};
 
     Resources();
     ~Resources();
 
+    void characters_refresh();
     resource::xml::Character& character_get(int index);
-    resource::xml::CharacterPreview& character_preview_get(int index);
-    void character_save_set(int index, const resource::xml::Save& save);
+    resource::xml::Schema& character_preview_get(int index);
+    int character_index_get(const std::string& key) const;
+    std::string character_key_get(int index) const;
+    void last_character_save(int index);
+    void last_character_clear();
+    void character_save_set(int index, const resource::xml::Schema& save);
+    void character_save_clear(int index);
 
     void volume_set(float volume);
+    void audio_mute_set(bool isMuted);
   };
 }
diff --git a/src/state.cpp b/src/state.cpp
index 9bcd7f5..7bb00f7 100644
--- a/src/state.cpp
+++ b/src/state.cpp
@@ -4,6 +4,7 @@
 #include <backends/imgui_impl_sdl3.h>
 #include <imgui.h>
 
+#include "util/display.hpp"
 #include "util/math.hpp"
 
 using namespace glm;
@@ -12,37 +13,31 @@ using namespace game::state;
 
 namespace game
 {
-  constexpr auto TICK_RATE = 30;
-  constexpr auto TICK_INTERVAL = (1000 / TICK_RATE);
   constexpr auto UPDATE_RATE = 60;
   constexpr auto UPDATE_INTERVAL = (1000 / UPDATE_RATE);
 
-  State::State(SDL_Window* _window, SDL_GLContext _context, resource::xml::Settings settings)
-      : window(_window), context(_context), canvas(settings.windowSize, Canvas::DEFAULT)
+  State::State(SDL_Window* _window, SDL_GLContext _context, resource::xml::Schema settings)
+      : window(_window), context(_context), canvas(settings.root()->windowSize, Canvas::DEFAULT)
   {
     resources.settings = settings;
-    SDL_SetWindowSize(window, resources.settings.windowSize.x, resources.settings.windowSize.y);
-  }
+    auto* settingsRoot = resources.settings.root();
+    SDL_SetWindowSize(window, settingsRoot->windowSize.x, settingsRoot->windowSize.y);
+    display::init(window);
 
-  void State::tick()
-  {
-    switch (type)
+    auto lastCharacterIndex = resources.character_index_get(settingsRoot->lastCharacter);
+    if (lastCharacterIndex >= 0)
     {
-      case SELECT:
-        select.tick();
-        break;
-      case PLAY:
-        play.tick(resources);
-        break;
-      default:
-        break;
+      select.characterIndex = lastCharacterIndex;
+      play.set(resources, lastCharacterIndex, state::Play::CONTINUE);
+      type = PLAY;
     }
   }
 
   void State::update()
   {
 #ifndef __EMSCRIPTEN__
-    SDL_GetWindowSize(window, &resources.settings.windowSize.x, &resources.settings.windowSize.y);
+    if (auto* settingsRoot = resources.settings.root(); settingsRoot && !display::fullscreen_get())
+      SDL_GetWindowSize(window, &settingsRoot->windowSize.x, &settingsRoot->windowSize.y);
 #endif
 
     SDL_Event event;
@@ -55,6 +50,28 @@ namespace game
         if (type == PLAY) play.exit(resources);
         isRunning = false;
       }
+      else if (event.type == SDL_EVENT_KEY_DOWN && !event.key.repeat)
+      {
+        auto isTextInput = ImGui::GetIO().WantTextInput;
+        auto isFullscreenShortcut = event.key.key == SDLK_F11 ||
+                                    (event.key.key == SDLK_RETURN && (event.key.mod & SDL_KMOD_ALT)) ||
+                                    (!isTextInput && event.key.scancode == SDL_SCANCODE_F);
+        auto isMuteShortcut = !isTextInput && event.key.scancode == SDL_SCANCODE_M;
+        if (isFullscreenShortcut) display::fullscreen_toggle();
+        if (isMuteShortcut)
+          if (auto* settingsRoot = resources.settings.root())
+          {
+            settingsRoot->isAudioMuted = !settingsRoot->isAudioMuted;
+            resources.audio_mute_set(settingsRoot->isAudioMuted);
+          }
+      }
+#if DEBUG
+      else if (event.type == SDL_EVENT_DROP_FILE)
+      {
+        resources.isDeveloper = true;
+        developerWindow.dropped_file_open(event.drop.data);
+      }
+#endif
       if (!isRunning) return;
     }
     ImGui_ImplOpenGL3_NewFrame();
@@ -66,10 +83,11 @@ namespace game
     {
       case SELECT:
         select.update(resources);
+        resources.last_character_clear();
         if (select.info.isNewGame || select.info.isContinue)
         {
           Play::Game game = select.info.isNewGame ? Play::NEW_GAME : Play::CONTINUE;
-          if (game == Play::NEW_GAME) resources.character_save_set(select.characterIndex, resource::xml::Save());
+          if (game == Play::NEW_GAME) resources.character_save_clear(select.characterIndex);
 
           play.set(resources, select.characterIndex, game);
           type = PLAY;
@@ -84,6 +102,7 @@ namespace game
         {
           play.exit(resources);
           type = SELECT;
+          resources.last_character_clear();
           play.menu.settingsMenu.isGoToSelect = false;
         }
         break;
@@ -91,7 +110,24 @@ namespace game
         break;
     }
 
-    auto isHideCursor = type == PLAY;
+#if DEBUG
+        developerWindow.update(resources, window, type == PLAY ? &play : nullptr);
+        if (developerWindow.action.isMenu && type == PLAY)
+        {
+          play.exit(resources);
+          type = SELECT;
+          resources.last_character_clear();
+        }
+        if (developerWindow.action.character >= 0)
+        {
+          if (type == PLAY) play.exit(resources);
+          select.characterIndex = developerWindow.action.character;
+          play.set(resources, select.characterIndex, state::Play::CONTINUE);
+          type = PLAY;
+        }
+#endif
+
+    auto isHideCursor = type == PLAY && !resources.isDeveloper && play.cursor_enabled_get();
     if (isHideCursor != isCursorHidden)
     {
       if (isHideCursor)
@@ -104,9 +140,10 @@ namespace game
 
   void State::render()
   {
+    auto* settingsRoot = resources.settings.root();
     auto& color =
-        resources.settings.isUseCharacterColor && type == PLAY ? play.character.data.color : resources.settings.color;
-    auto windowSize = resources.settings.windowSize;
+        settingsRoot->isUseCharacterColor && type == PLAY ? play.character.data.root()->color : settingsRoot->color;
+    auto windowSize = settingsRoot->windowSize;
 #ifndef __EMSCRIPTEN__
     SDL_GetWindowSize(window, &windowSize.x, &windowSize.y);
 #endif
@@ -127,13 +164,11 @@ namespace game
       default:
         break;
     }
-
     SDL_GL_SwapWindow(window);
   }
 
   void State::loop()
   {
-    auto currentTick = SDL_GetTicks();
     auto currentUpdate = SDL_GetTicks();
 
     if (currentUpdate - previousUpdate >= UPDATE_INTERVAL)
@@ -143,12 +178,6 @@ namespace game
       previousUpdate = currentUpdate;
     }
 
-    if (currentTick - previousTick >= TICK_INTERVAL)
-    {
-      tick();
-      previousTick = currentTick;
-    }
-
     SDL_Delay(1);
   }
 }
diff --git a/src/state.hpp b/src/state.hpp
index 4d639d7..5e14d7b 100644
--- a/src/state.hpp
+++ b/src/state.hpp
@@ -5,10 +5,14 @@
 #include "render/canvas.hpp"
 #include "resources.hpp"
 
+#if DEBUG
+#include "developer/window.hpp"
+#endif
+
 #include "state/play.hpp"
 #include "state/select.hpp"
 
-#include "entity/cursor.hpp"
+#include "entity.hpp"
 
 namespace game
 {
@@ -18,7 +22,6 @@ namespace game
     SDL_Window* window{};
     SDL_GLContext context{};
     Uint64 previousUpdate{};
-    Uint64 previousTick{};
 
     enum Type
     {
@@ -32,9 +35,10 @@ namespace game
 
     state::Play play;
     state::Select select;
+#if DEBUG
+    developer::Window developerWindow;
+#endif
 
-    void tick();
-    void tick_60();
     void update();
     void render();
 
@@ -43,7 +47,7 @@ namespace game
 
     Canvas canvas{};
 
-    State(SDL_Window*, SDL_GLContext, resource::xml::Settings);
+    State(SDL_Window*, SDL_GLContext, resource::xml::Schema);
     void loop();
   };
 };
diff --git a/src/state/play.cpp b/src/state/play.cpp
index 6ca7da2..e595ac7 100644
--- a/src/state/play.cpp
+++ b/src/state/play.cpp
@@ -21,12 +21,12 @@ namespace game::state
 {
   namespace
   {
-    int durability_animation_index_get(const resource::xml::Item& schema, const resource::xml::Anm2& anm2, int durability,
-                                       int durabilityMax)
+    int durability_animation_index_get(const resource::xml::Schema& schema, const resource::xml::Anm2& anm2,
+                                       int durability, int durabilityMax)
     {
       if (durability >= durabilityMax) return -1;
 
-      auto animationName = schema.animations.chew + std::to_string(std::max(0, durability));
+      auto animationName = schema.root()->animationChew + std::to_string(std::max(0, durability));
       return anm2.animationMap.contains(animationName) ? anm2.animationMap.at(animationName) : -1;
     }
   }
@@ -35,19 +35,29 @@ namespace game::state
   {
     if (!isWindows) return World::CENTER;
 
-    return menu.isOpen && tools.isOpen ? World::MENU_TOOLS
-           : menu.isOpen               ? World::MENU
-           : tools.isOpen              ? World::TOOLS
-                                       : World::CENTER;
+    auto isToolsOpen = tools.isOpen && !menu.is_fullscreen_visible_get();
+    return menu.isOpen && isToolsOpen ? World::MENU_TOOLS
+           : menu.isOpen              ? World::MENU
+           : isToolsOpen              ? World::TOOLS
+                                      : World::CENTER;
+  }
+
+  bool Play::cursor_enabled_get() const
+  {
+    auto* root = character.data.cursorSchema.root();
+    return root && root->type == Schema::Element::CURSOR;
   }
 
   void Play::start_sequence_begin()
   {
     auto& dialogue = character.data.dialogue;
-    if (!dialogue.start.is_valid()) return;
+    auto* start = dialogue.get(Schema::Element::START);
+    if (!start) return;
 
-    character.queue_play({.animation = dialogue.start.animation, .isInterruptible = false});
-    character.tick();
+    character.play({.animation = start->animation,
+                    .appendID = character.animation_append_id_get(),
+                    .interrupt = Entity::Interrupt::NEVER});
+    character.update();
     text.entry = nullptr;
     text.isEnabled = false;
     isWindows = false;
@@ -59,7 +69,7 @@ namespace game::state
   void Play::end_sequence_begin()
   {
     auto& dialogue = character.data.dialogue;
-    if (!dialogue.end.is_valid()) return;
+    if (!dialogue.get(Schema::Element::END)) return;
 
     text.entry = nullptr;
     text.isEnabled = false;
@@ -71,68 +81,92 @@ namespace game::state
   void Play::set(Resources& resources, int selectedCharacterIndex, enum Game game)
   {
     auto& data = resources.character_get(selectedCharacterIndex);
-    auto& saveData = data.save;
+    auto* saveRoot = data.save.root();
+    auto isSaveValid = saveRoot && saveRoot->type == Schema::Element::SAVE;
+    auto* saveCharacter = isSaveValid ? data.save.child_get(*saveRoot, Schema::Element::CHARACTER) : nullptr;
+    auto* saveInventory = isSaveValid ? data.save.child_get(*saveRoot, Schema::Element::INVENTORY) : nullptr;
+    auto* saveItems = isSaveValid ? data.save.child_get(*saveRoot, Schema::Element::ITEMS) : nullptr;
+    auto* savePan = isSaveValid ? data.save.child_get(*saveRoot, Schema::Element::PAN) : nullptr;
+    auto* saveZoom = isSaveValid ? data.save.child_get(*saveRoot, Schema::Element::ZOOM) : nullptr;
     auto& itemSchema = data.itemSchema;
     auto& dialogue = data.dialogue;
     auto& menuSchema = data.menuSchema;
+    auto* characterRoot = data.root();
     this->characterIndex = selectedCharacterIndex;
+    resources.last_character_save(selectedCharacterIndex);
     cheatCodeIndex = 0;
     cheatCodeStartTime = 0.0;
 
-    character =
-        entity::Character(data, vec2(World::BOUNDS.x + World::BOUNDS.z * 0.5f, World::BOUNDS.w - World::BOUNDS.y));
+    character = Entity(data, vec2(World::BOUNDS.x + World::BOUNDS.z * 0.5f, World::BOUNDS.w - World::BOUNDS.y));
     character.digestionRate =
-        glm::clamp(character.digestionRate, (float)data.digestionRateMin, (float)data.digestionRateMax);
-    character.eatSpeed = glm::clamp(character.eatSpeed, (float)data.eatSpeedMin, (float)data.eatSpeedMax);
-    character.capacity = glm::clamp(character.capacity, (float)data.capacityMin, (float)data.capacityMax);
+        glm::clamp(character.digestionRate, characterRoot->digestionRateMin, characterRoot->digestionRateMax);
+    character.eatSpeed =
+        glm::clamp(character.eatSpeed, characterRoot->eatSpeedMinMultiplier, characterRoot->eatSpeedMaxMultiplier);
+    character.capacity =
+        glm::clamp(character.capacity, characterRoot->capacityMinCalories, characterRoot->capacityMaxCalories);
 
+    auto* alternateSpritesheet = data.alternate_spritesheet();
     auto isAlternateSpritesheet =
-        (game == NEW_GAME && math::random_percent_roll(data.alternateSpritesheet.chanceOnNewGame));
+        alternateSpritesheet && game == NEW_GAME && math::random_percent_roll(alternateSpritesheet->chanceOnNewGame);
 
-    if (isAlternateSpritesheet || saveData.isAlternateSpritesheet)
+    if (isAlternateSpritesheet || (isSaveValid && saveRoot->isAlternateSpritesheet))
     {
-      character.spritesheet_set(entity::Character::ALTERNATE);
-      if (game == NEW_GAME) character.data.alternateSpritesheet.sound.play();
+      character.spritesheet_set(Entity::ALTERNATE);
+      if (game == NEW_GAME && alternateSpritesheet) alternateSpritesheet->soundEntry.sound.play();
     }
 
-    character.totalCaloriesConsumed = saveData.totalCaloriesConsumed;
-    character.totalFoodItemsEaten = saveData.totalFoodItemsEaten;
+    character.totalCaloriesConsumed = saveCharacter ? saveCharacter->totalCaloriesConsumed : 0;
+    character.totalFoodItemsEaten = saveCharacter ? saveCharacter->totalFoodItemsEaten : 0;
+    autofeed = play::Autofeed{};
     characterManager = CharacterManager{};
+    particleManager = ParticleManager{};
+    areaManager = AreaManager{};
 
-    cursor = entity::Cursor(character.data.cursorSchema.anm2);
-    cursor.interactTypeID = character.data.interactTypeNames.empty() ? -1 : 0;
+    cursor = Entity{};
+    cursor.entityType = CURSOR;
+    cursor.interactTypeID = character.data.interact_type_names_get().empty() ? -1 : 0;
+    autofeedCursor = Entity{};
+    autofeedCursor.entityType = AUTOCURSOR;
+    autofeedCursor.interactTypeID = cursor.interactTypeID;
+    autofeedCursor.position = cursor.position;
+    autofeedCursor.isVisible = false;
+    if (cursor_enabled_get())
+    {
+      cursor = Entity(character.data.cursorSchema.baseAnm2);
+      cursor.entityType = CURSOR;
+      cursor.interactTypeID = character.data.interact_type_names_get().empty() ? -1 : 0;
+      autofeedCursor = Entity(character.data.cursorSchema.baseAnm2);
+      autofeedCursor.entityType = AUTOCURSOR;
+      autofeedCursor.interactTypeID = cursor.interactTypeID;
+      autofeedCursor.position = cursor.position;
+      autofeedCursor.isVisible = false;
+    }
 
     menu.inventory = play::menu::Inventory{};
-    for (auto& [id, quantity] : saveData.inventory)
+    for (auto* item : saveInventory ? data.save.children_get(*saveInventory, Schema::Element::ITEM)
+                                    : std::vector<Schema::Element*>{})
     {
-      if (quantity == 0) continue;
-      menu.inventory.values[id] = quantity;
+      if (item->quantity == 0) continue;
+      menu.inventory.values[item->id] = item->quantity;
     }
 
     itemManager = ItemManager{};
-    for (auto& item : saveData.items)
+    for (auto* item :
+         saveItems ? data.save.children_get(*saveItems, Schema::Element::ITEM) : std::vector<Schema::Element*>{})
     {
-      auto& anm2 = itemSchema.anm2s.at(item.id);
-      auto& schemaItem = itemSchema.items.at(item.id);
-      auto durabilityMax = schemaItem.durability.value_or(itemSchema.durability);
-      auto animationIndex = durability_animation_index_get(itemSchema, anm2, item.durability, durabilityMax);
-      auto& saveItem = itemSchema.anm2s.at(item.id);
-      itemManager.items.emplace_back(saveItem, item.position, item.id, item.durability, animationIndex, item.velocity,
-                                     item.rotation);
+      auto& anm2 = itemSchema.anm2s.at(item->id);
+      auto& schemaItem = itemSchema.items.at(item->id);
+      auto durabilityMax = schemaItem.isDurability ? schemaItem.durability : itemSchema.durability;
+      auto animationIndex = durability_animation_index_get(itemSchema, anm2, item->durability, durabilityMax);
+      auto& saveItem = itemSchema.anm2s.at(item->id);
+      itemManager.items.emplace_back(saveItem, item->position, item->id, item->durability, animationIndex,
+                                     item->velocity, item->rotation);
     }
 
     imgui::style::widget_set(menuSchema.rounding);
-    imgui::widget::sounds_set(&menuSchema.sounds.hover, &menuSchema.sounds.select);
+    imgui::widget::sounds_set(&menuSchema.root()->soundHover, &menuSchema.root()->soundSelect);
     play::style::color_set(resources, character);
 
-    menu.arcade = play::menu::Arcade(character);
-    menu.arcade.skillCheck.totalPlays = saveData.skillCheck.totalPlays;
-    menu.arcade.skillCheck.highScore = saveData.skillCheck.highScore;
-    menu.arcade.skillCheck.bestCombo = saveData.skillCheck.bestCombo;
-    menu.arcade.skillCheck.gradeCounts = saveData.skillCheck.gradeCounts;
-    menu.arcade.skillCheck.isHighScoreAchieved = saveData.skillCheck.highScore > 0 ? true : false;
-    menu.arcade.orbit.highScore = saveData.orbit.highScore;
-
     text.entry = nullptr;
     text.isEnabled = false;
 
@@ -142,7 +176,7 @@ namespace game::state
     menu.isCheats = false;
 #endif
 
-    isPostgame = saveData.isPostgame;
+    isPostgame = isSaveValid && saveRoot->isPostgame;
     if (character.stage_get() >= character.stage_max_get()) isPostgame = true;
     if (isPostgame) menu.isCheats = true;
 
@@ -150,12 +184,16 @@ namespace game::state
 
     if (auto font = character.data.menuSchema.font.get()) ImGui::GetIO().FontDefault = font;
 
-    character.queue_idle_animation();
-    character.tick();
+    character.play({.animation = character.idle_animation_get(), .appendID = character.animation_append_id_get()});
+    character.update();
+    areaManager.set(character);
     worldCanvas.size_set(imgui::to_vec2(ImGui::GetMainViewport()->Size));
     world.set(character, worldCanvas, focus_get());
+    if (savePan) worldCanvas.pan = savePan->position;
+    if (saveZoom && saveZoom->zoom >= World::ZOOM_MIN)
+      worldCanvas.zoom = glm::clamp(World::ZOOM_MIN, saveZoom->zoom, World::ZOOM_MAX);
 
-    if (game == NEW_GAME && dialogue.start.is_valid()) start_sequence_begin();
+    if (game == NEW_GAME && dialogue.get(Schema::Element::START)) start_sequence_begin();
 
     if (isPostgame)
     {
@@ -173,25 +211,13 @@ namespace game::state
 
   void Play::exit(Resources& resources)
   {
-    imgui::style::color_set(resources.settings.color);
+    imgui::style::color_set(resources.settings.root()->color);
     imgui::style::widget_set();
     imgui::widget::sounds_set(nullptr, nullptr);
     ImGui::GetIO().FontDefault = resources.font.get();
     save(resources);
   }
 
-  void Play::tick(Resources&)
-  {
-    character.tick();
-    cursor.tick();
-    menu.tick();
-    toasts.tick();
-    text.tick(character);
-
-    for (auto& item : itemManager.items)
-      item.tick();
-  }
-
   void Play::update(Resources& resources)
   {
     static constexpr std::array<ImGuiKey, 10> CHEAT_CODE = {
@@ -200,10 +226,16 @@ namespace game::state
     static constexpr std::array<ImGuiKey, 6> CHEAT_INPUT_KEYS = {
         ImGuiKey_UpArrow, ImGuiKey_DownArrow, ImGuiKey_LeftArrow, ImGuiKey_RightArrow, ImGuiKey_B, ImGuiKey_A};
     static constexpr auto CHEAT_CODE_INPUT_TIME_SECONDS = 5.0;
+    static constexpr auto UI_ALPHA_MAX = 1.0f;
 
     auto focus = focus_get();
     auto& dialogue = character.data.dialogue;
-    cursor.isVisible = true;
+    auto isCursorEnabled = cursor_enabled_get();
+    if (isCursorEnabled)
+    {
+      cursor.isVisible = true;
+      autofeedCursor.isVisible = false;
+    }
 
     if (!menu.isCheats)
     {
@@ -233,7 +265,7 @@ namespace game::state
           cheatCodeIndex = 0;
           cheatCodeStartTime = 0.0;
           toasts.push(character.data.strings.get(Strings::ToastCheatsUnlocked));
-          character.data.menuSchema.sounds.cheatsActivated.play();
+          character.data.menuSchema.root()->soundCheatsActivated.play();
         }
       }
 
@@ -246,32 +278,19 @@ namespace game::state
 
     if (isWindows)
     {
-      menu.update(resources, itemManager, character, cursor, text, worldCanvas);
-      tools.update(character, cursor, world, focus, worldCanvas);
-      info.update(resources, character);
+      auto isToolsDisabled = menu.is_fullscreen_visible_get();
+      auto uiAlpha = UI_ALPHA_MAX - menu.fullscreen_alpha_get();
+      tools.update(character, cursor, world, focus, worldCanvas, isToolsDisabled, uiAlpha);
+      info.update(resources, character, uiAlpha);
+      menu.update(resources, itemManager, character, text, autofeed);
       toasts.update();
-
-#if DEBUG
-      if (menu.isDebugOpen && ImGui::IsKeyPressed(ImGuiKey_F8, false)) end_sequence_begin();
-#endif
-
-      if (menu.debug.isStartSequenceRequested)
-      {
-        menu.debug.isStartSequenceRequested = false;
-        start_sequence_begin();
-      }
-      if (menu.debug.isEndSequenceRequested)
-      {
-        menu.debug.isEndSequenceRequested = false;
-        end_sequence_begin();
-      }
     }
 
     auto isEndSequenceActive = isEndBegin && !isEndEnd;
     itemManager.isDisabled = isEndSequenceActive;
     characterManager.isDisabled = isEndSequenceActive;
 
-    if (text.isEnabled) text.update(character);
+    if (text.isEnabled) text.update(character, worldCanvas);
 
     if (isStart)
     {
@@ -279,16 +298,17 @@ namespace game::state
       {
         if (auto animation = character.animation_get())
         {
-          if (animation->isLoop || character.state == entity::Actor::STOPPED)
+          if (animation->isLoop || character.state == Entity::STOPPED)
           {
-            text.set(dialogue.get(dialogue.start.id), character);
+            auto* start = dialogue.get(Schema::Element::START);
+            text.set(start ? dialogue.dialogue_entry_get(*start) : nullptr, character);
             isStartBegin = true;
           }
         }
       }
       else if (!isStartEnd)
       {
-        if (text.entry->is_last())
+        if (text.entry && text.is_terminal() && text.is_finished())
         {
           isWindows = true;
           isStartEnd = true;
@@ -306,7 +326,8 @@ namespace game::state
       {
         if (character.is_animation_finished())
         {
-          text.set(dialogue.get(dialogue.end.id), character);
+          auto* end = dialogue.get(Schema::Element::END);
+          text.set(end ? dialogue.dialogue_entry_get(*end) : nullptr, character);
           isEndBegin = true;
           isWindows = false;
           tools.isOpen = false;
@@ -319,7 +340,7 @@ namespace game::state
       }
       else if (!isEndEnd)
       {
-        if (text.entry->is_last())
+        if (text.entry && text.is_terminal() && text.is_finished())
         {
           menu.isOpen = true;
           isWindows = true;
@@ -332,13 +353,29 @@ namespace game::state
       }
     }
 
-    itemManager.update(character, cursor, areaManager, text, World::BOUNDS, worldCanvas);
-    characterManager.update(character, cursor, text, worldCanvas);
+    autofeed.update(resources, character, autofeedCursor, menu.inventory, itemManager, characterManager, worldCanvas);
+    auto& interactionCursor = autofeed.active_get() ? autofeedCursor : cursor;
+    itemManager.isAutomation = autofeed.active_get();
+    itemManager.update(character, interactionCursor, areaManager, text, World::BOUNDS, worldCanvas);
+    characterManager.update(character, interactionCursor, text, worldCanvas);
+    for (auto& particle : itemManager.particles)
+      particleManager.spawn(character.data, particle.label, particle.position);
+    for (auto& particle : characterManager.particles)
+      particleManager.spawn(character.data, particle.label, particle.position);
+
+    if (isCursorEnabled && !autofeed.active_get() && ImGui::IsMouseClicked(ImGuiMouseButton_Left) &&
+        !itemManager.isItemHovered && !characterManager.isHovering && cursor.cursorState == Entity::DEFAULT)
+      if (auto* cursorRoot = character.data.cursorSchema.root())
+        if (auto animation = cursorRoot->animationClick.get())
+          cursor.play({.animation = *animation, .mode = Entity::PLAY_FORCE, .interrupt = Entity::Interrupt::ALWAYS});
 
     character.update();
+    areaManager.update(character);
+    particleManager.update();
     cursor.update();
+    if (autofeed.active_get()) autofeedCursor.update();
     world.update(character, cursor, worldCanvas, focus);
-    worldCanvas.tick();
+    worldCanvas.update();
 
     if (autosaveTime += ImGui::GetIO().DeltaTime; autosaveTime > AUTOSAVE_TIME || menu.settingsMenu.isSave)
     {
@@ -354,70 +391,82 @@ namespace game::state
     auto& rectShader = resources.shaders[shader::RECT];
     auto size = imgui::to_ivec2(ImGui::GetMainViewport()->Size);
 
-    auto& bgTexture = character.data.areaSchema.areas.at(areaManager.get(character)).texture;
-
     auto windowModel = math::quad_model_get(vec2(size));
-    auto worldModel = math::quad_model_get(bgTexture.size);
+
     worldCanvas.bind();
     worldCanvas.size_set(size);
     worldCanvas.clear();
-    worldCanvas.texture_render(textureShader, bgTexture.id, worldModel);
+
+    areaManager.render(character, textureShader, rectShader, worldCanvas);
 
     character.render(textureShader, rectShader, worldCanvas);
 
     for (auto& item : itemManager.items)
       item.render(textureShader, rectShader, worldCanvas);
 
-    if (menu.debug.isBoundsDisplay)
-    {
-      auto boundsModel =
-          math::quad_model_get(glm::vec2(World::BOUNDS.z, World::BOUNDS.w), glm::vec2(World::BOUNDS.x, World::BOUNDS.y),
-                               glm::vec2(World::BOUNDS.x, World::BOUNDS.y) * 0.5f);
-      worldCanvas.rect_render(rectShader, boundsModel);
-    }
+    auto isCursorEnabled = cursor_enabled_get();
+    if (isCursorEnabled && autofeed.active_get()) autofeedCursor.render(textureShader, rectShader, worldCanvas);
+    particleManager.render(textureShader, rectShader, worldCanvas);
+
     worldCanvas.unbind();
 
+    auto isCursor = isCursorEnabled && !resources.isDeveloper;
+
     canvas.bind();
     canvas.texture_render(textureShader, worldCanvas, windowModel);
     ImGui::Render();
     ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
-    cursor.render(textureShader, rectShader, canvas);
+    if (isCursor) cursor.render(textureShader, rectShader, canvas);
     canvas.unbind();
   }
 
   void Play::save(Resources& resources)
   {
-    resource::xml::Save save;
+    resource::xml::Schema save;
+    auto& root = save.element_add(resource::xml::Schema::Element::SAVE);
+    root.isPostgame = isPostgame;
+    root.isAlternateSpritesheet = character.spritesheetType == Entity::ALTERNATE;
 
-    save.weight = character.weight;
-    save.calories = character.calories;
-    save.capacity = character.capacity;
-    save.digestionRate = character.digestionRate;
-    save.eatSpeed = character.eatSpeed;
-    save.digestionProgress = character.digestionProgress;
-    save.isDigesting = character.isDigesting;
-    save.digestionTimer = character.digestionTimer;
-    save.totalCaloriesConsumed = character.totalCaloriesConsumed;
-    save.totalFoodItemsEaten = character.totalFoodItemsEaten;
-    save.skillCheck.totalPlays = menu.arcade.skillCheck.totalPlays;
-    save.skillCheck.highScore = menu.arcade.skillCheck.highScore;
-    save.skillCheck.bestCombo = menu.arcade.skillCheck.bestCombo;
-    save.skillCheck.gradeCounts = menu.arcade.skillCheck.gradeCounts;
-    save.orbit.highScore = menu.arcade.orbit.highScore;
-    save.isPostgame = isPostgame;
-    save.isAlternateSpritesheet = character.spritesheetType == entity::Character::ALTERNATE;
+    auto& panElement = save.element_add(resource::xml::Schema::Element::PAN, 0);
+    panElement.position = worldCanvas.pan;
+
+    auto& zoomElement = save.element_add(resource::xml::Schema::Element::ZOOM, 0);
+    zoomElement.zoom = worldCanvas.zoom;
+
+    auto& characterElement = save.element_add(resource::xml::Schema::Element::CHARACTER, 0);
+    characterElement.weightKilograms = character.weight;
+    characterElement.calories = character.calories;
+    characterElement.capacityCalories = character.capacity;
+    characterElement.digestionRate = character.digestionRate;
+    characterElement.eatSpeedMultiplier = character.eatSpeed;
+    characterElement.digestionProgress = character.digestionProgress;
+    characterElement.isDigesting = character.isDigesting;
+    characterElement.digestionTimer = character.digestionTimer;
+    characterElement.totalCaloriesConsumed = character.totalCaloriesConsumed;
+    characterElement.totalFoodItemsEaten = character.totalFoodItemsEaten;
+
+    auto inventoryIndex = (int)save.elements.size();
+    save.element_add(resource::xml::Schema::Element::INVENTORY, 0);
 
     for (auto& [id, quantity] : menu.inventory.values)
     {
       if (quantity == 0) continue;
-      save.inventory[id] = quantity;
+      auto& item = save.element_add(resource::xml::Schema::Element::ITEM, inventoryIndex);
+      item.id = id;
+      item.quantity = quantity;
     }
 
+    auto itemsIndex = (int)save.elements.size();
+    save.element_add(resource::xml::Schema::Element::ITEMS, 0);
     for (auto& item : itemManager.items)
-      save.items.emplace_back(item.schemaID, item.durability, item.position, item.velocity,
-                              *item.overrides[item.rotationOverrideID].frame.rotation);
-
-    save.isValid = true;
+    {
+      auto& itemElement = save.element_add(resource::xml::Schema::Element::ITEM, itemsIndex);
+      itemElement.id = item.schemaID;
+      itemElement.durability = item.durability;
+      itemElement.position = item.position;
+      itemElement.velocity = item.velocity;
+      itemElement.rotation = *item.overrides[item.rotationOverrideID].frame.rotation;
+    }
 
     resources.character_save_set(characterIndex, save);
     save.serialize(character.data.save_path_get());
diff --git a/src/state/play.hpp b/src/state/play.hpp
index d18de5a..5f6af1b 100644
--- a/src/state/play.hpp
+++ b/src/state/play.hpp
@@ -3,10 +3,12 @@
 #include "../resources.hpp"
 
 #include "play/area_manager.hpp"
+#include "play/autofeed.hpp"
 #include "play/character_manager.hpp"
 #include "play/info.hpp"
 #include "play/item_manager.hpp"
 #include "play/menu.hpp"
+#include "play/particle_manager.hpp"
 #include "play/text.hpp"
 #include "play/toasts.hpp"
 #include "play/tools.hpp"
@@ -25,8 +27,9 @@ namespace game::state
       CONTINUE
     };
 
-    entity::Character character;
-    entity::Cursor cursor;
+    Entity character;
+    Entity cursor;
+    Entity autofeedCursor;
 
     play::Info info;
     play::Menu menu;
@@ -34,7 +37,9 @@ namespace game::state
     play::Text text;
     play::World world;
     play::Toasts toasts;
+    play::Autofeed autofeed{};
     play::ItemManager itemManager{};
+    play::ParticleManager particleManager{};
     play::CharacterManager characterManager{};
     play::AreaManager areaManager{};
 
@@ -60,10 +65,10 @@ namespace game::state
     Canvas worldCanvas{play::World::SIZE};
 
     Play() = default;
+    bool cursor_enabled_get() const;
     void set(Resources&, int characterIndex, Game = CONTINUE);
     void exit(Resources& resources);
     void update(Resources&);
-    void tick(Resources&);
     void render(Resources&, Canvas&);
     void save(Resources&);
     play::World::Focus focus_get();
diff --git a/src/state/play/area_manager.cpp b/src/state/play/area_manager.cpp
index 572b2da..48d4b95 100644
--- a/src/state/play/area_manager.cpp
+++ b/src/state/play/area_manager.cpp
@@ -1,26 +1,73 @@
 #include "area_manager.hpp"
 
-#include <imgui.h>
+#include "../../util/math.hpp"
 
 using namespace game::resource;
 using namespace game::util;
 
 namespace game::state::play
 {
-  int AreaManager::get(entity::Character& character)
+  int AreaManager::index_get(Entity& character)
   {
     auto& data = character.data;
     auto& schema = data.areaSchema;
     if (schema.areas.empty()) return -1;
 
-    auto size = (int)data.stages.size();
+    auto stages = data.stages_get();
+    auto size = (int)stages.size();
 
     for (int i = 0; i < size; i++)
     {
-      auto& stage = data.stages[size - i - 1];
-      if (stage.areaID != -1) return stage.areaID;
+      auto* stage = stages[size - i - 1];
+      if (stage->areaID >= 0 && stage->areaID < (int)schema.areas.size()) return stage->areaID;
     }
 
-    return -1;
+    return 0;
+  }
+
+  game::resource::xml::Schema::AreaEntry* AreaManager::get(Entity& character)
+  {
+    auto index = index_get(character);
+    if (index == -1) return nullptr;
+    return &character.data.areaSchema.areas[index];
+  }
+
+  void AreaManager::set(Entity& character)
+  {
+    entities.clear();
+    auto& areas = character.data.areaSchema.areas;
+    entities.reserve(areas.size());
+
+    for (auto& area : areas)
+      entities.emplace_back(area.anm2.is_valid() ? Entity(area.anm2) : Entity{});
+  }
+
+  void AreaManager::update(Entity& character)
+  {
+    if (entities.size() != character.data.areaSchema.areas.size()) set(character);
+
+    auto index = index_get(character);
+    if (index == -1 || index >= (int)entities.size()) return;
+    entities[index].update();
+  }
+
+  void AreaManager::render(Entity& character, Shader& textureShader, Shader& rectShader, Canvas& canvas)
+  {
+    if (entities.size() != character.data.areaSchema.areas.size()) set(character);
+
+    auto index = index_get(character);
+    if (index == -1) return;
+
+    auto& area = character.data.areaSchema.areas[index];
+    if (index < (int)entities.size() && area.anm2.is_valid())
+    {
+      entities[index].render(textureShader, rectShader, canvas);
+      return;
+    }
+
+    if (!area.texture.is_valid()) return;
+
+    auto worldModel = math::quad_model_get(area.texture.size);
+    canvas.texture_render(textureShader, area.texture.id, worldModel);
   }
 }
diff --git a/src/state/play/area_manager.hpp b/src/state/play/area_manager.hpp
index 4f12b4a..71135bb 100644
--- a/src/state/play/area_manager.hpp
+++ b/src/state/play/area_manager.hpp
@@ -1,12 +1,21 @@
 #pragma once
 
-#include "../../entity/character.hpp"
+#include <vector>
+
+#include "../../entity.hpp"
+#include "../../resource/shader.hpp"
 
 namespace game::state::play
 {
   class AreaManager
   {
   public:
-    int get(entity::Character&);
+    std::vector<Entity> entities{};
+
+    int index_get(Entity&);
+    game::resource::xml::Schema::AreaEntry* get(Entity&);
+    void set(Entity&);
+    void update(Entity&);
+    void render(Entity&, game::resource::Shader&, game::resource::Shader&, Canvas&);
   };
 }
diff --git a/src/state/play/autofeed.cpp b/src/state/play/autofeed.cpp
new file mode 100644
index 0000000..31d5ad7
--- /dev/null
+++ b/src/state/play/autofeed.cpp
@@ -0,0 +1,448 @@
+#include "autofeed.hpp"
+
+#include "../../util/imgui.hpp"
+#include "../../util/math.hpp"
+
+#include <cmath>
+#include <imgui.h>
+
+using namespace game::resource::xml;
+using namespace game::util;
+
+namespace game::state::play
+{
+  namespace
+  {
+    constexpr float CURSOR_SPEED = 9.0f;
+    constexpr float DIGEST_CURSOR_SPEED = 3.0f;
+    constexpr float CURSOR_SPEED_REFERENCE_AREA = 512.0f * 512.0f;
+    constexpr float CURSOR_SPEED_SCALE_MIN = 0.5f;
+    constexpr float CURSOR_SPEED_SCALE_MAX = 2.0f;
+    constexpr float CALORIE_EPSILON = 0.001f;
+
+    glm::vec2 rect_center(glm::vec4 rect) { return {rect.x + rect.z * 0.5f, rect.y + rect.w * 0.5f}; }
+
+    bool is_finite(glm::vec2 value) { return std::isfinite(value.x) && std::isfinite(value.y); }
+
+    bool is_finite(glm::vec4 value)
+    {
+      return std::isfinite(value.x) && std::isfinite(value.y) && std::isfinite(value.z) && std::isfinite(value.w) &&
+             value.z > 0.0f && value.w > 0.0f;
+    }
+
+    bool move_toward(Entity& cursor, glm::vec2 target, float speed)
+    {
+      if (!is_finite(cursor.position)) cursor.position = {};
+      if (!is_finite(target)) return false;
+
+      auto delta = target - cursor.position;
+      auto distance = glm::length(delta);
+      if (!std::isfinite(distance)) return false;
+      if (distance <= speed || distance <= 0.001f)
+      {
+        cursor.position = target;
+        return true;
+      }
+
+      cursor.position += delta / distance * speed;
+      return false;
+    }
+
+    float cursor_speed_scale_get(Entity& character)
+    {
+      auto rect = character.rect();
+      if (!is_finite(rect)) return 1.0f;
+
+      auto area = rect.z * rect.w;
+      if (!std::isfinite(area) || area <= 0.0f) return 1.0f;
+
+      return glm::clamp(std::sqrt(area / CURSOR_SPEED_REFERENCE_AREA), CURSOR_SPEED_SCALE_MIN, CURSOR_SPEED_SCALE_MAX);
+    }
+
+    bool is_food(const Schema& schema, const Schema::ItemEntry& item)
+    {
+      return item.categoryID >= 0 && item.categoryID < (int)schema.categories.size() &&
+             schema.categories[item.categoryID].isEdible;
+    }
+
+    bool is_negative_effect(const Schema::ItemEntry& item)
+    {
+      return (item.isCapacityBonus && item.capacityBonus < 0.0f) ||
+             (item.isEatSpeedBonus && item.eatSpeedBonus < 0.0f) ||
+             (item.isDigestionBonus && item.digestionBonus < 0.0f);
+    }
+
+    bool is_autofeed_food(const Schema& schema, const Schema::ItemEntry& item)
+    {
+      return is_food(schema, item) && !is_negative_effect(item);
+    }
+
+    int durability_max_get(const Schema& schema, const Schema::ItemEntry& item)
+    {
+      return item.isDurability ? item.durability : schema.durability;
+    }
+
+    float calories_per_bite_get(const Schema& schema, const Schema::ItemEntry& item)
+    {
+      auto durabilityMax = durability_max_get(schema, item);
+      return item.isCalories && durabilityMax > 0 ? item.calories / (float)durabilityMax : 0.0f;
+    }
+
+    bool can_eat(const Entity& character, const Schema& schema, const Schema::ItemEntry& item)
+    {
+      auto caloriesPerBite = calories_per_bite_get(schema, item);
+      return caloriesPerBite > 0.0f && character.calories + caloriesPerBite <= character.max_capacity();
+    }
+
+    struct FoodScore
+    {
+      float calories{};
+      int bites{};
+      float caloriesPerBite{};
+      bool isValid{};
+    };
+
+    FoodScore food_score_get(const Entity& character, const Schema& schema, const Schema::ItemEntry& item,
+                             int durability)
+    {
+      if (!is_autofeed_food(schema, item)) return {};
+
+      auto caloriesPerBite = calories_per_bite_get(schema, item);
+      auto remainingCapacity = character.max_capacity() - character.calories;
+      auto durabilityMax = durability_max_get(schema, item);
+      auto remainingBites = glm::max(0, durabilityMax - durability);
+      if (caloriesPerBite <= 0.0f || remainingCapacity < caloriesPerBite || remainingBites <= 0) return {};
+
+      auto bites = glm::clamp((int)std::floor(remainingCapacity / caloriesPerBite), 0, remainingBites);
+      auto calories = (float)bites * caloriesPerBite;
+      return {.calories = calories, .bites = bites, .caloriesPerBite = caloriesPerBite, .isValid = bites > 0};
+    }
+
+    bool is_better_food_score(const FoodScore& score, const FoodScore& best)
+    {
+      if (!score.isValid) return false;
+      if (!best.isValid) return true;
+      if (score.calories != best.calories) return score.calories > best.calories;
+      if (score.bites != best.bites) return score.bites < best.bites;
+      return score.caloriesPerBite > best.caloriesPerBite;
+    }
+
+    bool can_eat_anything(Entity& character, ItemManager& itemManager, menu::Inventory& inventory)
+    {
+      auto& schema = character.data.itemSchema;
+      for (auto& entity : itemManager.items)
+      {
+        if (entity.schemaID < 0 || entity.schemaID >= (int)schema.items.size()) continue;
+        auto& item = schema.items[entity.schemaID];
+        if (is_autofeed_food(schema, item) && can_eat(character, schema, item)) return true;
+      }
+
+      for (auto& [id, quantity] : inventory.values)
+      {
+        if (quantity <= 0 || id < 0 || id >= (int)schema.items.size()) continue;
+        auto& item = schema.items[id];
+        if (is_autofeed_food(schema, item) && can_eat(character, schema, item)) return true;
+      }
+
+      return false;
+    }
+
+    int best_inventory_food_get(Entity& character, menu::Inventory& inventory)
+    {
+      auto& schema = character.data.itemSchema;
+      auto bestID = -1;
+      auto bestScore = FoodScore{};
+
+      for (auto& [id, quantity] : inventory.values)
+      {
+        if (quantity <= 0 || id < 0 || id >= (int)schema.items.size()) continue;
+        auto& item = schema.items[id];
+        auto score = food_score_get(character, schema, item, 0);
+
+        if (is_better_food_score(score, bestScore))
+        {
+          bestScore = score;
+          bestID = id;
+        }
+      }
+
+      return bestID;
+    }
+
+    bool is_inventory_food(Entity& character, menu::Inventory& inventory)
+    {
+      auto& schema = character.data.itemSchema;
+      for (auto& [id, quantity] : inventory.values)
+      {
+        if (quantity <= 0 || id < 0 || id >= (int)schema.items.size()) continue;
+        if (is_autofeed_food(schema, schema.items[id])) return true;
+      }
+
+      return false;
+    }
+
+    bool is_world_food(Entity& character, ItemManager& itemManager)
+    {
+      auto& schema = character.data.itemSchema;
+      for (auto& entity : itemManager.items)
+      {
+        if (entity.schemaID < 0 || entity.schemaID >= (int)schema.items.size()) continue;
+        if (is_autofeed_food(schema, schema.items[entity.schemaID])) return true;
+      }
+
+      return false;
+    }
+
+    bool is_food(Entity& character, menu::Inventory& inventory, ItemManager& itemManager)
+    {
+      return character.calories > CALORIE_EPSILON || is_inventory_food(character, inventory) ||
+             is_world_food(character, itemManager);
+    }
+
+    int best_world_food_get(Entity& character, ItemManager& itemManager, bool requireCanEat)
+    {
+      auto& schema = character.data.itemSchema;
+      auto bestIndex = -1;
+      auto bestScore = FoodScore{};
+
+      for (int i = 0; i < (int)itemManager.items.size(); i++)
+      {
+        auto& entity = itemManager.items[i];
+        if (entity.schemaID < 0 || entity.schemaID >= (int)schema.items.size()) continue;
+
+        auto& item = schema.items[entity.schemaID];
+        if (!is_autofeed_food(schema, item)) continue;
+        if (requireCanEat && !can_eat(character, schema, item)) continue;
+
+        auto score = food_score_get(character, schema, item, entity.durability);
+        if (is_better_food_score(score, bestScore))
+        {
+          bestScore = score;
+          bestIndex = i;
+        }
+      }
+
+      return bestIndex;
+    }
+
+    bool eat_rect_get(Entity& character, glm::vec4& rect)
+    {
+      for (auto* eatArea : character.data.eat_areas_get())
+      {
+        if (!eatArea) continue;
+        auto nullID = character.data.null_id_get(eatArea->null);
+        if (nullID == -1) continue;
+
+        rect = character.null_frame_rect(nullID);
+        if (is_finite(rect)) return true;
+
+        auto animationIndex = character.animation_index_get(eatArea->animation + character.animation_append_id_get());
+        rect = character.null_frame_rect(nullID, animationIndex, 0.0f);
+        if (is_finite(rect)) return true;
+      }
+
+      return false;
+    }
+
+    const Schema::Element* digestion_area_get(Entity& character)
+    {
+      for (auto* interactArea : character.data.interact_areas_get())
+      {
+        if (!interactArea) continue;
+        if (interactArea->digestionBonusOnClick <= 0.0f && interactArea->digestionBonusOnHover <= 0.0f) continue;
+        if (character.data.null_id_get(interactArea->null) == -1) continue;
+        return interactArea;
+      }
+
+      return nullptr;
+    }
+
+    void state_reset(Entity& cursor, bool& isItemMouseHeld, bool& isDigestMouseHeld, int& digestClickCooldown)
+    {
+      isItemMouseHeld = false;
+      isDigestMouseHeld = false;
+      digestClickCooldown = 0;
+      if (!is_finite(cursor.position)) cursor.position = {};
+    }
+  }
+
+  void Autofeed::update(Resources& resources, Entity& character, Entity& cursor, menu::Inventory& inventory,
+                        ItemManager& itemManager, CharacterManager& characterManager, Canvas& canvas)
+  {
+    isActive = false;
+    cursor.isVisible = false;
+
+    if (!isEnabled)
+    {
+      state_reset(cursor, isItemMouseHeld, isDigestMouseHeld, digestClickCooldown);
+      return;
+    }
+
+    if (!is_food(character, inventory, itemManager))
+    {
+      state_reset(cursor, isItemMouseHeld, isDigestMouseHeld, digestClickCooldown);
+      return;
+    }
+
+    if (character.isStageUp || character.isJustStageUp || character.isJustStageFinal)
+    {
+      state_reset(cursor, isItemMouseHeld, isDigestMouseHeld, digestClickCooldown);
+      return;
+    }
+
+    if (cursor.position == glm::vec2{} && is_finite(character.position)) cursor.position = character.position;
+
+    auto& schema = character.data.itemSchema;
+    if (inventory.upgrade_all_possible(schema))
+    {
+      state_reset(cursor, isItemMouseHeld, isDigestMouseHeld, digestClickCooldown);
+      return;
+    }
+
+    auto itemInput = ItemManager::Input{};
+    itemInput.isAutomation = true;
+    auto characterInput = CharacterManager::Input{};
+    auto speedScale = cursor_speed_scale_get(character);
+    auto cursorSpeed = CURSOR_SPEED * speedScale;
+    auto digestCursorSpeed = DIGEST_CURSOR_SPEED * speedScale;
+    auto eatRect = glm::vec4{};
+    auto isEatTarget = eat_rect_get(character, eatRect);
+
+    if (itemManager.heldItemIndex != -1 && itemManager.heldItemIndex < (int)itemManager.items.size())
+    {
+      auto& heldItem = itemManager.items[itemManager.heldItemIndex];
+      if (heldItem.schemaID < 0 || heldItem.schemaID >= (int)schema.items.size())
+      {
+        isActive = false;
+        cursor.isVisible = false;
+        state_reset(cursor, isItemMouseHeld, isDigestMouseHeld, digestClickCooldown);
+        return;
+      }
+      auto& schemaItem = schema.items[heldItem.schemaID];
+
+      if (isEatTarget && can_eat(character, schema, schemaItem))
+      {
+        isActive = true;
+        cursor.isVisible = true;
+        move_toward(cursor, rect_center(eatRect), cursorSpeed);
+
+        itemInput.isMouseLeftDown = true;
+        itemManager.inputOverride = itemInput;
+        isItemMouseHeld = true;
+        isDigestMouseHeld = false;
+        return;
+      }
+
+      itemInput.isMouseLeftReleased = true;
+      itemManager.inputOverride = itemInput;
+      isActive = true;
+      cursor.isVisible = true;
+      isItemMouseHeld = false;
+      return;
+    }
+
+    auto bestWorldFood = isEatTarget ? best_world_food_get(character, itemManager, true) : -1;
+
+    if (bestWorldFood != -1)
+    {
+      auto& item = itemManager.items[bestWorldFood];
+      auto rect = item.rect();
+      if (!is_finite(rect))
+      {
+        state_reset(cursor, isItemMouseHeld, isDigestMouseHeld, digestClickCooldown);
+        return;
+      }
+
+      isActive = true;
+      cursor.isVisible = true;
+      move_toward(cursor, rect_center(rect), cursorSpeed);
+
+      auto isInItemRect = math::is_point_in_rectf(rect, cursor.position);
+
+      itemInput.isMouseLeftClicked = isInItemRect && !isItemMouseHeld;
+      itemInput.isMouseLeftDown = isInItemRect || isItemMouseHeld;
+      itemManager.inputOverride = itemInput;
+      if (isInItemRect) isItemMouseHeld = true;
+      isDigestMouseHeld = false;
+      return;
+    }
+
+    auto isInventoryFood = is_inventory_food(character, inventory);
+    auto isWorldFood = is_world_food(character, itemManager);
+    if (character.calories <= CALORIE_EPSILON && !isInventoryFood && !isWorldFood)
+    {
+      state_reset(cursor, isItemMouseHeld, isDigestMouseHeld, digestClickCooldown);
+      return;
+    }
+
+    auto bestInventoryFood = isEatTarget ? best_inventory_food_get(character, inventory) : -1;
+    if (bestInventoryFood != -1 && !isWorldFood && (int)itemManager.items.size() < ItemManager::LIMIT)
+    {
+      itemManager.queuedItemIDs.emplace_back(bestInventoryFood);
+      inventory.values[bestInventoryFood]--;
+      schema.root()->soundSummon.play();
+      cursor.isVisible = false;
+      return;
+    }
+
+    if ((isWorldFood && bestWorldFood == -1) || !can_eat_anything(character, itemManager, inventory))
+    {
+      auto* interactArea = digestion_area_get(character);
+      if (!interactArea)
+      {
+        state_reset(cursor, isItemMouseHeld, isDigestMouseHeld, digestClickCooldown);
+        return;
+      }
+
+      auto rect = character.null_frame_rect(character.data.null_id_get(interactArea->null));
+      if (!is_finite(rect))
+      {
+        state_reset(cursor, isItemMouseHeld, isDigestMouseHeld, digestClickCooldown);
+        return;
+      }
+      auto radius = glm::max(1.0f, glm::min(rect.z, rect.w) * 0.25f);
+      digestAngle += 0.08f;
+      auto targetWorld = rect_center(rect) + glm::vec2(std::cos(digestAngle), std::sin(digestAngle)) * radius;
+      auto isAtTarget = move_toward(cursor, targetWorld, digestCursorSpeed);
+      isActive = true;
+      cursor.isVisible = true;
+
+      cursor.interactTypeID = character.data.interact_type_id_get(interactArea->typeString);
+      if (interactArea->digestionBonusOnHover > 0.0f)
+      {
+        auto isInDigestRect = math::is_point_in_rectf(rect, cursor.position);
+        characterInput.isMouseLeftClick = isInDigestRect && !isDigestMouseHeld;
+        characterInput.isMouseLeftDown = isInDigestRect;
+        characterInput.isMouseLeftReleased = isDigestMouseHeld && !isInDigestRect;
+        isDigestMouseHeld = isInDigestRect;
+      }
+      else
+      {
+        if (digestClickCooldown > 0) digestClickCooldown--;
+        characterInput.isMouseLeftClick = isAtTarget && digestClickCooldown <= 0 && !isDigestMouseHeld;
+        characterInput.isMouseLeftReleased = isDigestMouseHeld;
+        if (characterInput.isMouseLeftClick)
+        {
+          isDigestMouseHeld = true;
+          digestClickCooldown = 45;
+        }
+        else if (characterInput.isMouseLeftReleased)
+          isDigestMouseHeld = false;
+      }
+      characterManager.inputOverride = characterInput;
+      isItemMouseHeld = false;
+      return;
+    }
+
+    state_reset(cursor, isItemMouseHeld, isDigestMouseHeld, digestClickCooldown);
+  }
+
+  void Autofeed::toggle() { isEnabled = !isEnabled; }
+  void Autofeed::disable() { isEnabled = false; }
+  bool Autofeed::available_get(Entity& character, menu::Inventory& inventory, ItemManager& itemManager) const
+  {
+    return is_food(character, inventory, itemManager);
+  }
+  bool Autofeed::enabled_get() const { return isEnabled; }
+  bool Autofeed::active_get() const { return isActive; }
+}
diff --git a/src/state/play/autofeed.hpp b/src/state/play/autofeed.hpp
new file mode 100644
index 0000000..0db2cea
--- /dev/null
+++ b/src/state/play/autofeed.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "../../resources.hpp"
+#include "character_manager.hpp"
+#include "item_manager.hpp"
+#include "menu/inventory.hpp"
+
+namespace game::state::play
+{
+  class Autofeed
+  {
+    bool isItemMouseHeld{};
+    bool isDigestMouseHeld{};
+    int digestClickCooldown{};
+    float digestAngle{};
+    bool isEnabled{};
+    bool isActive{};
+
+  public:
+    void update(Resources&, Entity& character, Entity& cursor, menu::Inventory&, ItemManager&,
+                CharacterManager&, Canvas&);
+    void toggle();
+    void disable();
+    bool available_get(Entity& character, menu::Inventory&, ItemManager&) const;
+    bool enabled_get() const;
+    bool active_get() const;
+  };
+}
diff --git a/src/state/play/character_manager.cpp b/src/state/play/character_manager.cpp
index 920b3e9..32df974 100644
--- a/src/state/play/character_manager.cpp
+++ b/src/state/play/character_manager.cpp
@@ -3,6 +3,7 @@
 #include "../../util/math.hpp"
 
 #include <imgui.h>
+#include <algorithm>
 #include <optional>
 
 using namespace game::resource::xml;
@@ -10,13 +11,18 @@ using namespace game::util;
 
 namespace game::state::play
 {
-  void CharacterManager::update(entity::Character& character, entity::Cursor& cursor, Text& text, Canvas& canvas)
+  void CharacterManager::update(Entity& character, Entity& cursor, Text& text, Canvas& canvas)
   {
-    auto interact_area_override_tick = [](entity::Actor::Override& override_)
+    static constexpr auto SCALE_EFFECT_TIME_TICKS_DEFAULT = 20.0f;
+    static constexpr auto SCALE_EFFECT_CYCLES_DEFAULT = 1.0f;
+    static constexpr auto ZERO_FLOAT = 0.0f;
+
+    auto interact_area_override_tick = [](Entity::Override& override_)
     {
       auto& scale = override_.frame.scale;
       auto& scaleBase = override_.frameBase.scale;
-      auto isScaleValid = scale.x.has_value() && scale.y.has_value() && scaleBase.x.has_value() && scaleBase.y.has_value();
+      auto isScaleValid =
+          scale.x.has_value() && scale.y.has_value() && scaleBase.x.has_value() && scaleBase.y.has_value();
 
       if (isScaleValid && override_.time.has_value() && override_.timeStart.has_value())
       {
@@ -34,11 +40,22 @@ namespace game::state::play
     };
 
     auto& dialogue = character.data.dialogue;
-    auto cursorWorldPosition = canvas.screen_position_convert(cursor.position);
+    auto cursorWorldPosition =
+        cursor.entityType == AUTOCURSOR ? cursor.position : canvas.screen_position_convert(cursor.position);
     auto isMouseLeftClick = ImGui::IsMouseClicked(ImGuiMouseButton_Left);
+    auto isMouseLeftDown = ImGui::IsMouseDown(ImGuiMouseButton_Left);
     auto isMouseLeftReleased = ImGui::IsMouseReleased(ImGuiMouseButton_Left);
     auto isImguiCaptureMouse = ImGui::GetIO().WantCaptureMouse;
 
+    if (inputOverride)
+    {
+      isImguiCaptureMouse = inputOverride->isImguiCaptureMouse;
+      isMouseLeftClick = inputOverride->isMouseLeftClick;
+      isMouseLeftDown = inputOverride->isMouseLeftDown;
+      isMouseLeftReleased = inputOverride->isMouseLeftReleased;
+      inputOverride.reset();
+    }
+
     if (isDisabled)
     {
       isInteracting = false;
@@ -52,76 +69,121 @@ namespace game::state::play
     isHoveringPrevious = isHovering;
     isHoldInteractingPrevious = isHoldInteracting;
     isHovering = false;
+    particles.clear();
     if (!isInteracting) isHoldInteracting = false;
 
     if (isJustStoppedHoldInteracting)
     {
-      cursor.queue_play({cursor.defaultAnimation});
-      if (character.queuedPlay.empty()) character.queue_idle_animation();
+      cursor.play({cursor.defaultAnimation});
+      if (!character.is_animation_request())
+        character.play({.animation = character.idle_animation_get(), .appendID = character.animation_append_id_get()});
       isJustStoppedHoldInteracting = false;
     }
     else if (isJustStoppedInteracting)
     {
-      cursor.queue_play({cursor.defaultAnimation});
+      cursor.play({cursor.defaultAnimation});
       isJustStoppedInteracting = false;
     }
 
     if (isJustStoppedHovering)
     {
-      cursor.queue_play({cursor.defaultAnimation});
+      cursor.play({cursor.defaultAnimation});
       isJustStoppedHovering = false;
     }
 
-    for (int i = 0; i < (int)character.data.interactAreas.size(); i++)
-    {
-      auto& interactArea = character.data.interactAreas.at(i);
-      if (interactArea.nullID == -1) continue;
-      auto rect = character.null_frame_rect(interactArea.nullID);
+    auto interactAreas = character.data.interact_areas_get();
+    if (interactAreaDialogueTimers.size() != interactAreas.size())
+      interactAreaDialogueTimers.assign(interactAreas.size(), 0);
+    if (!text.entry) std::ranges::fill(interactAreaDialogueTimers, 0);
+    for (auto& timer : interactAreaDialogueTimers)
+      if (timer > 0) timer--;
 
-      if (cursor.state == entity::Cursor::DEFAULT && math::is_point_in_rectf(rect, cursorWorldPosition) &&
-          !isImguiCaptureMouse && interactArea.typeID == cursor.interactTypeID)
+    for (int i = 0; i < (int)interactAreas.size(); i++)
+    {
+      auto* interactArea = interactAreas.at(i);
+      auto nullID = character.data.null_id_get(interactArea->null);
+      auto layerID = character.data.layer_id_get(interactArea->layer);
+      if (nullID == -1) continue;
+      auto rect = character.null_frame_rect(nullID);
+
+      if (cursor.cursorState == Entity::DEFAULT && math::is_point_in_rectf(rect, cursorWorldPosition) &&
+          !isImguiCaptureMouse &&
+          character.data.interact_type_id_get(interactArea->typeString) == cursor.interactTypeID)
       {
-        cursor.state = entity::Cursor::HOVER;
-        cursor.queue_play({interactArea.animationCursorHover});
+        cursor.cursorState = Entity::HOVER;
+        cursor.play({.animation = interactArea->animationCursorHover, .transition = Entity::Transition::IF_IDLE});
         isHovering = true;
         interactAreaID = i;
 
-        if (isMouseLeftClick)
+        auto interact_area_proc = [&](bool isInteract)
         {
-          isInteracting = true;
-          isHoldInteracting = interactArea.isHold;
-          interactArea.sound.play();
-
-          if (interactArea.digestionBonusClick > 0 && character.calories > 0 && !character.isDigesting)
-            character.digestionProgress += interactArea.digestionBonusClick;
-
-          if (interactArea.layerID != -1)
+          if (isInteract)
           {
-            character.overrides.emplace_back(entity::Actor::Override(
-                interactArea.layerID, Anm2::LAYER, entity::Actor::Override::ADD,
-                {.scale = glm::vec2(interactArea.scaleEffectAmplitude)}, std::optional<float>(interactArea.time),
-                interact_area_override_tick, interactArea.scaleEffectCycles));
+            isInteracting = true;
+            isHoldInteracting = interactArea->isHold;
+          }
+          else
+          {
+            cursor.cursorState = Entity::ACTION;
+            cursor.play({.animation = interactArea->animationCursorActive,
+                         .mode = Entity::PLAY_FORCE,
+                         .interrupt = Entity::Interrupt::ALWAYS});
+          }
+          interactArea->soundEntries.play();
+          for (auto* particle : character.data.children_get(*interactArea, Schema::Element::PARTICLE))
+            if (particle && !particle->typeString.empty())
+              particles.push_back({.label = particle->typeString, .position = cursorWorldPosition});
+
+          if (interactArea->digestionBonusOnClick > 0 && character.calories > 0 && !character.isDigesting)
+            character.digestionProgress += interactArea->digestionBonusOnClick;
+
+          if (layerID != -1)
+          {
+            auto scaleEffectTimeTicks = interactArea->timeTicks == ZERO_FLOAT ? SCALE_EFFECT_TIME_TICKS_DEFAULT
+                                                                              : interactArea->timeTicks;
+            auto scaleEffectCycles = interactArea->scaleEffectCycles == ZERO_FLOAT ? SCALE_EFFECT_CYCLES_DEFAULT
+                                                                                  : interactArea->scaleEffectCycles;
+            character.overrides.emplace_back(Entity::Override(
+                layerID, Anm2::LAYER, Entity::Override::ADD, {.scale = glm::vec2(interactArea->scaleEffectAmplitude)},
+                std::optional<float>(scaleEffectTimeTicks), interact_area_override_tick, scaleEffectCycles));
           }
 
-          if (text.is_interruptible())
+          auto isDialogueReady = interactAreaDialogueTimers[i] <= 0;
+          interactAreaDialogueTimers[i] = std::max(0, interactArea->timeToActivateNewDialogueTicks);
+
+          auto poolFullID = character.data.dialogue_pool_id_get(interactArea->dialoguePoolIDFull);
+          auto poolID = character.data.dialogue_pool_id_get(interactArea->dialoguePoolID);
+          if (character.is_over_capacity() && poolFullID != -1) poolID = poolFullID;
+
+          if (poolID != -1)
           {
-            auto& pool = character.is_over_capacity() && interactArea.poolFull.is_valid() ? interactArea.poolFull
-                                                                                           : interactArea.pool;
-            if (pool.is_valid())
-              text.set(dialogue.get(pool), character);
+            if (text.is_interruptible() && isDialogueReady)
+            {
+              auto* entry = dialogue.dialogue_pool_entry_get(poolID);
+              if (entry) text.set(entry, character);
+            }
           }
-        }
+          else if (interactArea->dialoguePoolID.empty() && !interactArea->animation.empty())
+            character.play({.animation = interactArea->animation,
+                            .appendID = character.animation_append_id_get(),
+                            .mode = Entity::PLAY_FORCE});
+        };
+
+        if (interactArea->isHold && (isMouseLeftClick || (isMouseLeftDown && !isInteracting)))
+          interact_area_proc(true);
+        else if (!interactArea->isHold && isMouseLeftClick)
+          interact_area_proc(false);
 
         if (isInteracting)
         {
-          cursor.state = entity::Cursor::ACTION;
-          cursor.queue_play({interactArea.animationCursorActive});
+          cursor.cursorState = Entity::ACTION;
+          cursor.play({interactArea->animationCursorActive});
 
-          if (interactArea.digestionBonusRub > 0 && character.calories > 0 && !character.isDigesting)
+          if (interactArea->digestionBonusOnHover > 0 && character.calories > 0 && !character.isDigesting)
           {
             auto mouseDelta = cursorWorldPosition - cursorWorldPositionPrevious;
-            auto digestionBonus = (fabs(mouseDelta.x) + fabs(mouseDelta.y)) * interactArea.digestionBonusRub;
-            character.digestionProgress += digestionBonus;
+            if (fabs(mouseDelta.x) > 0.0f || fabs(mouseDelta.y) > 0.0f)
+              character.digestionProgress += interactArea->digestionBonusOnHover;
           }
         }
       }
@@ -141,7 +203,11 @@ namespace game::state::play
 
     cursorWorldPositionPrevious = cursorWorldPosition;
 
-    if (character.isJustDigested && text.is_interruptible()) text.set(dialogue.get(dialogue.digest), character);
-    if (character.isJustStageUp) text.set(dialogue.get(dialogue.stageUp), character);
+    if (character.isJustDigested && text.is_interruptible())
+      if (auto* digest = dialogue.get(Schema::Element::DIGEST))
+        text.set(dialogue.dialogue_pool_entry_get(*digest), character);
+    if (character.isJustStageUp)
+      if (auto* stageUp = dialogue.get(Schema::Element::STAGE_UP))
+        text.set(dialogue.dialogue_pool_entry_get(*stageUp), character);
   }
 }
diff --git a/src/state/play/character_manager.hpp b/src/state/play/character_manager.hpp
index 4abf06d..87f5487 100644
--- a/src/state/play/character_manager.hpp
+++ b/src/state/play/character_manager.hpp
@@ -1,9 +1,11 @@
 #pragma once
 
-#include "../../entity/character.hpp"
-#include "../../entity/cursor.hpp"
+#include "../../entity.hpp"
 #include "text.hpp"
 
+#include <optional>
+#include <vector>
+
 namespace game::state::play
 {
   class CharacterManager
@@ -20,10 +22,28 @@ namespace game::state::play
     bool isHoldInteractingPrevious{};
     bool isJustStoppedHoldInteracting{};
     int interactAreaID{-1};
+    std::vector<int> interactAreaDialogueTimers{};
 
     glm::vec2 cursorWorldPositionPrevious{};
     std::string queuedAnimation{};
 
-    void update(entity::Character&, entity::Cursor&, Text&, Canvas&);
+    struct Particle
+    {
+      std::string label{};
+      glm::vec2 position{};
+    };
+
+    struct Input
+    {
+      bool isImguiCaptureMouse{};
+      bool isMouseLeftClick{};
+      bool isMouseLeftDown{};
+      bool isMouseLeftReleased{};
+    };
+
+    std::optional<Input> inputOverride{};
+    std::vector<Particle> particles{};
+
+    void update(Entity&, Entity&, Text&, Canvas&);
   };
 }
diff --git a/src/state/play/cheats.cpp b/src/state/play/cheats.cpp
index ef5b8f2..eebc235 100644
--- a/src/state/play/cheats.cpp
+++ b/src/state/play/cheats.cpp
@@ -12,7 +12,7 @@ using namespace game::resource::xml;
 
 namespace game::state::play
 {
-  void Cheats::update(Resources&, entity::Character& character, menu::Inventory& inventory)
+  void Cheats::update(Resources&, Entity& character, menu::Inventory& inventory)
   {
     auto& strings = character.data.strings;
 
@@ -20,16 +20,20 @@ namespace game::state::play
     {
       auto stage = character.stage + 1;
       auto maxCapacity = (float)character.max_capacity();
-      auto capacityMin = (float)character.data.capacityMin;
-      auto capacityMax = (float)character.data.capacityMax;
-      auto weightMin = (float)character.data.weight;
-      auto weightMax = (float)character.data.weightMax;
-      auto digestionRateMin = (float)character.data.digestionRateMin;
-      auto digestionRateMax = (float)character.data.digestionRateMax;
-      auto eatSpeedMin = (float)character.data.eatSpeedMin;
-      auto eatSpeedMax = (float)character.data.eatSpeedMax;
+      auto capacityMin = (float)character.data.root()->capacityMinCalories;
+      auto capacityMax = (float)character.data.root()->capacityMaxCalories;
+      auto weightMin = (float)character.data.root()->weightKilograms;
+      auto weightMax = (float)character.data.root()->weightMaxKilograms;
+      auto digestionRateMin = (float)character.data.root()->digestionRateMin * Entity::UPDATE_RATE;
+      auto digestionRateMax = (float)character.data.root()->digestionRateMax * Entity::UPDATE_RATE;
+      auto digestionRate = character.digestion_rate_get();
+      auto eatSpeedMin = (float)character.data.root()->eatSpeedMinMultiplier;
+      auto eatSpeedMax = (float)character.data.root()->eatSpeedMaxMultiplier;
 
-      auto weight_update = [&]() { character.queue_idle_animation(); };
+      auto weight_update = [&]()
+      {
+        character.play({.animation = character.idle_animation_get(), .appendID = character.animation_append_id_get()});
+      };
 
       WIDGET_FX(ImGui::SliderFloat(strings.get(Strings::CheatsCalories).c_str(), &character.calories, 0.0f, maxCapacity,
                                    "%0.0f kcal"));
@@ -41,24 +45,26 @@ namespace game::state::play
                                         strings.get(Strings::CheatsWeightFormat).c_str())))
         weight_update();
 
+      auto stages = character.data.stages_get();
       if (WIDGET_FX(ImGui::SliderInt(strings.get(Strings::CheatsStage).c_str(), &stage, 1,
-                                     (int)character.data.stages.size() + 1)))
+                                     (int)stages.size() + 1)))
       {
-        character.stage = glm::clamp(0, stage - 1, (int)character.data.stages.size());
+        character.stage = glm::clamp(0, stage - 1, (int)stages.size());
         character.weight =
-            character.stage == 0 ? character.data.weight : character.data.stages.at(character.stage - 1).threshold;
+            character.stage == 0 ? character.data.root()->weightKilograms : stages.at(character.stage - 1)->thresholdKilograms;
         weight_update();
       }
 
-      WIDGET_FX(ImGui::SliderFloat(strings.get(Strings::CheatsDigestionRate).c_str(), &character.digestionRate,
-                                   digestionRateMin, digestionRateMax,
-                                    strings.get(Strings::CheatsDigestionRateFormat).c_str()));
+      if (WIDGET_FX(ImGui::SliderFloat(strings.get(Strings::CheatsDigestionRate).c_str(), &digestionRate,
+                                       digestionRateMin, digestionRateMax,
+                                       strings.get(Strings::CheatsDigestionRateFormat).c_str())))
+        character.digestionRate = digestionRate / Entity::UPDATE_RATE;
       WIDGET_FX(ImGui::SliderFloat(strings.get(Strings::CheatsEatSpeed).c_str(), &character.eatSpeed, eatSpeedMin,
                                    eatSpeedMax,
                                     strings.get(Strings::CheatsEatSpeedFormat).c_str()));
 
       if (WIDGET_FX(ImGui::Button(strings.get(Strings::CheatsDigestButton).c_str())))
-        character.digestionProgress = entity::Character::DIGESTION_MAX;
+        character.digestionProgress = Entity::DIGESTION_MAX;
 
       ImGui::SeparatorText(strings.get(Strings::CheatsInventory).c_str());
 
diff --git a/src/state/play/cheats.hpp b/src/state/play/cheats.hpp
index 0799950..5a0abbd 100644
--- a/src/state/play/cheats.hpp
+++ b/src/state/play/cheats.hpp
@@ -10,6 +10,6 @@ namespace game::state::play
   class Cheats
   {
   public:
-    void update(Resources&, entity::Character&, menu::Inventory&);
+    void update(Resources&, Entity&, menu::Inventory&);
   };
 }
diff --git a/src/state/play/debug.cpp b/src/state/play/debug.cpp
deleted file mode 100644
index 9581d3c..0000000
--- a/src/state/play/debug.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include "debug.hpp"
-
-#include "../../util/imgui/widget.hpp"
-
-#include <ranges>
-
-using namespace game::util::imgui;
-using namespace game::resource::xml;
-
-namespace game::state::play
-{
-  void Debug::update(entity::Character& character, entity::Cursor& cursor, ItemManager& itemManager, Canvas& canvas,
-                     Text& text)
-  {
-    auto cursorPosition = canvas.screen_position_convert(cursor.position);
-
-    ImGui::Text("Cursor Pos (Screen): %0.0f, %0.0f", cursor.position.x, cursor.position.y);
-    ImGui::Text("Cursor Pos (World): %0.0f, %0.0f", cursorPosition.x, cursorPosition.y);
-
-    ImGui::SeparatorText("Animations");
-    ImGui::Text("Now Playing: %s", character.animationMapReverse.at(character.animationIndex).c_str());
-
-    auto childSize = ImVec2(0, ImGui::GetContentRegionAvail().y / 3);
-
-    if (ImGui::BeginChild("##Animations", childSize, ImGuiChildFlags_Borders))
-    {
-      for (int i = 0; i < (int)character.animations.size(); i++)
-      {
-        auto& animation = character.animations[i];
-        ImGui::PushID(i);
-        if (WIDGET_FX(ImGui::Selectable(animation.name.c_str())))
-          character.play(animation.name.c_str(), entity::Actor::PLAY_FORCE);
-        ImGui::SetItemTooltip("%s", animation.name.c_str());
-        ImGui::PopID();
-      }
-    }
-    ImGui::EndChild();
-
-    ImGui::SeparatorText("Dialogue");
-
-    if (character.data.dialogue.start.is_valid())
-      if (WIDGET_FX(ImGui::Button("Play Start Sequence"))) isStartSequenceRequested = true;
-    if (character.data.dialogue.end.is_valid())
-      if (WIDGET_FX(ImGui::Button("Play End Sequence"))) isEndSequenceRequested = true;
-
-    if (ImGui::BeginChild("##Dialogue", childSize, ImGuiChildFlags_Borders))
-    {
-      for (int i = 0; i < (int)character.data.dialogue.entries.size(); i++)
-      {
-        auto& entry = character.data.dialogue.entries[i];
-        ImGui::PushID(i);
-        if (WIDGET_FX(ImGui::Selectable(entry.name.c_str()))) text.set(&entry, character);
-        ImGui::SetItemTooltip("%s", entry.name.c_str());
-        ImGui::PopID();
-      }
-    }
-    ImGui::EndChild();
-
-    WIDGET_FX(ImGui::Checkbox("Show Nulls (Hitboxes)", &character.isShowNulls));
-    WIDGET_FX(ImGui::Checkbox("Show World Bounds", &isBoundsDisplay));
-
-    if (!itemManager.items.empty())
-    {
-      ImGui::SeparatorText("Item");
-
-      for (int i = 0; i < (int)itemManager.items.size(); i++)
-      {
-        auto& item = itemManager.items[i];
-        if (itemManager.heldItemIndex == i) ImGui::TextUnformatted("Held");
-        ImGui::Text("Type: %i", item.schemaID);
-        ImGui::Text("Position: %0.0f, %0.0f", item.position.x, item.position.y);
-        ImGui::Text("Velocity: %0.0f, %0.0f", item.velocity.x, item.velocity.y);
-        ImGui::Text("Durability: %i", item.durability);
-        ImGui::Separator();
-      }
-    }
-  }
-}
diff --git a/src/state/play/debug.hpp b/src/state/play/debug.hpp
deleted file mode 100644
index 8502a41..0000000
--- a/src/state/play/debug.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#pragma once
-
-#include "../../entity/character.hpp"
-#include "../../entity/cursor.hpp"
-
-#include "item_manager.hpp"
-#include "text.hpp"
-
-#include <imgui.h>
-
-namespace game::state::play
-{
-  class Debug
-  {
-  public:
-    bool isBoundsDisplay{};
-    bool isStartSequenceRequested{};
-    bool isEndSequenceRequested{};
-
-    void update(entity::Character&, entity::Cursor&, ItemManager&, Canvas&, Text&);
-  };
-}
diff --git a/src/state/play/info.cpp b/src/state/play/info.cpp
index 4756ef0..d7637f2 100644
--- a/src/state/play/info.cpp
+++ b/src/state/play/info.cpp
@@ -14,119 +14,136 @@ using namespace game::util;
 
 namespace game::state::play
 {
-  void Info::update(Resources& resources, entity::Character& character)
+  float info_height_get()
   {
-    static constexpr auto WIDTH_MULTIPLIER = 0.30f;
     static constexpr auto HEIGHT_MULTIPLIER = 4.0f;
+    return ImGui::GetTextLineHeightWithSpacing() * HEIGHT_MULTIPLIER;
+  }
+
+  void info_content_draw(Resources& resources, Entity& character, ImVec2 size)
+  {
+    static constexpr auto HALF_MULTIPLIER = 0.5f;
+    static constexpr auto ZERO_FLOAT = 0.0f;
 
     auto& strings = character.data.strings;
+    auto& style = ImGui::GetStyle();
+    auto childSize = ImVec2((size.x - style.ItemSpacing.x) * HALF_MULTIPLIER, size.y);
+
+    if (ImGui::BeginChild("##Weight", childSize))
+    {
+      auto* settings = resources.settings.root();
+      auto system = settings->measurementSystem == "Imperial" ? measurement::IMPERIAL : measurement::METRIC;
+      auto weight = character.weight_get(system);
+      auto stage = character.stage_get();
+      auto stageMax = character.stage_max_get();
+      auto stageCount = character.stage_count_get();
+      auto stageWeight = character.stage_threshold_get(stage, system);
+      auto stageNextWeight = character.stage_threshold_next_get(system);
+      auto unitString = (system == measurement::IMPERIAL ? "lbs" : "kg");
+
+      auto weightString = util::string::format_commas(weight, 2) + " " + unitString;
+      imgui::text_unformatted_fit_draw(weightString.c_str(), ImVec2(ImGui::GetContentRegionAvail().x, Font::HEADER_2),
+                                       Font::HEADER_2);
+      ImGui::SetItemTooltip("%s", weightString.c_str());
+
+      auto stageProgress = character.stage_progress_get();
+      ImGui::ProgressBar(stageProgress, ImVec2(ImGui::GetContentRegionAvail().x, ZERO_FLOAT),
+                         strings.get(stage >= stageMax ? Strings::InfoProgressMax : Strings::InfoProgressToNextStage)
+                             .c_str());
+      if (ImGui::BeginItemTooltip())
+      {
+        ImGui::Text(strings.get(Strings::InfoStageProgressFormat).c_str(), stage + 1, stageCount,
+                    math::to_percent(stageProgress));
+        ImGui::Separator();
+        ImGui::PushStyleColor(ImGuiCol_Text, imgui::to_imvec4(color::GRAY));
+        if (stage >= stageMax)
+          ImGui::TextUnformatted(strings.get(Strings::InfoMaxedOut).c_str());
+        else
+        {
+          ImGui::Text(strings.get(Strings::InfoStageStartFormat).c_str(), stageWeight, unitString);
+          ImGui::Text(strings.get(Strings::InfoStageCurrentFormat).c_str(), weight, unitString);
+          ImGui::Text(strings.get(Strings::InfoStageNextFormat).c_str(), stageNextWeight, unitString);
+        }
+        ImGui::PopStyleColor();
+        ImGui::EndTooltip();
+      }
+    }
+    ImGui::EndChild();
+
+    ImGui::SameLine();
+
+    if (ImGui::BeginChild("##Calories and Capacity", childSize))
+    {
+      auto& calories = character.calories;
+      auto& capacity = character.capacity;
+
+      auto overstuffedPercent = std::max(ZERO_FLOAT, (calories - capacity) / (character.max_capacity() - capacity));
+      auto caloriesColor = ImVec4(1.0f, 1.0f - overstuffedPercent, 1.0f - overstuffedPercent, 1.0f);
+
+      ImGui::PushStyleColor(ImGuiCol_Text, caloriesColor);
+      auto caloriesString = std::format("{:.0f} kcal / {:.0f} kcal", calories,
+                                        character.is_over_capacity() ? character.max_capacity() : character.capacity);
+      imgui::text_unformatted_fit_draw(caloriesString.c_str(),
+                                       ImVec2(ImGui::GetContentRegionAvail().x, Font::HEADER_2), Font::HEADER_2);
+      ImGui::SetItemTooltip("%s", caloriesString.c_str());
+      ImGui::PopStyleColor();
+
+      auto digestionProgress = character.isDigesting
+                                   ? (float)character.digestionTimer / character.data.root()->digestionTimerMax
+                                   : character.digestionProgress / Entity::DIGESTION_MAX;
+      ImGui::ProgressBar(digestionProgress, ImVec2(ImGui::GetContentRegionAvail().x, ZERO_FLOAT),
+                         strings.get(character.isDigesting ? Strings::InfoDigesting : Strings::InfoDigestion).c_str());
+
+      if (ImGui::BeginItemTooltip())
+      {
+        if (character.isDigesting)
+          ImGui::TextUnformatted(strings.get(Strings::InfoDigestionInProgress).c_str());
+        else if (digestionProgress <= ZERO_FLOAT)
+          ImGui::TextUnformatted(strings.get(Strings::InfoGiveFoodToStartDigesting).c_str());
+        else
+          ImGui::Text("%0.2f%%", math::to_percent(digestionProgress));
+
+        ImGui::Separator();
+
+        ImGui::PushStyleColor(ImGuiCol_Text, ImGui::GetColorU32(imgui::to_imvec4(color::GRAY)));
+
+        ImGui::Text(strings.get(Strings::InfoDigestionRateFormat).c_str(), character.digestion_rate_get());
+        ImGui::Text(strings.get(Strings::InfoEatingSpeedFormat).c_str(), character.eatSpeed);
+
+        ImGui::PopStyleColor();
+
+        ImGui::EndTooltip();
+      }
+    }
+    ImGui::EndChild();
+  }
+
+  void Info::update(Resources& resources, Entity& character, float fadeAlpha)
+  {
+    static constexpr auto WIDTH_MULTIPLIER = 0.30f;
+    static constexpr auto ALPHA_MIN = 0.0f;
+    static constexpr auto ALPHA_MAX = 1.0f;
+    static constexpr auto STYLE_VAR_COUNT = 1;
+    if (fadeAlpha <= ALPHA_MIN) return;
+
     auto& style = ImGui::GetStyle();
     auto windowSize = imgui::to_ivec2(ImGui::GetMainViewport()->Size);
 
     auto size = ImVec2(windowSize.x * WIDTH_MULTIPLIER - (style.WindowPadding.x * 2.0f),
-                       ImGui::GetTextLineHeightWithSpacing() * HEIGHT_MULTIPLIER);
+                       info_height_get());
     auto pos = ImVec2((windowSize.x * 0.5f) - (size.x * 0.5f), style.WindowPadding.y);
 
     ImGui::SetNextWindowSize(size);
     ImGui::SetNextWindowPos(pos);
 
-    if (ImGui::Begin("##Info", nullptr,
-                     ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
-                         ImGuiWindowFlags_NoMove))
-    {
-      auto childSize = ImVec2(ImGui::GetContentRegionAvail().x / 2, ImGui::GetContentRegionAvail().y);
+    auto flags = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
+                 ImGuiWindowFlags_NoMove;
+    if (fadeAlpha < ALPHA_MAX) flags |= ImGuiWindowFlags_NoInputs;
 
-      if (ImGui::BeginChild("##Weight", childSize))
-      {
-        auto& system = resources.settings.measurementSystem;
-        auto weight = character.weight_get(system);
-        auto stage = character.stage_get();
-        auto stageMax = character.stage_max_get();
-        auto stageWeight = character.stage_threshold_get(stage, system);
-        auto stageNextWeight = character.stage_threshold_next_get(system);
-        auto unitString = (system == measurement::IMPERIAL ? "lbs" : "kg");
-
-        auto weightString = util::string::format_commas(weight, 2) + " " + unitString;
-        ImGui::PushFont(ImGui::GetFont(), Font::HEADER_1);
-        ImGui::TextUnformatted(weightString.c_str());
-        ImGui::SetItemTooltip("%s", weightString.c_str());
-        ImGui::PopFont();
-
-        auto stageProgress = character.stage_progress_get();
-        ImGui::ProgressBar(stageProgress, ImVec2(ImGui::GetContentRegionAvail().x, 0),
-                           strings.get(stage >= stageMax ? Strings::InfoProgressMax
-                                                         : Strings::InfoProgressToNextStage)
-                               .c_str());
-        if (ImGui::BeginItemTooltip())
-        {
-          ImGui::Text(strings.get(Strings::InfoStageProgressFormat).c_str(), stage + 1, stageMax + 1,
-                      math::to_percent(stageProgress));
-          ImGui::Separator();
-          ImGui::PushStyleColor(ImGuiCol_Text, imgui::to_imvec4(color::GRAY));
-          if (stage >= stageMax)
-            ImGui::TextUnformatted(strings.get(Strings::InfoMaxedOut).c_str());
-          else
-          {
-            ImGui::Text(strings.get(Strings::InfoStageStartFormat).c_str(), stageWeight, unitString);
-            ImGui::Text(strings.get(Strings::InfoStageCurrentFormat).c_str(), weight, unitString);
-            ImGui::Text(strings.get(Strings::InfoStageNextFormat).c_str(), stageNextWeight, unitString);
-          }
-          ImGui::PopStyleColor();
-          ImGui::EndTooltip();
-        }
-      }
-      ImGui::EndChild();
-
-      ImGui::SameLine();
-
-      if (ImGui::BeginChild("##Calories and Capacity", childSize))
-      {
-        auto& calories = character.calories;
-        auto& capacity = character.capacity;
-
-        auto overstuffedPercent = std::max(0.0f, (calories - capacity) / (character.max_capacity() - capacity));
-        auto caloriesColor = ImVec4(1.0f, 1.0f - overstuffedPercent, 1.0f - overstuffedPercent, 1.0f);
-
-        ImGui::PushFont(ImGui::GetFont(), Font::HEADER_1);
-        ImGui::PushStyleColor(ImGuiCol_Text, caloriesColor);
-        auto caloriesString = std::format("{:.0f} kcal / {:.0f} kcal", calories,
-                                          character.is_over_capacity() ? character.max_capacity() : character.capacity);
-        ImGui::TextUnformatted(caloriesString.c_str());
-        ImGui::SetItemTooltip("%s", caloriesString.c_str());
-        ImGui::PopStyleColor();
-        ImGui::PopFont();
-
-        auto digestionProgress = character.isDigesting
-                                     ? (float)character.digestionTimer / character.data.digestionTimerMax
-                                     : character.digestionProgress / entity::Character::DIGESTION_MAX;
-        ImGui::ProgressBar(digestionProgress, ImVec2(ImGui::GetContentRegionAvail().x, 0),
-                           strings.get(character.isDigesting ? Strings::InfoDigesting
-                                                             : Strings::InfoDigestion)
-                               .c_str());
-
-        if (ImGui::BeginItemTooltip())
-        {
-          if (character.isDigesting)
-            ImGui::TextUnformatted(strings.get(Strings::InfoDigestionInProgress).c_str());
-          else if (digestionProgress <= 0.0f)
-            ImGui::TextUnformatted(strings.get(Strings::InfoGiveFoodToStartDigesting).c_str());
-          else
-            ImGui::Text("%0.2f%%", math::to_percent(digestionProgress));
-
-          ImGui::Separator();
-
-          ImGui::PushStyleColor(ImGuiCol_Text, ImGui::GetColorU32(imgui::to_imvec4(color::GRAY)));
-
-          ImGui::Text(strings.get(Strings::InfoDigestionRateFormat).c_str(), character.digestion_rate_get());
-          ImGui::Text(strings.get(Strings::InfoEatingSpeedFormat).c_str(), character.eatSpeed);
-
-          ImGui::PopStyleColor();
-
-          ImGui::EndTooltip();
-        }
-      }
-      ImGui::EndChild();
-    }
+    ImGui::PushStyleVar(ImGuiStyleVar_Alpha, style.Alpha * fadeAlpha);
+    if (ImGui::Begin("##Info", nullptr, flags))
+      info_content_draw(resources, character, ImGui::GetContentRegionAvail());
     ImGui::End();
+    ImGui::PopStyleVar(STYLE_VAR_COUNT);
   }
 }
diff --git a/src/state/play/info.hpp b/src/state/play/info.hpp
index 613cb65..ba33cdd 100644
--- a/src/state/play/info.hpp
+++ b/src/state/play/info.hpp
@@ -1,15 +1,18 @@
 #pragma once
 
-#include "../../entity/character.hpp"
+#include "../../entity.hpp"
 #include "../../resources.hpp"
 
 #include <imgui.h>
 
 namespace game::state::play
 {
+  float info_height_get();
+  void info_content_draw(Resources&, Entity&, ImVec2);
+
   class Info
   {
   public:
-    void update(Resources&, entity::Character&);
+    void update(Resources&, Entity&, float fadeAlpha);
   };
 }
diff --git a/src/state/play/item/reward.cpp b/src/state/play/item/reward.cpp
deleted file mode 100644
index 7d4a447..0000000
--- a/src/state/play/item/reward.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#include "reward.hpp"
-
-#include "../../../util/math.hpp"
-
-using namespace game::util;
-
-namespace game::state::play::item
-{
-  int Reward::random_item_get(const resource::xml::Item& itemSchema, float chanceBonus)
-  {
-    const resource::xml::Item::Pool* pool{};
-    auto totalWeight = 0.0f;
-
-    for (auto& id : itemSchema.rarityIDs)
-    {
-      auto& rarity = itemSchema.rarities[id];
-      if (rarity.weight <= 0.0f) continue;
-      totalWeight += rarity.weight * chanceBonus;
-    }
-
-    if (totalWeight <= 0.0f) return INVALID_ID;
-
-    auto roll = math::random_roll(totalWeight);
-
-    for (auto& id : itemSchema.rarityIDs)
-    {
-      auto& rarity = itemSchema.rarities[id];
-      auto weight = rarity.weight * chanceBonus;
-      if (weight <= 0.0f) continue;
-
-      roll -= weight;
-      if (roll <= 0.0f)
-      {
-        pool = &itemSchema.pools.at(id);
-        rarity.sound.play();
-        break;
-      }
-    }
-
-    if (!pool || pool->empty()) return INVALID_ID;
-    return (*pool)[(int)math::random_roll((float)pool->size())];
-  }
-
-  void Reward::item_give(int itemID, menu::Inventory& inventory, menu::ItemEffectManager& itemEffectManager,
-                         const resource::xml::Item& itemSchema, const ImVec4& bounds, menu::ItemEffectManager::Mode mode)
-  {
-    if (itemID < 0) return;
-
-    inventory.values[itemID]++;
-    itemEffectManager.spawn(itemID, itemSchema, bounds, mode);
-  }
-
-  int Reward::reward_random_items_try(menu::Inventory& inventory, menu::ItemEffectManager& itemEffectManager,
-                                      const resource::xml::Item& itemSchema, const ImVec4& bounds, float rewardChance,
-                                      float rewardRollCount, menu::ItemEffectManager::Mode mode)
-  {
-    auto rollCountWhole = std::max(0, (int)std::floor(rewardRollCount));
-    auto rollCountFraction = std::max(0.0f, rewardRollCount - (float)rollCountWhole);
-    auto rollCount = rollCountWhole + (math::random_percent_roll(rollCountFraction) ? 1 : 0);
-    auto rewardedItemCount = 0;
-
-    for (int i = 0; i < rollCount; i++)
-    {
-      if (!math::random_percent_roll(rewardChance)) continue;
-
-      auto itemID = random_item_get(itemSchema);
-      if (itemID == INVALID_ID) continue;
-
-      item_give(itemID, inventory, itemEffectManager, itemSchema, bounds, mode);
-      rewardedItemCount++;
-    }
-
-    return rewardedItemCount;
-  }
-}
diff --git a/src/state/play/item/reward.hpp b/src/state/play/item/reward.hpp
deleted file mode 100644
index 7c71964..0000000
--- a/src/state/play/item/reward.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#pragma once
-
-#include "../menu/inventory.hpp"
-#include "../menu/item_effect_manager.hpp"
-
-namespace game::state::play::item
-{
-  class Reward
-  {
-  public:
-    static constexpr auto INVALID_ID = -1;
-
-    int random_item_get(const resource::xml::Item& itemSchema, float chanceBonus = 1.0f);
-    void item_give(int itemID, menu::Inventory& inventory, menu::ItemEffectManager& itemEffectManager,
-                   const resource::xml::Item& itemSchema, const ImVec4& bounds,
-                   menu::ItemEffectManager::Mode mode = menu::ItemEffectManager::FALL_DOWN);
-    int reward_random_items_try(menu::Inventory& inventory, menu::ItemEffectManager& itemEffectManager,
-                                const resource::xml::Item& itemSchema, const ImVec4& bounds, float rewardChance,
-                                float rewardRollCount,
-                                menu::ItemEffectManager::Mode mode = menu::ItemEffectManager::FALL_DOWN);
-  };
-}
diff --git a/src/state/play/item_manager.cpp b/src/state/play/item_manager.cpp
index 20698a8..de50484 100644
--- a/src/state/play/item_manager.cpp
+++ b/src/state/play/item_manager.cpp
@@ -17,17 +17,45 @@ namespace game::state::play
 {
   namespace
   {
-    int durability_animation_index_get(const resource::xml::Item& schema, const resource::xml::Anm2& anm2, int durability,
+    int durability_animation_index_get(const resource::xml::Schema& schema, const resource::xml::Anm2& anm2,
+                                       int durability, int durabilityMax)
+    {
+      if (durability >= durabilityMax) return -1;
+
+      auto animationName = schema.root()->animationChew + std::to_string(std::max(0, durability));
+      return anm2.animationMap.contains(animationName) ? anm2.animationMap.at(animationName) : -1;
+    }
+
+    int durability_animation_index_get(const resource::xml::Schema& schema, const Entity& entity, int durability,
                                        int durabilityMax)
     {
       if (durability >= durabilityMax) return -1;
 
-      auto animationName = schema.animations.chew + std::to_string(std::max(0, durability));
-      return anm2.animationMap.contains(animationName) ? anm2.animationMap.at(animationName) : -1;
+      auto animationName = schema.root()->animationChew + std::to_string(std::max(0, durability));
+      return entity.animationMap.contains(animationName) ? entity.animationMap.at(animationName) : -1;
+    }
+
+    bool is_finite(glm::vec4 value)
+    {
+      return std::isfinite(value.x) && std::isfinite(value.y) && std::isfinite(value.z) && std::isfinite(value.w) &&
+             value.z > 0.0f && value.w > 0.0f;
+    }
+
+    glm::vec2 item_spawn_position_get(Entity& character, const glm::vec4& bounds)
+    {
+      auto rect = character.rect();
+      if (!is_finite(rect)) rect = bounds;
+      auto center = glm::vec2(rect.x + rect.z * 0.5f, rect.y + rect.w);
+      auto radius = rect.w * 0.5f;
+      auto angle = glm::pi<float>() + math::random_max(glm::pi<float>());
+      auto position = center + glm::vec2(std::cos(angle), std::sin(angle)) * radius;
+
+      return {glm::clamp(position.x, bounds.x, bounds.x + bounds.z),
+              glm::clamp(position.y, bounds.y, bounds.y + bounds.w)};
     }
   }
 
-  void ItemManager::update(entity::Character& character, entity::Cursor& cursor, AreaManager& areaManager, Text& text,
+  void ItemManager::update(Entity& character, Entity& cursor, AreaManager& areaManager, Text& text,
                            const glm::vec4& bounds, Canvas& canvas)
   {
     static constexpr float ROTATION_MAX = 90.0f;
@@ -38,13 +66,33 @@ namespace game::state::play
 
     auto& schema = character.data.itemSchema;
     auto& cursorSchema = character.data.cursorSchema;
-    auto& area = character.data.areaSchema.areas.at(areaManager.get(character));
+    auto* cursorRoot = cursorSchema.root();
+    auto areaFallback = resource::xml::Schema::AreaEntry{.gravity = 0.95f, .friction = 0.80f, .airResistance = 0.975f};
+    auto* areaSelected = areaManager.get(character);
+    auto& area = areaSelected ? *areaSelected : areaFallback;
     auto& friction = area.friction;
     auto& airResistance = area.airResistance;
     auto& dialogue = character.data.dialogue;
     auto isOverCapacity = character.is_over_capacity();
+    auto dialogue_pool_entry_get = [&](resource::xml::Schema::Element::Type type)
+    {
+      auto* reference = dialogue.get(type);
+      return reference ? dialogue.dialogue_pool_entry_get(*reference) : nullptr;
+    };
+    auto particles_queue =
+        [&](resource::xml::Schema& particleSchema, resource::xml::Schema::Element::Type type, glm::vec2 position)
+    {
+      auto* root = particleSchema.root();
+      auto* actions = root ? particleSchema.child_get(*root, resource::xml::Schema::Element::ACTIONS) : nullptr;
+      auto* action = actions ? particleSchema.child_get(*actions, type) : nullptr;
+      if (!action) return;
+      for (auto* particle : particleSchema.children_get(*action, resource::xml::Schema::Element::PARTICLE))
+        if (particle && !particle->typeString.empty())
+          particles.push_back({.label = particle->typeString, .position = position});
+    };
 
-    auto cursorPosition = canvas.screen_position_convert(cursor.position);
+    auto cursorPosition =
+        cursor.entityType == AUTOCURSOR ? cursor.position : canvas.screen_position_convert(cursor.position);
     auto cursorDelta = cursorPosition - cursorPositionPrevious;
 
     auto isImguiCaptureMouse = ImGui::GetIO().WantCaptureMouse;
@@ -54,9 +102,22 @@ namespace game::state::play
     auto isMouseLeftReleased = ImGui::IsMouseReleased(ImGuiMouseButton_Left);
     auto isMouseRightClicked = ImGui::IsMouseClicked(ImGuiMouseButton_Right);
     auto isMouseRightDown = ImGui::IsMouseDown(ImGuiMouseButton_Right);
+    auto isAutomation = this->isAutomation;
 
     auto& io = ImGui::GetIO();
 
+    if (inputOverride)
+    {
+      isImguiCaptureMouse = inputOverride->isImguiCaptureMouse;
+      isMouseLeftClicked = inputOverride->isMouseLeftClicked;
+      isMouseLeftDown = inputOverride->isMouseLeftDown;
+      isMouseLeftReleased = inputOverride->isMouseLeftReleased;
+      isMouseRightClicked = inputOverride->isMouseRightClicked;
+      isMouseRightDown = inputOverride->isMouseRightDown;
+      isAutomation = isAutomation || inputOverride->isAutomation;
+      inputOverride.reset();
+    }
+
     if (isDisabled)
     {
       if (heldItemIndex != -1)
@@ -77,41 +138,42 @@ namespace game::state::play
 
     if (isJustItemHoveredStopped)
     {
-      cursor.queue_default_animation();
+      cursor.play({cursor.defaultAnimation});
       isJustItemHoveredStopped = false;
     }
 
     if (isJustItemHeldStopped || isJustItemThrown)
     {
-      cursor.queue_default_animation();
-      if (!isJustItemThrown && character.queuedPlay.empty()) character.queue_idle_animation();
+      cursor.play({cursor.defaultAnimation});
+      if (!isJustItemThrown && !character.is_animation_request())
+        character.play({.animation = character.idle_animation_get(), .appendID = character.animation_append_id_get()});
       isJustItemHeldStopped = false;
       isJustItemThrown = false;
     }
 
     isItemHoveredPrevious = isItemHovered;
     isItemHovered = false;
+    particles.clear();
     if (isItemHovered != isItemHoveredPrevious && !isItemHovered) isJustItemHoveredStopped = true;
 
     for (auto& id : queuedItemIDs)
     {
-      auto spawnBounds = character.rect();
-      auto position = glm::vec2(math::random_in_range(spawnBounds.x, spawnBounds.x + spawnBounds.z),
-                                math::random_in_range(spawnBounds.y, spawnBounds.y + spawnBounds.w));
+      auto position = item_spawn_position_get(character, bounds);
 
       auto& itemSchema = character.data.itemSchema;
       auto& item = itemSchema.items.at(id);
       auto& anm2 = itemSchema.anm2s.at(id);
-      auto durabilityMax = item.durability.value_or(itemSchema.durability);
+      auto durabilityMax = item.isDurability ? item.durability : itemSchema.durability;
       auto animationIndex = durability_animation_index_get(itemSchema, anm2, 0, durabilityMax);
       items.emplace_back(anm2, position, id, 0, animationIndex);
+      particles_queue(itemSchema, resource::xml::Schema::Element::SUMMON, position);
     }
     queuedItemIDs.clear();
 
     if (isMouseRightDown)
     {
-      auto animation = cursorSchema.animations.return_.get();
-      if (animation) cursor.queue_play({*animation});
+      if (cursorRoot)
+        if (auto animation = cursorRoot->animationReturn.get()) cursor.play({*animation});
     }
 
     if (auto heldItem = vector::find(items, heldItemIndex))
@@ -131,33 +193,47 @@ namespace game::state::play
 
       if (schema.categories[item.categoryID].isEdible)
       {
-        auto& durabilityMax = item.durability.has_value() ? *item.durability : schema.durability;
-        auto caloriesPerBite = item.calories.has_value() && durabilityMax > 0 ? *item.calories / durabilityMax : 0;
+        auto durabilityMax = item.isDurability ? item.durability : schema.durability;
+        auto caloriesPerBite = item.isCalories && durabilityMax > 0 ? item.calories / durabilityMax : 0;
         auto isCanEat = character.calories + caloriesPerBite <= character.max_capacity();
 
         if (isJustItemHeld)
         {
-          if (isCanEat)
-            text.set(dialogue.get(isOverCapacity ? dialogue.feedFull : dialogue.feed), character);
-          else if (caloriesPerBite > character.capacity)
-            text.set(dialogue.get(dialogue.lowCapacity), character);
-          else
-            text.set(dialogue.get(dialogue.full), character);
+          if (!isAutomation)
+          {
+            if (isCanEat)
+              text.set(dialogue_pool_entry_get(isOverCapacity ? resource::xml::Schema::Element::FEED_FULL
+                                                              : resource::xml::Schema::Element::FEED),
+                       character);
+            else if (caloriesPerBite > character.capacity)
+              text.set(dialogue_pool_entry_get(resource::xml::Schema::Element::LOW_CAPACITY), character);
+            else
+              text.set(dialogue_pool_entry_get(resource::xml::Schema::Element::FULL), character);
+          }
           isJustItemHeld = false;
         }
 
-        for (auto& eatArea : character.data.eatAreas)
+        for (auto* eatArea : character.data.eat_areas_get())
         {
           heldItem = vector::find(items, heldItemIndex);
           if (!heldItem) break;
 
-          auto rect = character.null_frame_rect(eatArea.nullID);
+          auto nullID = character.data.null_id_get(eatArea->null);
+          auto rect = character.null_frame_rect(nullID);
+          if (!is_finite(rect))
+          {
+            auto animationIndex =
+                character.animation_index_get(eatArea->animation + character.animation_append_id_get());
+            rect = character.null_frame_rect(nullID, animationIndex, 0.0f);
+          }
 
           if (isCanEat && math::is_point_in_rectf(rect, heldItem->position))
           {
-            character.queue_play({.animation = eatArea.animation, .speedMultiplier = character.eatSpeed});
+            character.play({.animation = eatArea->animation,
+                            .appendID = character.animation_append_id_get(),
+                            .speedMultiplier = character.eatSpeed});
 
-            if (character.playedEventID == eatArea.eventID)
+            if (character.playedEventID == character.data.event_id_get(eatArea->event))
             {
               heldItem->durability++;
               character.consume_played_event();
@@ -165,23 +241,24 @@ namespace game::state::play
               character.calories += caloriesPerBite;
               character.totalCaloriesConsumed += caloriesPerBite;
 
-              if (item.capacityBonus.has_value())
+              if (item.isCapacityBonus)
               {
-                character.capacity += *item.capacityBonus / durabilityMax;
-                character.capacity =
-                    glm::clamp(character.capacity, (float)character.data.capacityMin, (float)character.data.capacityMax);
+                character.capacity += item.capacityBonus / durabilityMax;
+                character.capacity = glm::clamp(character.capacity, (float)character.data.root()->capacityMinCalories,
+                                                (float)character.data.root()->capacityMaxCalories);
               }
-              if (item.eatSpeedBonus.has_value())
+              if (item.isEatSpeedBonus)
               {
-                character.eatSpeed += *item.eatSpeedBonus / durabilityMax;
-                character.eatSpeed = glm::clamp(character.eatSpeed, (float)character.data.eatSpeedMin,
-                                                (float)character.data.eatSpeedMax);
+                character.eatSpeed += item.eatSpeedBonus / durabilityMax;
+                character.eatSpeed = glm::clamp(character.eatSpeed, (float)character.data.root()->eatSpeedMinMultiplier,
+                                                (float)character.data.root()->eatSpeedMaxMultiplier);
               }
-              if (item.digestionBonus.has_value())
+              if (item.isDigestionBonus)
               {
-                character.digestionRate += *item.digestionBonus / durabilityMax;
-                character.digestionRate = glm::clamp(character.digestionRate, (float)character.data.digestionRateMin,
-                                                     (float)character.data.digestionRateMax);
+                character.digestionRate += item.digestionBonus / durabilityMax;
+                character.digestionRate =
+                    glm::clamp(character.digestionRate, (float)character.data.root()->digestionRateMin,
+                               (float)character.data.root()->digestionRateMax);
               }
 
               if (heldItem->durability >= durabilityMax)
@@ -195,7 +272,7 @@ namespace game::state::play
               {
                 auto animationIndex =
                     durability_animation_index_get(schema, *heldItem, heldItem->durability, durabilityMax);
-                heldItem->play(animationIndex, entity::Actor::SET);
+                heldItem->play({.index = animationIndex, .mode = Entity::SET});
               }
             }
           }
@@ -204,12 +281,12 @@ namespace game::state::play
           {
             if (fabs(delta.x) >= THROW_THRESHOLD || fabs(delta.y) >= THROW_THRESHOLD)
             {
-              cursorSchema.sounds.throw_.play();
-              text.set(dialogue.get(dialogue.throw_), character);
+              if (cursorRoot) cursorRoot->soundThrow.play();
+              if (!isAutomation) text.set(dialogue_pool_entry_get(resource::xml::Schema::Element::THROW), character);
               isJustItemThrown = true;
             }
-            else
-              cursorSchema.sounds.release.play();
+            else if (cursorRoot)
+              cursorRoot->soundRelease.play();
 
             heldItem->velocity -= delta;
             heldItemIndex = -1;
@@ -217,11 +294,14 @@ namespace game::state::play
           }
 
           // Food stolen
-          if (auto animation = character.animation_get(character.animation_name_convert(eatArea.animation));
+          if (auto animation = character.animation_get(eatArea->animation + character.animation_append_id_get());
               animation && character.is_playing(animation->name))
           {
             if (!math::is_point_in_rectf(rect, heldItem->position))
-              text.set(dialogue.get(isOverCapacity ? dialogue.foodTakenFull : dialogue.foodTaken), character);
+              if (!isAutomation)
+                text.set(dialogue_pool_entry_get(isOverCapacity ? resource::xml::Schema::Element::FOOD_TAKEN_FULL
+                                                                : resource::xml::Schema::Element::FOOD_TAKEN),
+                         character);
           }
         }
       }
@@ -229,7 +309,10 @@ namespace game::state::play
 
     if (auto animation = character.animation_get(); character.time >= animation->frameNum && isQueueFinishFood)
     {
-      text.set(dialogue.get(isOverCapacity ? dialogue.eatFull : dialogue.eat), character);
+      if (!isAutomation)
+        text.set(dialogue_pool_entry_get(isOverCapacity ? resource::xml::Schema::Element::EAT_FULL
+                                                        : resource::xml::Schema::Element::EAT),
+                 character);
       isQueueFinishFood = false;
     }
 
@@ -246,27 +329,31 @@ namespace game::state::play
       auto& schemaItem = schema.items[item.schemaID];
       auto& rotationOverride = item.overrides[item.rotationOverrideID];
       auto& rotation = *rotationOverride.frame.rotation;
-      auto& gravity = schemaItem.gravity.has_value() ? *schemaItem.gravity : area.gravity;
+      auto& gravity = schemaItem.isGravity ? schemaItem.gravity : area.gravity;
 
       item.update();
 
       if (math::is_point_in_rectf(item.rect(), cursorPosition) && !isImguiCaptureMouse)
       {
         isItemHovered = true;
-        if (auto animation = cursorSchema.animations.hover.get()) cursor.queue_play({*animation});
-        cursor.state = entity::Cursor::HOVER;
+        if (cursorRoot)
+          if (auto animation = cursorRoot->animationHover.get())
+            cursor.play({.animation = *animation, .transition = Entity::Transition::IF_IDLE});
+        cursor.cursorState = Entity::HOVER;
 
         if (isMouseLeftClicked)
         {
-          cursorSchema.sounds.grab.play();
+          if (cursorRoot) cursorRoot->soundGrab.play();
+          particles_queue(character.data.cursorSchema, resource::xml::Schema::Element::GRAB, cursorPosition);
           isJustItemHeld = true;
         }
 
         if (isMouseLeftDown)
         {
           isItemHeld = true;
-          if (auto animation = cursorSchema.animations.grab.get()) cursor.queue_play({*animation});
-          cursor.state = entity::Cursor::ACTION;
+          if (cursorRoot)
+            if (auto animation = cursorRoot->animationGrab.get()) cursor.play({*animation});
+          cursor.cursorState = Entity::ACTION;
           heldItemIndex = i;
           heldItemMoveIndex = i;
         }
@@ -274,10 +361,14 @@ namespace game::state::play
         if (isMouseRightClicked)
         {
           if (item.durability > 0)
-            schema.sounds.dispose.play();
+          {
+            schema.root()->soundDispose.play();
+            particles_queue(schema, resource::xml::Schema::Element::DISPOSE, item.position);
+          }
           else
           {
-            schema.sounds.return_.play();
+            schema.root()->soundReturn.play();
+            particles_queue(schema, resource::xml::Schema::Element::RETURN_, item.position);
             returnItemIDs.emplace_back(item.schemaID);
           }
 
@@ -303,7 +394,7 @@ namespace game::state::play
           item.angularVelocity *= friction;
           item.angularVelocity = -item.angularVelocity;
           rotation = -rotation;
-          schema.sounds.bounce.play();
+          schema.root()->soundBounce.play();
         }
 
         if (item.position.y <= bounds.y || item.position.y >= bounds.w)
@@ -331,7 +422,7 @@ namespace game::state::play
           {
             item.velocity.y = -item.velocity.y;
             item.angularVelocity *= friction;
-            schema.sounds.bounce.play();
+            schema.root()->soundBounce.play();
           }
 
           item.velocity.y *= friction;
diff --git a/src/state/play/item_manager.hpp b/src/state/play/item_manager.hpp
index ece4e2b..cc1850a 100644
--- a/src/state/play/item_manager.hpp
+++ b/src/state/play/item_manager.hpp
@@ -1,12 +1,12 @@
 #pragma once
 
-#include "../../entity/character.hpp"
-#include "../../entity/cursor.hpp"
-#include "../../entity/item.hpp"
+#include "../../entity.hpp"
 
 #include "area_manager.hpp"
 #include "text.hpp"
 
+#include <optional>
+
 namespace game::state::play
 {
   class ItemManager
@@ -15,7 +15,8 @@ namespace game::state::play
     static constexpr auto LIMIT = 100;
 
     bool isDisabled{};
-    std::vector<entity::Item> items{};
+    bool isAutomation{};
+    std::vector<Entity> items{};
     int heldItemIndex{-1};
     int queuedRemoveItemIndex{-1};
 
@@ -39,6 +40,26 @@ namespace game::state::play
     std::vector<int> queuedItemIDs{};
     std::vector<int> returnItemIDs{};
 
-    void update(entity::Character&, entity::Cursor&, AreaManager&, Text&, const glm::vec4& bounds, Canvas&);
+    struct Particle
+    {
+      std::string label{};
+      glm::vec2 position{};
+    };
+
+    struct Input
+    {
+      bool isImguiCaptureMouse{};
+      bool isMouseLeftClicked{};
+      bool isMouseLeftDown{};
+      bool isMouseLeftReleased{};
+      bool isMouseRightClicked{};
+      bool isMouseRightDown{};
+      bool isAutomation{};
+    };
+
+    std::optional<Input> inputOverride{};
+    std::vector<Particle> particles{};
+
+    void update(Entity&, Entity&, AreaManager&, Text&, const glm::vec4& bounds, Canvas&);
   };
 }
diff --git a/src/state/play/menu.cpp b/src/state/play/menu.cpp
index b487dc9..fdba823 100644
--- a/src/state/play/menu.cpp
+++ b/src/state/play/menu.cpp
@@ -5,48 +5,60 @@
 #include "../../util/imgui.hpp"
 #include "../../util/imgui/widget.hpp"
 
-#include <algorithm>
-
 using namespace game::util;
 using namespace game::util::imgui;
 using namespace game::resource::xml;
 
 namespace game::state::play
 {
-  void Menu::tick()
-  {
-    inventory.tick();
-    arcade.tick();
-  }
-
-  void Menu::update(Resources& resources, ItemManager& itemManager, entity::Character& character,
-                    entity::Cursor& cursor, Text& text, Canvas& canvas)
+  void Menu::update(Resources& resources, ItemManager& itemManager, Entity& character, Text& text, Autofeed& autofeed)
   {
     static constexpr auto WIDTH_MULTIPLIER = 0.30f;
+    static constexpr auto HALF_MULTIPLIER = 0.5f;
+    static constexpr auto BAR_DIVIDER_THICKNESS = 1.0f;
+    static constexpr auto PADDING_SIZE_MULTIPLIER = 2.0f;
+    static constexpr auto ZERO_FLOAT = 0.0f;
+    static constexpr auto ONE_FLOAT = 1.0f;
+    static constexpr auto MENU_STYLE_VAR_COUNT = 2;
+    static constexpr auto MENU_BAR_STYLE_VAR_COUNT = 4;
+    static constexpr auto MENU_BAR_FLAGS = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar |
+                                           ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
+                                           ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse;
 
     auto& schema = character.data.menuSchema;
     auto& strings = character.data.strings;
 
     auto style = ImGui::GetStyle();
     auto& io = ImGui::GetIO();
-    isDebugOpen = false;
 
     slide.update(isOpen, io.DeltaTime);
+    fullscreenSlide.update(isOpen && isFullscreen, io.DeltaTime);
 
     ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0);
     ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, style.FrameRounding);
 
     auto windowSize = imgui::to_ivec2(ImGui::GetMainViewport()->Size);
+    auto barSize =
+        ImVec2(imgui::side_bar_width_get(), windowSize.y - style.WindowPadding.y * PADDING_SIZE_MULTIPLIER);
+    auto fullscreenOffset = barSize.x;
 
-    auto size = ImVec2(windowSize.x * WIDTH_MULTIPLIER, windowSize.y - style.WindowPadding.y * 2);
+    auto normalSize =
+        ImVec2(windowSize.x * WIDTH_MULTIPLIER, windowSize.y - style.WindowPadding.y * PADDING_SIZE_MULTIPLIER);
+    auto fullscreenSize =
+        ImVec2(windowSize.x - fullscreenOffset, windowSize.y - style.WindowPadding.y * PADDING_SIZE_MULTIPLIER);
+    auto fullscreenT = fullscreenSlide.eased_get();
+    auto size = ImVec2(normalSize.x + (fullscreenSize.x - normalSize.x) * fullscreenT,
+                       normalSize.y + (fullscreenSize.y - normalSize.y) * fullscreenT);
     auto targetX = windowSize.x - size.x;
     auto t = slide.value_get();
     auto eased = slide.eased_get();
+    auto isFullscreenVisible = fullscreenSlide.value_get() > ZERO_FLOAT;
+    auto isFullscreenResizeSettled =
+        isFullscreen ? fullscreenSlide.value_get() >= ONE_FLOAT : fullscreenSlide.value_get() <= ZERO_FLOAT;
     auto posX = windowSize.x + (targetX - windowSize.x) * eased;
 
     auto pos = ImVec2(posX, style.WindowPadding.y);
-    auto barSize = ImVec2(ImGui::GetTextLineHeightWithSpacing(), windowSize.y - style.WindowPadding.y * 2);
-    auto barPos = ImVec2(pos.x - barSize.x - style.WindowPadding.x, style.WindowPadding.y);
+    auto barPos = ImVec2(pos.x - barSize.x, style.WindowPadding.y);
 
     if (slide.is_visible())
     {
@@ -62,19 +74,19 @@ namespace game::state::play
 
           if (WIDGET_FX(ImGui::BeginTabItem(strings.get(Strings::MenuTabInteract).c_str())))
           {
-            interact.update(resources, text, character);
+            interact.update(resources, text, character, isFullscreenVisible);
             ImGui::EndTabItem();
           }
 
-          if (WIDGET_FX(ImGui::BeginTabItem(strings.get(Strings::MenuTabArcade).c_str())))
+          if (WIDGET_FX(ImGui::BeginTabItem(strings.get(Strings::MenuTabGather).c_str())))
           {
-            arcade.update(resources, character, cursor, inventory, text, toasts);
+            gather.update(isFullscreen, isFullscreenResizeSettled);
             ImGui::EndTabItem();
           }
 
           if (WIDGET_FX(ImGui::BeginTabItem(strings.get(Strings::MenuTabInventory).c_str())))
           {
-            inventory.update(resources, itemManager, character);
+            inventory.update(resources, itemManager, character, autofeed);
             ImGui::EndTabItem();
           }
 
@@ -90,15 +102,6 @@ namespace game::state::play
             cheats.update(resources, character, inventory);
             ImGui::EndTabItem();
           }
-
-#if DEBUG
-          if (WIDGET_FX(ImGui::BeginTabItem("Debug")))
-          {
-            isDebugOpen = true;
-            debug.update(character, cursor, itemManager, canvas, text);
-            ImGui::EndTabItem();
-          }
-#endif
         }
         ImGui::EndTabBar();
       }
@@ -110,59 +113,84 @@ namespace game::state::play
 
     ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 0);
     ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2());
-    if (ImGui::Begin("##Menu Open Bar", nullptr,
-                     ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
-                         ImGuiWindowFlags_NoMove))
+    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2());
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowMinSize, barSize);
+    if (ImGui::Begin("##Menu Open Bar", nullptr, MENU_BAR_FLAGS))
     {
       auto buttonSize = ImGui::GetContentRegionAvail();
       auto cursorPos = ImGui::GetCursorScreenPos();
+      auto halfButtonSize = ImVec2(buttonSize.x, buttonSize.y * HALF_MULTIPLIER);
+      auto activeButtonSize = isOpen && !isFullscreenVisible ? halfButtonSize : buttonSize;
 
-      ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, style.WindowPadding);
-      auto result = WIDGET_FX(ImGui::Button("##MenuToggle", buttonSize));
+      auto tooltip_set = [&](const std::string& tooltip)
+      {
+        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, style.WindowPadding);
+        ImGui::SetItemTooltip("%s", tooltip.c_str());
+        ImGui::PopStyleVar();
+      };
 
+      auto isMainResult = WIDGET_FX(ImGui::Button("##MenuToggleNormal", activeButtonSize));
       if (t <= 0.0f || t >= 1.0f)
       {
-        ImGui::SetItemTooltip("%s", strings.get(isOpen ? Strings::MenuCloseTooltip : Strings::MenuOpenTooltip).c_str());
-        if (result)
+        tooltip_set(strings.get(isFullscreenVisible ? Strings::MenuRestoreTooltip
+                                             : isOpen ? Strings::MenuCloseTooltip
+                                                      : Strings::MenuOpenTooltip));
+        if (isMainResult)
         {
-          isOpen = !isOpen;
-
-          if (isOpen)
-            schema.sounds.open.play();
+          if (isFullscreenVisible)
+          {
+            if (isFullscreen) schema.root()->soundClose.play();
+            isFullscreen = false;
+          }
           else
-            schema.sounds.close.play();
+          {
+            isOpen = !isOpen;
+            isFullscreen = false;
+            if (isOpen)
+              schema.root()->soundOpen.play();
+            else
+              schema.root()->soundClose.play();
+          }
         }
-        if (!isOpen && t <= 0.0f && ImGui::IsItemHovered())
+        if (!isOpen && !isMainResult && ImGui::IsItemHovered())
         {
           isOpen = true;
-          schema.sounds.open.play();
+          isFullscreen = false;
+          schema.root()->soundOpen.play();
         }
       }
-      ImGui::PopStyleVar();
 
-      auto center = ImVec2(cursorPos.x + (buttonSize.x * 0.5f), cursorPos.y + (buttonSize.y * 0.5f));
-      auto half = std::min(buttonSize.x, buttonSize.y) * 0.22f;
-      ImVec2 tip;
-      ImVec2 baseA;
-      ImVec2 baseB;
-      if (isOpen)
+      auto fullscreenCursorPos = ImGui::GetCursorScreenPos();
+      auto isFullscreenResult = false;
+      if (isOpen && !isFullscreenVisible)
       {
-        tip = ImVec2(center.x + half, center.y);
-        baseA = ImVec2(center.x - half, center.y - half);
-        baseB = ImVec2(center.x - half, center.y + half);
-      }
-      else
-      {
-        tip = ImVec2(center.x - half, center.y);
-        baseA = ImVec2(center.x + half, center.y - half);
-        baseB = ImVec2(center.x + half, center.y + half);
+        isFullscreenResult = WIDGET_FX(ImGui::Button("##MenuToggleFullscreen", halfButtonSize));
+        if (t <= 0.0f || t >= 1.0f)
+        {
+          tooltip_set(strings.get(Strings::MenuOpenFullscreenTooltip));
+          if (isFullscreenResult)
+          {
+            isFullscreen = true;
+            schema.root()->soundOpen.play();
+          }
+        }
       }
 
-      auto color = ImGui::GetColorU32(ImGuiCol_Text);
-      ImGui::GetWindowDrawList()->AddTriangleFilled(tip, baseA, baseB, color);
+      auto direction = !isOpen ? imgui::TriangleDirection::LEFT : imgui::TriangleDirection::RIGHT;
+      imgui::triangle_draw(*ImGui::GetWindowDrawList(), cursorPos, activeButtonSize, direction,
+                           ImGui::GetColorU32(ImGuiCol_Text));
+      if (isOpen && !isFullscreenVisible)
+      {
+        auto separatorY = cursorPos.y + halfButtonSize.y;
+        ImGui::GetWindowDrawList()->AddLine(ImVec2(cursorPos.x, separatorY),
+                                            ImVec2(cursorPos.x + buttonSize.x, separatorY),
+                                            ImGui::GetColorU32(ImGuiCol_Separator), BAR_DIVIDER_THICKNESS);
+        imgui::triangle_draw(*ImGui::GetWindowDrawList(), fullscreenCursorPos, halfButtonSize,
+                             imgui::TriangleDirection::LEFT, ImGui::GetColorU32(ImGuiCol_Text));
+      }
     }
     ImGui::End();
-    ImGui::PopStyleVar(2);
-    ImGui::PopStyleVar(2);
+    ImGui::PopStyleVar(MENU_BAR_STYLE_VAR_COUNT);
+    ImGui::PopStyleVar(MENU_STYLE_VAR_COUNT);
   }
 }
diff --git a/src/state/play/menu.hpp b/src/state/play/menu.hpp
index c538ec6..b4218dc 100644
--- a/src/state/play/menu.hpp
+++ b/src/state/play/menu.hpp
@@ -4,13 +4,11 @@
 
 #include "../settings_menu.hpp"
 
-#include "menu/arcade.hpp"
 #include "cheats.hpp"
-#include "debug.hpp"
+#include "menu/gather.hpp"
 #include "menu/interact.hpp"
 #include "menu/inventory.hpp"
 #include "text.hpp"
-#include "menu/toasts.hpp"
 
 #include "../../util/imgui/window_slide.hpp"
 
@@ -19,13 +17,10 @@ namespace game::state::play
   class Menu
   {
   public:
-    menu::Arcade arcade;
     menu::Interact interact;
+    menu::Gather gather;
     Cheats cheats;
-    Debug debug;
     menu::Inventory inventory;
-    menu::Toasts toasts;
-
     state::SettingsMenu settingsMenu;
 
 #if DEBUG
@@ -35,10 +30,14 @@ namespace game::state::play
 #endif
 
     bool isOpen{true};
-    bool isDebugOpen{};
+    bool isFullscreen{};
+    static constexpr auto SLIDE_DURATION = 0.125f;
+    static constexpr auto SLIDE_CLOSED = 0.0f;
     util::imgui::WindowSlide slide{};
+    util::imgui::WindowSlide fullscreenSlide{SLIDE_DURATION, SLIDE_CLOSED};
 
-    void tick();
-    void update(Resources&, ItemManager&, entity::Character&, entity::Cursor&, Text&, Canvas&);
+    bool is_fullscreen_visible_get() const { return isOpen && (isFullscreen || fullscreenSlide.is_visible()); }
+    float fullscreen_alpha_get() const { return fullscreenSlide.eased_get(); }
+    void update(Resources&, ItemManager&, Entity&, Text&, Autofeed&);
   };
 }
diff --git a/src/state/play/menu/arcade.cpp b/src/state/play/menu/arcade.cpp
deleted file mode 100644
index e2e99e0..0000000
--- a/src/state/play/menu/arcade.cpp
+++ /dev/null
@@ -1,244 +0,0 @@
-#include "arcade.hpp"
-
-#include "../../../util/imgui/widget.hpp"
-
-using namespace game::util::imgui;
-using namespace game::resource::xml;
-
-namespace game::state::play::menu
-{
-  namespace
-  {
-    struct GameInfoStrings
-    {
-      Strings::Type name;
-      Strings::Type description;
-      Strings::Type howToPlay;
-    };
-  }
-
-  Arcade::Arcade(entity::Character& character) : skillCheck(character) {}
-
-  void Arcade::game_reset(entity::Character& character, Game gameCurrent)
-  {
-    switch (gameCurrent)
-    {
-      case SKILL_CHECK:
-        skillCheck.reset(character);
-        break;
-      case DUNGEON:
-        dungeon.reset(character);
-        break;
-      case ORBIT:
-        orbit.reset(character);
-        break;
-    }
-  }
-
-  void Arcade::tick()
-  {
-    skillCheck.tick();
-    dungeon.tick();
-    orbit.tick();
-  }
-
-  void Arcade::update(Resources& resources, entity::Character& character, entity::Cursor& cursor, Inventory& inventory,
-                      Text& text, Toasts& toasts)
-  {
-    auto available = ImGui::GetContentRegionAvail();
-    auto& strings = character.data.strings;
-    auto game_info_strings_get = [&](Game gameCurrent) -> GameInfoStrings
-    {
-      switch (gameCurrent)
-      {
-        case SKILL_CHECK:
-          return {Strings::ArcadeSkillCheckName, Strings::ArcadeSkillCheckDescription,
-                  Strings::ArcadeSkillCheckHowToPlay};
-        case DUNGEON:
-          return {Strings::ArcadeDungeonName, Strings::ArcadeDungeonDescription, Strings::ArcadeDungeonHowToPlay};
-        case ORBIT:
-          return {Strings::ArcadeOrbitName, Strings::ArcadeOrbitDescription, Strings::ArcadeOrbitHowToPlay};
-      }
-
-      return {Strings::ArcadeSkillCheckName, Strings::ArcadeSkillCheckDescription, Strings::ArcadeSkillCheckHowToPlay};
-    };
-    auto game_header_draw = [&](Game gameCurrent)
-    {
-      auto gameInfoStrings = game_info_strings_get(gameCurrent);
-      ImGui::PushFont(ImGui::GetFont(), resource::Font::HEADER_2);
-      ImGui::TextUnformatted(strings.get(gameInfoStrings.name).c_str());
-      ImGui::PopFont();
-    };
-
-    auto game_menu_draw = [&](Game gameCurrent)
-    {
-      constexpr auto GAME_CHILD_HEIGHT_MULTIPLIER = 7.0f;
-      constexpr auto GAME_DESCRIPTION_HEIGHT_MULTIPLIER = 4.75f;
-
-      auto lineHeight = ImGui::GetTextLineHeightWithSpacing();
-      auto gameChildHeight = lineHeight * GAME_CHILD_HEIGHT_MULTIPLIER;
-      auto gameDescriptionHeight = lineHeight * GAME_DESCRIPTION_HEIGHT_MULTIPLIER;
-      auto gameInfoStrings = game_info_strings_get(gameCurrent);
-      auto detailsChildID = [gameCurrent]()
-      {
-        switch (gameCurrent)
-        {
-          case SKILL_CHECK:
-            return "##ArcadeSkillCheckDescription";
-          case DUNGEON:
-            return "##ArcadeDungeonDescription";
-          case ORBIT:
-            return "##ArcadeOrbitDescription";
-        }
-
-        return "##ArcadeDescription";
-      }();
-
-      if (ImGui::BeginChild(gameInfoStrings.name, {0, gameChildHeight}, ImGuiChildFlags_Borders))
-      {
-        auto buttonWidth = (ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x) * 0.5f;
-
-        ImGui::BeginChild(detailsChildID, {0, gameDescriptionHeight});
-        game_header_draw(gameCurrent);
-        ImGui::Separator();
-        ImGui::TextWrapped("%s", strings.get(gameInfoStrings.description).c_str());
-        ImGui::EndChild();
-
-        ImGui::Separator();
-
-        if (WIDGET_FX(ImGui::Button(strings.get(Strings::ArcadePlayButton).c_str(), ImVec2(buttonWidth, 0))))
-        {
-          game_reset(character, gameCurrent);
-          game = gameCurrent;
-          state = GAMEPLAY;
-        }
-        ImGui::SameLine();
-        if (WIDGET_FX(ImGui::Button(strings.get(Strings::ArcadeInfoButton).c_str(), ImVec2(buttonWidth, 0))))
-        {
-          game = gameCurrent;
-          state = INFO;
-        }
-      }
-      ImGui::EndChild();
-    };
-
-    auto game_info_sections_draw = [&](Game gameCurrent)
-    {
-      auto gameInfoStrings = game_info_strings_get(gameCurrent);
-
-      ImGui::PushFont(ImGui::GetFont(), resource::Font::HEADER_1);
-      ImGui::TextWrapped("%s", strings.get(Strings::ArcadeHowToPlay).c_str());
-      ImGui::PopFont();
-      ImGui::Separator();
-      ImGui::PushFont(ImGui::GetFont(), resource::Font::NORMAL);
-      ImGui::TextWrapped("%s", strings.get(gameInfoStrings.howToPlay).c_str());
-      ImGui::PopFont();
-
-      ImGui::PushFont(ImGui::GetFont(), resource::Font::HEADER_1);
-      ImGui::TextWrapped("%s", strings.get(Strings::ArcadeStats).c_str());
-      ImGui::PopFont();
-      ImGui::Separator();
-    };
-
-    auto game_stats_draw = [&](Game gameCurrent)
-    {
-      switch (gameCurrent)
-      {
-        case SKILL_CHECK:
-        {
-          auto& schema = character.data.skillCheckSchema;
-
-          ImGui::Text(strings.get(Strings::ArcadeBestScoreComboFormat).c_str(), skillCheck.highScore,
-                      skillCheck.bestCombo);
-          ImGui::Text(strings.get(Strings::ArcadeTotalSkillChecksFormat).c_str(), skillCheck.totalPlays);
-
-          for (int i = 0; i < (int)schema.grades.size(); i++)
-          {
-            auto& grade = schema.grades[i];
-            ImGui::Text("%s: %i", grade.namePlural.c_str(), skillCheck.gradeCounts[i]);
-          }
-
-          ImGui::Text(strings.get(Strings::ArcadeAccuracyFormat).c_str(), skillCheck.accuracy_score_get(character));
-          break;
-        }
-
-        case DUNGEON:
-          break;
-
-        case ORBIT:
-          break;
-      }
-    };
-    auto game_info_draw = [&](Game gameCurrent)
-    {
-      game_header_draw(gameCurrent);
-      ImGui::Separator();
-      game_info_sections_draw(gameCurrent);
-      game_stats_draw(gameCurrent);
-    };
-
-    switch (state)
-    {
-      case GAMEPLAY:
-        switch (game)
-        {
-          case SKILL_CHECK:
-            if (skillCheck.update(resources, character, inventory, text, toasts))
-            {
-              game_reset(character, SKILL_CHECK);
-              state = MENU;
-            }
-            break;
-
-          case DUNGEON:
-            if (dungeon.update(character))
-            {
-              game_reset(character, DUNGEON);
-              state = MENU;
-            }
-            break;
-
-          case ORBIT:
-            if (orbit.update(resources, character, cursor, inventory, text, toasts))
-            {
-              game_reset(character, ORBIT);
-              state = MENU;
-            }
-            break;
-        }
-        return;
-
-      case MENU:
-      case INFO:
-        break;
-    }
-
-    auto buttonHeight = ImGui::GetFrameHeightWithSpacing();
-    auto childSize = ImVec2(available.x, std::max(0.0f, available.y - buttonHeight));
-
-    if (ImGui::BeginChild("##Arcade Child", childSize))
-    {
-      switch (state)
-      {
-        case MENU:
-          game_menu_draw(ORBIT);
-          //game_menu_draw(DUNGEON);
-          game_menu_draw(SKILL_CHECK);
-          break;
-
-        case INFO:
-          game_info_draw(game);
-          break;
-
-        case GAMEPLAY:
-          break;
-      }
-    }
-    ImGui::EndChild();
-
-    if (state == INFO)
-    {
-      if (WIDGET_FX(ImGui::Button(strings.get(Strings::ArcadeBackButton).c_str()))) state = MENU;
-    }
-  }
-}
diff --git a/src/state/play/menu/arcade.hpp b/src/state/play/menu/arcade.hpp
deleted file mode 100644
index 8c6c644..0000000
--- a/src/state/play/menu/arcade.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#pragma once
-
-#include "arcade/dungeon.hpp"
-#include "arcade/orbit.hpp"
-#include "arcade/skill_check.hpp"
-#include "toasts.hpp"
-
-namespace game::state::play::menu
-{
-  class Arcade
-  {
-  public:
-    enum Game
-    {
-      SKILL_CHECK,
-      DUNGEON,
-      ORBIT
-    };
-
-    enum State
-    {
-      MENU,
-      GAMEPLAY,
-      INFO
-    };
-
-    arcade::SkillCheck skillCheck{};
-    arcade::Dungeon dungeon{};
-    arcade::Orbit orbit{};
-    Game game{SKILL_CHECK};
-    State state{MENU};
-
-    Arcade() = default;
-    Arcade(entity::Character&);
-
-    void game_reset(entity::Character&, Game);
-    void tick();
-    void update(Resources&, entity::Character&, entity::Cursor&, Inventory&, Text&, Toasts&);
-  };
-}
diff --git a/src/state/play/menu/arcade/dungeon.cpp b/src/state/play/menu/arcade/dungeon.cpp
deleted file mode 100644
index 0223a53..0000000
--- a/src/state/play/menu/arcade/dungeon.cpp
+++ /dev/null
@@ -1,310 +0,0 @@
-#include "dungeon.hpp"
-
-#include "../../../../resource/font.hpp"
-#include "../../../../resource/xml/strings.hpp"
-#include "../../../../util/imgui/widget.hpp"
-#include "../../../../util/math.hpp"
-
-#include <format>
-#include <imgui.h>
-
-using namespace game::util::imgui;
-using namespace game::resource::xml;
-
-namespace game::state::play::menu::arcade
-{
-  int Dungeon::tile_value_get(const Tile& tile) const { return (int)tile.value; }
-  bool Dungeon::tile_value_counts_toward_sum(const Tile& tile) const
-  {
-    return (tile.value >= Tile::VALUE_0 && tile.value <= Tile::VALUE_13) || tile.value == Tile::MINE;
-  }
-  bool Dungeon::tile_is_scroll(const Tile& tile) const { return tile.value == Tile::SCROLL; }
-  const char* Dungeon::tile_flag_text_get(const Tile& tile) const
-  {
-    switch (tile.flagValue)
-    {
-      case Tile::FLAG_NONE:
-        return nullptr;
-      case Tile::FLAG_MINE:
-        return "M";
-      case Tile::FLAG_1:
-        return "1";
-      case Tile::FLAG_2:
-        return "2";
-      case Tile::FLAG_3:
-        return "3";
-      case Tile::FLAG_4:
-        return "4";
-      case Tile::FLAG_5:
-        return "5";
-      case Tile::FLAG_6:
-        return "6";
-      case Tile::FLAG_7:
-        return "7";
-      case Tile::FLAG_8:
-        return "8";
-      case Tile::FLAG_9:
-        return "9";
-      case Tile::FLAG_10:
-        return "10";
-      case Tile::FLAG_11:
-        return "11";
-      case Tile::FLAG_12:
-        return "12";
-      case Tile::FLAG_13:
-        return "13";
-      case Tile::FLAG_QUESTION:
-        return "?";
-    }
-
-    return nullptr;
-  }
-
-  int Dungeon::surrounding_value_sum_get(int row, int column) const
-  {
-    auto sum = 0;
-    for (int rowOffset = -1; rowOffset <= 1; rowOffset++)
-      for (int columnOffset = -1; columnOffset <= 1; columnOffset++)
-      {
-        if (rowOffset == 0 && columnOffset == 0) continue;
-
-        auto neighborRow = row + rowOffset;
-        auto neighborColumn = column + columnOffset;
-        if (neighborRow < 0 || neighborRow >= GRID_ROWS || neighborColumn < 0 || neighborColumn >= GRID_COLUMNS)
-          continue;
-
-        auto& neighbor = tiles[neighborRow * GRID_COLUMNS + neighborColumn];
-        if (!tile_value_counts_toward_sum(neighbor)) continue;
-
-        sum += tile_value_get(neighbor);
-      }
-
-    return sum;
-  }
-
-  void Dungeon::reveal_diamond(int row, int column, int radius)
-  {
-    for (int rowOffset = -radius; rowOffset <= radius; rowOffset++)
-      for (int columnOffset = -radius; columnOffset <= radius; columnOffset++)
-      {
-        if (std::abs(rowOffset) + std::abs(columnOffset) > radius) continue;
-
-        auto targetRow = row + rowOffset;
-        auto targetColumn = column + columnOffset;
-        if (targetRow < 0 || targetRow >= GRID_ROWS || targetColumn < 0 || targetColumn >= GRID_COLUMNS) continue;
-
-        auto& tile = tiles[targetRow * GRID_COLUMNS + targetColumn];
-        if (tile.state == Tile::HIDDEN)
-        {
-          tile.state = Tile::SHOWN;
-          tile.flagValue = Tile::FLAG_NONE;
-        }
-      }
-  }
-
-  void Dungeon::reset(entity::Character&)
-  {
-    tiles.assign(GRID_ROWS * GRID_COLUMNS, Tile{});
-    score = 0;
-    for (auto& tile : tiles)
-    {
-      tile.value = game::util::math::random_percent_roll(5.0f) ? Tile::MINE
-                                                               : (Tile::Value)(int)game::util::math::random_max(14.0f);
-      tile.state = Tile::HIDDEN;
-      tile.flagValue = Tile::FLAG_NONE;
-    }
-
-    if (!tiles.empty()) tiles[(int)game::util::math::random_max((float)tiles.size())].value = Tile::SCROLL;
-  }
-
-  void Dungeon::tick() {}
-
-  bool Dungeon::update(entity::Character& character)
-  {
-    auto& strings = character.data.strings;
-    constexpr float GRID_SPACING = 1.0f;
-    auto& style = ImGui::GetStyle();
-
-    if (tiles.size() != GRID_ROWS * GRID_COLUMNS) reset(character);
-
-    auto contentRegionAvail = ImGui::GetContentRegionAvail();
-    auto childSize =
-        ImVec2(contentRegionAvail.x,
-               std::max(0.0f, contentRegionAvail.y - ImGui::GetFrameHeightWithSpacing() - style.WindowPadding.y));
-
-    if (ImGui::BeginChild("##DungeonGrid", childSize))
-    {
-      auto drawList = ImGui::GetWindowDrawList();
-      auto childAvail = ImGui::GetContentRegionAvail();
-      auto cellWidth = std::max(1.0f, (childAvail.x - GRID_SPACING * (GRID_COLUMNS - 1)) / (float)GRID_COLUMNS);
-      auto cellHeight = std::max(1.0f, (childAvail.y - GRID_SPACING * (GRID_ROWS - 1)) / (float)GRID_ROWS);
-      auto cellSize = std::floor(std::min(cellWidth, cellHeight));
-      auto gridWidth = cellSize * (float)GRID_COLUMNS + GRID_SPACING * (GRID_COLUMNS - 1);
-      auto gridHeight = cellSize * (float)GRID_ROWS + GRID_SPACING * (GRID_ROWS - 1);
-      auto cursor = ImGui::GetCursorPos();
-      auto offsetX = std::max(0.0f, (childAvail.x - gridWidth) * 0.5f);
-      auto offsetY = std::max(0.0f, (childAvail.y - gridHeight) * 0.5f);
-
-      ImGui::SetCursorPos(ImVec2(cursor.x + offsetX, cursor.y + offsetY));
-      ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 0.0f);
-      ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(GRID_SPACING, GRID_SPACING));
-
-      for (int row = 0; row < GRID_ROWS; row++)
-      {
-        for (int column = 0; column < GRID_COLUMNS; column++)
-        {
-          auto tileID = row * GRID_COLUMNS + column;
-          auto& tile = tiles[tileID];
-          auto tileValue = tile_value_get(tile);
-
-          ImGui::PushID(tileID);
-          if (tile.state != Tile::HIDDEN)
-          {
-            auto buttonColor = style.Colors[ImGuiCol_WindowBg];
-            ImGui::PushStyleColor(ImGuiCol_Button, buttonColor);
-            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, buttonColor);
-            ImGui::PushStyleColor(ImGuiCol_ButtonActive, buttonColor);
-          }
-          auto isLeftPressed = WIDGET_FX(ImGui::Button("##DungeonCell", ImVec2(cellSize, cellSize)));
-          auto isPopupOpen = ImGui::BeginPopupContextItem("##DungeonFlagMenu");
-          if (isPopupOpen)
-          {
-            if (ImGui::Button("M", ImVec2(36.0f, 0.0f)))
-            {
-              tile.flagValue = Tile::FLAG_MINE;
-              ImGui::CloseCurrentPopup();
-            }
-            ImGui::SameLine();
-            for (int flagValue = Tile::FLAG_1; flagValue <= Tile::FLAG_13; flagValue++)
-            {
-              auto flagText = std::format("{}", flagValue);
-              if (ImGui::Button(flagText.c_str(), ImVec2(36.0f, 0.0f)))
-              {
-                tile.flagValue = (Tile::FlagValue)flagValue;
-                ImGui::CloseCurrentPopup();
-              }
-              if (flagValue % 4 != 0 && flagValue != Tile::FLAG_13) ImGui::SameLine();
-            }
-            if (ImGui::Button("?", ImVec2(36.0f, 0.0f)))
-            {
-              tile.flagValue = Tile::FLAG_QUESTION;
-              ImGui::CloseCurrentPopup();
-            }
-            ImGui::SameLine();
-            if (ImGui::Button("Clear"))
-            {
-              tile.flagValue = Tile::FLAG_NONE;
-              ImGui::CloseCurrentPopup();
-            }
-            ImGui::EndPopup();
-          }
-          auto rectMin = ImGui::GetItemRectMin();
-          auto rectMax = ImGui::GetItemRectMax();
-          if (tile.state != Tile::HIDDEN) ImGui::PopStyleColor(3);
-          ImGui::PopID();
-
-          if (isLeftPressed)
-          {
-            switch (tile.state)
-            {
-              case Tile::HIDDEN:
-                tile.state = Tile::SHOWN;
-                tile.flagValue = Tile::FLAG_NONE;
-                if (tile_is_scroll(tile))
-                {
-                  reveal_diamond(row, column, 2);
-                  tile.value = Tile::VALUE_0;
-                  tile.state = Tile::SHOWN;
-                }
-                break;
-              case Tile::SHOWN:
-                tile.flagValue = Tile::FLAG_NONE;
-                if (tile_is_scroll(tile))
-                {
-                  reveal_diamond(row, column, 2);
-                  tile.value = Tile::VALUE_0;
-                  tile.state = Tile::SHOWN;
-                }
-                else if (tileValue > 0)
-                {
-                  tile.state = Tile::CORPSE;
-                  score += tileValue;
-                }
-                break;
-              case Tile::CORPSE:
-                tile.value = Tile::VALUE_0;
-                tile.state = Tile::SHOWN;
-                tile.flagValue = Tile::FLAG_NONE;
-                break;
-            }
-          }
-
-          std::string tileText{};
-          auto textColor = IM_COL32(255, 255, 255, 255);
-          if (tile_is_scroll(tile))
-          {
-            tileText = "!";
-            if (tile.state == Tile::CORPSE)
-              textColor = IM_COL32(255, 230, 64, 255);
-            else
-              textColor = IM_COL32(255, 255, 255, 255);
-          }
-          else if (tile.state == Tile::HIDDEN)
-          {
-            if (auto flagText = tile_flag_text_get(tile))
-            {
-              tileText = flagText;
-              textColor = IM_COL32(64, 128, 255, 255);
-            }
-          }
-          else
-            switch (tile.state)
-            {
-              case Tile::HIDDEN:
-                break;
-              case Tile::SHOWN:
-                if (tileValue == 0)
-                {
-                  auto surroundingSum = surrounding_value_sum_get(row, column);
-                  if (surroundingSum > 0) tileText = std::format("{}", surroundingSum);
-                }
-                else
-                {
-                  tileText = std::format("{}", tileValue);
-                  textColor = IM_COL32(255, 64, 64, 255);
-                }
-                break;
-              case Tile::CORPSE:
-                if (tileValue == 0)
-                {
-                  auto surroundingSum = surrounding_value_sum_get(row, column);
-                  if (surroundingSum > 0) tileText = std::format("{}", surroundingSum);
-                }
-                else
-                {
-                  tileText = std::format("{}", tileValue);
-                  textColor = IM_COL32(255, 230, 64, 255);
-                }
-                break;
-            }
-
-          if (!tileText.empty())
-          {
-            auto textSize = ImGui::CalcTextSize(tileText.c_str());
-            auto textPosition = ImVec2(rectMin.x + (rectMax.x - rectMin.x - textSize.x) * 0.5f,
-                                       rectMin.y + (rectMax.y - rectMin.y - textSize.y) * 0.5f);
-            drawList->AddText(textPosition, textColor, tileText.c_str());
-          }
-
-          if (column + 1 < GRID_COLUMNS) ImGui::SameLine(0.0f, GRID_SPACING);
-        }
-      }
-
-      ImGui::PopStyleVar(2);
-    }
-    ImGui::EndChild();
-    ImGui::Text(strings.get(Strings::ArcadeScoreFormat).c_str(), score);
-
-    return WIDGET_FX(ImGui::Button(strings.get(Strings::ArcadeBackButton).c_str()));
-  }
-}
diff --git a/src/state/play/menu/arcade/dungeon.hpp b/src/state/play/menu/arcade/dungeon.hpp
deleted file mode 100644
index 7d04ac1..0000000
--- a/src/state/play/menu/arcade/dungeon.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-#pragma once
-
-#include "../../../../entity/character.hpp"
-
-#include <vector>
-
-namespace game::state::play::menu::arcade
-{
-  class Dungeon
-  {
-  public:
-    struct Tile
-    {
-      enum State
-      {
-        HIDDEN,
-        SHOWN,
-        CORPSE
-      };
-
-      enum FlagValue
-      {
-        FLAG_NONE,
-        FLAG_1,
-        FLAG_2,
-        FLAG_3,
-        FLAG_4,
-        FLAG_5,
-        FLAG_6,
-        FLAG_7,
-        FLAG_8,
-        FLAG_9,
-        FLAG_10,
-        FLAG_11,
-        FLAG_12,
-        FLAG_13,
-        FLAG_MINE,
-        FLAG_QUESTION
-      };
-
-      enum Value
-      {
-        VALUE_0,
-        VALUE_1,
-        VALUE_2,
-        VALUE_3,
-        VALUE_4,
-        VALUE_5,
-        VALUE_6,
-        VALUE_7,
-        VALUE_8,
-        VALUE_9,
-        VALUE_10,
-        VALUE_11,
-        VALUE_12,
-        VALUE_13,
-        MINE = 100,
-        SCROLL = 101
-      };
-
-      Value value{VALUE_0};
-      State state{HIDDEN};
-      FlagValue flagValue{FLAG_NONE};
-    };
-
-    static constexpr int GRID_ROWS = 13;
-    static constexpr int GRID_COLUMNS = 13;
-
-    std::vector<Tile> tiles{};
-    int score{};
-
-    int tile_value_get(const Tile&) const;
-    int surrounding_value_sum_get(int row, int column) const;
-    bool tile_value_counts_toward_sum(const Tile&) const;
-    bool tile_is_scroll(const Tile&) const;
-    const char* tile_flag_text_get(const Tile&) const;
-    void reveal_diamond(int row, int column, int radius);
-    void reset(entity::Character&);
-    void tick();
-    bool update(entity::Character&);
-  };
-}
diff --git a/src/state/play/menu/arcade/orbit.cpp b/src/state/play/menu/arcade/orbit.cpp
deleted file mode 100644
index 13d1365..0000000
--- a/src/state/play/menu/arcade/orbit.cpp
+++ /dev/null
@@ -1,605 +0,0 @@
-#include "orbit.hpp"
-
-#include "../../../../util/imgui.hpp"
-#include "../../../../util/imgui/widget.hpp"
-#include "../../../../util/math.hpp"
-
-#include <algorithm>
-#include <cmath>
-#include <format>
-#include <glm/gtc/constants.hpp>
-#include <imgui.h>
-
-using namespace game::util::imgui;
-using namespace game::resource::xml;
-using namespace game::util;
-using namespace glm;
-
-namespace game::state::play::menu::arcade
-{
-  namespace
-  {
-    enum SpawnSide
-    {
-      TOP,
-      RIGHT,
-      BOTTOM,
-      LEFT
-    };
-
-    bool is_rect_overlapping(const glm::vec4& left, const glm::vec4& right)
-    {
-      return left.x < right.x + right.z && left.x + left.z > right.x && left.y < right.y + right.w &&
-             left.y + left.w > right.y;
-    }
-
-    void target_tick(Orbit::Entity& entity, const glm::vec2& target, float acceleration)
-    {
-      auto delta = target - entity.position;
-      auto distance = glm::length(delta);
-
-      if (distance <= 0.001f)
-      {
-        entity.position = target;
-        entity.velocity *= 0.5f;
-        if (glm::length(entity.velocity) <= 0.001f) entity.velocity = {};
-        return;
-      }
-
-      auto maxSpeed = std::max(acceleration * 8.0f, 1.0f);
-      auto desiredVelocity = glm::normalize(delta) * std::min(distance * 0.35f, maxSpeed);
-      auto steering = desiredVelocity - entity.velocity;
-      auto steeringLength = glm::length(steering);
-      if (steeringLength > acceleration) steering = (steering / steeringLength) * acceleration;
-
-      entity.velocity += steering;
-
-      auto velocityLength = glm::length(entity.velocity);
-      if (velocityLength > maxSpeed) entity.velocity = (entity.velocity / velocityLength) * maxSpeed;
-
-      entity.position += entity.velocity;
-
-      if (glm::distance(entity.position, target) <= maxSpeed)
-      {
-        entity.position = glm::mix(entity.position, target, 0.15f);
-      }
-    }
-
-    void follower_angles_refresh(std::vector<Orbit::Entity>& entities)
-    {
-      std::vector<Orbit::Entity*> followers{};
-      for (auto& entity : entities)
-        if (entity.type == Orbit::Entity::FOLLOWER) followers.emplace_back(&entity);
-
-      if (followers.empty()) return;
-
-      std::sort(followers.begin(), followers.end(),
-                [](const Orbit::Entity* left, const Orbit::Entity* right) { return left->colorID < right->colorID; });
-
-      auto baseAngle = followers.front()->orbitAngle;
-      auto spacing = glm::two_pi<float>() / (float)followers.size();
-
-      for (int i = 0; i < (int)followers.size(); i++)
-        followers[i]->orbitAngle = baseAngle + spacing * (float)i;
-    }
-
-    const glm::vec3* color_value_get(const resource::xml::Orbit& schema, int colorID)
-    {
-      if (colorID < 0 || colorID >= (int)schema.colors.size()) return nullptr;
-      return &schema.colors[colorID].value;
-    }
-
-    int random_available_color_get(const resource::xml::Orbit& schema, int level)
-    {
-      auto availableCount = std::min(level, (int)schema.colors.size());
-      if (availableCount <= 0) return -1;
-      return (int)math::random_max((float)availableCount);
-    }
-
-    int unlocked_level_get(const resource::xml::Orbit& schema, int score)
-    {
-      int unlockedLevel = 0;
-
-      for (auto& color : schema.colors)
-      {
-        if (score >= color.scoreThreshold)
-          unlockedLevel++;
-        else
-          break;
-      }
-
-      return std::max(1, unlockedLevel);
-    }
-
-    void color_override_set(Orbit::Entity& entity, const resource::xml::Orbit& schema, int colorID,
-                            const std::string& layerName)
-    {
-      auto color = color_value_get(schema, colorID);
-      if (!color) return;
-      if (!entity.layerMap.contains(layerName)) return;
-
-      entity::Actor::Override override_{entity.layerMap.at(layerName), Anm2::LAYER, entity::Actor::Override::SET};
-      override_.frame.tint.x = color->r;
-      override_.frame.tint.y = color->g;
-      override_.frame.tint.z = color->b;
-      entity.overrides.emplace_back(std::move(override_));
-    }
-
-    void idle_queue(Orbit::Entity& entity)
-    {
-      if (!entity.animationIdle.empty())
-        entity.queue_play({.animation = entity.animationIdle, .isPlayAfterAnimation = true});
-    }
-
-    void spawn_animation_play(Orbit::Entity& entity)
-    {
-      if (!entity.animationSpawn.empty())
-      {
-        entity.play(entity.animationSpawn, entity::Actor::PLAY_FORCE);
-        idle_queue(entity);
-      }
-    }
-  }
-
-  void Orbit::spawn(entity::Character& character, Orbit::Entity::Type type, int colorID)
-  {
-    auto& schema = character.data.orbitSchema;
-
-    switch (type)
-    {
-      case Entity::PLAYER:
-        if (!schema.player.anm2.is_valid()) return;
-        entities.emplace_back(schema.player.anm2, Entity::PLAYER);
-        entities.back().position = centerPosition;
-        entities.back().animationIdle = schema.player.animations.idle;
-        entities.back().animationSpawn = schema.player.animations.spawn;
-        entities.back().animationDeath = schema.player.animations.death;
-        entities.back().hitboxNull = schema.player.hitboxNull;
-        spawn_animation_play(entities.back());
-        return;
-      case Entity::FOLLOWER:
-      {
-        if (!schema.follower.anm2.is_valid()) return;
-        if (colorID < 0 || colorID >= (int)schema.colors.size()) return;
-
-        Entity follower{schema.follower.anm2, Entity::FOLLOWER};
-        follower.colorID = colorID;
-        follower.orbitAngle = 0.0f;
-        follower.position = centerPosition;
-        follower.animationIdle = schema.follower.animations.idle;
-        follower.animationSpawn = schema.follower.animations.spawn;
-        follower.animationDeath = schema.follower.animations.death;
-        follower.hitboxNull = schema.follower.hitboxNull;
-        color_override_set(follower, schema, colorID, schema.follower.overrideTintLayer);
-        spawn_animation_play(follower);
-
-        entities.emplace_back(std::move(follower));
-        follower_angles_refresh(entities);
-        return;
-      }
-      case Entity::ENEMY:
-      {
-        if (!schema.enemy.anm2.is_valid()) return;
-
-        Entity enemy{schema.enemy.anm2, Entity::ENEMY};
-        enemy.colorID = colorID;
-        enemy.animationIdle = schema.enemy.animations.idle;
-        enemy.animationSpawn = schema.enemy.animations.spawn;
-        enemy.animationDeath = schema.enemy.animations.death;
-        enemy.hitboxNull = schema.enemy.hitboxNull;
-        color_override_set(enemy, schema, colorID, schema.enemy.overrideTintLayer);
-        spawn_animation_play(enemy);
-
-        auto rect = enemy.rect();
-        auto width = rect.z;
-        auto height = rect.w;
-        auto side = (SpawnSide)math::random_max(4.0f);
-        switch (side)
-        {
-          case TOP:
-            enemy.position = vec2(math::random_max(canvas.size.x), -height - schema.enemy.spawnPadding);
-            break;
-          case RIGHT:
-            enemy.position = vec2(canvas.size.x + width + schema.enemy.spawnPadding, math::random_max(canvas.size.y));
-            break;
-          case BOTTOM:
-            enemy.position = vec2(math::random_max(canvas.size.x), canvas.size.y + height + schema.enemy.spawnPadding);
-            break;
-          case LEFT:
-            enemy.position = vec2(-width - schema.enemy.spawnPadding, math::random_max(canvas.size.y));
-            break;
-        }
-
-        entities.emplace_back(std::move(enemy));
-
-        if (schema.warning.anm2.is_valid())
-        {
-          Entity warning{schema.warning.anm2, Entity::WARNING};
-          warning.colorID = colorID;
-          color_override_set(warning, schema, colorID, schema.warning.overrideTintLayer);
-
-          auto warningRect = warning.rect();
-          auto warningWidth = warningRect.z;
-          auto warningHeight = warningRect.w;
-
-          switch (side)
-          {
-            case TOP:
-              warning.position = vec2(glm::clamp(entities.back().position.x, warningWidth * 0.5f,
-                                                 (float)canvas.size.x - warningWidth * 0.5f),
-                                      warningHeight * 0.5f);
-              break;
-            case RIGHT:
-              warning.position = vec2((float)canvas.size.x - warningWidth * 0.5f,
-                                      glm::clamp(entities.back().position.y, warningHeight * 0.5f,
-                                                 (float)canvas.size.y - warningHeight * 0.5f));
-              break;
-            case BOTTOM:
-              warning.position = vec2(glm::clamp(entities.back().position.x, warningWidth * 0.5f,
-                                                 (float)canvas.size.x - warningWidth * 0.5f),
-                                      (float)canvas.size.y - warningHeight * 0.5f);
-              break;
-            case LEFT:
-              warning.position = vec2(warningWidth * 0.5f, glm::clamp(entities.back().position.y, warningHeight * 0.5f,
-                                                                      (float)canvas.size.y - warningHeight * 0.5f));
-              break;
-          }
-
-          entities.emplace_back(std::move(warning));
-        }
-        return;
-      }
-      case Entity::WARNING:
-      default:
-        return;
-    }
-  }
-
-  void Orbit::reset(entity::Character& character)
-  {
-    entities.clear();
-    sounds = &character.data.orbitSchema.sounds;
-    cursorPosition = {};
-    centerPosition = {};
-    level = 0;
-    highScoreAtRunStart = highScore;
-    score = 0;
-    isHighScoreAchievedThisRun = false;
-    itemEffectManager = {};
-    followerRadius = {};
-    playerTargetAcceleration = {};
-    followerTargetAcceleration = {};
-    playerTimeAfterHurt = {};
-    enemySpeed = {};
-    enemySpeedScoreBonus = {};
-    enemySpeedGainBase = {};
-    enemySpeedGainScoreBonus = {};
-    rotationSpeed = {};
-    rotationSpeedMax = {};
-    rotationSpeedFriction = {};
-    startTimer = character.data.orbitSchema.startTime;
-    hurtTimer = 0;
-    isPlayerDying = false;
-    isRotateLeft = false;
-    isRotateRight = false;
-  }
-
-  void Orbit::tick()
-  {
-    for (auto& entity : entities)
-      entity.tick();
-
-    itemEffectManager.tick();
-    canvas.tick();
-  }
-
-  bool Orbit::update(Resources& resources, entity::Character& character, entity::Cursor& cursor, Inventory& inventory,
-                     Text& text, menu::Toasts& toasts)
-  {
-    auto& strings = character.data.strings;
-    auto& schema = character.data.orbitSchema;
-    sounds = &schema.sounds;
-    auto& style = ImGui::GetStyle();
-    auto drawList = ImGui::GetWindowDrawList();
-    auto& textureShader = resources.shaders[resource::shader::TEXTURE];
-    auto& rectShader = resources.shaders[resource::shader::RECT];
-    ImGui::Text(strings.get(Strings::ArcadeScoreFormat).c_str(), score);
-    auto bestText = std::vformat(strings.get(Strings::ArcadeBestScoreFormat), std::make_format_args(highScore));
-    auto cursorPos = ImGui::GetCursorPos();
-    ImGui::SetCursorPos(ImVec2(ImGui::GetContentRegionAvail().x - ImGui::CalcTextSize(bestText.c_str()).x,
-                               cursorPos.y - ImGui::GetTextLineHeightWithSpacing()));
-    ImGui::Text(strings.get(Strings::ArcadeBestScoreFormat).c_str(), highScore);
-    auto padding = ImGui::GetTextLineHeightWithSpacing();
-    auto contentRegionAvail = ImGui::GetContentRegionAvail();
-    auto contentRegionPosition = ImGui::GetCursorScreenPos();
-    auto contentBounds =
-        ImVec4(contentRegionPosition.x, contentRegionPosition.y, contentRegionAvail.x, contentRegionAvail.y);
-    auto available =
-        imgui::to_vec2(contentRegionAvail) - vec2(0.0f, ImGui::GetFrameHeightWithSpacing() + style.WindowPadding.y);
-    auto canvasSize = glm::max(vec2(1.0f), available - vec2(padding * 2.0f));
-    auto canvasScreenPosition = imgui::to_vec2(ImGui::GetCursorScreenPos()) + vec2(padding);
-    centerPosition = canvasSize * 0.5f;
-
-    if (isPlayerDying)
-    {
-      Entity* playerEntity = nullptr;
-      for (auto& entity : entities)
-        if (entity.type == Entity::PLAYER)
-        {
-          playerEntity = &entity;
-          break;
-        }
-
-      if (!playerEntity || playerEntity->state == entity::Actor::STOPPED)
-      {
-        reset(character);
-      }
-    }
-
-    if (entities.empty() && startTimer <= 0) startTimer = schema.startTime;
-
-    if (entities.empty()) spawn(character, Entity::PLAYER);
-
-    followerRadius = schema.player.followerRadius;
-    playerTargetAcceleration = schema.player.targetAcceleration;
-    followerTargetAcceleration = schema.follower.targetAcceleration;
-    playerTimeAfterHurt = schema.player.timeAfterHurt;
-    enemySpeed = schema.enemy.speed;
-    enemySpeedScoreBonus = schema.enemy.speedScoreBonus;
-    enemySpeedGainBase = schema.enemy.speedGainBase;
-    enemySpeedGainScoreBonus = schema.enemy.speedGainScoreBonus;
-    rotationSpeed = schema.player.rotationSpeed;
-    rotationSpeedMax = schema.player.rotationSpeedMax;
-    rotationSpeedFriction = schema.player.rotationSpeedFriction;
-    auto nextLevel = std::min(unlocked_level_get(schema, score), (int)schema.colors.size());
-    if (nextLevel > level)
-    {
-      schema.sounds.levelUp.play();
-
-      auto colorIndex = nextLevel - 1;
-      if (colorIndex >= 0 && colorIndex < (int)schema.colors.size())
-      {
-        auto& pool = schema.colors[colorIndex].pool;
-        if (pool.is_valid() && text.is_interruptible()) text.set(character.data.dialogue.get(pool), character);
-      }
-    }
-    level = nextLevel;
-
-    auto player_get = [&]() -> Entity*
-    {
-      for (auto& entity : entities)
-        if (entity.type == Entity::PLAYER) return &entity;
-
-      return nullptr;
-    };
-
-    auto player = player_get();
-
-    if (player)
-    {
-      auto desiredFollowerCount = std::min(level, (int)schema.colors.size());
-      auto currentFollowerCount = (int)std::count_if(entities.begin(), entities.end(), [](const Entity& entity)
-                                                     { return entity.type == Entity::FOLLOWER; });
-      auto currentEnemyCount = (int)std::count_if(entities.begin(), entities.end(),
-                                                  [](const Entity& entity) { return entity.type == Entity::ENEMY; });
-
-      if (currentFollowerCount != desiredFollowerCount)
-      {
-        entities.erase(std::remove_if(entities.begin(), entities.end(),
-                                      [](const Entity& entity) { return entity.type == Entity::FOLLOWER; }),
-                       entities.end());
-
-        for (int i = 0; i < desiredFollowerCount; i++)
-          spawn(character, Entity::FOLLOWER, i);
-
-        player = player_get();
-      }
-
-      if (startTimer <= 0 && hurtTimer <= 0 && !isPlayerDying && !schema.colors.empty())
-      {
-        auto colorID = random_available_color_get(schema, level);
-        if (colorID == -1) return false;
-
-        if (currentEnemyCount == 0)
-        {
-          spawn(character, Entity::ENEMY, colorID);
-          player = player_get();
-        }
-
-        auto spawnChance = schema.enemy.spawnChanceBase + schema.enemy.spawnChanceScoreBonus * (float)score;
-        if (math::random_percent_roll(spawnChance))
-        {
-          colorID = random_available_color_get(schema, level);
-          if (colorID == -1) return false;
-          spawn(character, Entity::ENEMY, colorID);
-          player = player_get();
-        }
-      }
-    }
-
-    auto mousePosition = imgui::to_vec2(ImGui::GetMousePos());
-    auto canvasBoundsMax = canvasScreenPosition + canvasSize;
-    auto isHoveringCanvas = mousePosition.x >= canvasScreenPosition.x && mousePosition.x <= canvasBoundsMax.x &&
-                            mousePosition.y >= canvasScreenPosition.y && mousePosition.y <= canvasBoundsMax.y;
-
-    cursor.isVisible = !isHoveringCanvas;
-    isRotateLeft = startTimer <= 0 && hurtTimer <= 0 && !isPlayerDying && isHoveringCanvas &&
-                   ImGui::IsMouseDown(ImGuiMouseButton_Left);
-    isRotateRight = startTimer <= 0 && hurtTimer <= 0 && !isPlayerDying && isHoveringCanvas &&
-                    ImGui::IsMouseDown(ImGuiMouseButton_Right);
-    cursorPosition = glm::clamp(mousePosition - canvasScreenPosition, vec2(0.0f), canvasSize);
-
-    if (player)
-    {
-      if (isPlayerDying || hurtTimer > 0) player->velocity *= 0.85f;
-
-      if (!isPlayerDying && hurtTimer <= 0 && isRotateLeft) player->rotationVelocity -= rotationSpeed;
-      if (!isPlayerDying && hurtTimer <= 0 && isRotateRight) player->rotationVelocity += rotationSpeed;
-      player->rotationVelocity = glm::clamp(player->rotationVelocity, -rotationSpeedMax, rotationSpeedMax);
-      player->rotationVelocity *= rotationSpeedFriction;
-
-      if (!isPlayerDying && hurtTimer <= 0)
-        target_tick(*player, startTimer > 0 ? centerPosition : cursorPosition, playerTargetAcceleration);
-    }
-
-    for (auto& entity : entities)
-    {
-      switch (entity.type)
-      {
-        case Entity::FOLLOWER:
-          if (player)
-          {
-            entity.orbitAngle += player->rotationVelocity;
-
-            auto radius = std::max(0.0f, followerRadius);
-            auto target = player->position + vec2(std::cos(entity.orbitAngle), std::sin(entity.orbitAngle)) * radius;
-            target_tick(entity, target, followerTargetAcceleration);
-          }
-          break;
-        case Entity::ENEMY:
-          if (player && !entity.isMarkedForRemoval)
-          {
-            auto delta = player->position - entity.position;
-            auto distance = glm::length(delta);
-            auto speed = (enemySpeed + enemySpeedScoreBonus * (float)score) +
-                         (enemySpeedGainBase + enemySpeedGainScoreBonus * (float)score);
-            if (distance > 0.001f) entity.position += glm::normalize(delta) * speed;
-          }
-          break;
-        default:
-          break;
-      }
-    }
-
-    for (auto& follower : entities)
-    {
-      if (isPlayerDying) break;
-      if (follower.type != Entity::FOLLOWER) continue;
-      if (follower.hitboxNull.empty() || !follower.nullMap.contains(follower.hitboxNull)) continue;
-
-      auto followerRect = follower.null_frame_rect(follower.nullMap.at(follower.hitboxNull));
-      if (std::isnan(followerRect.x)) continue;
-
-      for (auto& enemy : entities)
-      {
-        if (enemy.type != Entity::ENEMY || enemy.isMarkedForRemoval) continue;
-        if (enemy.colorID != follower.colorID) continue;
-        if (enemy.hitboxNull.empty() || !enemy.nullMap.contains(enemy.hitboxNull)) continue;
-
-        auto enemyRect = enemy.null_frame_rect(enemy.nullMap.at(enemy.hitboxNull));
-        if (std::isnan(enemyRect.x)) continue;
-        if (!is_rect_overlapping(followerRect, enemyRect)) continue;
-
-        enemy.isMarkedForRemoval = true;
-        if (!enemy.animationDeath.empty())
-          enemy.play(enemy.animationDeath, entity::Actor::PLAY_FORCE);
-        else
-          enemy.state = entity::Actor::STOPPED;
-
-        spawn_animation_play(follower);
-        score++;
-        auto rewardChance = schema.rewardChanceBase + (schema.rewardChanceScoreBonus * score);
-        auto rewardRollCount = schema.rewardRollChanceBase + (schema.rewardRollScoreBonus * score);
-        itemRewards.reward_random_items_try(inventory, itemEffectManager, character.data.itemSchema, contentBounds,
-                                            rewardChance, rewardRollCount, menu::ItemEffectManager::SHOOT_UP);
-        if (score > highScore)
-        {
-          highScore = score;
-
-          if (!isHighScoreAchievedThisRun && highScoreAtRunStart > 0)
-          {
-            isHighScoreAchievedThisRun = true;
-            schema.sounds.highScore.play();
-            auto toastText = strings.get(Strings::ArcadeHighScoreToast);
-            auto toastPosition = imgui::to_imvec2(
-                canvasScreenPosition + player->position -
-                vec2(ImGui::CalcTextSize(toastText.c_str()).x * 0.5f, ImGui::GetTextLineHeightWithSpacing() * 2.0f));
-            toasts.spawn(toastText, toastPosition, 60);
-          }
-        }
-      }
-    }
-
-    if (player && !isPlayerDying && hurtTimer <= 0 && !player->hitboxNull.empty() &&
-        player->nullMap.contains(player->hitboxNull))
-    {
-      auto playerRect = player->null_frame_rect(player->nullMap.at(player->hitboxNull));
-
-      if (!std::isnan(playerRect.x))
-      {
-        auto isHit = false;
-
-        for (auto& enemy : entities)
-        {
-          if (enemy.type != Entity::ENEMY || enemy.isMarkedForRemoval) continue;
-          if (enemy.hitboxNull.empty() || !enemy.nullMap.contains(enemy.hitboxNull)) continue;
-
-          auto enemyRect = enemy.null_frame_rect(enemy.nullMap.at(enemy.hitboxNull));
-          if (std::isnan(enemyRect.x)) continue;
-          if (!is_rect_overlapping(playerRect, enemyRect)) continue;
-
-          isHit = true;
-          break;
-        }
-
-        if (isHit)
-        {
-          if (sounds) sounds->hurt.play();
-          if (isHighScoreAchievedThisRun) schema.sounds.highScoreLoss.play();
-          if (schema.poolDeath.is_valid() && text.is_interruptible())
-            text.set(character.data.dialogue.get(schema.poolDeath), character);
-          hurtTimer = playerTimeAfterHurt;
-          isPlayerDying = true;
-          player->velocity = {};
-          player->rotationVelocity = 0.0f;
-          if (!player->animationDeath.empty())
-            player->play(player->animationDeath, entity::Actor::PLAY_FORCE);
-          else
-            player->state = entity::Actor::STOPPED;
-
-          entities.erase(std::remove_if(entities.begin(), entities.end(),
-                                        [](const Entity& entity)
-                                        {
-                                          return entity.type == Entity::ENEMY || entity.type == Entity::WARNING ||
-                                                 entity.type == Entity::FOLLOWER;
-                                        }),
-                         entities.end());
-        }
-      }
-    }
-
-    entities.erase(std::remove_if(entities.begin(), entities.end(),
-                                  [](const Entity& entity)
-                                  {
-                                    return (entity.type == Entity::WARNING && entity.state == entity::Actor::STOPPED) ||
-                                           (entity.type == Entity::ENEMY && entity.isMarkedForRemoval &&
-                                            entity.state == entity::Actor::STOPPED);
-                                  }),
-                   entities.end());
-
-    if (startTimer > 0) startTimer--;
-    if (hurtTimer > 0) hurtTimer--;
-
-    canvas.bind();
-    canvas.size_set(ivec2(canvasSize));
-    canvas.clear(color::BLACK);
-
-    for (auto& entity : entities)
-      if (entity.type == Entity::PLAYER || entity.type == Entity::FOLLOWER || entity.type == Entity::ENEMY ||
-          entity.type == Entity::WARNING)
-        entity.render(textureShader, rectShader, canvas);
-
-    canvas.unbind();
-
-    ImGui::Dummy(ImVec2(0, padding));
-    ImGui::SetCursorScreenPos(imgui::to_imvec2(canvasScreenPosition));
-    ImGui::Image(canvas.texture, imgui::to_imvec2(canvasSize));
-    itemEffectManager.render(resources, character.data.itemSchema, contentBounds, ImGui::GetIO().DeltaTime);
-    ImGui::Dummy(ImVec2(0, padding));
-    toasts.update(drawList);
-
-    auto isMenuPressed = WIDGET_FX(ImGui::Button(strings.get(Strings::ArcadeMenuBackButton).c_str()));
-    if (ImGui::IsItemHovered()) ImGui::SetItemTooltip("%s", strings.get(Strings::ArcadeMenuBackButtonTooltip).c_str());
-    return isMenuPressed;
-  }
-}
diff --git a/src/state/play/menu/arcade/orbit.hpp b/src/state/play/menu/arcade/orbit.hpp
deleted file mode 100644
index b3d61e5..0000000
--- a/src/state/play/menu/arcade/orbit.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#pragma once
-
-#include "../../../../entity/actor.hpp"
-#include "../../../../entity/cursor.hpp"
-#include "../../../../resources.hpp"
-
-#include "../../../../util/color.hpp"
-#include "../inventory.hpp"
-#include "../item_effect_manager.hpp"
-#include "../../text.hpp"
-#include "../toasts.hpp"
-#include "../../item/reward.hpp"
-
-namespace game::state::play::menu::arcade
-{
-  class Orbit
-  {
-  public:
-    class Entity : public entity::Actor
-    {
-    public:
-      enum Type
-      {
-        PLAYER,
-        FOLLOWER,
-        ENEMY,
-        WARNING
-      };
-
-      Type type{PLAYER};
-      glm::vec2 velocity{};
-      float rotationVelocity{};
-      std::string animationIdle{};
-      std::string animationSpawn{};
-      std::string animationDeath{};
-      std::string hitboxNull{"Hitbox"};
-      bool isMarkedForRemoval{};
-      int health{3};
-      int colorID{};
-      float orbitAngle{};
-
-      Entity() = default;
-      Entity(resource::xml::Anm2 anm2, Type type = PLAYER) : entity::Actor(std::move(anm2)), type(type) {}
-    };
-
-    std::vector<Entity> entities{};
-    resource::xml::Orbit::Sounds* sounds{};
-    Canvas canvas{{1, 1}};
-    glm::vec2 cursorPosition{};
-    glm::vec2 centerPosition{};
-    int level{1};
-    int score{};
-    int highScore{};
-    int highScoreAtRunStart{};
-    bool isHighScoreAchievedThisRun{};
-    menu::ItemEffectManager itemEffectManager{};
-    game::state::play::item::Reward itemRewards{};
-    float followerRadius{};
-    float playerTargetAcceleration{};
-    float followerTargetAcceleration{};
-    int playerTimeAfterHurt{};
-    float enemySpeed{};
-    float enemySpeedScoreBonus{};
-    float enemySpeedGainBase{};
-    float enemySpeedGainScoreBonus{};
-    float rotationSpeed{};
-    float rotationSpeedMax{};
-    float rotationSpeedFriction{};
-    int startTimer{};
-    int hurtTimer{};
-    bool isPlayerDying{};
-    bool isRotateLeft{};
-    bool isRotateRight{};
-
-    Orbit() = default;
-    void reset(entity::Character&);
-    void tick();
-    void spawn(entity::Character&, Entity::Type, int colorID = -1);
-    bool update(Resources&, entity::Character&, entity::Cursor&, Inventory& inventory, Text& text, menu::Toasts&);
-  };
-}
diff --git a/src/state/play/menu/arcade/skill_check.cpp b/src/state/play/menu/arcade/skill_check.cpp
deleted file mode 100644
index a5bdb77..0000000
--- a/src/state/play/menu/arcade/skill_check.cpp
+++ /dev/null
@@ -1,339 +0,0 @@
-#include "skill_check.hpp"
-
-#include <imgui_internal.h>
-
-#include "../../../../util/imgui.hpp"
-#include "../../../../util/imgui/widget.hpp"
-#include "../../../../util/math.hpp"
-
-#include <cmath>
-#include <format>
-
-using namespace game::util;
-using namespace game::entity;
-using namespace game::resource;
-using namespace game::resource::xml;
-using namespace glm;
-
-namespace game::state::play::menu::arcade
-{
-  float SkillCheck::accuracy_score_get(entity::Character& character)
-  {
-    if (totalPlays == 0) return 0.0f;
-
-    auto& schema = character.data.skillCheckSchema;
-
-    float combinedWeight{};
-
-    for (int i = 0; i < (int)schema.grades.size(); i++)
-    {
-      auto& grade = schema.grades[i];
-      combinedWeight += gradeCounts[i] * grade.weight;
-    }
-
-    return glm::clamp(0.0f, math::to_percent(combinedWeight / totalPlays), 100.0f);
-  }
-
-  SkillCheck::Challenge SkillCheck::challenge_generate(entity::Character& character)
-  {
-    auto& schema = character.data.skillCheckSchema;
-
-    Challenge newChallenge;
-
-    Zone newZone{};
-
-    auto zoneSize = std::max(schema.zoneMin, schema.zoneBase - (schema.zoneScoreBonus * score));
-    newZone.min = math::random_max(1.0f - zoneSize);
-    newZone.max = newZone.min + zoneSize;
-
-    newChallenge.zone = newZone;
-    newChallenge.tryValue = 0.0f;
-
-    newChallenge.speed =
-        glm::clamp(schema.speedMin, schema.speedMin + (schema.speedScoreBonus * score), schema.speedMax);
-
-    if (math::random_bool())
-    {
-      newChallenge.tryValue = 1.0f;
-      newChallenge.speed *= -1;
-    }
-
-    return newChallenge;
-  }
-
-  SkillCheck::SkillCheck(entity::Character& character) { challenge = challenge_generate(character); }
-
-  void SkillCheck::reset(entity::Character& character)
-  {
-    challenge = challenge_generate(character);
-    queuedChallenge = {};
-    tryValue = challenge.tryValue;
-    score = 0;
-    combo = 0;
-    endTimer = 0;
-    endTimerMax = 0;
-    highScoreStart = 0;
-    isActive = true;
-    isRewardScoreAchieved = false;
-    isHighScoreAchieved = highScore > 0;
-    isHighScoreAchievedThisRun = false;
-    isGameOver = false;
-    itemEffectManager = {};
-  }
-
-  void SkillCheck::tick() { itemEffectManager.tick(); }
-
-  bool SkillCheck::update(Resources& resources, entity::Character& character, Inventory& inventory, Text& text,
-                          Toasts& toasts)
-  {
-    static constexpr auto BG_COLOR_MULTIPLIER = 0.5f;
-    static constexpr ImVec4 LINE_COLOR = ImVec4(1, 1, 1, 1);
-    static constexpr ImVec4 PERFECT_COLOR = ImVec4(1, 1, 1, 0.50);
-    static constexpr auto BAR_SPACING_MULTIPLIER = 1.5f;
-    static constexpr auto LINE_HEIGHT = 5.0f;
-    static constexpr auto LINE_WIDTH_BONUS = 10.0f;
-    auto& dialogue = character.data.dialogue;
-    auto& schema = character.data.skillCheckSchema;
-    auto& itemSchema = character.data.itemSchema;
-    auto& strings = character.data.strings;
-    auto& style = ImGui::GetStyle();
-    auto drawList = ImGui::GetWindowDrawList();
-    auto position = ImGui::GetCursorScreenPos();
-    auto size = ImGui::GetContentRegionAvail();
-    auto spacing = ImGui::GetTextLineHeightWithSpacing() * BAR_SPACING_MULTIPLIER;
-    auto& io = ImGui::GetIO();
-    auto menuButtonHeight = ImGui::GetFrameHeightWithSpacing();
-    size.y = std::max(0.0f, size.y - menuButtonHeight);
-    auto bounds = ImVec4(position.x, position.y, size.x, size.y);
-
-    auto cursorPos = ImGui::GetCursorPos();
-
-    ImGui::Text(strings.get(Strings::ArcadeScoreComboFormat).c_str(), score, combo);
-    auto bestString =
-        std::vformat(strings.get(Strings::ArcadeBestScoreComboFormat), std::make_format_args(highScore, bestCombo));
-    ImGui::SetCursorPos(ImVec2(size.x - ImGui::CalcTextSize(bestString.c_str()).x, cursorPos.y));
-
-    ImGui::Text(strings.get(Strings::ArcadeBestScoreComboFormat).c_str(), highScore, bestCombo);
-
-    if (score == 0 && isActive)
-    {
-      ImGui::SetCursorPos(ImVec2(style.WindowPadding.x, size.y - style.WindowPadding.y));
-      ImGui::TextWrapped("%s", strings.get(Strings::SkillCheckInstructions).c_str());
-    }
-
-    auto barMin = ImVec2(position.x + (size.x * 0.5f) - (spacing * 0.5f), position.y + (spacing * 2.0f));
-    auto barMax = ImVec2(barMin.x + (spacing * 2.0f), barMin.y + size.y - (spacing * 4.0f));
-    auto endTimerProgress = (float)endTimer / endTimerMax;
-
-    auto bgColor = ImGui::GetStyleColorVec4(ImGuiCol_FrameBg);
-    bgColor = imgui::to_imvec4(imgui::to_vec4(bgColor) * BG_COLOR_MULTIPLIER);
-    drawList->AddRectFilled(barMin, barMax, ImGui::GetColorU32(bgColor));
-
-    auto barWidth = barMax.x - barMin.x;
-    auto barHeight = barMax.y - barMin.y;
-
-    auto sub_zones_get = [&](Zone& zone)
-    {
-      auto& min = zone.min;
-      auto& max = zone.max;
-      std::vector<Zone> zones{};
-
-      auto baseHeight = max - min;
-      auto center = (min + max) * 0.5f;
-
-      int zoneCount{};
-
-      for (auto& grade : schema.grades)
-      {
-        if (grade.isFailure) continue;
-
-        auto scale = powf(0.5f, (float)zoneCount);
-        auto halfHeight = baseHeight * scale * 0.5f;
-
-        zoneCount++;
-
-        zones.push_back({center - halfHeight, center + halfHeight});
-      }
-
-      return zones;
-    };
-
-    auto zone_draw = [&](Zone& zone, float alpha = 1.0f)
-    {
-      auto subZones = sub_zones_get(zone);
-
-      for (int i = 0; i < (int)subZones.size(); i++)
-      {
-        auto& subZone = subZones[i];
-        int layer = (int)subZones.size() - 1 - i;
-
-        ImVec2 rectMin = {barMin.x, barMin.y + subZone.min * barHeight};
-
-        ImVec2 rectMax = {barMax.x, barMin.y + subZone.max * barHeight};
-
-        ImVec4 color =
-            i == (int)subZones.size() - 1 ? PERFECT_COLOR : ImGui::GetStyleColorVec4(ImGuiCol_FrameBgHovered);
-        color.w = (color.w - (float)layer / subZones.size()) * alpha;
-
-        drawList->AddRectFilled(rectMin, rectMax, ImGui::GetColorU32(color));
-      }
-    };
-
-    zone_draw(challenge.zone, isActive ? 1.0f : 0.0f);
-
-    auto lineMin = ImVec2(barMin.x - LINE_WIDTH_BONUS, barMin.y + (barHeight * tryValue));
-    auto lineMax = ImVec2(barMin.x + barWidth + LINE_WIDTH_BONUS, lineMin.y + LINE_HEIGHT);
-    auto lineColor = LINE_COLOR;
-    lineColor.w = isActive ? 1.0f : endTimerProgress;
-    drawList->AddRectFilled(lineMin, lineMax, ImGui::GetColorU32(lineColor));
-
-    if (!isActive && !isGameOver)
-    {
-      zone_draw(queuedChallenge.zone, 1.0f - endTimerProgress);
-
-      auto queuedLineMin = ImVec2(barMin.x - LINE_WIDTH_BONUS, barMin.y + (barHeight * queuedChallenge.tryValue));
-      auto queuedLineMax = ImVec2(barMin.x + barWidth + LINE_WIDTH_BONUS, queuedLineMin.y + LINE_HEIGHT);
-      auto queuedLineColor = LINE_COLOR;
-      queuedLineColor.w = 1.0f - endTimerProgress;
-      drawList->AddRectFilled(queuedLineMin, queuedLineMax, ImGui::GetColorU32(queuedLineColor));
-    }
-
-    if (isActive)
-    {
-      tryValue += challenge.speed;
-
-      if (tryValue > 1.0f || tryValue < 0.0f)
-      {
-        tryValue = tryValue > 1.0f ? 0.0f : tryValue < 0.0f ? 1.0f : tryValue;
-
-        if (score > 0)
-        {
-          score--;
-          schema.sounds.scoreLoss.play();
-          auto toastMessagePosition =
-              ImVec2(barMin.x - ImGui::CalcTextSize(strings.get(Strings::ArcadeScoreLoss).c_str()).x -
-                         ImGui::GetTextLineHeightWithSpacing(),
-                     lineMin.y);
-          toasts.spawn(strings.get(Strings::ArcadeScoreLoss), toastMessagePosition, schema.endTimerMax);
-        }
-      }
-
-      ImGui::SetCursorScreenPos(barMin);
-      auto barButtonSize = ImVec2(barMax.x - barMin.x, barMax.y - barMin.y);
-
-      if (ImGui::IsKeyPressed(ImGuiKey_Space) ||
-          WIDGET_FX(ImGui::InvisibleButton("##SkillCheckBar", barButtonSize, ImGuiButtonFlags_PressedOnClick)))
-      {
-        int gradeID{};
-
-        auto subZones = sub_zones_get(challenge.zone);
-
-        for (int i = 0; i < (int)subZones.size(); i++)
-        {
-          auto& subZone = subZones[i];
-
-          if (tryValue >= subZone.min && tryValue <= subZone.max)
-            gradeID = std::min((int)gradeID + 1, (int)schema.grades.size() - 1);
-        }
-
-        gradeCounts[gradeID]++;
-        totalPlays++;
-
-        auto& grade = schema.grades.at(gradeID);
-        grade.sound.play();
-
-        if (text.is_interruptible() && grade.pool.is_valid()) text.set(dialogue.get(grade.pool), character);
-
-        if (!grade.isFailure)
-        {
-          combo++;
-          score += grade.value;
-
-          if (score >= schema.rewardScore && !isRewardScoreAchieved)
-          {
-            schema.sounds.rewardScore.play();
-            isRewardScoreAchieved = true;
-
-            for (auto& itemID : itemSchema.skillCheckRewardItemPool)
-              itemRewards.item_give(itemID, inventory, itemEffectManager, itemSchema, bounds);
-
-            auto toastMessagePosition =
-                ImVec2(barMin.x - ImGui::CalcTextSize(strings.get(Strings::ArcadeRewardToast).c_str()).x -
-                           ImGui::GetTextLineHeightWithSpacing(),
-                       lineMin.y + (ImGui::GetTextLineHeightWithSpacing() + ImGui::GetStyle().ItemSpacing.y));
-            toasts.spawn(strings.get(Strings::ArcadeRewardToast), toastMessagePosition, schema.endTimerMax);
-          }
-
-          if (score > highScore)
-          {
-            highScore = score;
-
-            if (isHighScoreAchieved && !isHighScoreAchievedThisRun)
-            {
-              isHighScoreAchievedThisRun = true;
-              schema.sounds.highScore.play();
-              auto toastMessagePosition =
-                  ImVec2(barMin.x - ImGui::CalcTextSize(strings.get(Strings::ArcadeHighScoreToast).c_str()).x -
-                             ImGui::GetTextLineHeightWithSpacing(),
-                         lineMin.y + ImGui::GetTextLineHeightWithSpacing());
-              toasts.spawn(strings.get(Strings::ArcadeHighScoreToast), toastMessagePosition, schema.endTimerMax);
-            }
-          }
-
-          if (combo > bestCombo) bestCombo = combo;
-
-          auto rewardChance = schema.rewardChanceBase + (schema.rewardChanceScoreBonus * score);
-          auto rewardRollCount = schema.rewardRollChanceBase + (schema.rewardRollScoreBonus * score) +
-                                 (schema.rewardRollGradeBonus * grade.value);
-          itemRewards.reward_random_items_try(inventory, itemEffectManager, itemSchema, bounds, rewardChance,
-                                              rewardRollCount);
-        }
-        else
-        {
-          score = 0;
-          combo = 0;
-          if (isHighScoreAchievedThisRun) schema.sounds.highScoreLoss.play();
-          if (highScore > 0) isHighScoreAchieved = true;
-          isRewardScoreAchieved = false;
-          isHighScoreAchievedThisRun = false;
-          highScoreStart = highScore;
-          isGameOver = true;
-        }
-
-        endTimerMax = grade.isFailure ? schema.endTimerFailureMax : schema.endTimerMax;
-        isActive = false;
-        endTimer = endTimerMax;
-
-        queuedChallenge = challenge_generate(character);
-
-        auto string = grade.isFailure ? grade.name
-                                      : std::vformat(strings.get(Strings::SkillCheckGradeSuccessTemplate),
-                                                     std::make_format_args(grade.name, grade.value));
-        auto toastMessagePosition =
-            ImVec2(barMin.x - ImGui::CalcTextSize(string.c_str()).x - ImGui::GetTextLineHeightWithSpacing(), lineMin.y);
-        toasts.spawn(string, toastMessagePosition, endTimerMax);
-      }
-    }
-    else
-    {
-      endTimer--;
-      if (endTimer <= 0)
-      {
-        challenge = queuedChallenge;
-        tryValue = challenge.tryValue;
-        isActive = true;
-        isGameOver = false;
-      }
-    }
-
-    toasts.update(drawList);
-
-    itemEffectManager.render(resources, itemSchema, bounds, io.DeltaTime);
-
-    ImGui::SetCursorScreenPos(ImVec2(position.x, position.y + size.y + ImGui::GetStyle().ItemSpacing.y));
-    auto isMenuPressed = WIDGET_FX(ImGui::Button(strings.get(Strings::ArcadeMenuBackButton).c_str()));
-    if (ImGui::IsItemHovered())
-      ImGui::SetItemTooltip("%s", strings.get(Strings::ArcadeMenuBackButtonTooltip).c_str());
-    return isMenuPressed;
-  }
-}
diff --git a/src/state/play/menu/arcade/skill_check.hpp b/src/state/play/menu/arcade/skill_check.hpp
deleted file mode 100644
index 8421088..0000000
--- a/src/state/play/menu/arcade/skill_check.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-#pragma once
-
-#include "../item_effect_manager.hpp"
-#include "../../item/reward.hpp"
-#include "../toasts.hpp"
-
-#include "../../../../entity/character.hpp"
-#include "../../../../resources.hpp"
-
-#include "../inventory.hpp"
-#include "../../text.hpp"
-
-#include <imgui.h>
-#include <map>
-#include <vector>
-
-namespace game::state::play::menu::arcade
-{
-  class SkillCheck
-  {
-
-  public:
-    struct Zone
-    {
-      float min{};
-      float max{};
-    };
-
-    struct Challenge
-    {
-      Zone zone{};
-      float speed{};
-      float tryValue{};
-      int level{};
-    };
-
-    Challenge challenge{};
-    Challenge queuedChallenge{};
-    float tryValue{};
-
-    int score{};
-    int combo{};
-
-    int endTimer{};
-    int endTimerMax{};
-
-    int highScoreStart{};
-
-    int bestCombo{};
-    int highScore{};
-    int totalPlays{};
-    std::map<int, int> gradeCounts{};
-
-    bool isActive{true};
-    bool isRewardScoreAchieved{false};
-    bool isHighScoreAchieved{false};
-    bool isHighScoreAchievedThisRun{false};
-    bool isGameOver{};
-
-    game::state::play::menu::ItemEffectManager itemEffectManager{};
-    game::state::play::item::Reward itemRewards{};
-
-    SkillCheck() = default;
-    SkillCheck(entity::Character&);
-    Challenge challenge_generate(entity::Character&);
-    void reset(entity::Character&);
-    void tick();
-    bool update(Resources&, entity::Character&, Inventory&, Text&, Toasts&);
-    float accuracy_score_get(entity::Character&);
-  };
-}
diff --git a/src/state/play/menu/gather.cpp b/src/state/play/menu/gather.cpp
new file mode 100644
index 0000000..8ce63ee
--- /dev/null
+++ b/src/state/play/menu/gather.cpp
@@ -0,0 +1,619 @@
+#include "gather.hpp"
+
+#include "../../../resource/font.hpp"
+#include "../../../util/imgui.hpp"
+#include "../../../util/math.hpp"
+#include "../../../util/time.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <format>
+#include <imgui.h>
+
+namespace game::state::play::menu
+{
+  constexpr auto CANVAS_MIN_SIZE = 1.0f;
+  constexpr auto CENTER_RATIO = 0.5f;
+  constexpr auto START_TEXT_Y_RATIO = 0.75f;
+  constexpr auto PLAYER_ACCELERATION = 3.0f;
+  constexpr auto PLAYER_FRICTION_PER_SECOND = 0.72f;
+  constexpr auto PLAYER_SIZE = 32.0f;
+  constexpr auto PLAYER_VELOCITY_MAX = 720.0f;
+  constexpr auto PLAYER_VELOCITY_STOP = 0.0f;
+  constexpr auto PLAYER_BOOST_VELOCITY_GAIN = 320.0f;
+  constexpr auto PLAYER_BOOST_VELOCITY_MIN = 540.0f;
+  constexpr auto PLAYER_BOOST_DURATION = 0.35f;
+  constexpr auto BOOST_DIRECTION_EPSILON = 0.001f;
+  constexpr auto BOOST_DIRECTION_UNIT = 1.0f;
+  constexpr auto GAME_TEXT_FONT_SIZE = resource::Font::HEADER_1;
+  constexpr auto STAMINA_MIN = 0.0f;
+  constexpr auto STAMINA_MAX = 1.0f;
+  constexpr auto STAMINA_REGEN_PER_TICK = 0.002f;
+  constexpr auto STAMINA_BOOST_COST = 0.25f;
+  constexpr auto STAMINA_MAGNET_COST = 0.25f;
+  constexpr auto STAMINA_BAR_WIDTH = 120.0f;
+  constexpr auto STAMINA_BAR_HEIGHT = GAME_TEXT_FONT_SIZE;
+  constexpr auto STAMINA_BAR_PADDING = 8.0f;
+  constexpr auto STAMINA_BAR_PADDING_MULTIPLIER = 2.0f;
+  constexpr auto STAMINA_BAR_ROUNDING = 2.0f;
+  constexpr auto COLLECTIBLE_SIZE = 20.0f;
+  constexpr auto COLLECTIBLE_OSCILLATION_SPEED = 6.0f;
+  constexpr auto COLLECTIBLE_OSCILLATION_AMOUNT = 3.0f;
+  constexpr auto COLLECTIBLE_MAGNET_RADIUS = 72.0f;
+  constexpr auto COLLECTIBLE_MAGNET_RADIUS_EXTENDED = 240.0f;
+  constexpr auto COLLECTIBLE_MAGNET_RADIUS_EXTEND_SECONDS = 1.0f;
+  constexpr auto COLLECTIBLE_MAGNET_RADIUS_WINDOWED_MULTIPLIER = 0.5f;
+  constexpr auto COLLECTIBLE_MAGNET_ACCELERATION = 5200.0f;
+  constexpr auto COLLECTIBLE_MAGNET_ACCELERATION_GAIN = 26000.0f;
+  constexpr auto COLLECTIBLE_MAGNET_ACCELERATION_MAX = 26000.0f;
+  constexpr auto COLLECTIBLE_MAGNET_VELOCITY_MIN = 900.0f;
+  constexpr auto COLLECTIBLE_MAGNET_SPEED_MAX = 1800.0f;
+  constexpr auto COLLECTIBLE_MAGNET_FRICTION_PER_SECOND = 0.98f;
+  constexpr auto COLLECTIBLE_MAGNET_SIDE_VELOCITY_KEEP = 0.35f;
+  constexpr auto COLLECTIBLE_SPAWN_MARGIN_MULTIPLIER = 2.0f;
+  constexpr auto COLLECTIBLE_STRUCTURE_SPACING = 34.0f;
+  constexpr auto COLLECTIBLE_STRUCTURE_COUNT_MIN = 3;
+  constexpr auto COLLECTIBLE_POLYGON_RADIUS_BASE = 28.0f;
+  constexpr auto COLLECTIBLE_POLYGON_RADIUS_PER_COLLECTIBLE = 4.5f;
+  constexpr auto STAMINA_PICKUP_COUNT = 1;
+  constexpr auto COLLECTIBLE_TWO_PI = 6.283185f;
+  constexpr auto COLLECTIBLE_POLYGON_CHANCE = 0.20f;
+  constexpr auto COLLECTIBLE_LINE_CHANCE = 0.55f;
+  constexpr auto SCORE_TEXT_PADDING = 8.0f;
+  constexpr auto SCORE_TEXT_LINE_MULTIPLIER = 1.15f;
+  constexpr auto GAME_TIME_START_SECONDS = 30.0f;
+  constexpr auto GAME_TIME_START_TICKS = GAME_TIME_START_SECONDS * Entity::UPDATE_RATE;
+  constexpr auto GAME_TIME_GAIN_SECONDS = 5.0f;
+  constexpr auto GAME_TIME_GAIN_TICKS = GAME_TIME_GAIN_SECONDS * Entity::UPDATE_RATE;
+  constexpr auto WAVE_RESET_FADE_SECONDS = 0.125f;
+  constexpr auto TIME_GAIN_ALPHA_MAX = 1.0f;
+  constexpr auto TIME_GAIN_FADE_SECONDS = 1.25f;
+  constexpr auto TIME_TEXT_PADDING = 8.0f;
+  constexpr auto COLOR_CHANNEL_MAX = 255;
+  constexpr auto COLOR_GREEN_DIM = 64;
+  constexpr auto COLOR_GREEN = 220;
+  constexpr auto COLOR_COLLECTIBLE_BLUE = 255;
+  constexpr auto COLOR_TIME = 255;
+  constexpr auto COLOR_MAGNET_BLUE = 255;
+  constexpr auto COLOR_MAGNET_ALPHA = 70;
+  constexpr auto MAGNET_CIRCLE_SEGMENTS = 96;
+  constexpr auto MAGNET_CIRCLE_THICKNESS = 2.0f;
+  constexpr auto COLOR_COLLECTIBLE_ALPHA = 255;
+  constexpr auto COLOR_COLLECTIBLE_NEXT_ALPHA = 35;
+  constexpr auto STYLE_VAR_COUNT = 1;
+  constexpr auto CANVAS_FLAGS = ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse;
+
+  float Gather::random_range_get(float min, float max)
+  {
+    if (min >= max) return min;
+    return util::math::random_in_range(min, max);
+  }
+
+  glm::vec2 Gather::random_position_get(float minX, float minY, float maxX, float maxY)
+  {
+    return {random_range_get(minX, maxX), random_range_get(minY, maxY)};
+  }
+
+  Entity Gather::collectible_make(glm::vec2 position)
+  {
+    Entity collectible{};
+    collectible.position = position;
+    collectible.phase = util::math::random_max(COLLECTIBLE_TWO_PI);
+    return collectible;
+  }
+
+  Gather::Structure Gather::structure_get(int remaining)
+  {
+    auto roll = util::math::random();
+    if (remaining < COLLECTIBLE_STRUCTURE_COUNT_MIN) return Structure::SINGLE;
+    if (roll < COLLECTIBLE_POLYGON_CHANCE) return Structure::POLYGON;
+    if (roll < COLLECTIBLE_LINE_CHANCE)
+      return util::math::random_bool() ? Structure::LINE_HORIZONTAL : Structure::LINE_VERTICAL;
+    return Structure::SINGLE;
+  }
+
+  int Gather::structure_count_get(int remaining)
+  {
+    auto countRange = (remaining - COLLECTIBLE_STRUCTURE_COUNT_MIN) + 1;
+    auto countRoll = std::min(countRange - 1, (int)util::math::random_max((float)countRange));
+    return COLLECTIBLE_STRUCTURE_COUNT_MIN + countRoll;
+  }
+
+  int Gather::wave_collectible_count_get(int wave) { return std::max(1, wave); }
+
+  void Gather::collectible_add(std::vector<Entity>& wave, glm::vec2 position, int targetCount)
+  {
+    if ((int)wave.size() >= targetCount) return;
+    wave.emplace_back(collectible_make(position));
+  }
+
+  void Gather::single_spawn(std::vector<Entity>& wave, ImVec2 canvasSize, float margin, int targetCount)
+  {
+    auto position = random_position_get(margin, margin, canvasSize.x - margin, canvasSize.y - margin);
+    collectible_add(wave, position, targetCount);
+  }
+
+  void Gather::line_spawn(std::vector<Entity>& wave, ImVec2 canvasSize, float margin, bool isHorizontal,
+                          int structureCount, int targetCount)
+  {
+    auto structureHalf = COLLECTIBLE_STRUCTURE_SPACING * ((float)structureCount - 1) * CENTER_RATIO;
+    auto clearance = structureHalf + (COLLECTIBLE_SIZE * CENTER_RATIO);
+    auto center =
+        isHorizontal
+            ? random_position_get(margin + clearance, margin, canvasSize.x - margin - clearance, canvasSize.y - margin)
+            : random_position_get(margin, margin + clearance, canvasSize.x - margin, canvasSize.y - margin - clearance);
+    for (auto i = 0; i < structureCount; ++i)
+    {
+      auto offset = ((float)i - (((float)structureCount - 1) * CENTER_RATIO)) * COLLECTIBLE_STRUCTURE_SPACING;
+      auto position = isHorizontal ? glm::vec2(center.x + offset, center.y) : glm::vec2(center.x, center.y + offset);
+      collectible_add(wave, position, targetCount);
+    }
+  }
+
+  float Gather::polygon_radius_get(int structureCount)
+  {
+    return COLLECTIBLE_POLYGON_RADIUS_BASE + ((float)structureCount * COLLECTIBLE_POLYGON_RADIUS_PER_COLLECTIBLE);
+  }
+
+  void Gather::polygon_spawn(std::vector<Entity>& wave, ImVec2 canvasSize, float margin, int structureCount,
+                             int targetCount)
+  {
+    auto radius = polygon_radius_get(structureCount);
+    auto clearance = radius + (COLLECTIBLE_SIZE * CENTER_RATIO);
+    auto center = random_position_get(margin + clearance, margin + clearance, canvasSize.x - margin - clearance,
+                                      canvasSize.y - margin - clearance);
+    for (auto i = 0; i < structureCount; ++i)
+    {
+      auto angle = COLLECTIBLE_TWO_PI * ((float)i / (float)structureCount);
+      auto position = center + glm::vec2(std::cos(angle), std::sin(angle)) * radius;
+      collectible_add(wave, position, targetCount);
+    }
+  }
+
+  void Gather::wave_spawn(std::vector<Entity>& wave, ImVec2 canvasSize, int waveNumber)
+  {
+    wave.clear();
+    auto targetCount = wave_collectible_count_get(waveNumber);
+    auto margin = PLAYER_SIZE * COLLECTIBLE_SPAWN_MARGIN_MULTIPLIER;
+    while ((int)wave.size() < targetCount)
+    {
+      auto remaining = targetCount - (int)wave.size();
+      switch (structure_get(remaining))
+      {
+        case Structure::LINE_HORIZONTAL:
+          line_spawn(wave, canvasSize, margin, true, structure_count_get(remaining), targetCount);
+          break;
+        case Structure::LINE_VERTICAL:
+          line_spawn(wave, canvasSize, margin, false, structure_count_get(remaining), targetCount);
+          break;
+        case Structure::POLYGON:
+          polygon_spawn(wave, canvasSize, margin, structure_count_get(remaining), targetCount);
+          break;
+        case Structure::SINGLE:
+        default:
+          single_spawn(wave, canvasSize, margin, targetCount);
+          break;
+      }
+    }
+  }
+
+  int Gather::stamina_pickup_count_get(int) { return STAMINA_PICKUP_COUNT; }
+
+  void Gather::stamina_pickups_spawn(std::vector<Entity>& pickups, ImVec2 canvasSize, int waveNumber)
+  {
+    pickups.clear();
+    auto targetCount = stamina_pickup_count_get(waveNumber);
+    auto margin = PLAYER_SIZE * COLLECTIBLE_SPAWN_MARGIN_MULTIPLIER;
+    while ((int)pickups.size() < targetCount)
+      single_spawn(pickups, canvasSize, margin, targetCount);
+  }
+
+  float Gather::wave_time_gain_ticks_get() { return GAME_TIME_GAIN_TICKS; }
+
+  bool Gather::collectible_hit_get(const Entity& collectible, const Entity& player)
+  {
+    auto playerHalf = PLAYER_SIZE * CENTER_RATIO;
+    auto collectibleHalf = COLLECTIBLE_SIZE * CENTER_RATIO;
+    auto distance = glm::abs(player.position - collectible.position);
+    return distance.x <= playerHalf + collectibleHalf && distance.y <= playerHalf + collectibleHalf;
+  }
+
+  float Gather::magnet_radius_get(float magnetRadiusTime, bool isMenuFullscreen)
+  {
+    auto multiplier = isMenuFullscreen ? STAMINA_MAX : COLLECTIBLE_MAGNET_RADIUS_WINDOWED_MULTIPLIER;
+    auto baseRadius = COLLECTIBLE_MAGNET_RADIUS * multiplier;
+    auto extendedRadius = COLLECTIBLE_MAGNET_RADIUS_EXTENDED * multiplier;
+    auto ratio = std::clamp(magnetRadiusTime / COLLECTIBLE_MAGNET_RADIUS_EXTEND_SECONDS, STAMINA_MIN, STAMINA_MAX);
+    return baseRadius + ((extendedRadius - baseRadius) * ratio);
+  }
+
+  int Gather::collectibles_collect(std::vector<Entity>& wave, const Entity& player)
+  {
+    auto collected = 0;
+    for (auto& collectible : wave)
+    {
+      if (collectible.isCollected || !collectible_hit_get(collectible, player)) continue;
+      collectible.isCollected = true;
+      ++collected;
+    }
+    return collected;
+  }
+
+  void Gather::collectibles_magnet_update(std::vector<Entity>& wave, const Entity& player, ImVec2 canvasSize,
+                                          float magnetRadius, float dt)
+  {
+    auto radiusSquared = magnetRadius * magnetRadius;
+    auto collectibleHalf = COLLECTIBLE_SIZE * CENTER_RATIO;
+    auto minX = collectibleHalf;
+    auto minY = collectibleHalf;
+    auto maxX = std::max(minX, canvasSize.x - collectibleHalf);
+    auto maxY = std::max(minY, canvasSize.y - collectibleHalf);
+    for (auto& collectible : wave)
+    {
+      if (collectible.isCollected) continue;
+      auto direction = player.position - collectible.position;
+      auto distanceSquared = (direction.x * direction.x) + (direction.y * direction.y);
+      if (distanceSquared <= radiusSquared) collectible.isMagnetized = true;
+      if (collectible.isMagnetized && distanceSquared > BOOST_DIRECTION_EPSILON)
+      {
+        collectible.magnetTime += dt;
+        auto magnetAcceleration =
+            std::min(COLLECTIBLE_MAGNET_ACCELERATION_MAX,
+                     COLLECTIBLE_MAGNET_ACCELERATION + (COLLECTIBLE_MAGNET_ACCELERATION_GAIN * collectible.magnetTime));
+        auto distance = std::sqrt(distanceSquared);
+        auto directionUnit = direction * (BOOST_DIRECTION_UNIT / distance);
+        auto inwardVelocity = (collectible.velocity.x * directionUnit.x) + (collectible.velocity.y * directionUnit.y);
+        auto inward = directionUnit * inwardVelocity;
+        auto sideways = collectible.velocity - inward;
+        collectible.velocity = inward + (sideways * COLLECTIBLE_MAGNET_SIDE_VELOCITY_KEEP);
+        collectible.velocity += directionUnit * magnetAcceleration * dt;
+        inwardVelocity = (collectible.velocity.x * directionUnit.x) + (collectible.velocity.y * directionUnit.y);
+        if (inwardVelocity < COLLECTIBLE_MAGNET_VELOCITY_MIN)
+          collectible.velocity += directionUnit * (COLLECTIBLE_MAGNET_VELOCITY_MIN - inwardVelocity);
+      }
+
+      auto velocityLength = std::sqrt((collectible.velocity.x * collectible.velocity.x) +
+                                      (collectible.velocity.y * collectible.velocity.y));
+      if (velocityLength > COLLECTIBLE_MAGNET_SPEED_MAX)
+      {
+        auto velocityScale = COLLECTIBLE_MAGNET_SPEED_MAX / velocityLength;
+        collectible.velocity *= velocityScale;
+      }
+
+      auto velocityRetention = std::pow(COLLECTIBLE_MAGNET_FRICTION_PER_SECOND, dt);
+      collectible.velocity *= velocityRetention;
+      collectible.position += collectible.velocity * dt;
+      if (collectible.position.x < minX || collectible.position.x > maxX) collectible.velocity.x = PLAYER_VELOCITY_STOP;
+      if (collectible.position.y < minY || collectible.position.y > maxY) collectible.velocity.y = PLAYER_VELOCITY_STOP;
+      collectible.position.x = std::clamp(collectible.position.x, minX, maxX);
+      collectible.position.y = std::clamp(collectible.position.y, minY, maxY);
+    }
+  }
+
+  bool Gather::wave_complete_get(const std::vector<Entity>& wave)
+  {
+    if (wave.empty()) return false;
+    for (auto& collectible : wave)
+      if (!collectible.isCollected) return false;
+    return true;
+  }
+
+  void Gather::collectibles_draw(const std::vector<Entity>& wave, ImDrawList* drawList, ImVec2 canvasMin, float time,
+                                 ImU32 color)
+  {
+    for (auto& collectible : wave)
+    {
+      if (collectible.isCollected) continue;
+      auto size = COLLECTIBLE_SIZE + (std::sin((time * COLLECTIBLE_OSCILLATION_SPEED) + collectible.phase) *
+                                      COLLECTIBLE_OSCILLATION_AMOUNT);
+      auto half = size * CENTER_RATIO;
+      auto min = ImVec2(canvasMin.x + collectible.position.x - half, canvasMin.y + collectible.position.y - half);
+      auto max = ImVec2(min.x + size, min.y + size);
+      drawList->AddRectFilled(min, max, color);
+    }
+  }
+
+  void Gather::magnet_radius_draw(ImDrawList* drawList, ImVec2 canvasMin, const Entity& player, float radius)
+  {
+    auto center = ImVec2(canvasMin.x + player.position.x, canvasMin.y + player.position.y);
+    drawList->AddCircle(center, radius, IM_COL32(0, 0, COLOR_MAGNET_BLUE, COLOR_MAGNET_ALPHA), MAGNET_CIRCLE_SEGMENTS,
+                        MAGNET_CIRCLE_THICKNESS);
+  }
+
+  int Gather::alpha_get(int alpha, float multiplier)
+  {
+    return (int)((float)alpha * std::clamp(multiplier, STAMINA_MIN, STAMINA_MAX));
+  }
+
+  void Gather::progress_bar_draw(ImDrawList* drawList, ImVec2 min, ImVec2 max, float progress, ImU32 backgroundColor,
+                                 ImU32 fillColor, const std::string& text)
+  {
+    auto fillMax = ImVec2(min.x + ((max.x - min.x) * std::clamp(progress, STAMINA_MIN, STAMINA_MAX)), max.y);
+    drawList->AddRectFilled(min, max, backgroundColor, STAMINA_BAR_ROUNDING);
+    drawList->AddRectFilled(min, fillMax, fillColor, STAMINA_BAR_ROUNDING);
+    if (text.empty()) return;
+
+    auto textSize = util::imgui::draw_list_text_size_get(text, GAME_TEXT_FONT_SIZE);
+    auto textPos = ImVec2(min.x + ((max.x - min.x - textSize.x) * CENTER_RATIO),
+                          min.y + ((max.y - min.y - textSize.y) * CENTER_RATIO));
+    util::imgui::draw_list_text_draw(
+        *drawList, textPos, text, GAME_TEXT_FONT_SIZE,
+        IM_COL32(COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX));
+  }
+
+  void Gather::reset()
+  {
+    player = {};
+    collectibles.clear();
+    nextCollectibles.clear();
+    staminaPickups.clear();
+    nextStaminaPickups.clear();
+    targetPosition = {};
+    stamina = STAMINA_MAX;
+    boostTime = STAMINA_MIN;
+    magnetRadiusTime = STAMINA_MIN;
+    timeTicks = GAME_TIME_START_TICKS;
+    timeGainTicks = STAMINA_MIN;
+    timeGainAlpha = STAMINA_MIN;
+    score = 0;
+    wave = 1;
+    isStarted = false;
+    isPaused = false;
+    isMenuFullscreenKnown = false;
+    isMenuFullscreenLast = false;
+    isWaveResetPending = false;
+    waveResetAlpha = STAMINA_MAX;
+  }
+
+  void Gather::start(ImVec2 canvasSize)
+  {
+    reset();
+    player.position = glm::vec2(canvasSize.x * CENTER_RATIO, canvasSize.y * CENTER_RATIO);
+    targetPosition = player.position;
+    isStarted = true;
+    wave_reset(canvasSize);
+  }
+
+  void Gather::wave_reset(ImVec2 canvasSize)
+  {
+    wave_spawn(collectibles, canvasSize, wave);
+    wave_spawn(nextCollectibles, canvasSize, wave + 1);
+    stamina_pickups_spawn(staminaPickups, canvasSize, wave);
+    stamina_pickups_spawn(nextStaminaPickups, canvasSize, wave + 1);
+    magnetRadiusTime = STAMINA_MIN;
+    isWaveResetPending = false;
+    waveResetAlpha = STAMINA_MAX;
+  }
+
+  void Gather::wave_reset_request()
+  {
+    isWaveResetPending = true;
+    waveResetAlpha = STAMINA_MAX;
+    magnetRadiusTime = STAMINA_MIN;
+  }
+
+  void Gather::score_draw(ImDrawList* drawList, ImVec2 canvasMin, int score, int wave)
+  {
+    auto scoreText = std::format("{}", score);
+    auto position = ImVec2(canvasMin.x + SCORE_TEXT_PADDING, canvasMin.y + SCORE_TEXT_PADDING);
+    util::imgui::draw_list_text_draw(
+        *drawList, position, scoreText, GAME_TEXT_FONT_SIZE,
+        IM_COL32(COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX));
+    auto waveText = std::format("Wave #{}", wave);
+    auto wavePosition = ImVec2(position.x, position.y + (GAME_TEXT_FONT_SIZE * SCORE_TEXT_LINE_MULTIPLIER));
+    util::imgui::draw_list_text_draw(
+        *drawList, wavePosition, waveText, GAME_TEXT_FONT_SIZE,
+        IM_COL32(COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX));
+  }
+
+  void Gather::time_draw(ImDrawList* drawList, ImVec2 canvasMin, ImVec2 canvasMax, float timeTicks, float timeGainTicks,
+                         float timeGainAlpha)
+  {
+    auto timeText = util::time::ticks_to_minutes_seconds_centiseconds((int)std::ceil(timeTicks));
+    auto textSize = util::imgui::draw_list_text_size_get(timeText, GAME_TEXT_FONT_SIZE);
+    auto textWidth = util::imgui::draw_list_digit_fixed_width_get(timeText, GAME_TEXT_FONT_SIZE);
+    auto textPos = ImVec2(canvasMax.x - textWidth - TIME_TEXT_PADDING, canvasMin.y + TIME_TEXT_PADDING);
+    util::imgui::draw_list_digit_fixed_width_draw(*drawList, textPos, timeText, GAME_TEXT_FONT_SIZE,
+                                                  IM_COL32(COLOR_TIME, COLOR_TIME, COLOR_TIME, COLOR_CHANNEL_MAX));
+
+    if (timeGainAlpha <= STAMINA_MIN) return;
+    auto gainText =
+        std::format("+{}", util::time::ticks_to_minutes_seconds_centiseconds((int)std::ceil(timeGainTicks)));
+    auto alpha = (int)(COLOR_CHANNEL_MAX * std::clamp(timeGainAlpha, STAMINA_MIN, STAMINA_MAX));
+    auto gainTextWidth = util::imgui::draw_list_digit_fixed_width_get(gainText, GAME_TEXT_FONT_SIZE);
+    auto gainPos = ImVec2(canvasMax.x - gainTextWidth - TIME_TEXT_PADDING, textPos.y + textSize.y + TIME_TEXT_PADDING);
+    util::imgui::draw_list_digit_fixed_width_draw(*drawList, gainPos, gainText, GAME_TEXT_FONT_SIZE,
+                                                  IM_COL32(COLOR_TIME, COLOR_TIME, COLOR_TIME, alpha));
+  }
+
+  void Gather::update(bool isMenuFullscreen, bool isMenuResizeSettled)
+  {
+    auto canvasSize = ImGui::GetContentRegionAvail();
+    if (canvasSize.x <= CANVAS_MIN_SIZE || canvasSize.y <= CANVAS_MIN_SIZE) return;
+
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2());
+    if (ImGui::BeginChild("##Gather Canvas Child", canvasSize, ImGuiChildFlags_None, CANVAS_FLAGS))
+    {
+      canvasSize = ImGui::GetContentRegionAvail();
+      auto canvasMin = ImGui::GetCursorScreenPos();
+      auto canvasMax = ImVec2(canvasMin.x + canvasSize.x, canvasMin.y + canvasSize.y);
+      auto drawList = ImGui::GetWindowDrawList();
+      auto dt = ImGui::GetIO().DeltaTime;
+      auto isCanvasFocused = ImGui::IsWindowFocused();
+
+      ImGui::InvisibleButton("##Gather Canvas", canvasSize);
+      auto isCanvasHovered = ImGui::IsItemHovered();
+
+      drawList->AddRectFilled(canvasMin, canvasMax, IM_COL32(0, 0, 0, COLOR_CHANNEL_MAX / 2));
+
+      if (!isMenuFullscreenKnown)
+      {
+        isMenuFullscreenKnown = true;
+        isMenuFullscreenLast = isMenuFullscreen;
+      }
+      auto isMenuFullscreenChanged = isMenuFullscreenLast != isMenuFullscreen;
+      isMenuFullscreenLast = isMenuFullscreen;
+
+      if (isStarted && isMenuFullscreenChanged) wave_reset_request();
+
+      if (isStarted && isWaveResetPending)
+      {
+        waveResetAlpha = std::max(STAMINA_MIN, waveResetAlpha - (dt / WAVE_RESET_FADE_SECONDS));
+        if (isMenuResizeSettled) wave_reset(canvasSize);
+      }
+
+      if (!isStarted && isCanvasHovered && ImGui::IsMouseClicked(ImGuiMouseButton_Left)) start(canvasSize);
+
+      if (isStarted)
+      {
+        if (isCanvasFocused && ImGui::IsKeyPressed(ImGuiKey_P, false)) isPaused = !isPaused;
+
+        auto playerHalf = PLAYER_SIZE * CENTER_RATIO;
+        auto minX = std::min(playerHalf, canvasSize.x * CENTER_RATIO);
+        auto minY = std::min(playerHalf, canvasSize.y * CENTER_RATIO);
+        auto maxX = std::max(minX, canvasSize.x - playerHalf);
+        auto maxY = std::max(minY, canvasSize.y - playerHalf);
+
+        player.position.x = std::clamp(player.position.x, minX, maxX);
+        player.position.y = std::clamp(player.position.y, minY, maxY);
+        targetPosition.x = std::clamp(targetPosition.x, minX, maxX);
+        targetPosition.y = std::clamp(targetPosition.y, minY, maxY);
+
+        if (!isPaused)
+        {
+          if (isCanvasHovered)
+          {
+            auto mouse = ImGui::GetIO().MousePos;
+            targetPosition =
+                glm::vec2(std::clamp(mouse.x - canvasMin.x, minX, maxX), std::clamp(mouse.y - canvasMin.y, minY, maxY));
+          }
+
+          timeTicks = std::max(STAMINA_MIN, timeTicks - (Entity::UPDATE_RATE * dt));
+          if (timeTicks <= STAMINA_MIN) reset();
+
+          if (isStarted)
+          {
+            timeGainAlpha = std::max(STAMINA_MIN, timeGainAlpha - (dt / TIME_GAIN_FADE_SECONDS));
+            stamina =
+                std::clamp(stamina + (STAMINA_REGEN_PER_TICK * Entity::UPDATE_RATE * dt), STAMINA_MIN, STAMINA_MAX);
+            if (isCanvasHovered && ImGui::IsMouseClicked(ImGuiMouseButton_Middle) && stamina >= STAMINA_MAGNET_COST)
+            {
+              magnetRadiusTime = COLLECTIBLE_MAGNET_RADIUS_EXTEND_SECONDS;
+              stamina = std::max(STAMINA_MIN, stamina - STAMINA_MAGNET_COST);
+            }
+            if (isCanvasHovered && ImGui::IsMouseClicked(ImGuiMouseButton_Right) && stamina >= STAMINA_BOOST_COST)
+            {
+              auto boostDirection = targetPosition - player.position;
+              auto boostDirectionLength =
+                  std::sqrt((boostDirection.x * boostDirection.x) + (boostDirection.y * boostDirection.y));
+              if (boostDirectionLength > BOOST_DIRECTION_EPSILON)
+              {
+                auto boostDirectionScale = BOOST_DIRECTION_UNIT / boostDirectionLength;
+                auto boostDirectionUnit = boostDirection * boostDirectionScale;
+                player.velocity.x += boostDirectionUnit.x * PLAYER_BOOST_VELOCITY_GAIN;
+                player.velocity.y += boostDirectionUnit.y * PLAYER_BOOST_VELOCITY_GAIN;
+                auto boostVelocity =
+                    (player.velocity.x * boostDirectionUnit.x) + (player.velocity.y * boostDirectionUnit.y);
+                if (boostVelocity < PLAYER_BOOST_VELOCITY_MIN)
+                {
+                  auto boostVelocityAdd = PLAYER_BOOST_VELOCITY_MIN - boostVelocity;
+                  player.velocity.x += boostDirectionUnit.x * boostVelocityAdd;
+                  player.velocity.y += boostDirectionUnit.y * boostVelocityAdd;
+                }
+                boostTime = PLAYER_BOOST_DURATION;
+                stamina = std::max(STAMINA_MIN, stamina - STAMINA_BOOST_COST);
+              }
+            }
+
+            player.velocity.x += (targetPosition.x - player.position.x) * PLAYER_ACCELERATION * dt;
+            player.velocity.y += (targetPosition.y - player.position.y) * PLAYER_ACCELERATION * dt;
+            auto velocityRetention = std::pow(PLAYER_FRICTION_PER_SECOND, dt);
+            player.velocity.x *= velocityRetention;
+            player.velocity.y *= velocityRetention;
+            auto velocityLength =
+                std::sqrt((player.velocity.x * player.velocity.x) + (player.velocity.y * player.velocity.y));
+            auto isBoostActive = boostTime > STAMINA_MIN;
+            if (!isBoostActive && velocityLength > PLAYER_VELOCITY_MAX)
+            {
+              auto velocityScale = PLAYER_VELOCITY_MAX / velocityLength;
+              player.velocity.x *= velocityScale;
+              player.velocity.y *= velocityScale;
+            }
+            boostTime = std::max(STAMINA_MIN, boostTime - dt);
+            player.position.x += player.velocity.x * dt;
+            player.position.y += player.velocity.y * dt;
+
+            if (player.position.x < minX || player.position.x > maxX) player.velocity.x = PLAYER_VELOCITY_STOP;
+            if (player.position.y < minY || player.position.y > maxY) player.velocity.y = PLAYER_VELOCITY_STOP;
+            player.position.x = std::clamp(player.position.x, minX, maxX);
+            player.position.y = std::clamp(player.position.y, minY, maxY);
+
+            if (!isWaveResetPending)
+            {
+              auto magnetRadius = magnet_radius_get(magnetRadiusTime, isMenuFullscreen);
+              collectibles_magnet_update(collectibles, player, canvasSize, magnetRadius, dt);
+              magnetRadiusTime = std::max(STAMINA_MIN, magnetRadiusTime - dt);
+              score += collectibles_collect(collectibles, player);
+              if (collectibles_collect(staminaPickups, player) > 0) stamina = STAMINA_MAX;
+              if (wave_complete_get(collectibles))
+              {
+                timeGainTicks = wave_time_gain_ticks_get();
+                timeTicks += timeGainTicks;
+                timeGainAlpha = TIME_GAIN_ALPHA_MAX;
+                ++wave;
+                collectibles = nextCollectibles;
+                staminaPickups = nextStaminaPickups;
+                wave_spawn(nextCollectibles, canvasSize, wave + 1);
+                stamina_pickups_spawn(nextStaminaPickups, canvasSize, wave + 1);
+              }
+            }
+          }
+        }
+      }
+
+      if (isStarted)
+      {
+        auto playerHalf = PLAYER_SIZE * CENTER_RATIO;
+        auto collectibleAlpha = alpha_get(COLOR_COLLECTIBLE_ALPHA, waveResetAlpha);
+        auto nextCollectibleAlpha = alpha_get(COLOR_COLLECTIBLE_NEXT_ALPHA, waveResetAlpha);
+        collectibles_draw(nextCollectibles, drawList, canvasMin, (float)ImGui::GetTime(),
+                          IM_COL32(0, 0, COLOR_COLLECTIBLE_BLUE, nextCollectibleAlpha));
+        collectibles_draw(nextStaminaPickups, drawList, canvasMin, (float)ImGui::GetTime(),
+                          IM_COL32(0, COLOR_GREEN, 0, nextCollectibleAlpha));
+        collectibles_draw(collectibles, drawList, canvasMin, (float)ImGui::GetTime(),
+                          IM_COL32(0, 0, COLOR_COLLECTIBLE_BLUE, collectibleAlpha));
+        collectibles_draw(staminaPickups, drawList, canvasMin, (float)ImGui::GetTime(),
+                          IM_COL32(0, COLOR_GREEN, 0, collectibleAlpha));
+        magnet_radius_draw(drawList, canvasMin, player, magnet_radius_get(magnetRadiusTime, isMenuFullscreen));
+
+        auto playerMin =
+            ImVec2(canvasMin.x + player.position.x - playerHalf, canvasMin.y + player.position.y - playerHalf);
+        auto playerMax = ImVec2(playerMin.x + PLAYER_SIZE, playerMin.y + PLAYER_SIZE);
+        drawList->AddRectFilled(playerMin, playerMax,
+                                IM_COL32(COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX));
+
+        auto staminaBarWidth =
+            std::min(STAMINA_BAR_WIDTH,
+                     std::max(CANVAS_MIN_SIZE, canvasSize.x - (STAMINA_BAR_PADDING * STAMINA_BAR_PADDING_MULTIPLIER)));
+        auto staminaBarMin = ImVec2(canvasMax.x - staminaBarWidth - STAMINA_BAR_PADDING,
+                                    canvasMax.y - STAMINA_BAR_HEIGHT - STAMINA_BAR_PADDING);
+        auto staminaBarMax = ImVec2(staminaBarMin.x + staminaBarWidth, staminaBarMin.y + STAMINA_BAR_HEIGHT);
+        progress_bar_draw(drawList, staminaBarMin, staminaBarMax, stamina,
+                          IM_COL32(0, COLOR_GREEN_DIM, 0, COLOR_CHANNEL_MAX),
+                          IM_COL32(0, COLOR_GREEN, 0, COLOR_CHANNEL_MAX));
+        score_draw(drawList, canvasMin, score, wave);
+        time_draw(drawList, canvasMin, canvasMax, timeTicks, timeGainTicks, timeGainAlpha);
+        if (isPaused)
+          util::imgui::draw_list_text_center_draw(
+              *drawList, canvasMin, canvasSize, "PAUSED", GAME_TEXT_FONT_SIZE, CENTER_RATIO, CENTER_RATIO,
+              IM_COL32(COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX));
+      }
+      else
+        util::imgui::draw_list_text_center_draw(
+            *drawList, canvasMin, canvasSize, "Click to start!", GAME_TEXT_FONT_SIZE, CENTER_RATIO, START_TEXT_Y_RATIO,
+            IM_COL32(COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX, COLOR_CHANNEL_MAX));
+    }
+    ImGui::EndChild();
+    ImGui::PopStyleVar(STYLE_VAR_COUNT);
+  }
+}
diff --git a/src/state/play/menu/gather.hpp b/src/state/play/menu/gather.hpp
new file mode 100644
index 0000000..bf15af8
--- /dev/null
+++ b/src/state/play/menu/gather.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include "../../../entity.hpp"
+
+#include <imgui.h>
+#include <string>
+#include <vector>
+
+namespace game::state::play::menu
+{
+  class Gather
+  {
+  public:
+    Entity player{};
+    std::vector<Entity> collectibles{};
+    std::vector<Entity> nextCollectibles{};
+    std::vector<Entity> staminaPickups{};
+    std::vector<Entity> nextStaminaPickups{};
+    glm::vec2 targetPosition{};
+    float stamina{};
+    float boostTime{};
+    float magnetRadiusTime{};
+    float timeTicks{};
+    float timeGainTicks{};
+    float timeGainAlpha{};
+    int score{};
+    int wave{};
+    bool isStarted{};
+    bool isPaused{};
+    bool isMenuFullscreenKnown{};
+    bool isMenuFullscreenLast{};
+    bool isWaveResetPending{};
+    float waveResetAlpha{};
+
+    void update(bool isMenuFullscreen, bool isMenuResizeSettled);
+
+  private:
+    enum class Structure
+    {
+      SINGLE,
+      LINE_HORIZONTAL,
+      LINE_VERTICAL,
+      POLYGON
+    };
+
+    static float random_range_get(float, float);
+    static glm::vec2 random_position_get(float, float, float, float);
+    static Entity collectible_make(glm::vec2);
+    static Structure structure_get(int);
+    static int structure_count_get(int);
+    static int wave_collectible_count_get(int);
+    static void collectible_add(std::vector<Entity>&, glm::vec2, int);
+    static void single_spawn(std::vector<Entity>&, ImVec2, float, int);
+    static void line_spawn(std::vector<Entity>&, ImVec2, float, bool, int, int);
+    static float polygon_radius_get(int);
+    static void polygon_spawn(std::vector<Entity>&, ImVec2, float, int, int);
+    static void wave_spawn(std::vector<Entity>&, ImVec2, int);
+    static int stamina_pickup_count_get(int);
+    static void stamina_pickups_spawn(std::vector<Entity>&, ImVec2, int);
+    static float wave_time_gain_ticks_get();
+    static bool collectible_hit_get(const Entity&, const Entity&);
+    static float magnet_radius_get(float, bool isMenuFullscreen);
+    static int collectibles_collect(std::vector<Entity>&, const Entity&);
+    static void collectibles_magnet_update(std::vector<Entity>&, const Entity&, ImVec2, float, float);
+    static bool wave_complete_get(const std::vector<Entity>&);
+    static void collectibles_draw(const std::vector<Entity>&, ImDrawList*, ImVec2, float, ImU32);
+    static void magnet_radius_draw(ImDrawList*, ImVec2, const Entity&, float);
+    static int alpha_get(int, float);
+    static void progress_bar_draw(ImDrawList*, ImVec2, ImVec2, float, ImU32, ImU32, const std::string& = {});
+    static void score_draw(ImDrawList*, ImVec2, int, int);
+    static void time_draw(ImDrawList*, ImVec2, ImVec2, float, float, float);
+    void reset();
+    void start(ImVec2);
+    void wave_reset(ImVec2);
+    void wave_reset_request();
+  };
+}
diff --git a/src/state/play/menu/interact.cpp b/src/state/play/menu/interact.cpp
index a654d7f..3ef98ea 100644
--- a/src/state/play/menu/interact.cpp
+++ b/src/state/play/menu/interact.cpp
@@ -1,7 +1,8 @@
 #include "interact.hpp"
 
+#include "../info.hpp"
+
 #include "../../../util/imgui/widget.hpp"
-#include "../../../util/measurement.hpp"
 
 using namespace game::resource;
 using namespace game::resource::xml;
@@ -10,48 +11,73 @@ using namespace game::util::imgui;
 
 namespace game::state::play::menu
 {
-  void Interact::update(Resources& resources, Text& text, entity::Character& character)
+  void Interact::update(Resources& resources, Text& text, Entity& character, bool)
   {
+    static constexpr auto ZERO_FLOAT = 0.0f;
+
     auto& dialogue = character.data.dialogue;
     auto& strings = character.data.strings;
-    auto size = ImGui::GetContentRegionAvail();
-
-    ImGui::PushFont(ImGui::GetFont(), resource::Font::HEADER_2);
-
-    if (dialogue.random.is_valid())
-      if (WIDGET_FX(ImGui::Button(strings.get(Strings::InteractChatButton).c_str(), ImVec2(size.x, 0))))
-        text.set(dialogue.get(dialogue.random), character);
-
-    ImGui::PopFont();
-
-    if (dialogue.help.is_valid())
-      if (WIDGET_FX(ImGui::Button(strings.get(Strings::InteractHelpButton).c_str(), ImVec2(size.x, 0))))
-        text.set(dialogue.get(dialogue.help), character);
-
+    auto* random = dialogue.get(Schema::Element::RANDOM);
+    auto* help = dialogue.get(Schema::Element::HELP);
     auto stage = glm::clamp(0, character.stage_get(), character.stage_max_get());
-    auto& pool = stage > 0 ? character.data.stages.at(stage - 1).pool : character.data.pool;
-
-    if (pool.is_valid())
-      if (WIDGET_FX(
-              ImGui::Button(strings.get(Strings::InteractFeelingButton).c_str(), ImVec2(size.x, 0))))
-        text.set(dialogue.get(pool), character);
+    auto poolID = character.data.stage_pool_id_get(stage);
+    auto isFeelingAvailable = poolID != -1;
 
     ImGui::PushFont(ImGui::GetFont(), resource::Font::HEADER_1);
-    ImGui::SeparatorText(character.data.name.c_str());
+    ImGui::SeparatorText(character.data.root()->name.c_str());
     ImGui::PopFont();
 
-    auto& system = resources.settings.measurementSystem;
-    auto weight = character.weight_get(system);
-    auto weightUnit = system == measurement::IMPERIAL ? "lbs" : "kg";
+    info_content_draw(resources, character, ImVec2(ImGui::GetContentRegionAvail().x, info_height_get()));
 
-    ImGui::Text(strings.get(Strings::InteractWeightFormat).c_str(), weight, weightUnit,
-                character.stage_get() + 1);
-    ImGui::Text(strings.get(Strings::InteractCapacityFormat).c_str(), character.capacity,
-                character.max_capacity());
-    ImGui::Text(strings.get(Strings::InteractDigestionRateFormat).c_str(), character.digestion_rate_get());
-    ImGui::Text(strings.get(Strings::InteractEatingSpeedFormat).c_str(), character.eatSpeed);
-    ImGui::Separator();
-    ImGui::Text(strings.get(Strings::InteractTotalCaloriesFormat).c_str(), character.totalCaloriesConsumed);
-    ImGui::Text(strings.get(Strings::InteractTotalFoodItemsFormat).c_str(), character.totalFoodItemsEaten);
+    auto buttonHeight = ZERO_FLOAT;
+    if (random)
+    {
+      ImGui::PushFont(ImGui::GetFont(), resource::Font::HEADER_1);
+      buttonHeight += ImGui::GetFrameHeightWithSpacing();
+      ImGui::PopFont();
+    }
+    if (help)
+    {
+      ImGui::PushFont(ImGui::GetFont(), resource::Font::HEADER_2);
+      buttonHeight += ImGui::GetFrameHeightWithSpacing();
+      ImGui::PopFont();
+    }
+    if (isFeelingAvailable)
+    {
+      ImGui::PushFont(ImGui::GetFont(), resource::Font::HEADER_2);
+      buttonHeight += ImGui::GetFrameHeightWithSpacing();
+      ImGui::PopFont();
+    }
+
+    auto fillerHeight = ImGui::GetContentRegionAvail().y - buttonHeight;
+    if (fillerHeight > ZERO_FLOAT) ImGui::Dummy(ImVec2(ImGui::GetContentRegionAvail().x, fillerHeight));
+
+    if (random)
+    {
+      ImGui::PushFont(ImGui::GetFont(), resource::Font::HEADER_1);
+      if (WIDGET_FX(ImGui::Button(strings.get(Strings::InteractChatButton).c_str(),
+                                  ImVec2(ImGui::GetContentRegionAvail().x, ZERO_FLOAT))))
+        text.set(dialogue.dialogue_pool_entry_get(*random), character);
+      ImGui::PopFont();
+    }
+
+    if (help)
+    {
+      ImGui::PushFont(ImGui::GetFont(), resource::Font::HEADER_2);
+      if (WIDGET_FX(ImGui::Button(strings.get(Strings::InteractHelpButton).c_str(),
+                                  ImVec2(ImGui::GetContentRegionAvail().x, ZERO_FLOAT))))
+        text.set(dialogue.dialogue_entry_get(*help), character);
+      ImGui::PopFont();
+    }
+
+    if (poolID != -1)
+    {
+      ImGui::PushFont(ImGui::GetFont(), resource::Font::HEADER_2);
+      if (WIDGET_FX(
+              ImGui::Button(strings.get(Strings::InteractFeelingButton).c_str(),
+                            ImVec2(ImGui::GetContentRegionAvail().x, ZERO_FLOAT))))
+        text.set(dialogue.dialogue_pool_entry_get(poolID), character);
+      ImGui::PopFont();
+    }
   }
 }
diff --git a/src/state/play/menu/interact.hpp b/src/state/play/menu/interact.hpp
index 9e1706e..1add545 100644
--- a/src/state/play/menu/interact.hpp
+++ b/src/state/play/menu/interact.hpp
@@ -9,6 +9,6 @@ namespace game::state::play::menu
   class Interact
   {
   public:
-    void update(Resources&, Text&, entity::Character&);
+    void update(Resources&, Text&, Entity&, bool isMenuFullscreen);
   };
 }
diff --git a/src/state/play/menu/inventory.cpp b/src/state/play/menu/inventory.cpp
index 74425e5..2ba7e30 100644
--- a/src/state/play/menu/inventory.cpp
+++ b/src/state/play/menu/inventory.cpp
@@ -1,4 +1,5 @@
 #include "inventory.hpp"
+#include "../autofeed.hpp"
 #include "../style.hpp"
 
 #include <cmath>
@@ -15,7 +16,6 @@
 
 using namespace game::util;
 using namespace game::util::imgui;
-using namespace game::entity;
 using namespace game::resource;
 using namespace glm;
 
@@ -23,14 +23,85 @@ namespace game::state::play::menu
 {
   using Strings = resource::xml::Strings;
 
-  void Inventory::tick()
+  namespace
   {
-    for (auto& [i, actor] : actors)
-      actor.tick();
+    int& quantity_get(std::map<int, int>& values, const resource::xml::Schema& schema, int itemID)
+    {
+      auto& quantity = values[itemID];
+      quantity = glm::clamp(0, quantity, schema.quantityMax);
+      return quantity;
+    }
+
+    bool is_possible_to_upgrade_get(const resource::xml::Schema& schema, const resource::xml::Schema::ItemEntry& item)
+    {
+      return item.isUpgradeID && item.isUpgradeCount && schema.idToStringMap.contains(item.upgradeID);
+    }
   }
 
-  void Inventory::update(Resources& resources, ItemManager& itemManager, entity::Character& character)
+  bool Inventory::can_upgrade(const resource::xml::Schema& schema, int itemID)
   {
+    if (itemID < 0 || itemID >= (int)schema.items.size()) return false;
+
+    auto& item = schema.items[itemID];
+    auto& quantity = quantity_get(values, schema, itemID);
+    return is_possible_to_upgrade_get(schema, item) && quantity >= item.upgradeCount;
+  }
+
+  bool Inventory::upgrade(resource::xml::Schema& schema, int itemID, bool isAll)
+  {
+    if (itemID < 0 || itemID >= (int)schema.items.size()) return false;
+
+    auto& item = schema.items[itemID];
+    auto& quantity = quantity_get(values, schema, itemID);
+
+    if (!is_possible_to_upgrade_get(schema, item) || quantity < item.upgradeCount)
+    {
+      schema.root()->soundUpgradeFail.play();
+      return false;
+    }
+
+    if (isAll)
+    {
+      while (quantity >= item.upgradeCount)
+      {
+        values[item.upgradeID]++;
+        quantity -= item.upgradeCount;
+      }
+    }
+    else
+    {
+      values[item.upgradeID]++;
+      quantity -= item.upgradeCount;
+    }
+
+    schema.root()->soundUpgrade.play();
+    if (quantity < item.upgradeCount && selectedItemID == itemID) selectedItemID = item.upgradeID;
+    return true;
+  }
+
+  bool Inventory::upgrade_all_possible(resource::xml::Schema& schema)
+  {
+    auto isUpgraded = false;
+
+    for (auto isPassUpgraded = true; isPassUpgraded;)
+    {
+      isPassUpgraded = false;
+      for (int itemID = 0; itemID < (int)schema.items.size(); itemID++)
+      {
+        if (!can_upgrade(schema, itemID)) continue;
+        isPassUpgraded = upgrade(schema, itemID, true) || isPassUpgraded;
+        isUpgraded = isPassUpgraded || isUpgraded;
+      }
+    }
+
+    return isUpgraded;
+  }
+
+  void Inventory::update(Resources& resources, ItemManager& itemManager, Entity& character, Autofeed& autofeed)
+  {
+    for (auto& [i, actor] : actors)
+      actor.update();
+
     static constexpr auto INFO_CHILD_HEIGHT_MAX_MULTIPLIER = 0.5f;
     bool isSelectedItemPressed{};
     int pressedItemQuantity{-1};
@@ -38,69 +109,59 @@ namespace game::state::play::menu
     auto& schema = character.data.itemSchema;
     auto& strings = character.data.strings;
 
-    auto quantity_get = [&](int itemID) -> int&
-    {
-      auto& quantity = values[itemID];
-      quantity = glm::clamp(0, quantity, schema.quantityMax);
-      return quantity;
-    };
+    auto inventory_quantity_get = [&](int itemID) -> int& { return quantity_get(values, schema, itemID); };
 
-    auto is_possible_to_upgrade_get = [&](const resource::xml::Item::Entry& item)
-    {
-      return item.upgradeID.has_value() && item.upgradeCount.has_value() &&
-             schema.idToStringMap.contains(*item.upgradeID);
-    };
+    auto is_possible_to_upgrade_get = [&](const resource::xml::Schema::ItemEntry& item)
+    { return game::state::play::menu::is_possible_to_upgrade_get(schema, item); };
 
-    auto is_able_to_upgrade_get = [&](const resource::xml::Item::Entry& item, int quantity)
-    { return is_possible_to_upgrade_get(item) && quantity >= *item.upgradeCount; };
+    auto is_able_to_upgrade_get = [&](const resource::xml::Schema::ItemEntry& item, int quantity)
+    { return is_possible_to_upgrade_get(item) && quantity >= item.upgradeCount; };
 
-    auto item_header_draw = [&](const resource::xml::Item::Entry& item, int quantity)
+    auto item_header_draw = [&](const resource::xml::Schema::ItemEntry& item, int quantity)
     {
       ImGui::PushFont(ImGui::GetFont(), Font::HEADER_2);
       ImGui::TextWrapped("%s (x%i)", item.name.c_str(), quantity);
       ImGui::PopFont();
     };
 
-    auto item_summary_draw = [&](const resource::xml::Item::Entry& item)
+    auto item_summary_draw = [&](const resource::xml::Schema::ItemEntry& item)
     {
       auto& category = schema.categories[item.categoryID];
       auto& rarity = schema.rarities[item.rarityID];
-      auto durability = item.durability.value_or(schema.durability);
+      auto durability = item.isDurability ? item.durability : schema.durability;
 
       ImGui::PushStyleColor(ImGuiCol_Text, ImGui::GetColorU32(imgui::to_imvec4(color::GRAY)));
       ImGui::TextWrapped("-- %s (%s) --", category.name.c_str(), rarity.name.c_str());
-      if (item.flavorID.has_value())
+      if (item.isFlavor)
         ImGui::TextWrapped(strings.get(Strings::InventoryFlavorFormat).c_str(),
-                           schema.flavors[*item.flavorID].name.c_str());
-      if (item.calories.has_value())
-        ImGui::TextWrapped(strings.get(Strings::InventoryCaloriesFormat).c_str(), *item.calories);
+                           schema.flavors[item.flavorID].name.c_str());
+      if (item.isCalories) ImGui::TextWrapped(strings.get(Strings::InventoryCaloriesFormat).c_str(), item.calories);
       ImGui::TextWrapped(strings.get(Strings::InventoryDurabilityFormat).c_str(), durability);
-      if (item.capacityBonus.has_value())
-        ImGui::TextWrapped(strings.get(Strings::InventoryCapacityBonusFormat).c_str(), *item.capacityBonus);
-      if (item.digestionBonus.has_value())
+      if (item.isCapacityBonus)
+        ImGui::TextWrapped(strings.get(Strings::InventoryCapacityBonusFormat).c_str(), item.capacityBonus);
+      if (item.isDigestionBonus)
       {
-        if (*item.digestionBonus > 0)
+        if (item.digestionBonus > 0)
           ImGui::TextWrapped(strings.get(Strings::InventoryDigestionRateBonusFormat).c_str(),
-                             *item.digestionBonus * 60.0f);
-        else if (*item.digestionBonus < 0)
+                             item.digestionBonus * 60.0f);
+        else if (item.digestionBonus < 0)
           ImGui::TextWrapped(strings.get(Strings::InventoryDigestionRatePenaltyFormat).c_str(),
-                             *item.digestionBonus * 60.0f);
+                             item.digestionBonus * 60.0f);
       }
-      if (item.eatSpeedBonus.has_value())
+      if (item.isEatSpeedBonus)
       {
-        if (*item.eatSpeedBonus > 0)
-          ImGui::TextWrapped(strings.get(Strings::InventoryEatSpeedBonusFormat).c_str(), *item.eatSpeedBonus);
-        else if (*item.eatSpeedBonus < 0)
-          ImGui::TextWrapped(strings.get(Strings::InventoryEatSpeedPenaltyFormat).c_str(), *item.eatSpeedBonus);
+        if (item.eatSpeedBonus > 0)
+          ImGui::TextWrapped(strings.get(Strings::InventoryEatSpeedBonusFormat).c_str(), item.eatSpeedBonus);
+        else if (item.eatSpeedBonus < 0)
+          ImGui::TextWrapped(strings.get(Strings::InventoryEatSpeedPenaltyFormat).c_str(), item.eatSpeedBonus);
       }
       if (is_possible_to_upgrade_get(item))
-        ImGui::TextWrapped(strings.get(Strings::InventoryUpgradePreviewFormat).c_str(), *item.upgradeCount,
-                           schema.idToStringMap.at(*item.upgradeID).c_str());
+        ImGui::TextWrapped(strings.get(Strings::InventoryUpgradePreviewFormat).c_str(), item.upgradeCount,
+                           schema.idToStringMap.at(item.upgradeID).c_str());
       ImGui::PopStyleColor();
     };
 
-    auto info_section_separator_height_get = [&]()
-    { return ImGui::GetStyle().ItemSpacing.y + 1.0f; };
+    auto info_section_separator_height_get = [&]() { return ImGui::GetStyle().ItemSpacing.y + 1.0f; };
 
     auto info_section_separator_draw = [&]()
     {
@@ -113,7 +174,7 @@ namespace game::state::play::menu
       ImGui::Dummy(ImVec2(0.0f, separatorHeight));
     };
 
-    auto item_tooltip_draw = [&](const resource::xml::Item::Entry& item, int quantity)
+    auto item_tooltip_draw = [&](const resource::xml::Schema::ItemEntry& item, int quantity)
     {
       ImGui::PushTextWrapPos(ImGui::GetFontSize() * 24.0f);
       item_header_draw(item, quantity);
@@ -139,7 +200,7 @@ namespace game::state::play::menu
       return ImGui::CalcTextSize(text.data(), text.data() + text.size(), false, safeWrapWidth).y;
     };
 
-    auto item_header_height_get = [&](const resource::xml::Item::Entry& item, int quantity, float width)
+    auto item_header_height_get = [&](const resource::xml::Schema::ItemEntry& item, int quantity, float width)
     {
       float height{};
 
@@ -150,11 +211,11 @@ namespace game::state::play::menu
       return height;
     };
 
-    auto item_summary_height_get = [&](const resource::xml::Item::Entry& item, float width)
+    auto item_summary_height_get = [&](const resource::xml::Schema::ItemEntry& item, float width)
     {
       auto& category = schema.categories[item.categoryID];
       auto& rarity = schema.rarities[item.rarityID];
-      auto durability = item.durability.value_or(schema.durability);
+      auto durability = item.isDurability ? item.durability : schema.durability;
       auto itemSpacing = ImGui::GetStyle().ItemSpacing.y;
       float height{};
       int lineCount{};
@@ -167,46 +228,48 @@ namespace game::state::play::menu
       };
 
       add_line_height(std::format("-- {} ({}) --", category.name, rarity.name));
-      if (item.flavorID.has_value())
+      if (item.isFlavor)
         add_line_height(std::vformat(strings.get(Strings::InventoryFlavorFormat),
-                                     std::make_format_args(schema.flavors[*item.flavorID].name)));
-      if (item.calories.has_value())
-        add_line_height(std::vformat(strings.get(Strings::InventoryCaloriesFormat), std::make_format_args(*item.calories)));
-      add_line_height(std::vformat(strings.get(Strings::InventoryDurabilityFormat), std::make_format_args(durability)));
-      if (item.capacityBonus.has_value())
+                                     std::make_format_args(schema.flavors[item.flavorID].name)));
+      if (item.isCalories)
         add_line_height(
-            std::vformat(strings.get(Strings::InventoryCapacityBonusFormat), std::make_format_args(*item.capacityBonus)));
-      if (item.digestionBonus.has_value())
+            std::vformat(strings.get(Strings::InventoryCaloriesFormat), std::make_format_args(item.calories)));
+      add_line_height(std::vformat(strings.get(Strings::InventoryDurabilityFormat), std::make_format_args(durability)));
+      if (item.isCapacityBonus)
+        add_line_height(std::vformat(strings.get(Strings::InventoryCapacityBonusFormat),
+                                     std::make_format_args(item.capacityBonus)));
+      if (item.isDigestionBonus)
       {
-        if (*item.digestionBonus > 0)
+        if (item.digestionBonus > 0)
         {
-          auto digestionRateBonus = *item.digestionBonus * 60.0f;
-          add_line_height(
-              std::vformat(strings.get(Strings::InventoryDigestionRateBonusFormat), std::make_format_args(digestionRateBonus)));
+          auto digestionRateBonus = item.digestionBonus * 60.0f;
+          add_line_height(std::vformat(strings.get(Strings::InventoryDigestionRateBonusFormat),
+                                       std::make_format_args(digestionRateBonus)));
         }
-        else if (*item.digestionBonus < 0)
+        else if (item.digestionBonus < 0)
         {
-          auto digestionRatePenalty = *item.digestionBonus * 60.0f;
+          auto digestionRatePenalty = item.digestionBonus * 60.0f;
           add_line_height(std::vformat(strings.get(Strings::InventoryDigestionRatePenaltyFormat),
                                        std::make_format_args(digestionRatePenalty)));
         }
       }
-      if (item.eatSpeedBonus.has_value())
+      if (item.isEatSpeedBonus)
       {
-        if (*item.eatSpeedBonus > 0)
-          add_line_height(
-              std::vformat(strings.get(Strings::InventoryEatSpeedBonusFormat), std::make_format_args(*item.eatSpeedBonus)));
-        else if (*item.eatSpeedBonus < 0)
+        if (item.eatSpeedBonus > 0)
+          add_line_height(std::vformat(strings.get(Strings::InventoryEatSpeedBonusFormat),
+                                       std::make_format_args(item.eatSpeedBonus)));
+        else if (item.eatSpeedBonus < 0)
           add_line_height(std::vformat(strings.get(Strings::InventoryEatSpeedPenaltyFormat),
-                                       std::make_format_args(*item.eatSpeedBonus)));
+                                       std::make_format_args(item.eatSpeedBonus)));
       }
       if (is_possible_to_upgrade_get(item))
-        add_line_height(std::vformat(strings.get(Strings::InventoryUpgradePreviewFormat),
-                                     std::make_format_args(*item.upgradeCount, schema.idToStringMap.at(*item.upgradeID))));
+        add_line_height(
+            std::vformat(strings.get(Strings::InventoryUpgradePreviewFormat),
+                         std::make_format_args(item.upgradeCount, schema.idToStringMap.at(item.upgradeID))));
       return height;
     };
 
-    auto item_details_height_get = [&](const resource::xml::Item::Entry& item, int quantity, float width)
+    auto item_details_height_get = [&](const resource::xml::Schema::ItemEntry& item, int quantity, float width)
     {
       auto separatorHeight = info_section_separator_height_get();
       auto detailBodyHeight =
@@ -243,8 +306,8 @@ namespace game::state::play::menu
       else
       {
         auto& item = schema.items[selectedItemID];
-        measuredBodyHeight =
-            isSelectedItemKnown ? item_details_height_get(item, selectedQuantity, infoWidth) : item_unknown_height_get(infoWidth);
+        measuredBodyHeight = isSelectedItemKnown ? item_details_height_get(item, selectedQuantity, infoWidth)
+                                                 : item_unknown_height_get(infoWidth);
       }
 
       auto buttonChildHeight = 0.0f;
@@ -266,17 +329,17 @@ namespace game::state::play::menu
     {
       auto& item = schema.items[itemID];
       auto& category = schema.categories[item.categoryID];
-      auto& quantity = quantity_get(itemID);
+      auto& quantity = inventory_quantity_get(itemID);
 
       if (quantity <= 0) return;
 
       if (category.isEdible)
       {
         if (itemManager.items.size() + 1 >= ItemManager::LIMIT)
-          character.data.itemSchema.sounds.dispose.play();
+          character.data.itemSchema.root()->soundDispose.play();
         else
         {
-          character.data.itemSchema.sounds.summon.play();
+          character.data.itemSchema.root()->soundSummon.play();
           itemManager.queuedItemIDs.emplace_back(itemID);
           quantity--;
           if (quantity <= 0) selectedItemID = -1;
@@ -284,78 +347,17 @@ namespace game::state::play::menu
       }
       else if (item.isToggleSpritesheet)
       {
-        character.spritesheet_set(character.spritesheetType == Character::NORMAL ? Character::ALTERNATE
-                                                                                 : Character::NORMAL);
-        character.data.alternateSpritesheet.sound.play();
+        character.spritesheet_set(character.spritesheetType == Entity::NORMAL ? Entity::ALTERNATE : Entity::NORMAL);
+        if (auto* alternate = character.data.alternate_spritesheet()) alternate->soundEntry.sound.play();
         quantity--;
       }
     };
 
-    auto item_upgrade = [&](int itemID, bool isAll)
+    auto item_actor_get = [&](int itemID) -> Entity&
     {
-      auto& item = schema.items[itemID];
-      auto& quantity = quantity_get(itemID);
+      if (!actors.contains(itemID)) actors[itemID] = Entity(schema.anm2s[itemID], {}, Entity::SET);
 
-      if (!is_possible_to_upgrade_get(item))
-      {
-        schema.sounds.upgradeFail.play();
-        return;
-      }
-
-      if (!is_able_to_upgrade_get(item, quantity))
-      {
-        schema.sounds.upgradeFail.play();
-        return;
-      }
-
-      if (isAll)
-      {
-        while (quantity >= *item.upgradeCount)
-        {
-          values.at(*item.upgradeID)++;
-          quantity -= *item.upgradeCount;
-        }
-      }
-      else
-      {
-        values.at(*item.upgradeID)++;
-        quantity -= *item.upgradeCount;
-      }
-
-      schema.sounds.upgrade.play();
-
-      if (quantity < *item.upgradeCount && selectedItemID == itemID) selectedItemID = *item.upgradeID;
-    };
-
-    auto item_canvas_get = [&](int itemID, ImVec2 size)
-    {
-      if (!actors.contains(itemID))
-      {
-        actors[itemID] = Actor(schema.anm2s[itemID], {}, Actor::SET);
-        rects[itemID] = actors[itemID].rect();
-      }
-
-      auto& rect = rects[itemID];
-      auto rectSize = vec2(rect.z, rect.w);
-      auto previewScale = (size.x <= 0.0f || size.y <= 0.0f || rectSize.x <= 0.0f || rectSize.y <= 0.0f ||
-                           !std::isfinite(rectSize.x) || !std::isfinite(rectSize.y))
-                              ? 0.0f
-                              : std::min(size.x / rectSize.x, size.y / rectSize.y);
-
-      auto previewSize = rectSize * previewScale;
-      auto canvasSize = ivec2(std::max(1.0f, previewSize.x), std::max(1.0f, previewSize.y));
-      if (!canvases.contains(itemID)) canvases.emplace(itemID, Canvas(canvasSize, Canvas::FLIP));
-
-      auto& canvas = canvases[itemID];
-      canvas.zoom = math::to_percent(previewScale);
-      canvas.pan = vec2(rect.x, rect.y);
-      canvas.bind();
-      canvas.size_set(canvasSize);
-      canvas.clear();
-      actors[itemID].render(resources.shaders[shader::TEXTURE], resources.shaders[shader::RECT], canvas);
-      canvas.unbind();
-
-      return std::tuple<Canvas&, glm::vec4&>(canvas, rect);
+      return actors[itemID];
     };
 
     if (!itemManager.returnItemIDs.empty())
@@ -372,11 +374,18 @@ namespace game::state::play::menu
       auto available = ImGui::GetContentRegionAvail();
       auto isItemSelected = selectedItemID >= 0 && selectedItemID < (int)schema.items.size();
       auto isInfoVisible = isItemSelected || inventoryCount == 0;
-      auto infoChildHeight = info_child_height_get(available, isItemSelected, isItemSelected ? quantity_get(selectedItemID) : 0);
+      ImGui::PushFont(ImGui::GetFont(), Font::HEADER_2);
+      auto toggleButtonHeight = ImGui::GetFrameHeight();
+      ImGui::PopFont();
+      auto toggleChildHeight = toggleButtonHeight + ImGui::GetStyle().WindowPadding.y * 2.0f;
+      auto toggleSpacing = ImGui::GetStyle().ItemSpacing.y;
+      auto infoChildHeight =
+          info_child_height_get(available, isItemSelected, isItemSelected ? inventory_quantity_get(selectedItemID) : 0);
 
-      auto inventoryChildHeight =
-          isInfoVisible ? std::max(0.0f, available.y - infoChildHeight - ImGui::GetStyle().ItemSpacing.y) : available.y;
+      auto inventoryChildHeight = std::max(0.0f, available.y - infoChildHeight - toggleChildHeight -
+                                                     (isInfoVisible ? toggleSpacing * 2.0f : toggleSpacing));
       auto childSize = ImVec2(available.x, inventoryChildHeight);
+      auto toggleChildSize = ImVec2(available.x, toggleChildHeight);
       auto infoChildSize = ImVec2(available.x, infoChildHeight);
 
       if (ImGui::BeginChild("##Inventory List Child", childSize))
@@ -390,9 +399,9 @@ namespace game::state::play::menu
         for (int i = 0; i < (int)schema.items.size(); i++)
         {
           auto& item = schema.items[i];
-          auto& quantity = quantity_get(i);
+          auto& quantity = inventory_quantity_get(i);
           auto& rarity = schema.rarities[item.rarityID];
-          auto hasItemColor = item.color.has_value();
+          auto isItemColor = item.isColor;
 
           if (rarity.isHidden && quantity <= 0) continue;
 
@@ -400,9 +409,9 @@ namespace game::state::play::menu
 
           ImGui::SetCursorPos(cursorPos);
           auto cursorScreenPos = ImGui::GetCursorScreenPos();
-          auto [canvas, rect] = item_canvas_get(i, size);
+          auto& actor = item_actor_get(i);
           auto isSelected = selectedItemID == i;
-          if (hasItemColor) imgui::style::color_set(*item.color);
+          if (isItemColor) imgui::style::color_set(item.color);
 
           if (isSelected)
           {
@@ -412,9 +421,8 @@ namespace game::state::play::menu
             ImGui::PushStyleColor(ImGuiCol_ButtonActive, selectedColor);
           }
 
-          auto isPressed =
-              WIDGET_FX(ImGui::ImageButton("##Image Button", canvas.texture, size, ImVec2(), ImVec2(1, 1), ImVec4(),
-                                           quantity <= 0 ? ImVec4(0, 0, 0, 0.5f) : ImVec4(1, 1, 1, 1)));
+          auto isPressed = itemButtons[i].button(resources, actor, "##Image Button", size,
+                                                 quantity <= 0 ? ImVec4(0, 0, 0, 0.5f) : ImVec4(1, 1, 1, 1));
           if (isSelected) ImGui::PopStyleColor(3);
           isAnyInventoryItemHovered = isAnyInventoryItemHovered || ImGui::IsItemHovered();
           if (isPressed)
@@ -441,7 +449,7 @@ namespace game::state::play::menu
           ImGui::GetWindowDrawList()->AddText(textPos, ImGui::GetColorU32(ImGui::GetStyleColorVec4(ImGuiCol_Text)),
                                               text.c_str());
           ImGui::PopFont();
-          if (hasItemColor) style::color_set(resources, character);
+          if (isItemColor) style::color_set(resources, character);
 
           auto increment = ImGui::GetItemRectSize().x + ImGui::GetStyle().ItemSpacing.x;
           cursorPos.x += increment;
@@ -460,20 +468,39 @@ namespace game::state::play::menu
       }
       ImGui::EndChild();
 
+      if (ImGui::BeginChild("##Autofeed Toggle Child", toggleChildSize, ImGuiChildFlags_None,
+                            ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse))
+      {
+        ImGui::PushFont(ImGui::GetFont(), Font::HEADER_2);
+        auto isAutofeedAvailable = autofeed.available_get(character, *this, itemManager);
+        auto label = autofeed.enabled_get() ? strings.get(Strings::InventoryDisableAutofeedButton)
+                                            : strings.get(Strings::InventoryEnableAutofeedButton);
+        ImGui::BeginDisabled(!isAutofeedAvailable);
+        if (WIDGET_FX(ImGui::Button(label.c_str(), {ImGui::GetContentRegionAvail().x, 0}))) autofeed.toggle();
+        ImGui::EndDisabled();
+        ImGui::PopFont();
+        ImGui::SetItemTooltip("%s", strings
+                                        .get(autofeed.enabled_get() ? Strings::InventoryDisableAutofeedTooltip
+                                                                    : Strings::InventoryEnableAutofeedTooltip)
+                                        .c_str());
+      }
+      ImGui::EndChild();
+
       isItemSelected = selectedItemID >= 0 && selectedItemID < (int)schema.items.size();
       isInfoVisible = isItemSelected || inventoryCount == 0;
       auto selectedQuantity =
-          isItemSelected ? (isSelectedItemPressed && pressedItemQuantity >= 0 ? pressedItemQuantity : quantity_get(selectedItemID))
+          isItemSelected ? (isSelectedItemPressed && pressedItemQuantity >= 0 ? pressedItemQuantity
+                                                                              : inventory_quantity_get(selectedItemID))
                          : 0;
       infoChildHeight = info_child_height_get(available, isItemSelected, selectedQuantity);
       infoChildSize = ImVec2(available.x, infoChildHeight);
       auto isSelectedItemKnown = isItemSelected && selectedQuantity > 0;
-      auto selectedItemHasColor = isItemSelected && schema.items[selectedItemID].color.has_value();
+      auto selectedItemHasColor = isItemSelected && schema.items[selectedItemID].isColor;
 
       if (isInfoVisible && ImGui::BeginChild("##Info Child", infoChildSize, ImGuiChildFlags_None,
                                              ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse))
       {
-        if (selectedItemHasColor) imgui::style::color_set(*schema.items[selectedItemID].color);
+        if (selectedItemHasColor) imgui::style::color_set(schema.items[selectedItemID].color);
         info_section_separator_draw();
         auto isButtonChildVisible = selectedQuantity > 0;
         ImGui::PushFont(resources.font.get(), Font::HEADER_2);
@@ -497,10 +524,10 @@ namespace game::state::play::menu
           auto descriptionHeight = wrapped_text_height_get(selectedItem.description, contentWidth);
           auto sharedDetailHeight = std::max(statsHeight, descriptionHeight);
           auto headerHeight = item_header_height_get(selectedItem, selectedQuantity, contentWidth);
-          auto desiredInfoContentHeight =
-              headerHeight + separatorHeight + sharedDetailHeight * 2.0f + separatorHeight;
+          auto desiredInfoContentHeight = headerHeight + separatorHeight + sharedDetailHeight * 2.0f + separatorHeight;
           auto availableInfoContentHeight =
-              std::max(0.0f, ImGui::GetContentRegionAvail().y - (isButtonChildVisible ? separatorHeight + buttonChildHeight : 0.0f));
+              std::max(0.0f, ImGui::GetContentRegionAvail().y -
+                                 (isButtonChildVisible ? separatorHeight + buttonChildHeight : 0.0f));
           auto infoContentHeight = std::min(desiredInfoContentHeight, availableInfoContentHeight);
 
           item_header_draw(selectedItem, selectedQuantity);
@@ -508,7 +535,8 @@ namespace game::state::play::menu
 
           auto detailChildHeight = sharedDetailHeight;
           if (desiredInfoContentHeight > availableInfoContentHeight)
-            detailChildHeight = std::max(0.0f, (infoContentHeight - headerHeight - separatorHeight - separatorHeight) * 0.5f);
+            detailChildHeight =
+                std::max(0.0f, (infoContentHeight - headerHeight - separatorHeight - separatorHeight) * 0.5f);
           auto detailChildSize = ImVec2(ImGui::GetContentRegionAvail().x, detailChildHeight);
 
           if (ImGui::BeginChild("##Info Stats Child", detailChildSize))
@@ -540,8 +568,8 @@ namespace game::state::play::menu
 
               auto upgrade_item_name_get = [&]() -> std::string
               {
-                if (!selectedItem.upgradeID.has_value()) return {};
-                return schema.items.at(*selectedItem.upgradeID).name;
+                if (!selectedItem.isUpgradeID) return {};
+                return schema.items.at(selectedItem.upgradeID).name;
               };
 
               auto upgrade_tooltip_get = [&](bool isAll)
@@ -549,7 +577,7 @@ namespace game::state::play::menu
                 if (!is_possible_to_upgrade_get(selectedItem)) return strings.get(Strings::InventoryUpgradeNoPath);
 
                 auto upgradeItemName = upgrade_item_name_get();
-                auto upgradeCount = *selectedItem.upgradeCount;
+                auto upgradeCount = selectedItem.upgradeCount;
 
                 if (!canUpgradeSelectedItem)
                   return std::vformat(strings.get(Strings::InventoryUpgradeNeedsTemplate),
@@ -574,7 +602,7 @@ namespace game::state::play::menu
 
               ImGui::BeginDisabled(!canUpgradeSelectedItem);
               if (WIDGET_FX(ImGui::Button(strings.get(Strings::InventoryUpgradeButton).c_str(), rowTwoButtonSize)))
-                item_upgrade(selectedItemID, false);
+                upgrade(schema, selectedItemID, false);
               if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled))
               {
                 ImGui::PushFont(ImGui::GetFont(), Font::NORMAL);
@@ -583,7 +611,7 @@ namespace game::state::play::menu
               }
               ImGui::SameLine();
               if (WIDGET_FX(ImGui::Button(strings.get(Strings::InventoryUpgradeAllButton).c_str(), rowTwoButtonSize)))
-                item_upgrade(selectedItemID, true);
+                upgrade(schema, selectedItemID, true);
               if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled))
               {
                 ImGui::PushFont(ImGui::GetFont(), Font::NORMAL);
diff --git a/src/state/play/menu/inventory.hpp b/src/state/play/menu/inventory.hpp
index deb0f6c..d1bb0db 100644
--- a/src/state/play/menu/inventory.hpp
+++ b/src/state/play/menu/inventory.hpp
@@ -1,13 +1,20 @@
 #pragma once
 
-#include "../../../entity/character.hpp"
+#include "../../../entity.hpp"
 
+#include "../../../resource/schema.hpp"
 #include "../../../resources.hpp"
+#include "../../../util/imgui/entity_button.hpp"
 
 #include "../item_manager.hpp"
 
 #include <imgui.h>
 
+namespace game::state::play
+{
+  class Autofeed;
+}
+
 namespace game::state::play::menu
 {
   class Inventory
@@ -16,13 +23,14 @@ namespace game::state::play::menu
     static constexpr auto SIZE = 96.0f;
 
     std::map<int, int> values{};
-    std::unordered_map<int, entity::Actor> actors{};
-    std::unordered_map<int, glm::vec4> rects{};
-    std::unordered_map<int, Canvas> canvases{};
+    std::unordered_map<int, Entity> actors{};
+    std::unordered_map<int, util::imgui::widget::EntityButton> itemButtons{};
     int selectedItemID{-1};
 
-    void tick();
-    void update(Resources&, ItemManager&, entity::Character&);
+    bool can_upgrade(const resource::xml::Schema&, int itemID);
+    bool upgrade(resource::xml::Schema&, int itemID, bool isAll);
+    bool upgrade_all_possible(resource::xml::Schema&);
+    void update(Resources&, ItemManager&, Entity&, Autofeed&);
     int count();
   };
 }
diff --git a/src/state/play/menu/item_effect_manager.cpp b/src/state/play/menu/item_effect_manager.cpp
index 2623866..4e1da4a 100644
--- a/src/state/play/menu/item_effect_manager.cpp
+++ b/src/state/play/menu/item_effect_manager.cpp
@@ -8,13 +8,13 @@ using namespace glm;
 
 namespace game::state::play::menu
 {
-  void ItemEffectManager::tick()
+  void ItemEffectManager::update()
   {
     for (auto& [i, actor] : actors)
-      actor.tick();
+      actor.update();
   }
 
-  void ItemEffectManager::spawn(int itemID, const resource::xml::Item& itemSchema, const ImVec4& bounds, Mode mode)
+  void ItemEffectManager::spawn(int itemID, const resource::xml::Schema& itemSchema, const ImVec4& bounds, Mode mode)
   {
     static constexpr auto ITEM_SHOOT_UP_HORIZONTAL_SPEED_MIN = -250.0f;
     static constexpr auto ITEM_SHOOT_UP_HORIZONTAL_SPEED_MAX = 250.0f;
@@ -24,13 +24,12 @@ namespace game::state::play::menu
     static constexpr auto ITEM_ROTATION_VELOCITY_MAX = 45.0f;
 
     if (!actors.contains(itemID))
-    {
-      actors[itemID] = entity::Actor(itemSchema.anm2s[itemID], {}, entity::Actor::SET);
-      rects[itemID] = actors[itemID].rect();
-    }
+      actors[itemID] = Entity(itemSchema.anm2s[itemID], {}, Entity::SET);
 
     auto size = ImVec2(bounds.z, bounds.w);
-    auto rect = rects[itemID];
+    auto& canvas = canvases[itemID];
+    if (!std::isfinite(canvas.rect.x)) canvas.rect = actors[itemID].rect();
+    auto rect = canvas.rect;
     auto rectSize = vec2(rect.z, rect.w);
     auto previewScale = (rectSize.x <= 0.0f || rectSize.y <= 0.0f || size.x <= 0.0f || size.y <= 0.0f ||
                          !std::isfinite(rectSize.x) || !std::isfinite(rectSize.y))
@@ -66,7 +65,7 @@ namespace game::state::play::menu
     entries.emplace_back(std::move(entry));
   }
 
-  void ItemEffectManager::render(Resources& resources, const resource::xml::Item& itemSchema, const ImVec4& bounds,
+  void ItemEffectManager::render(Resources& resources, const resource::xml::Schema& itemSchema, const ImVec4& bounds,
                                  float deltaTime)
   {
     static constexpr auto ITEM_FALL_GRAVITY = 2400.0f;
@@ -87,35 +86,15 @@ namespace game::state::play::menu
         continue;
       }
 
-      auto rect = rects[item.id];
-      auto rectSize = vec2(rect.z, rect.w);
-      auto previewScale = (rectSize.x <= 0.0f || rectSize.y <= 0.0f || size.x <= 0.0f || size.y <= 0.0f ||
-                           !std::isfinite(rectSize.x) || !std::isfinite(rectSize.y))
-                              ? 0.0f
-                              : std::min(size.x / rectSize.x, size.y / rectSize.y);
-      previewScale = std::min(1.0f, previewScale);
-      auto previewSize = rectSize * previewScale;
-      auto canvasSize = ivec2(std::max(1.0f, previewSize.x), std::max(1.0f, previewSize.y));
-
-      if (!canvases.contains(item.id)) canvases.emplace(item.id, Canvas(canvasSize, Canvas::FLIP));
       auto& canvas = canvases[item.id];
-      canvas.zoom = math::to_percent(previewScale);
-      canvas.pan = vec2(rect.x, rect.y);
-      canvas.bind();
-      canvas.size_set(canvasSize);
-      canvas.clear();
-
-      actors[item.id].overrides.emplace_back(-1, resource::xml::Anm2::ROOT, entity::Actor::Override::SET,
-                                             resource::xml::Anm2::FrameOptional{.rotation = item.rotation});
-      actors[item.id].render(resources.shaders[shader::TEXTURE], resources.shaders[shader::RECT], canvas);
-      actors[item.id].overrides.pop_back();
-      canvas.unbind();
+      auto& textureCanvas = canvas.render_rotated(resources, actors[item.id], size, item.rotation, 1.0f);
+      auto previewSize = canvas.imageSize;
 
       auto min = ImVec2(position.x + item.position.x, position.y + item.position.y);
       auto max = ImVec2(item.position.x + previewSize.x, item.position.y + previewSize.y);
       max.x += position.x;
       max.y += position.y;
-      drawList->AddImage(canvas.texture, min, max);
+      drawList->AddImage(textureCanvas.texture, min, max);
 
       item.rotation += item.rotationVelocity * deltaTime;
       item.position.x += item.velocity.x * deltaTime;
diff --git a/src/state/play/menu/item_effect_manager.hpp b/src/state/play/menu/item_effect_manager.hpp
index 002e853..9480849 100644
--- a/src/state/play/menu/item_effect_manager.hpp
+++ b/src/state/play/menu/item_effect_manager.hpp
@@ -1,8 +1,9 @@
 #pragma once
 
 #include "../../../render/canvas.hpp"
-#include "../../../entity/actor.hpp"
+#include "../../../entity.hpp"
 #include "../../../resources.hpp"
+#include "../../../util/imgui/entity_canvas.hpp"
 
 #include <imgui.h>
 #include <unordered_map>
@@ -30,12 +31,11 @@ namespace game::state::play::menu
     };
 
     std::vector<Entry> entries{};
-    std::unordered_map<int, entity::Actor> actors{};
-    std::unordered_map<int, glm::vec4> rects{};
-    std::unordered_map<int, Canvas> canvases{};
+    std::unordered_map<int, Entity> actors{};
+    std::unordered_map<int, util::imgui::widget::EntityCanvas> canvases{};
 
-    void tick();
-    void spawn(int itemID, const resource::xml::Item& itemSchema, const ImVec4& bounds, Mode mode = FALL_DOWN);
-    void render(Resources& resources, const resource::xml::Item& itemSchema, const ImVec4& bounds, float deltaTime);
+    void update();
+    void spawn(int itemID, const resource::xml::Schema& itemSchema, const ImVec4& bounds, Mode mode = FALL_DOWN);
+    void render(Resources& resources, const resource::xml::Schema& itemSchema, const ImVec4& bounds, float deltaTime);
   };
 }
diff --git a/src/state/play/menu/toasts.cpp b/src/state/play/menu/toasts.cpp
deleted file mode 100644
index 81749d1..0000000
--- a/src/state/play/menu/toasts.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "toasts.hpp"
-
-namespace game::state::play::menu
-{
-  namespace
-  {
-    static constexpr auto TOAST_MESSAGE_SPEED = 1.0f;
-  }
-
-  void Toasts::spawn(const std::string& message, const ImVec2& position, int time)
-  {
-    toasts.emplace_back(message, position, time, time);
-  }
-
-  void Toasts::update(ImDrawList* drawList)
-  {
-    if (!drawList) return;
-
-    for (int i = 0; i < (int)toasts.size(); i++)
-    {
-      auto& toast = toasts[i];
-      toast.position.y -= TOAST_MESSAGE_SPEED;
-      auto textColor = ImGui::GetStyleColorVec4(ImGuiCol_Text);
-      textColor.w = (float)toast.time / toast.timeMax;
-      drawList->AddText(toast.position, ImGui::GetColorU32(textColor), toast.message.c_str());
-
-      toast.time--;
-      if (toast.time <= 0) toasts.erase(toasts.begin() + i--);
-    }
-  }
-}
diff --git a/src/state/play/menu/toasts.hpp b/src/state/play/menu/toasts.hpp
deleted file mode 100644
index f4adf7c..0000000
--- a/src/state/play/menu/toasts.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#pragma once
-
-#include <imgui.h>
-
-#include <string>
-#include <vector>
-
-namespace game::state::play::menu
-{
-  class Toasts
-  {
-  public:
-    struct Toast
-    {
-      std::string message{};
-      ImVec2 position{};
-      int time{};
-      int timeMax{};
-    };
-
-    std::vector<Toast> toasts{};
-
-    void spawn(const std::string& message, const ImVec2& position, int time);
-    void update(ImDrawList*);
-  };
-}
diff --git a/src/state/play/particle_manager.cpp b/src/state/play/particle_manager.cpp
new file mode 100644
index 0000000..ed0ad96
--- /dev/null
+++ b/src/state/play/particle_manager.cpp
@@ -0,0 +1,51 @@
+#include "particle_manager.hpp"
+
+#include "../../log.hpp"
+
+#include <format>
+
+using namespace game::resource::xml;
+
+namespace game::state::play
+{
+  void ParticleManager::spawn(Character& character, const std::string& label, glm::vec2 position)
+  {
+    for (auto* particle : character.particleSchema.get_all(Schema::Element::PARTICLE))
+    {
+      if (!particle || particle->typeString != label) continue;
+      if (!particle->anm2Entry.is_valid()) return;
+
+      auto& anm2 = particle->anm2Entry.anm2;
+      auto animationIndex = anm2.animationMap.contains(particle->animation) ? anm2.animationMap.at(particle->animation)
+                                                                            : anm2.defaultAnimationID;
+      Entity entity{anm2, position, Entity::PLAY, 0.0f, animationIndex};
+      entity.entityType = PARTICLE;
+      entity.isRemoveOnAnimationEnd = true;
+
+      particles.push_back(std::move(entity));
+      return;
+    }
+
+    logger.warning(std::format("Particle not found: {}", label));
+  }
+
+  void ParticleManager::update()
+  {
+    for (int i = 0; i < (int)particles.size();)
+    {
+      particles[i].update();
+      if (particles[i].isToBeDeleted)
+      {
+        particles.erase(particles.begin() + i);
+        continue;
+      }
+      i++;
+    }
+  }
+
+  void ParticleManager::render(resource::Shader& textureShader, resource::Shader& rectShader, Canvas& canvas)
+  {
+    for (auto& particle : particles)
+      particle.render(textureShader, rectShader, canvas);
+  }
+}
diff --git a/src/state/play/particle_manager.hpp b/src/state/play/particle_manager.hpp
new file mode 100644
index 0000000..89275b0
--- /dev/null
+++ b/src/state/play/particle_manager.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "../../entity.hpp"
+
+#include <vector>
+
+namespace game::state::play
+{
+  class ParticleManager
+  {
+  public:
+    std::vector<Entity> particles{};
+
+    void spawn(resource::xml::Character&, const std::string&, glm::vec2);
+    void update();
+    void render(resource::Shader&, resource::Shader&, Canvas&);
+  };
+}
diff --git a/src/state/play/style.hpp b/src/state/play/style.hpp
index cfdebe5..d84a914 100644
--- a/src/state/play/style.hpp
+++ b/src/state/play/style.hpp
@@ -1,14 +1,14 @@
 #pragma once
 
-#include "../../entity/character.hpp"
+#include "../../entity.hpp"
 #include "../../resources.hpp"
 #include "../../util/imgui/style.hpp"
 
 namespace game::state::play::style
 {
-  inline void color_set(Resources& resources, const entity::Character& character)
+  inline void color_set(Resources& resources, const Entity& character)
   {
-    game::util::imgui::style::color_set(resources.settings.isUseCharacterColor ? character.data.color
-                                                                                : resources.settings.color);
+    auto* settings = resources.settings.root();
+    game::util::imgui::style::color_set(settings->isUseCharacterColor ? character.data.root()->color : settings->color);
   }
 }
diff --git a/src/state/play/text.cpp b/src/state/play/text.cpp
index d36bf98..16f4325 100644
--- a/src/state/play/text.cpp
+++ b/src/state/play/text.cpp
@@ -4,9 +4,12 @@
 #include <imgui_internal.h>
 
 #include <algorithm>
+#include <cmath>
 #include <string_view>
+#include <vector>
 
 #include "../../util/imgui.hpp"
+#include "../../util/imgui/dialogue_text.hpp"
 #include "../../util/imgui/widget.hpp"
 #include "../../util/math.hpp"
 
@@ -14,58 +17,203 @@ using namespace game::util;
 
 namespace game::state::play
 {
-  const char* utf8_advance_chars(const char* text, const char* end, int count)
+  namespace
   {
-    const char* it = text;
-    while (it < end && count > 0)
+    bool dialogue_effect_is(const resource::xml::Schema::Element& element)
     {
-      unsigned int codepoint = 0;
-      int step = ImTextCharFromUtf8(&codepoint, it, end);
-      if (step <= 0) break;
-      it += step;
-      --count;
+      return element.type == resource::xml::Schema::Element::EFFECT;
+    }
+
+    constexpr auto OSCILLATION_AMPLITUDE_DEFAULT = 2.0f;
+    constexpr auto OSCILLATION_FREQUENCY_DEFAULT = 1.0f;
+    constexpr auto SCREEN_SHAKE_MAGNITUDE_DEFAULT = 0.03f;
+    constexpr auto SCREEN_SHAKE_TIME_TICKS_DEFAULT = 15;
+    constexpr auto SHAKE_AMPLITUDE_DEFAULT = 1.0f;
+    constexpr auto SHAKE_FREQUENCY_DEFAULT = 30.0f;
+    constexpr auto TEXT_SCALE_BIG = 1.25f;
+    constexpr auto TEXT_SCALE_SMALL = 0.75f;
+
+    std::string_view dialogue_char_get(std::string_view text, int index)
+    {
+      auto* start = text.data();
+      auto* end = start + text.size();
+      auto* charStart = imgui::utf8_advance_chars(start, end, index);
+      auto* charEnd = imgui::utf8_advance_chars(charStart, end, 1);
+      return charEnd > charStart ? std::string_view(charStart, charEnd - charStart) : std::string_view{};
+    }
+
+    struct DialogueDelayCharacter
+    {
+      int delay{};
+      bool isDisableTalk{};
+    };
+
+    DialogueDelayCharacter dialogue_delay_character_get(const resource::xml::Schema& dialogue, std::string_view text,
+                                                        int index, int fallback)
+    {
+      auto value = dialogue_char_get(text, index);
+      if (value.empty()) return {.delay = fallback};
+
+      auto* root = dialogue.root();
+      if (!root) return {.delay = fallback};
+      auto* textPlayback = dialogue.child_get(*root, resource::xml::Schema::Element::TEXT_PLAYBACK);
+      auto* delayCharacters =
+          textPlayback ? dialogue.child_get(*textPlayback, resource::xml::Schema::Element::DELAY_CHARACTERS) : nullptr;
+      if (!delayCharacters) return {.delay = fallback};
+
+      for (auto* delayCharacter : dialogue.children_get(*delayCharacters, resource::xml::Schema::Element::DELAY_CHARACTER))
+      {
+        if (delayCharacter->character == value)
+          return {.delay = fallback + std::max(0, delayCharacter->delayTicks),
+                  .isDisableTalk = delayCharacter->isDisableTalk};
+      }
+      return {.delay = fallback};
+    }
+
+    void dialogue_effect_one_shot_apply(const resource::xml::Schema::Element& effect, Canvas& canvas)
+    {
+      if (effect.typeString == "Screenshake")
+      {
+        canvas.shake(SCREEN_SHAKE_MAGNITUDE_DEFAULT, SCREEN_SHAKE_TIME_TICKS_DEFAULT);
+      }
+      else if (effect.typeString == "Sound" && effect.soundEntry.is_valid())
+      {
+        effect.soundEntry.sound.play();
+      }
+    }
+
+    bool dialogue_entry_terminal_get(const resource::xml::Schema& dialogue,
+                                     const resource::xml::Schema::Element& entry)
+    {
+      if (!entry.next.empty()) return false;
+      for (auto child : entry.children)
+      {
+        if (child < 0 || child >= (int)dialogue.elements.size()) continue;
+        if (dialogue.elements[child].type == resource::xml::Schema::Element::CHOICE) return false;
+      }
+      return true;
     }
-    return it;
   }
 
-  void Text::set(resource::xml::Dialogue::Entry* dialogueEntry, entity::Character& character, bool isInterruptible)
+  void Text::set(resource::xml::Schema::Element* dialogueEntry, Entity& character, bool isInterruptible)
   {
     if (!dialogueEntry) return;
     this->entry = dialogueEntry;
 
     isFinished = false;
+    isTerminal = dialogue_entry_terminal_get(character.data.dialogue, *dialogueEntry);
     index = 0;
+    updateDelay = 0;
+    baseDelay = 0;
+    currentDelay = 0;
+    isStartEffectsApplied = false;
+    isBlipQueued = false;
     time = 0.0f;
     isEnabled = true;
     if (!dialogueEntry->animation.empty())
-      character.queue_play({.animation = dialogueEntry->animation, .isInterruptible = isInterruptible});
+      character.play({.animation = dialogueEntry->animation,
+                      .appendID = character.animation_append_id_get(),
+                      .interrupt = isInterruptible ? Entity::Interrupt::IF_ALLOWED
+                                                   : Entity::Interrupt::NEVER});
+    auto* dialogueRoot = character.data.dialogue.root();
+    baseDelay = dialogueRoot && dialogueRoot->delayTicks > 0 ? dialogueRoot->delayTicks : 2;
+    currentDelay = baseDelay;
+    for (auto child : dialogueEntry->children)
+    {
+      if (child < 0 || child >= (int)character.data.dialogue.elements.size()) continue;
+      auto& effect = character.data.dialogue.elements[child];
+      if (!dialogue_effect_is(effect) || effect.start != 0) continue;
+      if (effect.typeString == "Delay")
+      {
+        baseDelay = std::max(1, effect.delayTicks);
+        currentDelay = baseDelay;
+      }
+      else if (effect.typeString == "Animation" && !effect.animation.empty())
+      {
+        character.play({.animation = effect.animation,
+                        .appendID = character.animation_append_id_get(),
+                        .mode = Entity::PLAY_FORCE});
+      }
+    }
     if (dialogueEntry->text.empty())
       isEnabled = false;
     else
       character.isTalking = true;
   }
 
-  void Text::tick(entity::Character& character)
-  {
-    if (!entry || isFinished) return;
-
-    index++;
-    auto blipPeriod = character.data.textBlipPeriodBase;
-    if (blipPeriod > 0 && index % blipPeriod == 0) character.data.sounds.blip.play();
-
-    if (index >= ImTextCountCharsFromUtf8(entry->text.c_str(), entry->text.c_str() + entry->text.size()))
-    {
-      isFinished = true;
-      character.isTalking = false;
-    }
-  }
-
-  void Text::update(entity::Character& character)
+  void Text::update(Entity& character, Canvas& canvas)
   {
     static constexpr auto WIDTH_MULTIPLIER = 0.30f;
     static constexpr auto HEIGHT_MULTIPLIER = 6.0f;
 
     if (!entry) return;
+    if (!isFinished)
+    {
+      if (!isStartEffectsApplied)
+      {
+        isStartEffectsApplied = true;
+        for (auto child : entry->children)
+        {
+          if (child < 0 || child >= (int)character.data.dialogue.elements.size()) continue;
+          auto& effect = character.data.dialogue.elements[child];
+          if (!dialogue_effect_is(effect) || effect.start != 0) continue;
+          dialogue_effect_one_shot_apply(effect, canvas);
+        }
+      }
+      auto* dialogueRoot = character.data.dialogue.root();
+      auto rootDelay = dialogueRoot && dialogueRoot->delayTicks > 0 ? dialogueRoot->delayTicks : 2;
+      if (baseDelay <= 0) baseDelay = rootDelay;
+      if (currentDelay <= 0) currentDelay = baseDelay;
+      if (++updateDelay >= currentDelay)
+      {
+        updateDelay = 0;
+        index++;
+        currentDelay = baseDelay;
+        for (auto child : entry->children)
+        {
+          if (child < 0 || child >= (int)character.data.dialogue.elements.size()) continue;
+          auto& effect = character.data.dialogue.elements[child];
+          if (!dialogue_effect_is(effect) || effect.start != index) continue;
+          if (effect.typeString == "Delay")
+          {
+            baseDelay = std::max(1, effect.delayTicks);
+            currentDelay = baseDelay;
+          }
+          else if (effect.typeString == "Animation" && !effect.animation.empty())
+          {
+            character.play({.animation = effect.animation,
+                            .appendID = character.animation_append_id_get(),
+                            .mode = Entity::PLAY_FORCE});
+          }
+          else
+          {
+            dialogue_effect_one_shot_apply(effect, canvas);
+          }
+        }
+        auto delayCharacter = dialogue_delay_character_get(character.data.dialogue, entry->text, index - 1, currentDelay);
+        currentDelay = delayCharacter.delay;
+        character.isTalking = !delayCharacter.isDisableTalk;
+        auto blipDelay = dialogueRoot ? dialogueRoot->blipDelayTicks : 0;
+        auto isBlipStep = blipDelay > 0 && index % blipDelay == 0;
+        if (delayCharacter.isDisableTalk)
+        {
+          if (isBlipStep) isBlipQueued = true;
+        }
+        else if (isBlipStep || isBlipQueued)
+        {
+          if (dialogueRoot) dialogueRoot->soundBlip.play();
+          isBlipQueued = false;
+        }
+
+        if (index >= imgui::utf8_char_count(entry->text))
+        {
+          isFinished = true;
+          character.isTalking = false;
+          isBlipQueued = false;
+        }
+      }
+    }
+
     auto& dialogue = character.data.dialogue;
     auto& menuSchema = character.data.menuSchema;
 
@@ -88,18 +236,16 @@ namespace game::state::play
       auto isHovered = ImGui::IsWindowHovered();
       auto isMouse = ImGui::IsMouseReleased(ImGuiMouseButton_Left);
       auto isSpace = ImGui::IsKeyReleased(ImGuiKey_Space);
-      auto isAdvance = (isHovered && (isMouse || isSpace));
+      auto isAdvance = (isHovered && isMouse) || isSpace;
 
       ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(style.ItemSpacing.x, 0));
 
       if (ImGui::BeginTabBar("##Name"))
       {
-        if (ImGui::BeginTabItem(character.data.name.c_str())) ImGui::EndTabItem();
+        if (ImGui::BeginTabItem(character.data.root()->name.c_str())) ImGui::EndTabItem();
         ImGui::EndTabBar();
       }
 
-      auto available = ImGui::GetContentRegionAvail();
-
       auto font = ImGui::GetFont();
       auto fontSize = resource::Font::NORMAL;
 
@@ -108,7 +254,7 @@ namespace game::state::play
       auto text = [&]()
       {
         auto text = entry ? std::string_view(entry->text) : "null";
-        auto length = std::clamp(index, 0, ImTextCountCharsFromUtf8(text.data(), text.data() + text.size()));
+        auto length = std::clamp(index, 0, imgui::utf8_char_count(text));
 
         if (length <= 0)
         {
@@ -116,13 +262,42 @@ namespace game::state::play
           return;
         }
 
-        const char* textStart = text.data();
-        const char* textEnd = textStart + text.size();
-        const char* textLimit = utf8_advance_chars(textStart, textEnd, length);
-
-        ImGui::PushTextWrapPos(ImGui::GetCursorPos().x + available.x);
-        ImGui::TextUnformatted(textStart, textLimit);
-        ImGui::PopTextWrapPos();
+        std::vector<imgui::DialogueEffectSpan> effects{};
+        effects.reserve(entry->children.size());
+        for (auto child : entry->children)
+        {
+          if (child < 0 || child >= (int)dialogue.elements.size()) continue;
+          auto& effect = dialogue.elements[child];
+          if (!dialogue_effect_is(effect)) continue;
+          if (effect.typeString == "Color")
+            effects.push_back({.type = imgui::DialogueEffectSpan::COLOR,
+                               .start = effect.start,
+                               .end = effect.end,
+                               .color = effect.color});
+          else if (effect.typeString == "Big")
+            effects.push_back({.type = imgui::DialogueEffectSpan::TEXT_SCALE,
+                               .start = effect.start,
+                               .end = effect.end,
+                               .textScale = TEXT_SCALE_BIG});
+          else if (effect.typeString == "Small")
+            effects.push_back({.type = imgui::DialogueEffectSpan::TEXT_SCALE,
+                               .start = effect.start,
+                               .end = effect.end,
+                               .textScale = TEXT_SCALE_SMALL});
+          else if (effect.typeString == "Oscillation")
+            effects.push_back({.type = imgui::DialogueEffectSpan::OSCILLATE,
+                               .start = effect.start,
+                               .end = effect.end,
+                               .frequency = OSCILLATION_FREQUENCY_DEFAULT,
+                               .amplitude = OSCILLATION_AMPLITUDE_DEFAULT});
+          else if (effect.typeString == "Shake")
+            effects.push_back({.type = imgui::DialogueEffectSpan::SHAKE,
+                               .start = effect.start,
+                               .end = effect.end,
+                               .frequency = SHAKE_FREQUENCY_DEFAULT,
+                               .amplitude = SHAKE_AMPLITUDE_DEFAULT});
+        }
+        imgui::dialogue_text_draw(text, length, effects, glm::vec3{1.0f}, (float)ImGui::GetTime());
       };
 
       text();
@@ -131,46 +306,65 @@ namespace game::state::play
       {
         if (isFinished)
         {
-          if (!entry->choices.empty())
+          auto choices = dialogue.children_get(*entry, resource::xml::Schema::Element::CHOICE);
+          if (!choices.empty())
           {
-            ImGui::SetCursorPos(ImVec2(ImGui::GetStyle().WindowPadding.x, available.y));
-            auto buttonSize = imgui::row_widget_size_get((int)entry->choices.size());
+            auto contentMin = ImVec2(ImGui::GetWindowPos().x + ImGui::GetWindowContentRegionMin().x,
+                                     ImGui::GetWindowPos().y + ImGui::GetWindowContentRegionMin().y);
+            auto contentMax = ImVec2(ImGui::GetWindowPos().x + ImGui::GetWindowContentRegionMax().x,
+                                     ImGui::GetWindowPos().y + ImGui::GetWindowContentRegionMax().y);
+            auto buttonY = contentMax.y - ImGui::GetFrameHeight();
+            auto separatorY = buttonY - style.ItemSpacing.y;
+            ImGui::GetWindowDrawList()->AddLine(ImVec2(contentMin.x, separatorY), ImVec2(contentMax.x, separatorY),
+                                                ImGui::GetColorU32(ImGuiCol_Separator));
+            ImGui::SetCursorScreenPos(ImVec2(contentMin.x, buttonY));
+            auto buttonSize = imgui::row_widget_size_get((int)choices.size());
 
-            for (auto& branch : entry->choices)
+            for (auto index = 0; index < (int)choices.size(); ++index)
             {
-              if (WIDGET_FX(ImGui::Button(branch.text.c_str(), buttonSize)))
-                set(dialogue.get(branch.nextID), character);
+              auto* branch = choices[index];
+              auto label = branch->text.empty() ? "<choice>" : branch->text.c_str();
+              ImGui::PushID(index);
+              if (WIDGET_FX(ImGui::Button(label, buttonSize)))
+                set(dialogue.dialogue_entry_get(*branch), character);
 
-              ImGui::SetItemTooltip("%s", branch.text.c_str());
-              ImGui::SameLine();
+              ImGui::SetItemTooltip("%s", label);
+              ImGui::PopID();
+              if (index + 1 < (int)choices.size()) ImGui::SameLine();
             }
 
             if (isHovered && isSpace)
             {
-              set(dialogue.get(entry->choices.front().nextID), character);
-              menuSchema.sounds.select.play();
+              auto* next = dialogue.dialogue_entry_get(*choices.front());
+              if (next) menuSchema.root()->soundSelect.play();
+              set(next, character);
             }
           }
           else
           {
-            if (entry->nextID != -1)
+            if (!entry->next.empty())
             {
-              ImGui::SetCursorPos(ImVec2(available.x - ImGui::GetTextLineHeightWithSpacing(), available.y));
               auto indicatorSize = ImVec2(ImGui::GetTextLineHeightWithSpacing(), ImGui::GetTextLineHeightWithSpacing());
+              auto contentMax = ImVec2(ImGui::GetWindowPos().x + ImGui::GetWindowContentRegionMax().x,
+                                       ImGui::GetWindowPos().y + ImGui::GetWindowContentRegionMax().y);
+              ImGui::SetCursorScreenPos(ImVec2(contentMax.x - indicatorSize.x, contentMax.y - indicatorSize.y));
               auto cursorPos = ImGui::GetCursorScreenPos();
-              auto center = ImVec2(cursorPos.x + (indicatorSize.x * 0.5f), cursorPos.y + (indicatorSize.y * 0.5f));
+              auto offset = std::sin((float)ImGui::GetTime() * 2.0f) * (indicatorSize.x * 0.12f);
+              auto center =
+                  ImVec2(cursorPos.x + (indicatorSize.x * 0.5f) + offset, cursorPos.y + (indicatorSize.y * 0.5f));
               auto half = std::min(indicatorSize.x, indicatorSize.y) * 0.35f;
               auto tip = ImVec2(center.x + half, center.y);
               auto baseA = ImVec2(center.x - half, center.y - half);
               auto baseB = ImVec2(center.x - half, center.y + half);
               auto color = ImGui::GetColorU32(ImGuiCol_Text);
               ImGui::GetWindowDrawList()->AddTriangleFilled(tip, baseA, baseB, color);
-              ImGui::Dummy(indicatorSize);
+              ImGui::InvisibleButton("##next-indicator", indicatorSize);
 
               if (isAdvance)
               {
-                menuSchema.sounds.select.play();
-                set(dialogue.get(entry->nextID), character);
+                auto* next = dialogue.dialogue_entry_get(*entry);
+                if (next) menuSchema.root()->soundSelect.play();
+                set(next, character);
               }
             }
             else if (isAdvance)
@@ -184,7 +378,32 @@ namespace game::state::play
         {
           if (isAdvance)
           {
-            index = ImTextCountCharsFromUtf8(entry->text.c_str(), entry->text.c_str() + entry->text.size());
+            auto target = imgui::utf8_char_count(entry->text);
+            for (auto skippedIndex = index + 1; skippedIndex <= target; ++skippedIndex)
+            {
+              for (auto child : entry->children)
+              {
+                if (child < 0 || child >= (int)character.data.dialogue.elements.size()) continue;
+                auto& effect = character.data.dialogue.elements[child];
+                if (!dialogue_effect_is(effect) || effect.start != skippedIndex) continue;
+                if (effect.typeString == "Delay")
+                {
+                  baseDelay = std::max(1, effect.delayTicks);
+                  currentDelay = baseDelay;
+                }
+                else if (effect.typeString == "Animation" && !effect.animation.empty())
+                {
+                  character.play({.animation = effect.animation,
+                                  .appendID = character.animation_append_id_get(),
+                                  .mode = Entity::PLAY_FORCE});
+                }
+                else
+                {
+                  dialogue_effect_one_shot_apply(effect, canvas);
+                }
+              }
+            }
+            index = target;
             isFinished = true;
             character.isTalking = false;
           }
@@ -196,7 +415,7 @@ namespace game::state::play
     };
     ImGui::End();
 
-    if (isEnabled && isFinished && entry && entry->is_last())
+    if (isEnabled && isFinished && entry && isTerminal)
     {
       if (time += ImGui::GetIO().DeltaTime; time > LIFETIME)
       {
@@ -206,5 +425,7 @@ namespace game::state::play
     }
   }
 
-  bool Text::is_interruptible() const { return !entry || (entry && entry->is_last()); }
+  bool Text::is_interruptible() const { return !entry || isTerminal; }
+  bool Text::is_finished() const { return isFinished; }
+  bool Text::is_terminal() const { return isTerminal; }
 }
diff --git a/src/state/play/text.hpp b/src/state/play/text.hpp
index 643b66e..954f8de 100644
--- a/src/state/play/text.hpp
+++ b/src/state/play/text.hpp
@@ -2,7 +2,8 @@
 
 #include <imgui.h>
 
-#include "../../entity/character.hpp"
+#include "../../entity.hpp"
+#include "../../render/canvas.hpp"
 
 #include "../../resources.hpp"
 
@@ -11,19 +12,26 @@ namespace game::state::play
   class Text
   {
     int index{};
+    int updateDelay{};
+    int baseDelay{};
+    int currentDelay{};
     bool isFinished{};
+    bool isTerminal{};
+    bool isStartEffectsApplied{};
+    bool isBlipQueued{};
 
   public:
     static constexpr auto LIFETIME = 10.0f;
 
-    resource::xml::Dialogue::Entry* entry{};
+    resource::xml::Schema::Element* entry{};
 
     bool isEnabled{true};
     float time{};
 
-    void set(resource::xml::Dialogue::Entry*, entity::Character&, bool isInterruptible = true);
-    void tick(entity::Character&);
-    void update(entity::Character&);
+    void set(resource::xml::Schema::Element*, Entity&, bool isInterruptible = true);
+    void update(Entity&, Canvas&);
     bool is_interruptible() const;
+    bool is_finished() const;
+    bool is_terminal() const;
   };
-}
\ No newline at end of file
+}
diff --git a/src/state/play/toasts.cpp b/src/state/play/toasts.cpp
index 2437b36..efa4cfb 100644
--- a/src/state/play/toasts.cpp
+++ b/src/state/play/toasts.cpp
@@ -2,10 +2,11 @@
 
 #include <imgui.h>
 #include <ranges>
+#include <string>
 
 namespace game::state::play
 {
-  void Toasts::tick()
+  void Toasts::update()
   {
     for (int i = 0; i < (int)items.size(); i++)
     {
@@ -19,10 +20,7 @@ namespace game::state::play
         continue;
       }
     }
-  }
 
-  void Toasts::update()
-  {
     if (items.empty()) return;
 
     auto viewport = ImGui::GetMainViewport();
@@ -35,13 +33,13 @@ namespace game::state::play
     for (int i = 0; i < (int)items.size(); i++)
     {
       auto& item = items[i];
-      auto posY = viewport->Size.y - style.WindowPadding.y -
-                  (((ImGui::GetTextLineHeightWithSpacing() + style.WindowPadding.y * 2)) * (items.size() - i));
+      auto height = ImGui::GetTextLineHeightWithSpacing() + style.WindowPadding.y * 2.0f;
+      auto posY = viewport->WorkPos.y + viewport->WorkSize.y - style.WindowPadding.y -
+                  (height * (items.size() - i));
 
-      ImGui::SetNextWindowPos(ImVec2(style.WindowPadding.x, posY));
-
-      ImGui::SetNextWindowSize(ImVec2(ImGui::CalcTextSize(item.message.c_str()).x + (style.WindowPadding.x * 2),
-                                      ImGui::GetTextLineHeightWithSpacing()));
+      auto textSize = ImGui::CalcTextSize(item.message.c_str());
+      auto pos = ImVec2(viewport->WorkPos.x + style.WindowPadding.x, posY);
+      auto size = ImVec2(textSize.x + (style.WindowPadding.x * 2), height);
 
       auto alpha = (float)item.lifetime / Item::LIFETIME;
 
@@ -49,18 +47,13 @@ namespace game::state::play
       borderColor.w = alpha;
       textColor.w = alpha;
 
-      ImGui::PushStyleColor(ImGuiCol_WindowBg, windowBgColor);
-      ImGui::PushStyleColor(ImGuiCol_Border, borderColor);
-      ImGui::PushStyleColor(ImGuiCol_Text, textColor);
-
-      auto name = "##Toast " + std::to_string(i);
-      if (ImGui::Begin(name.c_str(), nullptr,
-                       ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoMove |
-                           ImGuiWindowFlags_NoScrollbar))
-        ImGui::TextUnformatted(item.message.c_str());
-      ImGui::End();
-
-      ImGui::PopStyleColor(3);
+      auto* drawList = ImGui::GetForegroundDrawList();
+      drawList->AddRectFilled(pos, ImVec2(pos.x + size.x, pos.y + size.y), ImGui::GetColorU32(windowBgColor),
+                              style.WindowRounding);
+      drawList->AddRect(pos, ImVec2(pos.x + size.x, pos.y + size.y), ImGui::GetColorU32(borderColor),
+                        style.WindowRounding);
+      drawList->AddText(ImVec2(pos.x + style.WindowPadding.x, pos.y + style.WindowPadding.y),
+                        ImGui::GetColorU32(textColor), item.message.c_str());
     }
   }
 
diff --git a/src/state/play/toasts.hpp b/src/state/play/toasts.hpp
index 88e47f8..eb93a62 100644
--- a/src/state/play/toasts.hpp
+++ b/src/state/play/toasts.hpp
@@ -10,7 +10,7 @@ namespace game::state::play
   public:
     struct Item
     {
-      static constexpr auto LIFETIME = 30;
+      static constexpr auto LIFETIME = 180;
 
       std::string message{};
       int lifetime{};
@@ -19,7 +19,6 @@ namespace game::state::play
     std::vector<Item> items{};
 
     void update();
-    void tick();
     void push(const std::string&);
   };
-};
\ No newline at end of file
+};
diff --git a/src/state/play/tools.cpp b/src/state/play/tools.cpp
index ad423d2..88b681a 100644
--- a/src/state/play/tools.cpp
+++ b/src/state/play/tools.cpp
@@ -3,7 +3,7 @@
 #include "../../util/imgui.hpp"
 #include "../../util/imgui/widget.hpp"
 
-#include <algorithm>
+#include <cfloat>
 
 using namespace game::util;
 using namespace game::util::imgui;
@@ -11,59 +11,112 @@ using namespace game::resource::xml;
 
 namespace game::state::play
 {
-  void Tools::update(entity::Character& character, entity::Cursor& cursor, World& world, World::Focus focus,
-                     Canvas& canvas)
+  void Tools::update(Entity& character, Entity& cursor, World& world, World::Focus focus, Canvas& canvas,
+                     bool isDisabled, float fadeAlpha)
   {
     static constexpr auto WIDTH_MULTIPLIER = 0.05f;
+    static constexpr auto ALPHA_MIN = 0.0f;
+    static constexpr auto ALPHA_MAX = 1.0f;
+    static constexpr auto OUTER_STYLE_VAR_COUNT = 3;
+    static constexpr auto BAR_STYLE_VAR_COUNT = 2;
+    static constexpr auto PADDING_SIZE_MULTIPLIER = 2.0f;
 
     auto style = ImGui::GetStyle();
     auto& io = ImGui::GetIO();
     auto& schema = character.data.menuSchema;
     auto& strings = character.data.strings;
 
+    if (isDisabled) isOpen = false;
     slide.update(isOpen, io.DeltaTime);
+    if (fadeAlpha <= ALPHA_MIN) return;
 
     ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0);
     ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, style.FrameRounding);
+    ImGui::PushStyleVar(ImGuiStyleVar_Alpha, style.Alpha * fadeAlpha);
 
     auto windowSize = imgui::to_ivec2(ImGui::GetMainViewport()->Size);
 
-    auto size = ImVec2(windowSize.x * WIDTH_MULTIPLIER, windowSize.y - style.WindowPadding.y * 2);
+    auto size =
+        ImVec2(windowSize.x * WIDTH_MULTIPLIER, windowSize.y - style.WindowPadding.y * PADDING_SIZE_MULTIPLIER);
     auto targetX = 0;
     auto t = slide.value_get();
     auto eased = slide.eased_get();
     auto closedX = -size.x;
     auto posX = closedX + (targetX - closedX) * eased;
     auto pos = ImVec2(posX, style.WindowPadding.y);
-    auto barSize = ImVec2(ImGui::GetTextLineHeightWithSpacing(), windowSize.y - style.WindowPadding.y * 2);
+    auto barSize =
+        ImVec2(imgui::side_bar_width_get(), windowSize.y - style.WindowPadding.y * PADDING_SIZE_MULTIPLIER);
     auto barPos = ImVec2(pos.x + size.x, style.WindowPadding.y);
+    auto flags = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
+                 ImGuiWindowFlags_NoMove;
+    if (isDisabled || fadeAlpha < ALPHA_MAX) flags |= ImGuiWindowFlags_NoInputs;
 
     if (slide.is_visible())
     {
       ImGui::SetNextWindowSize(size);
       ImGui::SetNextWindowPos(pos);
 
-      if (ImGui::Begin("##Tools", nullptr,
-                       ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
-                           ImGuiWindowFlags_NoMove))
+      if (ImGui::Begin("##Tools", nullptr, flags))
       {
+        ImGui::BeginDisabled(isDisabled);
         auto buttonSize = imgui::to_imvec2(vec2(ImGui::GetContentRegionAvail().x));
+        auto* iconsFont = schema.iconsFont.is_valid() ? schema.iconsFont.get() : nullptr;
+
+        auto tool_button = [&](const char* id, const std::string& label, const std::string& iconGlyph,
+                               const std::string& tooltip, bool isActive = false)
+        {
+          auto useIcon = iconsFont && !iconGlyph.empty();
+          auto result = false;
+
+          ImGui::PushID(id);
+          if (isActive) ImGui::PushStyleColor(ImGuiCol_Button, ImGui::GetStyleColorVec4(ImGuiCol_ButtonHovered));
+
+          result = WIDGET_FX(ImGui::Button(useIcon ? "##ToolIcon" : label.c_str(), buttonSize));
+
+          if (isActive) ImGui::PopStyleColor();
+
+          if (useIcon)
+          {
+            auto min = ImGui::GetItemRectMin();
+            auto size = ImGui::GetItemRectSize();
+            auto fontSize = size.y;
+            auto textSize = iconsFont->CalcTextSizeA(fontSize, FLT_MAX, 0.0f, iconGlyph.c_str());
+            auto pos = ImVec2(min.x + (size.x - textSize.x) * 0.5f, min.y + (size.y - textSize.y) * 0.5f);
+            ImGui::GetWindowDrawList()->AddText(iconsFont, fontSize, pos, ImGui::GetColorU32(ImGuiCol_Text),
+                                                iconGlyph.c_str());
+          }
+
+          if (!tooltip.empty()) ImGui::SetItemTooltip("%s", tooltip.c_str());
+          ImGui::PopID();
+          return result;
+        };
 
         auto cursor_mode_button = [&](const std::string& name, int interactTypeID)
         {
-          auto isMode = cursor.interactTypeID == interactTypeID;
-          ImGui::PushStyleColor(ImGuiCol_Button,
-                                ImGui::GetStyleColorVec4(isMode ? ImGuiCol_ButtonHovered : ImGuiCol_Button));
-          if (WIDGET_FX(ImGui::Button(name.c_str(), buttonSize))) cursor.interactTypeID = interactTypeID;
-          ImGui::PopStyleColor();
+          std::string iconGlyph{};
+          for (auto* area : character.data.interact_area_types_get())
+          {
+            if (!area || area->typeString != name || area->iconGlyph.empty()) continue;
+            iconGlyph = area->iconGlyph;
+            break;
+          }
+
+          if (tool_button(name.c_str(), name, iconGlyph, iconsFont && !iconGlyph.empty() ? name : "",
+                          cursor.interactTypeID == interactTypeID))
+            cursor.interactTypeID = interactTypeID;
         };
 
-        if (WIDGET_FX(ImGui::Button(strings.get(Strings::ToolsHomeButton).c_str(), buttonSize)))
+        auto* root = schema.root();
+        auto* home = root ? schema.child_get(*root, Schema::Element::HOME) : nullptr;
+        auto homeIconGlyph = home ? home->iconGlyph : std::string{};
+        if (tool_button("Home", strings.get(Strings::ToolsHomeButton), homeIconGlyph,
+                        strings.get(Strings::ToolsHomeTooltip)))
           world.character_focus(character, canvas, focus);
-        ImGui::SetItemTooltip("%s", strings.get(Strings::ToolsHomeTooltip).c_str());
 
-        for (int i = 0; i < (int)character.data.interactTypeNames.size(); i++)
-          cursor_mode_button(character.data.interactTypeNames[i], i);
+        auto interactTypeNames = character.data.interact_type_names_get();
+        for (int i = 0; i < (int)interactTypeNames.size(); i++)
+          cursor_mode_button(interactTypeNames[i], i);
+        ImGui::EndDisabled();
       }
       ImGui::End();
     }
@@ -73,61 +126,44 @@ namespace game::state::play
 
     ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 0);
     ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2());
-    if (ImGui::Begin("##Tools Open Bar", nullptr,
-                     ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
-                         ImGuiWindowFlags_NoMove))
+    if (ImGui::Begin("##Tools Open Bar", nullptr, flags))
     {
       auto buttonSize = ImGui::GetContentRegionAvail();
       auto cursorPos = ImGui::GetCursorScreenPos();
 
       ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, style.WindowPadding);
+      ImGui::BeginDisabled(isDisabled);
       auto result = WIDGET_FX(ImGui::Button("##ToolsToggle", buttonSize));
 
-      if (t <= 0.0f || t >= 1.0f)
+      if (!isDisabled && (t <= 0.0f || t >= 1.0f))
       {
-        ImGui::SetItemTooltip("%s", strings.get(isOpen ? Strings::ToolsCloseTooltip
-                                                       : Strings::ToolsOpenTooltip)
-                                        .c_str());
+        ImGui::SetItemTooltip("%s",
+                              strings.get(isOpen ? Strings::ToolsCloseTooltip : Strings::ToolsOpenTooltip).c_str());
         if (result)
         {
           isOpen = !isOpen;
           if (isOpen)
-            schema.sounds.open.play();
+            schema.root()->soundOpen.play();
           else
-            schema.sounds.close.play();
+            schema.root()->soundClose.play();
         }
         if (!isOpen && t <= 0.0f && ImGui::IsItemHovered())
         {
           isOpen = true;
-          schema.sounds.open.play();
+          schema.root()->soundOpen.play();
         }
       }
+      ImGui::EndDisabled();
       ImGui::PopStyleVar();
 
-      auto center = ImVec2(cursorPos.x + (buttonSize.x * 0.5f), cursorPos.y + (buttonSize.y * 0.5f));
-      auto half = std::min(buttonSize.x, buttonSize.y) * 0.22f;
-      ImVec2 tip;
-      ImVec2 baseA;
-      ImVec2 baseB;
-      if (isOpen)
-      {
-        tip = ImVec2(center.x - half, center.y);
-        baseA = ImVec2(center.x + half, center.y - half);
-        baseB = ImVec2(center.x + half, center.y + half);
-      }
-      else
-      {
-        tip = ImVec2(center.x + half, center.y);
-        baseA = ImVec2(center.x - half, center.y - half);
-        baseB = ImVec2(center.x - half, center.y + half);
-      }
-
-      auto color = ImGui::GetColorU32(ImGuiCol_Text);
-      ImGui::GetWindowDrawList()->AddTriangleFilled(tip, baseA, baseB, color);
+      auto color = ImGui::GetStyleColorVec4(ImGuiCol_Text);
+      if (isDisabled) color.w *= style.DisabledAlpha;
+      auto direction = isOpen ? imgui::TriangleDirection::LEFT : imgui::TriangleDirection::RIGHT;
+      imgui::triangle_draw(*ImGui::GetWindowDrawList(), cursorPos, buttonSize, direction, ImGui::GetColorU32(color));
     }
     ImGui::End();
-    ImGui::PopStyleVar(2);
+    ImGui::PopStyleVar(BAR_STYLE_VAR_COUNT);
 
-    ImGui::PopStyleVar(2);
+    ImGui::PopStyleVar(OUTER_STYLE_VAR_COUNT);
   }
 }
diff --git a/src/state/play/tools.hpp b/src/state/play/tools.hpp
index 606f44e..b6a1f71 100644
--- a/src/state/play/tools.hpp
+++ b/src/state/play/tools.hpp
@@ -13,6 +13,6 @@ namespace game::state::play
     bool isOpen{};
     util::imgui::WindowSlide slide{0.125f, 0.0f};
 
-    void update(entity::Character&, entity::Cursor&, World&, World::Focus, Canvas&);
+    void update(Entity&, Entity&, World&, World::Focus, Canvas&, bool isDisabled, float fadeAlpha);
   };
 }
diff --git a/src/state/play/world.cpp b/src/state/play/world.cpp
index 67059e2..d450aea 100644
--- a/src/state/play/world.cpp
+++ b/src/state/play/world.cpp
@@ -10,15 +10,49 @@ using namespace game::util;
 
 namespace game::state::play
 {
-  void World::set(entity::Character& character, Canvas& canvas, Focus focus)
+  constexpr auto ZOOM_LADDER_EPSILON = 0.01f;
+  constexpr auto ZOOM_WHEEL_ZERO = 0.0f;
+
+  float zoom_ladder_level_get(int index)
+  {
+    auto clampedIndex = std::clamp(index, 0, World::ZOOM_LADDER_LEVEL_COUNT - 1);
+    auto exponent = (float)clampedIndex / (float)(World::ZOOM_LADDER_LEVEL_COUNT - 1);
+    return World::ZOOM_MIN * (float)std::pow(World::ZOOM_MAX / World::ZOOM_MIN, exponent);
+  }
+
+  int zoom_ladder_next_index_get(float zoom, int direction)
+  {
+    if (direction > 0)
+    {
+      for (int index = 0; index < World::ZOOM_LADDER_LEVEL_COUNT; ++index)
+        if (zoom < zoom_ladder_level_get(index) - ZOOM_LADDER_EPSILON) return index;
+      return World::ZOOM_LADDER_LEVEL_COUNT - 1;
+    }
+
+    for (int index = World::ZOOM_LADDER_LEVEL_COUNT - 1; index >= 0; --index)
+      if (zoom > zoom_ladder_level_get(index) + ZOOM_LADDER_EPSILON) return index;
+    return 0;
+  }
+
+  float zoom_ladder_zoom_get(float zoom, float wheel)
+  {
+    auto direction = wheel > ZOOM_WHEEL_ZERO ? 1 : -1;
+    auto stepCount = std::max(1, (int)std::ceil(std::abs(wheel)));
+    auto index = zoom_ladder_next_index_get(zoom, direction);
+    index = std::clamp(index + ((stepCount - 1) * direction), 0, World::ZOOM_LADDER_LEVEL_COUNT - 1);
+    return zoom_ladder_level_get(index);
+  }
+
+  void World::set(Entity& character, Canvas& canvas, Focus focus)
   {
     character.stage = character.stage_get();
     character_focus(character, canvas, focus);
   }
 
-  void World::update(entity::Character& character, entity::Cursor& cursor, Canvas& canvas, Focus focus)
+  void World::update(Entity& character, Entity& cursor, Canvas& canvas, Focus focus)
   {
     auto& cursorSchema = character.data.cursorSchema;
+    auto* cursorRoot = cursorSchema.root();
     auto& pan = canvas.pan;
     auto& zoom = canvas.zoom;
     auto& io = ImGui::GetIO();
@@ -31,7 +65,8 @@ namespace game::state::play
     {
       if ((isMouseMiddleDown) || (isMouseLeftDown && isCtrlDown))
       {
-        if (auto animation = cursorSchema.animations.pan.get()) cursor.queue_play({*animation});
+        if (cursorRoot)
+          if (auto animation = cursorRoot->animationPan.get()) cursor.play({*animation});
         pan -= imgui::to_vec2(io.MouseDelta) * panMultiplier;
       }
 
@@ -44,9 +79,10 @@ namespace game::state::play
         auto zoomFactorBefore = math::to_unit(zoomBefore);
         auto cursorWorld = pan + (cursorPos / zoomFactorBefore);
 
-        if (auto animation = cursorSchema.animations.zoom.get()) cursor.queue_play({*animation});
+        if (cursorRoot)
+          if (auto animation = cursorRoot->animationZoom.get()) cursor.play({*animation});
 
-        zoom = glm::clamp(ZOOM_MIN, zoom + (io.MouseWheel * ZOOM_STEP), ZOOM_MAX);
+        zoom = zoom_ladder_zoom_get(zoom, io.MouseWheel);
 
         auto zoomFactorAfter = math::to_unit(zoom);
         pan = cursorWorld - (cursorPos / zoomFactorAfter);
@@ -58,7 +94,7 @@ namespace game::state::play
     if (ImGui::IsKeyPressed(ImGuiKey_Home)) character_focus(character, canvas, focus);
   }
 
-  void World::character_focus(entity::Character& character, Canvas& canvas, Focus focus)
+  void World::character_focus(Entity& character, Canvas& canvas, Focus focus)
   {
     static constexpr float MENU_WIDTH_MULTIPLIER = 0.30f;
     static constexpr float TOOLS_WIDTH_MULTIPLIER = 0.10f;
diff --git a/src/state/play/world.hpp b/src/state/play/world.hpp
index 9b7624f..dfbf179 100644
--- a/src/state/play/world.hpp
+++ b/src/state/play/world.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "../../render/canvas.hpp"
-#include "../../entity/character.hpp"
+#include "../../entity.hpp"
 
 #include "character_manager.hpp"
 #include "item_manager.hpp"
@@ -13,7 +13,7 @@ namespace game::state::play
   public:
     static constexpr auto ZOOM_MIN = 50.0f;
     static constexpr auto ZOOM_BASE = 100.0f;
-    static constexpr auto ZOOM_STEP = 25.0f;
+    static constexpr auto ZOOM_LADDER_LEVEL_COUNT = 10;
     static constexpr auto ZOOM_MAX = 400.0f;
     static constexpr auto SIZE = glm::vec2{1920, 1080};
     static constexpr auto BOUNDS =
@@ -27,9 +27,9 @@ namespace game::state::play
       TOOLS
     };
 
-    void update(entity::Character& character, entity::Cursor& cursor, Canvas& canvas, Focus = CENTER);
-    void character_focus(entity::Character& character, Canvas& canvas, Focus = CENTER);
-    void set(entity::Character& character, Canvas& canvas, Focus = CENTER);
+    void update(Entity& character, Entity& cursor, Canvas& canvas, Focus = CENTER);
+    void character_focus(Entity& character, Canvas& canvas, Focus = CENTER);
+    void set(Entity& character, Canvas& canvas, Focus = CENTER);
     glm::vec2 screen_to_world(glm::vec2 screenPosition, const Canvas& canvas) const;
   };
 }
diff --git a/src/state/select.cpp b/src/state/select.cpp
index 07ee8b1..1776560 100644
--- a/src/state/select.cpp
+++ b/src/state/select.cpp
@@ -6,13 +6,15 @@ using namespace game::util;
 
 namespace game::state
 {
-  void Select::tick() { preview.tick(characterIndex); }
-
   void Select::update(Resources& resources)
   {
     preview.update(resources, characterIndex);
     info.update(resources, characterIndex);
-    characters.update(resources, characterIndex);
+    if (characters.update(resources, characterIndex))
+    {
+      preview.previousCharacterIndex = -1;
+      preview.canvas.clear();
+    }
   }
 
   void Select::render(Resources&, Canvas& canvas)
diff --git a/src/state/select.hpp b/src/state/select.hpp
index fc91676..e15e5c6 100644
--- a/src/state/select.hpp
+++ b/src/state/select.hpp
@@ -17,7 +17,6 @@ namespace game::state
 
     int characterIndex{-1};
 
-    void tick();
     void update(Resources&);
     void render(Resources&, Canvas&);
   };
diff --git a/src/state/select/characters.cpp b/src/state/select/characters.cpp
index 7f0e4d1..ce229dc 100644
--- a/src/state/select/characters.cpp
+++ b/src/state/select/characters.cpp
@@ -7,8 +7,9 @@ using namespace game::util;
 
 namespace game::state::select
 {
-  void Characters::update(Resources& resources, int& characterIndex)
+  bool Characters::update(Resources& resources, int& characterIndex)
   {
+    auto isRefreshed = false;
     auto& style = ImGui::GetStyle();
     auto viewport = ImGui::GetMainViewport();
 
@@ -27,6 +28,19 @@ namespace game::state::select
       {
         if (WIDGET_FX(ImGui::BeginTabItem("Characters")))
         {
+          if (ImGui::BeginPopupContextWindow("characters-context", ImGuiPopupFlags_MouseButtonRight))
+          {
+            if (ImGui::MenuItem("Refresh"))
+            {
+              resources.characters_refresh();
+              characterIndex = resources.characterPreviews.empty()
+                                   ? -1
+                                   : std::clamp(characterIndex, 0, (int)resources.characterPreviews.size() - 1);
+              isRefreshed = true;
+            }
+            ImGui::EndPopup();
+          }
+
           auto cursorPos = ImGui::GetCursorPos();
           auto cursorStartX = ImGui::GetCursorPosX();
 
@@ -34,25 +48,26 @@ namespace game::state::select
 
           for (int i = 0; i < (int)resources.characterPreviews.size(); i++)
           {
-            auto& character = resources.characterPreviews[i];
+            auto* character = resources.characterPreviews[i].root();
+            if (!character) continue;
             ImGui::PushID(i);
 
             ImGui::SetCursorPos(cursorPos);
-            imgui::style::color_set(character.color);
+            imgui::style::color_set(character->color);
 
             auto isSelected = i == characterIndex;
 
             if (isSelected) ImGui::PushStyleColor(ImGuiCol_FrameBg, ImGui::GetStyleColorVec4(ImGuiCol_FrameBgHovered));
 
-            if (character.portrait.is_valid())
+            if (character->portrait.is_valid())
             {
-              if (WIDGET_FX(ImGui::ImageButton(character.name.c_str(), character.portrait.id, buttonSize)))
+              if (WIDGET_FX(ImGui::ImageButton(character->name.c_str(), character->portrait.texture.id, buttonSize)))
                 characterIndex = i;
             }
-            else if (WIDGET_FX(ImGui::Button(character.name.c_str(), buttonSize)))
+            else if (WIDGET_FX(ImGui::Button(character->name.c_str(), buttonSize)))
               characterIndex = i;
             if (isSelected) ImGui::PopStyleColor();
-            ImGui::SetItemTooltip("%s", character.name.c_str());
+            ImGui::SetItemTooltip("%s", character->name.c_str());
 
             auto increment = ImGui::GetItemRectSize().x + ImGui::GetStyle().ItemSpacing.x;
             cursorPos.x += increment;
@@ -64,7 +79,7 @@ namespace game::state::select
             }
 
             ImGui::PopID();
-            imgui::style::color_set(resources.settings.color);
+            imgui::style::color_set(resources.settings.root()->color);
           }
           ImGui::EndTabItem();
         }
@@ -78,5 +93,6 @@ namespace game::state::select
       }
       ImGui::End();
     }
+    return isRefreshed;
   }
 }
diff --git a/src/state/select/characters.hpp b/src/state/select/characters.hpp
index 4109842..d98f5fe 100644
--- a/src/state/select/characters.hpp
+++ b/src/state/select/characters.hpp
@@ -10,6 +10,6 @@ namespace game::state::select
   public:
     SettingsMenu settingsMenu;
 
-    void update(Resources&, int& characterIndex);
+    bool update(Resources&, int& characterIndex);
   };
 }
diff --git a/src/state/select/info.cpp b/src/state/select/info.cpp
index 6307e84..d465e81 100644
--- a/src/state/select/info.cpp
+++ b/src/state/select/info.cpp
@@ -4,6 +4,7 @@
 #include "../../util/imgui.hpp"
 #include "../../util/imgui/style.hpp"
 #include "../../util/imgui/widget.hpp"
+#include "../../util/measurement.hpp"
 #include "../../util/vector.hpp"
 
 using namespace game::util;
@@ -19,7 +20,8 @@ namespace game::state::select
 
     auto& style = ImGui::GetStyle();
     auto viewport = ImGui::GetMainViewport();
-    auto& character = resources.characterPreviews[characterIndex];
+    auto* character = resources.characterPreviews[characterIndex].root();
+    if (!character) return;
 
     auto size = ImVec2(viewport->Size.x / 2.0f - (style.WindowPadding.x * 2.0f),
                        (viewport->Size.y / 2.0f) - (style.WindowPadding.y * 2.0f));
@@ -27,15 +29,19 @@ namespace game::state::select
 
     ImGui::SetNextWindowSize(size);
     ImGui::SetNextWindowPos(pos);
-    imgui::style::color_set(character.color);
+    imgui::style::color_set(character->color);
 
     if (ImGui::Begin("##Info", nullptr,
                      ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
                          ImGuiWindowFlags_NoTitleBar))
     {
-      auto& save = character.save;
-      auto& system = resources.settings.measurementSystem;
-      auto& weight = save.is_valid() ? save.weight : character.weight;
+      auto& save = resources.characterSaves.at(characterIndex);
+      auto* settings = resources.settings.root();
+      auto system = settings->measurementSystem == "Imperial" ? IMPERIAL : METRIC;
+      auto* saveRoot = save.root();
+      auto isSaveValid = saveRoot && saveRoot->type == resource::xml::Schema::Element::SAVE;
+      auto* savedCharacter = isSaveValid ? save.child_get(*saveRoot, resource::xml::Schema::Element::CHARACTER) : nullptr;
+      auto weight = savedCharacter ? (double)savedCharacter->weightKilograms : (double)character->weight;
 
       ImGui::PushFont(ImGui::GetFont(), Font::HEADER_3);
 
@@ -44,7 +50,7 @@ namespace game::state::select
       if (ImGui::BeginChild("##Info Child", childSize))
       {
         ImGui::PushFont(ImGui::GetFont(), Font::HEADER_3);
-        ImGui::TextUnformatted(character.name.c_str());
+        ImGui::TextUnformatted(character->name.c_str());
         ImGui::PopFont();
 
         ImGui::PushFont(ImGui::GetFont(), Font::NORMAL);
@@ -52,13 +58,13 @@ namespace game::state::select
         {
           if (ImGui::BeginTabItem("Overview"))
           {
-            if (!character.description.empty())
+            if (!character->description.empty())
             {
               ImGui::Separator();
 
               ImGui::PushStyleColor(ImGuiCol_Text, ImGui::GetColorU32(imgui::to_imvec4(color::GRAY)));
               ImGui::PushFont(ImGui::GetFont(), Font::HEADER_2);
-              ImGui::TextWrapped("%s", character.description.c_str());
+              ImGui::TextWrapped("%s", character->description.c_str());
               ImGui::PopFont();
 
               ImGui::PopStyleColor();
@@ -70,7 +76,8 @@ namespace game::state::select
 
             ImGui::Text("Weight: %0.2f %s", system == IMPERIAL ? weight * KG_TO_LB : weight,
                         system == IMPERIAL ? "lbs" : "kg");
-            ImGui::Text("Stages: %i", character.stages);
+            auto stages = resources.characterPreviews[characterIndex].get_all(resource::xml::Schema::Element::STAGE);
+            ImGui::Text("Stages: %i", (int)stages.size() + 1);
 
             ImGui::PopFont();
             ImGui::EndTabItem();
@@ -81,8 +88,8 @@ namespace game::state::select
             ImGui::Separator();
             ImGui::PushStyleColor(ImGuiCol_Text, ImGui::GetColorU32(imgui::to_imvec4(color::GRAY)));
             ImGui::PushFont(ImGui::GetFont(), Font::HEADER_2);
-            if (!character.credits.empty())
-              ImGui::TextWrapped("%s", character.credits.c_str());
+            if (!character->credits.empty())
+              ImGui::TextWrapped("%s", character->credits.c_str());
             else
               ImGui::TextUnformatted("No credits listed.");
             ImGui::PopFont();
@@ -96,9 +103,9 @@ namespace game::state::select
       }
       ImGui::EndChild();
 
-      auto widgetSize = row_widget_size_get(save.is_valid() ? 2 : 1);
+      auto widgetSize = row_widget_size_get(isSaveValid ? 2 : 1);
 
-      if (save.is_valid())
+      if (isSaveValid)
       {
         if (WIDGET_FX(ImGui::Button("Continue", widgetSize))) isContinue = true;
         ImGui::PushFont(ImGui::GetFont(), Font::NORMAL);
@@ -129,7 +136,7 @@ namespace game::state::select
       if (ImGui::BeginPopupModal("New Game Warning", &isNewGameWarning,
                                  ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize))
       {
-        auto popupWidgetSize = row_widget_size_get(save.is_valid() ? 2 : 1);
+        auto popupWidgetSize = row_widget_size_get(isSaveValid ? 2 : 1);
         ImGui::TextWrapped("This will delete saved progress! Are you sure?");
         if (WIDGET_FX(ImGui::Button("Yes", popupWidgetSize))) isNewGame = true;
         ImGui::SameLine();
@@ -138,6 +145,6 @@ namespace game::state::select
       }
     }
     ImGui::End();
-    imgui::style::color_set(resources.settings.color);
+    imgui::style::color_set(resources.settings.root()->color);
   }
 }
diff --git a/src/state/select/preview.cpp b/src/state/select/preview.cpp
index e691c5e..3ee0331 100644
--- a/src/state/select/preview.cpp
+++ b/src/state/select/preview.cpp
@@ -1,39 +1,35 @@
 #include "preview.hpp"
 
 #include <algorithm>
-#include <cmath>
 
 #include "../../util/imgui.hpp"
 #include "../../util/imgui/style.hpp"
 #include "../../util/imgui/widget.hpp"
 #include "../../util/vector.hpp"
 
-using namespace game::entity;
 using namespace game::resource;
 using namespace game::util;
 using namespace game::util::imgui;
 
 namespace game::state::select
 {
-  void Preview::tick(int characterIndex)
-  {
-    if (characterIndex != -1 && isInGame) actor.tick();
-  }
-
   void Preview::update(Resources& resources, int characterIndex)
   {
+    if (characterIndex != -1 && isInGame) actor.update();
+
     if (!vector::in_bounds(resources.characterPreviews, characterIndex)) return;
 
     auto& style = ImGui::GetStyle();
     auto viewport = ImGui::GetMainViewport();
-    auto& character = resources.characterPreviews[characterIndex];
+    auto* character = resources.characterPreviews[characterIndex].root();
+    if (!character) return;
     auto size = ImVec2(viewport->Size.x / 2.0f - (style.WindowPadding.x * 2.0f),
                        (viewport->Size.y / 2.0f) - (style.WindowPadding.y * 2.0f));
     auto pos = ImVec2(style.WindowPadding.x, style.WindowPadding.y);
 
     ImGui::SetNextWindowSize(size);
     ImGui::SetNextWindowPos(pos);
-    imgui::style::color_set(character.color);
+    imgui::style::color_set(character->color);
 
     if (ImGui::Begin("##Preview", nullptr,
                      ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
@@ -43,21 +39,29 @@ namespace game::state::select
       {
         auto available = ImGui::GetContentRegionAvail();
         auto availableSize = imgui::to_vec2(available);
-        auto textureSize = vec2(character.render.size);
-
         if (WIDGET_FX(ImGui::BeginTabItem("Render")))
         {
-          auto scale =
-              (availableSize.x <= 0.0f || availableSize.y <= 0.0f || textureSize.x <= 0.0f || textureSize.y <= 0.0f)
-                  ? 0.0f
-                  : std::min(availableSize.x / textureSize.x, availableSize.y / textureSize.y);
+          auto textureSize = vec2(character->render.texture.size);
 
-          auto renderSize = ImVec2(textureSize.x * scale, textureSize.y * scale);
+          if (character->render.is_valid())
+          {
+            auto scale =
+                (availableSize.x <= 0.0f || availableSize.y <= 0.0f || textureSize.x <= 0.0f || textureSize.y <= 0.0f)
+                    ? 0.0f
+                    : std::min(availableSize.x / textureSize.x, availableSize.y / textureSize.y);
 
-          ImGui::SetCursorPos(ImVec2(ImGui::GetCursorPosX() + (availableSize.x * 0.5f) - (renderSize.x * 0.5f),
-                                     ImGui::GetCursorPosY() + (availableSize.y * 0.5f) - (renderSize.y * 0.5f)));
+            auto renderSize = ImVec2(textureSize.x * scale, textureSize.y * scale);
 
-          ImGui::Image(character.render.id, renderSize);
+            ImGui::SetCursorPos(ImVec2(ImGui::GetCursorPosX() + (availableSize.x * 0.5f) - (renderSize.x * 0.5f),
+                                       ImGui::GetCursorPosY() + (availableSize.y * 0.5f) - (renderSize.y * 0.5f)));
+
+            ImGui::Image(character->render.texture.id, renderSize);
+          }
+          else
+          {
+            ImGui::TextUnformatted(character->name.c_str());
+            if (!character->description.empty()) ImGui::TextWrapped("%s", character->description.c_str());
+          }
 
           ImGui::EndTabItem();
         }
@@ -68,34 +72,18 @@ namespace game::state::select
 
           if (previousCharacterIndex != characterIndex)
           {
-            actor = Actor(resources.characterPreviews[characterIndex].anm2);
-            rect = actor.rect();
+            actor = Entity(resources.character_get(characterIndex).root()->anm2Entry.anm2);
+            canvas.clear();
             previousCharacterIndex = characterIndex;
           }
 
-          auto rectSize = vec2(rect.z, rect.w);
-          auto previewScale = (availableSize.x <= 0.0f || availableSize.y <= 0.0f || rectSize.x <= 0.0f ||
-                               rectSize.y <= 0.0f || !std::isfinite(rectSize.x) || !std::isfinite(rectSize.y))
-                                  ? 0.0f
-                                  : std::min(availableSize.x / rectSize.x, availableSize.y / rectSize.y);
-
-          auto previewSize = rectSize * previewScale;
-          auto canvasSize = ivec2(std::max(1.0f, previewSize.x), std::max(1.0f, previewSize.y));
-
-          canvas.zoom = previewScale * 100.0f;
-          canvas.pan = vec2(rect.x, rect.y);
+          auto& rendered = canvas.render(resources, actor, available);
 
           auto cursorPos = ImGui::GetCursorPos();
-          ImGui::SetCursorPos(ImVec2(cursorPos.x + (availableSize.x * 0.5f) - ((float)canvasSize.x * 0.5f),
-                                     cursorPos.y + (availableSize.y * 0.5f) - ((float)canvasSize.y * 0.5f)));
+          ImGui::SetCursorPos(ImVec2(cursorPos.x + (availableSize.x * 0.5f) - (canvas.imageSize.x * 0.5f),
+                                     cursorPos.y + (availableSize.y * 0.5f) - (canvas.imageSize.y * 0.5f)));
 
-          canvas.bind();
-          canvas.size_set(canvasSize);
-          canvas.clear();
-          actor.render(resources.shaders[shader::TEXTURE], resources.shaders[shader::RECT], canvas);
-          canvas.unbind();
-
-          ImGui::Image(canvas.texture, imgui::to_imvec2(canvasSize));
+          ImGui::Image(rendered.texture, canvas.imageSize);
 
           ImGui::EndTabItem();
         }
@@ -106,6 +94,6 @@ namespace game::state::select
       }
     }
     ImGui::End();
-    imgui::style::color_set(resources.settings.color);
+    imgui::style::color_set(resources.settings.root()->color);
   }
 }
diff --git a/src/state/select/preview.hpp b/src/state/select/preview.hpp
index 1d2c8cd..b2b106b 100644
--- a/src/state/select/preview.hpp
+++ b/src/state/select/preview.hpp
@@ -1,7 +1,8 @@
 #pragma once
 
-#include "../../entity/actor.hpp"
+#include "../../entity.hpp"
 #include "../../resources.hpp"
+#include "../../util/imgui/entity_canvas.hpp"
 
 namespace game::state::select
 {
@@ -9,13 +10,11 @@ namespace game::state::select
   {
   public:
     int previousCharacterIndex{-1};
-    entity::Actor actor{};
-    glm::vec4 rect{};
+    Entity actor{};
     bool isInGame{};
 
-    Canvas canvas{glm::vec2(), Canvas::FLIP};
+    util::imgui::widget::EntityCanvas canvas{};
 
     void update(Resources& resources, int characterIndex);
-    void tick(int characterIndex);
   };
 }
diff --git a/src/state/settings_menu.cpp b/src/state/settings_menu.cpp
index 0214f7d..0b1d873 100644
--- a/src/state/settings_menu.cpp
+++ b/src/state/settings_menu.cpp
@@ -5,6 +5,7 @@
 
 #include "../util/imgui/style.hpp"
 #include "../util/imgui/widget.hpp"
+#include "../util/display.hpp"
 #include "../util/math.hpp"
 #include "../util/measurement.hpp"
 
@@ -16,10 +17,16 @@ namespace game::state
 {
   void SettingsMenu::update(Resources& resources, Mode mode, const Strings* strings)
   {
-    auto& settings = resources.settings;
-    auto& measurementSystem = settings.measurementSystem;
-    auto& volume = settings.volume;
-    auto& color = settings.color;
+    auto* settings = resources.settings.root();
+    if (!settings)
+    {
+      resources.settings.settings_default();
+      settings = resources.settings.root();
+    }
+    auto measurementSystem = settings->measurementSystem == "Imperial" ? measurement::IMPERIAL : measurement::METRIC;
+    auto& volume = settings->volume;
+    auto& isAudioMuted = settings->isAudioMuted;
+    auto& color = settings->color;
     auto string_get = [&](Strings::Type type, const char* fallback) -> const char*
     {
       return strings ? strings->get(type).c_str() : fallback;
@@ -35,23 +42,41 @@ namespace game::state
     WIDGET_FX(ImGui::RadioButton(string_get(Strings::SettingsImperial, "Imperial"),
                                  (int*)&measurementSystem, measurement::IMPERIAL));
     ImGui::SetItemTooltip("%s", string_get(Strings::SettingsImperialTooltip, "Use pounds (lbs)."));
+    settings->measurementSystem = measurementSystem == measurement::IMPERIAL ? "Imperial" : "Metric";
+
+    ImGui::SeparatorText(string_get(Strings::SettingsWindow, "Window"));
+    const char* windowModes[] = {
+        string_get(Strings::SettingsWindowed, "Windowed"),
+        string_get(Strings::SettingsFullscreen, "Fullscreen"),
+    };
+    auto windowMode = display::fullscreen_get() ? 1 : 0;
+    if (WIDGET_FX(ImGui::Combo(string_get(Strings::SettingsWindowMode, "Mode"), &windowMode, windowModes, 2)))
+      display::fullscreen_set(windowMode == 1);
+    ImGui::SetItemTooltip("%s", string_get(Strings::SettingsWindowModeTooltip,
+                                           "Switch between windowed and fullscreen display.\n(Shortcut: F)"));
 
     ImGui::SeparatorText(string_get(Strings::SettingsSound, "Sound"));
+    ImGui::BeginDisabled(isAudioMuted);
     if (WIDGET_FX(
             ImGui::SliderInt(string_get(Strings::SettingsVolume, "Volume"), &volume, 0, 100, "%d%%")))
       resources.volume_set(math::to_unit((float)volume));
     ImGui::SetItemTooltip("%s", string_get(Strings::SettingsVolumeTooltip, "Adjust master volume."));
+    ImGui::EndDisabled();
+    ImGui::SameLine();
+    if (WIDGET_FX(ImGui::Checkbox(string_get(Strings::SettingsMute, "Mute"), &isAudioMuted)))
+      resources.audio_mute_set(isAudioMuted);
+    ImGui::SetItemTooltip("%s", string_get(Strings::SettingsMuteTooltip, "Mute all audio.\n(Shortcut: M)"));
 
     ImGui::SeparatorText(string_get(Strings::SettingsAppearance, "Appearance"));
 
     if (WIDGET_FX(ImGui::Checkbox(string_get(Strings::SettingsUseCharacterColor,
                                              "Use Character Color"),
-                                  &settings.isUseCharacterColor)))
+                                  &settings->isUseCharacterColor)))
       isJustColorSet = true;
     ImGui::SetItemTooltip("%s", string_get(Strings::SettingsUseCharacterColorTooltip,
                                            "When playing, the UI will use the character's preset UI color."));
     ImGui::SameLine();
-    ImGui::BeginDisabled(settings.isUseCharacterColor);
+    ImGui::BeginDisabled(settings->isUseCharacterColor);
     if (WIDGET_FX(
             ImGui::ColorEdit3(string_get(Strings::SettingsColor, "Color"), value_ptr(color),
                               ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoTooltip)))
@@ -66,8 +91,9 @@ namespace game::state
     if (WIDGET_FX(ImGui::Button(string_get(Strings::SettingsResetButton, "Reset to Default"),
                                 ImVec2(-FLT_MIN, 0))))
     {
-      settings = resource::xml::Settings();
-      style::color_set(settings.color);
+      resources.settings.settings_default();
+      settings = resources.settings.root();
+      style::color_set(settings->color);
     }
 
     if (mode == PLAY)
diff --git a/src/state/settings_menu.hpp b/src/state/settings_menu.hpp
index 2afa1b6..b7467a9 100644
--- a/src/state/settings_menu.hpp
+++ b/src/state/settings_menu.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../resource/xml/strings.hpp"
+#include "../resource/strings.hpp"
 #include "../resources.hpp"
 
 namespace game::state
diff --git a/src/util/clipboard.cpp b/src/util/clipboard.cpp
new file mode 100644
index 0000000..531d44f
--- /dev/null
+++ b/src/util/clipboard.cpp
@@ -0,0 +1,34 @@
+#include "clipboard.hpp"
+
+#include <imgui.h>
+
+namespace game::util
+{
+  void Clipboard::copy(const std::string& value)
+  {
+    text = value;
+    isCut = false;
+    ImGui::SetClipboardText(text.c_str());
+  }
+
+  void Clipboard::cut(const std::string& value)
+  {
+    text = value;
+    isCut = true;
+    ImGui::SetClipboardText(text.c_str());
+  }
+
+  void Clipboard::clear()
+  {
+    text.clear();
+    isCut = false;
+  }
+
+  const char* Clipboard::get() const
+  {
+    auto* systemText = ImGui::GetClipboardText();
+    return systemText && *systemText ? systemText : text.c_str();
+  }
+
+  bool Clipboard::cut_get() const { return isCut; }
+}
diff --git a/src/util/clipboard.hpp b/src/util/clipboard.hpp
new file mode 100644
index 0000000..e4156c2
--- /dev/null
+++ b/src/util/clipboard.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string>
+
+namespace game::util
+{
+  class Clipboard
+  {
+    std::string text{};
+    bool isCut{};
+
+  public:
+    void copy(const std::string&);
+    void cut(const std::string&);
+    void clear();
+    const char* get() const;
+    bool cut_get() const;
+  };
+}
diff --git a/src/util/dialog.cpp b/src/util/dialog.cpp
new file mode 100644
index 0000000..a8d2452
--- /dev/null
+++ b/src/util/dialog.cpp
@@ -0,0 +1,79 @@
+#include "dialog.hpp"
+
+#include <cstring>
+
+namespace game::util
+{
+  namespace
+  {
+    const SDL_DialogFileFilter* filters_get(Dialog::Filter filter)
+    {
+      if (filter == Dialog::NO_FILTER) return nullptr;
+      return Dialog::FILTERS[filter];
+    }
+
+    int filter_count_get(Dialog::Filter filter)
+    {
+      if (filter == Dialog::NO_FILTER) return 0;
+      return (int)std::size(Dialog::FILTERS[filter]);
+    }
+
+    void callback(void* userData, const char* const* filelist, int filter)
+    {
+      auto* self = (Dialog*)userData;
+      if (!self) return;
+
+      if (filelist && filelist[0] && std::strlen(filelist[0]) > 0)
+      {
+        self->path = filelist[0];
+        self->selectedFilter = filter;
+      }
+      else
+      {
+        self->path.clear();
+        self->selectedFilter = -1;
+      }
+    }
+  }
+
+  Dialog::Dialog(SDL_Window* _window) : window(_window) {}
+
+  void Dialog::window_set(SDL_Window* _window) { window = _window; }
+
+  void Dialog::file_open(Type _type)
+  {
+    if (_type == NONE) return;
+    auto filter = TYPE_FILTERS[_type];
+    type = _type;
+    path.clear();
+    selectedFilter = -1;
+    SDL_ShowOpenFileDialog(callback, this, window, filters_get(filter), filter_count_get(filter), nullptr, false);
+  }
+
+  void Dialog::file_save(Type _type)
+  {
+    if (_type == NONE) return;
+    auto filter = TYPE_FILTERS[_type];
+    type = _type;
+    path.clear();
+    selectedFilter = -1;
+    SDL_ShowSaveFileDialog(callback, this, window, filters_get(filter), filter_count_get(filter), nullptr);
+  }
+
+  void Dialog::folder_open(Type _type)
+  {
+    if (_type == NONE) return;
+    type = _type;
+    path.clear();
+    selectedFilter = -1;
+    SDL_ShowOpenFolderDialog(callback, this, window, nullptr, false);
+  }
+
+  bool Dialog::is_selected(Type _type) const { return type == _type && !path.empty(); }
+
+  void Dialog::reset()
+  {
+    auto* currentWindow = window;
+    *this = Dialog(currentWindow);
+  }
+}
diff --git a/src/util/dialog.hpp b/src/util/dialog.hpp
new file mode 100644
index 0000000..1ab7b9d
--- /dev/null
+++ b/src/util/dialog.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <filesystem>
+
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_dialog.h>
+
+namespace game::util
+{
+  class Dialog
+  {
+  public:
+#define GAME_DIALOG_FILTERS(X)                                                                                     \
+  X(NO_FILTER, {})                                                                                                  \
+  X(ZIP_FILTER, {"ZIP archive", "zip;ZIP"})                                                                        \
+  X(TEXTURE_FILTER, {"Texture", "png;PNG"})                                                                        \
+  X(SOUND_FILTER, {"Sound", "wav;WAV;ogg;OGG;mp3;MP3"})
+
+    enum Filter
+    {
+#define GAME_DIALOG_FILTER_ENUM(SYMBOL, ...) SYMBOL,
+      GAME_DIALOG_FILTERS(GAME_DIALOG_FILTER_ENUM)
+#undef GAME_DIALOG_FILTER_ENUM
+    };
+
+    static constexpr SDL_DialogFileFilter FILTERS[][1] = {
+#define GAME_DIALOG_FILTER_VALUE(SYMBOL, ...) {__VA_ARGS__},
+        GAME_DIALOG_FILTERS(GAME_DIALOG_FILTER_VALUE)
+#undef GAME_DIALOG_FILTER_VALUE
+    };
+
+#undef GAME_DIALOG_FILTERS
+
+#define GAME_DIALOG_TYPES(X)                                                                                       \
+  X(NONE, NO_FILTER)                                                                                               \
+  X(SCHEMA_FOLDER_OPEN, NO_FILTER)                                                                                 \
+  X(DOCUMENT_EXPORT, ZIP_FILTER)                                                                                   \
+  X(SCHEMA_RESOURCE_FOLDER_OPEN, NO_FILTER)                                                                        \
+  X(SCHEMA_SOUND_OPEN, SOUND_FILTER)                                                                               \
+  X(SCHEMA_TEXTURE_OPEN, TEXTURE_FILTER)
+
+    enum Type
+    {
+#define GAME_DIALOG_TYPE_ENUM(SYMBOL, FILTER) SYMBOL,
+      GAME_DIALOG_TYPES(GAME_DIALOG_TYPE_ENUM)
+#undef GAME_DIALOG_TYPE_ENUM
+    };
+
+    static constexpr Filter TYPE_FILTERS[]{
+#define GAME_DIALOG_TYPE_FILTER(SYMBOL, FILTER) FILTER,
+        GAME_DIALOG_TYPES(GAME_DIALOG_TYPE_FILTER)
+#undef GAME_DIALOG_TYPE_FILTER
+    };
+
+#undef GAME_DIALOG_TYPES
+
+    SDL_Window* window{};
+    std::filesystem::path path{};
+    Type type{NONE};
+    int selectedFilter{-1};
+
+    Dialog() = default;
+    explicit Dialog(SDL_Window*);
+
+    void window_set(SDL_Window*);
+    void file_open(Type);
+    void file_save(Type);
+    void folder_open(Type);
+    bool is_selected(Type) const;
+    void reset();
+  };
+}
diff --git a/src/util/display.cpp b/src/util/display.cpp
new file mode 100644
index 0000000..4800f57
--- /dev/null
+++ b/src/util/display.cpp
@@ -0,0 +1,62 @@
+#include "display.hpp"
+
+#include <glm/vec2.hpp>
+
+namespace game::util::display
+{
+  namespace
+  {
+    SDL_Window* window{};
+    bool isFullscreen{};
+    glm::ivec2 windowedPosition{};
+    glm::ivec2 windowedSize{};
+  }
+
+  void init(SDL_Window* value)
+  {
+    window = value;
+    if (!window) return;
+
+    SDL_GetWindowPosition(window, &windowedPosition.x, &windowedPosition.y);
+    SDL_GetWindowSize(window, &windowedSize.x, &windowedSize.y);
+  }
+
+  bool fullscreen_get()
+  {
+    return isFullscreen;
+  }
+
+  void fullscreen_set(bool enabled)
+  {
+    if (!window || enabled == isFullscreen) return;
+
+    if (enabled)
+    {
+      SDL_GetWindowPosition(window, &windowedPosition.x, &windowedPosition.y);
+      SDL_GetWindowSize(window, &windowedSize.x, &windowedSize.y);
+
+      auto displayID = SDL_GetDisplayForWindow(window);
+      if (!displayID) displayID = SDL_GetPrimaryDisplay();
+
+      if (const auto* mode = SDL_GetDesktopDisplayMode(displayID))
+      {
+        SDL_SetWindowFullscreenMode(window, nullptr);
+        SDL_SetWindowSize(window, mode->w, mode->h);
+      }
+
+      SDL_SetWindowFullscreen(window, true);
+      isFullscreen = true;
+      return;
+    }
+
+    SDL_SetWindowFullscreen(window, false);
+    SDL_SetWindowSize(window, windowedSize.x, windowedSize.y);
+    SDL_SetWindowPosition(window, windowedPosition.x, windowedPosition.y);
+    isFullscreen = false;
+  }
+
+  void fullscreen_toggle()
+  {
+    fullscreen_set(!isFullscreen);
+  }
+}
diff --git a/src/util/display.hpp b/src/util/display.hpp
new file mode 100644
index 0000000..57d788f
--- /dev/null
+++ b/src/util/display.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+namespace game::util::display
+{
+  void init(SDL_Window*);
+  bool fullscreen_get();
+  void fullscreen_set(bool);
+  void fullscreen_toggle();
+}
diff --git a/src/util/imgui.cpp b/src/util/imgui.cpp
index 8364a5d..52479e8 100644
--- a/src/util/imgui.cpp
+++ b/src/util/imgui.cpp
@@ -1,7 +1,139 @@
 #include "imgui.hpp"
 
+#include <algorithm>
+#include <cfloat>
+#include <string>
+
 namespace game::util::imgui
 {
+  constexpr auto DRAW_LIST_TEXT_WRAP_WIDTH_NONE = 0.0f;
+  constexpr auto DRAW_LIST_TEXT_CENTER_RATIO = 0.5f;
+  constexpr auto DRAW_LIST_TEXT_DIGIT_SLOT_PADDING = 1.0f;
+
+#define DRAW_LIST_TEXT_DIGITS(X)                                                                                      \
+  X('0')                                                                                                              \
+  X('1')                                                                                                              \
+  X('2')                                                                                                              \
+  X('3')                                                                                                              \
+  X('4')                                                                                                              \
+  X('5')                                                                                                              \
+  X('6')                                                                                                              \
+  X('7')                                                                                                              \
+  X('8')                                                                                                              \
+  X('9')
+
+  void triangle_draw(ImDrawList& drawList, ImVec2 pos, ImVec2 size, TriangleDirection direction, ImU32 color)
+  {
+    static constexpr auto HALF_MULTIPLIER = 0.5f;
+    static constexpr auto TRIANGLE_HALF_MULTIPLIER = 0.22f;
+
+    auto center = ImVec2(pos.x + (size.x * HALF_MULTIPLIER), pos.y + (size.y * HALF_MULTIPLIER));
+    auto half = size.x * TRIANGLE_HALF_MULTIPLIER;
+    ImVec2 tip;
+    ImVec2 baseA;
+    ImVec2 baseB;
+    if (direction == TriangleDirection::LEFT)
+    {
+      tip = ImVec2(center.x - half, center.y);
+      baseA = ImVec2(center.x + half, center.y - half);
+      baseB = ImVec2(center.x + half, center.y + half);
+    }
+    else
+    {
+      tip = ImVec2(center.x + half, center.y);
+      baseA = ImVec2(center.x - half, center.y - half);
+      baseB = ImVec2(center.x - half, center.y + half);
+    }
+
+    drawList.AddTriangleFilled(tip, baseA, baseB, color);
+  }
+
+  ImVec2 draw_list_text_size_get(const char* text, float fontSize)
+  {
+    auto* font = ImGui::GetFont();
+    if (!font || !text) return ImVec2();
+    return font->CalcTextSizeA(fontSize, FLT_MAX, DRAW_LIST_TEXT_WRAP_WIDTH_NONE, text);
+  }
+
+  ImVec2 draw_list_text_size_get(const std::string& text, float fontSize)
+  {
+    return draw_list_text_size_get(text.c_str(), fontSize);
+  }
+
+  void draw_list_text_draw(ImDrawList& drawList, ImVec2 position, const std::string& text, float fontSize, ImU32 color)
+  {
+    auto* font = ImGui::GetFont();
+    if (!font) return;
+    drawList.AddText(font, fontSize, position, color, text.c_str());
+  }
+
+  ImVec2 draw_list_text_center_position_get(ImVec2 canvasMin, ImVec2 canvasSize, const std::string& text, float fontSize,
+                                            float xRatio, float yRatio)
+  {
+    auto textSize = draw_list_text_size_get(text, fontSize);
+    return ImVec2(canvasMin.x + (canvasSize.x * xRatio) - (textSize.x * DRAW_LIST_TEXT_CENTER_RATIO),
+                  canvasMin.y + (canvasSize.y * yRatio) - (textSize.y * DRAW_LIST_TEXT_CENTER_RATIO));
+  }
+
+  void draw_list_text_center_draw(ImDrawList& drawList, ImVec2 canvasMin, ImVec2 canvasSize, const std::string& text,
+                                  float fontSize, float xRatio, float yRatio, ImU32 color)
+  {
+    draw_list_text_draw(drawList, draw_list_text_center_position_get(canvasMin, canvasSize, text, fontSize, xRatio, yRatio),
+                        text, fontSize, color);
+  }
+
+  bool draw_list_text_digit_get(char character)
+  {
+    switch (character)
+    {
+#define DRAW_LIST_TEXT_DIGIT_CASE(characterValue)                                                                      \
+  case characterValue:                                                                                                \
+    return true;
+      DRAW_LIST_TEXT_DIGITS(DRAW_LIST_TEXT_DIGIT_CASE)
+#undef DRAW_LIST_TEXT_DIGIT_CASE
+      default:
+        return false;
+    }
+  }
+
+  float draw_list_text_digit_width_get(float fontSize)
+  {
+    auto width = DRAW_LIST_TEXT_WRAP_WIDTH_NONE;
+#define DRAW_LIST_TEXT_DIGIT_WIDTH(characterValue)                                                                     \
+  width = std::max(width, draw_list_text_size_get(std::string(1, characterValue), fontSize).x);
+    DRAW_LIST_TEXT_DIGITS(DRAW_LIST_TEXT_DIGIT_WIDTH)
+#undef DRAW_LIST_TEXT_DIGIT_WIDTH
+    return width + DRAW_LIST_TEXT_DIGIT_SLOT_PADDING;
+  }
+
+  float draw_list_digit_fixed_width_get(const std::string& text, float fontSize)
+  {
+    auto width = DRAW_LIST_TEXT_WRAP_WIDTH_NONE;
+    auto digitWidth = draw_list_text_digit_width_get(fontSize);
+    for (auto character : text)
+    {
+      auto glyph = std::string(1, character);
+      width += draw_list_text_digit_get(character) ? digitWidth : draw_list_text_size_get(glyph, fontSize).x;
+    }
+    return width;
+  }
+
+  void draw_list_digit_fixed_width_draw(ImDrawList& drawList, ImVec2 position, const std::string& text, float fontSize,
+                                        ImU32 color)
+  {
+    auto x = position.x;
+    auto digitWidth = draw_list_text_digit_width_get(fontSize);
+    for (auto character : text)
+    {
+      auto glyph = std::string(1, character);
+      auto glyphSize = draw_list_text_size_get(glyph, fontSize);
+      auto slotWidth = draw_list_text_digit_get(character) ? digitWidth : glyphSize.x;
+      auto glyphPosition = ImVec2(x + ((slotWidth - glyphSize.x) * DRAW_LIST_TEXT_CENTER_RATIO), position.y);
+      draw_list_text_draw(drawList, glyphPosition, glyph, fontSize, color);
+      x += slotWidth;
+    }
+  }
+
   float row_widget_width_get(int count, float width)
   {
     return (width - (ImGui::GetStyle().ItemSpacing.x * (float)(count - 1))) / (float)count;
@@ -24,4 +156,48 @@ namespace game::util::imgui
   {
     return ImVec2(ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y - footer_height_get(rowCount));
   }
+
+  float side_bar_width_get()
+  {
+    auto& style = ImGui::GetStyle();
+    return std::max(ImGui::GetTextLineHeightWithSpacing(), style.WindowMinSize.x);
+  }
+
+  float text_font_size_fit_get(const char* text, ImVec2 bounds, float fontSizeMax, float fontSizeMin)
+  {
+    static constexpr auto ZERO_FLOAT = 0.0f;
+    static constexpr auto ONE_FLOAT = 1.0f;
+
+    auto* font = ImGui::GetFont();
+    if (!font || !text || fontSizeMax <= ZERO_FLOAT) return fontSizeMax;
+
+    auto textSize = font->CalcTextSizeA(fontSizeMax, FLT_MAX, ZERO_FLOAT, text);
+    if (textSize.x <= ZERO_FLOAT || textSize.y <= ZERO_FLOAT) return fontSizeMax;
+
+    auto widthScale = bounds.x > ZERO_FLOAT ? bounds.x / textSize.x : ONE_FLOAT;
+    auto heightScale = bounds.y > ZERO_FLOAT ? bounds.y / textSize.y : ONE_FLOAT;
+    auto scale = std::min({ONE_FLOAT, widthScale, heightScale});
+    return std::clamp(fontSizeMax * scale, fontSizeMin, fontSizeMax);
+  }
+
+  float text_unformatted_fit_draw(const char* text, ImVec2 bounds, float fontSizeMax, float fontSizeMin)
+  {
+    static constexpr auto HALF_MULTIPLIER = 0.5f;
+    static constexpr auto ZERO_FLOAT = 0.0f;
+
+    auto* font = ImGui::GetFont();
+    auto fontSize = text_font_size_fit_get(text, bounds, fontSizeMax, fontSizeMin);
+    auto pos = ImGui::GetCursorScreenPos();
+    ImGui::Dummy(bounds);
+    if (font && text)
+    {
+      auto textSize = font->CalcTextSizeA(fontSize, FLT_MAX, ZERO_FLOAT, text);
+      auto textPos = ImVec2(pos.x, pos.y + std::max(ZERO_FLOAT, (bounds.y - textSize.y) * HALF_MULTIPLIER));
+      auto clipRect = ImVec4(pos.x, pos.y, pos.x + bounds.x, pos.y + bounds.y);
+      ImGui::GetWindowDrawList()->AddText(font, fontSize, textPos, ImGui::GetColorU32(ImGuiCol_Text), text, nullptr,
+                                          ZERO_FLOAT, &clipRect);
+    }
+    return fontSize;
+  }
+#undef DRAW_LIST_TEXT_DIGITS
 }
diff --git a/src/util/imgui.hpp b/src/util/imgui.hpp
index 3eacfbb..9013158 100644
--- a/src/util/imgui.hpp
+++ b/src/util/imgui.hpp
@@ -3,17 +3,37 @@
 #include <imgui.h>
 
 #include <glm/glm.hpp>
+#include <string>
 
 using namespace glm;
 
 namespace game::util::imgui
 {
+  inline constexpr auto TEXT_FIT_FONT_SIZE_MIN = 1.0f;
+
+  enum class TriangleDirection
+  {
+    LEFT,
+    RIGHT
+  };
+
   float row_widget_width_get(int = 1, float = ImGui::GetContentRegionAvail().x);
   ImVec2 row_widget_size_get(int = 1, float = ImGui::GetContentRegionAvail().x);
 
   float footer_height_get(int = 1);
   ImVec2 footer_size_get(int = 1);
   ImVec2 size_without_footer_get(int = 1);
+  float side_bar_width_get();
+  void triangle_draw(ImDrawList&, ImVec2, ImVec2, TriangleDirection, ImU32);
+  ImVec2 draw_list_text_size_get(const char*, float);
+  ImVec2 draw_list_text_size_get(const std::string&, float);
+  void draw_list_text_draw(ImDrawList&, ImVec2, const std::string&, float, ImU32);
+  ImVec2 draw_list_text_center_position_get(ImVec2, ImVec2, const std::string&, float, float, float);
+  void draw_list_text_center_draw(ImDrawList&, ImVec2, ImVec2, const std::string&, float, float, float, ImU32);
+  float draw_list_digit_fixed_width_get(const std::string&, float);
+  void draw_list_digit_fixed_width_draw(ImDrawList&, ImVec2, const std::string&, float, ImU32);
+  float text_font_size_fit_get(const char*, ImVec2, float, float = TEXT_FIT_FONT_SIZE_MIN);
+  float text_unformatted_fit_draw(const char*, ImVec2, float, float = TEXT_FIT_FONT_SIZE_MIN);
 
   inline ImVec2 to_imvec2(vec2 value) { return ImVec2(value.x, value.y); }
   inline ImVec2 to_imvec2(ivec2 value) { return ImVec2((float)value.x, (float)value.y); }
diff --git a/src/util/imgui/dialogue_text.cpp b/src/util/imgui/dialogue_text.cpp
new file mode 100644
index 0000000..82474d2
--- /dev/null
+++ b/src/util/imgui/dialogue_text.cpp
@@ -0,0 +1,209 @@
+#include "dialogue_text.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+
+#include <imgui.h>
+#include <imgui_internal.h>
+
+namespace game::util::imgui
+{
+  namespace
+  {
+    bool is_word_space(unsigned int codepoint) { return codepoint == ' ' || codepoint == '\t'; }
+
+    float effect_text_scale_get(std::span<const DialogueEffectSpan> effects, int charIndex)
+    {
+      auto textScale = 1.0f;
+      for (auto& effect : effects)
+      {
+        if (effect.start > charIndex || charIndex >= effect.end) continue;
+        if (effect.type == DialogueEffectSpan::TEXT_SCALE) textScale = std::max(0.05f, effect.textScale);
+      }
+      return textScale;
+    }
+
+    float word_width_get(const char* text, const char* limit, int charIndex, std::span<const DialogueEffectSpan> effects)
+    {
+      auto width = 0.0f;
+      for (auto* it = text; it < limit;)
+      {
+        unsigned int codepoint{};
+        auto step = ImTextCharFromUtf8(&codepoint, it, limit);
+        if (step <= 0 || codepoint == '\n' || is_word_space(codepoint)) break;
+        auto* next = it + step;
+        auto textScale = effect_text_scale_get(effects, charIndex);
+        width += ImGui::CalcTextSize(it, next).x * textScale;
+        it = next;
+        ++charIndex;
+      }
+      return width;
+    }
+
+    float hash_to_unit(std::uint32_t value)
+    {
+      value ^= value >> 16;
+      value *= 0x7feb352du;
+      value ^= value >> 15;
+      value *= 0x846ca68bu;
+      value ^= value >> 16;
+      return (float)(value & 0xffffu) / 65535.0f;
+    }
+
+  }
+
+  int utf8_char_count(std::string_view text)
+  {
+    return ImTextCountCharsFromUtf8(text.data(), text.data() + text.size());
+  }
+
+  int utf8_byte_to_char_index(std::string_view text, int byteIndex)
+  {
+    auto* textStart = text.data();
+    auto* textEnd = textStart + text.size();
+    auto* byteEnd = textStart + std::clamp(byteIndex, 0, (int)text.size());
+    auto count = 0;
+    for (auto* it = textStart; it < textEnd && it < byteEnd;)
+    {
+      unsigned int codepoint{};
+      auto step = ImTextCharFromUtf8(&codepoint, it, textEnd);
+      if (step <= 0) break;
+      it += step;
+      ++count;
+    }
+    return count;
+  }
+
+  const char* utf8_advance_chars(const char* text, const char* end, int count)
+  {
+    auto* it = text;
+    while (it < end && count > 0)
+    {
+      unsigned int codepoint{};
+      auto step = ImTextCharFromUtf8(&codepoint, it, end);
+      if (step <= 0) break;
+      it += step;
+      --count;
+    }
+    return it;
+  }
+
+  ImVec2 dialogue_text_draw(std::string_view text, int count, std::span<const DialogueEffectSpan> effects,
+                            glm::vec3 defaultColor, float time)
+  {
+    static constexpr auto TAU = 6.28318530717958647692f;
+    auto blockStart = ImGui::GetCursorScreenPos();
+    auto blockMax = blockStart;
+    auto* textStart = text.data();
+    auto* textEnd = textStart + text.size();
+    auto* textLimit = utf8_advance_chars(textStart, textEnd, count);
+    auto lineStartX = ImGui::GetCursorScreenPos().x;
+    auto wrapX = lineStartX + ImGui::GetContentRegionAvail().x;
+    auto charIndex = 0;
+    auto isLineStart = true;
+
+    for (auto* it = textStart; it < textLimit;)
+    {
+      unsigned int codepoint{};
+      auto step = ImTextCharFromUtf8(&codepoint, it, textLimit);
+      if (step <= 0) break;
+
+      auto* next = it + step;
+      if (codepoint == '\n')
+      {
+        ImGui::NewLine();
+        lineStartX = ImGui::GetCursorScreenPos().x;
+        wrapX = lineStartX + ImGui::GetContentRegionAvail().x;
+        blockMax.y = std::max(blockMax.y, ImGui::GetCursorScreenPos().y);
+        it = next;
+        ++charIndex;
+        isLineStart = true;
+        continue;
+      }
+
+      auto isSpace = is_word_space(codepoint);
+      auto color = defaultColor;
+      auto textScale = 1.0f;
+      auto xOffset = 0.0f;
+      auto yOffset = 0.0f;
+      for (auto& effect : effects)
+      {
+        if (effect.start > charIndex || charIndex >= effect.end) continue;
+        if (effect.type == DialogueEffectSpan::COLOR)
+          color = effect.color;
+        else if (effect.type == DialogueEffectSpan::TEXT_SCALE)
+          textScale = std::max(0.05f, effect.textScale);
+        else if (effect.type == DialogueEffectSpan::OSCILLATE)
+        {
+          auto frequency = effect.frequency > 0.0f ? effect.frequency : 1.0f;
+          auto amplitude = effect.amplitude > 0.0f ? effect.amplitude : 2.0f;
+          yOffset += std::sin((time * frequency + charIndex * 0.16f) * TAU) * amplitude;
+        }
+        else if (effect.type == DialogueEffectSpan::SHAKE)
+        {
+          auto frequency = effect.frequency > 0.0f ? effect.frequency : 12.0f;
+          auto amplitude = effect.amplitude > 0.0f ? effect.amplitude : 1.0f;
+          auto tick = (std::uint32_t)std::floor(time * frequency);
+          auto seed = tick * 747796405u + (std::uint32_t)charIndex * 2891336453u;
+          xOffset += (hash_to_unit(seed) * 2.0f - 1.0f) * amplitude;
+          yOffset += (hash_to_unit(seed ^ 0xa511e9b3u) * 2.0f - 1.0f) * amplitude;
+        }
+      }
+
+      auto* font = ImGui::GetFont();
+      auto fontSize = ImGui::GetFontSize() * textScale;
+      auto size = ImGui::CalcTextSize(it, next);
+      size.x *= textScale;
+      size.y *= textScale;
+      auto cursorX = ImGui::GetCursorScreenPos().x;
+      if (!isSpace && isLineStart == false &&
+          (it == textStart || is_word_space((unsigned char)*(it - 1)) || *(it - 1) == '\n'))
+      {
+        auto wordWidth = word_width_get(it, textLimit, charIndex, effects);
+        if (wordWidth > 0.0f && cursorX + wordWidth > wrapX && lineStartX + wordWidth <= wrapX)
+        {
+          ImGui::NewLine();
+          lineStartX = ImGui::GetCursorScreenPos().x;
+          wrapX = lineStartX + ImGui::GetContentRegionAvail().x;
+          cursorX = ImGui::GetCursorScreenPos().x;
+          isLineStart = true;
+        }
+      }
+      if (cursorX + size.x > wrapX)
+      {
+        ImGui::NewLine();
+        lineStartX = ImGui::GetCursorScreenPos().x;
+        wrapX = lineStartX + ImGui::GetContentRegionAvail().x;
+        cursorX = ImGui::GetCursorScreenPos().x;
+        if (isSpace)
+        {
+          it = next;
+          ++charIndex;
+          isLineStart = true;
+          continue;
+        }
+      }
+
+      auto cursor = ImGui::GetCursorScreenPos();
+      auto drawCursor = ImVec2(cursor.x + xOffset, cursor.y + yOffset);
+      auto textColor = ImGui::GetColorU32(ImVec4(color.r, color.g, color.b, 1.0f));
+      ImGui::GetWindowDrawList()->AddText(font, fontSize, drawCursor, textColor, it, next);
+      ImGui::Dummy(size);
+      blockMax.x = std::max(blockMax.x, drawCursor.x + size.x);
+      blockMax.y = std::max(blockMax.y, drawCursor.y + size.y);
+      ImGui::SetCursorScreenPos(ImVec2(cursor.x + size.x, cursor.y));
+
+      it = next;
+      ++charIndex;
+      if (!isSpace) isLineStart = false;
+      if (it < textLimit) ImGui::SameLine(0.0f, 0.0f);
+    }
+
+    auto result = ImVec2(blockMax.x - blockStart.x, blockMax.y - blockStart.y);
+    auto reservedHeight = std::max(result.y, ImGui::GetTextLineHeight());
+    ImGui::SetCursorScreenPos(ImVec2(blockStart.x, blockStart.y + reservedHeight));
+    ImGui::Dummy(ImVec2(1.0f, 1.0f));
+    return result;
+  }
+}
diff --git a/src/util/imgui/dialogue_text.hpp b/src/util/imgui/dialogue_text.hpp
new file mode 100644
index 0000000..626d3d8
--- /dev/null
+++ b/src/util/imgui/dialogue_text.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <span>
+#include <string_view>
+
+#include <glm/glm.hpp>
+#include <imgui.h>
+
+namespace game::util::imgui
+{
+  struct DialogueEffectSpan
+  {
+    enum Type
+    {
+      COLOR,
+      TEXT_SCALE,
+      OSCILLATE,
+      SHAKE
+    };
+
+    Type type{COLOR};
+    int start{};
+    int end{};
+    glm::vec3 color{1.0f};
+    float textScale{1.0f};
+    float frequency{1.0f};
+    float amplitude{};
+  };
+
+  int utf8_char_count(std::string_view text);
+  int utf8_byte_to_char_index(std::string_view text, int byteIndex);
+  const char* utf8_advance_chars(const char* text, const char* end, int count);
+  ImVec2 dialogue_text_draw(std::string_view text, int count, std::span<const DialogueEffectSpan> effects = {},
+                            glm::vec3 defaultColor = glm::vec3{1.0f}, float time = 0.0f);
+}
diff --git a/src/util/imgui/entity_button.cpp b/src/util/imgui/entity_button.cpp
new file mode 100644
index 0000000..3478e52
--- /dev/null
+++ b/src/util/imgui/entity_button.cpp
@@ -0,0 +1,21 @@
+#include "entity_button.hpp"
+
+#include "widget.hpp"
+
+namespace game::util::imgui::widget
+{
+  void EntityButton::clear() { canvas.clear(); }
+
+  Canvas& EntityButton::canvas_get(Resources& resources, Entity& entity, ImVec2 size)
+  {
+    return canvas.render(resources, entity, size);
+  }
+
+  bool EntityButton::button(Resources& resources, Entity& entity, const char* id, ImVec2 size, ImVec4 tint)
+  {
+    auto& entityCanvas = canvas_get(resources, entity, size);
+    auto result = ImGui::ImageButton(id, entityCanvas.texture, size, ImVec2(), ImVec2(1, 1), ImVec4(), tint);
+    fx();
+    return result;
+  }
+}
diff --git a/src/util/imgui/entity_button.hpp b/src/util/imgui/entity_button.hpp
new file mode 100644
index 0000000..478ae60
--- /dev/null
+++ b/src/util/imgui/entity_button.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "entity_canvas.hpp"
+
+#include "../../entity.hpp"
+#include "../../render/canvas.hpp"
+#include "../../resources.hpp"
+
+#include <imgui.h>
+
+namespace game::util::imgui::widget
+{
+  class EntityButton
+  {
+  public:
+    EntityCanvas canvas{};
+
+    void clear();
+    Canvas& canvas_get(Resources&, Entity&, ImVec2);
+    bool button(Resources&, Entity&, const char*, ImVec2, ImVec4 = ImVec4(1, 1, 1, 1));
+  };
+}
diff --git a/src/util/imgui/entity_canvas.cpp b/src/util/imgui/entity_canvas.cpp
new file mode 100644
index 0000000..955492a
--- /dev/null
+++ b/src/util/imgui/entity_canvas.cpp
@@ -0,0 +1,109 @@
+#include "entity_canvas.hpp"
+
+#include "../math.hpp"
+
+#include <algorithm>
+#include <cmath>
+
+namespace game::util::imgui::widget
+{
+  namespace
+  {
+    bool is_rect_valid(glm::vec4 rect)
+    {
+      return std::isfinite(rect.x) && std::isfinite(rect.y) && std::isfinite(rect.z) &&
+             std::isfinite(rect.w) && rect.z > 0.0f && rect.w > 0.0f;
+    }
+
+    struct CanvasEffects
+    {
+      glm::vec2 shakeOffset{};
+      int shakeTimer{};
+      int shakeTimerMax{};
+    };
+
+    CanvasEffects canvas_effects_get(const Canvas& canvas)
+    {
+      return {.shakeOffset = canvas.shakeOffset,
+              .shakeTimer = canvas.shakeTimer,
+              .shakeTimerMax = canvas.shakeTimerMax};
+    }
+
+    void canvas_effects_apply(Canvas& canvas, const CanvasEffects& effects)
+    {
+      canvas.shakeOffset = effects.shakeOffset;
+      canvas.shakeTimer = effects.shakeTimer;
+      canvas.shakeTimerMax = effects.shakeTimerMax;
+    }
+  }
+
+  void EntityCanvas::clear()
+  {
+    auto effects = canvas_effects_get(canvas);
+    canvas = {};
+    canvas_effects_apply(canvas, effects);
+    rect = glm::vec4(NAN);
+    imageSize = {};
+    scale = {};
+  }
+
+  ImVec2 EntityCanvas::shake_offset_get() const
+  {
+    return ImVec2(canvas.shakeOffset.x * scale, canvas.shakeOffset.y * scale);
+  }
+
+  Canvas& EntityCanvas::render(Resources& resources, Entity& entity, ImVec2 size, float maxScale)
+  {
+    return render(resources, entity, size, maxScale, nullptr);
+  }
+
+  Canvas& EntityCanvas::render_rotated(Resources& resources, Entity& entity, ImVec2 size, float rotation,
+                                       float maxScale)
+  {
+    return render(resources, entity, size, maxScale, &rotation);
+  }
+
+  Canvas& EntityCanvas::render(Resources& resources, Entity& entity, ImVec2 size, float maxScale,
+                               const float* rotation)
+  {
+    if (!is_rect_valid(rect)) rect = entity.rect();
+
+    auto rectSize = glm::vec2(rect.z, rect.w);
+    scale = (size.x <= 0.0f || size.y <= 0.0f || !is_rect_valid(rect))
+                ? 0.0f
+                : std::min(size.x / rectSize.x, size.y / rectSize.y);
+    if (maxScale > 0.0f) scale = std::min(maxScale, scale);
+
+    auto previewSize = rectSize * scale;
+    imageSize = ImVec2(previewSize.x, previewSize.y);
+    auto canvasSize = glm::ivec2(std::max(1.0f, previewSize.x), std::max(1.0f, previewSize.y));
+
+    if (!canvas.is_valid())
+    {
+      auto effects = canvas_effects_get(canvas);
+      canvas = Canvas(canvasSize, Canvas::FLIP);
+      canvas_effects_apply(canvas, effects);
+    }
+
+    canvas.zoom = math::to_percent(scale);
+    canvas.pan = glm::vec2(rect.x, rect.y);
+    canvas.bind();
+    canvas.size_set(canvasSize);
+    canvas.clear();
+
+    if (rotation)
+    {
+      entity.overrides.emplace_back(-1, resource::xml::Anm2::ROOT, Entity::Override::SET,
+                                    resource::xml::Anm2::FrameOptional{.rotation = *rotation});
+      entity.render(resources.shaders[resource::shader::TEXTURE], resources.shaders[resource::shader::RECT],
+                    canvas);
+      entity.overrides.pop_back();
+    }
+    else
+      entity.render(resources.shaders[resource::shader::TEXTURE], resources.shaders[resource::shader::RECT],
+                    canvas);
+
+    canvas.unbind();
+    return canvas;
+  }
+}
diff --git a/src/util/imgui/entity_canvas.hpp b/src/util/imgui/entity_canvas.hpp
new file mode 100644
index 0000000..66522ad
--- /dev/null
+++ b/src/util/imgui/entity_canvas.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "../../entity.hpp"
+#include "../../render/canvas.hpp"
+#include "../../resources.hpp"
+
+#include <imgui.h>
+
+namespace game::util::imgui::widget
+{
+  class EntityCanvas
+  {
+  public:
+    Canvas canvas{};
+    glm::vec4 rect{NAN};
+    ImVec2 imageSize{};
+    float scale{};
+
+    void clear();
+    ImVec2 shake_offset_get() const;
+    Canvas& render(Resources&, Entity&, ImVec2, float maxScale = 0.0f);
+    Canvas& render_rotated(Resources&, Entity&, ImVec2, float rotation, float maxScale = 0.0f);
+
+  private:
+    Canvas& render(Resources&, Entity&, ImVec2, float maxScale, const float* rotation);
+  };
+}
diff --git a/src/util/imgui/input_string.cpp b/src/util/imgui/input_string.cpp
new file mode 100644
index 0000000..bdef435
--- /dev/null
+++ b/src/util/imgui/input_string.cpp
@@ -0,0 +1,28 @@
+#include "input_string.hpp"
+
+#include <misc/cpp/imgui_stdlib.h>
+#include <misc/cpp/imgui_stdlib.cpp>
+
+namespace game::util::imgui
+{
+  bool input_string(const char* label, std::string& value, ImGuiInputTextFlags flags)
+  {
+    auto changed = ImGui::InputText(label, &value, flags);
+    return ImGui::IsItemDeactivatedAfterEdit() ||
+           (changed && (flags & ImGuiInputTextFlags_EnterReturnsTrue));
+  }
+
+  bool input_string_multiline(const char* label, std::string& value, const ImVec2& size, ImGuiInputTextFlags flags)
+  {
+    return input_string_multiline_result(label, value, size, flags).committed;
+  }
+
+  InputStringResult input_string_multiline_result(const char* label, std::string& value, const ImVec2& size,
+                                                  ImGuiInputTextFlags flags)
+  {
+    auto changed = ImGui::InputTextMultiline(label, &value, size, flags);
+    return {.changed = changed,
+            .committed = ImGui::IsItemDeactivatedAfterEdit() ||
+                         (changed && (flags & ImGuiInputTextFlags_EnterReturnsTrue))};
+  }
+}
diff --git a/src/util/imgui/input_string.hpp b/src/util/imgui/input_string.hpp
new file mode 100644
index 0000000..3beb33e
--- /dev/null
+++ b/src/util/imgui/input_string.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+
+#include <imgui.h>
+
+namespace game::util::imgui
+{
+  struct InputStringResult
+  {
+    bool changed{};
+    bool committed{};
+  };
+
+  bool input_string(const char* label, std::string& value, ImGuiInputTextFlags flags = 0);
+  bool input_string_multiline(const char* label, std::string& value, const ImVec2& size = ImVec2(0, 0),
+                              ImGuiInputTextFlags flags = 0);
+  InputStringResult input_string_multiline_result(const char* label, std::string& value,
+                                                  const ImVec2& size = ImVec2(0, 0),
+                                                  ImGuiInputTextFlags flags = 0);
+}
diff --git a/src/util/imgui/io.cpp b/src/util/imgui/io.cpp
new file mode 100644
index 0000000..f6820bc
--- /dev/null
+++ b/src/util/imgui/io.cpp
@@ -0,0 +1,13 @@
+#include "io.hpp"
+
+#include <imgui.h>
+
+namespace game::util::imgui::io
+{
+  void keyboard_repeat_set()
+  {
+    auto& io = ImGui::GetIO();
+    io.KeyRepeatDelay = 0.12f;
+    io.KeyRepeatRate = 0.015f;
+  }
+}
diff --git a/src/util/imgui/io.hpp b/src/util/imgui/io.hpp
new file mode 100644
index 0000000..4f9305b
--- /dev/null
+++ b/src/util/imgui/io.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+namespace game::util::imgui::io
+{
+  void keyboard_repeat_set();
+}
diff --git a/src/util/imgui/path_widget.cpp b/src/util/imgui/path_widget.cpp
new file mode 100644
index 0000000..9128a51
--- /dev/null
+++ b/src/util/imgui/path_widget.cpp
@@ -0,0 +1,159 @@
+#include "path_widget.hpp"
+
+#include <imgui.h>
+
+namespace game::util::imgui
+{
+  namespace
+  {
+    bool relative_path_is_local(const std::filesystem::path& path)
+    {
+      if (path.empty() || path.is_absolute()) return false;
+      for (auto& part : path)
+        if (part == "..") return false;
+      return true;
+    }
+
+    std::filesystem::path schema_relative_path_get(const std::filesystem::path& schemaPath,
+                                                   const std::filesystem::path& path)
+    {
+      auto base = schemaPath.parent_path();
+      std::error_code error{};
+      auto relative = std::filesystem::relative(path, base, error);
+      if (error || relative.empty()) relative = path.lexically_relative(base);
+      if (relative.empty()) relative = path;
+      return relative;
+    }
+
+    std::filesystem::path root_prefix_strip(const std::filesystem::path& rootPath, const std::filesystem::path& path)
+    {
+      if (rootPath.empty()) return path;
+
+      auto root = rootPath.lexically_normal();
+      auto value = path.lexically_normal();
+      auto rootIt = root.begin();
+      auto valueIt = value.begin();
+      while (rootIt != root.end() && valueIt != value.end() && *rootIt == *valueIt)
+      {
+        ++rootIt;
+        ++valueIt;
+      }
+      if (rootIt != root.end()) return path;
+
+      std::filesystem::path result{};
+      for (; valueIt != value.end(); ++valueIt)
+        result /= *valueIt;
+      return result.empty() ? path : result;
+    }
+
+    bool path_button_draw(const char* id, const std::string& path, const std::string& displayPath, const ImVec2& size)
+    {
+      ImGui::PushID(id);
+      auto label = std::string{id ? id : ""};
+      auto hasVisibleLabel = !label.empty() && !label.starts_with("##");
+      auto buttonSize = size;
+      if (hasVisibleLabel && buttonSize.x <= 0.0f) buttonSize.x = ImGui::CalcItemWidth();
+      auto clicked = ImGui::Button(displayPath.empty() ? "<empty>" : displayPath.c_str(), buttonSize);
+      if (!path.empty() && ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNormal)) ImGui::SetTooltip("%s", path.c_str());
+      if (hasVisibleLabel)
+      {
+        ImGui::SameLine(0.0f, ImGui::GetStyle().ItemInnerSpacing.x);
+        ImGui::TextUnformatted(label.c_str());
+      }
+      ImGui::PopID();
+      return clicked;
+    }
+  }
+
+  std::filesystem::path path_base_get(const std::filesystem::path& schemaPath, const std::string& rootPath)
+  {
+    return rootPath.empty() ? schemaPath.parent_path() : schemaPath.parent_path() / rootPath;
+  }
+
+  std::filesystem::path path_absolute_get(const std::filesystem::path& schemaPath, const std::string& rootPath,
+                                          const std::string& path)
+  {
+    auto value = std::filesystem::path(path);
+    if (value.is_absolute()) return value;
+    auto root = std::filesystem::path(rootPath);
+    auto rootIt = root.begin();
+    auto valueIt = value.begin();
+    while (rootIt != root.end() && valueIt != value.end() && *rootIt == *valueIt)
+    {
+      ++rootIt;
+      ++valueIt;
+    }
+    if (rootIt == root.end()) return schemaPath.parent_path() / value;
+    return path_base_get(schemaPath, rootPath) / value;
+  }
+
+  std::string path_display_get(const std::filesystem::path& schemaPath, const std::string& rootPath,
+                               const std::string& path)
+  {
+    auto root = std::filesystem::path(rootPath);
+    auto value = std::filesystem::path(path).lexically_normal();
+    if (!value.is_absolute()) return root_prefix_strip(root, value).generic_string();
+
+    auto base = path_base_get(schemaPath, rootPath);
+    std::error_code error{};
+    auto relative = std::filesystem::relative(value, base, error);
+    if (!error && relative_path_is_local(relative)) return relative.generic_string();
+
+    error.clear();
+    relative = std::filesystem::relative(value, schemaPath.parent_path(), error);
+    if (!error && relative_path_is_local(relative)) return root_prefix_strip(root, relative).generic_string();
+
+    return value.generic_string();
+  }
+
+  std::string path_store_get(const std::filesystem::path& schemaPath, const std::string& rootPath,
+                             const std::filesystem::path& path)
+  {
+    auto normalizedPath = path.lexically_normal();
+    auto base = path_base_get(schemaPath, rootPath);
+    std::error_code error{};
+    auto relative = std::filesystem::relative(normalizedPath, base, error);
+    if (error || relative.empty()) relative = normalizedPath.lexically_relative(base);
+    if (relative.empty() || relative.is_absolute())
+    {
+      auto schemaRelative = schema_relative_path_get(schemaPath, normalizedPath);
+      auto root = std::filesystem::path(rootPath);
+      auto rootIt = root.begin();
+      auto schemaIt = schemaRelative.begin();
+      while (rootIt != root.end() && schemaIt != schemaRelative.end() && *rootIt == *schemaIt)
+      {
+        ++rootIt;
+        ++schemaIt;
+      }
+
+      if (rootIt == root.end())
+      {
+        relative.clear();
+        for (; schemaIt != schemaRelative.end(); ++schemaIt) relative /= *schemaIt;
+      }
+      else
+        relative = schemaRelative;
+    }
+    return relative.generic_string();
+  }
+
+  bool path_widget(const char* id, const std::string& path, const ImVec2& size)
+  {
+    return path_widget(id, path, path, size);
+  }
+
+  bool path_widget(const char* id, const std::string& path, const std::string& displayPath, const ImVec2& size)
+  {
+    return path_button_draw(id, path, displayPath, size);
+  }
+
+  bool folder_widget(const char* id, const std::string& path, const ImVec2& size)
+  {
+    return folder_widget(id, path, path, size);
+  }
+
+  bool folder_widget(const char* id, const std::string& path, const std::string& displayPath, const ImVec2& size)
+  {
+    return path_button_draw(id, path, displayPath, size);
+  }
+}
diff --git a/src/util/imgui/path_widget.hpp b/src/util/imgui/path_widget.hpp
new file mode 100644
index 0000000..29f3a54
--- /dev/null
+++ b/src/util/imgui/path_widget.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <filesystem>
+#include <string>
+
+#include <imgui.h>
+
+namespace game::util::imgui
+{
+  std::filesystem::path path_base_get(const std::filesystem::path& schemaPath, const std::string& rootPath);
+  std::filesystem::path path_absolute_get(const std::filesystem::path& schemaPath, const std::string& rootPath,
+                                          const std::string& path);
+  std::string path_display_get(const std::filesystem::path& schemaPath, const std::string& rootPath,
+                               const std::string& path);
+  std::string path_store_get(const std::filesystem::path& schemaPath, const std::string& rootPath,
+                             const std::filesystem::path& path);
+
+  bool path_widget(const char* id, const std::string& path, const ImVec2& size = ImVec2(-FLT_MIN, 0.0f));
+  bool path_widget(const char* id, const std::string& path, const std::string& displayPath, const ImVec2& size);
+  bool folder_widget(const char* id, const std::string& path, const ImVec2& size = ImVec2(-FLT_MIN, 0.0f));
+  bool folder_widget(const char* id, const std::string& path, const std::string& displayPath, const ImVec2& size);
+}
diff --git a/src/util/imgui/selectable_renamable.cpp b/src/util/imgui/selectable_renamable.cpp
new file mode 100644
index 0000000..af8e55d
--- /dev/null
+++ b/src/util/imgui/selectable_renamable.cpp
@@ -0,0 +1,51 @@
+#include "selectable_renamable.hpp"
+
+#include "input_string.hpp"
+
+namespace game::util::imgui
+{
+  SelectableRenamableResult selectable_renamable(const char* id, std::string& value, const char* fallback,
+                                                 bool selected, ImGuiSelectableFlags flags)
+  {
+    ImGui::PushID(id);
+
+    auto* storage = ImGui::GetStateStorage();
+    auto editingID = ImGui::GetID("selectable-renamable-editing");
+    auto focusID = ImGui::GetID("selectable-renamable-focus");
+    auto isEditing = storage->GetBool(editingID, false);
+
+    SelectableRenamableResult result{.editing = isEditing};
+    if (isEditing)
+    {
+      ImGui::SetNextItemWidth(-FLT_MIN);
+      if (storage->GetBool(focusID, false))
+      {
+        ImGui::SetKeyboardFocusHere();
+        storage->SetBool(focusID, false);
+      }
+
+      result.renamed = input_string("##rename", value, ImGuiInputTextFlags_EnterReturnsTrue);
+      result.editing = true;
+      if (ImGui::IsItemDeactivated())
+      {
+        storage->SetBool(editingID, false);
+        result.editing = false;
+      }
+    }
+    else
+    {
+      auto label = value.empty() ? std::string{fallback ? fallback : ""} : value;
+      result.selected = ImGui::Selectable(label.c_str(), selected, flags);
+      if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
+      {
+        storage->SetBool(editingID, true);
+        storage->SetBool(focusID, true);
+        result.selected = true;
+        result.editing = true;
+      }
+    }
+
+    ImGui::PopID();
+    return result;
+  }
+}
diff --git a/src/util/imgui/selectable_renamable.hpp b/src/util/imgui/selectable_renamable.hpp
new file mode 100644
index 0000000..4e3dbad
--- /dev/null
+++ b/src/util/imgui/selectable_renamable.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <string>
+
+#include <imgui.h>
+
+namespace game::util::imgui
+{
+  struct SelectableRenamableResult
+  {
+    bool selected{};
+    bool renamed{};
+    bool editing{};
+  };
+
+  SelectableRenamableResult selectable_renamable(const char* id, std::string& value, const char* fallback,
+                                                 bool selected, ImGuiSelectableFlags flags = 0);
+}
diff --git a/src/util/imgui/sound_widget.cpp b/src/util/imgui/sound_widget.cpp
new file mode 100644
index 0000000..df466c5
--- /dev/null
+++ b/src/util/imgui/sound_widget.cpp
@@ -0,0 +1,16 @@
+#include "sound_widget.hpp"
+
+#include <imgui.h>
+
+namespace game::util::imgui
+{
+  bool sound_widget(const char* id, bool isMissing)
+  {
+    ImGui::PushID(id);
+    ImGui::BeginDisabled(isMissing);
+    auto clicked = ImGui::SmallButton(isMissing ? "X" : "Play");
+    ImGui::EndDisabled();
+    ImGui::PopID();
+    return clicked;
+  }
+}
diff --git a/src/util/imgui/sound_widget.hpp b/src/util/imgui/sound_widget.hpp
new file mode 100644
index 0000000..30e21a2
--- /dev/null
+++ b/src/util/imgui/sound_widget.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+namespace game::util::imgui
+{
+  bool sound_widget(const char* id, bool isMissing = false);
+}
diff --git a/src/util/imgui/texture_widget.cpp b/src/util/imgui/texture_widget.cpp
new file mode 100644
index 0000000..7b09827
--- /dev/null
+++ b/src/util/imgui/texture_widget.cpp
@@ -0,0 +1,33 @@
+#include "texture_widget.hpp"
+
+#include <algorithm>
+
+namespace game::util::imgui
+{
+  bool texture_widget(const char* id, const resource::Texture* texture, bool isMissing, const ImVec2& maxSize)
+  {
+    ImGui::PushID(id);
+    auto size = maxSize;
+    auto isValid = texture && texture->is_valid() && texture->size.x > 0 && texture->size.y > 0;
+    if (isValid)
+    {
+      auto scale = std::min(maxSize.x / (float)texture->size.x, maxSize.y / (float)texture->size.y);
+      size = ImVec2(texture->size.x * scale, texture->size.y * scale);
+      ImGui::Image(texture->id, size);
+    }
+    else
+    {
+      ImGui::Button(isMissing ? "X" : "X", size);
+    }
+
+    auto clicked = ImGui::IsItemClicked();
+    if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNormal) && isValid)
+    {
+      ImGui::BeginTooltip();
+      ImGui::Image(texture->id, ImVec2((float)texture->size.x, (float)texture->size.y));
+      ImGui::EndTooltip();
+    }
+    ImGui::PopID();
+    return clicked;
+  }
+}
diff --git a/src/util/imgui/texture_widget.hpp b/src/util/imgui/texture_widget.hpp
new file mode 100644
index 0000000..8aeebab
--- /dev/null
+++ b/src/util/imgui/texture_widget.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <imgui.h>
+
+#include "../../resource/texture.hpp"
+
+namespace game::util::imgui
+{
+  bool texture_widget(const char* id, const resource::Texture* texture, bool isMissing = false,
+                      const ImVec2& maxSize = ImVec2(48.0f, 48.0f));
+}
diff --git a/src/util/imgui/widget.cpp b/src/util/imgui/widget.cpp
index a276d64..6ddf85f 100644
--- a/src/util/imgui/widget.cpp
+++ b/src/util/imgui/widget.cpp
@@ -1,8 +1,10 @@
 #include "widget.hpp"
 
+#include "../../resource/schema.hpp"
+
 #include <cmath>
 
-using game::resource::xml::SoundEntryCollection;
+using SoundEntryCollection = game::resource::xml::Schema::SoundEntryCollection;
 
 namespace game::util::imgui::widget
 {
diff --git a/src/util/imgui/widget.hpp b/src/util/imgui/widget.hpp
index 8359ee4..a49d8b9 100644
--- a/src/util/imgui/widget.hpp
+++ b/src/util/imgui/widget.hpp
@@ -1,11 +1,12 @@
 #pragma once
 
-#include "../../resource/xml/sound_entry.hpp"
+#include "../../resource/schema.hpp"
 #include <imgui.h>
 
 namespace game::util::imgui::widget
 {
-  void sounds_set(resource::xml::SoundEntryCollection* _hover, resource::xml::SoundEntryCollection* _select);
+  void sounds_set(resource::xml::Schema::SoundEntryCollection* _hover,
+                  resource::xml::Schema::SoundEntryCollection* _select);
   void fx();
 }
 
diff --git a/src/util/physfs.cpp b/src/util/physfs.cpp
index 23456ee..08295d5 100644
--- a/src/util/physfs.cpp
+++ b/src/util/physfs.cpp
@@ -2,6 +2,10 @@
 
 #include <physfs.h>
 
+#include <algorithm>
+#include <cstdint>
+#include <filesystem>
+#include <fstream>
 #include <string_view>
 #include <vector>
 
@@ -11,6 +15,117 @@
 
 namespace game::util::physfs
 {
+  namespace physfs_detail
+  {
+    constexpr auto BYTE_BITS = 8;
+    constexpr auto UINT16_BYTE_COUNT = 2;
+    constexpr auto UINT32_BYTE_COUNT = 4;
+    constexpr auto ZIP_VERSION = 20;
+    constexpr auto ZIP_COMPRESSION_STORE = 0;
+    constexpr auto ZIP_FLAG_NONE = 0;
+    constexpr auto ZIP_TIME_NONE = 0;
+    constexpr auto ZIP_DATE_NONE = 0;
+    constexpr auto ZIP_DISK_NONE = 0;
+    constexpr auto ZIP_ATTRIBUTE_NONE = 0;
+    constexpr auto ZIP_COMMENT_LENGTH_NONE = 0;
+    constexpr auto ZIP_EXTRA_LENGTH_NONE = 0;
+    constexpr auto ZIP_LOCAL_HEADER_SIGNATURE = 0x04034b50u;
+    constexpr auto ZIP_CENTRAL_HEADER_SIGNATURE = 0x02014b50u;
+    constexpr auto ZIP_END_SIGNATURE = 0x06054b50u;
+    constexpr auto BYTE_MASK = 0xff;
+    constexpr auto CRC_INITIAL = 0xffffffffu;
+    constexpr auto CRC_POLYNOMIAL = 0xedb88320u;
+    constexpr auto CRC_XOR = 0xffffffffu;
+    constexpr auto MOUNT_EXPORT = "__developer_export__";
+
+    struct ZipEntry
+    {
+      std::string path{};
+      std::vector<uint8_t> data{};
+      uint32_t crc{};
+      uint32_t offset{};
+    };
+
+    uint32_t crc32_get(const std::vector<uint8_t>& data)
+    {
+      auto crc = CRC_INITIAL;
+      for (auto value : data)
+      {
+        crc ^= value;
+        for (auto bit = 0; bit < BYTE_BITS; ++bit)
+        {
+          auto mask = (uint32_t)(-(int)(crc & 1));
+          crc = (crc >> 1) ^ (CRC_POLYNOMIAL & mask);
+        }
+      }
+      return crc ^ CRC_XOR;
+    }
+
+    void uint16_write(std::ostream& stream, uint16_t value)
+    {
+      for (auto i = 0; i < UINT16_BYTE_COUNT; ++i)
+        stream.put((char)((value >> (i * BYTE_BITS)) & BYTE_MASK));
+    }
+
+    void uint32_write(std::ostream& stream, uint32_t value)
+    {
+      for (auto i = 0; i < UINT32_BYTE_COUNT; ++i)
+        stream.put((char)((value >> (i * BYTE_BITS)) & BYTE_MASK));
+    }
+
+    void local_header_write(std::ostream& stream, const ZipEntry& entry)
+    {
+      uint32_write(stream, ZIP_LOCAL_HEADER_SIGNATURE);
+      uint16_write(stream, ZIP_VERSION);
+      uint16_write(stream, ZIP_FLAG_NONE);
+      uint16_write(stream, ZIP_COMPRESSION_STORE);
+      uint16_write(stream, ZIP_TIME_NONE);
+      uint16_write(stream, ZIP_DATE_NONE);
+      uint32_write(stream, entry.crc);
+      uint32_write(stream, (uint32_t)entry.data.size());
+      uint32_write(stream, (uint32_t)entry.data.size());
+      uint16_write(stream, (uint16_t)entry.path.size());
+      uint16_write(stream, ZIP_EXTRA_LENGTH_NONE);
+      stream.write(entry.path.data(), (std::streamsize)entry.path.size());
+    }
+
+    void central_header_write(std::ostream& stream, const ZipEntry& entry)
+    {
+      uint32_write(stream, ZIP_CENTRAL_HEADER_SIGNATURE);
+      uint16_write(stream, ZIP_VERSION);
+      uint16_write(stream, ZIP_VERSION);
+      uint16_write(stream, ZIP_FLAG_NONE);
+      uint16_write(stream, ZIP_COMPRESSION_STORE);
+      uint16_write(stream, ZIP_TIME_NONE);
+      uint16_write(stream, ZIP_DATE_NONE);
+      uint32_write(stream, entry.crc);
+      uint32_write(stream, (uint32_t)entry.data.size());
+      uint32_write(stream, (uint32_t)entry.data.size());
+      uint16_write(stream, (uint16_t)entry.path.size());
+      uint16_write(stream, ZIP_EXTRA_LENGTH_NONE);
+      uint16_write(stream, ZIP_COMMENT_LENGTH_NONE);
+      uint16_write(stream, ZIP_DISK_NONE);
+      uint16_write(stream, ZIP_ATTRIBUTE_NONE);
+      uint32_write(stream, ZIP_ATTRIBUTE_NONE);
+      uint32_write(stream, entry.offset);
+      stream.write(entry.path.data(), (std::streamsize)entry.path.size());
+    }
+
+    void end_header_write(std::ostream& stream, uint16_t entries, uint32_t directorySize, uint32_t directoryOffset)
+    {
+      uint32_write(stream, ZIP_END_SIGNATURE);
+      uint16_write(stream, ZIP_DISK_NONE);
+      uint16_write(stream, ZIP_DISK_NONE);
+      uint16_write(stream, entries);
+      uint16_write(stream, entries);
+      uint32_write(stream, directorySize);
+      uint32_write(stream, directoryOffset);
+      uint16_write(stream, ZIP_COMMENT_LENGTH_NONE);
+    }
+  }
+
+  using namespace physfs_detail;
+
   std::string path_normalize(std::string_view path)
   {
     const bool absolute = !path.empty() && path.front() == '/';
@@ -131,4 +246,54 @@ namespace game::util::physfs
     auto pathNormalized = path_normalize(*this);
     return PHYSFS_exists(pathNormalized.c_str());
   }
+
+  bool archive_write(const std::filesystem::path& source, const std::filesystem::path& destination)
+  {
+    std::error_code error{};
+    if (!std::filesystem::is_directory(source, error)) return false;
+
+    auto output = destination;
+    if (output.extension().empty()) output += ".zip";
+    if (!output.parent_path().empty()) std::filesystem::create_directories(output.parent_path(), error);
+
+    Archive archive(source, MOUNT_EXPORT);
+    if (!archive.is_valid()) return false;
+
+    std::vector<std::filesystem::path> paths{};
+    for (auto& entry : std::filesystem::recursive_directory_iterator(source, error))
+      if (!error && entry.is_regular_file(error)) paths.emplace_back(entry.path());
+    std::ranges::sort(paths);
+
+    std::vector<ZipEntry> entries{};
+    entries.reserve(paths.size());
+    for (auto& path : paths)
+    {
+      auto relative = std::filesystem::relative(path, source, error).generic_string();
+      if (relative.empty() || error) continue;
+      auto physfsPath = Path(std::string(archive) + "/" + relative);
+      auto data = physfsPath.read();
+      auto size = std::filesystem::file_size(path, error);
+      if (!error && size > 0 && data.empty()) return false;
+      entries.push_back({.path = relative, .data = std::move(data)});
+      entries.back().crc = crc32_get(entries.back().data);
+    }
+
+    std::ofstream stream(output, std::ios::binary | std::ios::trunc);
+    if (!stream.is_open()) return false;
+
+    for (auto& entry : entries)
+    {
+      entry.offset = (uint32_t)stream.tellp();
+      local_header_write(stream, entry);
+      if (!entry.data.empty()) stream.write((const char*)entry.data.data(), (std::streamsize)entry.data.size());
+    }
+
+    auto directoryOffset = (uint32_t)stream.tellp();
+    for (auto& entry : entries)
+      central_header_write(stream, entry);
+    auto directorySize = (uint32_t)stream.tellp() - directoryOffset;
+    end_header_write(stream, (uint16_t)entries.size(), directorySize, directoryOffset);
+
+    return stream.good();
+  }
 }
diff --git a/src/util/physfs.hpp b/src/util/physfs.hpp
index 005d5ca..fee5325 100644
--- a/src/util/physfs.hpp
+++ b/src/util/physfs.hpp
@@ -26,4 +26,5 @@ namespace game::util::physfs
   };
 
   std::string error_get();
+  bool archive_write(const std::filesystem::path& source, const std::filesystem::path& destination);
 }
diff --git a/src/util/time.cpp b/src/util/time.cpp
index baa646e..a4a497c 100644
--- a/src/util/time.cpp
+++ b/src/util/time.cpp
@@ -1,10 +1,14 @@
 #include "time.hpp"
 
 #include <chrono>
+#include <format>
 #include <iomanip>
+#include <sstream>
 
 namespace game::util::time
 {
+  constexpr auto ROUNDING_DIVISOR = 2;
+
   std::string get(const char* format)
   {
     auto now = std::chrono::system_clock::now();
@@ -19,4 +23,23 @@ namespace game::util::time
     timeString << std::put_time(&localTime, format);
     return timeString.str();
   }
+
+  std::string ticks_to_minutes_seconds(int ticks, int ticksPerSecond)
+  {
+    auto seconds = ticksPerSecond <= 0 ? 0 : ticks / ticksPerSecond;
+    auto minutes = seconds / SECOND_M;
+    seconds %= SECOND_M;
+    return std::format("{}:{:02}", minutes, seconds);
+  }
+
+  std::string ticks_to_minutes_seconds_centiseconds(int ticks, int ticksPerSecond)
+  {
+    ticks = ticks < 0 ? 0 : ticks;
+    if (ticksPerSecond <= 0) return "0'00\"00";
+    auto totalCentiseconds = ((ticks * CENTISECONDS_PER_SECOND) + (ticksPerSecond / ROUNDING_DIVISOR)) / ticksPerSecond;
+    auto minutes = totalCentiseconds / (SECOND_M * CENTISECONDS_PER_SECOND);
+    auto seconds = (totalCentiseconds / CENTISECONDS_PER_SECOND) % SECOND_M;
+    auto centiseconds = totalCentiseconds % CENTISECONDS_PER_SECOND;
+    return std::format("{}'{:02}\"{:02}", minutes, seconds, centiseconds);
+  }
 }
diff --git a/src/util/time.hpp b/src/util/time.hpp
index e74e722..4a2172d 100644
--- a/src/util/time.hpp
+++ b/src/util/time.hpp
@@ -5,6 +5,9 @@
 namespace game::util::time
 {
   constexpr auto SECOND_M = 60;
+  constexpr auto CENTISECONDS_PER_SECOND = 100;
 
   std::string get(const char*);
+  std::string ticks_to_minutes_seconds(int ticks, int ticksPerSecond = SECOND_M);
+  std::string ticks_to_minutes_seconds_centiseconds(int ticks, int ticksPerSecond = SECOND_M);
 }