/// <summary>
/// Generates the specified mode.
/// </summary>
/// <param name="mode">The mode.</param>
public override void Generate(GenerateMode mode)
{
ClearOutput();
Generator.Generate(GetSelectedTable(), GenerateMode.OutPutDir, ProjectBrowser.SelectedGenerations);
base.Generate(mode);
}
/// <summary>
/// Generates the specified mode.
/// </summary>
/// <param name="mode">The mode.</param>
public virtual void Generate(GenerateMode mode)
{
if (errorViewer != null)
{
errorViewer.ShowErrors(generator.Errors);
}
}
public (bool success, string possibleError) Init(object parameter, int seed)
{
if (parameter == null)
{
this.currentMode = GenerateMode.Random;
}
else if (parameter.GetType() == typeof(string))
{
var parsedParams = ParameterParser.GetParameterDictionary((string)parameter);
if (ParameterParser.ContainsKey(parsedParams, randomAliases))
{
this.currentMode = GenerateMode.Random;
}
}
else
{
string error = ErrorMessages.UnsupportedParameterType(LongName, "Init", parameter.GetType());
return(success : false, possibleError : error);
}
// Set values based on chosen GenerateMode
if (this.currentMode == GenerateMode.Random)
{
this.rng = new Random(seed);
this.GenerateFilename();
}
return(success : true, possibleError : "");
}
/// <summary>
/// Generates the specified mode.
/// </summary>
/// <param name="mode">The mode.</param>
public void Generate(GenerateMode mode)
{
if (ActiveManager != null)
{
ActiveManager.Generate(mode);
}
}
/// <summary>
/// Generates the generations.
/// </summary>
/// <param name="generations">The generations.</param>
/// <param name="mode">The mode.</param>
protected void Generate(List <Generation> generations, GenerateMode mode)
{
_errors.Clear();
if (mode == GenerateMode.Solution)
{
visualStudio.CheckVisualStudioSolution();
}
context.Put("datetimenow", DateTime.Now);
foreach (var generation in generations)
{
try
{
Generate(generation, mode);
}
catch (Exception ex)
{
_errors.Add(generation, ex);
}
}
if (mode == GenerateMode.Solution)
{
visualStudio.SaveSolution();
}
}
public HTMLGenerator(TextWriter inputWriter, GenerateMode mode, string CSSName)
{
if (indexWriter == null) throw new ArgumentNullException("inputWriter","Is null.");
this.textWriter = inputWriter;
this.mode = mode;
this.CSSFileName = CSSName;
this.indexWriter = new HtmlTextWriter(textWriter);
this.BeginDocument();
}
/// <summary>
/// 实例化一个根据时间存储的日志组件
/// </summary>
/// <param name="filePath">文件存储的路径</param>
/// <param name="generateMode">存储文件的间隔</param>
public LogNetDateTime(string filePath, GenerateMode generateMode = GenerateMode.ByEveryYear)
{
m_filePath = filePath;
m_generateMode = generateMode;
LogSaveMode = LogNetManagment.LogSaveModeByDateTime;
m_filePath = CheckPathEndWithSprit(m_filePath);
}
/// <summary>
///
/// </summary>
/// <param name="path"></param>
/// <param name="mode"></param>
/// <param name="CSSName"></param>
public HTMLGenerator(string path, GenerateMode mode, string CSSName)
{
this.textWriter = new StreamWriter(path + @"\index.html");
generatePath = path;
this.mode = mode;
this.CSSFileName = CSSName;
this.indexWriter = new HtmlTextWriter(textWriter);
this.BeginDocument();
}
/// <summary>
/// Generates the specified node.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="mode">The mode.</param>
/// <param name="generations">The generations.</param>
public void Generate(TreeNode node, GenerateMode mode, List <Generation> generations)
{
context.Put("node", node);
List <Generation> correctGenerations = new List <Generation>(generations);
string nodeTypeName = node.Tag.GetType().Name;
foreach (Generation generation in generations)
{
if (nodeTypeName.IndexOf(generation.ObjectType, StringComparison.InvariantCultureIgnoreCase) == -1)
{
correctGenerations.Remove(generation);
}
}
Generate(correctGenerations, mode);
}
/// <summary>
/// Generates the specified mode.
/// </summary>
/// <param name="mode">The mode.</param>
public override void Generate(GenerateMode mode)
{
if (Browser == null)
{
return;
}
List <Generation> generations = ProjectBrowser.SelectedGenerations;
ClearOutput();
foreach (TreeNode node in Browser.CheckedNodes)
{
Generator.Generate(node, mode, generations);
}
base.Generate(mode);
}
/// <summary>
/// Generates the mode.
/// </summary>
/// <param name="table">The table.</param>
/// <param name="mode">The mode.</param>
/// <param name="generations">The generations.</param>
public void Generate(BaseTable table, GenerateMode mode, List <Generation> generations)
{
if (table == null)
{
table = (BaseTable)PowerDesigner.GetSelectedObject();
}
if ((string)table.GetAttribute("Stereotype") != "entity")
{
throw new CodeGenerationException("Selected object is not entity");
}
context.Put("tableschema", schemaBuilder.CreateTableSchema(table));
context.Put("table", table);
Generate(generations, mode);
}
/// <summary>
/// 引数に合ったIGameGeneratorを作る
/// </summary>
/// <param name="generateMode">現在指定されている組み合わせ方法</param>
/// <returns>指定された組み合わせ方法のGenerator</returns>
/// <exception cref="ArgumentException">引数のgenerateModeに不適切なものが入っていた場合</exception>
public IGameGenerator Create(GenerateMode generateMode)
{
switch (generateMode)
{
case GenerateMode.Random:
return(new RandomGenerator());
case GenerateMode.RandomByGender:
return(new RandomByGenderGenerator());
case GenerateMode.RandomByLebel:
return(new RandomByLevelGenerator());
case GenerateMode.FewMatchPriority:
return(new FewMatchPriorityGenerator());
default:
throw new ArgumentException("generateModeに適切なものが入っていません");
}
}
/// <summary>
/// Generates the specified mode.
/// </summary>
/// <param name="mode">The mode.</param>
public override void Generate(GenerateMode mode)
{
if (Browser == null)
{
return;
}
ClearOutput();
List <Generation> generations = ProjectBrowser.SelectedGenerations;
List <TableSchema> tablesToGenerate = new List <TableSchema>();
foreach (DatabaseSchema database in Browser.Schemas)
{
foreach (TableSchema table in database.Tables)
{
foreach (ColumnSchema column in table.Columns)
{
column.IsSelected = false;
}
}
}
foreach (TreeNode node in Browser.CheckedNodes)
{
if (node.ImageIndex == (int)SchemaBrowser.ObjImage.Table)
{
tablesToGenerate.Add((TableSchema)node.Tag);
}
else if (node.ImageIndex == (int)SchemaBrowser.ObjImage.Column)
{
((ColumnSchema)node.Tag).IsSelected = true;
}
}
foreach (TableSchema table in tablesToGenerate)
{
Generator.Generate(table, mode, generations);
}
base.Generate(mode);
}
/// <summary>
/// Инициализирует новый экземпляр класса <see cref="MarkdownController"/>.
/// </summary>
/// <param name="generateMode">Набор опций режима генерации документации, передает в данный класс путь к шаблонам, путь для сохранения документации.</param>
public MarkdownController(GenerateMode generateMode)
{
_generateMode = generateMode;
_models = new Dictionary <BaseTypeNamespaceModel, MarkdownTemplateModel>();
_typeValue = new Dictionary <string, string>
{
{ "Class", "Класс" },
{ "Interface", "Интерфейс" },
{ "Struct", "Структура" },
{ "Enum", "Перечисление" },
{ "Constructor", "Конструктор" },
{ "Event", "Событие" },
{ "Field", "Поле" },
{ "NestedType", "Вложенный тип" },
{ "Property", "Свойство" },
{ "Method", "Метод" },
{ "Delegate", "Делегат" },
{ "Namespace", "Пространство имен" },
{ "Attribute", "Аттрибут" }
};
}
public string Generate(GenerateMode mode)
{
if (!_linked)
{
throw new ArgumentException("Please Link First");
}
if (_linker.ErrorInfos.Count != 0)
{
throw new ArgumentException("There are link errors");
}
GenerateContext context = new GenerateContext(_linker.AnonyCaptures, mode);
if (context.Mode == GenerateMode.MultiLine)
{
StringBuilder builder = new StringBuilder();
builder.Append('#').Append(Key).Append(" : ").Append(_group.Comment).Append('\n').Append(_syntaxTree.Root.Generate(context));
return(builder.ToString());
}
return(_syntaxTree.Root.Generate(context));
}
public (bool success, string possibleError) Init(object parameter, int seed)
{
if (parameter == null)
{
}
else if (parameter.GetType() == typeof(string))
{
string parameterAsString = (string)parameter;
parameterAsString = parameterAsString.ToLower();
if (randomModeKeywords.Contains(parameterAsString))
{
this.chosenMode = GenerateMode.Random;
}
else if (alternatingModeKeywords.Contains(parameterAsString))
{
this.chosenMode = GenerateMode.Alternating;
}
else
{
return(success : false, possibleError : ErrorMessages.UnsupportedParameterValue(LongName, "Init", parameterAsString));
}
}
else
{
return(success : false, possibleError : ErrorMessages.UnsupportedParameterType(LongName, "Init", parameter.GetType()));
}
if (this.chosenMode == GenerateMode.Random)
{
this.storedSeed = seed;
this.rng = new Random(seed);
this.currentValue = rng.Next(0, 2) == 0;
}
else if (this.chosenMode == GenerateMode.Alternating)
{
// TODO: Process current value override here
}
return(success : true, possibleError : "");
}
/// <summary>
/// Generates the generation.
/// </summary>
/// <param name="generation">The generation.</param>
/// <param name="mode">The mode.</param>
private void Generate(Generation generation, GenerateMode mode)
{
var fileName = GetDestinationFileName(generation);
var outputFilePath = OutputPath + fileName;
GenerateToOutputFolder(generation, outputFilePath);
if (mode == GenerateMode.SolutionDir || mode == GenerateMode.Solution)
{
var solutionFilePath = Path.Combine(generation.DestinationDirectory, fileName);
CopyToSolutionFolder(outputFilePath, solutionFilePath);
if (mode == GenerateMode.Solution)
{
InsertIntoSolution(generation.SolutionPath, solutionFilePath);
}
}
OnTemplateGenerated(new TemplateGenerateEventArgs(outputFilePath, File.ReadAllText(outputFilePath)));
}
public XmlController(GenerateMode generateMode)
{
_generateMode = generateMode;
_compiledTemplates = new Dictionary <string, Func <object, string> >();
}
/// <summary>
/// Generates the specified table.
/// </summary>
/// <param name="table">The table.</param>
/// <param name="mode">The mode.</param>
/// <param name="generations">The generations.</param>
public void Generate(TableSchema table, GenerateMode mode, List <Generation> generations)
{
context.Put("table", table);
Generate(generations, mode);
}
public GenerateContext(Dictionary <Capture, int> anonys, GenerateMode mode)
{
_level = 0;
_anonys = anonys;
_mode = mode;
}
public (bool success, string possibleError) Init(object parameter, int seed)
{
if (parameter == null)
{
// If no parameters are given
this.generateType = typeof(int);
this.chosenMode = GenerateMode.Random;
this.currentMinInclusive = IntegerGenerator.defaultMinIntInclusive;
this.currentMaxExclusive = IntegerGenerator.defaultMaxIntExclusive;
}
else if (parameter.GetType() == typeof(string))
{
string tempParameter = (string)parameter;
// Parse parameters
foreach (string separator in rangeSeparators)
{
if (tempParameter.Contains(separator))
{
string[] splitted = tempParameter.Split(new string[] { separator }, StringSplitOptions.None);
if (splitted.Length != 2)
{
return(success : false, possibleError : "Range for random should contain exactly 2 items, e.g. 13-4536");
}
if (long.TryParse(splitted[0], out long resultMin))
{
// Check if wanted min inclusive is int or long range
if (resultMin < IntegerGenerator.intMin || resultMin > IntegerGenerator.intMax)
{
this.currentMinInclusive = resultMin;
}
else
{
this.currentMinInclusive = (int)resultMin;
}
}
else
{
return(success : false, possibleError : $"{splitted[0]} is not number or it is outside of range {long.MinValue} .. {long.MaxValue}");
}
if (long.TryParse(splitted[1], out long resultMax))
{
// Check if wanted min inclusive is int or long range
if (resultMax < IntegerGenerator.intMin || resultMax > IntegerGenerator.intMax)
{
this.currentMaxExclusive = resultMax;
}
else
{
this.currentMaxExclusive = (int)resultMax;
}
}
else
{
return(success : false, possibleError : $"{splitted[0]} is not number or it is outside of range {long.MinValue} .. {long.MaxValue}");
}
// Check that min and max are same type
Type tOfMin = this.currentMinInclusive.GetType();
Type tOfMax = this.currentMaxExclusive.GetType();
if (tOfMin != tOfMax)
{
// If one is int and another is long, turn both to long
if (tOfMin == typeof(int))
{
this.currentMinInclusive = (long)(int)this.currentMinInclusive;
}
if (tOfMax == typeof(int))
{
this.currentMaxExclusive = (long)(int)this.currentMaxExclusive;
}
}
this.generateType = this.currentMinInclusive.GetType();
this.chosenMode = GenerateMode.Random;
}
}
}
else
{
return(success : false, possibleError : ErrorMessages.UnsupportedParameterType(LongName, "Init", parameter.GetType()));
}
if (this.chosenMode == GenerateMode.Random)
{
this.rng = new Random(seed);
this.storedSeed = seed;
this.NextStep();
}
else if (this.chosenMode == GenerateMode.WeightedRandom)
{
// TODO: Add code
}
return(success : true, possibleError : "");
}
public void GenerateMeshObject(GenerateMode generateMode, float smoothingAngleSameMaterial, float smoothingAngleDiffMaterial, List <Mesh> output_mesh_list, List <int> output_submesh_index_list)
{
if (generateMode == GenerateMode.RenderMesh)
{
//
// Building a render mesh -- materials matter
//
foreach (var kvp in m_submeshesBySubmeshIndex)
{
int submesh_index = kvp.Key;
SubmeshBuilder submesh_builder = kvp.Value;
// Sometimes we may create a submesh builder but not add any verts
// to it. This could be for no-render decal face flags.
List <FaceVertex> faceVerts;
if (!m_verts_by_submesh.TryGetValue(submesh_index, out faceVerts))
{
continue;
}
BuildMeshWorkerResult submesh_mesh_data = new BuildMeshWorkerResult();
submesh_mesh_data.Build(faceVerts);
Mesh m = new Mesh();
m.vertices = submesh_mesh_data.m_vertices;
// Needs UVs and colors
m.uv = submesh_mesh_data.m_uv1s;
if (submesh_mesh_data.m_has_uv2)
{
m.uv2 = submesh_mesh_data.m_uv2s;
}
if (submesh_mesh_data.m_has_uv3)
{
m.uv3 = submesh_mesh_data.m_uv3s;
}
if (submesh_mesh_data.m_has_translucent)
{
// Only take colors if there was a non-white color
m.colors = submesh_mesh_data.m_colors;
}
// As an optimization - each material gets its own mesh (instead of using submeshes within the mesh)
m.subMeshCount = 1;
m.SetTriangles(submesh_builder.SubmeshTriangleList, 0);
m.RecalculateNormals(smoothingAngleSameMaterial, smoothingAngleDiffMaterial, submesh_mesh_data.m_normal_lock, submesh_mesh_data.m_normals);
// Recalculate tangents (AFTER normals, as RecalculateNormals will destroy tangents)
m.RecalculateTangents();
m.RecalculateBounds();
output_mesh_list.Add(m);
output_submesh_index_list.Add(submesh_index);
}
}
else
{
//
// Building a collision mesh -- combine the verts
//
BuildMeshWorkerResult combined_mesh_data = new BuildMeshWorkerResult();
combined_mesh_data.Build(m_combined_verts);
Mesh m = new Mesh();
m.vertices = combined_mesh_data.m_vertices;
// Collision mesh is one submesh
m.subMeshCount = 1;
var all_combined_triangles = new List <int>();
foreach (var kvp in m_submeshesBySubmeshIndex)
{
int submeshIndex = kvp.Key;
if (submeshIndex < 0)
{
continue;
}
var submeshBuilder = kvp.Value;
if (submeshBuilder.GeomType == GeometryType.Portal)
{
// don't include the debug portal geometry into the collision data
continue;
}
all_combined_triangles.AddRange(submeshBuilder.CombinedTriangleList);
}
m.SetTriangles(all_combined_triangles.ToArray(), 0);
m.RecalculateNormals(smoothingAngleSameMaterial, smoothingAngleDiffMaterial, combined_mesh_data.m_normal_lock, combined_mesh_data.m_normals);
m.RecalculateBounds();
;
output_mesh_list.Add(m);
output_submesh_index_list.Add(0);
}
}
public void SetMode(GenerateMode mode)
{
RemoveFromClassList("Multiple");
RemoveFromClassList("Single");
AddToClassList(mode.ToString());
}
private static void GenerateHeightmap(NativeArray <float> heightmap, BurstModuleBase module, GenerateMode generateMode, int width, int height, double p1, double p2, double p3, double p4, bool p5 = false)
{
NativeArray <ModuleData> moduleData = CreateModuleData(module);
var job = new GenerateLibNoiseJob
{
moduleData = moduleData,
heightmap = heightmap,
width = width,
height = height,
generateMode = generateMode,
p1 = p1,
p2 = p2,
p3 = p3,
p4 = p4,
p5 = p5
};
JobHandle jobHandle = job.Schedule(heightmap.Length, 256);
jobHandle.Complete();
// // create texture
// Texture2D texture = new Texture2D(Width, Height);
// float[] heightmapValues = heightmap.ToArray();
// Color[] colors = new Color[heightmapValues.Length];
// for (int i = 0; i < heightmapValues.Length; i++) {
// float value = heightmapValues[i];
// value = (value + 1) / 2;
// colors[i] = new Color(value, value, value, 1);
// }
// texture.SetPixels(colors);
// texture.wrapMode = TextureWrapMode.Clamp;
// texture.Apply();
// GetComponent<Renderer>().material.mainTexture = texture;
moduleData.Dispose();
}
public MeshBuilder(GenerateMode mode)
{
Mode = mode;
}
/// <summary>
/// 配置参数
/// </summary>
public Log(GenerateMode mode)
{
//配置Log参数
LogRecord = new LogNetDateTime("./Log", mode);
}
public void CreateTest(GenerateMode generateMode, Type expectedGeneratorType)
{
Type actualGenerator = gameGeneratorFactory.Create(generateMode).GetType();
Assert.Equal(expectedGeneratorType, actualGenerator);
}
public MarkdownTemplate(GenerateMode generateMode)
{
_generateMode = generateMode;
CreateTemplate();
}
public static string Statement(string type, string name, string scheme, string text, GenerateMode mode)
{
var sw = new StringWriter();
string fullName = string.Format("[{0}].[{1}]", scheme, name);
switch (mode)
{
case GenerateMode.Create:
Create(sw, text);
break;
case GenerateMode.CreateOrAlter:
CreateOrAlter(sw, type, fullName, text);
break;
case GenerateMode.DeleteAndCreate:
DeleteAndCreate(sw, type, fullName, text);
break;
}
return(sw.ToString());
}
public async Task <Uri> Generate(string manifestName, GenerateMode generateMode)
{
if (string.IsNullOrWhiteSpace(manifestName))
{
throw new ArgumentException("Value can't be empty", nameof(manifestName));
}
var normalizedManifestName = manifestName.ToLower();
var pageName = manifestName;
var fileName = $"{normalizedManifestName}{PageExtension}";
var pageDefinition = _pageDefinitionService.Get(x => x.Type == PageType && x.PageName == pageName).FirstOrDefault();
switch (generateMode)
{
case GenerateMode.RetrieveExisting:
if (pageDefinition == null)
{
throw new ManifestPageNotFoundException(manifestName);
}
return(pageDefinition.Url);
case GenerateMode.GenerateIfNotExists:
if (pageDefinition != null)
{
return(pageDefinition.Url);
}
break;
}
var systemUser = _fr8AccountService.GetSystemUser()?.EmailAddress?.Address;
if (string.IsNullOrEmpty(systemUser))
{
throw new ManifestGenerationException("Failed to generate manifest description page. System user doesn't exist or not configured properly");
}
using (var uow = _uowFactory.Create())
{
var manifests = uow.MultiTenantObjectRepository.Query <ManifestDescriptionCM>(systemUser, x => x.Name.ToLower() == normalizedManifestName);
if (manifests.Count == 0)
{
throw new ManifestNotFoundException(manifestName);
}
manifests.Sort((x, y) => int.Parse(y.Version).CompareTo(int.Parse(x.Version)));
if (pageDefinition == null)
{
pageDefinition = new PageDefinitionDO
{
Type = PageType,
PageName = pageName,
};
}
pageDefinition.Title = $"Manifest description - {manifestName}";
pageDefinition.Description = $"Basic information and sample JSON of all registered version of '{manifestName}' manifest";
pageDefinition.Url = new Uri($"{_templateGenerator.BaseUrl}/{fileName}");
await _templateGenerator.Generate(new ManifestDescriptionTemplate(), fileName, new Dictionary <string, object>
{
["Manifests"] = manifests
});
_pageDefinitionService.CreateOrUpdate(pageDefinition);
return(pageDefinition.Url);
}
}
