Skip to content
| Marketplace
Sign in
Visual Studio Code>Programming Languages>bigFSNew to Visual Studio Code? Get it now.
bigFS

bigFS

max-bronner

|
1 install
| (0) | Free
Mod the Battle for Middle-earth games in VS Code: browse and edit BIG archives, INI, STR and WND language support, and previews for W3D models, APT movies, maps, textures and audio.
Installation
Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.
Copied to clipboard
More Info

bigFS

Browse and edit the BIG archives of the SAGE-engine games (The Battle for Middle-earth, The Battle for Middle-earth II, The Rise of the Witch-king, Command & Conquer: Generals) directly in VS Code, with language support for their INI dialect.

bigFS ships no game content. Open a folder holding your own installation or your mod's archives.

Features

Archives

  • BIG Archives view in the explorer: every .big file in the workspace, browsable as folders.
  • Edit in place: open, save, create, rename, move, copy, delete and drag and drop files inside an archive. A save rewrites the archive through a temporary file and keeps names, duplicates and the header layout as the game shipped them.
  • new Copy and move between archives: cut, copy and paste, or drag, files and folders from one archive into another writable one (a loose folder dragged in from the Explorer works too). Names the target already holds ask to replace, skip or keep both, and the target is saved once. Copying out of the read-only base game is allowed; moving out of it copies.
  • new Find Game Installs: with bigfs.baseGameFolder unset, a quick pick offers the BFME, BFME II and ROTWK installs found through the registry (reg query), the usual Program Files, EA app and Origin folders, and Wine, Proton and CrossOver prefixes on Linux and macOS. Nothing is written until you pick one; BIG: Find Game Installs asks again later. The folders are only read.
  • new Create archives and manage them: right-click a folder (or the workspace row) in the view for New Archive…, which writes an empty BIG4 archive and never replaces a file of that name. Rename… and Delete on an archive row rename it on disk and move it to the trash. Names are checked before anything is written: no empty, dot, Windows-reserved or non-Windows-1252 names, no separators in a single name, no path past 255 characters, nothing differing from an existing name only in case. Dropped files and folders that break these rules are skipped with a message; an archive that would pass 4 GiB is refused before it is touched. Dragging .big files from outside onto a folder row copies them there.
  • Context menu and keys on a row of the view: New File…, New Folder…, Add Files…, Rename… (F2), Delete (Del), Cut (Ctrl+X), Copy (Ctrl+C), Paste (Ctrl+V), Duplicate, Copy Path and Copy Relative Path; Refresh and Search in BIG Archives… sit in the view's title bar. Commands act on the row they are run from.
  • Show What the Game Loads / Show Every Archive (the title bar button) switch the view between the merged game view and one tree per archive, the same as bigfs.explorer.view.
  • Extract files, folders or whole archives, and add files from disk.
  • Pack into BIG Archive on any folder in the Explorer.
  • Launch Game with Mod starts the game with -mod "<folder>" on a folder or the workspace, saving open files first; a Run mod button sits in the status bar once the game is set (bigfs.game.executable, extra arguments in bigfs.game.arguments).
  • Override in Folder copies archive files into a mod folder at the same path.
  • Search in BIG Archives (the Search in Archives view under the archive tree, or the command, which takes the selected text as the query) finds text inside every archive the way VS Code's search does: results grouped by archive and file, each match highlighted with the lines around it (adjustable), toggles for case, whole word and regular expression, include and exclude globs on entry paths, a live count, results streaming in while it runs, and Cancel. A click opens the entry at the match. It reads text entries only (INI, STR, WND, Lua, XML and the like) and stops at 5000 matches, saying so. VS Code's own search and Ctrl+P cannot see inside a bigfs: folder (their extension points are closed to published extensions), which is why this exists.
  • Go to File in Archives… (Ctrl+Alt+P, Cmd+Alt+P on a Mac, or the title bar of the archive tree) is Ctrl+P for the archives: type part of a file name or path, with fuzzy matching that prefers the start of the name, and open it. Archives, loose files of every install and mod are listed from the index tables alone, recent files come first, and a path several archives hold is listed once per archive with the copy the game loads marked. The button on a row reveals it in the archive tree.
  • Load order follows the game: a loose file beats every archive of its install, archives go by their path below it (___a.big before b.big, the first holding a file wins), and installs are layered by the marker file in their folder: a mod, then ROTWK (lotrbfme2ep1.exe), then BFME II (lotrbfme2.exe). bigfs.baseGameFolder (with bigfs.underlyingGameFolder beneath it, found from the registry on Windows when empty) is the lowest layer, so a mod-only workspace still resolves the base game's files. Folders of one kind, such as two mods, keep their workspace folder order.
  • Compare with Base Game lists what the workspace adds and changes against an untouched install (bigfs.baseGameFolder), each side after the game's load order, with a diff for every changed text file, and for a changed INI file what it changes definition by definition: those it adds and drops, and in each the values it changes, named by where they sit (Body[ModuleTag_Body]/MaxHealth 200 → 220).
  • Package Mod… packs the mod folder into one archive after a report: against the base game, which files it overrides, which are new, and which a base archive would keep because it sorts before the archive's name (in the game folder the first archive by name wins; with -mod the mod always does), plus the INI errors found by checking the folder's files. Hidden files and archives are left out.
  • Check Translations compares the workspace's string tables language by language (from lang/german/…-style paths, else a .csf header) and lists the labels each lacks; for a .str table it can add them with another language's text standing in until they are translated. Tables inside archives are compared too (a .str in a writable archive is filled and saved with it; one in a base game archive is only reported, with Override in Folder offered), and the labels that INI files, loose or in archives, use but no table defines are listed.
  • Game view (bigfs.explorer.view): one merged tree of only the files the game loads, after its own priority rules, beside the default per-archive view.

