Halo 2: Map Editors

As each year ticks by the memories and visible web-pages of the original Halo 2 era of modding fades further away. I blogged about the patchers (ppf, sppf and serenity) - and this time I put my eyes on the map editors of the era. Researching everything about the tools to wrangle together another post to survive the challenge of time.

For those who remember the era - Halo 2 Map Editors took modifications to the next level enabling creations of maps that ranged from funny manipulations of the game to extremely precise and professionally balanced game play.

What were the tools behind these creations? Well reverse your clock to the original Xbox era and you'll find yourself with a difficult question. Software didn't auto update behind the scenes, Electron didn't exist and 64bit architecture was just beginning. It would be very difficult to pinpoint which tools generated which mods.

Tool authors may have shared many different versions of tools by passing around compressed binaries as revision control wasn't mainstream yet. So for this post we will take a look at some of the most popular map editors of the era, including some tidbits of knowledge we picked up along the way.

You can't talk about map editors without talking about Dothalo and that is where our story begins. We will soon learn that February of 2005 was a major month for tools where many editors made their public debut onto forums across the scene.

Dothalo may have started as H2Edit, but the big red DH logo became a staple for this tool. This tool launched with the support and help from many within the community with a feature set that set the bar high on what a map editor needed to compete. It launched onto HaloMods with:

• Meta Extraction / Injection
• Tag Editing (Supported HMT, HHT, CH2R plugins)
• Dependency Swapping
• Signature Correction
• Bitmap extraction/injection
• Sound extraction
• Hex Editor / Utilities
• Patch creation (ppf)

It also launched with an auto updater, which was nothing more than checking for a DotHalo.txt file located on the halomods.com/bocked/DotHalo folder. This would download the updated RAR file if the version didn't match and excelled at providing updated versions.

Next up we have Entity which is a program that has survived through so many authors and versions - probably because of the released source nature of it. Most versions of Entity released not only included the binary, but the source code itself. In terms of the interface it rocked a 3 column design where the tags held the left column, which the main configurable tools in the middle and all meta information on the far right.

Once Alpha was out in the wild, this attracted the help and attention of many. The next release (Beta) packed more features and some of the more known names of the era helped out in some way in this release. With such a large application, it became one of the first applications in the scene to include some "call home" functionality.

Signing into select versions of Entity back in the day would send an AIM message to either "mjdpdu", "thetyckoman" or "pukeanddeadstuff" using a hard-coded list of accounts to send the message. The accounts sending automated messages had clever passwords such as:

• loser
• halonazi
• l337

To save the curiosity - those accounts have been deactivated for being abandoned.

As Halo 2 DLC was released - the clever "patch.lvl" files came to light. shade45 ended up releasing what was known as Entity UE 1.6 which built upon the previous versions with features and fixes. Shade also released many fixes in this version which helped with SLC (System Link Compatibility).

I was curious if the different author versions still included the same AIM messaging "call home" feature and sure enough Entity UE 1.6 had the same code as Entity Beta 1.3.9.

Finally, we can't talk about Entity without mentioning Entity 2.0 and troymac1ure who started in 2009 releasing updates to the tool and updating it year after year till 2014 on GitHub. While the GitHub inclusion was just massive commits for each release - it was an excellent step in the direction of community based development.

Next up, I want to talk about ADI and Ch2r which were some of the first map editors on the scene - I believe the first public release of Ch2r was in November of 2004. Both allowed tag browsing via a pretty bare-bone implementation of plugins which had begun slightly earlier in the Halo era of tools.

<plugin>
	<tag>adlg</tag>
	<struct>
		<name>Main</name>
		<size>0</size>
		<value>
			<type>reflexive</type>
			<offset>0x0</offset>
			<name>Dialogs</name>
		</value>
	</struct>
	<struct>
		<name>Dialogs</name>
		<size>96</size>
	</struct>
</plugin>

This meant that plugin authors could map out one of the many tags and contribute by simply sharing plugins. Ch2r also used the same design of plugins which was quickly becoming a chance for improvement as multiple iterations of plugins were being designed.

