static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); // Initialize Data ISeedStore seedStore = null; if (Properties.Settings.Default.UseDatabaseStore) { if (!TestConnection(Properties.Settings.Default.SeedStoreConnectionString)) { MessageBox.Show($"Failed to connect to database. Using in-memory cache instead. Seed results won't be saved if you close the program: \n\n{Properties.Settings.Default.SeedStoreConnectionString}", "Database Error", MessageBoxButtons.OK, MessageBoxIcon.Error); seedStore = new SeedMemoryStore(); } else { seedStore = new SeedDatabaseStore(Properties.Settings.Default.SeedStoreConnectionString); } } else { seedStore = new SeedMemoryStore(); } var seedManager = new SeedManager(seedStore); Application.Run(new RustCrossbreederForm(seedManager)); }
public static void Main(string[] args) { Console.WriteLine("START"); try { var arguments = new Arguments().Parse(args); Console.WriteLine("Datasource: {0}", arguments.Datasource); Console.WriteLine("Catalog: {0}", arguments.Catalog); if (arguments.ForceReseeding) { Console.WriteLine("Forcing the reseeding of the system accounts"); } using (var dbContext = new DatabaseContextFactory().Create(arguments.Datasource, arguments.Catalog)) { Console.WriteLine("Seeding the database with data..."); var seedManager = new SeedManager(dbContext, arguments.ForceReseeding); seedManager.Seed(); } Console.WriteLine("Database seeded."); } catch (Exception e) { Console.WriteLine(e.ToDetail()); } finally { Console.WriteLine("END"); } }
public static async Task <IHost> MigrateDataBaseAsync(this IHost host) { using (var scope = host.Services.CreateScope()) { var services = scope.ServiceProvider; try { var dbContext = services.GetRequiredService <StoreContext>(); await dbContext.Database.MigrateAsync(); await SeedManager.SeedDataBaseAsync(dbContext, services.GetRequiredService <ILogger <SeedManager> >()); var userDbContext = services.GetRequiredService <AppUserDbContext>(); await userDbContext.Database.MigrateAsync(); await AppUserDbContextSeed.SeedUserDataAsync(services.GetRequiredService <UserManager <AppUser> >()); } catch (Exception ex) { var logger = services.GetRequiredService <ILogger <Program> >(); logger.LogError(ex, "An error occured while applying migrations"); } } return(host); }
public void InstallConfigure(IApplicationBuilder app) { var context = app.ApplicationServices.GetService <YeditepeContext>(); context.Database.Migrate(); SeedManager.SeedData(context); }
/// <summary> /// Create a new Form /// </summary> public RustCrossbreederForm(SeedManager seedManager) { InitializeComponent(); // Set DataGridViews to DoubleBuffer to reduce redraw lag this.dgvInputSeeds.DoubleBuffered(true); this.dgvOutputSeeds.DoubleBuffered(true); this.dgvCrossbreedInput.DoubleBuffered(true); // Configure DataGridView column sorting dgvInputSeeds.AutoGenerateColumns = false; dgvOutputSeeds.AutoGenerateColumns = false; dgvCrossbreedInput.AutoGenerateColumns = false; // Hook SeedManager events this._seedManager = seedManager; this._seedManager.ActiveCatalogUpdated += HandleActiveCatalogUpdated; this._seedManager.ActiveSeedTypeUpdated += HandleActiveSeedTypeUpdated; this._seedManager.AutoCrossBreedCompleted += HandleAutoCrossBreedCompleted; this._seedManager.DisplayError += HandleDisplayError; this._seedManager.CreateCatalog(cmbCatalog.Text); // Set Combo box data sources this.cmbSeedType.DataSource = Enum.GetNames(typeof(Seed.SeedTypes)); this.cmbCatalog.DataSource = this._seedManager.GetCatalogs().ToList(); this.cmbCatalog.DisplayMember = nameof(KeyValuePair <int, string> .Value); // Set display member to the Category string name }
public static Particle Create(EParticles particleType, Vector3 location, Vector3 force) { Particle particle = EntityFactory.Create <Particle>(string.Format("{0}Particle", particleType.ToString())); particle.AddComponent <TransformComponent>().Init(location); PhysicsComponent physics = particle.AddComponent <PhysicsComponent>(); physics.Init(BodyType.Dynamic, 0.94f, 0.5f); physics.ApplyForce(force, true); SpriteComponent sprite = particle.AddComponent <SpriteComponent>(); LightingComponent light = particle.AddComponent <LightingComponent>(); DespawnComponent despawn = particle.AddComponent <DespawnComponent>(); switch (particleType) { case EParticles.Spark: float lifeTime = SeedManager.Get().NextRandF(2.0f, 5.0f); sprite.Init(CollisionManager.Get().PointTexture); sprite.Scale = new Vector2(SeedManager.Get().NextRandF(5, 15), SeedManager.Get().NextRandF(5, 15)); sprite.AddColorFunction(x => { return(Color.Lerp(new Color(0.99f, 1.0f, 0.78f), new Color(1.0f, 0.0f, 0.0f), x)); }); sprite.AddOpacityFunction(x => { return(1.0f - x / lifeTime); }); light.Init(AssetManager.Get().Find <Texture2D>(ELightAssets.CircleLight), Vector2.Zero, new Vector2(0.4f, 0.4f)); light.AddColorFunction(x => { return(Color.Lerp(new Color(0.99f, 1.0f, 0.78f), new Color(1.0f, 0.0f, 0.0f), x)); }); light.AddBrightnessFunction(x => { return(1.0f - x / lifeTime); }); despawn.AddTimeTrigger(x => x > lifeTime); break; } return(particle); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { app.UseExceptionHandler("/Home/Error"); app.UseHsts(); } app.UseHttpsRedirection(); app.UseStaticFiles(); app.UseAnalytics(); app.UseRouting(); app.UseAuthorization(); app.UseEndpoints(endpoints => { endpoints.MapControllerRoute( name: "default", pattern: "{controller=Home}/{action=Index}/{id?}"); }); ModelContext modelContext = new ModelContext(); modelContext.Database.EnsureCreated(); #if DEBUG SeedManager seedManager = new SeedManager(modelContext); seedManager.Execute(); #endif }
public static ApplicationContext Create(bool performSeed = true) { var context = new ApplicationContext(); SeedManager.Initialize(context); return(context); }
public void SetupSeedFilters() { // Set up the score filter. // TODO: Better way of doing this. SeedGeneration tomatoSeeds = SeedManager.GetLatestGenerationOfCropType("Tomato"); tomatoSeeds.ScoreFilter.Add("DistanceFromGoal", -1); tomatoSeeds.ScoreFilter.Add("AliveTime", 0.5f); tomatoSeeds.ScoreFilter.Add("MaxConcurrentSeenCreatures", 0.1f); tomatoSeeds.ScoreFilter.Add("EnemyDamageDealt", 1.5f); tomatoSeeds.ScoreFilter.Add("EnemyKills", 2); SeedGeneration asparagusSeeds = SeedManager.GetLatestGenerationOfCropType("Asparagus"); asparagusSeeds.ScoreFilter.Add("DistanceFromGoal", -1); asparagusSeeds.ScoreFilter.Add("AliveTime", 2f); asparagusSeeds.ScoreFilter.Add("MaxConcurrentSeenCreatures", 0.1f); asparagusSeeds.ScoreFilter.Add("EnemyDamageDealt", 1.5f); asparagusSeeds.ScoreFilter.Add("FriendlyDamageDealt", -2f); asparagusSeeds.ScoreFilter.Add("EnemyKills", 2); asparagusSeeds.ScoreFilter.Add("FriendlyKills", -3); asparagusSeeds.ScoreFilter.Add("ClosestHit", -4.5f); asparagusSeeds.ScoreFilter.Add("BestAngle", 3); asparagusSeeds.ScoreFilter.Add("OffMap", -1.5f); }
//--------------------------------------------------------------------------- public ItemPool(EItemPool type) { Type = type; Types = new Dictionary <EItemType, float>(); m_Rand = new Random(SeedManager.Get().NextSeed()); }
private void Awake() { _grid = transform.GetChild(0); // init singleton SeedManager with system time SeedManager.Init((int)DateTime.Now.Ticks); }
public void Awake() { if (instance == null) { instance = this; } else if (instance != this) { Destroy(gameObject); } }
//--------------------------------------------------------------------------- public void Spawn(EItemType item) { TransformComponent transform = GetComponent <TransformComponent>(); if (transform != null) { float rot = (SeedManager.Get().NextRandF() * (float)Math.PI * 2.0f); float dist = (SeedManager.Get().NextRandF() * 120.0f + 400.0f); Vector3 force = new Vector3((float)Math.Sin(rot) * dist, (float)Math.Cos(rot) * dist, SeedManager.Get().NextRandF(20, 40)); PickupFactory.Create(item, transform.Location, force); } }
private void plantCrops() { for (int x = 0; x < WorldMap.Width; x++) { if (cropTilemap.IsTileEmpty(x, tomatoZ)) { cropTilemap.PlantSeed(x, tomatoZ, SeedManager.GetLatestGenerationOfCropType("Tomato").GetBestSeed()); } if (cropTilemap.IsTileEmpty(x, asparagusZ)) { cropTilemap.PlantSeed(x, asparagusZ, SeedManager.GetLatestGenerationOfCropType("Asparagus").GetBestSeed()); } } }
public static void RegisterPersistence(this IServiceCollection services, string connectionString) { services.AddSingleton <IDataBaseServiceOptions>(provider => new DataBaseServiceOptions() { ConnectionString = connectionString, Provider = services.BuildServiceProvider() }); services.AddDbContext <DatabaseService>(); services.AddScoped <IDatabaseService, DatabaseService>(); services.AddTransient <SeedManager, SeedManager>(); services.AddScoped(typeof(IRepository <>), typeof(Repository <>)); // ======================================Seed Management========================== SeedManager seedManager = services.BuildServiceProvider().GetService <SeedManager>(); seedManager.Seed(); }
private static void SeedDatabase(IHost host) { using var scope = host.Services.CreateScope(); var services = scope.ServiceProvider; try { var hashService = services.GetRequiredService <IHashService>(); var context = services.GetRequiredService <EFContext>(); var seedManager = new SeedManager(context, hashService); seedManager.SeedDatabaseAsync().GetAwaiter().GetResult(); } catch (Exception exception) { Log.Fatal(exception, "An error occurred while seeding the database."); } }
private void SetVariables() { blocksDatabase = blockDB.database; biomesDatabase = biomeDB.database; xBound = xChunkSize * chunkCountX; yBound = yChunkSize * chunkCountY; if (useSeed) { SeedManager.setSeed(seed); } else { SeedManager.setSeed(); } rng = SeedManager.rng; biomeGenerator = new BiomeGenerator(xBound, yBound, rng, xSamples, ySamples, tranzitionTreshhold); }
//--------------------------------------------------------------------------- public byte[,] CreateMap(int size = 1) { byte[,] map = new byte[Bounds.Width / size, Bounds.Height / size]; for (int x = 0; x < Bounds.Width / size; x++) { for (int y = 0; y < Bounds.Height / size; y++) { map[x, y] = SeedManager.Get().NextRand(0, 2) == 0 ? (byte)0 : (byte)2; } } foreach (Room room in Rooms) { for (int x = room.Bounds.X; x < room.Bounds.X + room.Bounds.Width; x++) { for (int y = room.Bounds.Y; y < room.Bounds.Y + room.Bounds.Height; y++) { map[x / size, y / size] = 255; } } } foreach (Corridor corridor in Corridors) { foreach (CorridorSegment segment in corridor.Segments) { int thickness = (segment.Thickness - 1) / 2; for (int x = Math.Min(segment.Start.X, segment.End.X) - thickness; x <= Math.Max(segment.Start.X, segment.End.X) + thickness; x++) { for (int y = Math.Min(segment.Start.Y, segment.End.Y) - thickness; y <= Math.Max(segment.Start.Y, segment.End.Y) + thickness; y++) { if (x >= 0 && x < map.GetLength(0) && y >= 0 && y < map.GetLength(1)) { map[x, y] = 255; } } } } } return(map); }
// Update is called once per frame void Update() { timeCounter += Time.deltaTime; if (timeCounter >= 2.5) { Destroy(gameObject); } else if (timeCounter >= 1.3) { if (done == false) { SeedManager newSeed = Instantiate(seed, transform.position + new Vector3(0, 0.7f, 0), Quaternion.identity); newSeed.setTarget(target); done = true; } } else if (timeCounter >= 0.6) { animator.SetBool("hasSpawn", true); } }
//--------------------------------------------------------------------------- public SpawnerComponent(Guid entity) : base(entity) { m_Rand = new Random(SeedManager.Get().NextSeed()); }
public int[,] GenerateBiomsFromRarity(Biome[] toSpawn) { resetMap(); this.biomeAvailability = new bool[xSamples, ySamples]; int raritySum = 0; foreach (Biome n in toSpawn) { raritySum += n.rarity; //Debug.Log(n.biomaName+ " rarity: "+ n.rarity); } float biomeParcel = (float)(xSamples * ySamples) / raritySum; int[] biomeCount = new int[toSpawn.Length]; int highestRarity = 0; int highestRarityI = 0; int sumOfReservedChunks = 0; for (int i = 0; i < biomeCount.Length; i++) { if (toSpawn[i].rarity > highestRarity) { highestRarity = toSpawn[i].rarity; highestRarityI = i; } biomeCount[i] = (int)(toSpawn[i].rarity * biomeParcel); sumOfReservedChunks += biomeCount[i]; } biomeCount[highestRarityI] += ((xSamples * ySamples) - sumOfReservedChunks); //mozna by zrobic ranodomowo to List <int> biomeSpawnOrder = new List <int>(); for (int i = 0; i < biomeCount.Length; i++) { for (int j = 0; j < biomeCount[i]; j++) { biomeSpawnOrder.Add(toSpawn[i].ID); } } SeedManager.Shuffle <int>(biomeSpawnOrder); //string s = ""; //foreach (int t in biomeSpawnOrder) // s += t.ToString(); //Debug.Log(s); int[,] biomeCenterMap = ListToBiomeCenters(biomeSpawnOrder); int xSampleSizeInBlocks = xBound / xSamples; int ySampleSizeInBlocks = yBound / ySamples; Vector2Int[,] centers = new Vector2Int[xSamples, ySamples]; Vector2Int randomizedPos; for (int y = 0; y < ySamples; y++) { for (int x = 0; x < xSamples; x++) { randomizedPos = new Vector2Int( rng.Next(x * xSampleSizeInBlocks, x * xSampleSizeInBlocks + xSampleSizeInBlocks), rng.Next(y * ySampleSizeInBlocks, y * ySampleSizeInBlocks + ySampleSizeInBlocks)); centers[x, y] = randomizedPos; //GameObject o = new GameObject(); //o.transform.position = new Vector3(randomizedPos.x, randomizedPos.y, 0); //o.transform.name = biomeCenterMap[x, y].ToString(); } } MapToVoronoiDiagram(centers, biomeCenterMap); //GenerateOneBiome(); return(biomeMap); }
//--------------------------------------------------------------------------- protected override void Initialize() { base.Initialize(); Window.AllowUserResizing = true; GameWindowSettings.SetWindowSettings(graphics, Window, 1680, 1050); oldKeyboardState = Keyboard.GetState(); int width = GraphicsDevice.PresentationParameters.BackBufferWidth; int height = GraphicsDevice.PresentationParameters.BackBufferHeight; GraphicsDevice.SamplerStates[0] = SamplerState.PointClamp; LightingManager.Get().Device = GraphicsDevice; SeedManager.Get().ResetBaseSeed(1234); /*-------------------------------------------------------------------------- * Items * --------------------------------------------------------------------------*/ ItemManager.Get().LoadItems(); ItemManager.Get().LoadItemPools(); /*-------------------------------------------------------------------------- * Stage * --------------------------------------------------------------------------*/ Stage stage = new Stage(SeedManager.Get().NextSeed()); StageManager.Get().Create(stage.CreateMap()); StageManager.Get().Stage = stage; foreach (Room room in stage.Rooms) { int max = SeedManager.Get().NextSeed(3, 7); for (int i = 0; i < max; i++) { Vector2 position = new Vector2(room.Bounds.Center.X * 64 + (float)Math.Sin((i / (max / 2.0f)) * Math.PI) * 360, room.Bounds.Center.Y * 64 + (float)Math.Cos((i / (max / 2.0f)) * Math.PI) * 360); EntityFactory.Create <Chest>("Chest").Init(position); } EntityFactory.Create <SimpleTestEnemy>("Enemy").Init(new Vector2(room.Bounds.Center.X * 64, room.Bounds.Center.Y * 64)); for (int x = 0; x < room.Bounds.Width; x += 3) { IEntity torch = EntityFactory.Create <Entity>("Torch"); torch.AddComponent <TransformComponent>().Init(new Vector3(room.Bounds.X * 64 + x * 64 + 32, room.Bounds.Y * 64 + 32, 110)); torch.AddComponent <ParticleSpawnerComponent>().Emitter.Description = ParticleDesc.Fire; torch.AddComponent <LightingComponent>().Init(AssetManager.Get().Find <Texture2D>(ELightAssets.CircleLight), new Vector2(0, 6), new Vector2(1, 1), Color.Orange, 0.6f); } } stage.SaveStageAsImage(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "Map.png")); /*-------------------------------------------------------------------------- * Player 1 * --------------------------------------------------------------------------*/ Player player = EntityFactory.Create <Player>("Player1"); /*-------------------------------------------------------------------------- * Player 2 * --------------------------------------------------------------------------*/ Player player2 = EntityFactory.Create <Player>("Player2"); /*-------------------------------------------------------------------------- * Camera * --------------------------------------------------------------------------*/ CameraManager.Get().Init(width, height); Camera cam1 = EntityFactory.Create <Camera>("Cam1"); cam1.Properties.Init(GraphicsDevice, width / 2, height, AssetManager.Get().Find <Texture2D>(ESpriteAssets.CameraBackground1), AssetManager.Get().Find <Effect>(EEffectAssets.DeferredLighting)); cam1.Properties.Viewport = new Rectangle(0, 0, width / 2, height); cam1.Properties.BloomExtractEffect = AssetManager.Get().Find <Effect>(EEffectAssets.BloomExtract); cam1.Properties.BloomCombineEffect = AssetManager.Get().Find <Effect>(EEffectAssets.BloomCombine); cam1.Properties.BlurEffect = AssetManager.Get().Find <Effect>(EEffectAssets.Blur); cam1.Properties.Tileset = AssetManager.Get().Find <Texture2D>(ETilesetAssets.DungeonTileset2); cam1.Properties.AddTarget(player); //cam1.Properties.IsAmbientOcclusionEnabled = true; Camera cam2 = EntityFactory.Create <Camera>("Cam2"); cam2.Properties.Init(GraphicsDevice, width / 2, height, AssetManager.Get().Find <Texture2D>(ESpriteAssets.CameraBackground1), AssetManager.Get().Find <Effect>(EEffectAssets.DeferredLighting)); cam2.Properties.Viewport = new Rectangle(width / 2, 0, width / 2, height); cam2.Properties.BloomExtractEffect = AssetManager.Get().Find <Effect>(EEffectAssets.BloomExtract); cam2.Properties.BloomCombineEffect = AssetManager.Get().Find <Effect>(EEffectAssets.BloomCombine); cam2.Properties.BlurEffect = AssetManager.Get().Find <Effect>(EEffectAssets.Blur); cam2.Properties.Tileset = AssetManager.Get().Find <Texture2D>(ETilesetAssets.DungeonTileset2); cam2.Properties.AddTarget(player2); //cam2.Properties.IsAmbientOcclusionEnabled = true; CameraManager.Get().FuseCameras(cam1, cam2, width / 2); /*-------------------------------------------------------------------------- * UI * --------------------------------------------------------------------------*/ UIManager.Get().Init(GraphicsDevice, width, height); SpriteFont debug_font = AssetManager.Get().Find <SpriteFont>(EFontAssets.DebugFont); UIEntity healthbar1 = EntityFactory.CreateUI <UIEntity>("HealthbarPlayer1"); HealthbarComponent healthbarcomponent1 = healthbar1.AddComponent <HealthbarComponent>(); healthbar1.VerticalAlignment = EVerticalAlignment.Top; healthbar1.HorizontalAlignment = EHorizontalAlignment.Left; healthbar1.Margin = new Rectangle(15, 25, 0, 0); healthbarcomponent1.BindPlayer(player, EHorizontalAlignment.Left); UIEntity healthbar2 = EntityFactory.CreateUI <UIEntity>("HealthbarPlayer2"); HealthbarComponent healthbarcomponent2 = healthbar2.AddComponent <HealthbarComponent>(); healthbar2.VerticalAlignment = EVerticalAlignment.Top; healthbar2.HorizontalAlignment = EHorizontalAlignment.Right; healthbar2.Margin = new Rectangle(0, 25, 15, 0); healthbarcomponent2.BindPlayer(player2, EHorizontalAlignment.Right); UIEntity coins = EntityFactory.CreateUI <UIEntity>("CollectedCoins"); CoinCollectionComponent coincollectioncomponent = coins.AddComponent <CoinCollectionComponent>(); coins.VerticalAlignment = EVerticalAlignment.Top; coins.HorizontalAlignment = EHorizontalAlignment.Center; coins.Margin = new Rectangle(0, 25, 0, 0); coincollectioncomponent.Bind(player, player2); #if DEBUG ConsoleManager.Get().RegisterCommand("SpawnChestAtPosition", null, (Func <int, int, string>)Chest.SpawnChest); ConsoleManager.Get().RegisterCommand("SpawnChestAtCamera", null, (Func <int, string>)Chest.SpawnChest); ConsoleManager.Get().RegisterCommand("SpawnPickup", null, (Func <string, int, Pickup>)PickupFactory.Create); #endif }
public void BlankStateDatabase() { SampleVehicleRepository seedVehicles = new SampleVehicleRepository(); SampleSpecialRepository seedSpecials = new SampleSpecialRepository(); SamplePurchaseRepository seedPurchases = new SamplePurchaseRepository(); SampleContactRepository seedContact = new SampleContactRepository(); var mSeed = seedVehicles.GetMakes(); var nSeed = seedVehicles.GetModels(); var sSeed = seedSpecials.GetSpecials(); var pSeed = seedPurchases.GetAllPurchases(); var cSeed = seedContact.GetAll(); List <Vehicle> vSeed = new List <Vehicle>(); SeedManager sMgr = new SeedManager(); for (int i = 0; i < 500; i++) { var v = sMgr.PlantACar(nSeed.Max(n => n.NameplateId)); v.Model = nSeed.FirstOrDefault(n => n.NameplateId == v.NameplateId); vSeed.Add(v); } VehicleRepository vRepo = new VehicleRepository(); SpecialRepository sRepo = new SpecialRepository(); PurchaseRepository pRepo = new PurchaseRepository(); ContactRepository cRepo = new ContactRepository(); foreach (var m in mSeed) { vRepo.AddMake(m); } foreach (var n in nSeed) { n.ManufacturerId = n.Manufacturer.ManufacturerId; vRepo.AddModel(n); } foreach (var v in vSeed) { if (v.ImageFileName == null || v.ImageFileName.Length < 4) { switch (v.Model.BodyStyle) { case BodyStyle.Car: v.ImageFileName = "Car.png"; break; case BodyStyle.SUV: v.ImageFileName = "SUV.png"; break; case BodyStyle.Truck: v.ImageFileName = "Truck.png"; break; case BodyStyle.Van: v.ImageFileName = "Van.png"; break; default: throw new Exception("A vehicle's model's body style data was corrupt."); } } v.NameplateId = v.Model.NameplateId; vRepo.AddVehicle(v); } foreach (var s in sSeed) { sRepo.AddSpecial(s); } foreach (var p in pSeed) { pRepo.AddPurchase(p); } foreach (var c in cSeed) { cRepo.Add(c); } }
public static SeedManager Init(int seed) => _instance ?? (_instance = new SeedManager(seed));
private void Start() { _seedManager = GetComponent <SeedManager>(); _chickenManager = GetComponent <ChickenManager>(); timer = 0; }
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, SeedManager seedManager, MigrationManager migrationManager) { var stopwatch = Stopwatch.StartNew(); try { loggerFactory.AddSerilog(); Log.Logger().Information("Application is starting..."); Log.Logger().Information("Configuration:"); ConfigurationProvider.GetType().GetProperties().ToList().ForEach(prop => { Log.Logger().Information("[{name}] = '{value}'", prop.Name, prop.GetValue(ConfigurationProvider)); }); DateTimeContext.Initialize(ConfigurationProvider.TimeZone); Log.Logger().Information("Configure EF Mappings..."); MappingConfig.RegisterMappings(); if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); app.UseDatabaseErrorPage(); } else { app.UseExceptionHandler("/Home/Error"); //todo IS incorrect page diesnt exist yet!! app.UseHsts(); app.UseHttpsRedirection(); } app.UseStaticFiles(new StaticFileOptions { FileProvider = new PhysicalFileProvider(Path.Combine(Directory.GetCurrentDirectory(), @"wwwroot")) }); app.UseSession(); app.UseAuthentication(); app.UseMvc(routes => { routes.MapRoute(name: "Area", template: "{area:exists}/{controller=Home}/{action=Index}/{id?}"); routes.MapRoute(name: "Area2", template: "{area:exists}/{controller=Home}/{action=Index}/{isReadonly?}"); routes.MapRoute(name: "default", template: "{controller=Home}/{action=Index}/{id?}"); routes.MapRoute(name: "default2", template: "{controller=Home}/{action=Index}/{isReadonly?}"); }); //migrationManager.EnsureCreated(ConfigurationProvider); //migrationManager.ApplyMigrations(ConfigurationProvider); seedManager.Seed(ConfigurationProvider); } catch (Exception e) { Log.Logger().Error(e, "Application failed to start"); throw; } finally { stopwatch.Stop(); Log.Logger().Information("Startup time: {Seconds}s", stopwatch.Elapsed.Seconds); } }
// Use this for initialization void Start() { SM = GetComponent <SeedManager>(); }
/// <inheritdoc /> protected override void Load(ContainerBuilder builder) { var iotaRepository = new RestIotaRepository( new FallbackIotaClient(new List <string> { "https://nodes.devnet.thetangle.org:443" }, 5000), new PoWService(new CpuPearlDiver())); var channelFactory = new MamChannelFactory(CurlMamFactory.Default, CurlMerkleTreeFactory.Default, iotaRepository); var subscriptionFactory = new MamChannelSubscriptionFactory(iotaRepository, CurlMamParser.Default, CurlMask.Default); var encryption = new RijndaelEncryption("somenicekey", "somenicesalt"); var resourceTracker = new ResourceTracker( channelFactory, subscriptionFactory, encryption, $"{DependencyResolver.LocalStoragePath}\\resources.sqlite"); var seedManager = new SeedManager( resourceTracker, new IssSigningHelper(new Curl(), new Curl(), new Curl()), new AddressGenerator(), iotaRepository, encryption, $"{DependencyResolver.LocalStoragePath}\\seedmanager.sqlite"); var fhirRepository = new IotaFhirRepository(iotaRepository, new FhirJsonTryteSerializer(), resourceTracker, seedManager); var fhirParser = new FhirJsonParser(); var searchRepository = new SearchRepository($"{DependencyResolver.LocalStoragePath}\\search.sqlite"); var createInteractor = new CreateResourceInteractor(fhirRepository, fhirParser, searchRepository); var readInteractor = new ReadResourceInteractor(fhirRepository, searchRepository); var validationInteractor = new ValidateResourceInteractor(fhirRepository, fhirParser); var searchInteractor = new SearchResourcesInteractor(fhirRepository, searchRepository); var resourceImporter = new ResourceImporter(searchRepository, fhirRepository, seedManager); builder.RegisterInstance(searchRepository).As <ISearchRepository>(); builder.RegisterInstance(resourceTracker).As <IResourceTracker>(); builder.RegisterInstance(createInteractor); builder.RegisterInstance(readInteractor); builder.RegisterInstance(validationInteractor); builder.RegisterInstance(searchInteractor); builder.RegisterInstance(resourceImporter); builder.RegisterInstance(seedManager).As <ISeedManager>(); builder.RegisterInstance(subscriptionFactory); builder.RegisterInstance(fhirRepository).As <IFhirRepository>(); builder.RegisterInstance(new AndroidLogout()).As <ILogout>(); var backgroundWorker = new BackgroundWorkerService(); var glucoseService = new FhirGlucoseService( new CreateResourceInteractor(fhirRepository, fhirParser, searchRepository), new UpdateResourceInteractor(fhirRepository, fhirParser), new ReadResourceInteractor(fhirRepository, searchRepository), searchRepository); var glucoseRepository = new DexcomGlucoseManagementRepository(new RestClient("https://sandbox-api.dexcom.com")); //backgoundWorker.RegisterTaskWorker(new ContinuousGlucoseTaskWorker(glucoseService, glucoseRepository)); backgroundWorker.RegisterTaskWorker(new AggregateGlucoseTaskWorker(glucoseService, glucoseRepository)); }
// Wrapper function for level generation private void Process() { SeedManager.Refresh(); // initialization of two lists which will be used in union–find data structure _parent = new List <int>(mapSize.x * mapSize.y); _weight = new List <int>(mapSize.x * mapSize.y); for (var i = 0; i < mapSize.x * mapSize.y; ++i) { _parent.Add(i); _weight.Add(1); } // arrangement of rooms foreach (var y in Enumerable.Range(0, mapSize.y)) { foreach (var x in Enumerable.Range(0, mapSize.x)) { var roomPosition = new Vector2Int(x * (roomSize.x + roomMargin.x), y * (roomSize.y + roomMargin.y)); AddRoom(roomPrefabs[Random.Range(0, roomPrefabs.Capacity)], roomPosition); } } // building a minimal connected graph while (_weight[ParentOf(0, 0)] != mapSize.x * mapSize.y) { int x = Random.Range(0, mapSize.x), y = Random.Range(0, mapSize.y); if (x > 0 && ParentOf(x, y) != ParentOf(x - 1, y)) { ConnectRooms(new Vector2Int(x, y), new Vector2Int(x - 1, y)); } if (y > 0 && ParentOf(x, y) != ParentOf(x, y - 1)) { ConnectRooms(new Vector2Int(x, y), new Vector2Int(x, y - 1)); } } // adding random connectors between rooms foreach (var y in Enumerable.Range(0, mapSize.y)) { foreach (var x in Enumerable.Range(0, mapSize.x)) { if (x > 0 && Random.Range(0, 5) == 0) { ConnectRooms(new Vector2Int(x, y), new Vector2Int(x - 1, y)); } if (y > 0 && Random.Range(0, 5) == 0) { ConnectRooms(new Vector2Int(x, y), new Vector2Int(x, y - 1)); } } } Instantiate(aStarPrefab, new Vector2( mapSize.x * (roomSize.x + roomMargin.x) / 2, mapSize.y * (roomSize.y + roomMargin.y) / 2), Quaternion.identity); StartCoroutine(ScanWithDelay()); }