INI language support for .ini, .inc and .bhav

  • Structure from the games' own field tables (via mint), for Rise of the Witch-king or BFME II (bigfs.ini.game).
  • Problems panel: unknown fields and modules, unclosed blocks, stray End, missing includes. BIG: Validate INI Files checks the whole workspace.
  • Highlighting, outline, folding, completion, hover with engine types and the game's own text for string labels, go to definition, find references and rename across archives and loose mod folders, #include links and #define macros.
  • Quick fixes: add a missing End, remove a stray one, and correct a misspelt keyword or name to the close ones the game knows.
  • Format Document re-indents from the block structure, touching only whitespace; embedded scripts stay as written, and formatting again never changes the result.
  • Hovering a MappedImage name shows the image, cut from its texture.
  • A lens over each MappedImage header, Edit region in texture, opens the texture with the block's rectangle drawn on it. Drag or resize the box, or type its edges, and the Coords line is rewritten as an undoable edit of the INI document.
  • In a shape's .ru geometry file, a lens over each s tc: texture style names the image and box it samples and opens the texture with that box selected; dragging it rewrites only that style line.
  • Lua in BeginScript regions is checked for syntax errors.
  • Duplicate Definition… (refactor menu, editor context menu) copies the definition at the cursor under a new name, renaming the game-text labels that carry the old name and copying their text into the string table.
  • Hovering a CommandSet name shows its buttons in slot order, each with its icon, its label in game text, its hotkey and its command; undefined buttons are marked. Slots whose buttons share a hotkey are reported as problems, unless they are never on the command bar together: a purchase button and the ability it unlocks (NEED_UPGRADE on an upgrade or science it buys).
  • Audio events get a ▶ Play lens that plays one of their sounds and an Open file lens; hovering a sound or an event name gives play and open links. Every play button in a preview (voices, FX timeline, script parameters, the APT Engine panel) plays in place; Ctrl+click (Cmd on macOS) opens the sound file instead, and a second press stops it.
  • new Indexing the INI files of a full install takes about a third of the time it did, and saving a file inside an archive re-reads that file alone, so hover, go to definition and checks stay current without a long wait.
  • new The object preview lists every Voice* and Sound* field of the object, inherited ones included, each with its own ▶ button; the preview stays muted otherwise.
  • Game-text labels such as OBJECT:Name that no string table defines are reported, with a quick fix that adds the record to the table the file already uses (bigfs.ini.checkStrings).
  • Find Unused Definitions lists, in the Problems panel, every weapon, armor, FX list, particle system, locomotor, command button and similar definition in the mod's own files that no INI file references. Kinds that maps, scripts or the engine name (objects, upgrades, sciences, special powers, command sets, player templates, sounds, announcer events, images, GameData) are never listed, nor is anything under bigfs.baseGameFolder.
  • New Unit, Hero or Building… makes a new object from an existing one: inherit (ChildObject) or copy, its own display name, and a copy of the button that builds the original, added to the next free slot of that command set. The new game text goes into the string table the original's comes from. It works on objects inside writable archives too, and a copy is always written to a file the game loads (Data\INI\Object\<name>.ini, or beside the original when that is one), never to a stray file; for an original in a base game archive, which is never changed, the new file goes to a folder of the workspace and what else would need editing is listed.
  • Edit slots lens on every CommandSet: its buttons in their slots as the player sees them, with icon, game text and hotkey, clashes marked. Drag a button to another slot (it swaps with what is there), clear a slot, or add a button to an empty one; the set's slot lines are written again in order.
  • Armor Table shows every armor against every damage type any of them names, in one grid: resists tinted green, weaknesses red, a type an armor does not write shown greyed from its DEFAULT. Typing in a cell writes that armor's line, or adds it.
  • Bulk Edit INI Values… changes many values by one formula: pick blocks (Object *Archer*), conditions (Side = Rohan; KindOf ~ INFANTRY), a field (ActiveBody/MaxHealth) and a formula of x and the block's own fields (round(x * 1.1)). Every change opens in the refactor preview as a diff to review and untick before applying. INI files inside writable archives are edited as well, each archive saved once and undoable; values defined in base game archives are never written, and Override in Folder is offered for those files. A value written as a #define macro, in an #included file or inherited by a ChildObject from its parent is edited where it is defined (the preview says so); one that cannot be, such as an #ADD call, is reported.
  • Effective definition lens on every ChildObject and ObjectReskin: the object as the game composes it from its parents, each line marked with where it comes from and what it replaced (fields override, modules by tag, RemoveModule/ReplaceModule, a new WeaponSet or ArmorSet clearing the inherited ones). It follows edits to the files involved.
  • Show Call Hierarchy (Shift+Alt+H) on a definition shows what it uses, down through weapons, FX lists and particle systems, and what uses it. Show Type Hierarchy follows ChildObject and ObjectReskin parents and children.
  • References to a definition that nothing in the workspace defines (a Weapon, Upgrade, FXList and the like) are reported as information, so a real typo stays visible without alarming on names the engine tolerates (bigfs.ini.checkReferences).
  • Clear Unused Definitions empties the list Find Unused Definitions left in the Problems panel.
  • Models, animations, textures and sounds named in INI files are checked against every archive and folder once bigfs.baseGameFolder is set (until then the check stays off and says so once); a missing one is reported with the nearest existing names as quick fixes, in the editor and in Validate INI Files (bigfs.ini.checkAssets).