• The above which was code named "xml"
• There were "ent" plugins, a sort of hybrid of the above
• There were "ifps" plugins, the format to withstand test of time

As usual Iron_Forge rushed to the scene like he did with patchers and signers and contributed a design for a plugin that would survive the test of time. The idea wasn't that different from the current - just extracting some meta information like version, author, revision and the format could automatically generate blank/unknown structs to be filled in later.

This meant you would get something like

<plugin class="adlg" author="Iron_Forge" version="0.1" headersize="44">
  <revision author="Iron_Forge" version="0.1">Added basic layout of plugin...</revision>
  ...
  <struct name="Unknown51" offset="36" visible="false" size="4" label="">
    <undefined name="Unknown" offset="0" visible="False" />
  </struct>
</plugin>

Now a decade and more later the design of the plugin has tweaked a bit, but the idea stays the same. We can peek at the public plugin of Assembly Halo3 adlg.

<?xml version="1.0" encoding="utf-8"?>
<plugin game="Halo3" baseSize="0x4C">
	<!-- Automatically generated plugin -->
	<revisions>
		<revision author="Assembly" version="1">Generated plugin from scratch.</revision>
		<revision author="DeadCanadian" version="2">naming stuff</revision>
		<revision author="OrangeMohawk" version="3">Responses/Indexes</revision>
		<revision author="Lord Zedd" version="4">Updates and corrections</revision>
		<revision author="Lord Zedd" version="5">thanks h5</revision>
	</revisions>
	<comment title="Global Timing" />
	<float32 name="Strike Delay Bounds min" offset="0x0" visible="true" />
    ...
	<tagblock name="Involuntary Data" offset="0x40" visible="true" elementSize="0x4">
		<int16 name="Involuntary Vocalization Index" offset="0x0" visible="true" />
		<int16 name="Unknown" offset="0x2" visible="false" />
	</tagblock>
</plugin>

Though, lets bring this back to ADI & Ch2r. Ch2r first few builds were quite a departure from what became the norm for map editors.

The builds rocked a calculator with basic add/subtraction, endian swap and a plethora of information that isolated around finding offsets and data to help with direct hex editing.

ADI was an upgraded version similar to the popular HHT (Halo Hacking Tools) for the original Halo. I don't believe ADI stands for anything - the author: The Swamp Fox just liked the ring to it.

Much like the other programs around at this time. The big deal was the plugin system which could read dynamic plugin files written for each of the many tag types. For example listed above is the Weapon tag looking at the SMG.

Moving onto to more editors we have to talk about Dark Matter, which was produced by pokecancer who also had his hands in Entity, H2X and H2G/H2C. It seemed pokecancer just kept making or helping with new tools that had one specific advantage over another. H2X for example excelled at the weird niche of model injection/viewing while Dark Matter specialized in recursive injection for the "snd!" tag (which was sound files).

Once one tool added support for something - prying eyes added the support to others.

In the case of Dark Matter - prying eyes weren't needed as pokecancer open sourced it in October of 2005 after losing the drive to work on the tool. My guess is that after intentionally rewriting it to C# didn't leave much effort remaining for the editor itself.

We can't talk about map editors without Insolence which any modder in the time would recognize as the only tool capable of tag injecting (via drag n drop). This of course over time would make it to other tools, but if you needed to fix SLC (System Link Compatibility) - chances are Isolence would be used.

tjc2k4 produced Insolence which can be traced back to a June 2005 release. This editor properly imported data from the single player shared map which basically prevented issues when importing and linking tags. It additionally packed an auto update system for plugins, but most modders only used Insolence for tag importing as it was known commonly to "break maps".

It was unfortunate for tjc2k4, but the era of open source and revision control wasn't thriving yet. A computer crash took down his computer and all the source code with it. Working with an old source copy that Aequitas provided he would go on to release Insolence Map Studio in November of 2005, but the project never really took off or stabilized.

We can continue to talk about editors like Halo Mutator which was the first mainstream Java application map editor. It came out in February of 2007 and had most of the features from all the previous editors in one tool plus some unique features like a built in FTP browser.

The language (Java) behind this editor was unique at the time as most of the tools discussed so far lived in the Microsoft world of Visual Basic and C#.

