FREE Theoretical : How to create new map squares in FusionFall?

Question: What are BuildPlayer files? FusionFall uses CustomAssetBundles containing assets (models, materials, etc.), but for map squares, it has BuildPlayer files that contain lists of pointers and references that seem to control the terrain and the locations of assets within the map square. FusionFall was made in a custom version of the Unity editor (2.5.5bf) that's very similar to Unity 2.6 and 2.5 from 2010, so can you tell me what these BuildPlayer asset bundles could be?

Answer: Great question—this dives deep into the way FusionFall, and similar early Unity-engine games, handled world data using BuildPlayer files.

🏗 How BuildPlayer serialized scenes in Unity 2.5/2.6​

• Scenes were fully flattened into binary blobs.
• Every GameObject, Component, Terrain, Lightmap, and reference was baked into these files.
• The files included:
  • Serialized Unity scene hierarchy.
  • Static and dynamic objects data.
  • Prefab references were embedded directly or pointed to via internal identifiers.
  • Lightmaps, navigation data (rudimentary), skyboxes, and environmental data.

🛠 Unity Web Player files (*.unity3d)​

• For the Web Player platform, Unity 2.5/2.6 used .unity3d files.
• These files contained the scenes and assets in a compact, proprietary archive, loaded at runtime by the Unity Web Player plugin.
• This file type and format is considered the precursor to Asset Bundles, but was mostly scene-focused, not modular asset packaging.

How this ties into FusionFall's BuildPlayer files​

• FusionFall likely hijacked this BuildPlayer pipeline to create scene-like chunks (map squares) as their own proprietary binary files.
• Instead of having massive monolithic scenes, they broke the world into square regions, each exported as its own BuildPlayer-style file, serialized with custom additions (ID lists, asset references).
• This allowed efficient streaming of world chunks without overloading the Web Player.
• Assets (models, props) were put in separate CustomAssetBundles, while BuildPlayer files only contained the layout + references.

Key Insight:​

In FusionFall, what you describe as:

• CustomAssetBundle (DongResources_00_09.resourceFile) → Contains models, materials, textures, and maybe terrain.
• Map_00_09.unity3d → Contains:
  • BuildPlayer-Map_00_09 → Scene/Map Square data (Transform, placement, terrain references)
  • BuildPlayer-Map_00_09.sharedAssets → Likely shared resource references, such as Materials or custom data used by the BuildPlayer file

How would you generate FusionFall-style BuildPlayer files in Unity 2.6's pipeline?​

⚙ Important understanding:​

Unity's BuildPipeline.BuildAssetBundle only builds asset bundles.
To generate BuildPlayer-style files, you need to instead build a scene using BuildPipeline.BuildPlayer or serialize the scene manually.

Path 1: Use the BuildPlayer pipeline directly (Old Unity 2.6-style)​

How to do it:​

1. Create a Unity Scene (*.unity) for each map square.
2. Manually place your terrain, static objects, etc. (they can reference models inside a CustomAssetBundle).
3. Use BuildPipeline.BuildPlayer to build the scene as a .unity3d file for the Web Player.
4. Unity will internally create:
   • A file containing the scene data (BuildPlayer-Map_00_09 equivalent).
   • A sharedAssets file containing scene-referenced assets that aren't inside an AssetBundle.

Example code:

using UnityEditor;
using UnityEngine;

public class ExportBuildPlayer
{
[MenuItem("Assets/Build BuildPlayer Scene")]
static void ExportScene()
{
string path = EditorUtility.SaveFilePanel("Save BuildPlayer Scene", Application.dataPath, "Map_00_09", "unity3d");

if (path.Length != 0)
{
// Build the selected scene as a WebPlayer scene (outputs .unity3d with BuildPlayer- and sharedAssets inside)
string[] scenes = { "Assets/Scenes/Map_00_09.unity" };
BuildPipeline.BuildPlayer(scenes, path, BuildTarget.WebPlayer, BuildOptions.BuildAdditionalStreamedScenes);

Debug.Log("BuildPlayer scene built successfully: " + path);
}
}
}

Click to expand...

Notes:​