Object preview

  • ▶ Preview object over every Object, ChildObject and ObjectReskin (also Preview Object Here in the editor context menu) opens the object with its default model, the idle animation playing and the default state's bone particle systems on; other effects are listed, switched off. ▶ Preview state over a ModelConditionState, AnimationState and the like shows that state's model and first animation. A lightbulb Preview on the object on an AnimationName, FX or ParticleSysBone line plays that animation or effect on the model. Toggles for model, bones and every effect, and pickers for state and animation. A ChildObject shows what it inherits.
  • Voices lists every sound field of the object with a ▶ button each; nothing plays unless clicked.
  • Model, animation and texture names in an INI file are links (Ctrl+click) to the file in its viewer, and the W3D viewer's "Used in" list links back to the INI lines naming the file.

Bone animations

  • Edit W3D Animation… on a .w3d file, in an archive or a folder: retime it to another number of frames, reverse it, play it along an easing curve, keep a range of its frames, or change its rate. The result is written beside it as a new animation file, named as the game finds it, for an INI line to switch to by name.

The 3D viewer

  • A .w3d, Preview object and an FX preview all open one viewer: the same view, grid and camera, and the same controls in the same place (animation list, play, stop, restart, step, time slider, speed, loop, bones, model, hidden parts, boxes, grid, level of detail, sky). A .w3d opened directly or by Ctrl-click shows the model alone; a preview adds its own panels beside it.

