Beispiel #1
0
 public void LoadGroup(RSARGroupNode group)
 {
     if ((_targetGroup = group) != null)
     {
         lstFiles.DataSource    = group._files;
         cboAllFiles.DataSource = group.RSARNode.Files;
     }
     else
     {
         lstFiles.DataSource    = null;
         cboAllFiles.DataSource = null;
     }
 }
Beispiel #2
0
        internal int EncodeFILEBlock(FILEHeader *header, RSAREntryList entries, RSARNode node)
        {
            int     len      = 0;
            VoidPtr baseAddr = (VoidPtr)header + 0x20;
            VoidPtr addr     = baseAddr;

            //Build files - order by groups
            for (int x = 0; x <= entries._groups.Count; x++)
            {
                RSARGroupNode   g = x == entries._groups.Count ? node._nullGroup : ((RSAREntryState)entries._groups[x])._node as RSARGroupNode;
                int             headerLen = 0, audioLen = 0;
                int             i = 0;
                INFOGroupEntry *e = (INFOGroupEntry *)((VoidPtr)g._rebuildAddr + INFOGroupHeader.Size + 4 + g._files.Count * 8);
                g._rebuildAddr->_headerOffset = (int)(addr - node._rebuildBase);
                foreach (RSARFileNode f in g.Files)
                {
                    e[i]._headerLength   = f._headerLen;
                    e[i++]._headerOffset = headerLen;

                    headerLen += f._headerLen;
                }
                i = 0;
                VoidPtr wave = addr + headerLen;
                g._rebuildAddr->_waveDataOffset = (int)(wave - node._rebuildBase);
                foreach (RSARFileNode f in g.Files)
                {
                    f._rebuildAudioAddr = wave + audioLen;

                    f.Rebuild(addr, f._headerLen, true);
                    addr += f._headerLen;

                    e[i]._dataLength   = f._audioLen;
                    e[i++]._dataOffset = f._audioLen == 0 ? 0 : audioLen;

                    audioLen += f._audioLen;
                }

                addr += audioLen;
                g._rebuildAddr->_headerLength   = headerLen;
                g._rebuildAddr->_waveDataLength = audioLen;
            }

            len = ((int)addr - (int)(VoidPtr)header).Align(0x20);

            //Set header
            header->_header._tag    = FILEHeader.Tag;
            header->_header._length = len;

            return(len);
        }
        public void NewGroup()
        {
            RSARGroupNode node = new RSARGroupNode();

            node.Name = _resource.FindName("NewGroup");
            RSARFolderNode folder = _resource as RSARFolderNode;
            RSARNode       rsar   = folder.RSARNode;

            if (rsar != null)
            {
                node._infoIndex = rsar._infoCache[4].Count;
                rsar._infoCache[4].Add(node);
            }
            _resource.AddChild(node);
        }
Beispiel #4
0
        internal int CalculateSize(RSAREntryList entries, RSARNode node)
        {
            //Header
            _headerLen = 0x40;

            //SYMB, INFO, FILE Headers
            _symbLen = 0x20;
            _infoLen = 0x8;
            _fileLen = 0x20;

            #region SYMB

            //String offsets
            _symbLen += entries._strings.Count * 4;

            //Strings are packed tightly with no trailing pad
            _symbLen += entries._stringLength;

            //Mask entries
            _symbLen += 32;                                    //Headers
            _symbLen += (entries._strings.Count * 2 - 4) * 20; //Entries

            //Align
            _symbLen = _symbLen.Align(0x20);

            #endregion

            #region Info

            //Info ruint collection and ruint list counts
            _infoLen += 0x30;

            int sounds = 4, playerInfo = 4, banks = 4, groups = 4, files = 4;

            //ruint sizes
            sounds     += entries._sounds.Count * 8;
            playerInfo += entries._playerInfo.Count * 8;
            groups     += entries._groups.Count * 8;
            banks      += entries._banks.Count * 8 + 8;
            files      += entries._files.Count * 8;

            //Evaluate entries with child offsets
            foreach (RSAREntryState s in entries._sounds)
            {
                sounds += s._node.CalculateSize(true);
            }
            foreach (RSAREntryState s in entries._playerInfo)
            {
                playerInfo += s._node.CalculateSize(true);
            }
            foreach (RSAREntryState s in entries._banks)
            {
                banks += s._node.CalculateSize(true);
            }
            foreach (RSAREntryState s in entries._groups)
            {
                groups += s._node.CalculateSize(true);
            }
            groups += INFOGroupHeader.Size + 4; //Null group at the end
            groups += node._nullGroup.Files.Count * 32;
            foreach (RSARFileNode s in entries._files)
            {
                files += INFOFileHeader.Size + 4;
                if (!(s is RSARExtFileNode))
                {
                    files += s._groups.Count * (8 + INFOFileEntry.Size);
                }
                else
                {
                    files += (s._extPath.Length + 1).Align(4);
                }
            }

            //Footer and Align
            _infoLen = ((_infoLen += (sounds + banks + playerInfo + files + groups)) + 0x10).Align(0x20);

            #endregion

            #region File

            foreach (RSAREntryState r in entries._groups)
            {
                RSARGroupNode g = r._node as RSARGroupNode;
                foreach (RSARFileNode f in g.Files)
                {
                    _fileLen += f.CalculateSize(true);
                }
            }
            foreach (RSARFileNode f in node._nullGroup.Files)
            {
                _fileLen += f.CalculateSize(true);
            }

            //Align
            _fileLen = _fileLen.Align(0x20);

            #endregion

            return(_headerLen + _symbLen + _infoLen + _fileLen);
        }
