Is there a way to find out from which TM game a map file is?

[Brainshaker95]

Hi 🙂

First things first: Huge thank you for maintaining this project! It clearly shows how much effort was put into it.

---

Here is some context to my question:

A few months back I suddenly had the urge to come back to some old TM story maps just to experience them again.

I quickly noticed though that I was missing a lot of files and that pretty much all the locators lead to dead links.
As I googled around for missing media packs I noticed pretty fast that I would not find a perfect zip file containing every needed file for the maps I wanted to play. So what do I do? Manually reconstruct the maps dependencies of course 😃

I tried various different tools for parsing and extracting the data I want, but since all of them only supported header parsing I started to look into GBX.NET (not a C# dev myself so I tried every other option first 😃).

Now I was finally able to extract all file and locator information I needed so everything was good wasn't it?
Well....let's just say I went a little overboard...

I found this playlist by fab'm who also, like me, is very nostalgic for these old story maps and tries recreate the media packs that are no longer easily findable.
As I came into contact with him I realized that the had the same issue as me (not all files are part of the header), but since he is not a developer at all he couldn't do anything about it. He had files I needed and I had files he needed they just weren't accessible online anymore.
I basically took this as an inspiration to create a tool that allows people to parse their maps and see which files are necessary to play it. Possible long term plans for that might involve creating a public archive and allowing people to contribute files they might still have.
Here is a WIP screenshot since the tool is not public yet:

Now back to my initial question:
I want to allow users of the tool to scan their TM data folders for any files they might already have.
Of course I have to look in the correct folder depending on the provided map so I came up with this mapping (I haven't gone further than TMF yet):

FileRef.Version 1 && Desert -> TMO Folder
FileRef.Version 1 && Rally -> TMO Folder
FileRef.Version 1 && Snow -> TMO Folder

FileRef.Version 1 && Bay-> TMS Folder
FileRef.Version 1 && Coast-> TMS Folder
FileRef.Version 1 && Island -> TMS Folder

FileRef.Version 1 && Stadium -> TMN Folder
___
FileRef.Version 2 && Desert -> TMF Folder
FileRef.Version 2 && Rally -> TMF Folder
FileRef.Version 2 && Snow -> TMF Folder

FileRef.Version 2 && Bay-> TMF Folder
FileRef.Version 2 && Coast-> TMF Folder
FileRef.Version 2 && Island -> TMF Folder

FileRef.Version 2 && Stadium -> TMF Folder

The problem arises when a TMU map is provided. The FileRef version of TMU files is 2 (like TMF) and the environments of course are also the same. I have to handle them differently though because TMU has its own data folder (TMUF and TMNF share the same one).
So now I ask my question again: Is there a way to find out from which TM game a map file is?

Thanks for again for working on this library and for your time reading this post 🙂

[thaumictom]

There is unfortunately no consistent way of figuring out which game something originates from. I have the same issue with my gbx.js library (thaumictom/gbx-ts#4). You can see the specific code (https://github.com/thaumictom/gbx.js/blob/121c50aad85e871fac16c003f4c0d8c672ff992c/src/gbx.js#L489) the library uses. It's obviously not a rigid solution, there likely will never be one. At least I could not imagine it being natively provided by the library.

[Brainshaker95]

Thank you for your answer. I am afraid that you are right...
I worked with your library before I switched to GBX.NET when I noticed that I also need to parse the body. I saw that part of the code and thought it was a little weird. I guess my hope was that it's just the header that doesn't contain that information and that it might be somewhere in the body.

[thaumictom]

Thank you for using the library prior to switching.

The current best solution is to fix the issue re-actively; if you find a test case that does not match, you add a conditional statement to fix it. However indeed, having access to the body potentially can give you more places where you can figure out what game its from, however that's on you. You can use the snippet I linked as a template.

[Brainshaker95]

The thing is that just knowing "Trackmania 1" is not enough for what I am trying to accomplish so that snippet doesn't really help me that much. Maybe @BigBang1112 knows something more? Thanks either way for your help, I'll continue fiddling arround and maybe I find someting. If so I'll of course let you know.

[Brainshaker95]

I think it might be enough for me to combine my previous approach with the exever value of the XML header. After looking at a few different maps it appears that all games before and including TMU have a 4 number version string like X.X.X.X and the TMF games have a 3 number one.

TMO maps -> No XML headers
TMS maps -> 0.1.4.5 and 0.1.5.0
TMN maps -> 0.1.7.5 and 0.1.7.9
TMU maps -> 0.2.0.7 and 0.2.0.9
TMF maps -> 2.11.11 and 2.11.17

Not sure when exactly the switch from 4 to 3 numbers happened but my theory is that it was with the forever update.

[BigBang1112]

There is a way. Currently, the most accurate one to differentiate games is to check for existence+nonexistence of data chunks.

I've been implementing this aside on my Gbx Web Tools project and I will eventually port it to GBX.NET likely in 1.3.

For example, the latest chunk of CGameCtnChallenge is 0x02A, so you can invalidate that the map is from TMF by checking if there's a chunk of a higher ID, and then you follow on with other conditions.

At micro-update scenarios it gets harder and you will have to add chunk versioning and other specifics into the conditions, but when you take two sample replays for example and compare them on https://gbxexplorer.net, you can spot micro-differences quite easily.

It can get a bit tricky to find the right condition combo but it does the job done well by then.

[Brainshaker95]

Thank you so much for that information, I will look into it some more. I'm sure this would be exactly what I need.

[Brainshaker95]

For anyone interested. this is what I came up with. It's not pretty but I think it should do the job:

private string getGame(CGameCtnChallenge challenge)
{
    if (challenge.TryGetChunk(out CGameCtnChallenge.Chunk03043060? tm2020Chunk))
    {
        return "TM2020";
    }

    if (challenge.TryGetChunk(out CGameCtnChallenge.Chunk03043034? tm2Chunk))
    {
        return challenge.TitleID == "TMCE@nadeolabs" || challenge.TitleID == "TMTurbo@nadeolabs"
            ? "TMT"
            : "TM2";
    }

    if (challenge.TryGetChunk(out CGameCtnChallenge.Chunk0304302A? tmfChunk))
    {
        return "TMF";
    }

    if (challenge.TryGetChunk(out CGameCtnChallenge.Chunk03043028? tmuChunk))
    {
        return "TMU";
    }

    switch (challenge.Collection.ToString())
    {
        case "Alpine":
        case "Rally":
        case "Speed":
            return "TMO";

        case "Bay":
        case "Coast":
        case "Island":
            return "TMS";

        case "Stadium":
            return "TMN";

        default:
            throw new NotImplementedException("Unsupported environment '" + challenge.Collection.ToString() + "'.");
    }
}