GenerationRules

We found 10 examples in language CSharp for this search. You will see 29 fragments of code.

    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();

        GenerationRules rules = (GenerationRules)target;

        if (GUILayout.Button("Set Up"))
        {
            rules.SetUp();
        }
    }


        private void GenRulesForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            GenGlobal.SaveSetting(GenGlobal.AutoTuneSettings.GEN_RULES);
        }


        public static bool GetSetting(AutoTuneSettings autoTuneSettings)
        {
            try
            {
                switch (autoTuneSettings)
                {
                    case AutoTuneSettings.GEN_RULES:
                        GenerationRules = JsonConvert.DeserializeObject<GenerationRules>(AutoTuneSetting.Default.GenRules);
                        if (GenerationRules == null)
                        {
                            GenerationRules = new GenerationRules();
                            SaveSetting(AutoTuneSettings.GEN_RULES);
                        }
                        break;

                    case AutoTuneSettings.OLD_GEN_CONFIG:
                        AppConfig = JsonConvert.DeserializeObject<AppConfig>(AutoTuneSetting.Default.GenConfig);
                        if (AppConfig == null)
                        {
                            AppConfig = new AppConfig();
                            SaveSetting(AutoTuneSettings.OLD_GEN_CONFIG);
                        }

                        break;
                    default:
                        break;
                }
                return true;
            }
            catch (Exception ex) { System.Windows.Forms.MessageBox.Show(ex.ToString()); return false; }
        }

        public static void SaveSetting(AutoTuneSettings autoTuneSettings)
        {
            switch (autoTuneSettings)
            {
                case AutoTuneSettings.GEN_RULES:
                    AutoTuneSetting.Default.GenRules = JsonConvert.SerializeObject(GenerationRules);
                    AutoTuneSetting.Default.Save();
                    break;
                case AutoTuneSettings.OLD_GEN_CONFIG:
                    AutoTuneSetting.Default.GenConfig = JsonConvert.SerializeObject(AppConfig);
                    AutoTuneSetting.Default.Save();
                    break;
                default:
                    break;
            }
        }


    void Start()
    {
        isReply = true;
        heightRatio = GameObject.Find("Source").GetComponent<GenerationRules>().heightRatio;
    }

    void Update()
    {
        if (isReply)
        {
            nodes = gameObject.GetComponent<GenerationRules>().nodes;
            countNodes = nodes.GetLength(0);
            Action();
            isReply = false;
        }
    }

    /// <summary>
    /// Расстояние между узлами
    /// </summary>
    public float Dist(GameObject a, GameObject b)
    {
        return Vector3.Distance(a.transform.position, b.transform.position) + heightRatio * Mathf.Abs(a.transform.position.y - b.transform.position.y);
    }

    /// <summary>
    /// Выполнение алгоритма A*
    /// </summary>
    public void Action()
    {
        //доп.условие: NodeStart = NodeEnd
        if (nodeStartX == nodeEndX && nodeStartY == nodeEndY)
        {
            Debug.Log("Стартовый и конечный узлы - это один и тот же узел");
            return;
        }
        //доп.условие: некорректные данные
        if (nodeStartX >= countNodes || nodeStartX < 0
            || nodeEndX >= countNodes || nodeEndX < 0
            || nodeStartY >= countNodes || nodeStartY < 0
            || nodeEndY >= countNodes || nodeEndY < 0)
        {
            Debug.Log("Некорректные данные: выход за границы поля");
            return;
        }

        //открытый список для нодов, ожидающих рассмотрения
        var openList = new PriorityQueue();
        //закоытый список для нодов, которые рассмотрели
        var closedList = new List<GameObject>();

        //выносим отдельно конечный узел
        var endNode = GetComponent<GenerationRules>().nodes[nodeEndY, nodeEndX];

        //помечаем стартовый узел
        var startNode = GetComponent<GenerationRules>().nodes[nodeStartY, nodeStartX];
        startNode.GetComponent<NodeElement>().LightOnVisited();
        //обнуляеи значения стартового узла
        SetParameters(startNode, 0, 0);

        //добавление стартовой клетки в открытый список
        openList.Add(startNode);
        while (true)
        {
            //достаем из открытого списка
            var currentObject = openList.GetPriorityElement();
            //кладем в закрытый
            closedList.Add(currentObject);

            //определение координат текущего узла
            var indexI = 0;
            var indexJ = 0;
            for (var i = 0; i < countNodes; i++)
            {
                var exit = false;
                for (var j = 0; j < countNodes; j++)
                    if (nodes[i, j].Equals(currentObject))
                    {
                        indexI = i;
                        indexJ = j;
                        exit = true;
                        break;
                    }
                if (exit) break;
            }
            //определяем координаты соседей (их может быть до 8)
            for (var i = -1; i <= 1; i++)
            {
                for (var j = -1; j <= 1; j++)
                {
                    //исключаем текущую клетку
                    if (i == 0 && j == 0) continue;
                    //начинаем проверку условий:
                    //1) Если клетка непроходима или находится в закрытом списке, игнорируем её.
                    if (GetObject(indexI, indexJ, i, j) != null && !closedList.Contains(nodes[indexI + i, indexJ + j]))
                    {
                        //Если клетка не в открытом списке, то добавляем её в открытый список, 
                        //при этом рассчитываем для неё значения G, H и F, и также устанавливаем ссылку родителя на текущую клетку.
                        GameObject searchElement = openList.Search(nodes[indexI + i, indexJ + j]);
                        if (searchElement == null)
                        {
                            //если рассматриваемый узел от текущего лежит по диагонале, то коэффициент g = +14 иначе +10
                            var g = currentObject.GetComponent<NodeElement>().G;
                            // if (i == 0 || j == 0) g += 10;
                            // else g += 14;
                            g += Dist(currentObject, nodes[indexI + i, indexJ + j]);
                            //h рассчитывается по методом Манхэттена
                            // var h = (Mathf.Abs((indexI + i) - nodeEndY) + Mathf.Abs((indexJ + j) - nodeEndX)) * 10;
                            var h = Dist(currentObject, nodes[nodeEndY, nodeEndX]);
                            //установка параметров
                            SetParameters(nodes[indexI + i, indexJ + j], h, g, currentObject);
                            openList.Add(nodes[indexI + i, indexJ + j]);
                        }
                        else
                        //Если клетка находится в открытом списке, то сравниваем её значение G со значением G таким, что если бы к ней пришли через текущую клетку. 
                        //Если сохранённое в проверяемой клетке значение G больше нового, то меняем её значение G на новое, 
                        //пересчитываем её значение F и изменяем указатель на родителя так, чтобы она указывала на текущую клетку.
                        {
                            var oldG = searchElement.GetComponent<NodeElement>().G;
                            //если рассматриваемый узел от текущего лежит по диагонале, то коэффициент g = +14 иначе +10
                            var newG = currentObject.GetComponent<NodeElement>().G;
                            // if (i == 0 || j == 0) newG += 10;
                            // else newG += 14;
                            newG += Dist(currentObject, nodes[indexI + i, indexJ + j]);
                            //если новое значение лучше (меньше), то меняем параметры найденного узла, иначе не трогаем ничего
                            if (newG < oldG) SetParameters(searchElement, -1, newG, currentObject);
                        }
                    }
                }
            }

            //условие выхода: в открытый список добавили целевую клетку
            if (openList.Search(endNode) != null) break;
            
            //условия выхода: открытый список пуст
            if (openList.Count == 0)
            {
                Debug.Log("Путь не был найден");
                return;
            }
        }

        //отрисовываем найденный путь
        GameObject currentNode = endNode;
        while (currentNode.GetComponent<NodeElement>().parent != null)
        {
            currentNode.GetComponent<NodeElement>().LightOnVisited();
            currentNode = currentNode.GetComponent<NodeElement>().parent;
        }
        Debug.Log("Путь найден");
        gameObject.GetComponent<GenerationRules>().ResetCooldown();
    }

    /// <summary>
    /// Установить параметры для указанного узла
    /// </summary>
    /// <param name="node">Сам узел</param>
    /// <param name="h">Примерное количество энергии, затрачиваемое на передвижение от текущей клетки до целевой клетки B. Если не требуется менять значение, то отправлять в параметр -1</param>
    /// <param name="g">Энергия, затрачиваемая на передвижение из стартовой клетки A в текущую рассматриваемую клетку, следуя найденному пути к этой клетке</param>
    /// <param name="parent">Родительский узел (тот из которого пришли)</param>
    private void SetParameters(GameObject node, float h, float g, GameObject parent = null)
    {
        if (h != -1) node.GetComponent<NodeElement>().H = h;
        node.GetComponent<NodeElement>().G = g;
        node.GetComponent<NodeElement>().F = h +  g;
        node.GetComponent<NodeElement>().parent = parent;
    }

    /// <summary>
    /// Получить объект из матрицы nodes по его индексам: index i = currentI + plusI, index j = currentJ + plusJ
    /// </summary>
    /// <returns>Если узел можно рассмотреть, то вернется объект, иначе null</returns>
    private GameObject GetObject(int currentI, int currentJ, int plusI, int plusJ)
    {
        var newI = currentI + plusI;
        var newJ = currentJ + plusJ;
        //проверка на выход за границы массива
        if (newI < 0 || newJ < 0 || newI >= countNodes || newJ >= countNodes)
            return null;
        //возврат найденного объекта, если клетка проходима
        return !nodes[newI, newJ].GetComponent<NodeElement>().isLet? nodes[newI, newJ] : null;
    }


        [GlobalSetup]
        public void SetupGenerator()
        {
            generator = new AssemblyGenerator(new DoNothingCompileStrategy());

            for (var i = 0; i < 50; i++)
            {
                generator.AddFile($"Benchmark{i}.cs", @"
namespace Blueprint.Benchmarks
{
    public class CompileBenchmarks{i}
    {
        public void Scenario1()
        {
            System.Console.WriteLine(""Hey!!"");
        }
    }
}".Replace("{i}", i.ToString()));
            }

            generationRules = new GenerationRules {AssemblyName = "Blueprint.Benchmarks"};
        }

        [Benchmark]
        public Assembly Base()
        {
            return generator.Generate(generationRules);
        }
            public Assembly TryLoadExisting(string sourceTextHash, string assemblyName)
            {
                return null;
            }

            public Assembly Compile(string sourceTextHash, CSharpCompilation compilation, Action<EmitResult> check)
            {
                return null;
            }


        /// <summary>
        /// Registers the <see cref="InMemoryOnlyCompileStrategy" /> as compilation strategy
        /// to use.
        /// </summary>
        /// <returns>This builder.</returns>
        public BlueprintCompilationBuilder UseInMemoryCompileStrategy()
        {
            this._blueprintApiBuilder.Services.AddSingleton<ICompileStrategy, InMemoryOnlyCompileStrategy>();

            return this;
        }

        /// <summary>
        /// Registers the <see cref="UseFileCompileStrategy" /> as compilation strategy, compiling to the
        /// given output folder.
        /// to use.
        /// </summary>
        /// <param name="path">The output folder to store the compiled DLL in.</param>
        /// <returns>This builder.</returns>
        public BlueprintCompilationBuilder UseFileCompileStrategy(string path)
        {
            this._blueprintApiBuilder.Services.AddSingleton<ICompileStrategy>(
                c => new ToFileCompileStrategy(c.GetRequiredService<ILogger<ToFileCompileStrategy>>(), path));

            return this;
        }

        /// <summary>
        /// Uses the specified optimization level when compiling the pipelines.
        /// </summary>
        /// <param name="optimizationLevel">Optimization level to use.</param>
        /// <returns>This builder.</returns>
        public BlueprintCompilationBuilder UseOptimizationLevel(OptimizationLevel optimizationLevel)
        {
            this._blueprintApiBuilder.Options.GenerationRules.OptimizationLevel = optimizationLevel;

            return this;
        }

        /// <summary>
        /// Sets the name of the assembly that is generated when compiling the executor pipelines.
        /// </summary>
        /// <param name="assemblyName">The name of the assembly to use.</param>
        /// <returns>This builder</returns>
        public BlueprintCompilationBuilder AssemblyName(string assemblyName)
        {
            Guard.NotNullOrEmpty(nameof(assemblyName), assemblyName);

            this._blueprintApiBuilder.Options.GenerationRules.AssemblyName = assemblyName;

            return this;
        }

        /// <summary>
        /// Customise the <see cref="GenerationRules" /> further, rules that are used when
        /// compiling the pipelines.
        /// </summary>
        /// <param name="editor">The action to run with the <see cref="GenerationRules"/> to modify.</param>
        /// <returns>This builder</returns>
        public BlueprintCompilationBuilder ConfigureRules(Action<GenerationRules> editor)
        {
            editor(this._blueprintApiBuilder.Options.GenerationRules);

            return this;
        }

        /// <summary>
        /// Adds a new <see cref="IVariableSource" /> for use in compilation of the pipelines.
        /// </summary>
        /// <param name="variableSource">The variable source to add.</param>
        /// <returns>This compilation builder.</returns>
        public BlueprintCompilationBuilder AddVariableSource(IVariableSource variableSource)
        {
            Guard.NotNull(nameof(variableSource), variableSource);

            this._blueprintApiBuilder.Options.GenerationRules.VariableSources.Add(variableSource);

            return this;
        }

using System.Collections.Generic;
using Blueprint.Compiler;
using Microsoft.CodeAnalysis;

namespace Blueprint.Configuration
{
    /// <summary>
    /// Serves as the central configuration point for the Blueprint API, providing the options for
    /// configuring behaviour as well as creating an <see cref="ApiDataModel" /> that represents the operations
    /// that can be executed.
    /// </summary>
    public class BlueprintApiOptions
    {
        /// <summary>
        /// Initialises a new instance of the <see cref="BlueprintApiOptions" /> class.
        /// </summary>
        public BlueprintApiOptions()
        {
            this.GenerationRules = new GenerationRules
            {
                OptimizationLevel = OptimizationLevel.Release,
            };
        }

        /// <summary>
        /// The data model that describes the structure of the API.
        /// </summary>
        public ApiDataModel Model { get; } = new ApiDataModel();

        /// <summary>
        /// The <see cref="Compiler.GenerationRules" /> that are used when compiling the pipelines of this API.
        /// </summary>
        public GenerationRules GenerationRules { get; }

        /// <summary>
        /// Gets the list of middleware builder that will be used by the pipeline generation, added in the
        /// order that they will be configured.
        /// </summary>
        public List<IMiddlewareBuilder> MiddlewareBuilders { get; } = new List<IMiddlewareBuilder>();

        /// <summary>
        /// Gets the name of the application, which is used when generating the DLL for the pipeline
        /// executors.
        /// </summary>
        public string ApplicationName { get; set; }
    }
}


			public void UpdateRules()
			{
				switch (++_ruleIndex % MaxRuleIndex)
				{

					case 0:
						GenerateScope = false;
						GenerateException = false;
						break;
					case 1:
						GenerateScope = true;
						GenerateException = false;
						break;
					case 2:
						GenerateScope = false;
						GenerateException = true;
						break;
					case 3:
						GenerateScope = true;
						GenerateException = true;
						break;
				}
			}

			public void GenerateLogStatements(int totalStatements)
			{
				for (int i = 0; i < totalStatements; i++)
				{
					GenerateLogStatement(i);
				}
			}

			private void GenerateLogStatement(int index)
			{	
				LogLevel logLevel = _logLevels[index % _logLevels.Length];

				if (logLevel == LogLevel.None)
				{
					return;
				}

				_generationRules.TryGetValue(logLevel, out LogGenerationRules generationRules);
				_logActions.TryGetValue(logLevel, out Action<string, Exception> action);

				Exception exception = GenerateException(index, generationRules);
				IDisposable scope = GenerateLogScope(index, generationRules);

				if (logLevel >= _logLevelFilter)
				{
					ExpectedStatements++;
				}

				action?.Invoke($"statement {index}", exception);
				generationRules?.UpdateRules();
				scope?.Dispose();
			}

			private Exception? GenerateException(int index, LogGenerationRules logGenerationRules)
			{
				if (!logGenerationRules.GenerateException)
				{
					return null;
				}

				try
				{
					throw new Exception($"exception for statement {index}");
				}
				catch (Exception ex)
				{
					return ex;
				}
			}

			private IDisposable? GenerateLogScope(int index, LogGenerationRules logGenerationRules) 
			{
				if (!logGenerationRules.GenerateScope)
				{
					return null;
				}

				if (LogLiteConfiguration.EnableScopeMessages && LogLiteConfiguration.ScopeMessageLogLevel >= _logLevelFilter)
				{
					ExpectedStatements += 2;
				}

				return _logger.BeginScope($"scope for statement {index}");
			}

		[AssemblyInitialize]
		public static void AssemblyInitialize(TestContext context)
		{
			_debugOutputSink = new DebugOutputSink();

			LogLiteConfiguration.EnableScopeMessages = true;
			LogLiteConfiguration.SetScopeMessageLogLevel(LogLevel.Critical);
			LogLiteConfiguration.AddSink(_debugOutputSink);
		}


    public void SetUp()
    {
        foreach(ModuleRule rule in moduleRules)
        {
            if(rule.bannedCodes.Length != 0)
            {
                rule.bannedCodesArray = rule.bannedCodes.Split(',');
            }
            else
            {
                rule.bannedCodesArray = new string[0];
            }
        }
    }

using System.Collections.Generic;
using System.Reflection;
using BlueMilk.Codegen.Variables;
using Microsoft.Extensions.DependencyInjection;

namespace BlueMilk.Codegen
{
    public class GenerationRules
    {
        public GenerationRules(string applicationNamespace)
        {
            ApplicationNamespace = applicationNamespace;
        }

        public string ApplicationNamespace { get; }

        public readonly IList<IVariableSource> Sources = new List<IVariableSource>();

        public readonly IList<Assembly> Assemblies = new List<Assembly>();
    }


}

LamarCodeGeneration.GenerationRules : Object

Fields :

public IList<IVariableSource> Sources
public IList<Assembly> Assemblies
public IDictionary<String, Object> Properties

Constructors :

public GenerationRules(String applicationNamespace = )
public GenerationRules()

Methods :

public String get_ApplicationNamespace()
public Void set_ApplicationNamespace(String value = )
public TypeLoadMode get_TypeLoadMode()
public Void set_TypeLoadMode(TypeLoadMode value = )
public String get_GeneratedCodeOutputPath()
public Void set_GeneratedCodeOutputPath(String value = )
public Assembly get_ApplicationAssembly()
public Void set_ApplicationAssembly(Assembly value = )
public Type GetType()
public String ToString()
public Boolean Equals(Object obj = )
public Int32 GetHashCode()