Most Liked Content

If you attended the Reach Modding Gamenight tonight, you probably noticed that we suddenly whipped out Longswords while playing Green World and surprised everyone. So it is time for me to come clean.

So on March 30th I began attempted to get something from shared.map to show up in forge_halo. After a few hours I managed to add the appropriate mode meta, but got a glitchy mess.


After finding something I forgot to copy over (Fixup Reflexives in the ZONE chunk), I got one step further and managed to get half the model to load.


I found that the model would show properly in Adjutant, but I couldn't figure out why it wasn't working right ingame.


And for anyone following in the Assembly chat on Skype, that was the last you heard of it. I had half a Longsword and was completely stumped. The discussion went on in another chat however.

That following night I decided that I was going to base an April Fool's joke around it.
I also figured out what was wrong; a dataref tucked away at the bottom of ZONE, which holds extra information about the raw asset. Sure enough, copying the correct data over fixed the model ingame.


The next logical step was to add the main textures over, using the same process as the model. A few hours later and...



From here, everyone in the chat planned out the prank.
When the idea first came up the plan was to post a few fakes mixed in with a legit pic, then fully announce everything at the end of the day.
We eventually settled on all fake pics and an overall fake post, simply closing the thread at the end of the day and treat everything as a joke. The twist, being, however, that the Longswords photoshopped in were cut out of pictures of them already on Forge world.


For the payoff, it was decided that we do it during a gamenight. The gamenight would have certainly come much, much sooner than the 2 weeks it became, but there were schedule issues and it got set back as an unfortunate result. Over the course of the past 2 weeks I made it into a vehicle and running effects, which were later improved by deadcanadian. We chose the best course of action was to patch the Lonsword into Green World to conceal it the best we could. The patch was finalized Wednesday Night and was uploaded to the site along with the other patch choices on Thursday.


What remained was an anxious and neverous wait until this very moment. We had to cross our fingers that nobody would snoop and spoil the surprise, and apparently nobody did. So thanks for that.


-

So here we are now, taking another step into bringing life back into Halo Modding.
And in case you were wondering: Yes, we hope to add Tag Injection to Assembly's ever-expanding list of features in the near future. Until then, however, a tutorial will be written in the coming days for those who with to go about it themselves.

It feels great to finally let this announcement out legitimately, and I deeply apologize if keeping this secret until now has for any reason offended you.

Alright, so here's the tutorial a lot of you have been waiting for.
Going to also be honest with you in saying that there aren't many "treasures" to be pulled from shared.map, so there may not be as many practical multiplayer applications of this tutorial as one would like until loading from campaign.map in MP can be figured out.

It should also be noted that this tutorial should work on any Halo game running on the 3rd Generation Blam Engine, though may require some tweaks depending on ZONE and PLAY layout differences.

What you will need:

• Assembly (with Updated Plugins, posted in conjunction with this tutorial)
• Time
• Hex Editor
• Time
• Patience
• Time
• MapExpand - Powered by Blamite (Not the original one)
• Also, Time
• Turning on Invisibles in Assembly is also necessary. You don't want to accidentally miss something like Gamecheat did, now would you?

Outline:

1. Deciding on the asset(s) to add.
2. Destination Map Planning.
3. Rearranging ZONE and PLAY data based on plans.
4. Filling in new chunks. - PLAY
5. Filling in new chunks and data. - ZONE
6. Filling in new tag data and the like.

1. Deciding On The Asset

When deciding on an asset, you must consider the destination map you plan on using and what kind of map it is/its limits.

Multiplayer Maps:
mainmenu.map - YES
shared.map - YES
campaign.map - NO

Eeeeeverything Else:
mainmenu.map - YES
shared.map - YES
campaign.map - YES

As you can see, and as is mentioned at the beginning of this post, Multiplayer maps are at a bit of a disadvantage in that they cannot (currently?) load from campaign.map, where admittedly a lot of the "goods" are.
Even further, a map like Forge World already contains a lot of what shared.map has to offer, having all the standard vehicles and weapons inside.

Aside from these things, shared.map is (currently) known to contain the following extras:
Longsword
Phantom

So yeah, not that interesting of a list, though there very well could be more out there. It just requires some looking into.

How would you go about looking into it, you ask? Why, AMD's Extraction Tutorial, of course! Parts 2 and 3, specifically, will help you navigate to an asset's Raw Page to check the Shared Cache Index (typo's been fixed, lol).
In fact, just read through his entire post. It really helps in understanding what is going on in this tutorial, plus it is less I have to explain here )

Another thing to account for is how intricate the object itself is tag-wise.
Thumb through the tags that make up your object and ask yourself how much of that you can tolerate fixing/adding manually, because you'll be linked to My Tag Duplication Tutorial for the final step, and fixing the tag data between maps is the hardest part of this tutorial, in my opinion.
So go ahead and pre-emptively read through that post too, if you already haven't.

The above information should help you decide on what asset(s) to add. If you just got scared off, don't worry, as Assembly should be able to automate this entire procedure in the future.

2. Planning Out Your Destination Map

With your asset(s) picked out, we need to grab the sizes of various blocks of data in ZONE and PLAY. In conjunction with MapExpand we will need to plan out just where these blocks are going to be duplicated so we can safely add new chunks to them. The following things need to be sized up:

Raw Pages Reflexive [play]
Segments Reflexive [play]
Tag Resources Reflexive [zone]
Global Zoneset's Required Raw Pool [zone]
Global Zoneset's Required Tag Pool [zone]
Information DataRef [zone]