As the years moved on tools continued to be released and Profane was no exception. Created by Prey and released at the same time as Blu, Menu Menu Menu & Visual Scenery Mover. This was December 2006 and Profane was a map editor that was not even 50% complete, but it was built from scratch and didn't share any DLLs from any of the previous editors.

The tool resembled a bit of Entity but otherwise continued the trend of using Sandbar. While still a beta piece of software, the communication on pieces remaining to be done was very well communicated. Prey's builds of Profane frequently included a progress page of features remaining or completed.

Strangely only one of the tools a decade later that won't open on my Windows 10 machine due to complaining about a missing "Dark.Globals" reference.

Before we move onto more editors - we have to talk about how every editor discussed thus far worked by directly editing the .map file. The map file was a cached/compiled file - which a good example would be a compiled final JavaScript app.js file that may be been generated from hundreds of Typescript files. You can obviously painfully edit car.js in that state, but it would be much easier to edit like Hood.ts and Wheel.ts.

The map file was being mapped out, and as usual Iron_Forge released a good chunk of research in November of 2004. This is what led to the many tools we've talked about above. Though talented modders started thinking - what if we don't edit the map file directly?

This would mean disassembling the map into parts, modifying those and then rebuilding it back into a cached .map format. This would require understanding the entire format, but would open up modifications to new levels.

So now we enter H2C / H2G, which was H2Core & H2Guerilla. These tools were released by Anthony, Brok3n Halo & pokecancer and were very unique. The idea was that H2Core would disassemble a map file into meta files. Those meta files could be opened/edited within Guerilla and rebuilt into a .map.

This tool wasn't quite understood with the population with only a few tool authors understanding the complexity behind it. There were two versions of the tool passed around known as the 3-7-7 Release & 4-2-7 Release. If a mod was released with a BSP conversion - chances are H2C/H2G played a part.

For this next tool we have to turn the clock years later to 2009 when Grimdoomer was hinting at Mutation launching. It was a strange piece of software that had more forum threads and posts about progress than an actual binary. Once released it promised to basically be what H2C/H2G attempted to be with more stability.

The UI was the classic DevExpress toolkit of UI elements, but this software included wizards, a log of output/warnings and a good set of quality of life software enhancements. It could submit feedback and bugs as well which would have been perfect if the tool and community hadn't fallen to under 50 people.

The idea of the tool was similar to H2G/H2C - dissemble a map into pieces, edit those pieces within Mutation then compile them back into a .map file when ready. This editor (at launch) was slow, but granted you gave it a clean map file to start with - it worked. 10 years later using the editor - it only took 20 seconds to disassemble my map, but that would be expected with the increase in computer specs.

Bugs existed with shoving dirty map files at it, but with plenty of different tools that could have corrupted the .map file it would be difficult for Mutation to handle every map possible.

Many were excited for Mutation, but by the time it launched the crowd around Halo 2 was limited to just a handful of folks and it never truly got to shine. Though an impressive piece of software that a decade later could still be opened, decode Ascension and rebuild after some random tag changes.

Continuing this train of talking about unique map editors. We have to talk about Prometheus.

Prometheus was never actually released for the masses. A few builds might have gone to a few folks, but by the time the source was released onto GitHub by kornman00 we could finally see rewritten source of the mystic software rumored for years. However, it was a decade later so only those around during the original era would remember the occasional voice hinting at Prometheus.

Building Prometheus a decade later is a challenge for any, so our only remaining proof is the above screenshot from a personal beta build.

There were plenty of other map editors like:

• Excalibur by OwnZ joO (RTH Built in)
• Abide by Click16 (for RC builds of Halo2)
• Incompetence by Shalted (for Linux)
• Oxygen by bcnipod (for Mac)
• Sunfish by JacksonCougar (An attempt at disassembling/compiling)

However, the test of time has taken a toll on these with not much details to go on. With that, I'll end this deep dive into the Halo 2 era of .map editor programs. If I messed anything up or you can correct something I said - feel free to leave a comment or contact me. This is only the beginning - more Halo scene history blogs to come.