• This will create a .unity3d file containing both BuildPlayer and sharedAssets automatically.
• You must ensure your scene references only externalized assets inside your CustomAssetBundles, or they'll get embedded into the sharedAssets file.

Path 2: Custom serialization (FusionFall-like)​

If you want to manually make BuildPlayer files without using Unity's official pipeline, you'd need to:

• Reverse engineer FusionFall's format fully.
• Write a custom exporter in the Unity Editor that exports all placed objects, transforms, terrain into a custom binary format (matching FusionFall's BuildPlayer file structure).
• This is much more complex and would require:
  • Parsing Unity scenes in the Editor.
  • Writing a binary serializer that matches the format FusionFall expects.

Best approach for you (recommended):​

Since FusionFall's files are from Unity 2.5.5 and closely tied to the Web Player scene pipeline, the easiest approach is:

1. Create a scene for each map square (Map_00_09.unity).
2. Use BuildPipeline.BuildPlayer targeting Web Player (early Unity 2.5/2.6 format uses .unity3d internally).
3. This will give you:
   • BuildPlayer-Map_00_09
   • BuildPlayer-Map_00_09.sharedAssets
4. Ensure your models, textures, etc. are in your custom AssetBundle, and only referenced inside the scene by ID or reference.

This will most closely replicate FusionFall's production workflow, assuming your Unity build is patched to behave like the FusionFall editor or you're using Unity 2.6 to match the file versions.

What are BuildPlayer Files in FusionFall?​

From your description and known FusionFall modding research:

• BuildPlayer files in FusionFall are not typical Unity AssetBundle files.
• They are more akin to serialized Unity scenes, compiled using Unity's internal build pipeline at the time (BuildPlayer refers to the API Unity used for making standalone player builds).
• In early versions of Unity (pre-3.x), this process created binary files containing scenes, objects, asset references, terrain data, and lightmaps, structured for the Unity player to consume at runtime.
  
  

  Key characteristics of BuildPlayer files in FusionFall​

  1. Scene-like files:
     • They include serialized GameObjects, Transforms, Terrain data, and asset references (by GUID, internal path, or ID).
     • Often contain hardcoded lists of asset IDs and positions.
     • Essentially an early Unity equivalent of scene streaming chunks.
  2. Low-level Player Data:
     • Created by Unity's BuildPlayer pipeline using internal serialization formats.
     • Unlike AssetBundles, they are not designed for modularity, but to be loaded directly by the Unity runtime as part of the game build.
  3. Map Square Usage:
     • Each map square has its own BuildPlayer file containing:
       • Terrain mesh or heightmap data.
       • Lightmaps baked into the scene.
       • Placement of static/dynamic assets via pointers to asset IDs.
       • Environmental settings.
  4. References to CustomAssetBundles:
     • Instead of embedding assets themselves, these files often reference IDs found in CustomAssetBundles, making them a layout + reference layer.
     • They act as a scene composition file, while actual assets like trees, props, or models live in separate bundles.
       
       

       How are they likely structured internally? (Hypothesis)​

       Based on FusionFall tools and reverse engineering:
       • Header (with identifiers, versioning, magic numbers).
       • Pointer table (with asset GUIDs or internal IDs from CustomAssetBundles).
       • Object list (Transform data, references to prefabs).
       • Terrain data block (heightmap, textures).
       • Lightmap and baking data (optional).
       • Scene configuration block (ambient lighting, skybox settings, triggers).
         
         Unity 2.5 and 2.6 (2009–2010 era) had a very different BuildPlayer pipeline compared to modern Unity.
         FusionFall, being developed in a heavily customized Unity 2.5.5bf build, leveraged this system in ways that closely reflect the original Unity player architecture.
         
         

         Unity 2.5 / 2.6 BuildPlayer Pipeline — Deep Dive​

         What is BuildPlayer in this era?​

         • The BuildPipeline.BuildPlayer method was the core Unity API to compile, serialize, and package the game project into a standalone Player or Web Player.
         • It bundled:
           • Scenes (*.unity files)
           • Assets embedded into scenes
           • Resources folders assets
           • Player executables
         • It created platform-specific builds, where scene data was serialized into proprietary binary formats alongside the player.