public void AddingNonExistingSectionWillCreateNew()
{
var project = CsProjects.SampleProjectSimple;
var writer = new ProjectWriter(project);
writer.AddFile(@"asd/qwe.txt", "ASDASD");
var newProject = writer.GetXml();
StringAssert.Contains("<ASDASD Include=\"asd\\qwe.txt\" />", newProject);
}
public void CanAddEmbeddedResourceFileInProject()
{
var project = CsProjects.SampleProjectSimple;
var writer = new ProjectWriter(project);
writer.AddEmbeddedResource("__test__");
var newProject = writer.GetXml();
StringAssert.Contains("<EmbeddedResource Include=\"__test__\" />", newProject);
}
public void CanAddCompileFileWithSlashInProjectAndItWillChangeToBackslash()
{
var project = CsProjects.SampleProjectSimple;
var writer = new ProjectWriter(project);
writer.AddCompile("__test__/asdasd");
var newProject = writer.GetXml();
StringAssert.Contains("<Compile Include=\"__test__\\asdasd\" />", newProject);
}
public void AddingDuplicatedFileWillMaintainTheLast()
{
var project = CsProjects.SampleProjectSimple;
var writer = new ProjectWriter(project);
writer.AddEmbeddedResource(@"Common\EnumerableExtensions.cs");
var newProject = writer.GetXml();
StringAssert.Contains("<Compile Include=\"Common\\EnumerableExtensions.cs\" />", newProject);
StringAssert.DoesNotContain("<EmbeddedResource Include=\"Common\\EnumerableExtensions.cs\" />", newProject);
}
public void CanRemoveEnumerableExtensionsInProject()
{
var project = CsProjects.SampleProjectSimple;
StringAssert.Contains("<Compile Include=\"Common\\EnumerableExtensions.cs\" />", project);
var writer = new ProjectWriter(project);
writer.RemoveFile(@"Common\EnumerableExtensions.cs");
var newProject = writer.GetXml();
StringAssert.DoesNotContain("<Compile Include=\"Common\\EnumerableExtensions.cs\" />", newProject);
}
public void AddingDuplicatedFileWontCreateNew()
{
var project = CsProjects.SampleProjectSimple;
var writer = new ProjectWriter(project);
writer.AddCompile(@"Common\EnumerableExtensions.cs");
var newProject = writer.GetXml();
Assert.AreEqual(
newProject.IndexOf("Include=\"Common\\EnumerableExtensions.cs\" />"),
newProject.LastIndexOf("Include=\"Common\\EnumerableExtensions.cs\" />"), "two occurrences");
}
public static void WriteMaxRoomIDs(ProjectWriter writer, int maxInstId, int maxTileId)
{
writer.Write(maxInstId);
writer.Write(maxTileId);
}
public static void WriteGEX(ProjectWriter writer, string filePath)
{
using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (ProjectReader pr = new ProjectReader(fs))
{
GEX gex = new GEX();
gex.Load(pr);
writer.Write(gex.Package.Version);
writer.Write(gex.Package.Name);
writer.Write(gex.Package.Folder);
writer.Write(gex.Package.Files.Count);
foreach (var file in gex.Package.Files)
{
writer.Write(file.Version);
writer.Write(file.FileName);
writer.Write((int)file.Kind);
writer.Write(file.Initialization);
writer.Write(file.Finalization);
writer.Write(file.Functions.Count);
int id = 0;
foreach (var func in file.Functions)
{
writer.Write(func.Version);
writer.Write(func.Name);
writer.Write(func.ExternalName);
writer.Write((int)func.Convention);
writer.Write(id); // ?????
writer.Write(func.Argc);
for (int i = 0; i < 17; i++)
{
writer.Write((int)func.ArgTypes[i]);
}
writer.Write((int)func.Return);
id++;
}
}
writer.Write(gex.Seed);
// Prepare DAT files...
MemoryStream ms = new MemoryStream();
for (int i = 0; i < gex.Package.Files.Count; i++)
{
if (gex.Package.Files[i].Kind == GEDFile.GEDFileKind.ActionLib)
{
continue;
}
byte[] zlibbed = ZlibStream.CompressBuffer(gex.RawDATs[i]);
byte[] size = BitConverter.GetBytes(zlibbed.Length);
ms.Write(size);
ms.Write(zlibbed);
}
byte[] includes = ms.ToArray();
writer.Write(includes.Length);
// GMKrypt the data.
for (int i = 1; i < includes.Length; i++)
{
includes[i] = gex.GMKrypt[0][includes[i]];
}
writer.Write(includes);
}
}
public async Task WritesDistinctConfigurations()
{
const string xml = @"
<Project DefaultTargets=""Build"" xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" ToolsVersion=""4.0"">
<Import Project=""$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props"" Condition=""Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')"" />
<PropertyGroup>
<VisualStudioVersion Condition=""'$(VisualStudioVersion)' == ''"">15.0</VisualStudioVersion>
<OldToolsVersion>14.0</OldToolsVersion>
<DslTargetsPath>..\SDK\v15.0\MSBuild\DSLTools</DslTargetsPath>
<TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
<MinimumVisualStudioVersion>15.0</MinimumVisualStudioVersion>
</PropertyGroup>
<PropertyGroup>
<Configuration Condition="" '$(Configuration)' == '' "">Debug</Configuration>
<Platform Condition="" '$(Platform)' == '' "">AnyCPU</Platform>
<ProjectGuid>{87161453-D71B-4ABB-BADB-1D0E621E8EA0}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Class1</RootNamespace>
<AssemblyName>Class1</AssemblyName>
<TargetFrameworkVersion>v4.7</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<TargetFrameworkProfile />
</PropertyGroup>
<PropertyGroup Condition="" '$(Configuration)|$(Platform)' == 'Debug|x86' "">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<PlatformTarget>AnyCPU</PlatformTarget>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
<DocumentationFile>bin\Debug\Class1.xml</DocumentationFile>
<RunCodeAnalysis>false</RunCodeAnalysis>
<CodeAnalysisRuleSet>..\FxCop.Rules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<PropertyGroup Condition="" '$(Configuration)|$(Platform)' == 'Debug|x64' "">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<PlatformTarget>AnyCPU</PlatformTarget>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
<DocumentationFile>bin\Release\Class1.xml</DocumentationFile>
<RunCodeAnalysis>true</RunCodeAnalysis>
<CodeAnalysisRuleSet>..\FxCop.Rules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<PropertyGroup Condition=""'$(Configuration)|$(Platform)' == 'Release|x86'"">
<OutputPath>bin\Release_CI\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<Optimize>true</Optimize>
<DebugType>pdbonly</DebugType>
<PlatformTarget>AnyCPU</PlatformTarget>
<ErrorReport>prompt</ErrorReport>
<CodeAnalysisRuleSet>..\FxCop.Rules.ruleset</CodeAnalysisRuleSet>
<DocumentationFile>bin\Release_CI\Class1.xml</DocumentationFile>
<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
<RunCodeAnalysis>true</RunCodeAnalysis>
</PropertyGroup>
<PropertyGroup Condition=""'$(Configuration)|$(Platform)' == 'Release|x64'"">
<OutputPath>bin\Release_CI\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<Optimize>true</Optimize>
<DebugType>pdbonly</DebugType>
<PlatformTarget>AnyCPU</PlatformTarget>
<ErrorReport>prompt</ErrorReport>
<CodeAnalysisRuleSet>..\FxCop.Rules.ruleset</CodeAnalysisRuleSet>
<DocumentationFile>bin\Release_CI\Class1.xml</DocumentationFile>
<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
<RunCodeAnalysis>true</RunCodeAnalysis>
</PropertyGroup>
</Project>";
var project = await ParseAndTransform(xml).ConfigureAwait(false);
Assert.AreEqual(2, project.Configurations.Count);
Assert.AreEqual(1, project.Configurations.Count(x => x == "Debug"));
Assert.AreEqual(1, project.Configurations.Count(x => x == "Release"));
var writer = new ProjectWriter();
var xmlNode = writer.CreateXml(project);
var generatedConfigurations = xmlNode.Element("PropertyGroup").Element("Configurations");
Assert.IsNull(generatedConfigurations);
}
public void Save(ProjectWriter writer, GMProject proj)
{
writer.Write(Point);
Event.Save(writer, proj);
}
public void Save(string fileName)
{
// StringWriter.Encoding always returns UTF16. We need it to return UTF8, so the
// XmlDocument will write the UTF8 header.
ItemGroups.Each(group => {
var items = group.Items.ToArray();
group.Element.RemoveAll();
var orderedItems = items.OrderBy(x => x.Name).ThenBy(x => x.Include);
orderedItems
.Each(item => group.AddNewItem(item.Name, item.Include));
});
var sw = new ProjectWriter(bom);
sw.NewLine = newLine;
doc.Save(sw);
string content = sw.ToString();
if (endsWithEmptyLine && !content.EndsWith(newLine))
content += newLine;
new FileSystem().WriteStringToFile(fileName, content);
}
/// <summary>
/// This method updates a 'Project' object.
/// </summary>
/// <param name='List<PolymorphicObject>'>The 'Project' to update.
/// <returns>A PolymorphicObject object with a value.
internal PolymorphicObject UpdateProject(List <PolymorphicObject> parameters, DataConnector dataConnector)
{
// Initial Value
PolymorphicObject returnObject = new PolymorphicObject();
// locals
Project project = null;
// If the data connection is connected
if ((dataConnector != null) && (dataConnector.Connected == true))
{
// Create Update StoredProcedure
UpdateProjectStoredProcedure updateProjectProc = null;
// verify the first parameters is a(n) 'Project'.
if (parameters[0].ObjectValue as Project != null)
{
// Create Project Parameter
project = (Project)parameters[0].ObjectValue;
// verify project exists
if (project != null)
{
// Now create updateProjectProc from ProjectWriter
// The DataWriter converts the 'Project'
// to the SqlParameter[] array needed to update a 'Project'.
updateProjectProc = ProjectWriter.CreateUpdateProjectStoredProcedure(project);
}
// Verify updateProjectProc exists
if (updateProjectProc != null)
{
// Execute Update Stored Procedure
bool saved = this.DataManager.ProjectManager.UpdateProject(updateProjectProc, dataConnector);
// Create returnObject.Boolean
returnObject.Boolean = new NullableBoolean();
// If save was successful
if (saved)
{
// Set returnObject.Boolean.Value to true
returnObject.Boolean.Value = NullableBooleanEnum.True;
}
else
{
// Set returnObject.Boolean.Value to false
returnObject.Boolean.Value = NullableBooleanEnum.False;
}
}
else
{
// Raise Error Data Connection Not Available
throw new Exception("The database connection is not available.");
}
}
}
// return value
return(returnObject);
}
public void RemovingLastItemOfAItemGroupWontLeaveItEmpty()
{
var project = CsProjects.SampleProjectSimple;
var writer = new ProjectWriter(project);
writer.AddFile(@"asd/qwe.txt", "ASDASD");
var newWriter = new ProjectWriter(writer.GetXml());
newWriter.RemoveFile("asd/qwe.txt");
var xml = newWriter.GetXml().Replace("\n", "").Replace("\r", "").Replace(" ", "");
StringAssert.DoesNotContain("<ItemGroup></ItemGroup>", xml);
}
static void Main(string[] args)
{
var stopwatch = Stopwatch.StartNew();
var projectAssembly = "EventHorizon.Blazor.BabylonJS.WASM";
var projectGenerationLocation = Path.Combine(
"..",
"_generated"
);
var sourceDirectory = Path.Combine(
".",
"SourceFiles"
);
var textFormatter = new NoFormattingTextFormatter();
var writer = new ProjectWriter(
projectGenerationLocation,
projectAssembly
);
var sourceFiles = new List <string>
{
"babylon.d.ts",
"babylon.gui.d.ts",
};
var generationList = new List <string>
{
"Scene",
"VertexBuffer",
"ICameraInput",
"AbstractActionManager",
"ICustomAnimationFrameRequester",
"IAction",
"Vector3",
"EventState",
"Observable",
"Container",
"Control",
"Button",
"UniversalCamera",
"ArcRotateCamera",
"PointLight",
"Grid",
"StackPanel",
"MeshBuilder",
"StandardMaterial",
"Texture",
"HemisphericLight",
"PointerInfo",
"PointerInfoBase",
"SceneLoader",
};
// Remove any already Generated Source.
if (Directory.Exists(Path.Combine(
projectGenerationLocation,
projectAssembly
)))
{
Directory.Delete(
Path.Combine(
projectGenerationLocation,
projectAssembly
),
true
);
}
GlobalLogger.Info("Removed Generation Directory");
new GenerateInteropSource().Run(
projectAssembly,
sourceDirectory,
sourceFiles,
generationList,
writer,
textFormatter,
new Dictionary <string, string>
{
{ "BABYLON.PointerInfoBase | type", "int" }
}
);
stopwatch.Stop();
GlobalLogger.Info("Removed Generation Directory");
GlobalLogger.Info($"Took {stopwatch.ElapsedMilliseconds}ms to generate.");
}
public void process(string filename)
{
//
// Create a ProjectFile instance
//
ProjectFile file = new ProjectFile();
//
// Uncomment these lines to test the use of alternative
// delimiters and separators for MPX file output.
//
//file.setDelimiter(';');
//file.setDecimalSeparator(',');
//file.setThousandsSeparator('.');
//
// Add a default calendar called "Standard"
//
ProjectCalendar calendar = file.addDefaultBaseCalendar();
//
// Add a holiday to the calendar to demonstrate calendar exceptions
//
calendar.addCalendarException(ParseDate("2006-03-13"), ParseDate("2006-03-13"));
//
// Retrieve the project properties and set the start date. Note Microsoft
// Project appears to reset all task dates relative to this date, so this
// date must match the start date of the earliest task for you to see
// the expected results. If this value is not set, it will default to
// today's date.
//
ProjectProperties properties = file.ProjectProperties;
properties.StartDate = ParseDate("2003-01-01");
//
// Set a couple more properties just for fun
//
properties.ProjectTitle = "Created by MPXJ";
properties.Author = "Jon Iles";
//
// Add resources
//
Resource resource1 = file.addResource();
resource1.Name = "Resource1";
Resource resource2 = file.addResource();
resource2.Name = "Resource2";
//
// This next line is not required, it is here simply to test the
// output file format when alternative separators and delimiters
// are used.
//
resource2.MaxUnits = NumberHelper.getDouble(50.0);
//
// Create a summary task
//
Task task1 = file.addTask();
task1.Name = "Summary Task";
//
// Create the first sub task
//
Task task2 = task1.addTask();
task2.Name = "First Sub Task";
task2.Duration = Duration.getInstance(10.5, TimeUnit.DAYS);
task2.Start = ParseDate("2003-01-01");
//
// We'll set this task up as being 50% complete. If we have no resource
// assignments for this task, this is enough information for MS Project.
// If we do have resource assignments, the assignment record needs to
// contain the corresponding work and actual work fields set to the
// correct values in order for MS project to mark the task as complete
// or partially complete.
//
task2.PercentageComplete = NumberHelper.getDouble(50.0);
task2.ActualStart = ParseDate("2003-01-01");
//
// Create the second sub task
//
Task task3 = task1.addTask();
task3.Name = "Second Sub Task";
task3.Start = ParseDate("2003-01-11");
task3.Duration = Duration.getInstance(10, TimeUnit.DAYS);
//
// Link these two tasks
//
task3.addPredecessor(task2, RelationType.FINISH_START, null);
//
// Add a milestone
//
Task milestone1 = task1.addTask();
milestone1.Name = "Milestone";
milestone1.Start = ParseDate("2003-01-21");
milestone1.Duration = Duration.getInstance(0, TimeUnit.DAYS);
milestone1.addPredecessor(task3, RelationType.FINISH_START, null);
//
// This final task has a percent complete value, but no
// resource assignments. This is an interesting case it it requires
// special processing to generate the MSPDI file correctly.
//
Task task4 = file.addTask();
task4.Name = "Next Task";
task4.Duration = Duration.getInstance(8, TimeUnit.DAYS);
task4.Start = ParseDate("2003-01-01");
task4.PercentageComplete = NumberHelper.getDouble(70.0);
task4.ActualStart = ParseDate("2003-01-01");
//
// Assign resources to tasks
//
ResourceAssignment assignment1 = task2.addResourceAssignment(resource1);
ResourceAssignment assignment2 = task3.addResourceAssignment(resource2);
//
// As the first task is partially complete, and we are adding
// a resource assignment, we must set the work and actual work
// fields in the assignment to appropriate values, or MS Project
// won't recognise the task as being complete or partially complete
//
assignment1.Work = Duration.getInstance(80, TimeUnit.HOURS);
assignment1.ActualWork = Duration.getInstance(40, TimeUnit.HOURS);
//
// If we were just generating an MPX file, we would already have enough
// attributes set to create the file correctly. If we want to generate
// an MSPDI file, we must also set the assignment start dates and
// the remaining work attribute. The assignment start dates will normally
// be the same as the task start dates.
//
assignment1.RemainingWork = Duration.getInstance(40, TimeUnit.HOURS);
assignment2.RemainingWork = Duration.getInstance(80, TimeUnit.HOURS);
assignment1.Start = ParseDate("2003-01-01");
assignment2.Start = ParseDate("2003-01-11");
//
// Write a 100% complete task
//
Task task5 = file.addTask();
task5.Name = "Last Task";
task5.Duration = Duration.getInstance(3, TimeUnit.DAYS);
task5.Start = ParseDate("2003-01-01");
task5.PercentageComplete = NumberHelper.getDouble(100.0);
task5.ActualStart = ParseDate("2003-01-01");
//
// Write the file
//
ProjectWriter writer = ProjectWriterUtility.getProjectWriter(filename);
writer.write(file, filename);
}
/// <summary>
/// Ports a list of projects
/// </summary>
/// <param name="projectPaths">List of projects paths</param>
/// <param name="solutionPath">Path to solution file</param>
/// <param name="targetFramework">Target framework to be used when porting</param>
/// <param name="upgradeVersions">List of key/value pairs where key is package and value is version number</param>
/// <returns>A PortingProjectFileResult object, representing the result of the porting operation</returns>
public List <PortingResult> ApplyProjectChanges(
List <string> projectPaths, string solutionPath, string targetFramework,
Dictionary <string, string> upgradeVersions)
{
_logger.LogInformation("Applying porting changes to {0}", projectPaths);
var results = new List <PortingResult>();
var projectFilesNotFound = projectPaths.Where((path) => !File.Exists(path)).ToList();
projectFilesNotFound.ForEach((path) => results.Add(new PortingResult
{
Message = "File not found.",
ProjectFile = path,
ProjectName = Path.GetFileNameWithoutExtension(path),
Success = false
}));
var conversionOptions = new ConversionOptions
{
ForceOnUnsupportedProjects = true,
ProjectCache = new DefaultProjectCache(),
TargetFrameworks = new List <string> {
targetFramework
},
};
var(projects, _) = _facility.ParseProjects(new[] { solutionPath }, Vs16TransformationSet.Instance, conversionOptions);
var selectedProjects = projects.Where(project => projectPaths.Contains(project.FilePath.FullName)).ToList();
var writer = new ProjectWriter(_logger, writeOptions);
foreach (var project in selectedProjects)
{
try
{
project.PackageReferences = project.PackageReferences.Select(p =>
new PackageReference
{
Id = p.Id,
Version = upgradeVersions.ContainsKey(p.Id) ? upgradeVersions[p.Id] : p.Version,
IsDevelopmentDependency = p.IsDevelopmentDependency,
DefinitionElement = p.DefinitionElement
}).ToList();
if (writer.TryWrite(project))
{
results.Add(new PortingResult
{
Success = true,
ProjectFile = project.FilePath.FullName,
ProjectName = project.ProjectName
});
}
else
{
results.Add(new PortingResult
{
Success = false,
ProjectFile = project.FilePath.FullName,
ProjectName = project.ProjectName
});
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Project {Item} analysis has thrown an exception",
project.ProjectName);
results.Add(new PortingResult
{
Success = false,
ProjectFile = project.FilePath.FullName,
ProjectName = project.ProjectName,
Exception = ex
});
}
}
conversionOptions.ProjectCache?.Purge();
_logger.LogInformation("Completed porting changes to {0}", projectPaths);
return(results);
}
public void Save(string fileName)
{
// StringWriter.Encoding always returns UTF16. We need it to return UTF8, so the
// XmlDocument will write the UTF8 header.
if (!this.Settings.MaintainOriginalItemOrder)
{
ItemGroups.Each(group =>
{
XmlElement[] elements = null;
elements = @group.Items.Select(x => x.Element).OrderBy(x => x.GetAttribute("Include")).ToArray();
group.Element.RemoveAll();
elements.Each(x => group.Element.AppendChild(x));
});
}
var sw = new ProjectWriter(bom);
sw.NewLine = newLine;
doc.Save(sw);
string content = sw.ToString();
if (endsWithEmptyLine && !content.EndsWith(newLine))
content += newLine;
var shouldSave = !this.Settings.OnlySaveIfChanged ||
(File.Exists(fileName) && !File.ReadAllText(fileName).Equals(content));
if (shouldSave)
new FileSystem().WriteStringToFile(fileName, content);
}
public int Compile()
{
try
{
Console.Write("Loading project file... ");
using (FileStream projectStream = new FileStream(ProjectFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
// meh. yes, that many streams.
using (MemoryStream gamedataBase = new MemoryStream())
using (ProjectWriter gamedataStream = new ProjectWriter(gamedataBase))
using (MemoryStream gmkryptBase = new MemoryStream())
using (ProjectWriter gmkryptStream = new ProjectWriter(gmkryptBase))
{
Project = new GMProject(projectStream);
Console.WriteLine("Done");
// Just like the Editor does.
if (Project.Rooms.Count <= 0)
{
throw new Exception("A game must have at least one room in order to run you dummy :)");
}
Console.Write("Unpacking rundata... ");
RundataManager.LoadRundata(Project.Version, OutputExecutablePath);
Console.WriteLine("Done");
ExeResInfo eri = new ExeResInfo(
Project.Options.GameVersion,
Project.Options.Company,
Project.Options.Product,
Project.Options.Copyright,
Project.Options.Description,
Project.Options.RawIcon
);
Console.Write("Setting exe information... ");
ExeResource.SetExeResourceInfo(OutputExecutablePath, eri);
Console.WriteLine("Done");
Console.Write("Writing game data... ");
gamedataStream.Write(GMProject.GMMagic);
gamedataStream.Write(Project.Version);
// dummy value 1
if (Project.Version == 810)
{
gamedataStream.Write(1337);
}
// the debug mode flag, not encrypted...
gamedataStream.Write(EnableDebugMode);
// dummy value 2
if (Project.Version == 810)
{
gamedataStream.Write(6969);
}
// options (not encrypted)
Options.WriteOptions(gamedataStream, Project.Options);
// embedded direct3d 8.0 dll
gamedataStream.Write("D3DX8.dll");
gamedataStream.Write(File.ReadAllBytes(Path.Combine(AppDir, "dxdata")));
// actual crypto fun starts.
gamedataStream.Write(0); // count1
gamedataStream.Write(0); // count2
// GMKrypt table, or in this case, a dummy table :p
for (int i = 0; i <= byte.MaxValue; i++)
{
gamedataStream.Write((byte)i);
}
// dummy ints...
gmkryptStream.Write(0); // count3
// header
gmkryptStream.Write(EnableProMode);
gmkryptStream.Write(Project.GameID);
gmkryptStream.Write(Project.DirectPlayGuid);
// extensions
Asset.WriteExtensions(gmkryptStream, Project.ExtensionPackageNames, GEXSearchPath);
// triggers
Asset.WriteAsset(gmkryptStream, Project.Triggers, AssetDelegates.Trigger);
// constants
Asset.WriteConstants(gmkryptStream, Project.Constants);
// sounds
Asset.WriteAsset(gmkryptStream, Project.Sounds, AssetDelegates.Sound);
// sprites
Asset.WriteAsset(gmkryptStream, Project.Sprites, AssetDelegates.Sprite);
// backgrounds
Asset.WriteAsset(gmkryptStream, Project.Backgrounds, AssetDelegates.Background);
// paths
Asset.WriteAsset(gmkryptStream, Project.Paths, AssetDelegates.Path);
// scripts
Asset.WriteAsset(gmkryptStream, Project.Scripts, AssetDelegates.Script);
// fonts
Asset.WriteAsset(gmkryptStream, Project.Fonts, AssetDelegates.Font);
// timelines
Asset.WriteAsset(gmkryptStream, Project.Timelines, AssetDelegates.Timeline, Project);
// objects
Asset.WriteAsset(gmkryptStream, Project.Objects, AssetDelegates.Object, Project);
// rooms
Asset.WriteAsset(gmkryptStream, Project.Rooms, AssetDelegates.Room, Project);
Asset.WriteMaxRoomIDs(gmkryptStream, Project.LastInstanceID, Project.LastTileID);
// included files
Asset.WriteAsset(gmkryptStream, Project.IncludedFiles, AssetDelegates.IncludedFile);
// game information
Asset.WriteGameInformation(gmkryptStream, Project.GameInformation);
// library creation code
Asset.WriteLibCC(gmkryptStream, Project.LibraryCreationCode);
// room execution order
Asset.WriteRoomExecOrder(gmkryptStream, Project.RoomExecutionOrder, Project);
// encryption
byte[] gmkryptData = Encryption.EncryptGM8(gmkryptBase);
gamedataStream.Write(gmkryptData.Length);
gamedataStream.Write(gmkryptData);
// encryption crc/xor (810 only)
if (Project.Version == 810)
{
// TODO: implement the thing.
Encryption.EncryptGM81(gamedataBase);
}
// finalization (rundata, icon, version, etc)
Console.WriteLine("Done");
// Write rundata.
Console.Write("Appending game data to rundata... ");
FileStream rundata = new FileStream(OutputExecutablePath, FileMode.Append, FileAccess.Write, FileShare.Read);
byte[] dataToWrite = gamedataBase.ToArray();
// GM8.1 STARTS AT A DIFFERENT POSITION, NEED TO CHANGE.
// Technically 2000000 should always be beyond rundata, but if you set a very large icon
// this position may be inside rundata, luckily GameMaker will also add 10000
// in a loop to the seek position until it finds the game data.
long pos = 2000000;
while (pos <= rundata.Length)
{
pos += 10000;
}
rundata.Seek(pos, SeekOrigin.Begin);
// Write gamedata to rundata.
rundata.Write(dataToWrite);
// Flush and close the stream safely.
rundata.Flush(true);
rundata.Dispose();
// yay!!!
Console.WriteLine("Done");
}
if (RunAfterBuild)
{
try
{
Console.Write("Trying to run the game... ");
Process game;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
game = Process.Start(OutputExecutablePath);
}
else
{
game = Process.Start("wine", OutputExecutablePath);
}
if (game == null)
{
throw new Exception("No game process was started.");
}
game.Dispose();
Console.WriteLine("Done");
}
catch
{
Console.WriteLine("Warning: Unable to run the game process!");
}
}
Console.WriteLine("All Done!");
}
catch (Exception e)
{
Console.WriteLine();
Console.WriteLine("-- BUILD FAILURE, EXCEPTION BEGIN --");
Console.WriteLine(e.ToString());
Console.WriteLine("-- EXCEPTION END --");
Console.WriteLine();
return(Program.EXIT_FAILURE);
}
return(Program.EXIT_SUCCESS);
}
string SaveToString (WriteContext ctx)
{
// StringWriter.Encoding always returns UTF16. We need it to return UTF8, so the
// XmlDocument will write the UTF8 header.
ProjectWriter sw = new ProjectWriter (format.ByteOrderMark);
sw.NewLine = format.NewLine;
var xw = XmlWriter.Create (sw, new XmlWriterSettings {
OmitXmlDeclaration = !hadXmlDeclaration,
NewLineChars = format.NewLine,
NewLineHandling = NewLineHandling.Replace
});
MSBuildWhitespace.Write (initialWhitespace, xw);
Save (xw);
xw.Dispose ();
return sw.ToString ();
}
public void CanRemoveNonExistingFileFromProject()
{
var project = CsProjects.SampleProjectSimple;
var writer = new ProjectWriter(project);
writer.RemoveFile(@"asd.qwe/asd.txt");
var newProject = writer.GetXml();
}
public void Save(string fileName)
{
// StringWriter.Encoding always returns UTF16. We need it to return UTF8, so the
// XmlDocument will write the UTF8 header.
ItemGroups.Each(group => {
var elements = group.Items.Select(x => x.Element).OrderBy(x => x.GetAttribute("Include")).ToArray();
group.Element.RemoveAll();
elements.Each(x => group.Element.AppendChild(x));
});
var sw = new ProjectWriter(bom);
sw.NewLine = newLine;
doc.Save(sw);
string content = sw.ToString();
if (endsWithEmptyLine && !content.EndsWith(newLine))
content += newLine;
new FileSystem().WriteStringToFile(fileName, content);
}
public void Save (string fileName)
{
// StringWriter.Encoding always returns UTF16. We need it to return UTF8, so the
// XmlDocument will write the UTF8 header.
ProjectWriter sw = new ProjectWriter (bom);
sw.NewLine = newLine;
doc.Save (sw);
string content = sw.ToString ();
if (endsWithEmptyLine && !content.EndsWith (newLine))
content += newLine;
TextFile.WriteFile (fileName, content, bom, true);
}
public void Save(ProjectWriter writer)
{
writer.Write(Name);
writer.Write(Value);
}
private void Save_Header(ProjectWriter writer)
{
writer.Write(GameID);
writer.Write(DirectPlayGuid);
}
private ProjectWriter CreateProjectWriter(string @namespace, ProjectVersion projectVersion)
{
var pw = new ProjectWriter(@namespace, projectVersion);
return(pw);
}
private void Save_LastIDs(ProjectWriter writer)
{
writer.Write(LastInstanceID);
writer.Write(LastTileID);
}
public void Write(ProjectWriter writer)
{
writer.Write(StartInFullscreen);
writer.Write(InterpolatePixels);
writer.Write(DontDrawBorder);
writer.Write(DisplayCursor);
writer.Write(Scaling);
writer.Write(AllowWindowResize);
writer.Write(AlwaysOnTop);
writer.Write(OutsideRoom);
writer.Write(SetResolution);
writer.Write((int)ColorDepth);
writer.Write((int)ScreenResolution);
writer.Write((int)Frequency);
writer.Write(Borderless);
uint vsync = VSync ? 1U : 0U;
if (SoftwareVertex)
{
vsync |= 0x80000000;
}
writer.Write(vsync);
writer.Write(DisableScreensavers);
writer.Write(LetF4Fullscreen);
writer.Write(LetF1GameInfo);
writer.Write(LetESCEndGame);
writer.Write(LetF5F6SaveLoad);
writer.Write(LetF9Screenshot);
writer.Write(TreatCloseAsESC);
writer.Write((int)Priority);
writer.Write(FreezeWhenFocusLost);
writer.Write((int)LoadingBarMode);
if (LoadingBarMode == ProgBars.BAR_CUSTOM)
{
if (BackLoadingBar != null)
{
writer.Write(1);
writer.Write(BackLoadingBar);
}
else
{
writer.Write(0);
}
if (FrontLoadingBar != null)
{
writer.Write(1);
writer.Write(FrontLoadingBar);
}
else
{
writer.Write(0);
}
}
writer.Write(ShowCustomLoadImage);
if (ShowCustomLoadImage)
{
if (LoadingImage != null)
{
writer.Write(1);
writer.Write(LoadingImage);
}
else
{
writer.Write(0);
}
}
writer.Write(LoadimgImagePartTransparent);
writer.Write(LoadImageAlpha);
writer.Write(ScaleProgressBar);
writer.Write(GameIcon);
writer.Write(DisplayErrors);
writer.Write(WriteToLog);
writer.Write(AbortOnAllErrors);
writer.Write(TreatUninitAsZero);
writer.Write(Author);
writer.Write(Version);
writer.Write(LastChanged);
writer.Write(Information);
writer.Write(GameVersion);
writer.Write(Company);
writer.Write(Product);
writer.Write(Copyright);
writer.Write(Description);
writer.Write(OptionsLastChanged);
}
public string SaveToString ()
{
// StringWriter.Encoding always returns UTF16. We need it to return UTF8, so the
// XmlDocument will write the UTF8 header.
ProjectWriter sw = new ProjectWriter (bom);
sw.NewLine = newLine;
doc.Save (sw);
string content = sw.ToString ();
if (endsWithEmptyLine && !content.EndsWith (newLine))
content += newLine;
return content;
}
private static int GenerateSources(
IList <string> source,
IList <string> classToGenerate,
string projectAssembly = "Generated.WASM",
string projectGenerationLocation = "_generated",
bool force = false
)
{
try
{
var stopwatch = Stopwatch.StartNew();
ValidateArguments(
source,
classToGenerate,
projectAssembly,
projectGenerationLocation
);
GlobalLogger.Info($"projectAssembly: {projectAssembly}");
GlobalLogger.Info($"projectGenerationLocation: {projectGenerationLocation}");
GlobalLogger.Info($"classToGenerate.Length: {classToGenerate.Count}");
foreach (var classToGenerateItem in classToGenerate)
{
GlobalLogger.Info($"classToGenerateItem: {classToGenerateItem}");
}
GlobalLogger.Info($"sourceFile.Length: {source.Count}");
foreach (var sourceFileItem in source)
{
GlobalLogger.Info($"sourceFile: {sourceFileItem}");
}
projectGenerationLocation = Path.Combine(
".",
projectGenerationLocation
);
var sourceDirectory = Path.Combine(
".",
SOURCE_FILES_DIRECTORY_NAME
);
var sourceFiles = CopyAndDownloadSourceFiles(
source
);
var generationList = classToGenerate;
// Check for already Generated Source.
var projectAssemblyDirectory = Path.Combine(
projectGenerationLocation,
projectAssembly
);
if (Directory.Exists(
projectAssemblyDirectory
))
{
if (!force)
{
GlobalLogger.Error(
$"Project Assembly Directory was not empty: {projectAssemblyDirectory}"
);
GlobalLogger.Error(
$"Use --force to replace directory."
);
return(502);
}
GlobalLogger.Warning(
$"Deleting existing projectAssemblyDirectory: {projectAssemblyDirectory}"
);
Directory.Delete(
projectAssemblyDirectory,
true
);
}
var textFormatter = new NoFormattingTextFormatter();
var writer = new ProjectWriter(
projectGenerationLocation,
projectAssembly
);
new GenerateSource().Run(
projectAssembly,
sourceDirectory,
sourceFiles,
generationList,
writer,
textFormatter,
new Dictionary <string, string>
{
{ "BABYLON.PointerInfoBase | type", "int" }
}
);
stopwatch.Stop();
GlobalLogger.Success($"Took {stopwatch.ElapsedMilliseconds}ms to Generate Source Project.");
return(0);
}
catch (ArgumentException ex)
{
GlobalLogger.Error(
$"Argument failure: {ex.ParamName} -> {ex.Message}"
);
return(404);
}
catch (InvalidSourceFileException ex)
{
GlobalLogger.Error(
$"Invalid Source File Exception: {ex.Message}"
);
return(501);
}
}