Particle preview

  • A Preview lens on every FXParticleSystem, ParticleSystem and FXList block opens a live 3D preview with the system's textures: orbit, pan and zoom, play, pause, step, restart, speed from 0.1× to 4×, a moving emitter, the emission volume drawn as a wireframe with handles: drag them to size a sphere, cylinder or box, or move a line's ends.
  • Every number in the block gets a slider. Sliders change the preview only; Apply to INI writes them back as one undoable edit, Reset drops them. Typing in the block updates the preview as well.
  • Scale makes a whole effect bigger or longer and keeps it the same effect: size × scales every length and speed, time × stretches every duration and key and slows the rates to match (speeds ÷ k, gravity ÷ k², damping d^(1/k)). Previewed like the sliders until applied.
  • On a model… shows the effect on any W3D model of the workspace or its archives, drawn shaded, started at a bone you pick in its bind pose, the way a unit carries an effect on a bone.
  • A/B (C) flips the preview between the block as written and with the values being tried; Vary ± nudges every value by up to a percentage to try variations; Save as variant… writes the values as a new system after this one, which keeps its own.
  • Over lifetime curves for a system: colour keys as a gradient, alpha keys as a min-max band, size as the game grows it. Drag keys along and up or down, pick a key's colour, add and remove keys (written at once, renumbered), and drag the end of a size curve to set the SizeRate that reaches it.
  • New Particle System from Template… (editor context menu) inserts a working system to start from: fire, smoke, sparks, dust cloud, magic glow or flash, with its name and texture as tab stops.
  • An FX list's preview has a Timeline: a bar per nugget from its InitialDelay for as long as it emits and its particles live, lit while it runs, with the playhead. Click a name to mute it, shift-click to play it alone, drag a bar to move its delay. Sound nuggets get a play button (nothing plays unless asked). The other nuggets are listed with their delay and key fields: LightPulse is approximated as a screen flash, ViewShake and CameraShakerVolume as a camera shake, TerrainScorch as a ring on the ground, and FXListAtBonePos, BuffNugget, AttachedModel, DynamicDecal and the rest are labelled only, as in mint's FX viewer. The approximations show when and roughly how big, not the game's own look.
  • Load: live particles and systems now, at peak and on average, per system, how much of the view the billboards cover, and the peak against each MaxParticleCount the mod's StaticGameLOD blocks allow.
  • Slave systems, per-particle attached systems, terrain-collision events and an FX list's ParticleSystem nuggets (offset, count, delay) play along.
  • The simulation follows the Generals engine's rules as BFME keeps them, at 30 frames a second; where the game's rule is not settled (wind strength, hollow boxes) the reading is a switch, with W and H as hotkeys. Model (DRAWABLE) particles are drawn as markers and streaks as sprites.

Balance sheet

  • BIG: Open Balance Sheet lists every unit and building with its side, cost, build time, command points, health, vision, speed, armor and primary weapon's damage, range and delay, read across all INI files.
  • Sort by any column, filter by name, weapon, armor or side.
  • Double-click a value to change it where it is written; a child's inherited value is shown in italics and edited at its parent, and a weapon value notes how many templates share it.
  • A Damage/s column works out the primary weapon's damage a second (Damage × 1000 / DelayBetweenShots), to sort units by it.

String tables

  • .str files get their own language: highlighting, an outline of labels, folding, and problems for duplicate labels, missing END and unclosed quotes. They are read as Windows-1252, as the game reads them.
  • Open as Table edits a .str as a filterable table; only the records you change are rewritten.
  • .csf files open as the same table and save back byte for byte.
  • Convert String Table turns a .str into a .csf and back.

Create-a-Hero files (.cah)

  • new MyHero_<id>.cah files, loose or inside a BIG archive, open in a form showing the hero's name, id, class and subclass, the three colours, the 15 power slots, the bling and upgrade choices, and the attribute points spent. Class, subclass, bling, power and special-power names resolve through the CreateAHeroSystem, Upgrade, CommandButton and SpecialPower definitions and the string labels of the chosen game language; whatever does not resolve is shown as stored.
  • new Name, id, class, subclass, colours, powers and bling are editable with undo and redo. Saving recomputes the CRC-32 trailer exactly as mint's mint-sage-cah does (the game drops a hero whose checksum is wrong) and writes record version 8. Files from a game install are read-only; use Save As.

