Esempio n. 1
0
 public void LoadInfo()
 {
     _genParams  = mProject.GenerationParams.Clone();
     _projParams = mProject.Params.Clone();
     generationParametersBindingSource.DataSource = _genParams;
     projectParametersBindingSource.DataSource    = _projParams;
 }
Esempio n. 2
0
        private void GenerateAllSprocsFile(CslaObjectInfo info, string dir, GenerationParameters generationParams)
        {
            var selfLoad = CslaTemplateHelper.GetSelfLoad(info);

            StringBuilder proc = new StringBuilder();

            //make sure we don't generate selects when we don't need to.
            if (!((info.ObjectType == CslaObjectType.EditableChildCollection ||
                   info.ObjectType == CslaObjectType.EditableChild) && !selfLoad))
            {
                foreach (Criteria crit in info.CriteriaObjects)
                {
                    if (crit.GetOptions.Procedure && !String.IsNullOrEmpty(crit.GetOptions.ProcedureName))
                    {
                        proc.AppendLine(GenerateProcedure(info, crit, "SelectProcedure.cst",
                                                          crit.GetOptions.ProcedureName));
                    }
                }
            }

            if (info.ObjectType != CslaObjectType.ReadOnlyObject &&
                info.ObjectType != CslaObjectType.ReadOnlyCollection &&
                info.ObjectType != CslaObjectType.EditableRootCollection &&
                info.ObjectType != CslaObjectType.DynamicEditableRootCollection &&
                info.ObjectType != CslaObjectType.EditableChildCollection &&
                info.ObjectType != CslaObjectType.NameValueList)
            {
                //Insert
                if (info.InsertProcedureName != "")
                {
                    proc.AppendLine(GenerateProcedure(info, null, "InsertProcedure.cst", info.InsertProcedureName));
                }

                //update
                if (info.UpdateProcedureName != "")
                {
                    proc.AppendLine(GenerateProcedure(info, null, "UpdateProcedure.cst", info.UpdateProcedureName));
                }

                //delete
                foreach (Criteria crit in info.CriteriaObjects)
                {
                    if (crit.DeleteOptions.Procedure && !String.IsNullOrEmpty(crit.DeleteOptions.ProcedureName))
                    {
                        proc.AppendLine(GenerateProcedure(info, crit, "DeleteProcedure.cst", crit.DeleteOptions.ProcedureName));
                    }
                }
                if (_targetFramework != TargetFramework.CSLA40 && info.ObjectType == CslaObjectType.EditableChild)
                {
                    proc.AppendLine(GenerateProcedure(info, null, "DeleteProcedure.cst", info.DeleteProcedureName));
                }
            }
            if (proc.Length > 0)
            {
                CheckDirectory(dir + @"\sprocs");
                WriteToFile(dir + @"\sprocs\" + info.ObjectName + ".sql", proc.ToString());
            }
        }
Esempio n. 3
0
        internal void LoadInfo()
        {
            _genParams  = project.GenerationParams.Clone();
            _projParams = project.Params.Clone();
            generationParametersBindingSource.DataSource = _genParams;
            projectParametersBindingSource.DataSource    = _projParams;

            NotYetImplemented();
        }
Esempio n. 4
0
        internal static void SetDefaultDbProvider(GenerationParameters generationParams)
        {
            GenerationDbProvider = null;
            DbProvider           = null;

            if (!generationParams.UseDal)
            {
                SetCurrentDbProvider(
                    GeneratorController.Current.CurrentUnit.GenerationParams.GenerationDbProviderCollection.GetActive());
            }
        }
    // Only to be called by user in editor
    // As not much though has been placed in here
    private void RegenerateMap()
    {
        oldParameters = GetParameters();
        MapGenerator generator = new MapGenerator(oldParameters);

        MapGenerationProgress.InstantiateNew(generator);
        generationTask = Task.Run(() =>
        {
            GridMap.Instance.GenerateMap(generator);
            RegenerateMeshes();
        });
    }
Esempio n. 6
0
        void LoadInfo()
        {
            GenerationParameters p = _unit.GenerationParams;

            cboTarget.SelectedItem              = p.TargetFramework.ToString();
            chkActiveObjects.Checked            = p.ActiveObjects;
            chkBackUpOldSource.Checked          = p.BackupOldSource;
            chkGenerateStoredProcedures.Checked = p.GenerateSprocs;
            chkSpOneFile.Checked           = p.OneSpFilePerObject;
            chkSeparateBaseClasses.Checked = p.SeparateBaseClasses;
            chkSeparateNamespaces.Checked  = p.SeparateNamespaces;
            chkUseDotDesignerFileNameConvention.Checked = p.UseDotDesignerFileNameConvention;
        }
Esempio n. 7
0
        void SaveInfo()
        {
            GenerationParameters p = _unit.GenerationParams;

            p.TargetFramework     = (TargetFramework)Enum.Parse(typeof(TargetFramework), (string)cboTarget.SelectedItem);
            p.ActiveObjects       = chkActiveObjects.Checked;
            p.BackupOldSource     = chkBackUpOldSource.Checked;
            p.GenerateSprocs      = chkGenerateStoredProcedures.Checked;
            p.OneSpFilePerObject  = chkSpOneFile.Checked;
            p.SeparateBaseClasses = chkSeparateBaseClasses.Checked;
            p.SeparateNamespaces  = chkSeparateNamespaces.Checked;
            p.UseDotDesignerFileNameConvention = chkUseDotDesignerFileNameConvention.Checked;
        }
        /// <summary>
        /// generates an infinite sequence of generated values
        /// </summary>
        /// <param name="gen">generator</param>
        /// <typeparam name="T">generator element type</typeparam>
        /// <returns>an infinite sequence of generates values of type T</returns>
        public static IEnumerable <T> Enumerate <T>(this Gen <T> gen, GenerationParameters env)
        {
            var seed = env.InitialSeed;

            while (true)
            {
                if (gen(seed, out var result))
                {
                    yield return(result.Value);

                    seed = result.Next;
                }
            }
        }
Esempio n. 9
0
        static void Main(string[] args)
        {
            var parameters = new GenerationParameters {
                Size = 9, WaterDensity = FillerDensity.Medium, MountainsDensity = FillerDensity.Low
            };
            var worldGen = new WorldGenerator.WorldGen(parameters);
            var world    = worldGen.GenerateWorld();

            var printer = new WorldPrinter();

            printer.PrintWorld(world);

            Console.ReadKey();
        }
Esempio n. 10
0
        public static void Demo2()
        {
            var options = new JsonSerializerOptions {
                WriteIndented = true
            };

            var env     = new GenerationParameters();
            var service = new Container(env, 10, 10, 3);

            foreach (var order in service.Orders)
            {
                Console.WriteLine("{0}", JsonSerializer.Serialize(order, options));
            }
        }
    void Update()
    {
        switch (state)
        {
        case State.Created:
            state = State.GeneratingMap;
            logger.Log("generating new map");

            GenerationParameters parameters = GetParameters();
            MapGenerator         generator  = new MapGenerator(parameters);
            MapGenerationProgress.InstantiateNew(generator);
            oldParameters  = parameters;
            generationTask = Task.Run(() => GridMap.Instance.GenerateMap(generator));
            break;

        case State.GeneratingMap:
        case State.LoadingMap:
            if (GridMap.Instance.IsGenerationDone())
            {
                logger.Log("Map finished generation");
                state = State.MapGenerated;
            }
            break;

        case State.MapGenerated:
            logger.Log("Creating meshGenerators");
            BlockMeshes.LoadMeshes();
            createMeshCreators();
            UpdateMaxVerticalLevel();
            RegenerateMeshes();
            state          = State.MeshGeneratorsCreated;
            cameraObserver = new SimpleObserver <CameraController>(mainCam, (cam) =>
            {
                UpdateMaxVerticalLevel();
                RegenerateMeshes();
            });

            break;

        case State.MeshGeneratorsCreated:
            break;
        }
        if (!oldParameters.Equals(GetParameters()) && generationTask != null && !generationTask.Status.Equals(TaskStatus.Running))
        {
            regenerateMap = false;
            RegenerateMap();
        }
    }
Esempio n. 12
0
        public static void Demo1()
        {
            var gen =
                from i in String(6, HexDigit())
                from f in Choose("Abe", "Joe", "Bea", "Ben", "Bob", "Sue", "Sky", "Roy", "Ted")
                from l in Choose("Smith", "Miller", "Meyer", "Tailor", "Fisher", "Potter", "Carter", "Cooper")
                from y in Range(1960, 2010)
                select new Person(i, f, l, y);

            var env = new GenerationParameters();

            foreach (var person in gen.Enumerate(env).Take(12).OrderBy(p => p.lastName))
            {
                Console.WriteLine("{0}", person);
            }
        }
Esempio n. 13
0
        private bool TryGenerateNewCodes(GenerationParameters requestData)
        {
            var generationSucceeded = _codeGenerator.TryAddNewUniqueCodes(_codes, requestData.CodeLength, requestData.NumberOfCodesToGenerate, out var newCodes);

            if (!generationSucceeded)
            {
                return(false);
            }

            if (SaveCodesToStorage())
            {
                return(true);
            }

            // Rollback if save to storage failed.
            _codes.RemoveRange(newCodes);
            return(false);
        }
        public PrototypeDungeonGenerator(AbstractDungeonStructure structure, int seed, GenerationParameters generationParameters = null)
        {
            _seed   = seed;
            _random = new Random(seed);
            _generationParameters = generationParameters;
            _loadedStructure      = DungeonStructureConcretizer.ConcretizeStructure(structure, _random);
            _loadedRooms          = RoomResourceLoader.LoadRoomPrototypes(_loadedStructure);
            _marginHalf           = structure.StructureMetaData.MarginUnit / 2f;
            CollectMetaData(_loadedStructure);

            if (_generationParameters != null)
            {
                ParameterizeDungeon();
            }

            if (_stepBackCounter == null)
            {
                _stepBackCounter = new StepBackCounter(DefaultMaxSteps);
            }
        }
Esempio n. 15
0
            public Container(GenerationParameters env, int productCount, int userCount, int orderCount)
            {
                // generator for Product
                var products =
                    from key in String(6, HexDigit())
                    from nam in Word
                    from des in Sentence
                    select new Product(key, nam, des);

                // generator for Person
                var users =
                    from id in Concat(Const("U-"), String(4, HexDigit()))
                    from fi in Choose("Abe", "Joe", "Bea", "Ben", "Bob", "Sue", "Sky", "Roy", "Ted")
                    from la in Choose("Smith", "Miller", "Meyer", "Tailor", "Fisher", "Potter", "Carter", "Cooper")
                    from ye in Range(1960, 2010)
                    select new Person(id, fi, la, ye);

                // generator for LineItem dependent on a products generator
                var items = Link(products, (products) =>
                                 from k in Concat(Const("I-"), String(4, HexDigit()))
                                 from a in Range(1, 10)
                                 from p in Choose(products)
                                 select new LineItem(k, a, p)
                                 );

                // generator for Orders
                var orders = Link(users, products, (users, products) =>
                                  from k in Concat(Const("O-"), String(4, HexDigit()))
                                  from p in Choose(users)
                                  from n in Range(new DateTime(2015, 1, 1), DateTime.Today)
                                  from i in items(products).List(3, 7)
                                  select new Order(k, p, n, i)
                                  );

                Products = products.Enumerate(env).Take(productCount).ToList();
                Users    = users.Enumerate(env).Take(userCount).ToList();
                Orders   = orders(Users, Products).Enumerate(env).Take(orderCount).ToList();
            }
 public ActionResult AuthUser([FromBody] GenerationParameters parameters)
 {
     // todo: put here you generator request
     return(Ok());
 }
Esempio n. 17
0
 public MapGenerator(GenerationParameters parameters)
 {
     this.parameters = parameters;
 }
    public void GenerateMap(GenerationParameters parameters)
    {
        if (parameters == null)
        {
            throw new System.ArgumentNullException();
        }

        // Generate grid
        grid.Clear();
        gridItemObject.SetActive(true);
        /*** Sublevels ***/
        // Rescale object if required
        if (parameters.columns > (width - 2 * itemWidth) / itemWidth)
        {
            // Get scale factor
            float percentage = width / ((parameters.columns + 2) * itemWidth);
            // Scale width accordingly
            Vector3 scale = gridItemObject.transform.localScale;
            scale.x   *= percentage;
            itemWidth *= percentage;
            gridItemObject.transform.localScale = scale;
        }
        if (parameters.lines > height / itemHeight)
        {
            // Get scale factor
            float percentage = height / (parameters.lines * itemHeight);
            // Scale width accordingly
            Vector3 scale = gridItemObject.transform.localScale;
            scale.y    *= percentage;
            itemHeight *= percentage;
            gridItemObject.transform.localScale = scale;
        }

        /*** Start area ***/
        if (parameters.startArea != null)
        {
            GameObject createdObject = Instantiate(gridItemObject, gridmapObject.transform);
            grid.Add(new GridLevelObject()
            {
                sublevel    = parameters.startArea,
                isStartArea = true,
                itemObject  = createdObject.GetComponent <LevelMapSystem>(),
            });
            createdObject.transform.localPosition = new Vector2(itemWidth / 2, 0);
        }

        Vector2 offset  = new Vector2(itemWidth + itemWidth / 2, (itemHeight / 2f) * (parameters.lines - 1));
        Vector2 pos     = Vector2.zero;
        Vector2 bossPos = new Vector2(width - itemWidth / 2, 0);

        for (int i = 0; i < parameters.lines; i++)
        {
            for (int j = 0; j < parameters.columns; j++)
            {
                int k = parameters.columns * i + j;
                // If max reached, exit
                if (k >= parameters.levelsToGenerate)
                {
                    i = parameters.lines;
                    j = parameters.columns;
                    continue;
                }

                GameObject createdObject = Instantiate(gridItemObject, gridmapObject.transform);

                grid.Add(new GridLevelObject()
                {
                    sublevel    = parameters.sublevels[k],
                    lineIndex   = i,
                    columnIndex = j,
                    itemObject  = createdObject.GetComponent <LevelMapSystem>(),
                });
                createdObject.transform.localPosition = offset + pos;

                pos.x += itemWidth;
            }
            if (i == 0)
            {
                bossPos = new Vector2(itemWidth * 1.5f + pos.x, 0);
            }
            pos.x  = 0;
            pos.y -= itemHeight;
        }

        /*** Boss area ***/
        if (parameters.bossArea != null)
        {
            GameObject createdObject = Instantiate(gridItemObject, gridmapObject.transform);
            grid.Add(new GridLevelObject()
            {
                sublevel   = parameters.bossArea,
                isBossArea = true,
                itemObject = createdObject.GetComponent <LevelMapSystem>(),
            });
            createdObject.transform.localPosition = bossPos;
        }
        gridItemObject.SetActive(false);

        // Add OnPlayerEnter events
        foreach (GridLevelObject item in grid)
        {
            item.itemObject.SetVisible(false);
            item.itemObject.SetSeen(false);
            item.itemObject.SetText(item.sublevel.GetComponent <LevelSystem>().sublevelType);
            LevelSystem levelSystem = item.sublevel.GetComponent <LevelSystem>();
            levelSystem.OnPlayerEnter += LevelMapGenerator_OnPlayerEnter;
            levelSystem.OnPlayerExit  += LevelSystem_OnPlayerExit;
        }
    }