-For reflexives, you can get the size by expanding the Information dropdown and multiplying the Count and Entry Size values together, then for the sake of this tutorial, converting the result into Hexadecimal.

-For the dataref, you can right click the name and choose "View Value As..." From there you can scroll until you find the UInt32 example. That will be your size. Convert that to Hexadecimal as well.

*If you are on Windows 7 or above, you can convert to hexadecimal with the Windows Calculator by setting it to "Programmer" mode via View>Programmer or the hotkey Alt+3.
It automatically starts in Decimal so paste in your number and click the Hex radio button to change it to Hexadecimal.

With the sizes, it is time to figure out just how to lay it all out.

These are the final sizes for a clean forge_halo.map, which will be used for example: (leading 0s added to be tidy)
x0005EC48 Raw Pages
x00019AB0 Segments
x0006A000 Tag Resources
x00000350 Required Raw Pool
x000005F4 Required Tag Pool
x001BF42C Information

So in forge_halo's case, you can get away with only expanding enough to house the new information dataref, relocating the others to information's original location with generous spacing for further expansion. This will leave you their original locations to use for tag data, and another block at the end of the old information.

Time to start editing the map. We will start by running MapExpand on it to get the space we need.
Copy the map to MapExpand's directory and then run the program from the command prompt. You can either navigate your way there, or if you have the MapExpand folder on your Desktop, you can hold Shift and Right Click to get a slightly different context menu that includes an "Open Command Window Here" option.

MapExpand works via the following command:

mapexpand mapname.map #

mapname.map is the filename of your map, and # is the number of new data "pages" you want to add in decimal.
Each "page" is x00010000 bytes long, making your input a multiple of that.
Since I am sticking to my above plan, I only want to expand enough to fit a new information dataref.
It's current size is just under x1C (28 decimal) pages. Using x1C will not allow for much expansion, so I'm going to go 1 more with x1D (29 decimal).

So, for this tutorial, the map is forge_halo.map and the number of pages will be 29. After running MapExpand you'll want to make note of a couple things before you close the window:


Before we move however we need to grab the original locations of everything for both future reference and so we can move everything in one go. I didn't ask to grab these before because using MapExpand would make all the file offsets incorrect (Memory Offset would not change though)

To be thorough, we will grab both the file and memory offsets of everything.

For the reflexives, you can expand the Information dropdown to get the memory offset, and right click the FIRST VALUE of the FIRST CHUNK (CHUNK 0) and choose View Value As to get the file offset, which will be at the top of the new window.


For the dataref you need to do some conversion. Right click the dataref and View Value As again like you did for the size, but now scroll down to the Raw Examples. At 24 characters in/12 bytes, the following 8 characters/4 bytes are your memory offset. Note that down.


In the main Assembly window, Click "Map Information" and double click the "Map Magic" value. Note that down too.


Now do the following math:
Dataref Memory Offset - Map Magic
The result will be your file offset. Note that down.

These are the final offsets for a forge_halo.map expanded by 29 pages, which will be used for example:
FILE (MEMORY)
x05EC1220 (xBE0D0220) Raw Pages
x05F3E230 (xBE14D230) Segments
x05FF701C (xBE20601C) Tag Resources
x0606101C (xBE45E370) Required Raw Pool
x06061ACC (xBE45F370) Required Tag Pool
x0613CC80 (xBE34BC80) Information

3. Rearranging

First thing to do is get that dataref relocated. So open your expanded map in a hex editor (Do I even have to tell you to make backups?) and jump to the file offset for the Information data.

From here, use your editor's select block tool to select the entire dataref via the size you got. Copy and paste into a new document for safe keeping.


With the data safe in a new file, jump to the file offset mapexpand gave you and select another block there of the same size. Go to your new file, select all, copy it again, then go back to the map tab while everything is still selected and paste.

Due to the large amount of data being pasted in, your hex editor may say something about the undo-buffer; just hit OK and continue on.

At this point be sure to note down the new information offsets, close out the extra file you made to store the data, then save the map.

Let's do it again. But first, let's 0-out the original information data so we don't get confused. Head back to that offset, select the block again, but this time use the fill tool to fill the selection with 0s. Again ignoring any potential buffer messages.


And if you want to be extra careful, you can type something over the last few bytes that you just filled, like so:


Save again and jump to the Raw Pages file offset. And as you did with information data, select the entire block using your size, and paste into another file.

In the map tab jump to your newly-blank old information offset and again, select the size of the data you just copied. Go back to your storage file and copy everything, then paste over your map selection. Not even gonna mention undo buffer messages from here on out, you know what to do with them.

But unlike the information data, we are going to add an extra step here.

Upon pasting your data, your cursor should be at the end of the data. If so, then open up the jump/goto dialog and change the starting point to the current position. Now, the value you choose is up to you, and you should also be conscious of the other 2 blocks of data you will be adding in. For this example, x10000 is more than generous and will work fine.


Note exactly where you landed, or for tidiness you can jump to the beginning of the current row.


Noted? Good, because that's where we will be putting the next block of data, using the exact same procedure you've done twice now. Yay!

Jump to the Segments file offset. (FYI you are totally still in current position mode instead of from the beginning, so change that back before you embarrass yourself)

Copy the size, paste in a new file, jump to that Offset you just noted down before, select size, and paste over.

