Unity

Unity is a general engine, so a game’s files look alike and its content differs. A player is a set of serialized files (scenes, shared assets, global settings) holding objects of Unity’s built-in classes, plus streamed bulk data and the game’s code; some builds also pack data into UnityFS bundles. The games here span two eras of the engine: SkateBIRD (2019.4.20f1, Mono, built-in pipeline, container version 21) and Sledding Game (6000.3.12f1), PEAK (6000.3.15f1) and Big Walk (6000.3.17f1), which use container version 22 and the Universal Render Pipeline. Proven · every serialized file of each install

What the games share and where they differ

Area	SkateBIRD	Sledding Game	PEAK	Big Walk	Confidence
Unity version	2019.4.20f1	6000.3.12f1	6000.3.15f1	6000.3.17f1	Proven
Container version	21	22	22	22	Proven
Scripting	Mono	IL2CPP	Mono	IL2CPP	Observed
Data layout	loose files	loose files, Addressables for localization	loose files, 208 level scenes in AssetBundles	one data.unity3d bundle	Observed
Type trees in files	stripped	stripped (kept in bundles)	stripped (kept in bundles)	stripped	Observed
Render pipeline	built-in	URP	URP assemblies present	URP	Observed · SkateBIRD, Sledding, PEAK Inferred · Big Walk
Colour space	linear	not read	not read	not read	Proven · SkateBIRD
Networking	none	FishNet	Photon	Mirror	Observed
Physics gravity (m/s²)	−9.81	−9.81	−19.62	not read	Proven · SkateBIRD, Sledding, PEAK
Terrain	none	nine terrains, 12,321 trees (build 25351629)	not read	four terrains	Proven · Sledding Inferred · Big Walk

Each row is described on the page it belongs to: serialized files, bundles and the data folder for the containers; type trees for the layouts a player strips; scripting backends and networking for the code. The frame Unity uses (left-handed, +Y up, +Z forward, metres) is on scenes. Proven

How the pieces fit

A scene (levelN) holds GameObjects, Transforms and components; renderers, colliders and lights name meshes, materials and textures in the sharedassets files. A mesh’s vertices and a texture’s pixels are often not in the object but in a stream file beside it. Materials name a shader and store property values; the shader holds its render state and compiled Direct3D 11 programs, from which draw keywords select a variant. Observed

• Geometry: meshes, skinning and blend shapes.
• Appearance: textures, materials, built-in and URP shaders, shader objects, draw keywords.
• Light: ambient light and probes, lights.
• World: layers, cameras and culling masks, terrain, colliders and physics.
• Animation: clips, controllers, humanoid muscles.
• Games’ own rules: SkateBIRD, Sledding Game, Big Walk.

Traps that cut across games

• A reader accepts the container versions it was checked against and refuses others; versions 21 and 22 differ in header and object table widths. Proven
• Layouts depend on the Unity version: field names change (dynamicFriction against m_DynamicFriction), the shader program storage changes at 2021.2, and a layout package can lack the exact patch version of a build. Observed
• A player strips type trees; a script’s fields have no description at all and must be measured or recovered from code. Observed
• State is data: an inactive GameObject or a disabled component is stored, not omitted, and what a camera draws depends on culling masks. Observed
• Linear and sRGB are per texture and per property; colour properties are stored gamma-encoded. Observed

Pages

Archives and files

• SerializedFile containers — The container behind globalgamemanagers, levelN and *.assets files: header versions 17, 21 and 22, the type table, the object table, script references, external files and managed references.
• The player data folder — How a Unity Windows player lays out its data: globalgamemanagers, scenes, shared assets, streamed resources, scripts and runtime, per game.
• UnityFS bundles — The UnityFS archive format (header, compressed block table, directory), and which games use it for AssetBundles, Addressables or the whole player.

Data model

• Scenes and the object hierarchy — What a scene file holds: GameObjects, Transforms, components, static batching, LOD groups, inactive state, UI transforms, and the frame Unity uses.
• Script fields of MonoBehaviours — How a game's own script data is stored after a MonoBehaviour's base fields, the layouts measured for SkateBIRD's scripts and for the Universal Render Pipeline asset.
• Type trees — How a Unity object's bytes are laid out: the type tree that describes each class, the rules for decoding by it, the packages that supply stripped trees, and version-dependent field names.

