private Module CreateModuleFromBuildModuleAtPosition(BuildModule buildModule, Vector2Int position)
{
Module module = new Module(buildModule.Name, buildModule.Size, position);
for (int x = position.x; x < position.x + buildModule.Size.x; x++)
{
for (int y = position.y; y < position.y + buildModule.Size.y; y++)
{
FieldTiles[x, y].TileType = FieldTile.eTileType.Module;
}
}
buildModule.AmountPlaced++;
_Modules.Add(module);
if (buildModule.ConnectionNeeded)
{
foreach (FieldTile tile in _Modules[0].GetSortedListByDistanceToModule(_Modules[0].GetAdjacentTilesOfType(FieldTiles, FieldTile.eTileType.Connection, FieldTile.eTileType.Empty), module))
{
if (TryCreateConnectionToModule(module, tile, new List <FieldTile>()))
{
break;
}
}
}
return(module);
}
public void UpdateDataFromWorld()
{
if (LocalModuleData == null)
{
LocalModuleData = new BuildModule();
}
else
{
LocalModuleData.BuildParts.Clear();
}
foreach (Transform child in transform)
{
UnityEngine.Object parentObject = PrefabUtility.GetPrefabParent(child);
Vector3 eulerAngles = child.transform.localRotation.eulerAngles;
BuildPart temp = new BuildPart
{
PositionX = child.localPosition.x,
PositionY = child.localPosition.y,
PositionZ = child.localPosition.z,
RotationX = eulerAngles.x,
RotationY = eulerAngles.y,
RotationZ = eulerAngles.z,
PartName = child.name,
PrefabName = parentObject.name
};
LocalModuleData.BuildParts.Add(temp);
}
}
/// <summary>
/// Find a mapping from PCH to the most included files by the files using it
/// </summary>
/// <param name="SourceFileToCompileEnvironment">Files being compiled</param>
/// <param name="PchToIncludeFileCount">Mapping of PCH to included files</param>
/// <param name="Log">Writer for log messages</param>
static void FindPchInfo(BuildTarget Target, Dictionary <SourceFile, CompileEnvironment> SourceFileToCompileEnvironment, Dictionary <FileReference, PchInfo> FileToPchInfo, TextWriter Log)
{
// Create a map of module to the shared PCH it uses
Dictionary <BuildModule, FileReference> ModuleToPch = new Dictionary <BuildModule, FileReference>();
// Recurse through all the includes for each source file
Dictionary <FileReference, int> UsingPchCount = new Dictionary <FileReference, int>();
foreach (KeyValuePair <SourceFile, CompileEnvironment> Pair in SourceFileToCompileEnvironment)
{
// Figure out which module it's in
BuildModule Module = Pair.Key.Module;
// Determine which PCH it's using
FileReference UsingPch;
if (!ModuleToPch.TryGetValue(Module, out UsingPch))
{
if (Module.PrivatePCH != null)
{
UsingPch = Module.PrivatePCH;
}
else if (Module.PCHUsage == BuildModulePCHUsage.UseExplicitOrSharedPCHs || Module.PCHUsage == BuildModulePCHUsage.UseSharedPCHs || Module.PCHUsage == BuildModulePCHUsage.Default)
{
HashSet <BuildModule> PossibleModules = new HashSet <BuildModule>(Module.NonCircularDependencies.Where(x => x.SharedPCH != null));
foreach (BuildModule PossibleModule in PossibleModules.ToArray())
{
PossibleModules.ExceptWith(PossibleModule.NonCircularDependencies);
}
if (PossibleModules.Count == 0)
{
Log.WriteLine("warning: No valid PCH found for {0}", Module);
}
else if (PossibleModules.Count == 1)
{
UsingPch = PossibleModules.First().SharedPCH;
}
else
{
Log.WriteLine("warning: Multiple valid PCHs for {0}: {1}", Module, String.Join(",", PossibleModules.Select(x => x.Name)));
}
}
else
{
Log.WriteLine("warning: Unknown PCH for {0}", Module);
}
ModuleToPch[Module] = UsingPch;
}
// Make sure we're using a PCH
if (UsingPch != null)
{
// Get the info for this PCH
PchInfo Info;
if (!FileToPchInfo.TryGetValue(UsingPch, out Info))
{
Info = new PchInfo(UsingPch);
Info.PublicIncludePathModules.Add(Target.Modules.First(x => UsingPch.IsUnderDirectory(x.Directory)));
for (int Idx = 0; Idx < Info.PublicIncludePathModules.Count; Idx++)
{
BuildModule NextModule = Info.PublicIncludePathModules[Idx];
Info.PublicIncludePathModules.UnionWith(NextModule.PublicDependencyModules.Except(NextModule.CircularlyReferencedModules));
}
FileToPchInfo.Add(UsingPch, Info);
}
// Increment the number of files using this PCH
Info.SourceFiles.Add(Pair.Key.Location);
// Find all the included files
HashSet <SourceFile> IncludedFiles = new HashSet <SourceFile>();
FindIncludedFiles(Pair.Key, IncludedFiles);
// Update the counts for each one
foreach (SourceFile IncludedFile in IncludedFiles)
{
int IncludeCount;
Info.IncludedFiles.TryGetValue(IncludedFile, out IncludeCount);
Info.IncludedFiles[IncludedFile] = IncludeCount + 1;
}
}
}
}
public void LoadFromFile()
{
string path = Path.Combine(Application.dataPath, FileLocation + "/" + BuildModuleName);
Debug.Log(path);
LocalModuleData = BuildModule.Load(path);
}
void Start()
{
LocalModuleData = new BuildModule();
}
public override async Task ExecuteAsync(IOperationExecutionContext context)
{
var info = new BuildInfo
{
Name = this.BuildName,
Version = this.BuildVersion,
Number = this.BuildNumber,
ArtifactoryPrincipal = this.UserName,
Type = this.ArtifactoryBuildType,
Properties = this.Properties?.ToDictionary(p => p.Key, p => p.Value.AsString()),
VcsUrl = this.VcsUrl,
VcsRevision = this.VcsRevision
};
if (!string.IsNullOrEmpty(this.BuildAgentName))
{
info.BuildAgent = new BuildAgent
{
Name = this.BuildAgentName,
Version = this.BuildAgentVersion
};
}
info.ExecutionUrl = $"{SDK.BaseUrl}/executions/execution-details?executionId={context.ExecutionId}";
/*
* using (var db = new DB.Context())
* {
* //info.Started = new DateTimeOffset((await db.Executions_GetExecutionAsync(context.ExecutionId).ConfigureAwait(false)).Start_Date, TimeSpan.Zero);
*
* if (this.IncludeIssues)
* {
* var release = (await db.Releases_GetReleaseAsync(context.ApplicationId, context.ReleaseNumber).ConfigureAwait(false)).Releases_Extended.Single();
* var sources = await db.IssueSources_GetIssueSourcesAsync(release.Release_Id).ConfigureAwait(false);
* var issues = (await Task.WhenAll(sources.Select(s => IssueSource.Create(s).EnumerateIssuesAsync(new IssueEnumerationContext(this, context, s)))).ConfigureAwait(false)).SelectMany(i => i);
* var buildIssues = issues.Select(i => new BuildIssue { Key = i.Id, Url = i.Url, Summary = i.Title });
*
* if (sources.Any())
* {
* info.Issues = new BuildIssues
* {
* Tracker = new BuildAgent
* {
* Name = string.Join(", ", sources.Select(s => IssueSource.Create(s).GetDescription().ToString())),
* Version = "0.0.0"
* },
* AffectedIssues = buildIssues,
* };
* }
* }
* }
*/
info.Modules = this.Modules?.Select(m => BuildModule.FromRuntimeValue(this, m.AsDictionary()));
using (var client = this.CreateClient())
using (var request = new StringContent(JsonConvert.SerializeObject(info), InedoLib.UTF8Encoding, "application/json"))
using (var response = await client.PutAsync("api/build", request, context.CancellationToken).ConfigureAwait(false))
{
await this.ParseResponseAsync(response).ConfigureAwait(false);
}
}
