private static IEnumerable <object[]> GetMapTriggersDataSpecificFormatVersion(MapTriggersFormatVersion?formatVersion)
{
foreach (var testData in GetMapTriggersData())
{
using var original = FileProvider.GetFile((string)testData[0]);
using var reader = new BinaryReader(original);
if (original.Length >= 8)
{
if (reader.ReadInt32() == MapTriggers.FileFormatSignature)
{
var actualVersion = (MapTriggersFormatVersion?)reader.ReadInt32();
if (!Enum.IsDefined(typeof(MapTriggersFormatVersion), actualVersion))
{
actualVersion = null;
}
if (formatVersion == actualVersion)
{
yield return(testData);
}
}
}
}
}
public void TestParseCampaignUnitObjectData(string campaignUnitObjectDataFilePath)
{
using var original = FileProvider.GetFile(campaignUnitObjectDataFilePath);
using var recreated = new MemoryStream();
CampaignUnitObjectData.Parse(original, true).SerializeTo(recreated, true);
StreamAssert.AreEqual(original, recreated, true, true);
}
public void TestParseMapDoodads(string mapDoodadsFilePath)
{
using var original = FileProvider.GetFile(mapDoodadsFilePath);
using var recreated = new MemoryStream();
MapDoodads.Parse(original, true).SerializeTo(recreated, true);
StreamAssert.AreEqual(original, recreated, true);
}
private static void TestParseMapCustomTextTriggers(string mapCustomTextTriggersFilePath)
{
using var original = FileProvider.GetFile(mapCustomTextTriggersFilePath);
using var recreated = new MemoryStream();
MapCustomTextTriggers.Parse(original, true).SerializeTo(recreated, true);
StreamAssert.AreEqual(original, recreated, true);
}
public void TestParseMapEnvironment(string environmentFilePath)
{
using var original = FileProvider.GetFile(environmentFilePath);
using var recreated = new MemoryStream();
MapEnvironment.Parse(original, true).SerializeTo(recreated, true);
StreamAssert.AreEqual(original, recreated, true);
}
public void TestParsePathingMap(string pathingMapFile)
{
using var original = FileProvider.GetFile(pathingMapFile);
using var recreated = new MemoryStream();
PathingMap.Parse(original, true).SerializeTo(recreated, true);
StreamAssert.AreEqual(original, recreated, true);
}
// Delete file from the server
private void DeleteFile(HttpContext context)
{
var file = FileProvider.GetFile(context.Request["f"]);
if (file != null && file.Exists)
{
file.Delete();
}
}
/// <summary>
/// Processes the content.
/// </summary>
/// <returns>processed conntent</returns>
public string ProcessContent()
{
if (HtmlFile == null)
{
HtmlFile = FileProvider.GetFile(HtmlFileUri);
}
_baseFolderUrl = new Uri(htmlParser.GetBaseUrlFolder(HtmlFile));
return(ResolveDependencies());
}
/// <summary>
/// Gets url of file to download
/// </summary>
/// <param name="url">File url</param>
private string DownloadDependencyFile(string url)
{
IWebFile downloadedFile = FileProvider.GetFile(new Uri(url));
if (downloadedFile == null)
{
return(url);
}
return(FileStorage.SaveFile(downloadedFile, false));
}
private FileInfo GetRenamedFileIfExists(string relativeFile)
{
var file = FileProvider.GetFile(relativeFile);
string fileName = file.FileNameWithoutExtension();
string ext = file.Extension;
int idx = 1;
while (file.Exists)
{
file = new FileInfo(Path.Combine(file.DirectoryName,
string.Format("{0}({1}){2}", fileName, idx, ext)));
idx++;
}
return(file);
}
private void DeliverFile(HttpContext context)
{
var filename = context.Request["f"];
string uploadPath = GetUploadPath(filename, context);
var file = FileProvider.GetFile(uploadPath + filename);
if (file.Exists)
{
context.Response.AddHeader("Content-Disposition", "attachment; filename=\"" + filename + "\"");
context.Response.ContentType = "application/octet-stream";
context.Response.ClearContent();
context.Response.WriteFile(file.FullName);
}
else
{
context.Response.StatusCode = 404;
}
}
private static void Main()
{
var stringProvider = new ExampleStringProvider();
var mapInfo = MapInfo.Parse(FileProvider.GetFile(Path.Combine(stringProvider.BaseMapFilePath, MapInfo.FileName)));
mapInfo.MapName = stringProvider.MapName;
mapInfo.MapDescription = stringProvider.MapDescription;
mapInfo.MapAuthor = stringProvider.MapAuthor;
mapInfo.RecommendedPlayers = stringProvider.RecommendedPlayers;
mapInfo.MapFlags &= ~MapFlags.MeleeMap;
mapInfo.ScriptLanguage = ScriptLanguage.Lua;
PlayerAndForceProperties.ApplyToMapInfo(mapInfo);
var scriptCompilerOptions = new ScriptCompilerOptions(CoreSystemProvider.GetCoreSystemFiles().Append(@".\LuaLibs\PerlinNoise.lua"));
scriptCompilerOptions.MapInfo = mapInfo;
scriptCompilerOptions.LobbyMusic = stringProvider.LobbyMusic;
scriptCompilerOptions.SourceDirectory = stringProvider.SourceProjectPath;
scriptCompilerOptions.OutputDirectory = stringProvider.OutputDirectoryPath;
// Note: do not use MpqFileFlags.SingleUnit, as it appears to be bugged.
scriptCompilerOptions.DefaultFileFlags = MpqFileFlags.Exists | MpqFileFlags.CompressedMulti;
scriptCompilerOptions.FileFlags["war3map.wtg"] = 0;
scriptCompilerOptions.FileFlags[mapInfo.ScriptLanguage == ScriptLanguage.Jass ? "war3map.lua" : "war3map.j"] = 0;
scriptCompilerOptions.FileFlags[ListFile.Key] = MpqFileFlags.Exists | MpqFileFlags.Encrypted | MpqFileFlags.BlockOffsetAdjustedKey;
#if DEBUG
scriptCompilerOptions.Debug = true;
#endif
// Build and launch
var mapName = stringProvider.MapFileName;
var mapBuilder = new MapBuilder(mapName);
if (mapBuilder.Build(scriptCompilerOptions, stringProvider.AssetsDirectoryPath, stringProvider.BaseMapFilePath))
{
var mapPath = Path.Combine(scriptCompilerOptions.OutputDirectory, mapName);
var absoluteMapPath = new FileInfo(mapPath).FullName;
Process.Start(stringProvider.Warcraft3ExecutablePath, $"{stringProvider.CommandLineArguments} -loadfile \"{absoluteMapPath}\"");
}
}
internal static void RunBinaryRWTest(
string filePath,
Type type,
string?readMethodName = null,
object?[]?additionalReadParameters = null,
object?[]?additionalWriteParameters = null)
{
var expectedReadTypes = new[] { typeof(BinaryReader) };
if (additionalReadParameters is not null)
{
expectedReadTypes = expectedReadTypes.Concat(additionalReadParameters.Select(p => p.GetType())).ToArray();
}
var readMethod = typeof(BinaryReaderExtensions).GetMethod(readMethodName ?? $"Read{type.Name}", expectedReadTypes);
Assert.IsNotNull(readMethod, $"Could not find extension method to read {type.Name}.");
var expectedWriteTypes = new[] { typeof(BinaryWriter), type };
if (additionalWriteParameters is not null)
{
expectedWriteTypes = expectedWriteTypes.Concat(additionalWriteParameters.Select(p => p.GetType())).ToArray();
}
var writeMethod = typeof(BinaryWriterExtensions).GetMethod(nameof(BinaryWriter.Write), expectedWriteTypes);
Assert.IsNotNull(writeMethod, $"Could not find extension method to write {type.Name}.");
using var expectedStream = FileProvider.GetFile(filePath);
using var reader = new BinaryReader(expectedStream);
var parsedFile = readMethod !.Invoke(null, new object?[] { reader }.Concat(additionalReadParameters ?? Array.Empty <object?[]>()).ToArray());
Assert.AreEqual(type, parsedFile.GetType());
using var actualStream = new MemoryStream();
using var writer = new BinaryWriter(actualStream);
writeMethod !.Invoke(null, new object?[] { writer, parsedFile }.Concat(additionalWriteParameters ?? Array.Empty <object?[]>()).ToArray());
writer.Flush();
StreamAssert.AreEqual(expectedStream, actualStream, true);
}
public void TestFileProviderGetFile(string path, bool expected)
{
if (expected)
{
using var file = FileProvider.GetFile(path);
Assert.IsNotNull(file);
}
else
{
try
{
using (var file = FileProvider.GetFile(path))
{
Assert.Fail();
}
}
catch (FileNotFoundException)
{
}
}
}
/// <summary>
/// Retrieves application changelog which lists all versions.
/// </summary>
/// <returns>Returns object representing application ChangeLog.</returns>
public async Task <ChangeLog> GetChangeLog()
{
if (CachedChangeLog != null)
{
return(CachedChangeLog);
}
string changelogContent = await FileProvider.GetFile("changelog.json");
if (string.IsNullOrEmpty(changelogContent))
{
return(null);
}
ChangeLog changeLog = ChangeLog.FromJson(changelogContent, this);
if (changeLog != null)
{
CachedChangeLog = changeLog;
}
return(changeLog);
}