Beispiel #5
0
        private void makeAllExternalToolStripMenuItem_Click(object sender, EventArgs e)
        {
            foreach (SoundPackItem i in lstSets.Items)
            {
                if (i._node is RSARExtFileNode)
                {
                    continue;
                }

                ListViewItem v        = i as ListViewItem;
                string       type     = v.SubItems[1].Text;
                string       dir      = "\\" + type + "\\";
                string       fileName = i._node.Name.Replace('/', '_').Replace('<', '(').Replace('>', ')') + ".b" + type.ToLower();

                string newPath = _targetNode._origPath.Substring(0, _targetNode._origPath.LastIndexOf('\\')) + dir;
                if (!Directory.Exists(newPath))
                {
                    Directory.CreateDirectory(newPath);
                }
                i._node.Export(newPath + fileName);

                RSARGroupNode[] groups = i._node.GroupRefNodes;

                //Contains lists of all instances of this file in each group
                List <int>[] refs = new List <int> [groups.Length];

                //Remove all references to this file
                for (int n = 0; n < groups.Length; ++n)
                {
                    refs[n] = new List <int>();
                    RSARGroupNode g = groups[n];
                    for (int m = 0; m < g._files.Count; ++m)
                    {
                        if (g._files[m] == i._node)
                        {
                            refs[n].Add(m);
                            g._files.RemoveAt(m--);
                        }
                    }
                }
                //if (i._node is RWSDNode)
                //{
                //    if (i._node.Children.Count > 0)
                //        foreach (RWSDDataNode d in i._node.Children[0].Children)
                //        {
                //            foreach (RSARSoundNode r in d._refs)
                //            {

                //            }
                //        }
                //}
                //else if (i._node is RSEQNode)
                //{
                //    foreach (RSEQLabelNode d in i._node.Children)
                //    {

                //    }
                //}
                //else
                List <RSARBankNode> rbnkRefs = null;
                if (i._node is RBNKNode)
                {
                    RBNKNode rbnk = i._node as RBNKNode;
                    rbnkRefs = rbnk._rsarBankEntries;
                    for (int j = 0; j < rbnk._rsarBankEntries.Count; ++j)
                    {
                        RSARBankNode b = rbnk._rsarBankEntries[j];
                        b.BankNode = null;
                    }
                    //if (i._node.Children.Count > 0)
                    //    foreach (RBNKDataEntryNode d in i._node.Children[0].Children)
                    //    {

                    //    }
                }

                _targetNode.Files.RemoveAt(i.Index);

                RSARExtFileNode ext = new RSARExtFileNode();
                ext._fileIndex = i.Index;
                ext._parent    = _targetNode;
                _targetNode.Files.Insert(i.Index, ext);

                ext.ExtPath = (dir + fileName).Replace('\\', '/');
                ext.Name    = String.Format("[{0}] {1}", i.Index, ext.ExtPath);

                if ((i._node is RBNKNode || i._node is RSARExtFileNode) && rbnkRefs != null)
                {
                    RBNKNode rbnk = i._node as RBNKNode;
                    foreach (RSARBankNode b in rbnkRefs)
                    {
                        b.BankNode = ext;
                    }
                }

                //Remake references
                for (int groupID = 0; groupID < refs.Length; ++groupID)
                {
                    int           r     = 0;
                    RSARGroupNode group = groups[groupID];
                    foreach (int occurrence in refs[groupID])
                    {
                        group._files.Insert(occurrence + r++, ext);
                    }

                    ext._groupRefs.Add(group);
                }

                i._node = ext;
            }
            _targetNode.IsDirty = true;
            Update(lstSets);
        }