private Map SpawnMap( IMapGenerator mapGenerator, MapTileSpawner spawnMapTile, IMapToWorldMapper mapToWorldMapper ) { var map = mapGenerator.GenerateMap(); map.ForEachTile((x, y, tile) => { var pos = mapToWorldMapper.GetWorldPosition( mapX: x, mapY: y, tile: tile ); spawnMapTile( tile: tile, mapX: x, mapY: y, worldPos: pos ); }); return(map); }
public HexControl(int sizeX, int sizeZ, IMapGenerator generator) { this.sizeX = sizeX; this.sizeZ = sizeZ; tiles = generator.GenerateTiles(sizeX, sizeZ); pathfinder = new Pathfinding(); }
// Setup game. // initialMoney: The initially available money. // economyTickInterval: // The number of game ticks that elapse between economy ticks. // incomePerEconomyTick: // Amount of Money that is added for each economy tick. public Game( IMapGenerator mapGenerator, MapTileSpawner spawnMapTile, IMapToWorldMapper mapToWorldMapper, int initialMoney, int incomePerEconomyTick, int economyTickInterval ) { this.Map = SpawnMap( mapGenerator: mapGenerator, spawnMapTile: spawnMapTile, mapToWorldMapper: mapToWorldMapper ); this.MapToWorldMapper = mapToWorldMapper; WorldSize = mapToWorldMapper.GetWorldSize( mapWidth: this.Map.Width, mapHeight: this.Map.Height ); Economy = new EconomySimulation( initialMoney: initialMoney, getIncome: () => incomePerEconomyTick, getUpkeepCosts: GetUpkeepCosts ); EconomyTickInterval = economyTickInterval; TicksUntilEconomyTick = economyTickInterval; this.Warehouse = new Warehouse(); //Debug.Log(Map.getNeighboursOfTile(0, 0)[1]); }
/// <summary> /// Gibt den Planeten mit der angegebenen ID zurück /// </summary> /// <param name="id">Die Planteten-ID des gewünschten Planeten</param> /// <returns>Der gewünschte Planet, falls er existiert</returns> public IPlanet GetPlanet(int id) { if (universe == null) { throw new Exception("No Universe loaded"); } IPlanet planet; if (!planets.TryGetValue(id, out planet)) { // Versuch vorhandenen Planeten zu laden planet = persistenceManager.LoadPlanet(universe.Id, id); if (planet == null) { // Keiner da -> neu erzeugen Random rand = new Random(universe.Seed + id); var generators = MapGeneratorManager.GetMapGenerators().ToArray(); int index = rand.Next(generators.Length - 1); IMapGenerator generator = generators[index]; planet = generator.GeneratePlanet(universe.Id, id, universe.Seed + id); // persistenceManager.SavePlanet(universe.Id, planet); } planets.Add(id, planet); } return(planet); }
public Level(IMapGenerator mapGenerator, int difficulty) { this.generator = mapGenerator; this.difficulty = difficulty; GameLogger.LogMessage($"Current difficulty {difficulty} {this.difficulty}", "Level"); this.LevelSetup(); }
/// <summary> /// Konstruktor des komplexen Map-Generators /// </summary> /// <param name="id">ID des Planeten</param> /// <param name="universe">ID des Universums</param> /// <param name="size">Größe des Planeten in Zweierpotenzen Chunks</param> /// <param name="generator">Instanz des Map-Generators</param> /// <param name="seed">Seed des Zufallsgenerators</param> public ComplexPlanet(int id, Guid universe, Index3 size, IMapGenerator generator, int seed) : base(id, universe, size, seed) { BiomeGenerator = new SurfaceBiomeGenerator(this, 40); this.Heightmap = null; ClimateMap = new Climate.ComplexClimateMap(this); }
// Use this for initialization private void Start() { _mapGenerator = GetMarkovMapGenerator(); var map = _mapGenerator.GenerateMap(TextureWidth, TextureHeight); DisplayMap(map); }
public void TestWinningCondition() { // 1x1 map int w = 1; int h = 1; IMapGenerator mapGenerator = MapGeneratorFactory.CreateOpenMapGenerator(); Map map = mapGenerator.GenerateMap(w, h, IMapGeneratorConstants.NO_SEED); // place player AbstractPlayer player = AIPlayerFactory.CreateEmptyAIPlayer("Test empty AI", map.Grid[0, 0]); // create game instance Game game = new Game() { GameMap = map }; game.AddAIPlayer(player); // perform one game loop step game.GameLoopStep(); // check winner Assert.IsTrue(game.IsWinner, "No winner after game loop step!"); Assert.IsNotNull(game.Winner, "Winner is null!"); }
public ComplexPlanet(int id, int universe, Index3 size, IMapGenerator generator, int seed) : base(id, universe, size, seed) { BiomeGenerator = new SurfaceBiomeGenerator(this, 40); this.Heightmap = null; ClimateMap = new Climate.ComplexClimateMap(this); }
/// <summary> /// Lädt einen Planeten. /// </summary> /// <param name="universeGuid">Guid des Universums</param> /// <param name="planetId">Index des Planeten</param> /// <returns></returns> public IPlanet LoadPlanet(Guid universeGuid, int planetId) { string file = Path.Combine(GetRoot(), universeGuid.ToString(), planetId.ToString(), PlanetFilename); string generatorInfo = Path.Combine(GetRoot(), universeGuid.ToString(), planetId.ToString(), PlanetGeneratorInfo); if (!File.Exists(generatorInfo) || !File.Exists(file)) { return(null); } IMapGenerator generator = null; using (Stream stream = File.Open(generatorInfo, FileMode.Create, FileAccess.Read)) { using (BinaryReader bw = new BinaryReader(stream)) { string generatorName = bw.ReadString(); generator = MapGeneratorManager.GetMapGenerators().FirstOrDefault(g => g.GetType().FullName.Equals(generatorName)); } } if (generator == null) { throw new Exception("Unknown Generator"); } using (Stream stream = File.Open(file, FileMode.Open, FileAccess.Read)) { using (GZipStream zip = new GZipStream(stream, CompressionMode.Decompress)) { return(generator.GeneratePlanet(zip)); } } }
internal void GenMap(int width, int height, int length, int seed, IMapGenerator generator) { game.World.Reset(); GC.Collect(); this.generator = generator; game.SetNewScreen(new LoadingMapScreen(game, "Generating level", "Generating..")); generator.GenerateAsync(game, width, height, length, seed); }
public MapState GenerateNewMap(Type generatorType) { IMapGenerator generator = GetMapGenerator(generatorType); IMap map = generator.GenerateMap(DefaultMapWidth, DefaultMapHeight); return(new MapState(map)); }
/// <summary> /// Generates the world using provided generator /// </summary> /// <param name="generator">The provided generator</param> /// <param name="progressBar">The progressbar to mark progress on</param> public void Generate(IMapGenerator generator, ProgressBar progressBar = null) { if (generator == null) { throw new ArgumentNullException("The generator can not be null!"); } generator.Generate(this, progressBar); }
public Game(IMapGenerator generator, IEnumerable<IAction> coreActions, IAgent agent) { _initialiseHooks = new List<IInitialiseHook>(); _addedActions = new List<IAction>(); _actionHooks = new Dictionary<string, List<IActionHook>>(); _coreActions = coreActions; _generator = generator; Reset(agent); }
public override void OnInspectorGUI() { if (owner == null) { owner = target as IMapGenerator; } ShowCommonCommands(); base.OnInspectorGUI(); }
public static T Create <T>(IMapGenerator <T> mapCreationStrategy) where T : IMap { if (mapCreationStrategy == null) { Debug.LogError(nameof(mapCreationStrategy) + "Map creation strategy cannot be null"); } return(mapCreationStrategy.CreateMap()); }
public Game(IMapGenerator generator, IEnumerable <IAction> coreActions, IAgent agent) { _initialiseHooks = new List <IInitialiseHook>(); _addedActions = new List <IAction>(); _actionHooks = new Dictionary <string, List <IActionHook> >(); _coreActions = coreActions; _generator = generator; Reset(agent); }
public void CreateNewMap() { for (int i = 0; i < ActiveMap.Count; i++) { MapGenerator = ActiveMap[i]; MapGenerator.Setup(MapWidth, MapHeight, RandomMap); RandomMap = MapGenerator.Generate(); } }
public IEnumerator Load(IMapGenerator map_generator) { map_generator_ = map_generator; map_factory_ = GetComponent <MapFactory>(); yield return(StartCoroutine(map_generator_.Generate())); Reset(map_generator_.GetMap()); }
// Update is called once per frame private void Update() { if (Input.GetMouseButtonDown(0)) { _mapGenerator = GetMarkovMapGenerator(); var map = _mapGenerator.GenerateMap(TextureWidth, TextureHeight); DisplayMap(map); } }
public AiTester(Settings settings, IMapGenerator mapGenerator, IGameVisualizer gameVisualizer, IProcessMonitor monitor, IAiFactory aiFactory, IGameFactory gameFactory) { this.settings = settings; this.mapGenerator = mapGenerator; this.gameVisualizer = gameVisualizer; this.monitor = monitor; this.aiFactory = aiFactory; this.gameFactory = gameFactory; }
// Use this for initialization void Start() { Maps = new List <Map>(); startVector = Camera.main.ScreenToWorldPoint(new Vector3(0, 0, 0)) + ((Vector3)MapController.SpriteSize / 2); generator = new MazeGenerator(); //<----------------- Здесь меняем генератор player = FindObjectOfType <PlayerController>(); deathWall = FindObjectOfType <DeathWallController>(); AddNewMap(); LocatePlayer(); }
public Game(IMapGenerator mapGenerator, ICountriesGenerator countriesGenerator) { // TODO: remove var size = 100; Countries = countriesGenerator.GenerateCountries(); Map = mapGenerator.GenerateMap(Countries, size); ProcessTurn(); }
private ResourceManager() { mapGenerator = MapGeneratorManager.GetMapGenerators().First(); chunkPersistence = new ChunkDiskPersistence(); planetCache = new Cache<int, IPlanet>(1, loadPlanet, savePlanet); chunkCache = new Cache<PlanetIndex3, IChunk>(CacheSize, loadChunk, saveChunk); bool.TryParse(ConfigurationManager.AppSettings["DisablePersistence"], out disablePersistence); }
public LocalCreepWayBuilder(IMapGenerator mapGenerator) { var _mapGenerator = (MapGenerator)mapGenerator; var map = _mapGenerator.GeneratedMap; foreach (var section in map.MapSections) { PathInSections.Add(section.Key, GeneratePathInSection(section.Value)); } }
/// <summary> /// Konstruktor des komplexen Map-Generators /// </summary> /// <param name="id">ID des Planeten</param> /// <param name="universe">ID des Universums</param> /// <param name="size">Größe des Planeten in Zweierpotenzen Chunks</param> /// <param name="generator">Instanz des Map-Generators</param> /// <param name="seed">Seed des Zufallsgenerators</param> /// <param name="averageDensity">Durchschnittliche Dichte des Planeten zur Berechnung der Gravitation in kg/m³. Erd- und Standardwert: 5510</param> public ComplexPlanet(int id, Guid universe, Index3 size, IMapGenerator generator, int seed, int averageDensity = 5510) : base(id, universe, size, seed) { // Berechnung der Gravitation auf Basis des Newton'schen Grundgesetzes und // der Annahme einer Kugel mit gleicher Oberfläche wie der rechteckige Planet. var radius = Math.Sqrt((Size.X * Size.Y) / (16 * Math.PI)); Gravity = (float)((4f / 3f) * Math.PI * GravitationalConstant * averageDensity * radius); Initalize(); }
internal void BeginGeneration(int width, int height, int length, int seed, IMapGenerator gen) { game.World.Reset(); game.WorldEvents.RaiseOnNewMap(); GC.Collect(); this.gen = gen; game.Gui.SetNewScreen(new GeneratingMapScreen(game, gen)); gen.Width = width; gen.Height = height; gen.Length = length; gen.Seed = seed; gen.GenerateAsync(game); }
//readonly CreepWayBuilder _creepWayBuilder; //? Where is used? //readonly WaypointsSpawner _wayPointSpawner; public MapManager(IMapGenerator mapGenerator //CreepWayBuilder creepWayBuilder, //WaypointsSpawner waypointsSpawner ) { var _mapGenerator = (MapGenerator)mapGenerator; Map = _mapGenerator.GeneratedMap; //_creepWayBuilder = creepWayBuilder; //_wayPointSpawner = waypointsSpawner; }
/// <summary> /// 生成実行 /// </summary> public void OnClick() { IMapGenerator logic = this.logicChanger.Logic; this.map = logic.DoGenerate(this.mapSize, this.complexLevel, this.player1, this.tileContainer); if (this.map != null) { // マップタイルを配置 Debug.Log(this.map.TileDataToString()); this.tileGenerator.GenerateTiles(this.map); } }
public void SetUp() { _targets = new Collection<Target>(); _map = new GoogleMap(); _player = new Player(); _mapGenerator = MockRepository.GenerateMock<IMapGenerator>(); _mapGenerator.Expect(m => m.GenerateTargetMap(null)).Return(_map).IgnoreArguments(); _targetRepository = new InMemoryRepository<Target>(_targets); _controller = new MissionController(_mapGenerator, _targetRepository); }
public static void StartEditor(IMapGenerator generator) { EditorManager.level = new Level(generator, 0); var reloading = SceneManager.LoadSceneAsync(3); GameLogger.LogMessage("Editor loading started", "EditorManager"); reloading.completed += (asyncOperation) => { GameLogger.LogMessage("Editor loading complete", "EditorManager"); Time.timeScale = 1; }; }
public void AddMapGeneratorType(Type mapGeneratorType) { try { IMapGenerator newGenerator = (IMapGenerator)Activator.CreateInstance(mapGeneratorType); AddMapGenerator(newGenerator); } catch (InvalidCastException ex) { throw new ArgumentException(string.Format(ErrorMessages.TypeDoesNotImplementInterface, mapGeneratorType.GetType().ToString(), "IMapGenerator"), ex); } }
public void InjectDependencies( IMapGenerationConfig config, IEnumerable <IMapTemplate> mapTemplates, IMapGenerator mapGenerator, [Inject(Id = "UI Animator")] Animator uiAnimator, ReadOnlyCollection <ICivilizationTemplate> civTemplates, ITechCanon techCanon ) { MapGenerationConfig = config; MapTemplates = mapTemplates; MapGenerator = mapGenerator; UIAnimator = uiAnimator; ValidCivTemplates = civTemplates.Where(template => !template.IsBarbaric).ToList(); TechCanon = techCanon; }
public AiTester(Settings settings, ILoggerFactory loggerFactory, IMapGenerator mapGenerator, IGameVisualizer gameVisualizer, Func <string, Ai> createAi, Func <Map, Ai, IGame> createGame, TextWriter textWriter, TextReader textReader) { this.settings = settings; resultsLog = loggerFactory.CreateLogger(); this.mapGenerator = mapGenerator; this.gameVisualizer = gameVisualizer; this.createAi = createAi; this.createGame = createGame; this.textWriter = textWriter; this.textReader = textReader; }
private ResourceManager() { mapGenerator = MapGeneratorManager.GetMapGenerators().First(); chunkSerializer = new ChunkSerializer(); chunkPersistence = new ChunkDiskPersistence(chunkSerializer); _managers = new Dictionary<int, PlanetResourceManager>(); _planets = new[] {loadPlanet(0)}; //planetCache = new Cache<int, IPlanet>(1, loadPlanet, savePlanet); //chunkCache = new Cache<PlanetIndex3, IChunk>(CacheSize, loadChunk, saveChunk); bool.TryParse(ConfigurationManager.AppSettings["DisablePersistence"], out disablePersistence); }
public GameController(IRepository<Player> playerRepository, IRepository<Area> areaRepository, IMapGenerator mapGenerator) { _playerRepository = playerRepository; _mapGenerator = mapGenerator; _areaRepository = areaRepository; }
private void LoadGenerator(IMapGenerator generator) { Generator = generator; generatorName = generator.GetType().Name; Universe = generator.GenerateUniverse(0); Planet = generator.GeneratePlanet(0, seed); }
public Map(IMapGenerator generator,int seed) { this.seed = seed; LoadGenerator(generator); Chunks = new Chunk2D[Planet.Size.X * Planet.Size.Y]; }
public void LoadGenerator(IMapGenerator generator,int seed) { Map = new Map(generator,seed); //offsetX = offsetY = 0; UpdateQueue(); }
public MissionController(IMapGenerator mapGenerator, IRepository<Target> targetRepository) { _mapGenerator = mapGenerator; _targetRepository = targetRepository; }
public void SetUp() { _mother = new ObjectMother(); _account = _mother.GetAccountByEmailAddress("*****@*****.**"); _playerRepository = MockRepository.GenerateMock<IRepository<Player>>(); _areaRepository = MockRepository.GenerateMock<IRepository<Area>>(); _mapGenerator = new MapGenerator(); _controller = new GameController(_playerRepository, _areaRepository, _mapGenerator); _view = new CreatePlayerView { Name = "Dr. Evil", BaseName = "My Base", BaseLatitude = _latitude, BaseLongitude = _longitude }; }