World and streaming

• Layers, cameras and culling masks — How Unity decides what a camera draws: the layer of each GameObject, a camera's culling mask and render target, the layer names each game defines, and SkateBIRD's minimap markers.

Geometry

• Meshes — How a Unity Mesh object stores vertices, indices and submeshes: channels in interleaved streams, compressed meshes, topologies, streamed vertex data.
• Skinning and blend shapes — How a Unity mesh stores bone influences (four-influence channels and variable bone counts), bind poses, quality-dependent skin weights, and blend shapes.

Materials

• Built-in and URP shaders — What the shaders the Unity games use compute from a material's properties: URP Lit, Standard, Autodesk Interactive, the legacy surface shaders, unlit shaders, and SkateBIRD's Voronoi shader.
• Materials — The Material object: shader reference, saved properties (textures with tiling, floats, colours), keywords, tags and render queue, and how the draw pass is chosen.

Shaders

• Draw keywords — Which shader keywords a draw has under the built-in pipeline and under URP, as a function of the scene's lights, shadows, fog and the pipeline asset, measured with an editor probe.
• Shader objects and compiled programs — How a player stores a shader: the parsed form with its passes and render state, the per-platform compressed program blob, variants and keywords, constant buffers, and the 2021.2 parameter blobs.

Textures

• Texture2D — How Unity stores a texture: format ids, the mip chain, row order, colour space, normal map usage modes, wrap and filter, streaming, and the engine's default textures.

Lighting and sky

• Ambient light, probes and fog — A scene's RenderSettings: ambient modes (skybox, trilight, flat), the stored spherical-harmonics probe, fog, and the values every scene of SkateBIRD, Sledding Game and PEAK stores.
• Lights — The Light object, how URP and the built-in pipeline interpret colour, intensity, range and cones, which light is the sun, and the lights the games' scenes store.

Terrain

• Terrain — The Terrain component and its TerrainData: heightmap quantisation, holes, splat layers and alphamaps, tree prototypes and instances, and Sledding Game's terrains.

Effects and decals

• Post-processing — The post-processing stack SkateBIRD uses and the gameplay profile it applies: depth of field on the bird, lens distortion, chromatic aberration and vignette.

Collision and physics

• Colliders and physics materials — Collider components and their shapes under PhysX, physic materials with their friction and combine modes per game, and the project physics settings each game stores.

Animation

• Animation clips — How an AnimationClip stores its curves: the streamed, dense and constant blocks, the bindings that name what each curve drives, and the cubic form of a streamed key.
• Avatars, Animators and controllers — The Mecanim objects: Avatar skeletons, the compiled AnimatorController (layers, state machines, transitions, blend trees), how blend tree weights and state time are computed, and SkateBIRD's bird controller.
• Humanoid muscles — How Mecanim turns a humanoid clip's muscle curves into bone rotations: degrees of freedom, the swing-twist rotation, limb twist sharing, the body's centre of mass and frame, as fitted to the editor.

Gameplay data

• Big Walk's world, puzzle and prop systems — Big Walk's scenes and culling system, the player and prop model, and its networked puzzle logic (pecks), as recovered from the IL2CPP metadata and an earlier reconnaissance of the build.
• SkateBIRD scene scripts — SkateBIRD's own gameplay objects: reset points and the level start, mission givers and the mission roots, collectibles, rails and ramp zones, the player's board, and the level spawn data.
• Sledding Game scene scripts and traps — Sledding Game's own classes and the places where its Unity 6000.3 scene data is not what the serialized objects say: runtime-built chairlift cables, text mesh signs, procedural decals, opaque trees.

Runtime and limits

• Networking stacks — The networking libraries the multiplayer Unity games are built on: Mirror with KCP and Epic Online Services in Big Walk, FishNet in Sledding Game, Photon in PEAK, and what a mod has to match.
• Scripting backends: Mono and IL2CPP — How the games' code ships (Mono assemblies or IL2CPP native code with a metadata file), how to recover class and field layouts from each, and the traps in the IL2CPP dumps.

Mod loading

• Loading code into Unity games (BepInEx and Doorstop) — How plugins are loaded into the Mono and IL2CPP Unity games: Unity Doorstop and BepInEx 5 or 6, what each game's data allows, and the loader files each install shows.