/// <summary>
/// Fires the <see cref="TileCollision"/> event.
/// Event is wrapped so the static <see cref="TileCollision"/> can fire the event.
/// </summary>
public void FireTileCollisionEvent(TileTypeEnum tileType)
{
if (TileCollision != null)
{
TileCollision(tileType);
}
}
private void CreateRandomTile(TileTypeEnum tileType, Action <List <ResourceModel> > callback)
{
LootDropTable <ResourceModel, ResourceTypesEnum> lootDropTable = new LootDropTable <ResourceModel, ResourceTypesEnum>();
List <BucketObjectModel <ResourceTypesEnum> > lootObjectModel = new List <BucketObjectModel <ResourceTypesEnum> >();
List <ResourceModel> resources = null;
foreach (TileCreateModel tileCreateModel in GameModel.Tiles)
{
if (tileCreateModel.Type == tileType)
{
foreach (ResourceCreateModel resource in tileCreateModel.Resources)
{
BucketObjectModel <ResourceTypesEnum> bucketObject = new BucketObjectModel <ResourceTypesEnum>(resource.Type, resource.Weight, resource.Count);
lootObjectModel.Add(bucketObject);
}
resources = lootDropTable.GetLoot(lootObjectModel, tileCreateModel.MinDrop, tileCreateModel.MaxDrop);
break;
}
}
if (resources != null)
{
callback.Invoke(resources);
}
else
{
Debug.LogError("resources == NULL");
}
}
public void Init(TileModel tileModel)
{
this.tileType = tileModel.TileType;
this.resources = tileModel.Resources;
this.position = tileModel.Position;
this.unityWorldPosition = tileModel.UnityWorldPosition;
}
public void perlinPass(TileTypeEnum tte, int threshold, bool evenMap)
{
float RandomChange = Random.value;
int xLen = (!evenMap) ? boardX : boardX/2;
for(int x= 0;x < xLen; x++ ){
for(int y=0; y< boardY; y++ ){
float xVal = (x+RandomChange)*2.5f;
float yVal = (y+RandomChange)*2.5f;
float perlinVal = Mathf.PerlinNoise(xVal,yVal)*10;
//if(perlinVal*perlinVal > 60 && perlinVal*perlinVal < 80){
if(perlinVal*perlinVal*perlinVal*perlinVal > threshold){
BaseTile.createTile(tte, tilesGameBoard[x,y]);
}
//tilesGameBoard[x,y].renderer.material= matTest;
//tilesGameBoard[x,y].renderer.material =(Material)Resources.Load("Sprites/Materials/River");
}
}
if(evenMap){
for(int x= 0;x < xLen; x++ ){
for(int y=0; y< boardY; y++ ){
BaseTile.createTile(tilesGameBoard[x,y].GetComponent<BaseTile>().currentType, tilesGameBoard[boardX-x-1,y]);
}
}
}
}
void OnTileCollision(TileTypeEnum tileType)
{
if (CurrentLevel.DiamondsToCollect == DiamondsCollected)
{
SoundFxManager.Instance.PlaySound(SoundFxManager.CueEnums.applause);
Thread.Sleep(6000);
GameStateManager.CurrentGameState = GameStateManager.GameState.Menu;
mainWindow.Show();
IsMouseVisible = true;
}
}
public static bool isTileAnimated(TileTypeEnum tileType)
{
switch (tileType)
{
case TileTypeEnum.Water:
return(true);
default:
return(false);
}
}
public Tile(int coordinateX, int coordinateY, TileTypeEnum tileType, ResourceTypeEnum resourceType, Region region)
{
CoordinateX = coordinateX;
CoordinateY = coordinateY;
TileType = tileType;
ResourceType = resourceType;
CurrentRegion = region;
DailyResourceIncrement = (int)resourceType;
MaximumResourceLevel = DailyResourceIncrement * 100;
CurrentResourceLevel = MaximumResourceLevel;
}
// Set tile as empty or blocked
public void SetAs(TileTypeEnum newTileType)
{
if (newTileType == TileTypeEnum.Empty)
{
spriteRenderer.sprite = tileData.Empty;
tileType = TileTypeEnum.Empty;
}
else if (newTileType == TileTypeEnum.Blocked)
{
spriteRenderer.sprite = tileData.Blocked;
tileType = TileTypeEnum.Blocked;
}
}
public void perlinPass(TileTypeEnum tte, int threshold )
{
float RandomChange = Random.value;
for(int x= 0;x < boardX; x++ ){
for(int y=0; y< boardY; y++ ){
float xVal = (x+RandomChange)*2.5f;
float yVal = (y+RandomChange)*2.5f;
float perlinVal = Mathf.PerlinNoise(xVal,yVal)*10;
//if(perlinVal*perlinVal > 60 && perlinVal*perlinVal < 80){
if(perlinVal*perlinVal*perlinVal*perlinVal > threshold){
BaseTile.createTile(tte, tilesGameBoard[x,y]);
}
//tilesGameBoard[x,y].renderer.material= matTest;
//tilesGameBoard[x,y].renderer.material =(Material)Resources.Load("Sprites/Materials/River");
}
}
}
public static TileTypeEnum[,] GenerateLevel()
{
TileTypeEnum[,] map = new TileTypeEnum[20, 10];
for (int x = 0; x < map.GetLength(0); x++)
{
for (int y = 0; y < map.GetLength(1); y++)
{
if (x == 0 || y == 0 || x == map.GetLength(0) - 1 || y == map.GetLength(1) - 1)
{
map[x, y] = TileTypeEnum.Wall;
}
else
{
map[x, y] = TileTypeEnum.Ground;
}
}
}
return(map);
}
void init(TileTypeEnum type)
{
this.typeEnum = type;
switch (typeEnum)
{
case TileTypeEnum.GROUND:
//do something
break;
case TileTypeEnum.BONE_PILE:
//do something
break;
case TileTypeEnum.RIVER:
//do something
break;
case TileTypeEnum.STALAGMITE:
//do something
break;
}
}
private GameObject CreateTileGameObject(TileTypeEnum tileType, Transform parent)
{
Object obj = Resources.Load(RESOURCE_PATH_TILE + OBJECT_NAME_Tile + tileType.ToString());
if (obj != null)
{
GameObject clone = Object.Instantiate(obj) as GameObject;
clone.name = OBJECT_NAME_Tile + tileType.ToString();
clone.transform.parent = parent;
TileView tileView = clone.GetComponent <TileView>();
tileView.OnDeSpawn();
return(clone);
}
else
{
Debug.LogError(RESOURCE_PATH_TILE + OBJECT_NAME_Tile + tileType.ToString() + " == NULL");
return(null);
}
}
public void setTypeEnum(TileTypeEnum typeEnum)
{
this.typeEnum = typeEnum;
}
public EmptyTile(int x, int y, TileTypeEnum tileType) : base(x, y, tileType)
{
}
public Obsticle(int x, int y, TileTypeEnum tileType) : base(x, y, tileType)
{
}
public Tile(int x, int y, TileTypeEnum tileType)
{
X = x;
Y = y;
TileType = tileType;
}
public ResourcesCreateCallBackModel(TileTypeEnum tileType, Action <List <ResourceModel> > callBack)
{
this.tileType = tileType;
this.callBack = callBack;
}
public void SetTileType(TileTypeEnum type)
{
tileType = type;
// UpdateGfx(tileType);
}
public bool IsContainsTileType(TileTypeEnum id)
{
return(TileIds.ContainsKey((short)id));
}
private List <ITile> GetTiles(TileTypeEnum tileType, XmlNodeList tiles)
{
GetTileType(tileType, out List <ITile> list, out Type typeOfTile);
try
{
//Follows schema of Location, RegionId, Visited, Cleared (Dungeon only)
foreach (XmlNode tile in tiles)
{
var locationNode = tile.FirstChild;
if (locationNode == null)
{
Console.WriteLine($"Invalid location node: {tile.ParentNode.Name}");
continue;
}
var x = Convert.ToInt32(locationNode.FirstChild.InnerXml);
var y = Convert.ToInt32(locationNode.LastChild.InnerXml);
IPoint location = new Point2D(x, y);
var regionNode = locationNode.NextSibling;
if (regionNode == null)
{
Console.WriteLine($"Invalid regionID node: {tile}");
continue;
}
var region = regionNode.InnerXml;
var visitedNode = regionNode.NextSibling;
var visited = visitedNode != null?Convert.ToBoolean(visitedNode.InnerXml) : false;
var tileParams = new List <object>
{
location,
region,
visited
};
if (typeOfTile == typeof(DungeonTile))
{
var clearedNode = visitedNode.NextSibling;
if (clearedNode != null)
{
tileParams.Add(Convert.ToBoolean(clearedNode.InnerXml));
}
else
{
tileParams.Add(false);
}
//TODO: Add as field in xml doc
var numOfEnemies = 3;
tileParams.Add(numOfEnemies);
}
if (typeOfTile == typeof(EnemyTile) || typeOfTile == typeof(DungeonTile))
{
tileParams.Add(_battleManager);
}
var newTile = (ITile)Activator.CreateInstance(typeOfTile, tileParams.ToArray());
list.Add(newTile);
}
return(list);
}
catch (Exception e)
{
StaticHelperClass.PrintException(e, 3);
}
return(null);
}
private static void GetTileType(TileTypeEnum tileType, out List <ITile> list, out Type typeOfTile)
{
switch (tileType)
{
case TileTypeEnum.Enemy:
{
list = new List <ITile>();
typeOfTile = typeof(EnemyTile);
}
break;
case TileTypeEnum.Town:
{
list = new List <ITile>();
typeOfTile = typeof(TownTile);
}
break;
case TileTypeEnum.Dungeon:
{
list = new List <ITile>();
typeOfTile = typeof(DungeonTile);
}
break;
case TileTypeEnum.POI:
{
list = new List <ITile>();
typeOfTile = typeof(POITile);
}
break;
case TileTypeEnum.Desert:
{
list = new List <ITile>();
typeOfTile = typeof(DesertTile);
}
break;
case TileTypeEnum.Forest:
{
list = new List <ITile>();
typeOfTile = typeof(ForestTile);
}
break;
case TileTypeEnum.Mountain:
{
list = new List <ITile>();
typeOfTile = typeof(MountainTile);
}
break;
case TileTypeEnum.Plains:
{
list = new List <ITile>();
typeOfTile = typeof(PlainsTile);
}
break;
case TileTypeEnum.Seaside:
{
list = new List <ITile>();
typeOfTile = typeof(SeasideTile);
}
break;
case TileTypeEnum.None:
default:
{
list = new List <ITile>();
typeOfTile = typeof(ITile);
}
break;
}
}
// Procedurally generate level
private void GenerateLevel()
{
// Array of game objects to clone for each column
TileTypeEnum[] columnToCreate = new TileTypeEnum[worldSize.y];
// Cycle through columns
for (int i = 0; i < worldSize.x; i++)
{
// Number of passages in current column (by default all)
int numEmpty = worldSize.y;
// For current column determine which tiles are empty and which are
// blocked
for (int j = 0; j < worldSize.y; j++)
{
// By default, current position in column is empty
columnToCreate[j] = TileTypeEnum.Empty;
// However, if column is odd...
if (i % 2 != 0)
{
// ...and of by chance it's supposed to have a blocked tile
if (Random.value > passageRatio)
{
// ...then set a blocked tile
columnToCreate[j] = TileTypeEnum.Blocked;
// Now we have on less empty space
numEmpty--;
}
}
}
// Are there any empty tiles in current column?
if (numEmpty == 0)
{
// If not, then randomly define one empty tile
columnToCreate[Random.Range(0, worldSize.y)] =
TileTypeEnum.Empty;
}
// Instantiate tiles for current column
for (int j = 0; j < worldSize.y; j++)
{
GameObject currTile = Instantiate(tile, transform);
currTile.name = $"Tile({i},{j})";
currTile.transform.position =
new Vector3(i - offset.x, j - offset.y, 0);
world[i, j] = currTile.GetComponent <TileBehaviour>();
world[i, j].SetAs(columnToCreate[j]);
world[i, j].Pos = new Vector2Int(i, j);
}
}
// Place player anywhere in the world, as long as it's an empty tile
while (true)
{
PlayerPos = new Vector2Int(
Random.Range(0, worldSize.x), Random.Range(0, worldSize.y));
if (world[PlayerPos.x, PlayerPos.y].TileType == TileTypeEnum.Empty)
{
player = Instantiate(player);
player.transform.position = new Vector3(
PlayerPos.x - offset.x, PlayerPos.y - offset.y, -2);
break;
}
}
Debug.Log($"Player placed at {PlayerPos}");
// Place goal anywhere in the world, as long as it's an empty tile and
// noy the player position
while (true)
{
GoalPos = new Vector2Int(
Random.Range(0, worldSize.x), Random.Range(0, worldSize.y));
if (world[GoalPos.x, GoalPos.y].TileType == TileTypeEnum.Empty &&
PlayerPos != GoalPos)
{
goal = Instantiate(goal);
goal.transform.position = new Vector3(
GoalPos.x - offset.x, GoalPos.y - offset.y, -1);
break;
}
}
Debug.Log($"Goal placed at {GoalPos}");
}
public TileCreateModel(TileTypeEnum type, List <ResourceCreateModel> resources, float weight)
{
this.type = type;
this.resources = resources;
this.weight = weight;
}
public static void createTile(TileTypeEnum et, GameObject currentTile)
{
currentTile.GetComponent<BaseTile>().IsHover = false;
currentTile.GetComponent<BaseTile>().IsSelected = false;
currentTile.GetComponent<BaseTile>().IsHighlighted = false;
switch (et){
case TileTypeEnum.regular:
currentTile.renderer.material = (Material)Resources.Load("Sprites/Materials/Regular");
currentTile.GetComponent<BaseTile>().currentType = TileTypeEnum.regular;
break;
case TileTypeEnum.water:
currentTile.renderer.material = (Material)Resources.Load("Sprites/Materials/Water");
currentTile.GetComponent<BaseTile>().currentType = TileTypeEnum.water;
break;
}
}
public void setTileType(TileTypeEnum TT)
{
switch (TT){
case TileTypeEnum.regular:
gameObject.renderer.material = (Material)Resources.Load("Sprites/Materials/Regular");
currentType = TileTypeEnum.regular;
break;
case TileTypeEnum.water:
gameObject.renderer.material = (Material)Resources.Load("Sprites/Materials/Water");
currentType = TileTypeEnum.water;
break;
}
}
public Tile(TileTypeEnum tileType, bool behaviorIsHidden, Vector3 position)
{
_Position = position;
_TileType = tileType;
_BehaviorIsHidden = behaviorIsHidden;
}
