protected override void Execute()
{
string levelFileName = StringHelper.ConvertToXMLCompatible(levelNameStatus.Name);
LevelSaveData levelSaveData = SerializeHelper.Deserialize <LevelSaveData>(LevelDataPath.Path + levelFileName);
List <Vector2> standardTileGridPositions = levelSaveData.StandardTileGridPositions;
List <Vector2> nonStandardTileGridPositions = new List <Vector2>();
foreach (TileSaveData tileSaveData in levelSaveData.NonStandardTilesSaveData)
{
GenerateableTileNode generateableTileNode = GenerateableTileLibrary.GetGeneratableTileNode(tileSaveData.TileType);
if (!generateableTileNode.UserGenerated)
{
continue;
}
nonStandardTileGridPositions.Add(tileSaveData.GridPosition);
}
List <Vector2> userGeneratedTileGridPositions = standardTileGridPositions.Concat(nonStandardTileGridPositions).ToList();
TileGenerator.SpawnTiles(userGeneratedTileGridPositions);
List <LevelObjectSaveData> levelObjectsSaveData = levelSaveData.LevelObjectsSaveData;
SpawnLevelObjects(levelObjectsSaveData);
}
void Start()
{
UI = GameObject.Find("UI").GetComponent <UIController>();
Physics.gravity = new Vector3(0f, 0f, -9.81f); // Set Gravity in z-direction
// Make this accessible via WorldController.Instance
if (Instance != null)
{
Debug.LogError("There should never be two world controllers.");
}
Instance = this; // instantiate Worldcontroller
Debug.Log(PlayerPrefs.GetString("currlvl"));
lvl = new LevelController(PlayerPrefs.GetString("currlvl"));
map = new TileGenerator(lvl.Width, lvl.Height); // Generate map with Weight/Height given by the Levelcontroller
//if (lvl == null)
// Debug.LogError("Level controller missing!");
//Debug.Log("Created TileGenerator");
// Set Cameraposition to center
Camera.main.transform.position = new Vector3(lvl.Height / 2, lvl.Width / 2, Camera.main.transform.position.z);
// Draw the playing field
for (int x = 0; x < map.Width; x++)
{
for (int y = 0; y < map.Height; y++)
{
Tile tile = map.GetTileAt(x, y);
tile.Sprite = (GameObject)Instantiate(BGTile, new Vector3(x, y, 0f), Quaternion.identity);
}
}
// Place initial blocks
GenerateLevel();
}
public void Initialize()
{
this.IsInitialized = true;
TileGenerator.RefreshTileTask();
if (IsolatedStorageSettings.ApplicationSettings.Contains(AppSettings.FavoritesKey))
{
this.Favorites = (ObservableCollection <GeoLocationCity>)
IsolatedStorageSettings.ApplicationSettings[AppSettings.FavoritesKey];
this.Favorites = this.Favorites ?? new ObservableCollection <GeoLocationCity>();
}
this.LoadNewsFeed();
this.LoadFavorites();
this.AddToFavorites = new RelayCommand(AddToFavoritesExecute);
this.RemoveFromFavorites = new RelayCommand <GeoLocationCity>(RemoveFromFavoritesExecute);
this.FavoriteItemSelected = new RelayCommand <GeoLocationCity>(FavoriteItemSelectedExecute);
this.NewsItemSelected = new RelayCommand <NewsItem>(NewsItemSelectedExecute);
this.GoToLocation = new RelayCommand(GoToLocationExecute);
if (InternetIsAvailable())
{
ResolveAddress();
}
}
static void Main(string[] args)
{
Console.WriteLine("加载mapConfig.json...");
MapConfig mapConfig = MapConfig.Load();
TileGenerator generator = new TileGenerator(mapConfig);
generator.TileLoaded += new EventHandler <TileCoord>((sender, tileCoord) =>
{
Console.WriteLine(string.Format("Tile : zoom ： {0} x： {1} y ：{2}，已完成：{3}/{4}", tileCoord.Zoom, tileCoord.X,
tileCoord.Y, generator.SuccessTileIndex, generator.TotalTile));
});
generator.Finished += new EventHandler((sender, e) =>
{
Console.WriteLine(string.Format("完成：{0}/{1}，失败：{2}!", generator.SuccessTileIndex, generator.TotalTile, generator.FailTiles));
//if (generator.FailTiles > 0)
//{
// Console.WriteLine("是否尝试重新下载失败的瓦片？[Y/N]");
// string askYesNo = Console.ReadLine();
// if (askYesNo.Trim().ToUpper() =="Y")
// {
// generator.RetryFails();
// }
//}
});
Console.WriteLine("服务已启动......");
generator.Start();
Console.WriteLine("输入回车退出...");
Console.ReadKey();
generator.Close();
}
// Update is called once per frame
void Update()
{
if (!GameTurnManager.m_instance.IsPlayerTurn())
{
UnDisplaySpawnPossibility();
}
if (Input.GetMouseButton(0) && m_IsSpawnPossible && !IsBusyByPlayer)
{
if (PlayerManager.m_instance.m_player.isActiveAndEnabled)
{
PlayerManager.m_instance.m_player.GetComponent <touristSize>().Unspawn();
}
SpawnPlayer();
}
if (m_IsOver && GameTurnManager.m_instance.IsPlayerTurn())
{
m_rotation = TileMatching(TileGenerator.GetFreeTileForPlayer(), playerSpawnPossibility.GetComponent <touristSize>().takenSize, 1);
if (m_rotation != -1 && !m_IsSpawnPossible)
{
DisplaySpawnPossibility();
IsSpawnPossible.Invoke();
m_IsSpawnPossible = true;
}
}
}
/// <summary>
/// Generates reference image tiles.
/// </summary>
/// <param name="shapeFilePath">Shape file path.</param>
/// <param name="regionHvMapPath">Region HV map file path.</param>
/// <param name="shapeKey">Shape key used.</param>
/// <param name="outputDir">Output directory where the reference image tiles have to be stored.</param>
/// <param name="maxLevel">Maximum level of the pyramid.</param>
private static void GenerateReferenceImageTiles(string shapeFilePath, string regionHvMapPath, string shapeKey, string outputDir, int maxLevel)
{
// Create output folder.
if (!Directory.Exists(outputDir))
{
Directory.CreateDirectory(outputDir);
}
// Define Color map.
var shapeGrid = new ShapeValueMap(shapeFilePath, regionHvMapPath, shapeKey);
var colorMap = new ShapeColorMap(shapeGrid);
// Define serializer.
var tileSerializer = new ImageTileSerializer(TileHelper.GetDefaultImageTilePathTemplate(outputDir), ImageFormat.Png);
// Create and configure the tile creator.
var tileCreator = new ShapeTileCreator(tileSerializer, colorMap, ProjectionTypes.Toast, maxLevel);
// Generate shape file tiles.
Trace.TraceInformation("{0}: Creating the reference image tiles..", DateTime.Now.TimeOfDay.ToString(@"hh\:mm\:ss"));
var tileGenerator = new TileGenerator(tileCreator);
tileGenerator.Generate(maxLevel);
Trace.TraceInformation("{0}: Reference Image generation completed.", DateTime.Now.TimeOfDay.ToString(@"hh\:mm\:ss"));
}
private async Task RefreshTile(DbService dbService)
{
if (Utils.GetTileId() != null)
{
await TileGenerator.Generate(dbService, false);
}
}
protected IActionResult FractalImage(IFractal fractal, int z, long x, long y, int shades)
{
var generator = new TileGenerator(fractal, shades, z, x, y);
generator.Palette = DefaultPalette();
return(File(generator.GetImageStream(), "image/png"));
}
public GameObject SpawnIfPossible(GameObject touristPrefab)
{
touristSize tourist = touristPrefab.GetComponent <touristSize>();
int rotation = TileMatching(TileGenerator.GetFreeTile(), tourist.takenSize, 0);
if (rotation == -1)
{
return(null);
}
FillTouristTileComponent(tourist);
Sprite sprite = gameObject.GetComponent <SpriteRenderer>().sprite;
Vector2 SpriteSize = sprite.bounds.size;
Vector3 position = this.transform.position + new Vector3(SpriteSize.x * touristPrefab.GetComponent <touristSize>().GetTileOffset().x, SpriteSize.y * touristPrefab.GetComponent <touristSize>().GetTileOffset().y, 0);
if (m_rotation == 1)
{
position = this.transform.position + new Vector3(SpriteSize.y * touristPrefab.GetComponent <touristSize>().GetTileOffset().y, SpriteSize.x * touristPrefab.GetComponent <touristSize>().GetTileOffset().x, 0);
}
GameObject touristSpawnGO = (GameObject)Instantiate(touristPrefab, position, Quaternion.identity);
touristSpawnGO.transform.localEulerAngles = new Vector3(0, 0, (m_rotation == 1) ? 90 : 0);
Debug.Log("SpawnPlayer in tile : " + (int)m_tileIndex.x + " " + (int)m_tileIndex.y);
touristSpawnGO.GetComponent <touristSize>().SetOrderInLayer((int)m_tileIndex.x, (int)m_tileIndex.y);
return(touristSpawnGO);
}
// set tile properties (position, id, length and parent)
public override void SetProperties(float posX, int idTecla, int tam, TileGenerator tileG, float offy)
{
transform.position = new Vector3(posX, transform.position.y + offy, 0);
id = idTecla;
tileGenerator = tileG;
// crea la segunda tecla
if (partner == null)
{
partner = Instantiate(doubleTilePrefab);
partner.SetPartner(this);
float partnerPosX;
switch (posX)
{
case -2.25f:
partnerPosX = 0.75f;
break;
case -0.75f:
partnerPosX = 2.25f;
break;
case 0.75f:
partnerPosX = -2.25f;
break;
default:
partnerPosX = -0.75f;
break;
}
partner.SetProperties(partnerPosX, id, tam, tileGenerator, offy);
}
}
public Tile GetTileAtMouse()
{
Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
RaycastHit2D hit2D = Physics2D.Raycast(new Vector2(mousePos.x, mousePos.y), Vector2.down);
return(TileGenerator.GetTileAt((int)hit2D.transform.position.x, (int)hit2D.transform.position.y));
}
void Update()
{
if (IsPreviewing)
{
Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
RaycastHit2D hit2D = Physics2D.Raycast(new Vector2(mousePos.x, mousePos.y), Vector2.down);
if (hit2D.collider != null)
{
Tile tile = TileGenerator.GetTileAt((int)hit2D.transform.position.x, (int)hit2D.transform.position.y);
if (tile.IsBuildable && ActivePreview.transform.position != tile.Position)
{
ActivePreview.transform.position = tile.Position;
IsLocked = true;
}
else
{
if (IsLocked && tile.Position != hit2D.transform.position)
{
IsLocked = false;
}
}
}
if (!IsLocked)
{
ActivePreview.transform.position = new Vector3(mousePos.x, mousePos.y, 0);
}
}
}
public void Generates_With_Exit_Ok_Put()
{
//SetUp();
var mf = new TileGenerator(_size, _mineList, _exit).GenerateTiles();
Assert.IsInstanceOfType(mf[3, 3], typeof(ExitTitle));
}
private void CreateMesh(Vector3[,] vertices, Vector2[,] uvs, NeighBoursDirection direction)
{
Action createMeshAction = () =>
{
MeshData = MeshDataProvider.GenerateMeshData(vertices, uvs, Color.white, direction);
Action updateMeshAction = () =>
{
GameObject go = TileGenerator.CreateMeshGO(transform);
// Apply or remove the normal map from our material, based on the option set in the editor.
Mesh mesh = go.GetComponent <MeshFilter>().mesh;
var material = go.GetComponent <MeshRenderer>().material;
if (UseNormalMap)
{
ApplyNormalTexture(material);
}
else
{
RemoveNormalTexture(material);
}
MeshData.UpdateMesh(mesh);
};
ThreadQueue.StartFunctionInMainThread(updateMeshAction);
};
ThreadQueue.StartThreadFunction(createMeshAction);
}
private void Init()
{
try
{
configuration = Configuration.Load <Configuration>(StartupDir + configFileName);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
configuration = new Configuration();
configuration.CreateDefault();
}
try
{
configuration.Save <Configuration>(StartupDir + configFileName);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
generator = new TileGenerator(configuration, (int)this.Width, (int)this.Height);
generator.WorkerEvent += generator_WorkerEvent;
generator.Start();
}
/// <summary>
/// Initialize the generation context: settings, logger,
/// tiles configuration and tile generator.
/// </summary>
private void Init()
{
// Load settings
try {
_settings = Settings.LoadOrDefault(Settings.SETTINGS_PATH);
_logger = new Logger(_settings.LogFilePath);
} catch (Exception ex) {
_msg.InvalidSettings(ex);
Environment.Exit(11);
return;
}
// Initialize the logger
_msg.Logger = _logger;
try {
_logger.Init();
} catch (Exception ex) {
_msg.InvalidLogFile(ex);
Environment.Exit(12);
return;
}
_logger.Success("Loaded settings");
// Load tiles configuration
try {
_tilesConfig = TileConfig.Load(_settings.TilesConfigPath);
} catch (Exception ex) {
_msg.InvalidTilesConfig(ex);
Environment.Exit(13);
}
_logger.Success("Loaded tiles configuration");
// Initialize the tile generator
_generator = new TileGenerator(_settings, _logger);
_logger.Success("Initialized tiles generator");
}
public GameObject getCandyObject()
{
return(TileGenerator.Choose(
new GameObject[] { candy1, candy2, candy3, candy4, candy5, candy6, candy7 },
new float[] { 0.145f, 0.145f, 0.145f, 0.145f, 0.145f, 0.145f, 0.13f },
7));
}
private async void AppBarButton_Click_UploadAsync(object sender, RoutedEventArgs e)
{
FileOpenPicker picker = new FileOpenPicker();
picker.ViewMode = PickerViewMode.Thumbnail;
picker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add(".jpg");
picker.FileTypeFilter.Add(".jpeg");
picker.FileTypeFilter.Add(".png");
StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
try {
var bitmap = await Commons.Convert.ConvertImageToByte(file);
viewModel.UpdateBitmap(SelectedItem, bitmap);
TodoMain.Current.BackgroundChange(await Commons.Convert.ConvertByteToImage(bitmap));
TileGenerator.Update(Database.ViewModel.Collection);
} catch (Exception) {
MessageDialog msg = new MessageDialog("发生了些小问题，稍后试试吧", "Oops!");
await msg.ShowAsync();
}
}
}
public void Generates_Tiles_OK_Length()
{
//SetUp();
var mf = new TileGenerator(_size, _mineList, _exit).GenerateTiles();
Assert.AreEqual(mf.Length, 50);
}
// set tile properties (position, id, length and parent)
public override void SetProperties(float posX, int idTecla, int tamTecla, TileGenerator tileG, float offy)
{
tam = tamTecla;
escalador.localScale = new Vector3(1, tam, 1);
transform.position = new Vector3(posX, transform.position.y + offy, 0);
id = idTecla;
tileGenerator = tileG;
}
public void GivenTwoOneDotFieldShouldGetZero()
{
// Use the Assert class to test conditions.
var generator = new TileGenerator();
var field = generator.GenerateField(2, 1, new string[] { ".." });
Assert.AreEqual(field[0], "00");
}
/// <summary>
/// Processes the input equirectangular image.
/// </summary>
/// <param name="inputImage">
/// Input image path.
/// </param>
/// <param name="outputDir">
/// Output directory where pyramid is generated.
/// </param>
/// <param name="projection">
/// Projection type.
/// </param>
private static void ProcessEquirectangularImage(string inputImage, string outputDir, ProjectionTypes projection)
{
Trace.TraceInformation("{0}: Reading image..", DateTime.Now.TimeOfDay.ToString(@"hh\:mm\:ss", CultureInfo.InvariantCulture));
ImageFormat imageFormat = ImageFormat.Png;
// Set the grid boundaries
var imageBoundary = new Boundary(-180, -90, 180, 90);
// Build an image grid using the input image
var imageGrid = new ImageGrid(inputImage, true);
// Build the grid map for equirectangular projection using the image grid and boundary co-ordinates
var equirectangularGridMap = new EquirectangularGridMap(imageGrid, imageBoundary);
// Build the color map using equirectangular projection grid map
var imageColorMap = new ImageColorMap(equirectangularGridMap);
var maximumLevelsOfDetail = TileHelper.CalculateMaximumLevel(imageGrid.Height, imageGrid.Width, imageBoundary);
// Define ITileCreator instance for creating image tiles.
ITileCreator tileCreator = TileCreatorFactory.CreateImageTileCreator(imageColorMap, projection, outputDir);
// Define plumbing for looping through all the tiles to be created for base image and pyramid.
var tileGenerator = new TileGenerator(tileCreator);
// Start building base image and the pyramid.
Trace.TraceInformation("{0}: Building base and parent levels...", DateTime.Now.TimeOfDay.ToString(@"hh\:mm\:ss", CultureInfo.InvariantCulture));
tileGenerator.Generate(maximumLevelsOfDetail);
string fileName = Path.GetFileNameWithoutExtension(inputImage);
// Generate Plate file.
Trace.TraceInformation("{0}: Building Plate file...", DateTime.Now.TimeOfDay.ToString(@"hh\:mm\:ss", CultureInfo.InvariantCulture));
ImageTileSerializer pyramid = new ImageTileSerializer(TileHelper.GetDefaultImageTilePathTemplate(outputDir), ImageFormat.Png);
PlateFileGenerator plateGenerator = new PlateFileGenerator(
Path.Combine(outputDir, fileName + ".plate"),
maximumLevelsOfDetail,
ImageFormat.Png);
plateGenerator.CreateFromImageTile(pyramid);
// Generate Thumbnail Images.
Trace.TraceInformation("{0}: Building Thumbnail image..", DateTime.Now.TimeOfDay.ToString(@"hh\:mm\:ss", CultureInfo.InvariantCulture));
string thumbnailFile = Path.Combine(outputDir, fileName + ".jpeg");
TileHelper.GenerateThumbnail(inputImage, 96, 45, thumbnailFile, ImageFormat.Jpeg);
// Get the path of image tiles created and save it in WTML file.
Trace.TraceInformation("{0}: Building WTML file..", DateTime.Now.TimeOfDay.ToString(@"hh\:mm\:ss", CultureInfo.InvariantCulture));
string pyramidPath = WtmlCollection.GetWtmlTextureTilePath(TileHelper.GetDefaultImageTilePathTemplate(outputDir), imageFormat.ToString());
// Create and save WTML collection file.
WtmlCollection wtmlCollection = new WtmlCollection(fileName, thumbnailFile, pyramidPath, maximumLevelsOfDetail, projection);
string path = Path.Combine(outputDir, fileName + ".wtml");
wtmlCollection.Save(path);
Trace.TraceInformation("{0}: Collection successfully generated.", DateTime.Now.TimeOfDay.ToString(@"hh\:mm\:ss", CultureInfo.InvariantCulture));
}
//Basically, give it the data as encoded by MapEditor.serializeTile
public static Tile[,,] DeserializeTiles(string tileRaw, TileGenerator generator, Transform tileHolder)
{
//Parse the saved data. If there's nothing there, indicate that by -1
int[] data = tileRaw.Split(',').Select((datum) => {
int num = -1;
if (!Int32.TryParse(datum, out num))
{
num = -1;
}
return(num);
}).ToArray();
Tile[,,] parsedTiles = new Tile[data[0], data[1], data[2]];
data = data.Skip(3).ToArray();
//Reconstruct the map
for (int x = 0; x < parsedTiles.GetLength(0); x++)
{
for (int y = 0; y < parsedTiles.GetLength(1); y++)
{
for (int z = 0; z < parsedTiles.GetLength(2); z++)
{
int flatIndex = x + parsedTiles.GetLength(1) * (y + parsedTiles.GetLength(0) * z);
//If its an actual gameplay tile, deserialize it
if (data[flatIndex] != -1 && data[flatIndex] != 0)
{
int tileTypeInt = data[flatIndex];
TileType type = (TileType)tileTypeInt;
GameObject newTile = generator.getTileByType((TileType)tileTypeInt);
if (newTile != null)
{
//typePrefabs was old way of doing this
Tile tile = GameObject.Instantiate(newTile,
Util.GridToWorld(x, y, z),
Quaternion.Euler(-90, 0, 0))
.GetComponent <Tile>();
//make child of singe transform for easier deletion
tile.transform.parent = tileHolder;
tile.tileType = (TileType)(tileTypeInt);
parsedTiles[x, y, z] = tile;
//Make it taste better
addFlavor(new Vector3Int(x, y, z), tile);
}
else
{
Debug.Log("Null tile");
}
}
}
}
}
return(parsedTiles);
}
void Start()
{
if (!OptionsScript.debugMode)
{
gameObject.SetActive(false);
}
generator = GameObject.Find("Generator").GetComponent <TileGenerator>();
}
void Start()
{
_mapGrid = GetComponent <Grid>();
_navSurface = GetComponent <NavMeshSurface>();
_levelManager = GetComponent <LevelManager>();
_propsManager = GetComponent <PropsManager>();
_tileGenerator = GetComponent <TileGenerator>();
Generate();
}
public void Start()
{
SetPosition(start_x, start_y);
tg = GameObject.FindGameObjectWithTag("TileGenerator").GetComponent <TileGenerator>();
tm = GameObject.FindGameObjectWithTag("TileGenerator").GetComponent <TurnManager>();
IAMovement.Instance.player = this;
}
private Vector3 determineDirection()
{
int enemyX = (int)gameObject.transform.position.x;
int enemyZ = (int)gameObject.transform.position.z;
List <GameObject> tiles = TileGenerator.GetWalkableTilesInRange(enemyX, enemyZ, 1);
GameObject tile = getNearestTile(tiles, targetPosX, targetPosZ);
return(new Vector3(tile.transform.position.x, 0, tile.transform.position.z));
}
public void GenerateTile(TileItem item)
{
TileGenerator.RefreshTileTask();
#if DEBUG
ScheduledActionService.LaunchForTest(AppSettings.PeriodicTaskName, TimeSpan.FromSeconds(1));
#endif
TileGenerator.GenerateTile(item, delegate() {});
}
private void AppBarButton_Click_Delete(object sender, RoutedEventArgs e)
{
viewModel.Remove(SelectedItem);
SelectedItem = null;
StateChange("Init");
TodoList.Current.UpdateListViewEmptyVisibility();
TodoMain.Current.BackgroundChange(null);
TodoMain.Current.StateFromDetailToList();
TileGenerator.Update(Database.ViewModel.Collection);
}
// Start is called before the first frame update
void Awake()
{
tg = this;
t = new Tile[wid, hgt];
for (int i = 0; i < wid; i++)
{
for (int j = 0; j < hgt; j++)
{
t[i, j] = GameObject.Instantiate(tile, new Vector3(i * 10 + transform.position.x, 0, j * 10 + transform.position.z), Quaternion.identity).GetComponent <Tile>();
t[i, j].neighbors = new Dictionary <Tile, int>();
t[i, j].x = i;
t[i, j].y = j;
}
}
for (int i = 0; i < wid; i++)
{
for (int j = 0; j < hgt; j++)
{
if (i > 0)
{
t[i, j].neighbors.Add(t[i - 1, j], 0);
}
if (i < wid - 1)
{
t[i, j].neighbors.Add(t[i + 1, j], 0);
}
if (j > 0)
{
t[i, j].neighbors.Add(t[i, j - 1], 0);
}
if (j < hgt - 1)
{
t[i, j].neighbors.Add(t[i, j + 1], 0);
}
if (i > 0 && j > 0)
{
t[i, j].neighbors.Add(t[i - 1, j - 1], 0);
}
if (i < wid - 1 && j < hgt - 1)
{
t[i, j].neighbors.Add(t[i + 1, j + 1], 0);
}
if (j > 0 && i < wid - 1)
{
t[i, j].neighbors.Add(t[i + 1, j - 1], 0);
}
if (j < hgt - 1 && i > 0)
{
t[i, j].neighbors.Add(t[i - 1, j + 1], 0);
}
}
}
}
public void GeneratePyramidsTest()
{
MockClasses.MockTileCreatorForTileGenerator creator = new MockClasses.MockTileCreatorForTileGenerator();
TileGenerator target = new TileGenerator(creator);
int level = 5;
target.Generate(level);
Assert.AreEqual(6, creator.TileCreated.Count);
Assert.AreEqual(1024, creator.TileCreated[5]);
Assert.AreEqual(256, creator.TileCreated[4]);
Assert.AreEqual(64, creator.TileCreated[3]);
Assert.AreEqual(16, creator.TileCreated[2]);
Assert.AreEqual(4, creator.TileCreated[1]);
Assert.AreEqual(1, creator.TileCreated[0]);
}
public void GeneratePyramidsWithBoundaryMercatorTest()
{
MockClasses.MockTileCreatorForMercatorTileGenerator creator = new MockClasses.MockTileCreatorForMercatorTileGenerator();
TileGenerator target = new TileGenerator(creator);
int level = 5;
var imageBoundary = new Boundary(-180, -90, 180, 90);
target.Generate(level, imageBoundary);
Assert.AreEqual(6, creator.TileCreated.Count);
Assert.AreEqual(1024, creator.TileCreated[5]);
Assert.AreEqual(256, creator.TileCreated[4]);
Assert.AreEqual(64, creator.TileCreated[3]);
Assert.AreEqual(16, creator.TileCreated[2]);
Assert.AreEqual(4, creator.TileCreated[1]);
Assert.AreEqual(1, creator.TileCreated[0]);
}
public void GeneratePyramidsDepthTest()
{
MockClasses.MockTileCreatorForTileGenerator creator = new MockClasses.MockTileCreatorForTileGenerator();
TileGenerator target = new TileGenerator(creator);
int level = 5;
int tileXStart = 5;
int tileXEnd = 28;
int tileYStart = 10;
int tileYEnd = 28;
int depth = 3;
target.Generate(level, tileXStart, tileXEnd, tileYStart, tileYEnd, depth);
Assert.AreEqual(3, creator.TileCreated.Count);
Assert.AreEqual(456, creator.TileCreated[5]);
Assert.AreEqual(130, creator.TileCreated[4]);
Assert.AreEqual(42, creator.TileCreated[3]);
}
void Awake()
{
instance = this;
}
// Use this for initialization
void Start () {
gen = gameObject.GetComponentInParent<TileGenerator>();
//renderer = gameObject.GetComponentInParent<SpriteRenderer>();
}
// Use this for initialization
void Start()
{
tileGenerator = GetComponent<TileGenerator>();
playerHand = GetComponent<PlayerHand>();
moveSlider = GameObject.FindGameObjectWithTag("MoveSlider");
moveSliderTextTextComponent = GameObject.FindGameObjectWithTag("SliderText").GetComponent<Text>();
movePanel = GameObject.FindGameObjectWithTag("SelectAmountToMovePanel");
movePanel.SetActive(false); // Since you cant find gameobjects that arent active, this must be done first
endTurnButton = GameObject.FindGameObjectWithTag("EndTurnButton");
endTurnButton.SetActive(false);
}
