public static void Main(string[] args)
{
const bool validate = true;
CacheFile cache;
var fileBytes = File.ReadAllBytes(args[0]);
using (var input = new MemoryStream(fileBytes, false))
{
cache = CacheFile.Load(input, validate);
}
RemoveStaticArraySizeUsage(cache);
var mySourceFile = new SourceFileDefinition(@"_\gibbed\exec.script");
cache.Definitions.Add(mySourceFile);
AddExecCommandSTS(cache, mySourceFile);
AddMinimapScaler(cache);
PatchJohnnySkillChecks(cache);
byte[] testCacheBytes;
using (var output = new MemoryStream())
{
cache.Save(output);
output.Flush();
testCacheBytes = output.ToArray();
}
File.WriteAllBytes("test_patch.redscripts", testCacheBytes);
}
static void Main(string[] args)
{
System.IO.Directory.CreateDirectory("Red4Assembler/debug");
System.IO.Directory.CreateDirectory("Red4Assembler/tests");
var scriptFile = "final.redscripts";
if (args.Length > 0 && string.IsNullOrWhiteSpace(args[0]) == false)
{
scriptFile = args[0];
}
const bool validate = true;
CacheFile scriptCacheFile;
var fileBytes = File.ReadAllBytes(scriptFile);
using (var input = new MemoryStream(fileBytes, false))
scriptCacheFile = CacheFile.Load(input, validate);
var functionBodyScripts =
scriptCacheFile.Definitions
.OfType <FunctionDefinition>()
.Where(t => t.Flags.HasFlag(FunctionFlags.HasBody))
.OrderBy(f => f.SourceFile?.Path)
.ThenBy(f => f.SourceLine)
.ToArray();
var dism = new FunctionDissembler();
System.IO.File.WriteAllText("Red4Assembler/tests/GetActionAnimationSlideParams.non_ref.ws", dism.Dissemble(functionBodyScripts[0]));
System.IO.File.WriteAllText("Red4Assembler/tests/GetActionAnimationSlideParams.ref_param.ws", dism.Dissemble(functionBodyScripts[1]));
// Console.ReadLine();
}
private KeyValuePair <CacheFile, bool> EvaluateCacheFile()
{
CacheFile cacheFile;
var newDgSpecHash = _request.DependencyGraphSpec.GetHash();
var noOp = false;
if (_request.AllowNoOp && File.Exists(_request.Project.RestoreMetadata.CacheFilePath))
{
cacheFile = CacheFileFormat.Load(_request.Project.RestoreMetadata.CacheFilePath, _logger);
if (cacheFile.IsValid && StringComparer.Ordinal.Equals(cacheFile.DgSpecHash, newDgSpecHash))
{
_logger.LogVerbose(string.Format(CultureInfo.CurrentCulture, Strings.Log_RestoreNoOpFinish, _request.Project.Name));
_success = true;
noOp = true;
}
else
{
cacheFile = new CacheFile(newDgSpecHash);
_logger.LogVerbose(string.Format(CultureInfo.CurrentCulture, Strings.Log_RestoreNoOpDGChanged, _request.Project.Name));
}
}
else
{
cacheFile = new CacheFile(newDgSpecHash);
}
return(new KeyValuePair <CacheFile, bool>(cacheFile, noOp));
}
private void exportToolStripMenuItem_Click(object sender, EventArgs e)
{
if (m_cacheFile == null)
{
return;
}
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = "Archive Dictonary file (*.tad)|*.tad";
if (saveFileDialog.ShowDialog() == DialogResult.OK)
{
string tadPath = saveFileDialog.FileName;
m_cacheFile.Export(tadPath);
m_tadFile = new TADFile(tadPath);
FilenameDatabase.MapFilenamesToTAD(m_tadFile);
DescriptionDatabase.MapDescriptionToTAD(m_tadFile);
if (System.Diagnostics.Debugger.IsAttached)
{
if (MessageBox.Show("Do you want to unpack the TAC file?", "Unpack TAC", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
{
tadDataTable1.SetTAD(m_tadFile);
}
}
m_cacheFile = new CacheFile(m_tadFile);
m_cacheFile.Unpack();
tadDataTable1.SetCache(m_cacheFile);
}
}
public RestoreResult(
bool success,
IEnumerable <RestoreTargetGraph> restoreGraphs,
IEnumerable <CompatibilityCheckResult> compatibilityCheckResults,
IEnumerable <MSBuildOutputFile> msbuildFiles,
LockFile lockFile,
LockFile previousLockFile,
string lockFilePath,
CacheFile cacheFile,
string cacheFilePath,
string packagesLockFilePath,
PackagesLockFile packagesLockFile,
string dependencyGraphSpecFilePath,
DependencyGraphSpec dependencyGraphSpec,
ProjectStyle projectStyle,
TimeSpan elapsedTime)
{
Success = success;
RestoreGraphs = restoreGraphs;
CompatibilityCheckResults = compatibilityCheckResults;
MSBuildOutputFiles = msbuildFiles;
LockFile = lockFile;
LockFilePath = lockFilePath;
PreviousLockFile = previousLockFile;
CacheFile = cacheFile;
CacheFilePath = cacheFilePath;
_newPackagesLockFilePath = packagesLockFilePath;
_newPackagesLockFile = packagesLockFile;
_dependencyGraphSpecFilePath = dependencyGraphSpecFilePath;
_dependencyGraphSpec = dependencyGraphSpec;
ProjectStyle = projectStyle;
ElapsedTime = elapsedTime;
}
public override byte[] EncodeFile(CacheFile file, CacheFileInfo?info)
{
var data = file.HasEntries ? this.EncodeEntries(file.Entries, info) : file.Data;
var compressionType = info?.CompressionType ?? CompressionType.Zlib;
if (compressionType == CompressionType.Zlib)
{
using var encodedDataStream = new MemoryStream();
using var encodedDataWriter = new BinaryWriter(encodedDataStream);
encodedDataWriter.Write((byte)'Z');
encodedDataWriter.Write((byte)'L');
encodedDataWriter.Write((byte)'B');
encodedDataWriter.Write((byte)0x01);
encodedDataWriter.WriteInt32BigEndian(data.Length);
encodedDataWriter.Write((byte)0x78);
encodedDataWriter.Write((byte)0x9C);
using (var compressionStream = new DeflateStream(encodedDataStream, CompressionMode.Compress))
using (var compressionWriter = new BinaryWriter(compressionStream))
{
compressionWriter.Write(data);
}
// Info is not changed for zlib because info does not describe zlib data.
return(encodedDataStream.ToArray());
}
return(this.EncodeData(data, info));
}
internal void ReconstructHack(CacheFile c, Cache.CacheFileLanguagePackResource english)
{
var interop = new Cache.CacheFileLanguageHandleInterop[((int)LanguageType.English) + 1];
for (int x = 0; x < interop.Length; x++)
{
interop[x] = new Cache.CacheFileLanguageHandleInterop();
}
int total_string_buffer_size = 0;
// For each language, get the string data referenced by this tag
for (LanguageType lang = LanguageType.English; lang < (LanguageType.English + 1); lang++)
{
total_string_buffer_size = interop[(int)lang].Initialize( //clpi.LanguagePackGet(lang),
english,
total_string_buffer_size, LanguageHandles[(int)lang]);
}
// Resize the string data container to have enough memory for all of our language strings
this.StringData.Value = new byte[total_string_buffer_size];
// For each language, copy the string data and initialize the reference blocks
for (LanguageType lang = LanguageType.English; lang < (LanguageType.English + 1); lang++)
{
interop[(int)lang].ReconstructTagData(c, this, (int)lang);
}
// Null the handles for the extracted tag
foreach (var handle in LanguageHandles)
{
handle.Value = 0;
}
}
public void WhenNoOpRestoreResult_LogMessagesAreSourcedFromTheCacheFile()
{
// Arrange
var expectedLogLevel = NuGetLogCode.NU1500;
var assetsLogMessage = new AssetsLogMessage(LogLevel.Error, NuGetLogCode.NU1501, "a");
var cacheLogMessage = new AssetsLogMessage(LogLevel.Error, expectedLogLevel, "a");
var lockFile = new LockFile();
lockFile.LogMessages.Add(assetsLogMessage);
var cacheFile = new CacheFile("hash")
{
Success = true,
LogMessages = new List <IAssetsLogMessage>()
{
cacheLogMessage
},
};
// Act
var result = new NoOpRestoreResult(
success: true,
lockFilePath: "project.assets.json",
new Lazy <LockFile>(() => lockFile),
cacheFile: cacheFile,
cacheFilePath: "cachepath",
projectStyle: ProjectStyle.PackageReference,
elapsedTime: TimeSpan.MinValue);
// Assert
result.LogMessages.Should().NotBeNull();
result.LogMessages.Should().HaveCount(1);
result.LogMessages.Single().Code.Should().Be(expectedLogLevel);
}
public static void Main(string[] args)
{
const bool validate = true;
CacheFile cache;
var fileBytes = File.ReadAllBytes(args[0]);
using (var input = new MemoryStream(fileBytes, false))
{
cache = CacheFile.Load(input, validate);
}
byte[] testCacheBytes;
using (var output = new MemoryStream())
{
cache.Save(output);
output.Flush();
testCacheBytes = output.ToArray();
}
File.WriteAllBytes("test_roundtrip.redscripts", testCacheBytes);
CacheFile testCache;
using (var input = new MemoryStream(testCacheBytes, false))
{
testCache = CacheFile.Load(input, validate);
}
DumpExecCallableFunctions(cache);
DumpFunctions(cache, validate);
DumpEnumerations(cache);
}
public void InitialScan()
{
CacheFile loadedCache = null;
if (File.Exists(cachePath))
{
try
{
loadedCache = JsonConvert.DeserializeObject <CacheFile>(File.ReadAllText(cachePath));
}
catch (Exception ex)
{
Trace.TraceWarning("Warning: problem reading scanner cache: {0}", ex);
loadedCache = null;
}
}
if (loadedCache != null)
{
cache = loadedCache;
}
Rescan();
Trace.TraceInformation("Initial scan done");
}
public static void Main(string[] args)
{
if (args[0].Length == 0)
{
throw new ArgumentException("You must provide a final.redscripts file!");
}
byte[] fileBytes = File.ReadAllBytes(args[0]);
using MemoryStream input = new MemoryStream(fileBytes, false);
using MemoryStream output = new MemoryStream();
cache = CacheFile.Load(input, false);
cg = new CodeGenerator();
CreateNatives();
CreateFunctions();
ApplyPatches();
cache.Save(output);
output.Flush();
File.WriteAllBytes("output.redscripts", output.ToArray());
}
public static T GetDefinition <T>(this CacheFile cache, string name)
where T : Definition
{
return(cache.Definitions
.OfType <T>()
.Single(d => d.Name == name));
}
private static void RemoveStaticArraySizeUsage(CacheFile cache)
{
foreach (var function in cache.Definitions
.OfType <FunctionDefinition>()
.Where(fd => (fd.Flags & FunctionFlags.HasCode) != 0))
{
for (int i = 0; i < function.Code.Count;)
{
if (function.Code[i].Opcode != Opcode.StaticArraySize)
{
i++;
continue;
}
var staticArrayType = (NativeDefinition)function.Code[i].Argument;
if (staticArrayType.NativeType != NativeType.StaticArray)
{
throw new InvalidOperationException();
}
// replace StaticArraySize with int constant
var staticArraySize = staticArrayType.ArraySize;
function.Code[i] = staticArraySize switch
{
0 => new Instruction(Opcode.Int32Zero),
1 => new Instruction(Opcode.Int32One),
_ => new Instruction(Opcode.Int32Const, staticArraySize)
};
// replace referencing of static array with a nop
function.Code[i + 1] = new Instruction(Opcode.Nop);
i += 2;
}
}
}
private static BitmapTextureInteropResource GetResourceDefinition(CacheFile cache, DatumIndex handle)
{
var resourceEntry = cache.ResourceGestalt.TagResources[handle.Index];
var definitionData = cache.ResourceGestalt.FixupInformation.Skip(resourceEntry.FixupInformationOffset).Take(resourceEntry.FixupInformationLength).ToArray();
BitmapTextureInteropResource definition;
using (var definitionStream = new MemoryStream(definitionData, true))
using (var definitionReader = new EndianReader(definitionStream, EndianFormat.BigEndian))
using (var definitionWriter = new EndianWriter(definitionStream, EndianFormat.BigEndian))
{
foreach (var fixup in resourceEntry.ResourceFixups)
{
var newFixup = new TagResourceGen3.ResourceFixup
{
BlockOffset = (uint)fixup.BlockOffset,
Address = new CacheAddress(CacheAddressType.Definition, fixup.Offset)
};
definitionStream.Position = newFixup.BlockOffset;
definitionWriter.Write(newFixup.Address.Value);
}
var dataContext = new DataSerializationContext(definitionReader, definitionWriter, CacheAddressType.Definition);
definitionStream.Position = resourceEntry.DefinitionAddress.Offset;
definition = cache.Deserializer.Deserialize <BitmapTextureInteropResource>(dataContext);
}
return(definition);
}
/**
* Create mesh by tile map data
*/
private IEnumerator CreateMeshByTileMapFile()
{
string sampleURL = GetURL();
// Start a download of the given URL
WWW www = CacheFile.LoadOrDownLoad(sampleURL, new TileMapUrlParse(Settings.TILE_MAP_FILE_FOLDER), this);
// Wait for download to complete
yield return(www);
if (www.error == null)
{
//Get HeigtMap
int multiplier = 1;
IHeightMapReader heightMapReader;
if (!IsUseToggle)
{
heightMapReader = new TextHeightMapReader(www.text);
multiplier = 10;
}
else
{
Texture2D texture2D = new Texture2D(www.texture.width, www.texture.height);
www.LoadImageIntoTexture(texture2D);
heightMapReader = new TextureHeightMapReader(texture2D);
}
//Get height map
HeightMap = heightMapReader.Read(multiplier, ZoomLevel);
//Create mesh action
CreateMeshByHeightMap();
}
}
private static bool HasSecondaryResource(CacheFile cache, DatumIndex handle)
{
var resourceEntry = cache.ResourceGestalt.TagResources[handle.Index];
var segmentIndex = resourceEntry.SegmentIndex;
var segment = cache.ResourceLayoutTable.Segments[segmentIndex];
return(segment.OptionalPageIndex != -1);
}
private static bool HasPrimaryResource(CacheFile cache, int handle)
{
var resourceEntry = cache.ResourceGestalt.TagResources[handle & ushort.MaxValue];
var segmentIndex = resourceEntry.SegmentIndex;
var segment = cache.ResourceLayoutTable.Segments[segmentIndex];
return(segment.RequiredPageIndex != -1);
}
public static IEnumerable <Group> GroupCode(CacheFile cache, FunctionDefinition function)
{
var instance = new InstructionGrouper(cache, function);
foreach (var group in instance.GroupCode())
{
yield return(group);
}
}
public static CommandContext Create(CommandContext parent, OpenTagCache info, CacheFile blamCache)
{
var context = new CommandContext(parent, blamCache.Build);
context.AddCommand(new PortShaderCommand(info, blamCache));
context.AddCommand(new PortModelCommand(info, blamCache));
context.AddCommand(new ListBitmapsCommand(info, blamCache));
context.AddCommand(new PortBspCommand(info, blamCache));
return context;
}
public RenderGeometryConverter(HaloOnlineCacheContext cacheContext, CacheFile blamCache)
{
CacheContext = cacheContext;
BlamCache = blamCache;
OriginalBufferOffsets = new List <long>();
Unknown1BIndices = new List <ushort>();
WaterData = new List <WaterConversionData>();
CurrentWaterBuffer = 0;
}
async void LoadScaleFromWave(string filePath)
{
PauseAudio();
MainView.Progress = 0.0;
Lock = true;
MainView.MessageText = LangResources.ProgressMessage_LoadScale;
await Task.Run(() =>
{
try
{
var wave = Wavefile.Read(filePath);
var selectedOperator = SelectedOperator;
var aac = CacheFile.FindCache <AnalyzedAudioCache>(wave.Hash + selectedOperator.GetType().FullName)
.GetOrElse(() =>
{
var aa = selectedOperator.Analyze(new Plugin.WaveData(wave.Data, wave.Fs), ApplicationSettings.Setting.PitchOperation.FramePeriod, (p) =>
{
Dispatcher.Invoke(() =>
{
MainView.Progress = p * 0.75 + 25.0;
});
});
var result = new AnalyzedAudioCache(selectedOperator.GetType(), aa, wave.Data.Length, wave.Fs, wave.Hash);
CacheFile.SaveCache(result, wave.Hash + selectedOperator.GetType().FullName);
return(result);
});
Dispatcher.Invoke(() =>
{
MainView.Progress = 1000.0;
ApplyScale(aac.AnalyzedAudio.F0);
Lock = false;
});
}
catch (InvalidDataException)
{
MessageBox.ShowWarning(LangResources.Error_UnsupportedWaveFile, LangResources.MessageBoxTitle_CannotLoadWaveFile);
Dispatcher.Invoke(() =>
{
Lock = false;
});
}
catch (Exception e)
{
MessageBox.ShowWarning(LangResources.Error_CannodLoadWaveFile, exception: e);
Dispatcher.Invoke(() =>
{
Lock = false;
});
}
});
}
public PortModelCommand(OpenTagCache info, CacheFile blamCache)
: base(CommandFlags.Inherit,
"portmodel",
"",
"portmodel [new] <blam tag path> <eldorado tag index>",
"")
{
Info = info;
BlamCache = blamCache;
}
public MultiplayerScenarioTagCollector(CacheFile blamCache, Scenario blamScnr,
int desiredZoneSetIndex, BspFlags desiredBsps, MultiplayerScenarioConversionFlags conversionFlags)
{
this.BlamCache = blamCache;
this.BlamScnr = blamScnr;
this.DesiredZoneSetIndex = desiredZoneSetIndex;
this.DesiredBsps = desiredBsps;
this.ConversionFlags = conversionFlags;
this.Tags = new List <IndexItem>();
}
public ListBitmapsCommand(OpenTagCache info, CacheFile blamCache)
: base(CommandFlags.None,
"listbitmaps",
"",
"listbitmaps <blam tag path>",
"")
{
Info = info;
BlamCache = blamCache;
}
public PortShaderCommand(OpenTagCache info, CacheFile blamCache)
: base(CommandFlags.None,
"portshader",
"",
"portshader <blam tag path>",
"")
{
Info = info;
BlamCache = blamCache;
}
public PortBspCommand(OpenTagCache info, CacheFile blamCache)
: base(CommandFlags.Inherit,
"portbsp",
"",
"portbsp <blam tag path> <Halo Online tag index>",
"")
{
Info = info;
BlamCache = blamCache;
}
public CacheSerializationContext(ref CacheFile blamCache, CacheFile.IndexItem blamTag)
{
if (blamCache.Version < CacheVersion.Halo3Retail)
{
var oldBlamCache = blamCache;
var oldBlamTag = blamTag;
if (blamTag.External)
{
try
{
blamCache = CacheFileGen2.MainMenuCache;
blamTag = blamCache.IndexItems[blamTag.GroupTag, blamTag.Name];
}
catch (KeyNotFoundException)
{
blamCache = oldBlamCache;
blamTag = oldBlamTag;
}
}
if (blamTag.External)
{
try
{
blamCache = CacheFileGen2.SharedCache;
blamTag = blamCache.IndexItems[blamTag.GroupTag, blamTag.Name];
}
catch (KeyNotFoundException)
{
blamCache = oldBlamCache;
blamTag = oldBlamTag;
}
}
if (blamTag.External)
{
try
{
blamCache = CacheFileGen2.SinglePlayerSharedCache;
blamTag = blamCache.IndexItems[blamTag.GroupTag, blamTag.Name];
}
catch (KeyNotFoundException)
{
blamCache = oldBlamCache;
blamTag = oldBlamTag;
}
}
if (blamTag.External)
{
throw new KeyNotFoundException($"[{blamTag.GroupTag}] {blamTag.Name}");
}
}
BlamCache = blamCache;
BlamTag = blamTag;
}
public void Write_WhenVersionIsCurrentVersion_WritesCorrectly()
{
using (var workingDir = TestDirectory.Create())
{
var projectFullPath = Path.Combine(workingDir, "E6E7F0F96EBE438887ED7D0B9FC88AFA");
var file1 = Path.Combine(workingDir, "DA9707B5FCFB4DA8B8BB77AD527C778C");
var file2 = Path.Combine(workingDir, "C78CE6D18C604A55BECD845F4F694A4B");
var v = "2";
var dgSpecHash = "LhkXQGGI+FQMy9dhLYjG5sWcHX3z/copzi4hjjBiY3Fotv0i7zQCikMZQ+rOKJ03gtx0hoHwIx5oKkM7sVHu7g==";
var success = "true";
var expected = $@"{{
""version"": {v},
""dgSpecHash"": ""{dgSpecHash}"",
""success"": {success},
""projectFilePath"": {JsonConvert.ToString(projectFullPath)},
""expectedPackageFiles"": [
{JsonConvert.ToString(file1)},
{JsonConvert.ToString(file2)}
],
""logs"": [
{{
""code"": ""NU1000"",
""level"": ""Information"",
""message"": ""Test""
}}
]
}}";
var cacheFile = new CacheFile(dgSpecHash)
{
Success = bool.Parse(success),
ProjectFilePath = projectFullPath,
ExpectedPackageFilePaths = new List <string>
{
file1,
file2
},
LogMessages = new List <IAssetsLogMessage>
{
new AssetsLogMessage(LogLevel.Information, NuGetLogCode.NU1000, "Test")
}
};
using (var stream = new MemoryStream())
{
CacheFileFormat.Write(stream, cacheFile);
var actual = Encoding.UTF8.GetString(stream.ToArray());
Assert.Equal(expected, actual);
}
}
}
public static T GetDefinition <T>(this CacheFile cache, string name, Func <T, bool> predicate)
where T : Definition
{
if (predicate == null)
{
throw new ArgumentNullException(nameof(predicate));
}
return(cache.Definitions
.OfType <T>()
.Single(d => d.Name == name && predicate(d) == true));
}
public static IEnumerable <T> GetDefinitions <T>(this CacheFile cache, Func <T, bool> predicate)
where T : Definition
{
if (predicate == null)
{
throw new ArgumentNullException(nameof(predicate));
}
return(cache.Definitions
.OfType <T>()
.Where(d => predicate(d) == true));
}
public void SetTAD(TADFile tadFile)
{
button_Refresh.Enabled = false;
m_tadFile = tadFile;
m_cacheFile = null;
TADStatistic statistic = m_tadFile.GetStatistic();
label_Statistic.Text = String.Format(StatisticFormat, statistic.FilesCovered, statistic.FileCount, statistic.FileCoverage);
m_sortedEntries = tadFile.FileEntries;
UpdateView();
}
public ExtractBitmapCommand(CacheFile blamCache) :
base(true,
"ExtractBitmap",
"Extracts a unmodified Bitmap from selected tag.",
"ExtractBitmap <tag name> [output directory] ",
"Extracts a unmodified Bitmap from selected tag.")
{
BlamCache = blamCache;
}
private async void HandleDownloaded(CacheFile file)
{
List <CacheValue> pending = file.GetAllPendingNotifies();
var tasks = new List <Task> ();
foreach (CacheValue value in pending)
{
tasks.Add(value.HandleDownloaded(file, this.HandleFileLoaded));
}
await Task.WhenAll(tasks);
}
public PortMultiplayerEventsCommand(HaloOnlineCacheContext cacheContext, CacheFile blamCache) :
base(true,
"PortMultiplayerEvents",
"Ports events from multiplayer_globals.",
"PortMultiplayerEvents",
"Ports events from multiplayer_globals.")
{
CacheContext = cacheContext;
BlamCache = blamCache;
}
public NameBlamTagCommand(HaloOnlineCacheContext cacheContext, CacheFile blamCache) :
base(true,
"NameBlamTag",
"Sets the name of the specified tag in the current external cache.",
"NameBlamTag <Tag> <Name>",
"Sets the name of the specified tag in the current external cache.")
{
CacheContext = cacheContext;
BlamCache = blamCache;
}
public static ModelData Create(CacheFile file)
{
var ret = new ModelData {Name = ShortenName(file.Name)};
var rows = file.GetRows();
ret.Rows = rows;
if (rows.Count() == 0)
throw new InvalidDataException("Cache is empty");
var singleRow = rows.First();
ret.SingleRow = singleRow;
// we need to go through all rows to find the maximum size type of all columns
var fieldTypes = new FieldType[singleRow.Columns.Count];
for (int i = 0; i < singleRow.Columns.Count; i++)
fieldTypes[i] = singleRow.Columns[i].Type;
foreach (var row in rows)
for (int i = 0; i < row.Columns.Count; i++)
if (FieldTypeHelper.GetTypeBits(row.Columns[i].Type) > FieldTypeHelper.GetTypeBits(fieldTypes[i]))
fieldTypes[i] = row.Columns[i].Type;
ret.FieldTypes = fieldTypes;
// now build the creation query - fields, primary key, indices, cleanup
var query = new StringBuilder();
query.AppendLine("DROP TABLE IF EXISTS " + ret.Name + ";");
query.AppendLine("CREATE TABLE " + ret.Name + " (");
bool createAutoIncrement = !IsColumnUnique(rows, 0);
string autoIncrementName = createAutoIncrement ? (singleRow.Columns.Any(c => c.Name == "id") ? "index" : "id") : "";
if (createAutoIncrement)
query.AppendLine(Indention + autoIncrementName + " INT AUTO_INCREMENT,");
for (int i = 0; i < singleRow.Columns.Count; i++)
query.AppendLine(Indention + singleRow.Columns[i].Name + " " + GetSQLType(fieldTypes[i]) + ",");
if (createAutoIncrement)
query.AppendLine(Indention + "PRIMARY KEY (" + autoIncrementName + "),");
else
query.AppendLine(Indention + "PRIMARY KEY (" + singleRow.Columns[0].Name + "),");
for (int i = 1; i < singleRow.Columns.Count; i++)
if (singleRow.Columns[i].Name.EndsWith("ID"))
query.AppendLine(Indention + "INDEX " + singleRow.Columns[i].Name + " (" + singleRow.Columns[i].Name + "),");
if (query[query.Length - 1] == '\n' && query[query.Length - 2] == '\r' && query[query.Length - 3] == ',')
query.Remove(query.Length - 3, 1);
query.AppendLine(");");
ret.CreationQuery = query.ToString();
return ret;
}
public CacheTagDatabase(CacheFile cf, Blam.CacheIndex.Item root_tag) : base(root_tag) { cacheFile = cf; }
public void InitialScan()
{
CacheFile loadedCache = null;
if (File.Exists(cachePath))
{
try
{
loadedCache = JsonConvert.DeserializeObject<CacheFile>(File.ReadAllText(cachePath));
}
catch (Exception ex)
{
Trace.TraceWarning("Warning: problem reading scanner cache: {0}", ex);
loadedCache = null;
}
}
if (loadedCache != null) cache = loadedCache;
Rescan();
Trace.TraceInformation("Initial scan done");
}
bool Reconstruct(int index, CacheFile c, out byte[] data)
{
geometry_block_resource_block gbr = Resources[index];
// seek to the actual data
c.InputStream.Seek(GetBlockOffset().Offset +
8 +
GetSectionSize() +
gbr.Offset);
// read all of the geometry resource block data
data = c.InputStream.ReadBytes(gbr.Size);
return true;
}
public CacheTagDatabase(CacheFile cf) : base() { cacheFile = cf; }
private void Load()
{
lock (cache) {
if (loaded) return;
if (File.Exists(PhysicalCacheFile)) {
using (var fs = new FileStream(PhysicalCacheFile, FileMode.Open, FileAccess.Read)) {
cache = ProtoBuf.Serializer.Deserialize<CacheFile>(fs);
//Todo- implement cross-process sync
}
}
lastFlush = DateTime.UtcNow;
loaded = true;
}
}
public XboxSerializationContext(CacheFile.IndexItem tag)
{
_tag = tag;
}
public void InitialScan()
{
CacheFile loadedCache = null;
if (File.Exists(cachePath))
{
try
{
loadedCache = JsonConvert.DeserializeObject<CacheFile>(File.ReadAllText(cachePath));
}
catch (Exception ex)
{
Trace.TraceWarning("Warning: problem reading scanner cache: {0}", ex);
loadedCache = null;
}
}
if (loadedCache != null) cache = loadedCache;
var foundFiles = new Dictionary<string, bool>();
InitialFolderScan("games", foundFiles);
InitialFolderScan("maps", foundFiles);
InitialFolderScan("packages", foundFiles);
Dictionary<string, CacheItem> copy;
lock (cache) copy = new Dictionary<string, CacheItem>(cache.ShortPathIndex);
foreach (var pair in copy) if (!foundFiles.ContainsKey(pair.Key)) CacheItemRemove(pair.Value);
Trace.TraceInformation("Initial scan done");
}