public void shouldBeValley_trough8() { var landscapeType = new LandscapeType("[9, 8, 9]"); String result = landscapeType.Type(); Assert.Equal(VALLEY, result); }
public void shouldBeNeither() { var landscapeType = new LandscapeType("[9, 8, 9, 8]"); String result = landscapeType.Type(); Assert.Equal(NEITHER, result); }
/// <summary> /// The constructor for a Landscape tile is just a plain old C# object constructor. /// </summary> /// <param name="inType">The type of tile, using enum LandscapeType</param> /// <param name="inBrightnessOffset">a random int to brighten or darken the color of the tile. Stored to make it consistent</param> /// <param name="inRandomShape">The random shape of this tile. Only used for rocks</param> public LandscapeTile(LandscapeType inType, int inBrightnessOffset, List <PointF> inRandomShape) { tileType = inType; randomShape = inRandomShape; tileChanged = false; brightnessOffset = inBrightnessOffset; }
public void shouldBeMountain_peak5() { var landscapeType = new LandscapeType("[3, 4, 5, 4, 3]"); String result = landscapeType.Type(); Assert.Equal(MOUNTAIN, result); }
public LandscapeTypeConfObject(LandscapeType type, float rarityFrom, float blendDistance, float heightMultiplier) { this.type = type; this.rarityFrom = rarityFrom; this.blendDistance = blendDistance; this.blendTo = rarityFrom + blendDistance; this.heightMultiplier = heightMultiplier; }
public void GridIsPassableMethodWorksCorrectly(int x, int y, LandscapeType cellType, int cellClearance, LandscapeType unitType, int unitySize, bool result) { var grid = new PathfindingGrid(20, 20, Allocator.Persistent); grid.SetFlag(x, y, (long)cellType); grid.SetClearance(x, y, cellClearance); Assert.AreEqual(result, grid.IsPassable(x, y, (long)unitType, unitySize)); grid.Dispose(); }
protected void GenerateRandomLandscapes(int num) { for (int i = 0; i < num; i++) { int r = rand.Next(0, 2); LandscapeType lt = (LandscapeType)r; Landscape ls = new Landscape(lt, new Vector(rand.Next(0, 1366), rand.Next(0, 768))); overallMap.Add(ls); } }
public void AddTypeConf(LandscapeType type, float rarityFrom, float blendDistance, float heightMultiplier) { if (this.landscapeTypeGradient.Count > 0) { this.landscapeTypeGradient.Add(new LandscapeTypeConfObject(type, rarityFrom, blendDistance, heightMultiplier, this.landscapeTypeGradient[this.landscapeTypeGradient.Count - 1])); } else { this.landscapeTypeGradient.Add(new LandscapeTypeConfObject(type, rarityFrom, blendDistance, heightMultiplier)); } }
public Landscape(LandscapeType type, Vector pos) { Type = type; Position = pos; if (type == LandscapeType.House || type == LandscapeType.Rock || type == LandscapeType.Wall) { Passable = false; } else { Passable = true; } SetImage(type); }
public LandscapeTypeConfObject(LandscapeType type, float rarityFrom, float blendDistance, float heightMultiplier, LandscapeTypeConfObject prev) : this(type, rarityFrom, blendDistance, heightMultiplier) { this.prev = prev; }
public Landscape(string name, Vector pos, Animation ani, bool pass, LandscapeType type) : base(name, pos, ani) { Type = type; Passable = pass; }
public void SetLandscape(LandscapeType landscape) { this.landscape = landscape; }
public Node(LandscapeType type) { landscape = type; entity = null; }
private void SetImage(LandscapeType type) { /* if (type == LandscapeType.House) * { * Img = Properties.Resources.House; * } * else if (type == LandscapeType.Rock) * { * Img = Properties.Resources.rock; * } * else if (type == LandscapeType.Stairs) * { * Img = Properties.Resources.stairs; * } * else if (type == LandscapeType.TreasureChest) * { * Img = Properties.Resources.chest; * } * else*/ if (type == LandscapeType.Tree) { int r = Form1.rand.Next(0, 20); if (r == 0) { Img = Res.foliage1; } else if (r == 1) { Img = Res.foliage2; } else if (r == 2) { Img = Res.foliage3; } else if (r == 3) { Img = Res.foliage4; } else if (r == 4) { Img = Res.palmtree1; } else if (r == 5) { Img = Res.palmtree2; } else if (r == 6) { Img = Res.palmtree3; } else if (r == 7) { Img = Res.palmtree4; } else if (r == 8) { Img = Res.palmtree5; } else if (r == 9) { Img = Res.palmtree6; } else if (r == 10) { Img = Res.tree1; } else if (r == 11) { Img = Res.tree2; } else if (r == 12) { Img = Res.tree3; } else if (r == 13) { Img = Res.tree4; } else if (r == 14) { Img = Res.tree5; } else if (r == 15) { Img = Res.tree6; } else if (r == 16) { Img = Res.tree7; } else if (r == 17) { Img = Res.tree8; } else if (r == 18) { Img = Res.tree9; } else if (r == 19) { Img = Res.treeDead; } // Img = Properties.Resources.Tree; } else { Img = Properties.Resources.block; } }
}//E N D C O N S T R U C T O R /// <summary> /// The start method generates a random landscape to fit the parameters. /// </summary> public void Start() { Array landscapeTypes = Enum.GetValues(typeof(LandscapeType)); tilesMap = new List <List <LandscapeTile> >(); int goalRow = rand.Next(3, landscapeHeight - 3); //seed initial map for (int row = 0; row < landscapeHeight; row++) { List <LandscapeTile> currentRow = new List <LandscapeTile>(); for (int col = 0; col < landscapeWidth; col++) { if (row >= goalRow - 1 && row <= goalRow + 1 && col == 0) { currentRow.Add(new LandscapeTile(LandscapeType.goal, rand.Next(-30, 30), generateRandomShape())); } else if (row == 0 || col == 0 || col == landscapeWidth - 1 || row == landscapeHeight - 1) { currentRow.Add(new LandscapeTile(LandscapeType.bedrock, rand.Next(-30, 30), generateRandomShape())); } else { if (col < edgeBuffer || col > landscapeWidth - edgeBuffer - 1 || row < edgeBuffer || row > landscapeHeight - edgeBuffer - 1) { currentRow.Add(new LandscapeTile(LandscapeType.rock, rand.Next(-30, 30), generateRandomShape())); } else { LandscapeType randomLandscapeType = (LandscapeType)landscapeTypes.GetValue(rand.Next(landscapeTypes.Length - 2)); currentRow.Add(new LandscapeTile(randomLandscapeType, rand.Next(-30, 30), generateRandomShape())); } } } tilesMap.Add(currentRow); }//end seed //iterate on generation (cell generation) for (int iteration = 0; iteration < generationIterations; iteration++) { for (int row = edgeBuffer; row < landscapeHeight - edgeBuffer; row++) { for (int col = edgeBuffer; col < landscapeWidth - edgeBuffer; col++) { int rocksCount = 0; int grassCount = 0; //proximity search of all neighbors. for (int searchRow = row - 1; searchRow < row + 2; searchRow++) { for (int searchCol = col - 1; searchCol < col + 2; searchCol++) { if (searchRow != row || searchCol != col) { if (tilesMap[searchRow][searchCol].tileType == LandscapeType.rock) { rocksCount++; } if (tilesMap[searchRow][searchCol].tileType == LandscapeType.grass) { grassCount++; } } } }//end proximity search if (rocksCount > rockSpawnThreshold) { tilesMap[row][col].tileType = LandscapeType.rock; } } } } //clean up excess rocks for (int row = edgeBuffer; row < landscapeHeight - edgeBuffer; row++) { for (int col = edgeBuffer; col < landscapeWidth - edgeBuffer; col++) { if (tilesMap[row][col].tileType == LandscapeType.rock) { int rocksCount = 0; int grassCount = 0; //proximity search of all neighbors. for (int searchRow = row - 1; searchRow < row + 2; searchRow++) { for (int searchCol = col - 1; searchCol < col + 2; searchCol++) { if (searchRow != row || searchCol != col) { if (tilesMap[searchRow][searchCol].tileType == LandscapeType.rock) { rocksCount++; } if (tilesMap[searchRow][searchCol].tileType == LandscapeType.grass) { grassCount++; } } } }//end proximity search if (rocksCount < rockSpawnThreshold) { if (grassCount > grassSpawnThreshold) { tilesMap[row][col].tileType = LandscapeType.grass; } else { tilesMap[row][col].tileType = LandscapeType.dirt; } } } else if (tilesMap[row][col].tileType == LandscapeType.dirt) { tilesMap[row][col].tileType = LandscapeType.grass; } } }//end clean up }
public CellLandscapeType(LandscapeType type, float score) { this.type = type; this.score = score; }
/// <summary> /// The KeyPlayer's Tick method controls invincibility, collision with landscape, movement and digging. /// </summary> public void Tick() { //i n v i n c i b i l i t y handling if (invincible && timeInvincible < invincibilityTime) { timeInvincible++; } else { invincible = false; timeInvincible = 0; } /*s i z i n g, originally l o c a t i n g, and determining * the s p e e d of the character based on the size of the landscape */ int pixelSpeed = 0; if (landscape.pixelHeightPerTile != 0) { bounds.Width = landscape.pixelWidthPerTile / 2; bounds.Height = landscape.pixelHeightPerTile * 3; imageBounds.X = bounds.X - bounds.Width / 2; imageBounds.Y = bounds.Y - bounds.Height / 2; imageBounds.Width = landscape.pixelWidthPerTile; imageBounds.Height = landscape.pixelHeightPerTile * 5; pixelSpeed = landscape.pixelWidthPerTile / 4; if (bounds.X == 0 && bounds.Y == 0) { bounds.X = (landscapeCol * landscape.pixelWidthPerTile); bounds.Y = (landscapeRow * landscape.pixelHeightPerTile); } else { landscapeCol = (int)((bounds.X + (bounds.Width / 2)) / landscape.pixelWidthPerTile); landscapeRow = (int)((bounds.Y + (bounds.Height)) / landscape.pixelHeightPerTile); landscape.tilesMap[landscapeRow][landscapeCol].tileType = LandscapeType.dirt; } } //M o v e m e n t code digHeld = false; if (landscape.tilesMap[landscapeRow][landscapeCol - 1].tileType == LandscapeType.goal) //Victory condition { stateManager.keyboardVictory(); } else //loop through all the keys currently held to determine what actions to take. { foreach (KeyEventArgs key in inputManager.keysHeld) { if (key.KeyCode == Keys.W) { lastFacingDirection[0] = -1; lastFacingDirection[1] = 0; LandscapeType forwardTile = landscape.tilesMap[landscapeRow - 1][landscapeCol].tileType; if (forwardTile == LandscapeType.grass || forwardTile == LandscapeType.dirt || bounds.Y + bounds.Height > (landscapeRow * landscape.pixelHeightPerTile) + pixelSpeed) { bounds.Y -= pixelSpeed; } } if (key.KeyCode == Keys.A) { lastFacingDirection[0] = 0; lastFacingDirection[1] = -1; LandscapeType forwardTile = landscape.tilesMap[landscapeRow][landscapeCol - 1].tileType; if (forwardTile == LandscapeType.grass || forwardTile == LandscapeType.dirt || bounds.X > (landscapeCol * landscape.pixelWidthPerTile) + pixelSpeed) { bounds.X -= pixelSpeed; } } if (key.KeyCode == Keys.S) { lastFacingDirection[0] = 1; lastFacingDirection[1] = 0; LandscapeType forwardTile = landscape.tilesMap[landscapeRow + 1][landscapeCol].tileType; if (forwardTile == LandscapeType.grass || forwardTile == LandscapeType.dirt || bounds.Y + bounds.Height < (landscapeRow * landscape.pixelHeightPerTile) - landscape.pixelHeightPerTile - pixelSpeed) { bounds.Y += pixelSpeed; } } if (key.KeyCode == Keys.D) { lastFacingDirection[0] = 0; lastFacingDirection[1] = 1; LandscapeType forwardTile = landscape.tilesMap[landscapeRow][landscapeCol + 1].tileType; if (forwardTile == LandscapeType.grass || forwardTile == LandscapeType.dirt || bounds.X + bounds.Width < (landscapeCol * landscape.pixelWidthPerTile) - landscape.pixelWidthPerTile - pixelSpeed) { bounds.X += pixelSpeed; } } if (key.KeyCode == Keys.Space) { digHeld = true; attackBounds.Width = landscape.pixelWidthPerTile; attackBounds.Height = landscape.pixelHeightPerTile * 2; attackBounds.Y = bounds.Y; attackBounds.X = bounds.X + (bounds.Width / 2 - attackBounds.Width / 2); if (lastFacingDirection[1] > 0) { attackBounds.X = bounds.X + bounds.Width; } else if (lastFacingDirection[1] < 0) { attackBounds.X = bounds.X - attackBounds.Width; } if (timeDigging >= digCooldown) { if (landscape.tilesMap[landscapeRow + lastFacingDirection[0]] [landscapeCol + lastFacingDirection[1]].tileType != LandscapeType.bedrock) { landscape.tilesMap[landscapeRow + lastFacingDirection[0]] [landscapeCol + lastFacingDirection[1]].tileType = LandscapeType.dirt; timeDigging = 0; } } else { digHeld = true; timeDigging += 0.1f; } } }//end inputs if (!digHeld) { timeDigging = 0; attackBounds.Width = 0; attackBounds.Height = 0; } } }