public void TryExecutePacket(GameClient Session, ClientPacket Packet)
{
if (!_incomingPackets.TryGetValue(Packet.Id, out IPacketEvent Pak))
{
if (System.Diagnostics.Debugger.IsAttached)
{
log.Debug("Unhandled Packet: " + Packet.ToString());
}
return;
}
if (System.Diagnostics.Debugger.IsAttached)
{
log.Debug("Handled Packet: [" + Packet.Id + "] " + Pak.GetType().Name);
}
if (!IgnoreTasks)
{
ExecutePacketAsync(Session, Packet, Pak);
}
else
{
Pak.Parse(Session, Packet);
}
}
public override bool TryApplyPatch(out string failureReason)
{
string path = Directory.GetFiles(GameDirectory, Chunk + ".pak", SearchOption.AllDirectories).FirstOrDefault();
if (path == null)
{
failureReason = $"Can't find pak file '{Chunk}.pak'";
return(false);
}
try
{
using (var pak = Pak.OpenAsync(path).Result)
{
var task = pak.DecryptAsync(Key);
task.Wait();
}
}
catch (IncorrectEncryptionKeyException)
{
failureReason = "The given encryption key was not correct";
return(false);
}
failureReason = null;
return(true);
}
private void salvarStrDefbinToolStripMenuItem_Click(object sender, EventArgs e)
{
try
{
using (SaveFileDialog save = new SaveFileDialog())
{
save.Filter = "*.bin|*.bin";
save.Title = "Selecione onde deseja salvar sua strdef.bin";
save.ShowDialog();
if (save.FileName != "")
{
External.g_pStrdef.Checksum = 26115295;
byte[] toSave = Pak.ToByteArray(External.g_pStrdef);
for (int i = 0; i < toSave.Length - 4; i++)
{
toSave[i] ^= 0x5A;
}
File.Create(save.FileName).Close();
File.WriteAllBytes(save.FileName, toSave);
MessageBox.Show($"Arquivo {save.FileName} salvo com sucesso!");
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public void LoadItemIcon()
{
try
{
using (OpenFileDialog find = new OpenFileDialog())
{
find.Filter = "ItemIcon.bin|ItemIcon.bin";
find.Title = "Selecione sua ItemIcon.bin";
find.ShowDialog();
if (find.CheckFileExists)
{
this.FilePath = find.FileName;
if (File.Exists(this.FilePath))
{
byte[] temp = File.ReadAllBytes(this.FilePath);
if (temp.Length != 26000 && temp.Length != 25992)
{
MessageBox.Show("ItemIcon inválida", "ItemIcon.bin inválida", MessageBoxButtons.OK, MessageBoxIcon.Error);
this.LoadItemIcon();
}
else
{
this.ItemIcon = Pak.ToStruct <STRUCT_ITEMICON>(temp);
if (listBox1.Items.Count > 0)
{
listBox1.Items.Clear();
}
for (int i = 0; i < this.ItemIcon.Item.Length; i++)
{
this.listBox1.Items.Add($"{i.ToString().PadLeft(4, '0')}: {this.ItemIcon.Item[i].Icone}");
}
salvarItemIconbinToolStripMenuItem.Enabled = true;
}
}
else
{
Environment.Exit(0);
}
}
else
{
Environment.Exit(0);
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public async Task OpenPakAsync(StorageFile file)
{
try
{
var fileStream = (await file.OpenAsync(FileAccessMode.ReadWrite)).AsStream();
Pak pak = await Pak.OpenAsync(fileStream);
if (pak.IsIndexEncrypted)
{
// If the pak is encrypted, ask for the key and attempt to decrypt it.
bool decryptSuccessful = false;
bool isSubsequentAttempt = false;
while (!decryptSuccessful)
{
var decryptDialog = new DecryptPakDialog(isSubsequentAttempt);
if (await decryptDialog.ShowAsync() == ContentDialogResult.Primary)
{
try
{
Entries = await pak.GetEntriesAsync(decryptDialog.EncryptionKey);
decryptSuccessful = true;
EncryptionKey = decryptDialog.EncryptionKey;
}
catch (IncorrectEncryptionKeyException)
{
isSubsequentAttempt = true;
}
}
else
{
return; // No encryption key provided, we're not opening this file.
}
}
}
else
{
Entries = await pak.GetEntriesAsync();
}
CurrentPak = pak;
ApplicationView.GetForCurrentView().Title = file.Path;
StatusText = $"{Entries.Count} files";
}
catch (MagicNumberMismatchException)
{
await(new MessageDialog("This isn't a pak file.")).ShowAsync();
}
catch (UnsupportedVersionException)
{
await(new MessageDialog("This pak is based on a version that isn't supported at this time.")).ShowAsync();
}
}
/// <summary>
/// Finds a match to a game object property value.
/// </summary>
/// <param name="filter">The filter.</param>
/// <returns></returns>
private bool FindMatch(string filter)
{
return(Name?.IndexOf(filter, StringComparison.CurrentCultureIgnoreCase) >= 0 ||
Pak.IndexOf(filter, StringComparison.CurrentCultureIgnoreCase) >= 0 ||
MapKey?.IndexOf(filter, StringComparison.CurrentCultureIgnoreCase) >= 0 ||
ParentTemplateId?.IndexOf(filter, StringComparison.CurrentCultureIgnoreCase) >= 0 ||
DisplayNameHandle?.IndexOf(filter, StringComparison.CurrentCultureIgnoreCase) >= 0 ||
DisplayName?.IndexOf(filter, StringComparison.CurrentCultureIgnoreCase) >= 0 ||
DescriptionHandle?.IndexOf(filter, StringComparison.CurrentCultureIgnoreCase) >= 0 ||
Description?.IndexOf(filter, StringComparison.CurrentCultureIgnoreCase) >= 0 ||
Icon?.IndexOf(filter, StringComparison.CurrentCultureIgnoreCase) >= 0 ||
Stats?.IndexOf(filter, StringComparison.CurrentCultureIgnoreCase) >= 0);
}
public override PlatformData Create(string path, Game game, ProgressIndicator progress)
{
PlatformData data = new PlatformData(this, game);
DirectoryNode dir = data.GetDirectoryStructure(path);
data.Game = Platform.DetermineGame(data);
FileNode qbpak = dir.Navigate("pak/qb.pak.ngc") as FileNode;
if (qbpak == null)
{
Exceptions.Error("Couldn't find qb.pak.ngc on Guitar Hero 3 Wii disc.");
}
try {
Pak qb = new Pak(new EndianReader(qbpak.Data, Endianness.BigEndian));
FileNode songlistfile = qb.Root.Find("songlist.qb.ngc", SearchOption.AllDirectories) as FileNode;
FileNode albumfile = dir.Navigate("pak/album_covers/album_covers.pak.ngc", false, true) as FileNode;
QbFile songlist = new QbFile(songlistfile.Data, PakFormat);
QbItemStruct list = songlist.FindItem(QbKey.Create(NeversoftMetadata.SonglistKeys[0]), true) as QbItemStruct;
data.Session["rootdir"] = dir;
data.Session["rootqb"] = qb;
if (albumfile != null)
{
data.Session["albumpak"] = new Pak(new EndianReader(albumfile.Data, Endianness.BigEndian));
}
var items = list.Items;
progress.NewTask(items.Count);
foreach (QbItemStruct item in items)
{
SongData song = NeversoftMetadata.GetSongData(data, item);
try {
AddSong(data, song, progress);
} catch (Exception exception) {
Exceptions.Warning(exception, "Unable to properly parse " + song.Name);
}
progress.Progress();
}
progress.EndTask();
} catch (Exception exception) {
Exceptions.Error(exception, "An error occurred while parsing the Guitar Hero 3 Wii disc.");
}
return(data);
}
private static void AddAfbeelding(Jurk jurk, Pak pak, String sourcepath, HoneyMoonShopContext context)
{
context.AddRange(
new Afbeelding {
Jurk = jurk, Pak = null, SourcePath = "/" + sourcepath + "a"
},
new Afbeelding {
Jurk = jurk, Pak = null, SourcePath = "/" + sourcepath + "b"
},
new Afbeelding {
Jurk = jurk, Pak = null, SourcePath = "/" + sourcepath + "c"
}
);
}
private void TryLoadPakFiles()
{
Pak.PakList.Clear();
string steamPath = config.settings.GetOption <string>("SteamPath");
if (steamPath != "")
{
try
{
Pak.GetPakFiles(steamPath);
}
catch (DirectoryNotFoundException ex)
{
MessageBox.Show(ex.Message, "Starbound Workshop Folder not found.");
}
}
}
public SearchPath(String path)
{
if (path.EndsWith(".PAK"))
{
pack = FileSystem.LoadPackFile(path);
if (pack == null)
{
Utilities.Error("Couldn't load packfile: {0}", path);
}
}
else if (path.EndsWith(".PK3"))
{
pk3 = ZipFile.OpenRead(path);
pk3filename = path;
if (pk3 == null)
{
Utilities.Error("Couldn't load pk3file: {0}", path);
}
}
else
{
filename = path;
}
}
/// <summary>
/// Create Maps Paks based on JSON file created during Cooking. (-GenerateDependenciesForMaps)
/// </summary>
public void CreateMapPak()
{
// read in the json file.
object[] Value = (object[])DependencyJson["ContentDirectoryAssets"];
List <string> ContentDirectory = Array.ConvertAll <object, string>(Value, Convert.ToString).ToList();
foreach (string Pak in DependencyJson.Keys)
{
object[] ObjectList = (object[])DependencyJson[Pak];
List <string> Assets = Array.ConvertAll <object, string>(ObjectList, Convert.ToString).ToList();
// add itself.
Assets.Add(Pak);
if (Pak != "ContentDirectoryAssets")
{
// remove content directory assets.
Assets = Assets.Except(ContentDirectory).ToList();
string[] Tokens = Pak.Split('/');
CreatePak(Tokens[Tokens.Length - 1], Assets);
}
}
}
private void salvarSkillDatabinToolStripMenuItem_Click(object sender, EventArgs e)
{
try
{
using (SaveFileDialog save = new SaveFileDialog())
{
save.Filter = "*.bin|*.bin";
save.Title = "Selecione onde deseja salvar sua SkillData.bin";
save.ShowDialog();
if (save.FileName != "")
{
byte[] toSave = Pak.ToByteArray(External.g_pSkillData);
byte[] pKeyList = File.ReadAllBytes("./Keys.bin");
Array.Resize(ref pKeyList, pKeyList.Length + 1);
for (int i = 0; i < toSave.Length; i++)
{
toSave[i] ^= (pKeyList[i & 63]);
}
File.Create(save.FileName).Close();
File.WriteAllBytes(save.FileName, toSave);
MessageBox.Show($"Arquivo {save.FileName} salvo com sucesso!");
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public void SalvaritemIconBIN()
{
try
{
using (SaveFileDialog save = new SaveFileDialog())
{
save.Filter = "*.bin|*.bin";
save.Title = "Selecione onde deseja salvar sua ItemIcon.bin";
save.ShowDialog();
if (save.FileName != "")
{
byte[] toSave = Pak.ToByteArray(this.ItemIcon);
File.Create(save.FileName).Close();
File.WriteAllBytes(save.FileName, toSave);
MessageBox.Show($"Arquivo {save.FileName} salvo no modo Encode com sucesso!");
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// COM_LoadPackFile
/// Takes an explicit (not game tree related) path to a pak file.
/// Loads the header and directory, adding the files at the beginning
/// of the list so they override previous pack files.
/// </summary>
public static Pak LoadPackFile(String packfile)
{
var file = OpenRead(packfile);
if (file == null)
{
return(null);
}
var header = Utilities.ReadStructure <PakHeader>(file);
var id = Encoding.ASCII.GetString(header.id);
if (id != "PACK")
{
Utilities.Error("{0} is not a packfile", packfile);
}
header.dirofs = EndianHelper.LittleLong(header.dirofs);
header.dirlen = EndianHelper.LittleLong(header.dirlen);
var numpackfiles = header.dirlen / Marshal.SizeOf(typeof(PakFile));
if (numpackfiles > MAX_FILES_IN_PACK)
{
Utilities.Error("{0} has {1} files", packfile, numpackfiles);
}
//if (numpackfiles != PAK0_COUNT)
// _IsModified = true; // not the original file
file.Seek(header.dirofs, SeekOrigin.Begin);
var buf = new Byte[header.dirlen];
if (file.Read(buf, 0, buf.Length) != buf.Length)
{
Utilities.Error("{0} buffering failed!", packfile);
}
var info = new List <PakFile>(MAX_FILES_IN_PACK);
var handle = GCHandle.Alloc(buf, GCHandleType.Pinned);
try
{
var ptr = handle.AddrOfPinnedObject( );
Int32 count = 0, structSize = Marshal.SizeOf(typeof(PakFile));
while (count < header.dirlen)
{
var tmp = ( PakFile )Marshal.PtrToStructure(ptr, typeof(PakFile));
info.Add(tmp);
ptr = new IntPtr(ptr.ToInt64( ) + structSize);
count += structSize;
}
if (numpackfiles != info.Count)
{
Utilities.Error("{0} directory reading failed!", packfile);
}
}
finally
{
handle.Free( );
}
// crc the directory to check for modifications
//ushort crc;
//CRC.Init(out crc);
//for (int i = 0; i < buf.Length; i++)
// CRC.ProcessByte(ref crc, buf[i]);
//if (crc != PAK0_CRC)
// _IsModified = true;
buf = null;
// parse the directory
var newfiles = new MemoryPakFile[numpackfiles];
for (var i = 0; i < numpackfiles; i++)
{
var pf = new MemoryPakFile( );
pf.name = Utilities.GetString(info[i].name);
pf.filepos = EndianHelper.LittleLong(info[i].filepos);
pf.filelen = EndianHelper.LittleLong(info[i].filelen);
newfiles[i] = pf;
}
var pack = new Pak(packfile, new BinaryReader(file, Encoding.ASCII), newfiles);
ConsoleWrapper.Print("Added packfile {0} ({1} files)\n", packfile, numpackfiles);
return(pack);
}
public override bool AddSong(PlatformData data, SongData song, ProgressIndicator progress)
{
string albumname = null;
switch (song.ID)
{
case "dontholdback": albumname = "TheSleepingQuestionsAndAnswers"; break;
case "minuscelsius": albumname = "BackyardBabiesStockholmSyndrome"; break;
case "thrufireandflames": albumname = "DragonforceInhumanRampage"; break;
case "fcpremix": albumname = "FallofTroyDoppelganger"; break;
case "avalancha": albumname = "HeroesDelSilencioAvalancha"; break;
case "takethislife": albumname = "InFlamesComeClarity"; break;
case "ruby": albumname = "KaiserChiefsYoursTrulyAngry_Mob"; break;
case "mycurse": albumname = "KillswitchEngageAsDaylightDies"; break;
case "closer": albumname = "LacunaCoilKarmaCode"; break;
case "metalheavylady": albumname = "LionsLions"; break;
case "mauvaisgarcon": albumname = "NaastAntichambre"; break;
case "generationrock": albumname = "RevolverheldRevolverheld"; break;
case "prayeroftherefugee": albumname = "RiseAgainstTheSuffererAndTheWitness"; break;
case "cantbesaved": albumname = "SensesFailStillSearching"; break;
case "shebangsadrum": albumname = "StoneRosesStoneRoses"; break;
case "radiosong": albumname = "SuperbusPopnGum"; break;
case "bellyofashark": albumname = "TheGallowsOrchestraofWoles"; break;
case "gothatfar": albumname = "BretMichealsBandGoThatFar"; break;
case "impulse": albumname = "endlesssporadic"; break;
case "thewayitends": albumname = "prototype_continuum_cover"; break;
case "nothingformehere": albumname = "Dope_PosterCover_edsel"; break;
case "inlove": albumname = "store_song_ScoutsStSebastian"; break;
}
if (albumname != null)
{
if (data.Session.ContainsKey("albumpak"))
{
Pak albumpak = data.Session["albumpak"] as Pak;
Pak.Node node = albumpak.Nodes.Find(n => n.FilenamePakKey == QbKey.Create(albumname).Crc);
if (node != null)
{
song.AlbumArt = NgcImage.Create(new EndianReader(node.Data, Endianness.BigEndian)).Bitmap;
}
}
}
DirectoryNode dir = data.Session["rootdir"] as DirectoryNode;
Pak qb = data.Session["rootqb"] as Pak;
FileNode chartpak = dir.Navigate("songs/" + song.ID + ".pak.ngc", false, true) as FileNode;
if (chartpak == null)
{
return(false);
}
chartpak.Data.Position = 0;
Pak chartqb = new Pak(new EndianReader(chartpak.Data, Endianness.BigEndian));
FileNode sectionfile = chartqb.Root.Find(song.ID + ".mid_text.qb.ngc", SearchOption.AllDirectories, true) as FileNode;
if (sectionfile == null) // GHA stores it elsewhere
{
sectionfile = qb.Root.Find(song.ID + ".mid_text.qb.ngc", SearchOption.AllDirectories, true) as FileNode;
}
if (sectionfile == null) // Last resort, check for it raw on the disc partition
{
sectionfile = dir.Find(song.ID + ".mid_text.qb.ngc", SearchOption.AllDirectories, true) as FileNode;
}
for (int coop = 0; coop < 2; coop++)
{
if (coop == 1)
{
song = new SongData(song);
song.ID += "_coop";
song.Name += " [coop]";
}
FormatData formatdata = new TemporaryFormatData(song, data);
FileNode datfile = dir.Navigate("music/" + song.ID + ".dat.ngc", false, true) as FileNode;
FileNode wadfile = dir.Navigate("music/" + song.ID + ".wad.ngc", false, true) as FileNode;
if (datfile == null || wadfile == null)
{
continue;
}
AudioFormatGH3WiiFSB.Instance.Create(formatdata, datfile.Data, wadfile.Data);
ChartFormatGH3.Instance.Create(formatdata, chartpak.Data, sectionfile.Data, coop == 1);
data.AddSong(formatdata);
}
chartpak.Data.Close();
return(true);
}
public SearchPath(Pak pak)
{
pack = pak;
}
public override bool TryApplyPatch(out string failureReason)
{
string path = Directory.GetFiles(GameDirectory, Chunk + ".pak", SearchOption.AllDirectories).FirstOrDefault();
if (path == null)
{
failureReason = $"Can't find pak file '{Chunk}.pak'";
return(false);
}
var replacementFile = PatchFile.GetEntry(ReplacementFileName);
if (replacementFile == null)
{
failureReason = $"Missing file '{ReplacementFileName}' in patch";
return(false);
}
using (var pak = Pak.OpenAsync(path).Result)
{
if (pak.IsIndexEncrypted)
{
failureReason = "Pak must be decrypted first";
return(false);
}
foreach (var entry in pak.GetEntriesAsync().Result)
{
if (entry.FileName == FileName)
{
using (var stream = replacementFile.Open())
using (var ms = new MemoryStream())
{
stream.CopyTo(ms);
if (ms.Length > entry.Size)
{
failureReason = "Replacement file is bigger than the original file";
return(false);
}
else if (ms.Length < entry.Size)
{
long padSize = entry.Size - ms.Length;
for (long i = 0; i < padSize; i++)
{
ms.WriteByte(Padding == PaddingType.Spaces ? (byte)0x20 : (byte)0x00);
}
}
ms.Seek(0, SeekOrigin.Begin);
var task = pak.SwapEntryAsync(entry, ms);
task.Wait();
failureReason = "";
return(true);
}
}
}
failureReason = $"Cannot find file '{FileName}' in pak '{Chunk}.pak'";
return(false);
}
}
public override ChartFormat DecodeChart(FormatData data, ProgressIndicator progress)
{
if (!data.HasStream(this, ChartName) || !data.HasStream(this, SectionsName))
{
throw new FormatException();
}
progress.NewTask(6 + 8);
Stream chartstream = data.GetStream(this, ChartName);
Stream sectionstream = data.GetStream(this, SectionsName);
PakFormat format = NeversoftMetadata.GetSongItemType(data.Song);
SongData song = NeversoftMetadata.GetSongData(data.PlatformData, NeversoftMetadata.GetSongItem(data));
Pak chartpak = new Pak(new EndianReader(chartstream, Endianness.BigEndian)); // TODO: Endianness based on format?
FileNode chartfile = chartpak.Root.Find(song.ID + ".mid.qb.ngc", SearchOption.AllDirectories, true) as FileNode;
QbFile qbsections = new QbFile(sectionstream, format);
QbFile qbchart = new QbFile(chartfile.Data, format);
NoteChart chart = new NoteChart();
chart.PartGuitar = new NoteChart.Guitar(chart);
chart.PartBass = new NoteChart.Bass(chart);
chart.Events = new NoteChart.EventsTrack(chart);
chart.Venue = new NoteChart.VenueTrack(chart);
chart.Beat = new NoteChart.BeatTrack(chart);
progress.Progress();
DecodeChartFretbars(song, qbchart, chart);
progress.Progress();
DecodeChartMarkers(song, qbsections, qbchart, chart);
progress.Progress();
for (NoteChart.TrackType track = NoteChart.TrackType.Guitar; track <= NoteChart.TrackType.Bass; track++)
{
for (NoteChart.Difficulty difficulty = NoteChart.Difficulty.Easy; difficulty <= NoteChart.Difficulty.Expert; difficulty++)
{
DecodeChartNotes(data, song, qbchart, chart, track, difficulty, data.Song.Data.GetValue <bool>("GH3ChartCoop"));
progress.Progress();
}
}
progress.Progress();
DecodeChartDrums(song, qbchart, chart);
progress.Progress();
DecodeChartVenue(song, qbchart, chart);
ImportMap.ImportChart(data.Song, chart);
progress.Progress();
data.CloseStream(chartstream);
data.CloseStream(sectionstream);
progress.EndTask();
return(new ChartFormat(chart));
}
public override PlatformData Create(string path, Game game, ProgressIndicator progress)
{
PlatformData data = new PlatformData(this, game);
DirectoryNode dir = data.GetDirectoryStructure(path);
data.Game = Platform.DetermineGame(data);
try {
FileNode qbpak = dir.Navigate("pak/qb.pak.ngc") as FileNode;
if (qbpak == null)
{
throw new FormatException("Couldn't find qb.pak on Guitar Hero Wii disc.");
}
FileNode qspak = dir.Navigate("pak/qs.pak.ngc") as FileNode;
if (qspak == null)
{
throw new FormatException("Couldn't find qs.pak on Guitar Hero Wii disc.");
}
Pak qs = new Pak(new EndianReader(qspak.Data, Endianness.BigEndian));
StringList strings = new StringList();
foreach (Pak.Node node in qs.Nodes)
{
strings.ParseFromStream(node.Data);
}
Pak qb = new Pak(new EndianReader(qbpak.Data, Endianness.BigEndian));
FileNode songlistfile = qb.FindFile(@"scripts\guitar\songlist.qb.ngc");
if (songlistfile == null)
{
songlistfile = qb.FindFile(@"scripts\guitar\songlist.qb");
}
if (songlistfile == null)
{
throw new FormatException("Couldn't find the songlist on the Guitar Hero Wii disc pak.");
}
QbFile songlist = new QbFile(songlistfile.Data, PakFormat);
data.Session["rootdir"] = dir;
List <QbKey> listkeys = new List <QbKey>();
foreach (uint songlistkey in NeversoftMetadata.SonglistKeys)
{
QbKey key = QbKey.Create(songlistkey);
QbItemStruct list = songlist.FindItem(key, true) as QbItemStruct;
if (list != null && list.Items.Count > 0)
{
listkeys.Add(key);
}
}
progress.NewTask(listkeys.Count);
List <string> songsadded = new List <string>();
foreach (QbKey songlistkey in listkeys)
{
QbItemStruct list = songlist.FindItem(songlistkey, true) as QbItemStruct;
progress.NewTask(list.Items.Count);
foreach (QbItemArray item in list.Items.OfType <QbItemArray>())
{
item.Items[0].ItemQbKey = item.ItemQbKey;
SongData song = NeversoftMetadata.GetSongData(data, item.Items[0] as QbItemStruct, strings);
progress.Progress();
if (songsadded.Contains(song.ID))
{
continue;
}
try {
if (AddSong(data, song, progress))
{
songsadded.Add(song.ID);
}
} catch (Exception exception) {
Exceptions.Warning(exception, "Unable to properly parse " + song.Name);
}
}
progress.EndTask();
progress.Progress();
}
progress.EndTask();
qbpak.Data.Close();
qspak.Data.Close();
} catch (Exception exception) {
Exceptions.Error(exception, "An error occurred while parsing the Guitar Hero Wii disc.");
}
return(data);
}
public override PlatformData Create(string path, Game game, ProgressIndicator progress)
{
PlatformData data = new PlatformData(this, game);
DirectoryNode dir = data.GetDirectoryStructure(path);
FileNode binfile = dir.Navigate("001.bin") as FileNode;
if (binfile == null)
{
Exceptions.Error("Unable to open Guitar Hero World Tour DLC because 001.bin is missing.");
}
data.Session["rootdir"] = dir;
try {
DlcBin bin = new DlcBin(binfile.Data);
U8 u8 = new U8(bin.Data);
FileNode listfile = u8.Root.Navigate("DLC1.pak.ngc") as FileNode;
Pak qb = new Pak(new EndianReader(listfile.Data, Endianness.BigEndian));
FileNode songlistfile = qb.Root.Find("catalog_info.qb.ngc", SearchOption.AllDirectories) as FileNode;
QbFile songlist = new QbFile(songlistfile.Data, PakFormat);
StringList strings = new StringList();
foreach (Pak.Node node in qb.Nodes)
{
if (!node.Filename.HasValue())
{
strings.ParseFromStream(node.Data);
}
}
List <QbKey> listkeys = new List <QbKey>();
foreach (uint songlistkey in NeversoftMetadata.SonglistKeys)
{
QbKey key = QbKey.Create(songlistkey);
QbItemStruct list = songlist.FindItem(key, true) as QbItemStruct;
if (list != null && list.Items.Count > 0)
{
listkeys.Add(key);
}
}
Stream str = new FileStream(@"C:\ghwt.xml", FileMode.Create);
StreamWriter writer = new StreamWriter(str);
progress.NewTask(listkeys.Count);
foreach (QbKey songlistkey in listkeys)
{
QbItemStruct list = songlist.FindItem(songlistkey, true) as QbItemStruct;
progress.NewTask(list.Items.Count);
foreach (QbItemArray item in list.Items.OfType <QbItemArray>())
{
item.Items[0].ItemQbKey = item.ItemQbKey;
SongData song = NeversoftMetadata.GetSongData(data, item.Items[0] as QbItemStruct, strings);
writer.WriteLine("\t<song id=\"" + song.ID + "\">");
writer.WriteLine("\t\t<pack>Guitar Hero World Tour DLC</pack>");
writer.WriteLine("\t\t<nameprefix>[GHWT DLC]</nameprefix>");
writer.WriteLine("\t\t<name>" + song.Name + "</name>");
writer.WriteLine("\t\t<artist>" + song.Artist + "</artist>");
writer.WriteLine("\t\t<album>" + song.Album + "</album>");
writer.WriteLine("\t\t<genre>" + song.Genre + "</genre>");
writer.WriteLine("\t\t<track>" + song.AlbumTrack.ToString() + "</track>");
writer.WriteLine("\t\t<difficulty instrument=\"band\" rank=\"1\" />");
writer.WriteLine("\t\t<difficulty instrument=\"guitar\" rank=\"1\" />");
writer.WriteLine("\t\t<difficulty instrument=\"bass\" rank=\"1\" />");
writer.WriteLine("\t\t<difficulty instrument=\"drum\" rank=\"1\" />");
writer.WriteLine("\t\t<difficulty instrument=\"vocals\" rank=\"1\" />");
writer.WriteLine("\t</song>");
try {
AddSong(data, song, progress);
} catch (Exception exception) {
Exceptions.Warning(exception, "Unable to properly parse " + song.Name);
}
progress.Progress();
}
progress.EndTask();
progress.Progress();
}
progress.EndTask();
writer.Close();
binfile.Data.Close();
} catch (Exception exception) {
Exceptions.Error(exception, "An error occurred while parsing the Guitar Hero World Tour DLC list.");
}
return(data);
}
