cinn4bread/coolmathgamejam

1. Project type and runtime

- This is a Unity 2D puzzle/physics game built with Universal Render Pipeline and packaged for at least Web/Desktop builds.

- The repo is mostly content-driven: scenes, prefabs, ScriptableObject assets, and runtime scripts under Assets/Resources.

2. High-level game structure

- The game loop is level-based: a main menu leads into a set of playable scenes (Level1–Level12, plus EvilLevel variants and supporting test/template scenes).

- Each level is a self-contained puzzle where the player builds a contraption to dispense the correct coin value and earn stars.

3. Persistent runtime layer

- A PersistentManagers prefab and Bootstrapper/DontDestroyOnLoad scripts indicate a global service layer that survives scene changes.

- This layer likely owns cross-scene systems such as audio, game state, input routing, and UI/event coordination.

4. Level and progression management

- LevelManager, Level, GameStateManager, and TargetValueManagerScript form the core progression/state boundary.

- These systems appear to manage level loading, win/lose state, target amounts, scoring/star outcomes, and transitions between menu and gameplay scenes.

5. Contraption-building system

- The game’s main mechanic is built around placeable components: rails, corners, fans, springs, seesaws, boxes, and breakable/falling variants.

- ComponentDefinition, ComponentInstance, and ComponentPlacer suggest a data-driven placement pipeline where definitions map to prefabs and instances are placed into the level grid.

6. Grid and build-space control

- GridManager and related placement scripts define the spatial rules for where the player can build.

- Supporting scripts such as CloseWalls, Windowboxer, and AutoScroll imply the playfield and camera/UI may be constrained or animated around this build space.

7. Coin and currency simulation

- Coins are a major gameplay subsystem: CoinScriptableObject defines coin data, while prefab variants exist for penny/nickel/dime/quarter/dollar.

- CoinScript, HopperScript, and DepoScript handle the physical coin flow and banking/deposit behavior that drives the educational “make exact change” mechanic.

8. Physics interaction layer

- The contraption uses Unity physics plus specialized behavior scripts such as FanPush, SpringStretch, SeesawScript, CollisionBreak, and StartLever.

- These scripts turn static placed parts into interactive mechanisms that redirect, launch, or transform coins as they move through the level.

9. UI and player-facing flow

- UI is assembled from CanvasParent, DialogueManager, HUDManagerScript, LevelSelectButton, InventoryButton, TransitionPanel, and animation helpers like MoveUpperRightPanel.

- This layer covers level select, HUD feedback, dialogue/tutorial prompts, inventory-like component selection, and scene transition animations.

10. Dialogue and scripted presentation

- Dialogue is treated as a distinct subsystem: DialogueManager, Dial, timeline assets, and signal assets (startDialogue, openDialogueBox) coordinate narrative/tutorial sequences.

- The open/close dialogue box timelines under Resources/Animations/UI indicate dialogue is presented through animated UI state changes rather than purely static panels.

11. Input and event routing

- The project uses the Unity Input System (InputSystem_Actions.inputactions) with an InputEventManager as the likely central bridge from raw player input to gameplay/UI actions.

- GameEventManager and signal assets suggest a lightweight event-bus pattern used to decouple gameplay actions, UI prompts, and state changes.

12. Audio subsystem

- AudioManager is a persistent service with MusicScript and a large set of music/SFX assets under Resources/Audio.

- The audio design is split between background music tracks and many short interaction cues tied to buttons, coins, mechanical parts, and state changes.

13. Content organization and loading model

- Most runtime assets live under Assets/Resources, which means they are intended to be loaded by name at runtime rather than only referenced directly in scenes.

- This includes prefabs for managers, UI, coins, contraption parts, and ScriptableObject definitions, making the project strongly data-driven.

14. External libraries and tooling

- The repo includes DOTween for UI/scene animation and TextMesh Pro for text rendering.

- URP and the included render/volume settings shape the visual pipeline, but the architectural focus remains on gameplay systems, scene content, and persistent managers.

15. Architecture boundary summary

- The clearest boundary is between persistent services (audio, input, state, events) and scene-local content (levels, placeable contraptions, UI panels, dialogue sequences).

- Runtime flow is: player input and UI selection → placement/state systems → physics-driven coin movement → deposit/target evaluation → HUD/audio/transition feedback.