public void ModifyNameAndVersion()
{
var importPipeline = ImportPipeline.Create().Build();
var createExplorer = ProjectExplorer.CreateProject(FileName("project"), importPipeline);
createExplorer.Definition.Properties.Name = "TestName1";
createExplorer.Definition.Properties.Version = "1.0.0";
createExplorer.Definition.SaveChanges();
var loadExplorer = ProjectExplorer.Load(FileName("project"), importPipeline);
Assert.That(loadExplorer.Definition.Properties.Name, Is.EqualTo("TestName1"));
Assert.That(loadExplorer.Definition.Properties.Version, Is.EqualTo("1.0.0"));
loadExplorer.ExportZippedToDirectory(new BuildPipeline()
{
ImportPipeline = importPipeline,
}, FileName("export"));
var packageImport = PackageExplorer.LoadFromFileAsync(
Path.Combine(FileName("export"), "TestName1.bpkg")).Result;
Assert.That(packageImport.Definition.Properties.Name, Is.EqualTo("TestName1"));
Assert.That(packageImport.Definition.Properties.Version, Is.EqualTo("1.0.0"));
}
public BuildCommand(string name, string description = null) : base(name, description)
{
AddArgument(new Argument <FileInfo>("project", null)
{
Description = "A project file to use."
});
Handler = CommandHandler.Create((ParseResult parseResult, IConsole console) =>
{
var project = parseResult.ValueForOption <FileInfo>("project");
if (project == null)
{
project = FindFileOfType(".bproj");
}
var importPipeline = new ImportPipeline();
var projectExplorer = ProjectExplorer.Load(project.DirectoryName, importPipeline);
string exportDirectory = "./bin/";
Directory.CreateDirectory(exportDirectory);
var consoleRenderer = new BuildConsoleRenderer();
var buildPipeline = new BuildPipeline()
{
BuildActions = new List <IBuildAction>()
{
consoleRenderer
}
};
consoleRenderer.DrawProgressBar(32);
projectExplorer.Export(buildPipeline, exportDirectory);
});
}
public void ModifyVersion()
{
var importPipeline = ImportPipeline.Create().Build();
string projectPath = TestUtilities.CreateFilePath("project");
string exportPath = Path.Combine(TestUtilities.CreateFilePath("export"), "project.bpkg");
using (var explorer = ProjectExplorer.CreateProject(projectPath, importPipeline))
{
explorer.Definition.Properties.Version = "1.0.0";
explorer.Definition.SaveChanges();
}
using (var explorer = ProjectExplorer.Load(projectPath, importPipeline))
{
Assert.That(explorer.Definition.Properties.Version, Is.EqualTo("1.0.0"));
explorer.ExportZippedToDirectory(new BuildPipeline()
{
ImportPipeline = importPipeline,
}, TestUtilities.CreateFilePath("export"));
}
using (var explorer = PackageExplorer.LoadFromFileAsync(exportPath).Result)
{
Assert.That(explorer.Definition.Properties.Version, Is.EqualTo("1.0.0"));
}
}
public void CreateBlankProject()
{
var importPipeline = ImportPipeline.Create().Build();
string projectPath = TestUtilities.CreateFilePath("project");
using (var explorer = ProjectExplorer.CreateProject(projectPath, importPipeline))
{
explorer.Definition.Properties.Name = "TestName1";
explorer.Definition.SaveChanges();
}
}
private static void ImportSimulationArguments(CliOptions options)
{
_log.Debug("Processing cli options");
SimArgs = new ImportPipeline(options, Factory, Runtime)
.Run(new RuntimeImporter())
.Run(new EnergyImporter())
.Run(new DevicesImporter())
.Run(new SceneImporter())
.Run(new ChannelImporter())
.Run(new AntennaImporter())
.Run(new CommunicationImporter())
.Arguments;
_log.Debug("Cli options processed");
}
public async Task <ImportPipeline> CreateImportPipelineResourceAsync()
{
var importResourceGroupName = options.ImportPipeline.ResourceGroupName;
var importRegistryName = options.ImportPipeline.RegistryName;
var registry = await registryClient.Registries.GetAsync(
importResourceGroupName,
importRegistryName).ConfigureAwait(false);
if (registry != null)
{
var importPipeline = new ImportPipeline(
name: options.ImportPipeline.PipelineName,
location: registry.Location,
identity: IdentityHelper.GetManagedIdentity(options.ImportPipeline.UserAssignedIdentity),
source: new ImportPipelineSourceProperties
{
Type = "AzureStorageBlobContainer",
Uri = options.ImportPipeline.ContainerUri,
KeyVaultUri = options.ImportPipeline.KeyVaultUri
},
trigger: new PipelineTriggerProperties
{
SourceTrigger = new PipelineSourceTriggerProperties
{
Status = "Enabled"
}
},
options: options.ImportPipeline.Options
);
return(await registryClient.ImportPipelines.CreateAsync(registryName : registry.Name,
resourceGroupName : options.ImportPipeline.ResourceGroupName,
importPipelineName : options.ImportPipeline.PipelineName,
importPipelineCreateParameters : importPipeline).ConfigureAwait(false));
}
else
{
throw new ArgumentException($"Could not find registry '{importRegistryName}'. Please ensure the registry exists in the current resource group {importResourceGroupName}.");
}
}
public void Validate()
{
if (string.IsNullOrWhiteSpace(TenantId))
{
throw new ArgumentNullException(nameof(TenantId));
}
if (string.IsNullOrWhiteSpace(MIClientId) &&
(string.IsNullOrWhiteSpace(SPClientId) || string.IsNullOrWhiteSpace(SPClientSecret)))
{
throw new ArgumentNullException($"Missing {nameof(MIClientId)} or {nameof(SPClientId)}/{nameof(SPClientSecret)}");
}
if (string.IsNullOrWhiteSpace(SubscriptionId))
{
throw new ArgumentNullException(nameof(SubscriptionId));
}
ExportPipeline.Validate();
ImportPipeline.Validate();
}
public FormatCommand(string name, string description = null) : base(name, description)
{
AddArgument(new Argument <FileInfo>("project", null)
{
Description = "A project file to use."
});
Handler = CommandHandler.Create((ParseResult parseResult, IConsole console) =>
{
var project = parseResult.ValueForOption <FileInfo>("project");
if (project == null)
{
project = FindFileOfType(".bproj");
}
var importPipeline = new ImportPipeline();
var projectExplorer = ProjectExplorer.Load(project.DirectoryName, importPipeline);
projectExplorer.Definition.SaveChanges();
});
}
public static void Run()
{
var manifest = BehaviourManifest.CreateFromAppDomain(AppDomain.CurrentDomain);
File.WriteAllText("Content/RPGCoreMath.bmfst", manifest.ToString());
Console.WriteLine("Importing Graph...");
var importPipeline = ImportPipeline.Create().Build();
var proj = ProjectExplorer.Load("Content/Core", importPipeline);
Console.WriteLine(proj.Definition.Properties.Name);
Console.WriteLine($"\t\"{proj.Definition.Properties.Name}\"");
foreach (var resource in ((IExplorer)proj).Resources)
{
Console.WriteLine($"\t{resource.FullName}");
}
var editorTargetResource = proj.Resources["Fireball/Main.json"];
var editorTargetData = editorTargetResource.Content.LoadStream();
JObject editorTarget;
var serializer = new JsonSerializer();
using (var sr = new StreamReader(editorTargetData))
using (var reader = new JsonTextReader(sr))
{
editorTarget = JObject.Load(reader);
}
var editor = new EditorSession(manifest, editorTarget, "SerializedGraph", serializer);
foreach (var node in (editor.Root.Fields["Nodes"].Value as EditorObject).Fields.Values)
{
var nodeData = (node.Value as EditorObject).Fields["Data"];
foreach (var field in (nodeData.Value as EditorObject).Fields.Values)
{
var editableValue = field.Value as EditorValue;
Console.WriteLine($"{field}");
if (field.Field.Name == "MaxValue")
{
editableValue.SetValue(editableValue.GetValue <int>() + 10);
editableValue.ApplyModifiedProperties();
editableValue.SetValue(editableValue.GetValue <int>());
editableValue.ApplyModifiedProperties();
}
else if (field.Field.Name == "ValueB")
{
Console.WriteLine(editableValue.GetValue <LocalPropertyId>());
}
}
}
using (var file = editorTargetResource.Content.OpenWrite())
using (var sr = new StreamWriter(file))
using (var jsonWriter = new JsonTextWriter(sr)
{
Formatting = Formatting.Indented
})
{
serializer.Serialize(jsonWriter, editorTarget);
}
Console.WriteLine(new DirectoryInfo("Content/Temp").FullName);
var consoleRenderer = new BuildConsoleRenderer();
var buildPipeline = new BuildPipeline();
buildPipeline.Exporters.Add(new BhvrExporter());
buildPipeline.BuildActions.Add(consoleRenderer);
consoleRenderer.DrawProgressBar(32);
proj.ExportZippedToDirectory(buildPipeline, "Content/Temp");
Console.WriteLine("Exported package...");
var exportedPackage = PackageExplorer.LoadFromFileAsync("Content/Temp/Core.bpkg").Result;
var fireballAsset = exportedPackage.Resources["Fireball/Main.json"];
var data = fireballAsset.Content.LoadStream();
SerializedGraph packageItem;
using (var sr = new StreamReader(data))
using (var reader = new JsonTextReader(sr))
{
packageItem = serializer.Deserialize <SerializedGraph>(reader);
}
Console.WriteLine("Imported: " + fireballAsset.Name);
var unpackedGraph = packageItem.Unpack();
Console.WriteLine("Running Simulation...");
var player = new DemoPlayer();
IGraphInstance instancedItem = unpackedGraph.Create();
instancedItem.Setup();
instancedItem.SetInput(player);
for (int i = 0; i < 5; i++)
{
Thread.Sleep(100);
player.Health.Value -= 10;
}
instancedItem.Remove();
var settings = new JsonSerializerSettings();
settings.Converters.Add(new LocalIdJsonConverter());
settings.Converters.Add(new SerializedGraphInstanceProxyConverter(null));
string serializedGraph = JsonConvert.SerializeObject(instancedItem, settings);
// var packedInstance = ((GraphInstance)instancedItem).Pack ();
// string serializedGraph = packedInstance.AsJson ();
Console.WriteLine(serializedGraph);
var deserialized = JsonConvert.DeserializeObject <SerializedGraphInstance>(serializedGraph);
var unpackedInstance = deserialized.Unpack(unpackedGraph);
unpackedInstance.SetInput(player);
unpackedInstance.Setup();
for (int i = 0; i < 5; i++)
{
Thread.Sleep(100);
player.Health.Value -= 20;
}
unpackedInstance.Remove();
for (int i = 0; i < 5; i++)
{
Thread.Sleep(100);
player.Health.Value -= 20;
}
}
public static void Run()
{
var nodes = NodeManifest.Construct(
new Type[] {
typeof(AddNode),
typeof(RollNode),
typeof(OutputValueNode),
typeof(ItemInputNode),
typeof(ActivatableItemNode),
typeof(IterateNode),
typeof(GetStatNode),
}
);
var types = TypeManifest.ConstructBaseTypes();
var manifest = new BehaviourManifest()
{
Nodes = nodes,
Types = types
};
File.WriteAllText("Content/RPGCoreMath.bmfst", manifest.ToString());
Console.WriteLine("Importing Graph...");
var importPipeline = new ImportPipeline();
var proj = ProjectExplorer.Load("Content/Core", importPipeline);
Console.WriteLine(proj.Name);
Console.WriteLine("\t\"" + proj.Name + "\"");
foreach (var resource in ((IExplorer)proj).Resources)
{
Console.WriteLine("\t" + resource.FullName);
}
var editorTargetResource = proj.Resources["Fireball/Main.bhvr"];
var editorTargetData = editorTargetResource.LoadStream();
JObject editorTarget;
var serializer = new JsonSerializer();
using (var sr = new StreamReader(editorTargetData))
using (var reader = new JsonTextReader(sr))
{
editorTarget = JObject.Load(reader);
}
var editor = new EditorSession(manifest, editorTarget, "SerializedGraph", serializer);
foreach (var node in editor.Root["Nodes"])
{
var nodeData = node["Data"];
foreach (var field in nodeData)
{
Console.WriteLine($"{field}");
if (field.Name == "MaxValue")
{
field.SetValue(field.GetValue <int>() + 10);
field.ApplyModifiedProperties();
field.SetValue(field.GetValue <int>());
field.ApplyModifiedProperties();
}
else if (field.Name == "ValueB")
{
Console.WriteLine(field.GetValue <LocalPropertyId>());
}
}
}
using (var file = editorTargetResource.WriteStream())
using (var jsonWriter = new JsonTextWriter(file)
{
Formatting = Formatting.Indented
})
{
serializer.Serialize(jsonWriter, editorTarget);
}
Console.WriteLine(new DirectoryInfo("Content/Temp").FullName);
var consoleRenderer = new BuildConsoleRenderer();
var buildPipeline = new BuildPipeline()
{
Exporters = new List <ResourceExporter>()
{
new BhvrExporter()
},
BuildActions = new List <IBuildAction>()
{
consoleRenderer
}
};
consoleRenderer.DrawProgressBar(32);
proj.Export(buildPipeline, "Content/Temp");
Console.WriteLine("Exported package...");
var exportedPackage = PackageExplorer.Load("Content/Temp/Core.bpkg");
var fireballAsset = exportedPackage.Resources["Fireball/Main.bhvr"];
var data = fireballAsset.LoadStream();
SerializedGraph packageItem;
using (var sr = new StreamReader(data))
using (var reader = new JsonTextReader(sr))
{
packageItem = serializer.Deserialize <SerializedGraph>(reader);
}
Console.WriteLine("Imported: " + packageItem.Name);
var unpackedGraph = packageItem.Unpack();
Console.WriteLine("Running Simulation...");
var player = new DemoPlayer();
IGraphInstance instancedItem = unpackedGraph.Create();
instancedItem.Setup();
instancedItem.SetInput(player);
for (int i = 0; i < 5; i++)
{
Thread.Sleep(100);
player.Health.Value -= 10;
}
instancedItem.Remove();
var settings = new JsonSerializerSettings();
settings.Converters.Add(new LocalIdJsonConverter());
settings.Converters.Add(new SerializedGraphInstanceProxyConverter(null));
string serializedGraph = JsonConvert.SerializeObject(instancedItem, settings);
// var packedInstance = ((GraphInstance)instancedItem).Pack ();
// string serializedGraph = packedInstance.AsJson ();
Console.WriteLine(serializedGraph);
var deserialized = JsonConvert.DeserializeObject <SerializedGraphInstance>(serializedGraph);
var unpackedInstance = deserialized.Unpack(unpackedGraph);
unpackedInstance.SetInput(player);
unpackedInstance.Setup();
for (int i = 0; i < 5; i++)
{
Thread.Sleep(100);
player.Health.Value -= 20;
}
unpackedInstance.Remove();
for (int i = 0; i < 5; i++)
{
Thread.Sleep(100);
player.Health.Value -= 20;
}
}
public void Start()
{
// Import the project
var importPipeline = new ImportPipeline();
importPipeline.ImportProcessors.Add(new BoardGameResourceImporter());
var projectExplorer = ProjectExplorer.Load("Content/BoardGame", importPipeline);
// Build the project to a package.
var consoleRenderer = new BuildConsoleRenderer();
var buildPipeline = new BuildPipeline();
buildPipeline.Exporters.Add(new BhvrExporter());
buildPipeline.BuildActions.Add(consoleRenderer);
consoleRenderer.DrawProgressBar(32);
projectExplorer.Export(buildPipeline, "BoardGame/Temp");
Console.WriteLine("Exported package...");
Step();
var gameServer = new GameServer();
gameServer.StartHosting(projectExplorer);
var playerA = LocalId.NewShortId();
var playerB = LocalId.NewShortId();
gameServer.OnClientConnected(playerA, "Player A");
gameServer.OnClientConnected(playerB, "Player B");
DrawGameState(gameServer.Lobby);
Step();
gameServer.AcceptInput(playerA, new StartGameCommand()
{
});
DrawGameState(gameServer.Lobby);
Step();
gameServer.AcceptInput(playerA, new DeclareResourceCommand()
{
ResourceIdentifier = "x"
});
DrawGameState(gameServer.Lobby);
Step();
gameServer.AcceptInput(playerA, new PlaceResourceCommand()
{
ResourceIdentifier = "x",
ResourcePosition = new Integer2(2, 2)
});
DrawGameState(gameServer.Lobby);
Step();
gameServer.AcceptInput(playerB, new PlaceResourceCommand()
{
ResourceIdentifier = "x",
ResourcePosition = new Integer2(3, 1)
});
DrawGameState(gameServer.Lobby);
Step();
gameServer.AcceptInput(playerB, new EndTurnCommand());
DrawGameState(gameServer.Lobby);
}
public void Start()
{
var serializer = new JsonSerializer();
Console.WriteLine("Importing Graph...");
var importPipeline = ImportPipeline.Create()
.UseProcessor(new TagAllProjectResourceImporter())
.Build();
var projectExplorer = ProjectExplorer.Load("Content/Core", importPipeline);
Console.WriteLine("Building project files...");
RenderDirectory(projectExplorer.Archive.RootDirectory);
var consoleRenderer = new BuildConsoleRenderer();
var buildPipeline = new BuildPipeline();
buildPipeline.BuildActions.Add(consoleRenderer);
consoleRenderer.DrawProgressBar(32);
projectExplorer.ExportZippedToDirectory(buildPipeline, "Content/Temp");
Console.WriteLine("Exported package...");
var exportedPackage = PackageExplorer.LoadFromFileAsync("Content/Temp/Core.bpkg").Result;
RenderDirectory(exportedPackage.Source);
var fireballAsset = exportedPackage.Resources["Fireball/Main.json"];
var data = fireballAsset.Content.OpenRead();
SerializedGraph packageItem;
using (var sr = new StreamReader(data))
using (var reader = new JsonTextReader(sr))
{
packageItem = serializer.Deserialize <SerializedGraph>(reader);
}
Console.WriteLine("Imported: " + fireballAsset.Name);
var unpackedGraph = packageItem.Unpack();
Console.WriteLine("Running Simulation...");
var player = new DemoPlayer();
IGraphInstance instancedItem = unpackedGraph.Create();
instancedItem.Setup();
instancedItem.SetInput(player);
for (int i = 0; i < 5; i++)
{
Thread.Sleep(100);
player.Health.Value -= 10;
}
instancedItem.Remove();
var settings = new JsonSerializerSettings();
settings.Converters.Add(new LocalIdJsonConverter());
settings.Converters.Add(new SerializedGraphInstanceProxyConverter(null));
string serializedGraph = JsonConvert.SerializeObject(instancedItem, settings);
Console.WriteLine(serializedGraph);
var deserialized = JsonConvert.DeserializeObject <SerializedGraphInstance>(serializedGraph);
var unpackedInstance = deserialized.Unpack(unpackedGraph);
unpackedInstance.SetInput(player);
unpackedInstance.Setup();
for (int i = 0; i < 5; i++)
{
Thread.Sleep(100);
player.Health.Value -= 20;
}
unpackedInstance.Remove();
for (int i = 0; i < 5; i++)
{
Thread.Sleep(100);
player.Health.Value -= 20;
}
}
/// <summary>
/// Creates an import pipeline for a container registry with the specified
/// parameters.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group to which the container registry belongs.
/// </param>
/// <param name='registryName'>
/// The name of the container registry.
/// </param>
/// <param name='importPipelineName'>
/// The name of the import pipeline.
/// </param>
/// <param name='importPipelineCreateParameters'>
/// The parameters for creating an import pipeline.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async System.Threading.Tasks.Task <ImportPipeline> BeginCreateAsync(this IImportPipelinesOperations operations, string resourceGroupName, string registryName, string importPipelineName, ImportPipeline importPipelineCreateParameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginCreateWithHttpMessagesAsync(resourceGroupName, registryName, importPipelineName, importPipelineCreateParameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Creates an import pipeline for a container registry with the specified
/// parameters.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group to which the container registry belongs.
/// </param>
/// <param name='registryName'>
/// The name of the container registry.
/// </param>
/// <param name='importPipelineName'>
/// The name of the import pipeline.
/// </param>
/// <param name='importPipelineCreateParameters'>
/// The parameters for creating an import pipeline.
/// </param>
public static ImportPipeline BeginCreate(this IImportPipelinesOperations operations, string resourceGroupName, string registryName, string importPipelineName, ImportPipeline importPipelineCreateParameters)
{
return(operations.BeginCreateAsync(resourceGroupName, registryName, importPipelineName, importPipelineCreateParameters).GetAwaiter().GetResult());
}
public async Task StartAsync()
{
// Import the project
var importPipeline = ImportPipeline.Create()
.UseImporter(new BoardGameResourceImporter())
.UseJsonMetaFiles(options =>
{
options.IsMetaFilesOptional = true;
})
.Build();
var projectExplorer = ProjectExplorer.Load("Content/BoardGame", importPipeline);
// Build the project to a package.
var consoleRenderer = new BuildConsoleRenderer();
var buildPipeline = new BuildPipeline();
buildPipeline.BuildActions.Add(consoleRenderer);
consoleRenderer.DrawProgressBar(32);
projectExplorer.ExportZippedToDirectory(buildPipeline, "BoardGame/Temp");
var packageExplorer = PackageExplorer.LoadFromFileAsync("BoardGame/Temp/BoardGame.bpkg").Result;
var dest = new FileSystemArchive(new DirectoryInfo("BoardGame/Temp"));
await packageExplorer.Source.CopyIntoAsync(dest.RootDirectory, "Fast");
var cottage = packageExplorer.Resources["buildings/cottage.json"];
foreach (var dep in cottage.Dependencies)
{
Console.WriteLine($"{dep.Key}: {dep.Resource?.Name}");
}
Step();
var gameServer = new GameServer();
gameServer.StartHosting(projectExplorer);
var playerA = LocalId.NewShortId();
var playerB = LocalId.NewShortId();
gameServer.OnClientConnected(playerA, "Player A");
gameServer.OnClientConnected(playerB, "Player B");
DrawGameState(gameServer.Lobby);
Step();
gameServer.AcceptInput(playerA, new StartGameCommand()
{
});
DrawGameState(gameServer.Lobby);
Step();
gameServer.AcceptInput(playerA, new DeclareResourceCommand()
{
ResourceIdentifier = "x"
});
DrawGameState(gameServer.Lobby);
Step();
gameServer.AcceptInput(playerA, new PlaceResourceCommand()
{
ResourceIdentifier = "x",
ResourcePosition = new Integer2(2, 2)
});
DrawGameState(gameServer.Lobby);
Step();
gameServer.AcceptInput(playerB, new PlaceResourceCommand()
{
ResourceIdentifier = "x",
ResourcePosition = new Integer2(3, 1)
});
DrawGameState(gameServer.Lobby);
Step();
gameServer.AcceptInput(playerA, new BuildBuildingCommand()
{
BuildingIdentifier = "cottage",
BuildingPosition = new Integer2(1, 1),
Offset = new Integer2(1, 1),
});
DrawGameState(gameServer.Lobby);
Step();
gameServer.AcceptInput(playerB, new EndTurnCommand());
DrawGameState(gameServer.Lobby);
}
