public Tile(string assetname = "", TileType tp = TileType.Background, int layer = 0, string id = "")
: base(assetname, layer, id)
{
type = tp;
hot = false;
ice = false;
}
private Material GetMaterial(TileType type, TileDir dir)
{
string path = "Material/TileGrass";
switch (type)
{
case TileType.DeapWater:
path = "Material/Tile/DeapWater";
break;
case TileType.ShallowWater:
path = "Material/Tile/ShallowWater";
break;
case TileType.Sandbeach:
path = "Material/Tile/Sand";
break;
case TileType.Grassland:
path = "Material/Tile/Grass";
break;
case TileType.Forest:
path = "Material/Tile/Forest";
break;
case TileType.Snow:
path = "Material/Tile/Snow";
break;
default:
Log.LogError("Tile.GetMaterial: failed");
break;
}
Material mat = Resources.Load(path) as Material;
return mat;
}
public BillboardPrimitive(Core core, TileType tileType)
: base(core)
{
this.tileType = tileType;
BuildPrimitive();
}
private void CreateTile(TileType type, Vector2 position)
{
//sets tile with given position to given type
if (position.X > mapSize
|| position.Y > mapSize)
{
return;
}
Tile til;
switch (type)
{
case TileType.Grass:
til = new TileGrass(position);
break;
case TileType.Rock:
til = new TileRock(position);
break;
case TileType.Gravel:
til = new TileGravel(position);
break;
case TileType.Water:
til = new TileWater(position);
break;
default:
til = new TileGrass(position);
break;
}
int X = (int)position.X;
int Y = (int)position.Y;
TilesArray[X, Y] = til;
}
public Tile(TileType type, Point loc, int code)
{
MapLocation = loc;
Type = type;
DistanceFromStart = 0;
TileCode = code;
}
private int propertyPrice = 0; // Cost to initially purchase property
#endregion Fields
#region Constructors
public PropertyTile(
TileType t,
string n,
Color c,
int bR,
int h1R,
int h2R,
int h3R,
int h4R,
int hR,
int mV,
int hC,
int hotelC,
int pP)
: base(n, t)
{
// Set all the property values
// These are meant to be static, so they shouldn't change
houseRent = new int[4];
color = c;
baseRent = bR;
houseRent[0] = h1R;
houseRent[1] = h2R;
houseRent[2] = h3R;
houseRent[3] = h4R;
hotelRent = hR;
mortgageValue = mV;
houseCost = hC;
hotelCost = hotelC;
propertyPrice = pP;
currentRentCost = baseRent;
}
public Game(GameConfiguration configuration)
{
this.firstCapture = TileType.none;
this.turnOrder.Add(TileType.yellow);
this.currentTurn = 0;
this.Configuration = configuration;
}
public Tile(TileType type, int tileID, Texture2D texture)
{
_tileType = type;
_texture = texture;
_tileName = String.Empty;
_tileID = tileID;
}
public void CreateTile(TileType tileType, bool supportsWideTile)
{
ShellTile shellTile = _FindTile(tileType);
ShellTileData shellTileData=null;
switch(tileType)
{
case TileType.Standard:
shellTileData = _CreateStandardTileData();
supportsWideTile = false;
break;
case TileType.Flip:
shellTileData = _CreateFlipTileData();
break;
case TileType.Cycle:
shellTileData = _CreateCycleTileData();
break;
case TileType.Iconic:
shellTileData = _CreateIconicTileData();
break;
}
if (shellTile != null)
{
shellTile.Update(shellTileData);
//shellTile.Delete();
}
else
{
ShellTile.Create(new Uri("/Page1.xaml?TileType=" + tileType, UriKind.Relative), shellTileData, supportsWideTile);
}
}
public bool IsTileAngle()
{
var mid = Elevations[4];
if (Elevations[0] < mid)
{
this.Type = TileType.TopLeftAngle;
return true;
}
if (Elevations[2] < mid)
{
this.Type = TileType.TopRightAngle;
return true;
}
if (Elevations[6] < mid)
{
this.Type = TileType.BottomLeftAngle;
return true;
}
if (Elevations[8] < mid)
{
this.Type = TileType.BottomRightAngle;
return true;
}
return false;
}
public Tile(int id, Vector3 position, Vector2 size, TileType tileType)
{
//this.rand = new Random(DateTime.Now.Millisecond);
this.ID = id;
this.Position = position;
this.Size = size;
this.TileType = tileType;
//this.Paths = new List<List<Tile>>();
this.PathsInts = new List<List<int>>();
this.UnSafePaths = new List<List<int>>();
//this.units = new List<Unit>();
//this.unitsInTile = new List<bool>();
//this.unitIndexes = new List<int>();
//this.unitsCount = 0;
this.tileNeighbors = new List<Tile>();
for (int i = 0/*Paths.Count*/; i < TileMap.TileCount; i++)
{
//Paths.Add(new List<Tile>());
PathsInts.Add(new List<int>());
UnSafePaths.Add(new List<int>());
}
/*for (int i = 0; i < UnitCollection.TotalPossibleUnitCount(); i++)
{
//unitsInTile.Add(false);
unitIndexes.Add(0);
}*/
SetTileType(tileType);
}
private Tile LoadBasicTile(string name, TileType tileType, bool hot = false, bool ice = false)
{
Tile t = new Tile("Tiles/" + name, tileType);
t.Hot = hot;
t.Ice = ice;
return t;
}
public Tile(Vector2 pos, Vector2 size, TileType type, Color color)
{
position = pos;
this.size = size;
Color = color;
this.type = type;
}
// Create a new tile for this row using common base
public MetroTile AddTile(TileType type, TileWidth width, TileHeight height, string bgColor, string title, string onClick = "", string navUrl = "")
{
// Get the last tile added to this row
MetroTile lastTileAdded = this.Tiles.LastOrDefault();
int nextLeftMargin = 0;
// If this is the first tile in the row, margin is column margin
if (lastTileAdded == null)
{
nextLeftMargin = this.Column.LeftMargin;
}
else
{
// Calculate left margin based on the previous tile in the row
nextLeftMargin = lastTileAdded.LeftMargin + lastTileAdded.Width + Column.SpacingBetweenTiles;
}
// Now create the actual tile based on our calculations
MetroTile newTile = new MetroTile(this.Column.Position, type, TopMargin, nextLeftMargin, width, height, bgColor, title, onClick, navUrl);
// Add the new tile to the list of tiles for this row
this.Tiles.Add(newTile);
// Recalculate the width and height of this row
this.Width = this.Width == 0 ? newTile.Width : this.Width + Column.SpacingBetweenTiles + newTile.Width;
this.Height = this.Height < newTile.Height ? newTile.Height : this.Height;
// Return the new tile so it can be further worked with
return newTile;
}
public LevelTile(Point twoDimPoint, TileType type, Bitmap texture)
{
dimensions = new Size(40, 38);
this.type = type;
this.twoDimPoint = twoDimPoint;
this.texture = texture;
}
public override bool Do()
{
if (Layer.IsTileEmpty(TilePosition))
{
//architect.AddTile(Layer, TileWorldPosition, TilePosition, DoTileType, DoRotationFlip);
Layer.AddTile(TilePosition, DoTileType, DoRotationFlip);
return true;
}
else if (Layer[TilePosition].TileType != DoTileType)
//else if (Layer[TilePosition].TileType != architect.SelectedTileType)
{
OldTileType = Layer[TilePosition].TileType;
OldRotationFlip = ArchitectRotationFlip.FromTransform(Layer[TilePosition].Transform);
Layer.EmptyTile(TilePosition);
//architect.AddSelectedTileType(Layer, TileWorldPosition, TilePosition);
Layer.AddTile(TilePosition, DoTileType, DoRotationFlip);
OldRotationFlip.ApplyTo(Layer[TilePosition].Transform);
return true;
}
else if (!DoRotationFlip.Equals(Layer[TilePosition].Transform))
//else if (!architect.RotationFlip.Equals(Layer[TilePosition].Transform))
{
//PDebug.Log(Layer[TilePosition].Transform.localScale, Layer[TilePosition].Transform.localRotation.eulerAngles.z, architect.RotationFlip);
OldTileType = Layer[TilePosition].TileType;
OldRotationFlip = ArchitectRotationFlip.FromTransform(Layer[TilePosition].Transform);
DoRotationFlip.ApplyTo(Layer[TilePosition].Transform);
//architect.RotationFlip.ApplyTo(Layer[TilePosition].Transform);
return true;
}
else
return false;
}
public Entity ReplaceTileType(TileType newType) {
var componentPool = GetComponentPool(ComponentIds.TileType);
var component = (TileTypeComponent)(componentPool.Count > 0 ? componentPool.Pop() : new TileTypeComponent());
component.type = newType;
ReplaceComponent(ComponentIds.TileType, component);
return this;
}
public Tile(bool blocksMovement, TileType type)
: base(DrawTag.Tile_Ground_1, "")
{
this.blocksMovement = blocksMovement;
setDrawTag(type);
discovered = true;
}
public override void MatchedTilesAsBonus(GameDriver driver, TileType matchedType)
{
if (Random.Range(0, 100) <= bonusChance) {
driver.AddStats(matchedType, 3, matchedType);
driver.AddBonus(type);
}
}
public Tool(TileType type, Texture2D texture, bool isObstacle, int cost)
{
this.type = type;
this.texture = texture;
this.isObstacle = isObstacle;
this.cost = cost;
}
public int[] FillMap(int size)
{
TileType[] tiles = null;
int nbTiles=0;
int[] res = null;
switch (size)
{
case 0:
nbTiles = 36;
tiles = new TileType[nbTiles];
res = new int[nbTiles];
break;
case 1:
nbTiles = 100;
tiles = new TileType[nbTiles];
res = new int[nbTiles];
break;
case 2:
nbTiles = 196;
tiles = new TileType[nbTiles];
res = new int[nbTiles];
break;
default:
System.Console.WriteLine("CE MODE N4EXISTE PAS GROS BATARD.");
break;
}
Algo_fillMap(nativeAlgo, tiles, nbTiles);
for(int i=0;i<res.Length;i++)
{
res[i] = (int)tiles[i];
}
return res;
}
public Tile(String title, Color c, String path, bool pinned)
{
InitializeComponent();
TileTitle = title;
l_LabelTile.Content = TileTitle;
SolidColorBrush scb = new SolidColorBrush(c);
r_TileRect.Fill = scb;
r_Fx.Color = c;
s_AppPath = path;
//Pinned state
b_isPinned = pinned;
if (b_isPinned == true)
cm_Pin.Header = "Unpin";
tt_Type = TileType.Application;
this.DataContext = this;
api_Email = new APIGmHelper("", "");
//"\\Images\\Icons\\"
String exeName = path;
int start = exeName.LastIndexOf("\\");
exeName = exeName.Substring(start + 1, exeName.Length - start - 5);
exeName = exeName.ToLower();
BitmapImage img = new BitmapImage(new Uri("..\\Images\\AppIcons\\" + exeName + ".png", UriKind.Relative));
i_Icon.Source = img;
//(BitmapSource)Helpers.GetIcon(s_AppPath, false, false);
InitAnimations();
}
// TODO Make reading of types from file
void FillTileTypes()
{
tileTypes = new TileType[7];
TileType grass = new TileType(Types.Grassland, true, 1);
TileType road = new TileType(Types.Road, true, 2);
TileType mountain = new TileType(Types.Mountain, false, 1);
TileType water = new TileType(Types.Water, false, 1);
TileType swamp = new TileType(Types.Swamp, true, 0.5f);
TileType unknown = new TileType(Types.Unknown, true, 1);
TileType house = new TileType(Types.House, false, 1);
tileTypes[0] = grass;
tileTypes[1] = road;
tileTypes[2] = mountain;
tileTypes[3] = water;
tileTypes[4] = swamp;
tileTypes[5] = unknown;
tileTypes[6] = house;
}
public TileStruct(int x, int y, TileType type, TerrainType terrainType)
{
SetBoth(terrainType);
this.X = x;
this.Y = y;
this.Type = type;
}
/// <summary>
/// Grows the minerals on the map.
/// </summary>
/// <param name="map">The map where the minerals spawn</param>
/// <param name="biomeMap">The biome map attached to the previous map.</param>
public void GrowAll (TileType[, ] map, BiomeType[, ] biomeMap) {
NoiseGenerator gen = new NoiseGenerator ();
while (availableMinerals.Count > 0) {
MineralInfo mineral = availableMinerals.Dequeue();
gen.Reset();
for (int x = 0; x < map.GetLength(0); x ++) {
int y = (mineral.minHeight > 0 ? mineral.minHeight : 0);
int maxY = (mineral.maxHeight < map.GetLength(1) ? mineral.maxHeight : map.GetLength(1));
for (; y < maxY; y ++) {
if (IsTileCompatible(biomeMap, x, y, mineral.compatibleBiomes) && (mineral.rarity < (int) gen.PerlinNoise(x, y, 10, 100, 1)))
PlaceMinerals(map, x, y, mineral.minerals);
}
}
}
}
public void init(float height)
{
this.height = height;
this.heatIndex = 0;
this.type = TerrainTile.TileType.none;
this.maxHeat = 10;
}
public HexagonTileSerializable(HexagonTile source)
{
//this.Active = source.Active;
this.X = source.Visual.X;
this.Y = source.Visual.Y;
this.TileType = source.TileType;
}
/// <summary>
/// Create an invisible tile. Useful for the spawn tile or waypoint tiles
/// </summary>
/// <param name="position">The tile's world coordinates</param>
/// <param name="type">The tile type, determined when it is initially read in</param>
public Tile(Vector2 position, TileType type, float depth)
{
texture = null;
BoundingRectangle = new BoundingBox(new Vector3(position.X, position.Y, depth), new Vector3(position.X + 60, position.Y + 40, depth));
tileType = type;
setCollisions();
}
/// <summary>
/// Draws the preview.
/// </summary>
void DrawPreview()
{
GUILayout.Label("Preview", EditorStyles.boldLabel);
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
EditorGUILayout.Separator();
EditorGUILayout.TextField(AssetDatabase.GetAssetPath(selected));
TileType tempType = ttype;
ttype = (TileType) EditorGUILayout.EnumPopup("Base Frame", ttype);
if (ttype != tempType)
OnSelectionChange();
int tempInt = pivotX;
pivotX = EditorGUILayout.IntField("Pivot X", pivotX);
if (pivotX != tempInt)
OnSelectionChange();
tempInt = pivotY;
pivotY = EditorGUILayout.IntField("Pivot Y", pivotY);
if (pivotY != tempInt)
OnSelectionChange();
EditorGUILayout.Popup(0, new string[] {"New Category", "Brick"});
categoryName = EditorGUILayout.TextField("Category Name", categoryName);
if (GUILayout.Button("add to library")) {
OnClickAdd();
}
GUILayout.EndVertical();
GUILayout.Box(mixed);
GUILayout.EndHorizontal();
}
//Activates the tile's fruit.
public void SetFruit()
{
fruitObject.SetActive(true);
type = TileType.Fruit;
}
public static BoardTile FindTile(TileType Type, int TileID)
{
return(AllTiles.First(i => i.Type == Type && i.boardID == TileID));
}
public Tile(TileType type, int idx, Vector3 pos) : this((int)type, idx, pos)
{
}
public void SetTile(TileType tileType)
{
Type = tileType;
SetTexture(Type);
}
public Tile(TileType new_tile_type)
{
this.mType = new_tile_type;
}
public TilePosTuple(Point pos, TileType type)
{
this.Pos = pos;
this.TileType = type;
}
public TileProperties(TileType tileProp)
{
this.tileIdentity = tileProp;
}
public GridTile(Room pRoom, int pX, int pY, TileType pType) : base(pRoom, pX, pY, pType)
{
}
public void SetMode_Bulldoze()
{
buildModeIsObjects = false;
buildModeTile = TileType.Empty;
}
public void SetTile(int x, int y, TileType type)
{
_cells[x + y * Width] = type;
}
public void SetMode_BuildRock()
{
buildModeIsObjects = false;
buildModeTile = TileType.Rock;
}
public TileClass(Vector3Int _pos, TileType _type = TileType.None, bool _enabled = true)
{
position = _pos;
type = _type;
enabled = _enabled;
}
public static LayerTile GetTile(TileType tileType, string key)
{
return(tiles[tileType, key]);
}
public void SetMode_BuildFloor()
{
buildModeIsObjects = false;
buildModeTile = TileType.Floor;
}
public void Start()
{
//Adds special tiles
SpecialTiles.Add(0);
SpecialTiles.Add(5);
//Adds Accepted tiles
for (int TileCount = 0; TileCount < 6; TileCount++)
{
AcceptedTiles.Add(TileCount, new List <int>());
AcceptedTiles[TileCount].Add(TileCount);
}
AcceptedTiles[3].Add(2);
AcceptedTiles[3].Add(5);
//Creates list of blank tile infomation then adds it all.
for (int i = 0; i < TileInfo.Length; i++)
{
TileInfo[i] = new TileType();
}
TileInfo[0].Name = "Grass";
TileInfo[0].FertilityMax = 1f;
TileInfo[0].FertilityMin = 0.2f;
TileInfo[0].MetalMax = 0.6f;
TileInfo[0].MetalMin = 0.1f;
TileInfo[0].StoneMax = 0.6f;
TileInfo[0].StoneMin = 0.1f;
TileInfo[0].WaterMax = 0.6f;
TileInfo[0].WaterMin = 0.1f;
TileInfo[0].WoodMax = 0.4f;
TileInfo[0].WoodMin = 0.0f;
TileInfo[1].Name = "Stone";
TileInfo[1].FertilityMax = 0.2f;
TileInfo[1].FertilityMin = 0.0f;
TileInfo[1].MetalMax = 1f;
TileInfo[1].MetalMin = 0.6f;
TileInfo[1].StoneMax = 1f;
TileInfo[1].StoneMin = 0.8f;
TileInfo[1].WaterMax = 0.3f;
TileInfo[1].WaterMin = 0.0f;
TileInfo[1].WoodMax = 0.2f;
TileInfo[1].WoodMin = 0.0f;
TileInfo[2].Name = "Water";
TileInfo[2].FertilityMax = 0.1f;
TileInfo[2].FertilityMin = 0.0f;
TileInfo[2].MetalMax = 0.2f;
TileInfo[2].MetalMin = 0.0f;
TileInfo[2].StoneMax = 0.0f;
TileInfo[2].StoneMin = 0.0f;
TileInfo[2].WaterMax = 1f;
TileInfo[2].WaterMin = 1f;
TileInfo[2].WoodMax = 0.2f;
TileInfo[2].WoodMin = 0.0f;
TileInfo[3].Name = "Sand";
TileInfo[3].FertilityMax = 0.1f;
TileInfo[3].FertilityMin = 0.0f;
TileInfo[3].MetalMax = 0.2f;
TileInfo[3].MetalMin = 0.0f;
TileInfo[3].StoneMax = 0.6f;
TileInfo[3].StoneMin = 0.0f;
TileInfo[3].WaterMax = 0.7f;
TileInfo[3].WaterMin = 0.5f;
TileInfo[3].WoodMax = 0.2f;
TileInfo[3].WoodMin = 0.0f;
TileInfo[4].Name = "Woodland";
TileInfo[4].FertilityMax = 1f;
TileInfo[4].FertilityMin = 0.5f;
TileInfo[4].MetalMax = 0.4f;
TileInfo[4].MetalMin = 0.2f;
TileInfo[4].StoneMax = 0.6f;
TileInfo[4].StoneMin = 0.3f;
TileInfo[4].WaterMax = 0.6f;
TileInfo[4].WaterMin = 0.1f;
TileInfo[4].WoodMax = 1f;
TileInfo[4].WoodMin = 0.7f;
TileInfo[5].Name = "Sea";
TileInfo[5].FertilityMax = 0.1f;
TileInfo[5].FertilityMin = 0.0f;
TileInfo[5].MetalMax = 0.2f;
TileInfo[5].MetalMin = 0.0f;
TileInfo[5].StoneMax = 0.0f;
TileInfo[5].StoneMin = 0.0f;
TileInfo[5].WaterMax = 1f;
TileInfo[5].WaterMin = 1f;
TileInfo[5].WoodMax = 0.2f;
TileInfo[5].WoodMin = 0.0f;
}
public void SetMode_BuildTree()
{
buildModeIsObjects = false;
buildModeTile = TileType.Tree;
}
private void DrawTile(Location location, TileType tile)
{
var roadDefinition = roadTileInitializer.GetRoadDefinitions(tile);
Instantiate(roadDefinition, location.Visual);
}
public static string Get(TileType type)
{
return(paths.ContainsKey(type) ? paths[type] : null);
}
public static bool AreSameBaseTileType(TileType tileTypeA, TileType tileTypeB)
{
return(Tile.BaseTileType(tileTypeA) == Tile.BaseTileType(tileTypeB));
}
public bool IsPartOfTask(TileType _tileType, TileTypeTag _tileTypeTag)
{
return(tileType == _tileType && tileTypeTag == _tileTypeTag);
}
public static string BaseTileType(TileType tileType)
{
return(Regex.Match(tileType.ToString(), @"[a-zA-z]+").Value);
}
private void AddLogicalTile(Location location, TileType tile)
{
tileTypes[location.Logical] = tile;
}
public Tile(TileType tileType, int x, int y, Grid grid, int cost = 0, bool isAdvancing = false, TileType advancingType = TileType.Dirt, float cycleTime = 0)
{
this.TileType = tileType;
this.X = x;
this.Y = y;
this.Grid = grid;
this.Cost = cost;
this.IsAdvancing = isAdvancing;
this.AdvancingType = advancingType;
this.CycleTime = cycleTime;
}
public static int GetTileTypeLevel(TileType tileType)
{
var r = Regex.Match(tileType.ToString(), @"[0-9]$");
return(r.Success ? int.Parse(r.Value) : 0);
}
public Tile(uint x, uint y, TileType type)
{
X = x;
Y = y;
Type = type;
}
public static Tile CreateTile(TileType tileType, int x, int y, Grid grid, bool isAdvancing = false, TileType advancingType = TileType.Dirt, float cycleTime = 0)
{
Tile tile;
switch (tileType)
{
case TileType.Dirt:
tile = new DirtTile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Grass:
tile = new GrassTile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Field:
tile = new FieldTile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Construct:
tile = new ConstructTile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Blueberry1:
tile = new Blueberry1Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Blueberry2:
tile = new Blueberry2Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Blueberry3:
tile = new Blueberry3Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Carrot1:
tile = new Carrot1Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Carrot2:
tile = new Carrot2Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Carrot3:
tile = new Carrot3Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Potato1:
tile = new Potato1Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Potato2:
tile = new Potato2Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Potato3:
tile = new Potato3Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Strawberry1:
tile = new Strawberry1Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Strawberry2:
tile = new Strawberry2Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Strawberry3:
tile = new Strawberry3Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Wheat1:
tile = new Wheat1Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Wheat2:
tile = new Wheat2Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Wheat3:
tile = new Wheat3Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
case TileType.Greenhouse1:
tile = new Greenhouse1Tile(x, y, grid, isAdvancing, advancingType, cycleTime);
break;
default:
throw new ArgumentOutOfRangeException(nameof(tileType));
}
return(tile);
}
private void InitializeTile(TileType type, int x, int y)
{
string resourceName;
switch (type)
{
case TileType.GROUND:
resourceName = "ground";
break;
case TileType.SOLID_WALL:
resourceName = "wall";
break;
case TileType.BREAK_BLOCK:
resourceName = "vase";
break;
case TileType.BREAK_START:
resourceName = "ground";
var breaker = Resources.Load("Actors/breaker");
breakerObj = Instantiate(breaker,
BasePosition + new Vector3(tileLength * x - tileLength / 2f, 2.4f, tileLength * y - tileLength / 2f),
Quaternion.identity) as GameObject;
Breaker = breakerObj.GetComponent <Breaker>();
Breaker.Initialize(mapManager, new Position(x, y));
break;
case TileType.FIX_BLOCK:
resourceName = "crate_broken";
break;
case TileType.FIX_START:
resourceName = "ground";
var fixer = Resources.Load("Actors/fixer");
fixerObj = Instantiate(fixer,
BasePosition + new Vector3(tileLength * x - tileLength / 2f, 2.4f, tileLength * y - tileLength / 2f),
Quaternion.identity) as GameObject;
Fixer = fixerObj.GetComponent <Fixer>();
Fixer.Initialize(mapManager, new Position(x, y));
break;
case TileType.BOTH_ACT_BLOCK:
resourceName = "crate";
break;
case TileType.BUTTON:
resourceName = "button";
break;
case TileType.DOOR:
resourceName = "door";
break;
case TileType.HOLE:
resourceName = "hole";
break;
case TileType.BREAK_EXIT:
resourceName = "break_exit";
break;
case TileType.FIX_EXIT:
resourceName = "fix_exit";
break;
case TileType.EXIT_BOTH:
resourceName = "exit_both";
break;
default:
return;
}
try
{
if (resourceName == "ground")
{
resourceName += rand.Next(1, 4);
}
var tileObject = Instantiate(Resources.Load(BasePath + resourceName),
BasePosition + new Vector3(tileLength * x, 0, tileLength * y),
Quaternion.identity);
var tileReference = tileObject as GameObject;
var tile = tileReference.GetComponent <Tile>();
tileMap[x, y] = tile;
gameObjects.Add(tileReference);
}
catch (Exception ex)
{
Debug.LogError(ex.Message);
var tileObject = Instantiate(Resources.Load(BasePath + "ground" + rand.Next(1, 5)),
BasePosition + new Vector3(tileLength * x, 0, tileLength * y),
Quaternion.identity);
var tile = (tileObject as GameObject).GetComponent <Tile>();
tileMap[x, y] = tile;
}
}
//Sets the tile as empty.
public void SetEmpty()
{
ClearTile();
type = TileType.Empty;
}
/// <summary>
/// If one of the 8 neighbouring tiles is of TileType type then this returns true.
/// </summary>
public bool HasNeighboursOfType(TileType tileType)
{
return(GetNeighbours(true).Any(tile => (tile != null && tile.Type == tileType)));
}
private Vector3 PickRandomPosition(TileType type = TileType.Grass)
{
Vector3 randomTilePos = board.GetRandomTile(type).transform.position;
return(new Vector3(randomTilePos.x, 0, randomTilePos.z));
}
public TileType[,] Read(TextAsset file, int xSize, int ySize)
{
StringReader reader = new StringReader(file.text);
TileType[,] ttmap = new TileType[xSize, ySize];
if (reader == null)
{
print ("read failed");
return null;
}
else
{
int x = 0;
int y = ySize - 1;
for (string line = reader.ReadLine(); line != null; line = reader.ReadLine())
{
//PrintMapLine(line, row);
x = 0;
foreach(char c in line)
{
//print ("" + x + " " + y);
ttmap[x,y] = ConvertToTileTypeFromChar(c, x, y);
x++;
}
y--;
}
return ttmap;
}
}
