protected virtual void LoadSharedConfiguration()
{
var definition = new ContainerDefinition(_sharedConfigElement);
try
{
var sharedConfiguration = GetContainer(definition);
// Assert that expected dependencies exist - and in the case of data stores are specifically singletons (WEIRD things happen otherwise)
sharedConfiguration.AssertSingleton(typeof(ITemplateMetadataGenerator));
sharedConfiguration.AssertSingleton(typeof(IArchitectureValidator));
sharedConfiguration.AssertSingleton(typeof(IInputProvider));
sharedConfiguration.Assert(typeof(ILogger));
_sharedConfig = sharedConfiguration;
}
catch (InvalidOperationException ex)
{
if (ex.Message.Contains("Leprechaun.InputProviders.Rainbow"))
{
new ConsoleLogger().Error("Unable to resolve dependency. If you are using Rainbow, ensure you have the /r switch in the command line arguments.", ex);
}
else
{
new ConsoleLogger().Error($"{ex.Message}.\n\nCheck your configuration files to make sure it is typed correctly. " +
$"If so, ensure that the dlls are in the correct location. " +
$"You may need to use the /p switch to specify this location", ex);
}
Environment.Exit(1);
}
}
public override FileActionStatus Delete(FileDefinition fileDefinition, ContainerDefinition containerDefinition)
{
var status = new FileActionStatus();
var path = GetFullFilePath(fileDefinition, containerDefinition);
// Fail early if file doesn't exist
if (!File.Exists(path))
{
status.Status = Status.NoAction;
status.Message = Constants.Messages.FileDoesNotExist;
return(status);
}
try
{
File.Delete(path);
if (_removeEmptyPathsOnDelete)
{
RemoveEmptyDirectories(containerDefinition.Path);
}
}
catch (Exception)
{
status.Status = Status.NoAction;
status.Message = Constants.Messages.NoAction;
}
status.Status = Status.Success;
status.Message = Constants.Messages.Success;
return(status);
}
public override void ReplaceVariables(ContainerDefinition definition)
{
foreach (var instance in _replacerCollection)
{
instance.ReplaceVariables(definition);
}
}
public override FileActionStatus Save(FileDefinition fileDefinition, ContainerDefinition containerDefinition,
FileCreateOptions fileCreateOptions,
ContainerCreateOptions containerCreateOptions)
{
var status = new FileActionStatus();
// If we aren't allowing auto creation of directories, fail
if (!Directory.Exists(containerDefinition.Path) && !_createPathsAutomatically)
{
status.Status = Status.NoAction;
status.Message = Constants.Messages.NoAction +
" Path does not exist, and config to create paths automatically is false.";
return(status);
}
// Create directory if it doesn't exist
Directory.CreateDirectory(containerDefinition.Path);
var path = GetFullFilePath(fileDefinition, containerDefinition);
// Overwrite based on provided option
if (!fileCreateOptions.OverwriteExisting && File.Exists(path))
{
status.Status = Status.NoAction;
status.Message = Constants.Messages.NoAction +
" File already exists; must explicitly set option to overwrite.";
return(status);
}
SaveFile(path, fileDefinition.Data).Wait();
status.Status = Status.Success;
status.Message = Constants.Messages.Success;
return(status);
}
public virtual void ReplaceVariables(ContainerDefinition definition)
{
foreach (var replacer in _innerReplacers)
{
replacer.ReplaceVariables(definition);
}
}
public async Task <List <AddedFileDto> > AddUserPlantMediaAsync(List <AddFileDto> files, string userPlantId, string userId)
{
var path = $"{userId}\\{userPlantId}";
var addedFiles = new List <AddedFileDto>();
foreach (var file in files)
{
var fileName = $"{Guid.NewGuid().ToString()}{file.FileExtension}";
var containerDefinition = new ContainerDefinition {
Name = "UserPlants", Path = path
};
var fileDefinition = new FileDefinition {
Name = fileName, Data = file.File
};
await _fileClient.SaveFile(containerDefinition, fileDefinition);
var addedFile = new AddedFileDto
{
FileName = fileName,
FilePath = path
};
addedFiles.Add(addedFile);
}
return(addedFiles);
}
internal static void SetModPath(ContainerDefinition baseDefs, string modContext)
{
if (baseDefs.WeaponDefs != null)
{
for (int i = 0; i < baseDefs.WeaponDefs.Length; i++)
{
baseDefs.WeaponDefs[i].ModPath = modContext;
}
}
if (baseDefs.SupportDefs != null)
{
for (int i = 0; i < baseDefs.SupportDefs.Length; i++)
{
baseDefs.SupportDefs[i].ModPath = modContext;
}
}
if (baseDefs.UpgradeDefs != null)
{
for (int i = 0; i < baseDefs.UpgradeDefs.Length; i++)
{
baseDefs.UpgradeDefs[i].ModPath = modContext;
}
}
}
public static async Task <TaskDefinition> RegisterFargateTaskAsync(this ECSHelper ecs,
string executionRoleArn,
string family,
int cpu,
int memory,
string name,
string image,
Dictionary <string, string> envVariables,
string logGroup,
IEnumerable <int> ports,
CancellationToken cancellationToken = default(CancellationToken))
{
var env = envVariables?.Select(x => new Amazon.ECS.Model.KeyValuePair()
{
Name = x.Key, Value = x.Value
})?.ToList();
var lc = new LogConfiguration()
{
LogDriver = new LogDriver("awslogs"),
Options = new Dictionary <string, string>()
{
{ "awslogs-group", logGroup },
{ "awslogs-region", ecs.Client.GetRegionName() },
{ "awslogs-stream-prefix", "ecs" }
}
};
var pmTCP = ports.Select(x => new PortMapping()
{
ContainerPort = x, HostPort = x, Protocol = TransportProtocol.Tcp
});
var cd = new ContainerDefinition()
{
Name = name,
Image = image,
Environment = env,
LogConfiguration = lc,
PortMappings = pmTCP.ToList(),
MemoryReservation = (int)(memory * 4) / 5
};
var response = await ecs.RegisterTaskDefinitionAsync(
executionRoleArn,
executionRoleArn,
family,
new string[] { "FARGATE" },
new List <ContainerDefinition>() { cd },
cpu,
memory,
NetworkMode.Awsvpc,
cancellationToken);
return(response.TaskDefinition);
}
public virtual void ReplaceVariables(ContainerDefinition definition)
{
if (definition.Name == null)
{
throw new ArgumentException("Configuration without a name was used. Add a name attribute to all configurations.", nameof(definition));
}
var args = new UnicornExpandConfigurationVariablesPipelineArgs(definition);
CorePipeline.Run("unicornExpandConfigurationVariables", args);
}
public override void ReplaceVariables(ContainerDefinition definition)
{
if (definition.Name == null)
{
throw new ArgumentException("Configuration without a name was used. Add a name attribute to all configurations.", nameof(definition));
}
ApplyVariables(definition.Definition, new Dictionary <string, string> {
{ "configurationName", definition.Name }
});
}
public override void ReplaceVariables(ContainerDefinition definition)
{
if (definition.Name == null)
{
throw new ArgumentException("Configuration without a name was used. Add a name attribute to all configurations.", nameof(definition));
}
var variables = GetVariables(definition.Name);
ApplyVariables(definition.Definition, variables);
}
protected override IContainer CreateContainer(ContainerDefinition definition)
{
var description = GetAttributeValue(definition.Definition, "description");
var attributeValue = GetAttributeValue(definition.Definition, "dependencies");
var dependencies = !string.IsNullOrEmpty(attributeValue) ? attributeValue.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries) : null;
var ignoredAttributeValue = GetAttributeValue(definition.Definition, "ignoredImplicitDependencies");
var ignoredDependencies = !string.IsNullOrEmpty(ignoredAttributeValue) ? ignoredAttributeValue.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries) : null;
return(new MicroConfiguration(definition.Name, description, definition.Extends, dependencies, ignoredDependencies));
}
protected virtual void LoadSharedConfiguration()
{
var definition = new ContainerDefinition(_sharedConfigElement);
var sharedConfiguration = GetContainer(definition);
// Assert that expected dependencies exist - and in the case of data stores are specifically singletons (WEIRD things happen otherwise)
sharedConfiguration.AssertSingleton(typeof(ITemplateMetadataGenerator));
sharedConfiguration.AssertSingleton(typeof(IArchitectureValidator));
sharedConfiguration.Assert(typeof(ILogger));
_sharedConfig = sharedConfiguration;
}
public virtual IContainer GetContainer(ContainerDefinition definition)
{
_variablesReplacer?.ReplaceVariables(definition);
var container = CreateContainer(definition);
foreach (XmlElement dependency in definition.Definition.ChildNodes.OfType <XmlElement>())
{
RegisterConfigTypeInterfaces(dependency, container);
}
return(container);
}
public override FileActionStatus Move(FileDefinition fileDefinition, ContainerDefinition containerDefinition,
ContainerDefinition newContainerDefinition, string newFileName = null)
{
var status = new FileActionStatus();
var newFileDefinition = new FileDefinition {
Name = newFileName ?? fileDefinition.Name
};
// Don't clone fileDefinition since we don't need the data here, just the name
var oldPath = GetFullFilePath(fileDefinition, containerDefinition);
var newPath = GetFullFilePath(newFileDefinition, newContainerDefinition);
// Fail early if file doesn't exist
if (!File.Exists(oldPath))
{
status.Status = Status.NoAction;
status.Message = Constants.Messages.FileDoesNotExist;
return(status);
}
try
{
// If we aren't allowing auto creation of directories, fail
if (!Directory.Exists(newContainerDefinition.Path) && !_createPathsAutomatically)
{
status.Status = Status.NoAction;
status.Message = Constants.Messages.NoAction +
" Destination path does not exist, and config to create paths automatically is false.";
return(status);
}
Directory.CreateDirectory(newContainerDefinition.Path);
File.Move(oldPath, newPath);
if (_removeEmptyPathsOnMove)
{
RemoveEmptyDirectories(containerDefinition.Path);
}
}
catch (Exception)
{
status.Status = Status.NoAction;
status.Message = Constants.Messages.NoAction;
}
status.Status = Status.Success;
status.Message = Constants.Messages.Success;
return(status);
}
protected void SpawnContainer(string name)
{
ContainerDefinition cDef = ContainerManifest.GetContainerDefinition(name);
if (cDef == null)
{
return; // If the ContainerDefinition is null, we just return here. We will have already logged an error in ContainerManifest's function which will have our stack trace.
}
Container c = Instantiate(cDef.Actor, inputPosition,
Quaternion.identity, transform);
Containers.Add(c);
c.Definition = cDef;
pickedActor = c;
pickedActor.transform.position = inputPosition;
}
public ContainerSaveData(
ISaveContext context,
int objectId,
object target,
ContainerType containerType)
{
this.ObjectId = objectId;
this.Context = context;
this.Target = target;
this._containerType = containerType;
this.Type = target.GetType();
this._elementCount = this.GetElementCount();
this._childStructs = new List <ObjectSaveData>();
this._typeDefinition = context.DefinitionContext.GetContainerDefinition(this.Type);
if (this._typeDefinition == null)
{
throw new Exception("Could not find type definition of container type: " + (object)this.Type);
}
}
public static void AddCosmosContext <TContext>(this IServiceCollection services) where TContext : CosmosContext, new()
{
services.AddTransient(typeof(TContext), provider =>
{
var cosmosDbClient = provider.GetRequiredService <ICosmosDbClient>();
var cosmosContext = new TContext();
Type cosmosContextType = typeof(TContext);
// concrete repository type to instantiate against the IRepository<> interface
Type repoType = typeof(CosmosDbContainerRepository <>);
IEnumerable <PropertyInfo> contextRepositories = cosmosContextType.GetProperties()
.Where(prop =>
prop.PropertyType.IsInterface &&
prop.PropertyType.IsGenericType &&
prop.PropertyType.GetGenericTypeDefinition() == typeof(IRepository <>));
foreach (PropertyInfo prop in contextRepositories)
{
Type repositoryEntityGenericType = prop.PropertyType.GetGenericArguments()[0];
Type constructedRepoType = repoType.MakeGenericType(repositoryEntityGenericType);
// TODO: how can we allow multiple repos of the same type but with different names and pk paths?
// We somehow have to search via ContainerDefs or... rework the whole config story...and have a Config() method on the CosmosContext that
// we use to configure each repository individually...
ContainerDefinition containerDefinition = cosmosDbClient.GetContainerDefinitionForType(prop.PropertyType.GetGenericArguments()[0]);
ICosmosDbContainer container = cosmosDbClient.CreateContainer(containerDefinition).ConfigureAwait(false).GetAwaiter().GetResult();
var entityTypeNameResolverInstance = new CosmosDbEntityTypeNameResolver();
var pkvResolver = new CosmosDbPartitionKeyResolver();
var idValueGeneratorType = typeof(CosmosDbIdValueGenerator <>);
var idValueGeneratorInstanceType = idValueGeneratorType.MakeGenericType(repositoryEntityGenericType);
var idValueGeneratorInstance = Activator.CreateInstance(idValueGeneratorInstanceType);
object repoInstance = Activator.CreateInstance(constructedRepoType, args: new object[] { container, entityTypeNameResolverInstance, idValueGeneratorInstance, pkvResolver });
prop.SetValue(cosmosContext, repoInstance);
}
return(cosmosContext);
});
}
public void ExecuteTryReadExample()
{
// Create definitions
var file = new FileDefinition {
Name = "output.jpg"
};
var container = new ContainerDefinition {
Path = @"C:/temp/nstore-test/photos"
};
// Save file
byte[] output;
var status = _fileSystemRepository.TryRead(file, container, out output);
// Done!
Console.WriteLine("Attempting to read file \"{0}\" in {1}", file.Name, container.Path);
Console.WriteLine("Read file from repository, total {0} KB", output.LongLength / 1024);
Console.WriteLine(status.Message);
}
public void ExecuteSaveExample()
{
// Get some data
var data = File.ReadAllBytes(AppDomain.CurrentDomain.BaseDirectory + "example-files/mountain-fog.jpg");
// Create definitions
var file = new FileDefinition {
Name = "output.jpg", Data = data
};
var container = new ContainerDefinition {
Path = @"C:/temp/nstore-test/photos"
};
// Save file
var status = _fileSystemRepository.Save(file, container);
// Done!
Console.WriteLine("Attempting to save file \"{0}\" in {1}", file.Name, container.Path);
Console.WriteLine(status.Message);
}
public override FileActionStatus TryRead(FileDefinition fileDefinition, ContainerDefinition containerDefinition,
out byte[] data)
{
var status = new FileActionStatus();
var path = GetFullFilePath(fileDefinition, containerDefinition);
try
{
data = File.ReadAllBytes(path);
status.Status = Status.Success;
status.Message = Constants.Messages.Success;
}
catch (Exception)
{
data = null;
status.Status = Status.NoAction;
status.Message = Constants.Messages.NoAction;
}
return(status);
}
public static void AddCosmosDbContext <TContext>(this IServiceCollection services) where TContext : DbContext, new()
{
services.AddTransient(typeof(TContext), provider =>
{
var cosmosDbClient = provider.GetRequiredService <ICosmosDbClient>();
var instance = new TContext();
Type instanceType = typeof(TContext);
// concrete repository type to instantiate against the IRepository<> interface
Type repoType = typeof(CosmosDbContainerRepository <>);
IEnumerable <PropertyInfo> contextRepositories = instanceType.GetProperties()
.Where(prop =>
prop.PropertyType.IsInterface &&
prop.PropertyType.IsGenericType &&
prop.PropertyType.GetGenericTypeDefinition() == typeof(IRepository <>));
var containerFactory = provider.GetRequiredService <ICosmosDbContainerFactory>();
foreach (PropertyInfo prop in contextRepositories)
{
Type repositoryEntityGenericType = prop.PropertyType.GetGenericArguments()[0];
Type constructedRepoType = repoType.MakeGenericType(repositoryEntityGenericType);
ContainerDefinition containerDefinition = cosmosDbClient.GetContainerDefinitionForType(prop.PropertyType.GetGenericArguments()[0]);
ICosmosDbContainer container = containerFactory.Create(instanceType, containerDefinition, cosmosDbClient);
var entityTypeNameResolverInstance = new CosmosDbEntityTypeNameResolver();
var pkvResolver = new CosmosDbPartitionKeyResolver();
var idValueGeneratorType = typeof(CosmosDbIdValueGenerator <>);
var idValueGeneratorInstanceType = idValueGeneratorType.MakeGenericType(repositoryEntityGenericType);
var idValueGeneratorInstance = Activator.CreateInstance(idValueGeneratorInstanceType);
object repoInstance = Activator.CreateInstance(constructedRepoType, args: new object[] { container, entityTypeNameResolverInstance, idValueGeneratorInstance, pkvResolver });
prop.SetValue(instance, repoInstance);
}
return(instance);
});
}
public void DynamicContainer_Basic_Props()
{
var props = new List <ContainerPropDefinition>();
props.Add(new ContainerPropDefinition()
{
Name = "Prop1", Type = typeof(int)
});
ContainerDefinition def = new ContainerDefinition();
def.Name = "Foo";
def.Properties = props.ToArray();
Type t = ContainerEmmitter.Emit(def);
dynamic obj = Activator.CreateInstance(t);
obj.Prop1 = 12;
Assert.AreEqual(12, obj.Prop1);
}
public void ExecuteSaveExample()
{
// Get some data
var data = File.ReadAllBytes(AppDomain.CurrentDomain.BaseDirectory + "example-files/mountain-fog.jpg");
// Create definitions
var file = new FileDefinition {
Name = "output.jpg", Data = data
};
var container = new ContainerDefinition {
Path = @"C:/temp/nstore-test/photos"
};
// File and container options
var fileCreateOptions = Defaults <FileCreateOptions> .GetDefault();
fileCreateOptions.OverwriteExisting = true;
var containerCreateOptions = Defaults <ContainerCreateOptions> .GetDefault();
containerCreateOptions.MakeFilesPublic = true;
// Save file
var status = _fileSystemRepository.Save(file, container, fileCreateOptions);
Console.WriteLine("Attempting to save file \"{0}\" in {1}", file.Name, container.Path);
Console.WriteLine(status.Message);
// Let's move it too by specifying a new container (a clone of our container, actually) and a new name for the file
var newContainer = new ContainerDefinition(container)
{
Path = "C:/temp/nstore-test2/photos"
};
var newFileName = "output-new.jpg";
status = _fileSystemRepository.Move(file, container, newContainer, newFileName);
Console.WriteLine("Attempting to move file \"{0}\" to {1} with new name \"{2}\"", file.Name,
newContainer.Path, newFileName);
Console.WriteLine(status.Message);
}
public override IContainer CreateContainer(ReadOnlySettings settings)
{
IMessageBusContainer container;
if (settings.TryGet <IMessageBusContainer>("MessageBusContainer", out container))
{
if (container.NativeContainer is IKernel)
{
_builder = new NinjectBuilder();
}
else if (container.NativeContainer is IUnityContainer)
{
_builder = new UnityBuilder();
}
if (_builder != null)
{
return(_builder.CreateContainer(settings));
}
}
return(null);
}
public static void openGUI(SSTUVolumeContainer container, ContainerDefinition[] modContainers)
{
containerIndex = 0;
module = container;
int len = modContainers.Length;
List<ContainerDefinition> availContainers = new List<ContainerDefinition>();
for (int i = 0; i < len; i++)
{
if (modContainers[i].guiAvailable && modContainers[i].containerPercent > 0)
{
availContainers.Add(modContainers[i]);
}
}
containers = availContainers.ToArray();
id = module.GetInstanceID();
statId = id + 1;
len = containers.Length;
if (len <= 0)
{
closeGUI();
return;
}
resourceEntries = new VolumeRatioEntry[len][];
string[] names;
PartResourceDefinition def;
for (int i = 0; i < len; i++)
{
names = containers[i].getResourceNames();
int len2 = names.Length;
resourceEntries[i] = new VolumeRatioEntry[len2];
for (int k = 0; k < len2; k++)
{
def = PartResourceLibrary.Instance.GetDefinition(names[k]);
resourceEntries[i][k] = new VolumeRatioEntry(containers[i], names[k], def.title, containers[i].getResourceUnitRatio(names[k]));
}
}
}
public void DynamicContainer_Basic_Reflection()
{
var props = new List <ContainerPropDefinition>();
props.Add(new ContainerPropDefinition()
{
Name = "Prop1", Type = typeof(int)
});
ContainerDefinition def = new ContainerDefinition();
def.Name = "Foo";
def.Properties = props.ToArray();
Type t = ContainerEmmitter.Emit(def);
dynamic obj = Activator.CreateInstance(t);
t.GetProperty("Prop1").SetValue(obj, 10, new object[] { });
Assert.AreEqual(10, t.GetProperty("Prop1").GetValue(obj, new object[] { }));
Assert.AreEqual("Foo", obj.GetType().Name);
Assert.AreEqual(1, obj.GetType().GetProperties().Length);
}
public UnicornExpandConfigurationVariablesPipelineArgs(ContainerDefinition configuration)
{
Assert.ArgumentNotNull(configuration, "configuration");
Configuration = configuration;
}
public void setResourceRatio(ContainerDefinition def, string resourceName, int newRatio, bool updateSymmetry = false)
{
def.setResourceRatio(resourceName, newRatio);
if (updateSymmetry)
{
foreach (Part p in part.symmetryCounterparts)
{
SSTUVolumeContainer mod = p.GetComponent<SSTUVolumeContainer>();
ContainerDefinition def2 = mod.getContainer(def.name);
mod.setResourceRatio(def2, resourceName, newRatio, false);
}
}
}
internal CdkStack(Construct scope, string id, IStackProps props = null)
: base(scope, id, props)
{
var vpc = new Vpc(this, "api-vpc", new VpcProps
{
MaxAzs = 3 // Default is all AZs in region
});
var cluster = new Cluster(this, "api-ecs-cluster", new ClusterProps
{
Vpc = vpc,
});
var task = new FargateTaskDefinition(this, "api-fargate-task", new FargateTaskDefinitionProps()
{
Cpu = 256,
MemoryLimitMiB = 512
});
var logGroup = new LogGroup(this, "loggroup-containers", new LogGroupProps()
{
Retention = RetentionDays.ONE_MONTH
});
var nginxContainer = new ContainerDefinition(this, "container-nginx", new ContainerDefinitionProps()
{
TaskDefinition = task,
Image = ContainerImage.FromAsset("../Web/Nginx", new AssetImageProps()
{
File = "Nginx.Dockerfile"
}),
PortMappings = new[]
{
new PortMapping() { HostPort = 80, ContainerPort = 80, Protocol = Protocol.TCP }
},
Essential = true,
Environment = new Dictionary<string, string>()
{
{ "WEB_HOST", "127.0.0.1" }
},
Logging = new AwsLogDriver(new AwsLogDriverProps()
{
LogGroup = logGroup,
StreamPrefix = "nginx"
})
});
var apiContainer = new ContainerDefinition(this, "container-api", new ContainerDefinitionProps()
{
TaskDefinition = task,
Image = ContainerImage.FromAsset("../Web/Mvc", new AssetImageProps()
{
File = "Mvc.Dockerfile"
}),
PortMappings = new[]
{
new PortMapping() { HostPort = 5000, ContainerPort = 5000, Protocol = Protocol.TCP }
},
Essential = true,
Logging = new AwsLogDriver(new AwsLogDriverProps()
{
LogGroup = logGroup,
StreamPrefix = "web"
})
});
// Create a load-balanced Fargate service and make it public
new ApplicationLoadBalancedFargateService(this, "api-fargate-loadbalancer",
new ApplicationLoadBalancedFargateServiceProps
{
Cluster = cluster, // Required
// DesiredCount = 6, // Default is 1
// TaskDefinition or TaskImageOptions must be specified, but not both.
TaskDefinition = task,
// MemoryLimitMiB = 2048, // Default is 256
PublicLoadBalancer = true // Default is false
}
);
}
public void subtractPresetRatios(ContainerDefinition container, ContainerFuelPreset preset, bool updateSymmetry)
{
container.subtractPresetRatios(preset);
if (updateSymmetry)
{
foreach (Part p in part.symmetryCounterparts)
{
SSTUVolumeContainer mod = p.GetComponent<SSTUVolumeContainer>();
ContainerDefinition def2 = mod.getContainer(container.name);
ContainerFuelPreset preset2 = def2.internalGetFuelPreset(preset.name);
mod.subtractPresetRatios(def2, preset2, false);
}
}
}
internal static void GetBaseDefinitions(out ContainerDefinition baseDefs)
{
baseDefs = new Parts().Container;
}
private void loadConfigData()
{
ConfigNode node = SSTUConfigNodeUtils.parseConfigNode(configNodeData);
ConfigNode[] containerNodes = node.GetNodes("CONTAINER");
int len = containerNodes.Length;
containers = new ContainerDefinition[len];
for (int i = 0; i < len; i++)
{
containers[i] = new ContainerDefinition(this, containerNodes[i], volume);
}
if (!string.IsNullOrEmpty(persistentData))
{
string[] splits = persistentData.Split(':');
len = containers.Length;
for (int i = 0; i < len && i < splits.Length; i++)
{
containers[i].loadPersistenData(splits[i]);
}
}
prevFuelType = getBaseContainer().fuelPreset;
}
public void containerTypeUpdated(ContainerDefinition container, ContainerModifier newType, bool updateSymmetry = false)
{
container.setModifier(newType);
updatePartStats();
if (updateSymmetry)
{
foreach (Part p in part.symmetryCounterparts)
{
SSTUVolumeContainer mod = p.GetComponent<SSTUVolumeContainer>();
ContainerDefinition def2 = mod.getContainer(container.name);
ContainerModifier mod2 = def2.internalGetModifier(newType.name);
mod.containerTypeUpdated(def2, mod2, false);
}
}
}
private static void addWindowFuelTypeControls(ContainerDefinition container)
{
GUILayout.Label("Fuel Types -- Click to add ratio, CTRL click to set ratio, SHIFT click to subtract ratio");
ContainerFuelPreset[] presets = container.fuelPresets;
ContainerFuelPreset preset;
GUILayout.BeginHorizontal();
for (int i = 0; i < presets.Length; i++)
{
preset = presets[i];
if (i > 0 && i % 4 == 0)
{
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
}
if (GUILayout.Button(preset.name, GUILayout.Width(175)))
{
if (ctrlPressed())//ctrl == set fuel type
{
container.module.setFuelPreset(container, presets[i], true);
}
else if (shiftPressed())
{
container.module.subtractPresetRatios(container, presets[i], true);
}
else
{
container.module.addPresetRatios(container, presets[i], true);
}
}
}
GUILayout.EndHorizontal();
}
public override void ReplaceVariables(ContainerDefinition definition)
{
ApplyVariables(definition.Definition, new Dictionary <string, string> {
{ "configDirectory", _configDirectory }
});
}
/// <summary>
/// Constructor used for cloning
/// </summary>
/// <param name="containerDefinition"></param>
public ContainerDefinition(ContainerDefinition containerDefinition)
{
Name = containerDefinition.Name;
Path = containerDefinition.Path;
}
public void addPresetRatios(ContainerDefinition container, ContainerFuelPreset preset, bool updateSymmetry)
{
container.addPresetRatios(preset);
if (updateSymmetry)
{
foreach (Part p in part.symmetryCounterparts)
{
SSTUVolumeContainer symmetryModule = p.GetComponent<SSTUVolumeContainer>();
ContainerDefinition symmetryModuleContainer = symmetryModule.getContainer(container.name);
ContainerFuelPreset symmetryModulePreset = symmetryModuleContainer.internalGetFuelPreset(preset.name);
symmetryModule.addPresetRatios(symmetryModuleContainer, symmetryModulePreset, false);
}
}
}
public VolumeRatioEntry(ContainerDefinition container, string resourceName, string displayName, int startRatio)
{
this.container = container;
this.resourceName = resourceName;
this.displayName = displayName;
this.prevRatio = startRatio;
this.textRatio = prevRatio.ToString();
this.fillPercent = container.getResourceFillPercent(resourceName);
updateCachedValues();
}
private static void addWindowContainerTypeControls(ContainerDefinition container)
{
GUILayout.BeginHorizontal();
GUILayout.Label("Select a container type:");
GUILayout.Label("Current Type: " + container.currentModifier.name);
GUILayout.EndHorizontal();
ContainerModifier[] mods = container.modifiers;
ContainerModifier mod;
int len = mods.Length;
GUILayout.BeginHorizontal();
for (int i = 0; i < len; i++)
{
mod = mods[i];
if (i > 0 && i % 4 == 0)
{
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
}
if (GUILayout.Button(mod.title, GUILayout.Width(175)))
{
module.containerTypeUpdated(container, mod, true);
}
}
GUILayout.EndHorizontal();
}
private static void addWindowContainerRatioControls(ContainerDefinition container)
{
GUILayout.Label("Adjust ratio through input box to change resource ratios");
VolumeRatioEntry[] ratioData = resourceEntries[containerIndex];
scrollPos = GUILayout.BeginScrollView(scrollPos);
GUILayout.BeginHorizontal();
GUILayout.Label("Resource", GUILayout.Width(150));
GUILayout.Label("Unit Ratio", GUILayout.Width(100));
GUILayout.Label("Units", GUILayout.Width(80));
GUILayout.Label("Volume", GUILayout.Width(80));
GUILayout.Label("Mass", GUILayout.Width(80));
GUILayout.Label("Cost", GUILayout.Width(80));
GUILayout.Label("% of Tank", GUILayout.Width(80));
GUILayout.Label("Fill %", GUILayout.Width(80));
GUILayout.EndHorizontal();
int len = ratioData.Length;
for (int i = 0; i < len; i++)
{
GUILayout.BeginHorizontal();
ratioData[i].draw();
GUILayout.EndHorizontal();
}
GUILayout.EndScrollView();
}
