public JazzGraphContainer(int index,
StateMachine sm, Control view, TabPage page)
{
this.Index = index;
this.mName = sm.Name;
this.UndoRedo = new UndoManager();
this.SaveState = JazzSaveState.Dirty;
this.Key = new RK(GlobalManager.kJazzTID, 0,
FNVHash.HashString64(this.mName));
this.Comp = true;
this.JP = null;
this.RIE = null;
this.Scene = new StateMachineScene(sm, view, this);
KKLayoutAlgorithm <StateNode, StateEdge> layout
= new KKLayoutAlgorithm <StateNode, StateEdge>(
this.Scene.StateGraph, this.Scene);
layout.LengthFactor = 1.25f;
this.Scene.Layout = layout;
layout.ShuffleNodes();
this.Scene.LayoutPaused = true;
this.Scene.StartLayout();
this.mPage = page;
this.mPage.Controls.Add(view);
this.mPage.Text = this.mName + " *";
this.mPage.SizeChanged +=
new EventHandler(this.OnTabSizeChanged);
}
protected virtual void Set(IResourceIndexEntry entry, IPackage package)
{
mEntry = entry;
mPackage = package;
mType = (ResourceType)mEntry.ResourceType;
if (mEntry != null)
{
// NameColumn
NameMapResource.NameMapResource nameMap = MainForm.CreateKeyResource(package) as NameMapResource.NameMapResource;
if ((nameMap != null) && (nameMap.ContainsKey(mEntry.Instance)))
{
Text = nameMap[mEntry.Instance];
}
// TagColumn
SubItems.Add(Type.ToString());
// Instance
mInstance = SubItems.Add(Instance);
// Filename
mFilename = SubItems.Add("");
}
}
/// <summary>
/// Tell the package to delete the resource indexed by <paramref name="rc"/>
/// </summary>
/// <param name="rc">Target resource index</param>
public override void DeleteResource(IResourceIndexEntry rc)
{
if (!rc.IsDeleted)
{
(rc as ResourceIndexEntry).Delete();
}
}
public JazzGraphContainer(int index, string name, Control view)
{
this.Index = index;
this.mName = name ?? "";
this.UndoRedo = new UndoManager();
this.SaveState = JazzSaveState.Dirty;
ulong iid = 0;
if (!this.mName.StartsWith("0x") ||
!ulong.TryParse(this.mName.Substring(2),
System.Globalization.NumberStyles.HexNumber,
null, out iid))
{
iid = FNVHash.HashString64(this.mName);
}
this.Key = new RK(GlobalManager.kJazzTID, 0, iid);
this.Comp = true;
this.JP = null;
this.RIE = null;
StateMachine sm = new StateMachine(name);
this.Scene = new StateMachineScene(sm, view, this);
KKLayoutAlgorithm <StateNode, StateEdge> layout
= new KKLayoutAlgorithm <StateNode, StateEdge>(
this.Scene.StateGraph, this.Scene);
layout.LengthFactor = 1.25f;
this.Scene.Layout = layout;
layout.ShuffleNodes();
this.Scene.LayoutPaused = true;
this.Scene.StartLayout();
}
void Add(IResourceIndexEntry rie)
{
Thread.Sleep(0); if (form.IsHandleCreated)
{
form.Invoke(addCB, new object[] { rie, });
}
}
protected virtual void Set(IResourceIndexEntry entry, IPackage package)
{
mEntry = entry;
mPackage = package;
mType = (ResourceType)mEntry.ResourceType;
if (mEntry != null)
{
// NameColumn
NameMapResource.NameMapResource nameMap = MainForm.CreateKeyResource(package) as NameMapResource.NameMapResource;
if ((nameMap != null) && (nameMap.ContainsKey(mEntry.Instance)))
{
Text = nameMap[mEntry.Instance];
}
// TagColumn
SubItems.Add(Type.ToString());
// Instance
mInstance = SubItems.Add(Instance);
// Filename
mFilename = SubItems.Add("");
}
}
private void BrowserWidget_ResourceIndexEntryChanged(object sender, EventArgs e)
{
IResourceIndexEntry rie = sender as IResourceIndexEntry;
if (rie == null)
{
return;
}
if (lookup == null)
{
return;
}
if (!lookup.ContainsKey(rie))
{
(rie as AResourceIndexEntry).ResourceIndexEntryChanged -= new EventHandler(BrowserWidget_ResourceIndexEntryChanged); return;
}
ListViewItem lvi = lookup[rie];
ListViewItem newlvi = CreateItem(rie);
listView1.SuspendLayout();
lvi.SubItems.Clear(); for (int i = 1; i < newlvi.SubItems.Count; i++)
{
lvi.SubItems.Add(newlvi.SubItems[i]);
}
lvi.Font = newlvi.Font;
lvi.Text = newlvi.Text;
listView1.ResumeLayout();
}
ListViewItem CreateItem(IResourceIndexEntry ie)
{
ListViewItem lvi = new ListViewItem();
if (ie.IsDeleted)
{
lvi.Font = new Font(lvi.Font, lvi.Font.Style | FontStyle.Strikeout);
}
for (int j = 0; j < fields.Count + 1; j++)
{
if (j == 0)
{
lvi.Text = ResourceName(ie);
}
else if (j == 1)
{
lvi.SubItems.Add(ResourceTag(ie));
}
else
{
lvi.SubItems.Add(ie[fields[j - 2]] + "");
}
}
lvi.Tag = ie;
(ie as AResourceIndexEntry).ResourceIndexEntryChanged -= new EventHandler(BrowserWidget_ResourceIndexEntryChanged);
(ie as AResourceIndexEntry).ResourceIndexEntryChanged += new EventHandler(BrowserWidget_ResourceIndexEntryChanged);
return(lvi);
}
bool importFile(string filename, TGIN tgin, bool useName, bool rename, bool compress, DuplicateHandling dups, bool select)
{
IResourceKey rk = (TGIBlock)tgin;
string resName = tgin.ResName;
bool nmOK = true;
MemoryStream ms = new MemoryStream();
BinaryWriter w = new BinaryWriter(ms);
BinaryReader r = new BinaryReader(new FileStream(filename, FileMode.Open, FileAccess.Read));
w.Write(r.ReadBytes((int)r.BaseStream.Length));
r.Close();
w.Flush();
if (useName && resName != null && resName.Length > 0)
{
nmOK = browserWidget1.ResourceName(rk.Instance, resName, true, rename);
}
IResourceIndexEntry rie = NewResource(rk, ms, dups, compress);
if (rie != null)
{
browserWidget1.Add(rie, select);
}
return(nmOK);
}
static bool FlagMatch(uint flags, IResourceIndexEntry values, IResourceIndexEntry target)
{
if (flags == 0)
{
return(true);
}
for (int i = 0; i < sizeof(uint); i++)
{
uint j = (uint)(1 << i);
if ((flags & j) == 0)
{
continue;
}
string f = values.ContentFields[i];
if (!target.ContentFields.Contains(f))
{
return(false);
}
if (!values[f].Equals(target[f]))
{
return(false);
}
}
return(true);
}
public void Add(IResourceIndexEntry rie, bool select = true)
{
AddRange(new[] { rie, });
if (select)
{
SelectedResource = rie;
}
}
public Save(string strPath)
{
nhdPath = strPath;
Package package = (Package)Package.OpenPackage(Path.Combine(Path.GetDirectoryName(strPath), "Meta.data"));
IResourceIndexEntry rie = package.Find(r => r.ResourceType == 1653241999U);
UnParse(S3PI.WrapperDealer.GetResource(package, rie).Stream);
}
/// <summary>
/// Initialise a new helpers list for a given resource
/// </summary>
/// <param name="key">The resource index entry</param>
/// <param name="res">The resource</param>
/// <param name="resname">(Optional) The resource name</param>
public HelperManager(IResourceIndexEntry key, IResource res, string resname = null)
{
if (helpers == null)
{
ReadConfig();
}
if (res == null || key == null)
{
return;
}
string wrapper = res.GetType().Name.ToLower();
foreach (string cfg in helpers.Keys)
{
Dictionary <string, string> match = null;
foreach (string kwd in helpers[cfg].Keys)
{
if (kwd.Equals("wrapper"))
{
if ((new List <string>(helpers[cfg]["wrapper"].Split(' '))).Contains("*"))
{
match = helpers[cfg]; goto matched;
}
if ((new List <string>(helpers[cfg]["wrapper"].ToLower().Split(' '))).Contains(wrapper))
{
match = helpers[cfg]; goto matched;
}
continue;
}
if (reserved.Contains(kwd))
{
continue;
}
if (keywords.Contains(kwd))
{
if ((new List <string>(helpers[cfg][kwd].Split(' '))).Contains("" + key[kwd]))
{
match = helpers[cfg]; goto matched;
}
if ((new List <string>(helpers[cfg][kwd].Split(' '))).Contains("*"))
{
match = helpers[cfg]; goto matched;
}
continue;
}
}
matched:
if (match != null)
{
this.Add(new Helper(match, new s3pi.Extensions.TGIN(key, resname), res));
}
}
}
bool IEquatable <IResourceIndexEntry> .Equals(
IResourceIndexEntry other)
{
if (this.RIE == null)
{
return(false);
}
return(this.RIE.Equals(other));
}
public JazzGraphContainer(int index, JazzPackage jp,
IResourceIndexEntry rie, Control view, TabPage page)
{
this.Index = index;
this.UndoRedo = new UndoManager();
this.SaveState = JazzSaveState.Saved;
this.Key = new RK(rie);
this.Comp = rie.Compressed == 0xFFFF;
this.JP = jp;
this.RIE = rie;
IResource res = null;
GenericRCOLResource rcol = null;
try
{
res = WrapperDealer.GetResource(0, jp.Package, rie);
}
catch (Exception ex)
{
MainForm.ShowException(ex,
"Could not load JAZZ resource: " + this.Key + "\n",
MainForm.kName + ": Unable to load JAZZ resource");
}
if (res != null)
{
rcol = res as GenericRCOLResource;
if (rcol != null)
{
this.Scene = new StateMachineScene(
new StateMachine(rcol), view, this);
KKLayoutAlgorithm <StateNode, StateEdge> layout
= new KKLayoutAlgorithm <StateNode, StateEdge>(
this.Scene.StateGraph, this.Scene);
layout.LengthFactor = 1.25f;
this.Scene.Layout = layout;
layout.ShuffleNodes();
this.Scene.LayoutPaused = true;
this.Scene.StartLayout();
}
else
{
this.Scene = null;
}
}
if (!KeyNameReg.TryFindName(rie.Instance, out this.mName))
{
this.mName = "0x" + rie.Instance.ToString("X16");
}
if (this.Scene != null)
{
this.mPage = page;
this.mPage.Controls.Add(view);
this.mPage.Text = this.mName;
this.mPage.SizeChanged +=
new EventHandler(this.OnTabSizeChanged);
}
}
public Resource FindResource(Predicate <IResourceKey> Match)
{
IResourceIndexEntry rie = _package.Find(Match);
if (rie == null)
{
return(default(Resource));
}
return(GetResource(rie));
}
/// <summary>
/// Add a resource, identified by <paramref name="rk"/> with the content from <paramref name="stream"/>
/// the package referenced by this <see cref="PathPackageTuple"/>. The new <see cref="SpecificResource"/>
/// value is returned.
/// </summary>
/// <param name="rk">The <see cref="IResourceKey"/> to use to identify the new resource.</param>
/// <param name="stream">A <see cref="Stream"/> of data to use to populate the new resource.</param>
/// <returns>The <see cref="SpecificResource"/> representing the newly added <see cref="IResourceIndexEntry"/>.</returns>
public SpecificResource AddResource(IResourceKey rk, Stream stream = null)
{
IResourceIndexEntry rie = Package.AddResource(rk, stream, true);
if (rie == null)
{
return(null);
}
return(new SpecificResource(this, rie));
}
protected static Dictionary <ulong, STBLImporter.Lookup> ReadTable(string prefix, string instance, IPackage package, bool addOtherKeys)
{
instance = prefix + instance.Substring(4);
Dictionary <ulong, STBLImporter.Lookup> lookup = new Dictionary <ulong, STBLImporter.Lookup>();
IResourceIndexEntry entry = package.Find(key => ((key.ResourceType == (uint)ResourceType.STBL) && (key["Instance"] == instance)));
if (entry != null)
{
StblResource.StblResource resource = ResourceHandlers.CreateResource(entry, package) as StblResource.StblResource;
foreach (KeyValuePair <ulong, string> element in resource)
{
bool space = false;
string keyValue = element.Value;
if (prefix == "0x17")
{
if (keyValue.StartsWith("PackerSpace|"))
{
keyValue = keyValue.Replace("PackerSpace|", "");
space = true;
}
}
if (!lookup.ContainsKey(element.Key))
{
STBLImporter.Lookup recent = new STBLImporter.Lookup(keyValue, keyValue, space);
lookup.Add(element.Key, recent);
}
if ((addOtherKeys) && (!HasSuffix(keyValue)))
{
foreach (string suffix in sSuffixes)
{
string value = keyValue + suffix;
ulong key = FNV64.GetHash(value);
if (lookup.ContainsKey(key))
{
continue;
}
STBLImporter.Lookup recent = new STBLImporter.Lookup(value, value, space);
lookup.Add(key, recent);
}
}
}
}
return(lookup);
}
static bool NameMatch(string[] names, TypedValue[] values, IResourceIndexEntry target)
{
for (int i = 0; i < names.Length; i++)
{
if (!target.ContentFields.Contains(names[i]) || !values[i].Equals(target[names[i]]))
{
return(false);
}
}
return(true);
}
public Resource GetResource(IResourceIndexEntry rie)
{
IResource res = WrapperDealer.GetResource(0, _package, rie);
if (res != null)
{
res.ResourceChanged += new EventHandler(OnResourceChanged);
}
return(new Resource {
IResourceIndexEntry = rie, IResource = res
});
}
public Resource GetResource(uint resourceType, uint resourceGroup, ulong instance)
{
IResourceIndexEntry rie = _package.Find(x =>
x.ResourceType == resourceType && x.ResourceGroup == resourceGroup && x.Instance == instance);
if (rie == null)
{
return(default(Resource));
}
return(GetResource(rie));
}
public static IResource CreateKeyResource(IPackage package)
{
IResourceIndexEntry key = package.Find(value => value.ResourceType == (uint)ResourceType._KEY);
if (key == null)
{
return(null);
}
else
{
return(ResourceHandlers.CreateResource(key, package));
}
}
public static void AddFiles(IPackage package, List <string> sourceFilePaths)
{
List <TGIN> addedResourceKeys = new List <TGIN>();
for (int sourceFilePathIndex = 0; sourceFilePathIndex < sourceFilePaths.Count; sourceFilePathIndex++)
{
string sourceInfoFilePath = sourceFilePaths[sourceFilePathIndex] + "." + SourceInfoFileExtension;
TGIN targetResourceKeyTGIN = Path.GetFileName(sourceFilePaths[sourceFilePathIndex]);
if (File.Exists(sourceInfoFilePath))
{
try {
SourceInfo sourceInfo = (SourceInfo)Tools.ReadXML <SourceInfo>(sourceInfoFilePath);
targetResourceKeyTGIN = sourceInfo.ToTGIN();
} catch (Exception e) {
Console.Error.Write("Failed to read source info file.\n" + sourceInfoFilePath + "\n" + e.ToString());
}
}
AResourceKey targetResourceKey = targetResourceKeyTGIN;
MemoryStream sourceStream = new MemoryStream();
BinaryWriter sourceStreamWriter = new BinaryWriter(sourceStream);
using (BinaryReader sourceFileReader = new BinaryReader(new FileStream(sourceFilePaths[sourceFilePathIndex], FileMode.Open, FileAccess.Read))) {
sourceStreamWriter.Write(sourceFileReader.ReadBytes((int)sourceFileReader.BaseStream.Length));
sourceStreamWriter.Flush();
}
IResourceIndexEntry targetPreviousEntry = package.Find(targetResourceKey.Equals);
while (targetPreviousEntry != null)
{
package.DeleteResource(targetPreviousEntry);
targetPreviousEntry = package.Find(targetResourceKey.Equals);
}
IResourceIndexEntry targetEntry = package.AddResource(targetResourceKey, sourceStream, false);
if (targetEntry == null)
{
continue;
}
targetEntry.Compressed = 23106;
addedResourceKeys.Add(targetResourceKeyTGIN);
}
GenerateNameMap(package, addedResourceKeys, null);
}
public string ResourceTag(IResourceIndexEntry rie)
{
string key = rie["ResourceType"];
if (s4pi.Extensions.ExtList.Ext.ContainsKey(key))
{
return(s4pi.Extensions.ExtList.Ext[key][0]);
}
if (s4pi.Extensions.ExtList.Ext.ContainsKey("*"))
{
return(s4pi.Extensions.ExtList.Ext["*"][0]);
}
return("");
}
void importStream(myDataFormat data, bool useName, bool rename, bool compress, DuplicateHandling dups, bool select)
{
if (useName && data.tgin.ResName != null && data.tgin.ResName.Length > 0)
{
browserWidget1.ResourceName(data.tgin.ResInstance, data.tgin.ResName, true, rename);
}
IResourceIndexEntry rie = NewResource((TGIBlock)data.tgin, new MemoryStream(data.data), dups, compress);
if (rie != null)
{
browserWidget1.Add(rie, select);
}
}
public static ListItem CreateHandler(IResourceIndexEntry entry, IPackage package)
{
ResourceType type = (ResourceType)entry.ResourceType;
ListItem item;
if (Handlers.TryGetValue(type, out item))
{
item = item.Clone() as ListItem;
item.Set(entry, package);
return(item);
}
return(null);
}
void Add(IResourceIndexEntry rie)
{
XmlElement key = CreateElement("reskey", string.Format("1:{0:x8}:{1:x8}:{2:x16}", rie.ResourceType, rie.ResourceGroup, rie.Instance));
KeyList.AppendChild(key);
if (icons.Contains(rie.ResourceType))
{
NumOfThumbs.InnerText = "" + ++numofthumbs;
Document.DocumentElement.AppendChild(CreateElement("thumbnail", string.Format("{0:x8}:{1:x8}:{2:x16}", rie.ResourceType, rie.ResourceGroup, rie.Instance)));
}
if (catlgResTypes.Contains(rie.ResourceType))
{
numofCatlgResources++;
}
}
/// <summary>
/// Add a resource to the package
/// </summary>
/// <param name="rk">The resource key</param>
/// <param name="stream">The stream that contains the resource data</param>
/// <param name="rejectDups">If true, fail if the resource key already exists</param>
/// <returns>Null if rejectDups and the resource key exists; else the new IResourceIndexEntry</returns>
public override IResourceIndexEntry AddResource(IResourceKey rk, Stream stream, bool rejectDups)
{
if (rejectDups && Index[rk] != null && !Index[rk].IsDeleted)
{
return(null);
}
IResourceIndexEntry newrc = Index.Add(rk);
if (stream != null)
{
(newrc as ResourceIndexEntry).ResourceStream = stream;
}
return(newrc);
}
public bool IsKindred(IResourceIndexEntry rie)
{
if (this.KinHelper.IsKindred(this.ParentKey, rie))
{
RK rk = new RK(rie);
for (int i = 0; i < this.Seen.Count; i++)
{
if (rk.Equals(this.Seen[i]))
{
return(false);
}
}
return(true);
}
return(false);
}
public static IResource CreateResource(IResourceIndexEntry entry, IPackage package)
{
Type t = GetHandler(entry["ResourceType"]);
if (t == null) return null;
APackage localPackage = package as APackage;
try
{
return t.GetConstructor(new Type[] { typeof(int), typeof(Stream), }).Invoke(new object[] { 0, localPackage.GetResource(entry) }) as IResource;
}
catch
{ }
return null;
}
private void UnParse(Stream s)
{
BinaryReader binaryReader = new BinaryReader(s);
binaryReader.ReadInt32();
StringBuilder stringBuilder = new StringBuilder();
int num1 = checked (binaryReader.ReadInt32() - 1);
int num2 = 0;
while (num2 <= num1)
{
short num3 = binaryReader.ReadInt16();
stringBuilder.Append((char)num3);
checked { ++num2; }
}
stringBuilder.Append(' ');
int num4 = checked (binaryReader.ReadInt32() - 1);
int num5 = 0;
while (num5 <= num4)
{
short num3 = binaryReader.ReadInt16();
stringBuilder.Append((char)num3);
checked { ++num5; }
}
WorldName = stringBuilder.ToString();
binaryReader.ReadInt32();
IPackage pkg = Package.OpenPackage(nhdPath);
ImgInstance = binaryReader.ReadUInt64();
IResourceIndexEntry rie = pkg.Find(entry => (long)entry.Instance == (long)ImgInstance & entry.ResourceType == 1802339198U);
if (rie != null)
{
FamilyIcon = new Bitmap(S3PI.WrapperDealer.GetResource(pkg, rie).Stream);
}
else
{
FamilyIcon = App.GetResource <DrawingImage>("UnknownIcon");
}
binaryReader.ReadUInt64();
}
public string ResourceName(IResourceIndexEntry rie)
{
if (!displayResourceNames)
{
return("");
}
if (nameMap == null)
{
return("");
}
foreach (IDictionary <ulong, string> nmap in nameMap)
{
if (nmap.ContainsKey(rie.Instance))
{
return(nmap[rie.Instance]);
}
}
return("");
}
public abstract List<IResourceIndexEntry> FindAll(uint flags, IResourceIndexEntry values);
public TextImporter(IResourceIndexEntry entry)
: base (entry)
{ }
public GoEventArgs(IResourceIndexEntry rie) { this.rie = rie; }
private static bool IsSTBL(IResourceIndexEntry rie)
{
return rie.ResourceType == STBL_TID;
}
static bool FlagMatch(uint flags, IResourceIndexEntry values, IResourceIndexEntry target)
{
if (flags == 0) return true;
for (int i = 0; i < sizeof(uint); i++)
{
uint j = (uint)(1 << i);
if ((flags & j) == 0) continue;
string f = values.ContentFields[i];
if (!target.ContentFields.Contains(f)) return false;
if (!values[f].Equals(target[f])) return false;
}
return true;
}
// Required by API, not user tools
/// <summary>
/// Required internally by s3pi - <b>not</b> for use in user tools.
/// Please use <c>WrapperDealer.GetResource(int, IPackage, IResourceIndexEntry)</c> instead.
/// </summary>
/// <param name="rie">IResourceIndexEntry of resource</param>
/// <returns>The resource data (uncompressed, if necessary)</returns>
/// <remarks>Used by WrapperDealer to get the data for a resource.</remarks>
public abstract Stream GetResource(IResourceIndexEntry rie);
public IMAGImporter(IResourceIndexEntry entry)
: base (entry)
{ }
private static bool IsEffectResource(IResourceIndexEntry entry)
{
return entry.ResourceType == kEffectTID;
}
/// <summary>
/// Tell the package to replace the data for the resource indexed by <paramref name="rc"/>
/// with the data from the resource <paramref name="res"/>
/// </summary>
/// <param name="rc">Target resource index</param>
/// <param name="res">Source resource</param>
public override void ReplaceResource(IResourceIndexEntry rc, IResource res) { (rc as ResourceIndexEntry).ResourceStream = res.Stream; }
// Required by API, not user tools
/// <summary>
/// Required internally by s3pi - <b>not</b> for use in user tools.
/// Please use <c>WrapperDealer.GetResource(int, IPackage, IResourceIndexEntry)</c> instead.
/// </summary>
/// <param name="rc">IResourceIndexEntry of resource</param>
/// <returns>The resource data (uncompressed, if necessary)</returns>
/// <remarks>Used by WrapperDealer to get the data for a resource.</remarks>
public override Stream GetResource(IResourceIndexEntry rc)
{
ResourceIndexEntry rie = rc as ResourceIndexEntry;
if (rie == null) return null;
if (rie.ResourceStream != null) return rie.ResourceStream;
if (rc.Chunkoffset == 0xffffffff) return null;
packageStream.Position = rc.Chunkoffset;
byte[] data = null;
if (rc.Filesize == 1 && rc.Memsize == 0xFFFFFFFF) return null;//{ data = new byte[0]; }
else if (rc.Filesize == rc.Memsize)
{
data = (new BinaryReader(packageStream)).ReadBytes((int)rc.Filesize);
}
else
{
data = Compression.UncompressStream(packageStream, (int)rc.Filesize, (int)rc.Memsize);
}
MemoryStream ms = new MemoryStream();
ms.Write(data, 0, data.Length);
ms.Position = 0;
return ms;
}
/// <summary>
/// Tell the package to delete the resource indexed by <paramref name="rc"/>
/// </summary>
/// <param name="rc">Target resource index</param>
public override void DeleteResource(IResourceIndexEntry rc)
{
if (!rc.IsDeleted)
(rc as ResourceIndexEntry).Delete();
}
void Add(IResourceIndexEntry rie)
{
lbxHits.Items.Add(fromRIE(rie));
lrie.Add(rie);
}
bool search(IResourceIndexEntry rie)
{
IResource res = s4pi.WrapperDealer.WrapperDealer.GetResource(0, pkg, rie, true);// we're searching bytes
byte[] resBytes = res.AsBytes;
for (int i = 0; i < resBytes.Length - pattern.Length; i++)
{
for (int j = 0; j < pattern.Length; j++)
if (resBytes[i + j] != pattern[j]) goto fail;
return true;
fail: { }
}
return false;
}
void Add(IResourceIndexEntry rie) { Thread.Sleep(0); if (form.IsHandleCreated) form.Invoke(addCB, new object[] { rie, }); }
/// <summary> /// Tell the package to replace the data for the resource indexed by <paramref name="rc"/> /// with the data from the resource <paramref name="res"/> /// </summary> /// <param name="rc">Target resource index</param> /// <param name="res">Source resource</param> public abstract void ReplaceResource(IResourceIndexEntry rc, IResource res);
public static bool IsNameMap(IResourceIndexEntry rie)
{
return rie.ResourceType == NameMapTID;
}
/// <summary> /// Tell the package to delete the resource indexed by <paramref name="rc"/> /// </summary> /// <param name="rc">Target resource index</param> public abstract void DeleteResource(IResourceIndexEntry rc);
public override List<IResourceIndexEntry> FindAll(uint flags, IResourceIndexEntry values) { return Index.FindAll(x => !x.IsDeleted && FlagMatch(flags, values, x)); }
public S3SAImporter(IResourceIndexEntry entry)
: base (entry)
{ }
static bool NameMatch(string[] names, TypedValue[] values, IResourceIndexEntry target)
{
for (int i = 0; i < names.Length; i++) if (!target.ContentFields.Contains(names[i]) || !values[i].Equals(target[names[i]])) return false;
return true;
}
public STBLExporter(IResourceIndexEntry entry)
: base (entry)
{ }
private void exportFile(IResourceIndexEntry rie, string filename)
{
IResource res = s4pi.WrapperDealer.WrapperDealer.GetResource(0, CurrentPackage, rie, true);//Don't need wrapper
Stream s = res.Stream;
s.Position = 0;
if (s.Length != rie.Memsize) CopyableMessageBox.Show(String.Format("Resource stream has {0} bytes; index entry says {1}.", s.Length, rie.Memsize));
BinaryWriter w = new BinaryWriter(new FileStream(filename, FileMode.Create));
w.Write((new BinaryReader(s)).ReadBytes((int)s.Length));
w.Close();
}
/// <summary> /// Indicates whether the current <see cref="IResourceIndexEntry"/> instance is equal to another <see cref="IResourceIndexEntry"/> instance. /// </summary> /// <param name="other">An <see cref="IResourceIndexEntry"/> instance to compare with this instance.</param> /// <returns>true if the current instance is equal to the <paramref name="other"/> parameter; otherwise, false.</returns> public abstract bool Equals(IResourceIndexEntry other);
private void exportResourceToPackage(IPackage tgtpkg, IResourceIndexEntry srcrie, bool replace)
{
IResourceIndexEntry rie = tgtpkg.Find(x => ((IResourceKey)srcrie).Equals(x));
if (rie != null)
{
if (!replace) return;
tgtpkg.DeleteResource(rie);
}
rie = tgtpkg.AddResource(srcrie, null, true);
if (rie == null) return;
rie.Compressed = srcrie.Compressed;
IResource srcres = s4pi.WrapperDealer.WrapperDealer.GetResource(0, CurrentPackage, srcrie, true);//Don't need wrapper
tgtpkg.ReplaceResource(rie, srcres);
}
private static bool IsCTPT(IResourceIndexEntry rie)
{
return (CatalogType)rie.ResourceType == CatalogType.CatalogTerrainPaintBrush;
}
public abstract IResourceIndexEntry Find(uint flags, IResourceIndexEntry values);
public string ResourceTag(IResourceIndexEntry rie)
{
string key = rie["ResourceType"];
if (s4pi.Extensions.ExtList.Ext.ContainsKey(key)) return s4pi.Extensions.ExtList.Ext[key][0];
if (s4pi.Extensions.ExtList.Ext.ContainsKey("*")) return s4pi.Extensions.ExtList.Ext["*"][0];
return "";
}
string fromRIE(IResourceIndexEntry rie) { return (rie as AResourceKey) + ""; }