Window layouts (.wnd)

  • Highlighting, outline of windows, folding, completion of keys, window types and status and style flags, and every structural problem at once.
  • Show Layout Preview (the .wnd editor title button) draws the windows at their creation resolution beside the text, live; click a window to jump to it.

Maps (.map, .bse)

  • The terrain as a shaded relief with objects, waypoints, start positions and the playable area; click an object to select it.

  • Size, border, playable area, height range, players and every chunk at a glance.

  • Edit the world info (name, description, weather...), the time of day and each time of day's sun (ambient, colour, direction), each player's and team's settings, and every object's template, position, angle and properties.

  • The map's scripts per player, with their conditions and actions, each switchable on or off; trigger areas drawn on the terrain. Compressed maps are saved compressed again; nothing an edit does not touch changes.

  • new A ▶ button after every script parameter that names a sound or music track (PLAY_SOUND_EFFECT, SPEECH_PLAY, AUDIO_PUSH_MUSIC, ...) plays it through the INI audio events of the workspace. Nothing plays unless clicked.

  • new Place, move, turn and delete objects on the map: pick a template from the workspace's INI definitions and click the map, drag an object to move it, ⟲ ⟳ or [ ] turn it by 15°, Delete removes it. Owner or team, health and name are fields; any other property can be added or removed. New names are added to the map's name table.

  • new Waypoints are drawn with their links as arrows. Place waypoint adds one with the next id, Alt-click another waypoint to add or remove a link, and the object panel lists a waypoint's links. Removing a waypoint removes its links.

  • new Trigger areas can be selected, renamed, reshaped (drag a corner or type coordinates), added by clicking points on the map, and deleted. Chunks the editor does not touch, including PolygonTriggers, keep their bytes. Maps from a game install open read-only.

  • new Standalone .scb script files open in a read-only viewer with the same script tree as the map editor.