Jump forward from the end to another point. (I'm using x10000 again) And note that location, or the beginning of that row, whatever.

Again! Go to Tag Resources offset, select and copy, paste to new file, go to the fresh offset, select and paste. Jump ahead another whatever (x10000 again for me) and note down the point/beginning of the row.

Again! Go to Raw Pool offset, select and copy, paste to new file, go to the fresh offset, select and paste. Being much smaller than the others, we are going to jump forward a smaller amount (x1000 here). For my example I am jumping x1000 from where this data starts, rather than from the end of it like we've been doing. After doing so, note down the offset.

Once More! Go to Tag Pool offset, select and copy, paste to new file, go to the fresh offset, select and paste. This is also getting the same jump treatment as Raw Pool, so do that and note the offset. (I'm adding x1000 from the start again)

From this offset onward, this is free space to use for whatever. Note it down as such. Give another save and let's 0 out the original locations of those reflexives so they can be free space, too. We also need to math up the memory offset for those relocated ones.

Jump to the original pages offset, select the size, and fill with 0s.

Jump to the original segments offset, select the size, and fill with 0s.

Jump to the original resources offset, select the size, and fill with 0s.

Jump to the original raw pool offset, select the size, and fill with 0s.

Jump to the original tag pool offset, select the size, and fill with 0s.

Save again. You can now close the hex editor for now if you want, though we will be returning to it.

3 and a half. Fixing the mess you just made.

This is how our offsets look now:
name file offset (memory offset), size
new info x5CF1000 (xBDF00000)
new pages x613CC80 (xBE34BC80)
new segments x61AB8C0 (?)
new resources x61D5370 (?)
new raw x624F370 (?)
new tag x6250370 (?)
free space 1 x6251370 (?), ?
free space 2 x5EC1220 (xBE0D0220), x5EC48
free space 3 x5F3E230 (xBE14D230), x19AB0
free space 4 x5FF701C (xBE20601C), x6A000

There are a few ? that need filling in, so let's begin finding those.
For the memory offsets, those are simple. Remember how you got the dataref file offset? Now do that in reverse. That is;
File Offset + Map Magic = Memory Offset.

Do that for the first 3 ?s and...
name file offset (memory offset), size
new info x5CF1000 (xBDF00000)
new pages x613CC80 (xBE34BC80)
new segments x61AB8C0 (xBE3BA8C0)
new resources x61D5370 (xBE3E4370)
new raw x624F370 (xBE45E370)
new tag x6250370 (xBE45F370)
free space 1 x6251370 (xBE460370), ?
free space 2 x5EC1220 (xBE0D0220), x5EC48
free space 3 x5F3E230 (xBE14D230), x19AB0
free space 4 x5FF701C (xBE20601C), x6A000

This leaves us with finding the remainder of the old information data. We can figure that out with our notes, as such:

free space offset - beginning offset of old info = starting location of free space.
Now,
old info size - starting location of free space = size of free space.

Which gives us...
name file offset (memory offset), size
new info x5CF1000 (xBDF00000)
new pages x613CC80 (xBE34BC80)
new segments x61AB8C0 (xBE3BA8C0)
new resources x61D5370 (xBE3E4370)
new raw x624F370 (xBE45E370)
new tag x6250370 (xBE45F370)
free space 1 x6251370 (xBE460370), xAAD3C
free space 2 x5EC1220 (xBE0D0220), x5EC48
free space 3 x5F3E230 (xBE14D230), x19AB0
free space 4 x5FF701C (xBE20601C), x6A000

Great!

Now lets open up the map in Assembly so we can assign these new memory offsets.

Starting with PLAY, scroll down to Raw Pages and notice that everything is 0s now. To fix, Expand the Information dropdown and paste in your relocated offset. Upon clicking off the textbox everything should go back to normal.

Repeat for Segments and hit save. Open up ZONE.

Do the same for Tag Resources, Global Zoneset's Required Raw and Tag Pools, then the datare... Oops, Assembly cannot edit sizes and offsets of datarefs directly as of this writing, so back to the hex editor we go!

But first, hit save to save the update the other reflexives, then right click that dataref name and view value as. This time you are after the file offset you see at the top. This is the file offset for the actual dataref pointer. Note it down and close the map from Assembly.

Open the map in your hex editor and jump to your newly found file offset.
A Dataref is laid out as follows:


What we want to edit right now is that memory offset. Select the old, and paste the new one over it. Save and close, then check it in Assembly.

Now everything is safely relocated so you can...

4. Fill in new PLAY chunks

Now that everything is re-arranged and ready to have chunks added, we are going to do just that. This guide is going to become more disconnected depending on what you are adding, so I'll just go over this one single asset, and you can repeat as needed, k?

So let's get the Longsword model into our example forge_halo.

Starting with Raw Pages, expand the Information dropdown and add 1 to the Count value. Navigate to your new, blank chunk at the end. Note down the chunk while you are at it.

You are going to fill in your new Raw Pages chunk to match the one from the source map 100%. No exceptions. Then save.

Now add 1 to Segment's Count. Set the Required Page Index to the chunk you just made in Raw Pages, and use the same Required Segment Offset as the source map.
If your asset is a bitmap/uses the Optional values, you will need to add 1 more to your Raw Pages count and match the source's Optional page 100% as well, then set the Optional Index to that extra chunk. Save once more and PLAY is filled out! Note your new Segment chunk and head over to ZONE.

5. Fill in new ZONE chunks

Scroll down to Tag Resources and match everything from the original EXCEPT "Fixup Information Offset" and "Optional Fixup Information Offset" (Unless the Optional one is -1, which is okay to copy.) Since we haven't added any tags, leave the tag reference null, too.
This includes the 2 Fixup Reflexives. To do those, let's take one of our free space memory offsets and give it to "Resource Fixups" and set the count to match the source map. Now fill in each chunk. If there are 10+ chunks, you could also: (In spoiler)

After the Resource Fixups is filled in, get the size of it using Count * Entry Size again and convert the answer to hex. Add that result to the memory offset you used, and give it to "Resource Definition Fixups" and follow the same procedure. Then get the size, convert to hex, add to the used memory offset, and note it down. Feel free to add both sizes to the file offset too. Save.

Time for the pools.

As was recently (finally) figured out, turns out pools work by assigning each asset and tag 1 bit, and grouping them in groups of 32 for the reflexive. We are editing the Global Zoneset so that our new content will be always loaded no matter what, making it easier to access ingame. We also have to do this anyway or all this new stuff won't even load.
So first we need to figure out if we even need to add any chunks or if we can get away with using existing extras due to the 32 bit groupings.

To find this out for the Required Raw Pool, take the total number of chunks for "Tag References", which will be in parenthesis after the #-# in the dropdown, and divide by 32. All decimal. It may help to switch out of Programmer mode so Windows Calculator doesn't round up/down on you.

So basically, if the result on the calculator is GREATER than the Raw Pool's chunk count by any amount, then you need to add one chunk.
If the result is by any amount LESS than the chunk count, add a chunk anyway to be safe

Once you have added your chunk, to be lazy, tick everything in both your new chunk and the one before it. Everything. Now you are safe from touching this again for 32 Tag Resource chunks! Neat!

For the Required Tag Pool, we are going to have to open our map in a hex editor again and go to the offset x2B4. The next 4 bytes make up the tag count. So select them copy them into Windows Calculator or whatever to view the bytes as decimal. In Hex Workshop you just select them;


Like Raw Pools above, divide that value by 32 and act appropriately. Same thing. Save again.

One last beast to tame in ZONE, which is the Fixup Information. This again cannot be modified in Assembly so make sure all is saved and close your map out of Assembly. Open your source map in Assembly if it wasn't already open, and go to the original Tag Resources chunk for your asset, then note down the Information Offset, Information Length, and Optional Offset (if applicable). Then scroll down to the source map's Fixup Information dataref and grab the file offset for its data. You remember how from the beginning of this tut, don't you?

Once grabbed, open both your source map and destination map in the hex editor. Take the offset(s) you got from the Tag Resources chunk and convert them into hex. Add the first to the dataref's offset and in the SOURCE map, go to the resulting offset. Select the length you got (Convert to hex, too) and copy to a new file. If there's an optional offset, take the converted offset from earlier and add THAT to the dataref offset this time and go to it. Copy the same length and paste in another new file. Go to your destination map.

Add the destination map's dataref size to its offset and jump to the result to quickly get to the end. Where you landed, select the length of the first information data you copied a minute ago, go to the first file you made that has the data, select all, copy, and paste over your selection in the destination. If an Optional exists, repeat the same from the end of that paste with the second new file and save.

Jump to the dataref location that we were at earlier to fix the memory offset so we can fix the size now.


As you can see, you should be right on the size, so take your hex-converted Information Length, and add it to the size. Note down the result. If Optional, add it again, noting the result again. Save once more and close the hex editor.

Open the destination map into Assembly again and go to your new Tag Resources chunk. Now we can fill in our offsets. The main Information offset will be equal to the original Information size, so convert it back to decimal and paste it in. For Optional, use the first size you noted when added the data a second ago. If no optional, the size you noted will be where your next data will be for future assets. If optional, the second noted size will be that offset. Save a final time and get ready...

6. Filling in dat tag data.

...For me to refer you to My Tag Duplication Tutorial! It was written with Ascension in mind, but if you've made it this far, you should be savvy enough to translate.
Sorry for this dickish last step, but seeing as I promised this tutorial almost a week ago, I figured everything above is the real injection portions. If you have any questions about translating the Duplication tutorial, post them in THIS thread.

Some things to note on your tag data journey:

• StringIDs will likely be wrong after porting. If you find your destination map lacks a particular string, don't fret. Find a similar substitute and remember to use that. Alternatively, you could just leave the stringIDS as they are after porting as anything else you port will match where necessary, which is what StringIDs are all about anyway.
• Some things CAN be winged, such as ignoring model markers and only porting ones you need to save time. Use it to your advantage.
• Don't forget to update the [zone] Asset Index value to point to the right Tag Resources chunk, and fix that tag reference in the chunk I told you to leave before!

And that's it!
Please don't hesitate to ask whatever you need to down below. I'll be happy to help.

After eight months of development, we are proud to announce the first stable release of Assembly, a 100% open-source Blam/Halo research tool and map editor. It enables users to both research how the Halo games work and also share creative modifications that are made. Assembly was built from the ground up with four goals in mind:

• Flexibility - Assembly is capable of seamlessly opening and editing .map, .mapinfo, and .blf files from Halo 2: Vista, Halo 3, Halo 3: ODST, Halo: Reach, and Halo 4, with support for more games coming soon.
• Speed - Spend more time modding and less time waiting for trivial tasks to complete. Even the largest tags load extremely quickly with invisible fields enabled, and search and autocomplete features throughout the program allow you to find what you need quickly
• Usability - We built Assembly using Windows Presentation Foundation and utilized modern UI design concepts. Thus, assembly is both easy to use and easy to look at.
• Customizability - Don't like the default blue look? Select from one of four different UI themes. Don't like how the View Value As tool is laid out? Make your own meta editor plugin for it. Almost everything in Assembly can be customized in some way. Not to mention that the source code is freely available on GitHub to give you even more control.

Supported Features:

• Beta versions of games are supported
• Patch compatibility from Alteration and Ascension
• Patches can contain name, author, description, and target map information
• Voxel converter for creating custom Halo 4 loading screens
• Plugin generator
• Plugin editor with syntax highlighting code completion
• Plugin converter for converting Ascension and Alteration plugins to the new format
• Add support for other similar builds on the fly with XML
• "Xbox Memory" sidebar for controlling your console and taking screenshots
• Automatic update system

Maps:

• Tagnames decrypted for all games
• StringIDs decrypted for all games
• BlamScript decompilation for Reach (soon to be all games)
• Locale viewing and editing, with special characters (e.g. button icons) replaced with XML tags
• Meta data viewing, editing, and searching
• Meta data "View Value as" window

BLF:

• Extract existing images
• Inject new images

MapInfo:

• Edit map ID
• Edit map internal name
• Edit map external name and description

Screenshots:



Assembly was brought to you by:

• AMD
• Xerax
• Thunder/Dovahkiin
• Lord Zedd
• DeadCanadian
• SnipeStyle
• gabe_k

With special thanks to:

• Xenomega (Xenon.7/Detox)
• Kornman00
• CLK
• DarkShallFall
• Prey
• Shade45
• Anthony
• KingDingDan
• XenonDev
• Gravemind

Finally, we also want to thank all who have been a part of research in the Halo scene over the past decade. Without your work, none of this would have been possible.

Here's to the next ten years.

Download from SourceForge
Get the Source Code

So after a lot of solo research, I, Lord Zedd, have become the first person to finally crack Tag Injection for the 3rd Generation Blam Engine.


While I'd much rather the information be open to the community, as that's the only way to ensure these sort of things will be continuously developed, via a community effort, I feel, however, that I must charge for the method. While you can argue about the morality of holding tag injection ransom, I must be firm on this.


Therefore, I am asking $1000.00 in unmarked, American bills to release the method. Once you purchase you are free to do as you wish with it; you could take the information, promise to make a tool, and then wait a year to release as to hype the newest version of your AIO software. You could also give it out publicly or something, I guess, but after a $1000 investment, probably not.


I'm sorry about having go this route, but this is the only way. To just give out the method would be a waste of my time otherwise. Maybe I'll release it someday, but compiling this information for the public wouldn't happen overnight, and I've got things like Assembly plugins to tend to still.

~Lord Zedd, the first person to do this.

Adding Tags:

Requirements: MapExpand (Blamite Edition)
Part A: Prep
Before you can do anything anything, you need to make some room in the map for the new tag's meta.
Copy mapexpand to the folder with your map and run it from the command prompt as follows:

mapexpand forge_halo.map 1

(You can substitute for any map (forge world here) or more blank meta pages (1 here), but you can always add more pages later.)


Once mapexpand does its thing, you'll want to make note of the two offsets it gives you (highlighted)
Blue is the memory offset which we will be plugging into the tag list when we add the tag, and Red is the file offset where the blank meta actually starts, which we will need soon as well.
Now we need to actually add the tag to the tag list so we can start filling meta in.

**Be aware that once you use mapexpand on a map, the header is changed enough to where a standard xex with only RSA bypassed will not load your map anymore. Patch your xex with any of the patches from the following download and it should work: http://www.xboxchaos...ex-ppf-patches/ **

Part B: Adding
Pop open your expanded map in a hex editor and do a hex search for "00726D63726D2020" to jump right to the end of the map's tag list.


Now click right before the selection and add 8 bytes right there. This will give you a blank entry to fill in.





Those 8 bytes you added will break up as follows:
int16 Class Index
int16 Datum Index Salt
int32 Memory Address (File Offset + Map Magic)

So let's start with the first 2 bytes, or the Class Index. Refer to the following list to decide what value you are putting in:

Next 2 bytes is the Datum Salt, which doesn't really affect anything, but needs to be a value NOT x0000 or xFFFF.

For the last 4 bytes, the memory offset, you'll want to enter the memory offset mapexpand gave you (the Blue one above).

For an example, here is what adding a new LIGH tag would look like:


Part C: Cleanup
Next we have to remove 8 bytes from somewhere else so that everything lines up to counter the 8 you added. Luckily, there is an abundance of 00 bytes beyond the class list, so scroll down until you see the text "tags" and select any 8 bytes after it and hit delete on your keyboard.


In addition, we also have to adjust a few things to accommodate for the new tag entry. While we are here, let's take care of the 2 values located just above where we deleted the 8 bytes.

Go to the byte after the last group of FFs and jump 8 more. This should take you to the Class Index Address...


...Which we'll need to add x8 to, since we added 8 bytes for the 1 entry.


This should leave you just after that address, which is the Tag Count. Add x1 to it for 1 tag.


Looking good. Last things to fix are in the map's header, so go to the offset 0x10 to see a familiar value.


Like before, add x8 for the new entry.
Now head to the offset x2B4 for another familiar face.


Also like before, add x1 for the new entry. And Save.

--
--
--

Congratulations! You have added a tag! Only thing left now is to add meta for it!

Filling in the meta:
To make this easy, let's just copy and paste the meta of an existing tag and modify it from there with a map editor. Here's how you would go about that:

Part A: Copy/Pasting the main meta
With your modified map still open in the hex editor, pop the original map in Ascension and open the tag you are duplicating. In the "Tag Information" box, right click the offset and copy the value.


Paste the offset elsewhere for safe keeping and head to the "Plugin" tab in the meta editor. Make note of the value given for "headersize" in the first line. Hopefully, the given size will be correct. If it seems very large, please post in this topic and I will help you out. (Apologies in advance if there are errors) Once you've got the offset and size, minimize Ascension.


Open the hex editor back up and go to the offset mapexpand gave you in the modified map. (the Red one above).


Now open the original map in the hex editor alongside the modified one and go to the offset you copied in it.


From that position, select (as decimal) the size you got from the Plugin. Copy the selection. Return to the modified map.


From the position you went to with the map expand offset, select the same amount of bytes as you copied and paste. Save and exit.


If you've been following this tutorial correctly, you should now be able to open your map in Ascension and go to your new tag without any problems.


You're almost done. At this point the only thing left is to copy reflexives and datarefs and point the main meta to them.

Part B: Copy/Pasting the other meta
There is likely to be more than one reflexive/dataref in your meta, so I'll just outline one of both and you can repeat the process if necessary.
Part B.1: Reflexives
The easier of the two. Since lights don't have reflexive's I'll use the Spartan's attachments reflexive.


There are 3 things in the reflexive layout that you need to note; The size, the count, and the offset.
The offset is fine how it is, but you'll want to multiply the size and count together and save the result, that is how much you'll be copying. Close the map out of Ascension and open the map in a hex editor again.

Head to the offset you got, which will be in decimal format and select the entirety of the reflexive using the number you got from multiplying (decimal as well)


Copy and paste that into a new file for safe keeping. Go back to the file offset from map expand to get back to your blank meta.

Take a look at the hex and find where the first meta you copied ends, then to be safe jump to the next offset ending in x00. In my example map, that would be offset x5CF1100. Make note of this offset.


Select the size of the amount you copied, copy the meta from the spare file you made and paste it in to the blank area you selected. Save and exit, you're done in hex.


Open the map in Ascension and go back to your tag/reflexive.


And fill in the new offset. You'll have to convert it to decimal first, which you could do via the Windows Calulator and changing the mode to programmer via the View menu or pressing Alt+3. Tick the Hex radio button and paste in your offset, then click decimal and copy the result. Easy.


Take that number and plug it into the Offset box and hit the Save button next to it. If you did it right you'll notice no change at all. You just duplicated a reflexive!

Part B.2: Tagdata/Datarefs
Datarefs are no different than reflexives, except that you'll be replacing the memory offset using a hex editor.
Go to your tag and right click the dataref you'll be copying and choose "Display Information". Only worry about the size and file offset that spits out.


Make a note of that then go to the "Info" tab so we can grab the map magic. Copy that somewhere safe and close the map.


Back in the hex editor we go, this time going to the offset of the dataref's reference. We'll have to do some more math before we get to the offset of the actual data. Once there, make note of the 4 bytes directly in front, which is the size, then jump ahead x0C/12 bytes more to get to the memory offset of the data and copy it.


Paste that into the Windows Calcluator you set up in the reflexive part above with the Hex option ticked. Now subtract the map magic from it and copy the result elsewhere. Then jump there in the hex editor.


At that offset, select the amount you got from the size (Hex) and paste it into a new file. Go back to the file offset from map expand to get back to your blank meta.

Take a look at the hex and find where the meta you copied ends, then to be safe jump to the next offset ending in x00. In my example map, that would be offset x5CF1200. Make note of this offset, you'll be adding maths to it soon.


Select the size of the amount you copied, copy the meta from the spare file you made and paste it in to the blank area you selected. Almost done.

Go to the tagdata reference offset you got from Ascension again and jump x0C/12 bytes more again to the memory offset.

Open the Calculator back up and paste in the offset you pasted the data to (Hex), now ADD the map magic to it. Copy the result.


Paste the result over the old memory offset and Save. You're done!


Opening back in Ascension one last time to check your work, you should see a valid dataref still. If so, then you just duplicated a dataref!

Getting Duplicated Objects Working
If you are duplicating an object, it will not load ingame until you modify the global object pool to allow for it. If you are not duplicating an object, you should be okay skipping this step.
 

Make sure your plugins are updated!

 

Open the ZONE tag in your modified map.
Scroll until you see the "Global Pool" reflexive, then the "Objects" reflexive inside it. (Invisibles are OFF in the following pic)


The fix is very simple; jump to the last chunk in "Objects", set the value to -1 and save. Simple as that.


What remains is referencing your new tag wherever you plan on implementing it, but I'm sure you know how to do that.

MP:
ca_blood_cavern - Abandon
ca_blood_crash - Exile
ca_canyon - Meltdown
ca_forge_bonanza - Impact
ca_forge_erosion - Erosion
ca_forge_ravine - Ravine
ca_gore_valley - Longbow
ca_redoubt - Vortex
ca_tower - Solace
ca_warhouse - Adrift
wraparound - Haven
z05_cliffside - Complex
z11_valhalla - Ragnarok

Crimson Map Pack
dlc_dejewel - Shatter
dlc_dejunkyard - Wreckage
zd_02_grind - Harvest

 

Majestic Map Pack

ca_deadlycrossing - Monolith

ca_port - Landfall

ca_rattler - Skyline

 

Castle Map Pack

ca_basin - Outcast

ca_highrise - Perdition

ca_spiderweb - Daybreak

SO 1.0:
ff81_courtyard - The Gate
ff82_scurve - The Cauldron
ff84_temple - The Refuge
ff86_sniperalley - Sniper Alley
ff87_chopperbowl - Quarry
ff90_fortsw - Fortress
ff91_complex - Galileo Base
ff92_valhalla - Two Giants

SO 1.5:
dlc01_engine - Infinity
dlc01_facory - Lockup
ff151_mezzanine - Control
ff152_vortex - Cyclone
ff153_caverns - Warrens
ff154_hillside - Apex
ff155_breach - Harvester

SP:
m05_prologue - Prologue
m10_crash - Dawn
m020 - Requiem
m30_cryptum - Forerunner
m60_rescue - Infinity (switched around)
m40_invasion - Reclaimer (switched around)
m70_liftoff - Shutdown
m80_delta - Composer
m90_sacrifice - Midnight
m95_epilogue - Epilogue

meep

 

EDIT: Gotta say, that post was brilliant.

 

alright guys i think i'm onto something i opened the map in word and pasted in this pic of a spartan modle. i tried to load the map into the game and it showed in the menu but said it was invalid. so i think we're onto something here at least it's a start. any news is good news right.

 

Awesome work.

And as Zedd said, Assembly will be able to automate this to the point where you only have to click a few buttons, so if you can't understand this tutorial or don't have enough time, you won't be left out. This can only get more complicated too as we figure out how to inject non-shared resources or resources from campaign.map.

EDIT: Something I'm not sure you mentioned is that the information data ref in zone HAS to be aligned on a 16-byte boundary (i.e. its offset in hex must end with a 0) or else it'll cause problems with the BSP and impostor models. It worked out anyway in this case but it's something that needs to be paid attention to.

i am the first person to do this

 

 

........

 

 

Basically what happened I guess...

 

Lo

Lol I keed nice work Zedd

My expanded gametype settings menu:

Appearance Traits:


New Weapon Traits Sub Menu: (Game caps the option list at 16, couldn't find a way to remove so I made a submenu)


Movement Traits:


Flood Loadouts (Have to poke the goof reference since the game doesn't like adding things to root menus)


Reference list of each trait menu:

HEALTH:
01 - damage resistance
02 - shield multiplier
03 - body multiplier
04 - shield stun duration
05 - shield recharge rate
06 - body recharge rate
07 - overshield recharge
08 - vampirism percent
09 - explosive damage resistance
10 - wheelman armor vehicle stun time modifier
11 - wheelman armor vehicle recharge time modifier
12 - wheelman armor vehicle emp disabled time modifier
13 - headshot immunity
14 - assassination immunity
15 - deathless

WEAPON/DAMAGE:
>01 - grenade recharge seconds frag
>02 - grenade recharge seconds plasma
>03 - grenade recharge seconds spike
>04 - switch speed modifier
>05 - reload speed modifier
>06 - ordnance points modifier
>07 - explosive area of effect radius modifier
>08 - gunner armor modifier
>09 - stability armor modifier
>10 - drop recon warning seconds
>11 - drop recon distance modifier
>12 - assassination speed modifier
01 - damage multiplier
02 - melee damage multiplier
03 - weapon pickup allowed
04 - initial grenade count
05 - infinite ammo
06 - initial primary weapon
07 - initial secondary weapon
08 - weapons ammopack
09 - weapons grenadier
10 - weapons explode on death armormod
11 - ordnance markers visible
12 - weapons ordnance reroll available
13 - weapons resourceful
14 - weapons well equipped
15 - ordnance disabled

EQUIPMENT:
>01 - hero equipment energy use rate modifier
>02 - hero equipment energy recharge delay modifier
>03 - hero equipment energy recharge rate modifier
>04 - hero equipment initial energy modifier
>05 - equipment energy use rate modifier
>06 - equipment energy recharge delay modifier
>07 - equipment energy use recharge rate modifier
>08 - equipment energy initial energy modifier
>09 - directional damage indicator
>10 - vision mode
>11 - battle awareness
>12 - threat view
>13 - aural enhancement
>14 - nemesis
01 - fast track armor
02 - powerup cancellation
03 - equipment usage
04 - equipment usage excepting auto turret
05 - equipment drop
06 - infinite equipment
07 - initial equipment
08 - initial tactical package
09 - initial support upgrade
10 - motion tracker range
11 - nemesis duration
12 - motion tracker
13 - motion tracker while zoomed

MOVEMENT:
01 - fall damage multiplier
02 - speed
03 - gravity multiplier
04 - jump multiplier
05 - turn speed multiplier
06 - vehicle usage
07 - double jump
08 - sprint usage
09 - automatic momentum usage
10 - vaulting enabled
11 - stealthy

APPEARANCE:
01 - player scale
02 - active camo
03 - waypoint
04 - gamertag visible
05 - aura
06 - death effect
07 - looping effect
08 - shield hud

So, The title of this thread is Videos/Screenshots of your mods. So I figured this fits in here lol.
Sure it may not be a game mods, but pfff. Didn't say anything about it had to be game mods lol.

So anyways, here we go.
So I had this stormtrooper helmet sitting in closet for a while, just collecting dust. I also had a PC mic that was falling apart. So I had a thought, why not combine them?? Why you may ask? Well simple. Its beast as fuck. Who wouldn't want to?
After few thought of how I would do it and not go too complex into it, I got started.

Here are the pics;







In person the LEDs look soo much better and not retarded.
I also modified the LEDS to blink when ever spoken into or played any track, Even the buttons which plays some commands will make the LEDs blink.
So now, I can webcam in style lol.
I still have to work on the padding, but for now this works pretty well.

Over the past few day's I've been working on Halo 3 Sound Extraction (should work in other games, if the plugins are mapped out). Now I've hit a point I'm stuck at, so let's hold hands and do it together! I'll post all the research/progress I've made below.

Special Thanks:
Gravemind.


Stage 1: Raw Table Resource Allocation
In any snd! tag, there is a DatumIndex (int32) labelled as the Raw ID or Raw Identifier. This is used to find the data of the object in the raw table. This thread really isn't to do with how the Raw Table works, so let's just skip over that for now.
 
Stage 2: Extract Sound from Raw Table
The Raw table is split between a Primary Page and a Secondary Page. If there is content in both Pages, you need to concatenate the second page on to the end of the first page.
  
​Stage 3: Get Playback Index
In a snd! tag, there is an int16 called Playback Index, this relates to finding sound data in the `sound_cache_file_gestalt`.
  
Stage 4: Get the Permutation Data
In the ugh! class, there is 1 tag, the `i've got a lovely bunch of coconuts`, this contains everything we need to extract permutations from raw sound sections. Go to the index in the `Playback` reflexive that we got in the previous stage, and get the uint16 `First Permutation`, and the  int16 `Encoded Permutation Data` (this is encoded and you need to do this to it to get it to be a readable number, (value >> 4) & 63). Now go to the index of the `Sound Permutations` table we got from `First Permutation`, and the next n entries are also permutations from the same sound (n being the number we decoded from `Encoded Permutation Data`. 
  
Stage 5: Get the Raw Offset and Length
For each (lol vb) entry in the `Sound Permutations`, the int16 `Sound name Index` is the index in the `Sound Names` reflexive that has the StringID of the name of the permutation. Now, we need to get the int32 `Raw Chunk Index` and the uint16 `Chunk Count` (we'll come to this later), this is the index in the `Raw Chunks` reflexive that says where in the raw sound data to start the permutation (int32 `File Offset`), and the size of it (uint16 `Size`).
  
Stage 6: There is where the party starts
Riiight, so if you followed this, and took the outputted sound data and added the XMA header and footer, and converted it to WAV, you might see that the permutations are, well, to put it mildly, completely fucked up. Something is causing the permutation data to get screwed up, and I think (well, pretty sure) it's to do with that phantom uint16 `Chunk Count` in the `Sound Permutations`.
 
 
So, let's get this done.

Disclaimer: This use of this mod requires a modified console. I do not condone piracy. By downloading and using this work, you agree that you take full responsibility for the use or misuse of these files. I am relieved of any liability associated with how you use or misuse these files.


This mod requires a JTAG/RGH console. If you don't know what that means then you don't have one. If you want more information on it, use your favorite search engine. If you need help installing converted mods, refer to my tutorial. If you would like to try to convert mods yourself, refer to my other tutorial.

Do not make requests in a release thread. If you want to request a conversion, make a request thread.


Need help testing alpha version.
Check this post


Multi-Utility is a Skyrim mod that adds a menu with many console functions for Xbox360 and PS3 users. I will attempt to add requested features as time permits.

I have included some excel sheets with many IDs. The rest can be found at SkyrimSearch.com or at UESP.net

Expand this spoiler to see the menu hiearchy.

Regarding Form IDs for installed mods:
If you look up a Quest Form ID in TESVSnip (or similar) it will give you a normal looking number e.g. 02000DE6. The 02 at the beginning will be different depending on the load order of your mods. To determine load order for a mod that isn't in the info menu, look at the Add-Ons menu on the start screen and count from bottom up, change this to hexadecimal, and this will be close to the number you need. The reason this is not acccurate is because load order is determined by the number of ESM/ESP's loaded. Some mods (Vanilla Mannequin Script Fix) have no ESM/ESP, while others have many (Belua Sanguinare Revisited has 6). I will try to inform on the release page if any mod does not contain only one ESM/ESP per container.

So here is an example:
I have 27 mods on my Add-Ons list. The 3rd from the top is Convenient Horses and I need this number so I can stop the CH quest. Counting from the bottom, Convenient Horses is #25. In hexadecimal, this is 19. TESVSnip showed the Form ID for quest 'CH' is 01020329. My first attempt to stop the quest will be 19020329. If I get the failed message, I try close numbers so I will try 1A020329, 18020329, 1B020329, 17020329, etc.


Usage:

Equip Multi-Utility from Powers in the Magic menu. I tried to make the menu as easy to navigate as possible. If something is really confusing, ask here and I will answer your questions and maybe change it so it will be easier in newer versions.



Known Issues:

1) Uninstall is broken in v5/v6. It will be fixed in v6.2.

2) Sometimes the number you enter isn't what is shown as current (Put in 4.2 and it shows 4.199999). This is not a bug with the mod but has to do with the way Skyrim handles it's variables. I don't understand it myself. I thought long and hard about a way to fix this but I've got nothing :-/

3) Some messages in the top left are very small text. This has somthing to do with my compile of messagebox.swf. I am looking into the problem.



Credits:

This mod was inspired by Command360 by rankstar over at Xbox360iso but I rewrote my own from scratch. Source for the scripts are included.



DOWNLOAD
By typing I_AGREE for the password, you agree to the disclaimer above

Current
v6.1 4Shared or Mediafire

Old Versions
4Shared or Mediafire

Changelog:

I'm going to lock this. Nothing new has been found on the subject, and if someone does find how to make a Scarab drivable, then I'm sure that person will post a tutorial on it. There is no need to be constantly asking, especially without trying much yourself, because sitting here and asking the same question over and over will not speed up research.

Didn't see any "forge art" in here so I thought I'd post something I made in reach ages ago.

 

 

Probably have about twenty different versions of this and I have no idea where I went with it. This is just the only version I took pics of. I'll go look and see how different the newer ones are and see if they are worth showing.

As some of you have already realized, April Fools!

Edit: