~unknowns\unknown_0000030d
~unknowns\unknown_00000481
~unknowns\unknown_000004d9
~unknowns\unknown_000004f7
~unknowns\unknown_000005e1
~unknowns\unknown_0000074c
~unknowns\unknown_00000802
~unknowns\unknown_00000828
~unknowns\unknown_00000909
~unknowns\unknown_00000acf
~unknowns\unknown_00000cfc
~unknowns\unknown_00000d7c
~unknowns\unknown_00000db7
idk if I need to give you the mpq file or not but those are the unknowns

Download these list files and add them to winmpq. Go to Options >> File Lists and click on "Add Files." I think that should fix it.

it's from sc1 beta, not today's mpq

Oh, whoops. Well then, I don't know.

It's ok

See http://www.zezula.net/en/mpq/namebreak.html .
There is a Download link under the Listfiles section.
It also mentions the number of unknowns remaining or if the listfile is complete.

Hey it doesn't even clear one of the unknowns

Post has been edited 3 time(s), last time on May 14 2011, 3:59 am by xboi209.

Then you didn't use it properly. There are only 2 unknowns and that's in Install.exe.
I'm assuming you're talking about one of the standard Starcraft MPQs.

This is sc beta im talking about

Oh sorry, I didn't read it fully.
Looked at the formats a bit and...



Without actually checking in detail, can't exactly know what they are called. But I'm assuming there are no references to them. Meaning using brute force to identify the names would be the only way.

Post has been edited 3 time(s), last time on May 14 2011, 8:04 pm by Heinermann.

that grp file is the one i might need along with the wavs, ill try and brute force them i guess

It seems the order they're in is alphabetical, so it's easy to narrow it down, however the brute force algorithm is quite slow and GUI not very intuitive.

Here are the ones I've recovered so far:

thanks heinermann, more if you can though

Only 7 unknowns left, but I'm getting bored of this so you will have to do the rest yourself.

Can you give me instructions how to brute force then?

Using Ladik's MPQ Editor (found on the site linked earlier), there is a "Name Breaker..." option under Tools.


Right click anywhere in the list, and click "Next Unknown" or "Previous Unknown" to allow you to iterate through the unknowns.


Right click on the entry and click "Detect..." or click on "Detect name ..." in the bottom right.


Since the entry in my example is a pcx, and is between two "glue\battle.net\icons\" entries, we know that the entry is called "glue\battle.net\icons\*.pcx".
In the name breaking window, the "Folders" represent a prefix, and the "Extensions" represent a suffix.
We know that the entry is alphabetically ordered between "cmmr" and "difficulty", so the first letter must either be c or d. I have chosen to include these letters in my prefix.
You may also want to eliminate or include characters that might be part of the file name using the "Characters..." button.
Here is a screenshot of my options.


The name breaker will then iterate each entry and notify you of its progress.


If you can't find a name, then you can do some research to get an idea of what the image is called.
For example, if we expand the attributes and look at the "Hash #", it corresponds to one of our unknown files.


If we open it we see...

... DIABLO?!?!?

Well... let's try something out.
We know that the word "Diablo" comes before "downloads" and after "cmmr" alphabetically.


Still... No luck, but I'm convinced the name begins with "glue\battle.net\icons\diablo".

Well for an example, if I knew the extension and I know the name starts with a T and ends with a shad, is there a way I can tell the name breaker to find what's in between?

For extension instead of selecting what's in the list, type in "shad.grp" or whatever the name is.
For prefix do what I did in the example.

EDIT:
Decided to start my own brute forcer.
Comparison (mm:ss):
MPQ Editor Name Breaker tool
6 digits: 01:03

Heinermann's Commandline Brute Force
6 digits: 00:04
7 digits: 01:31

Still todo:

• Name range restrictions (Will significantly improve performance by narrowing the search scope)
  
• First-digit precalculations (+1 digits with almost same amount of time)
  
• Multi-threading (Make use of multi-core systems to greatly decrease time required)
  
• Final optimization (Loop unfolding etc.)
  

Post has been edited 2 time(s), last time on May 15 2011, 11:46 pm by Heinermann.

Wait you mean you're making your own brute force program specifically for this? Make a beta with multi threading and put me in it

Oops, I completely forgot... first-digit precalculation can't be done in this case, since the prefix must be calculated beforehand.

Todo:

• Name range restrictions (Will significantly improve performance by narrowing the search scope)
  
• First-digit precalculations (+1 digits with almost same amount of time) (Can't be done)
  
• Multi-threading (Make use of multi-core systems to greatly decrease time required)
  
• Final optimization (Loop unfolding etc.)
  

Sample of unfinished name-range restriction (7 characters, time in min:sec:ms):

That's only 5 seconds compared to the full 91 seconds.

Thing I still need to do in order to complete the name-range feature is to split the algorithm into two parts; one that includes the restriction and one that doesn't, because when we iterate through "redlag", the 7th character which is not specified can be anything, so we can ignore the restrictions and improve performance by iterating without the code needed to restrict it. It will have a larger impact when we increase the maximum character limit.

EDIT:

I have completed what I mentioned above as well as multithreading.
Sample:


That's 2 seconds.


Todo:

• Name range restrictions (Will significantly improve performance by narrowing the search scope)
  
• First-digit precalculations (+1 digits with almost same amount of time) (Can't be done)
  
• Multi-threading (Make use of multi-core systems to greatly decrease time required)
  
• Final optimization (Loop unfolding etc.)
  

Benchmark (no hits)
8 characters - 29 seconds
9 characters - 5 hours and 28 minutes

Post has been edited 3 time(s), last time on May 19 2011, 2:51 am by Heinermann.