Previews

  • Textures: TGA and DDS (DXT1/3/5, uncompressed), with zoom, channels and mip levels. A References panel lists every MappedImage and every APT shape that uses part of the texture, draws their boxes on it and lets you select one and drag, resize or type its region back into the INI or .ru file. Fit follows the room the image has beside the panel, the image scrolls inside its own area so the list stays in view while zoomed, the panel is resized by dragging its edge, and Pop out moves the editor to its own window for more room. Export as PNG, Replace with PNG… (written back in the texture's own format, mipmaps included) and Convert to Game Texture… for PNGs (TGA 24/32-bit, DDS DXT1/3/5 or uncompressed).
  • Sounds: WAV, including IMA ADPCM, which VS Code's own audio preview cannot play. MP3 opens in VS Code's own preview.
  • new Cursors: .cur and .ani open in the preview with every image, its size and its hotspot (outlined in red); an animated cursor plays its own sequence and rates, with play, pause and a step slider.
  • new Export Cursor as PNG… writes a .cur, or one or all frames of an .ani, as PNG (to a file or a folder you pick, never beside the source), and Convert to Cursor… on a PNG asks for the hotspot and writes a .cur with alpha.
  • new Build Animated Cursor… (command palette, or the file explorer menu on images) puts .png, .tga, .cur, .ico or .ani files in a list of frames: reorder, duplicate or remove them, set each frame's hotspot and duration in milliseconds, watch the loop, then Save as .ani… to a place you choose. All frames must share one size.
  • Videos: EA's VP6 movies (.vp6), decoded frame by frame with play, pause and seeking (dragging the slider follows the pointer and lands on the frame you let go on); alpha movies show over a checkerboard.
  • Convert to VP6 Movie… on a video, an image or a folder of numbered PNG/TGA/DDS frames writes an EA VP6 movie the games play: size, frame rate and quality are asked for, transparency is kept as an alpha stream, and the result is decoded again before it is saved. Frames between key frames (bigfs.vp6.keyFrameSeconds) are coded as changes from the one before, with motion search, and each frame sends the probabilities it needs. Any video FFmpeg reads works when FFmpeg is installed (bigfs.ffmpegPath); without it, WebM and Ogg.
  • Models: W3D in 3D, with their skeleton and textures found in any archive, drawn pass by pass with each triangle's own texture, shader, blend and depth test, and with the material's colours: emissive glow, tints, vertex colours, opacity, unlit surfaces, second texture stages with every detail combine, clamped textures and bump offsets. Scrolling, rotating, flipbook and environment-mapped textures run on the preview's clock and stop with its pause. Parts housecolor.ini masks wear a default team colour, and normal-mapped meshes show their relief and highlight. Any animation plays on any model, by bone number as the game applies it; the list shows the skeleton's own clips first and the ones made for other skeletons in their own group, and playing one of those says so. Animations of the skeleton are listed and play on the model (dense, time-coded, adaptive-delta and motion channels); a skeleton or an animation file on its own shows its bones. Meshes marked hidden are not drawn (a toggle shows them); the levels of detail the HLOD header counts are picked from a dropdown with their max screen size when there is more than one, and arrays past that count are skipped as the game skips them; the aggregate and proxy lists are shown; collision boxes can be drawn as wireframes. A Parts list turns each mesh on and off, and the object preview hides what the object's INI and scripts hide in the shown state, and as the game does a write also reaches the parts on bones below the part it names (animation state scripts, fired SubObjectsUpgrade modules, TransitionDamageFX lists, OnCreated handlers in scripts.lua), naming the source and listing what depends on the running game. Scripts are read, not run.

Interface movies (APT)

  • A big movie opens in seconds: the movie is drawn as soon as it is read, its imports fill in after, and a progress line says what it is doing.
  • Every character drawn with its shapes, textures and text; sprites play frame by frame.
  • Edit text fields, colours, bounds, exports, imports, placements, frame labels and frames, add frames, duplicate characters and create new text, sprite, shape and image characters, with undo.
  • new Every field the parser reads is editable, with undo: a placement's flags (move and each optional field on or off), depth, character (picked from a list), matrix, the colour transform's multiply and add as R, G, B, A bytes or a hex word, ratio, name, clip depth and clip events; button records' states, character, depth, matrix and colour; button action conditions; text runs (font, colour, pen offset, height, glyphs) of Text characters, added and removed; font glyph ids; morph shapes; frame label flags, background colours (added too), init actions and removed depths; the movie record's word at +36, import slots and every .const item. An unedited movie still saves byte for byte, and an edit touches only its own fields or appends.
  • new A text view of the whole movie, .apt and .const together, for people who prefer text: bigFS: Open APT as Text (editor title, palette or the .apt context menu) switches to it and Reopen as Visual Editor switches back. One record a line, indented by what holds it, character ids explicit, numbers exact, and every script decompiled in a fence; see docs/apt-text-format.md. Highlighting (scripts too), an outline, folding, and hover and go to definition on character ids. Saving turns the differences into the editor's own edits, so only the edited fields change and an unedited text leaves the movie byte for byte; a text that does not parse or cannot be saved is underlined and the movie is left as it was. Works for loose movies and movies in writable archives; base game movies open read-only.
  • Check APT Movies checks every movie of the workspace, loose or in an archive, for integrity problems and reports what it found; Rename APT Movie… and Delete APT Movie… (on an .apt, in the Explorer or an archive) rename or remove a movie together with its .const and .dat, and update the imports that name it.
  • Create whole new movies (New APT Movie… on a folder): an .apt, .const and .dat with exported empty sprites, ready for a root movie to import with Add import in its movie panel.
  • Text fields written as $KEY show the game's text: APT:key is tried, then key, and a key neither has shows MISSING: 'APT:key' as the game does; a trailing &dropShadow is style and not shown. A movie's own .const and .dat are read from its own archive first, whatever their casing there, and imports resolve in the game's load order (mod, ROTWK, BFME II).
  • Movies a script loads (loadMovie, loadMovieNum, unloadMovie, getURL to a clip or level) are found in the game's load order like an import (.apt and .const) and play inside the target clip or level; one that cannot be found or read is a line in the log. Sounds a movie asks for (FSCommand:PlaySound) are listed in the Engine panel with a play button; the Play movie sounds checkbox, off at every start, lets them play as the movie asks.
  • new Engine images: surfaces no movie names get what the game supplies, the main menu's logo and shell background, the faction icon and a black portrait, in place of their magenta squares. The Engine panel shows each with a field to change it to any MappedImage or texture file, kept per movie with the other answers.
  • new Engine suggestions: where the engine feeds a movie a value out of the game's INI, the Engine panel field is still plain text but offers the INI's values to pick from. The palantir's SetPalantirFrameState offers _good and _evil with the sides each shows, SetFaction (the all-heroes button) and SetPlayerFaction offer the player templates' Side values, and faction icon, rank icon and command button picture fields offer the MappedImages the game binds there. Nothing is offered without a game loaded. Hovering a field says where the game takes its value from. The same goes for create-a-hero power, class and type icons, hero-row and unit portraits, spell book pictures and the MultiplayerColor swatches of the score and loading screens' colour externs. Values the engine itself fixes are offered too, with the evidence in the tooltip: power cell, icon slot and show/hide states, the score screen's mode, save/load mode, game types, true and false externs and a view's _AnimMode.
  • new View3D surfaces (ported from mint's view3d.rs): a clip naming a W3D model in _RenderObj draws it, found through the game's load order, through the model's own camera and following _AnimMode and _Frame, in the clip's place in paint order, so masks and fades apply. Models load when shown, at most 16 at a time; a missing one is a labelled box. Scrolling, rotating and flipbook materials of the model move with the stage's clock.
  • new Engine gadgets (ported from mint's apt-player and apt-viewer): a clip whose _type (or _Load template) names a slider, check box, list box, combo box, text entry, scroll bar or progress bar gets a working control over the stage, bound to variables of the clip (_value/_min/_max, _checked, _selected and _items separated by |, _text). A clip with _imageName (or _imageMap) draws that MappedImage from the INI index and its texture. Any other _type is a labelled placeholder. The Engine panel has a Gadgets section listing each one with its bound values, overridable like any other value.
  • changed The details, inspector and timeline panels are a block editor: every record (movie header, character, frame, placement, button record, action, export, import, .const item) is a collapsible card with a type icon, id or name and summary, its fields as labelled typed inputs (numbers, colour swatch with R, G, B, A, flag toggles, character pickers with search), and VS Code theme colours throughout.
  • new + Add block menus offer only the record kinds that fit the spot; frame items and button records reorder by drag handle or Alt+↑ and Alt+↓ (each one undo step); cards duplicate and delete inline; and the keyboard moves between cards, opens and closes them and reorders.
  • new Script blocks show the decompiled ActionScript in place as a highlighted code field. It compiles when you leave it, underlines the error and writes nothing until it compiles; Open in tab is still on each script block. The toolbar's Text view button asks for the whole movie as text.
  • ActionScript as a small JavaScript-like language, editable and compiled back to bytecode; see docs/apt-scripts.md. A script is only offered once compiling it is checked to give back the same code, and blocks you do not change keep their bytes as shipped.
  • A timeline panel under the stage: depths by frames, with labels and scripts marked. Select a range of frames, at one depth or all, and set it once instead of frame by frame: a tween to an end pose with an easing, a formula per property (x0 + 120*t, y0 - 40*sin(t*pi)), fade out, remove or show, and insert, delete, duplicate, reverse or retime frames. Frames the change leaves alone keep their records as shipped. Onion skin (N) draws the frames either side faintly.
  • Script… writes the timeline as a few lines, like a CSS animation, and bakes them into frames: depth 3, frames 0-20: x 0 -> 120 easeOut; alpha 1 -> 0, y = y0 - 40 * sin(t * pi), fade, hide, show, retime 20. It starts as the tweens found in the movie, runs as one undoable edit, and names the line that is wrong.
  • Copy motion remembers how a depth moves over a range, relative to its first frame; Paste motion plays it on another depth or range from that one's own pose, and Paste ↔ / ↕ mirrors it.
  • The preview runs the movie's ActionScript on a small AVM (ported from mint's player): frame, button and clip-event scripts with variables, conditions, functions and the MovieClip methods. Ignore action scripts (S) plays every frame in order instead; Play from… starts at a label.
  • The Engine panel is the game's side of the movie: what its code reaches for while it runs, found as it runs. Functions only the engine calls (the palantir's SetPlayerFaction) get a field per argument and a Call button; every variable it reads, and its GetExtern keys, can be overridden, winning over what the movie holds; calls into the engine (GameCode, FSCommand:) are counted with their arguments and can be given a return value. Overrides and the calls you make are kept per movie, and a restarted movie makes those calls again once it has settled.
  • Tweens already baked into a movie are recognised: a run of frames in which an instance follows one easing curve shows as a purple bar, its tooltip saying what moves from where to where, and a double-click opens it in the tween form with its easing, to change it as one tween.

Commands, settings and editors

Every command is in the Command Palette as BIG: … (or bigFS: …) where it makes sense without a selection; the rest sit in the context menu of the row, file or editor they act on.

Command Where Does
Refresh, Search in BIG Archives…, Go to File in Archives…, Validate INI Files, Show What the Game Loads, Show Every Archive BIG Archives title bar Rescan, search, validate, switch view
New File…, New Folder…, Add Files…, Extract…, Rename…, Delete, Cut, Copy, Paste, Duplicate, Copy Path, Copy Relative Path, Override in Folder… archive row context menu Edit archives
Pack into BIG Archive…, Launch Game with Mod Explorer folder menu Build and run a mod
Find Game Installs, Choose Game Language, Compare with Base Game, Package Mod…, Check Translations, Open Balance Sheet, Armor Table, Find Unused Definitions, Clear Unused Definitions, Check APT Movies Command Palette Workspace tools
Convert String Table (.str ⇄ .csf), Open as Table .str/.csf menu, editor title String tables
Show Layout Preview .wnd editor title WND preview
Export as PNG, Replace with PNG…, Convert to Game Texture… .tga/.dds/.png menu Textures
Export Cursor as PNG… .cur/.ani menu Cursors
Convert to Cursor… .png menu Cursors
Build Animated Cursor… palette, .png/.cur/.tga file menu Cursors
Convert to VP6 Movie… video, image or folder menu VP6
Edit W3D Animation… .w3d menu Bone animations
New APT Movie…, Rename APT Movie…, Delete APT Movie… folder or .apt menu APT movies
new Open APT as Text, Reopen as Visual Editor APT editor title, .apt menu, text view title APT text view
Preview Particle System, Preview Object Here, New Particle System from Template…, Bulk Edit INI Values…, Show Effective Definition, New Unit, Hero or Building…, Duplicate Definition…, Edit CommandSet Slots, Play Audio Event INI editor menu and lenses INI tools
Setting Default Does
bigfs.ini.game rotwk Grammar for rotwk, bfme2 or bfme1
bigfs.ini.checkReferences, bigfs.ini.checkAssets, bigfs.ini.checkStrings auto Report undefined references, missing assets, undefined game text (auto, on, off)
bigfs.language auto Game text language
bigfs.explorer.view archives archives or game view
bigfs.baseGameFolder, bigfs.underlyingGameFolder empty Untouched installs, the lowest load-order layers
bigfs.game.executable, bigfs.game.arguments empty What Launch Game with Mod starts
bigfs.ffmpegPath, bigfs.vp6.keyFrameSeconds empty, 2 VP6 conversion
Editor Opens
bigFS Preview .tga, .dds, .wav, .w3d, .vp6, .cur, .ani
bigFS APT Movie .apt
bigFS String Table, bigFS CSF String Table .str, .csf
bigFS Create-a-Hero .cah
bigFS Map .map, .bse
bigFS Script File .scb

Languages: sage-ini (.ini, .inc, .bhav), sage-str, sage-wnd, apt-script (.aptscript), new apt-text (.apttext, the APT text view).

Game language

A game's languages are the lang/<Language>.big archives of its install (English.big, ...); the *Audio.big ones hold speech and are ignored. Each holds its own string table. bigFS: Choose Game Language picks which one labels resolve against, and the bigfs.language setting (default auto) names it directly. With auto, the only installed language is used; when several are installed, bigFS asks once and remembers the answer for the workspace. The language applies to INI DisplayName hovers, APT $KEY text and the WND preview's text.

Development

npm install
npm run compile
npm test          # unit tests, then the VS Code integration suite

Tests build their own archives in code; no game file is ever committed.

Licence

GPL-3.0-or-later. See LICENSE.

  • Contact us
  • Jobs
  • Privacy
  • Manage cookies
  • Terms of use
  • Trademarks
  • Your Privacy Choices
  • Consumer Health Privacy
© 2026 Microsoft