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
};
}
