public TileDat getTileAtPosition(Vector2 Position, bool makeDirty = false) { // Get the position in the array of tiles. int pos = this.vectorToArrayPosition(Position); bool outsideRange = false; // end of the chunk if (Position.x < 0 || Position.y < 0 || Position.x >= this.chunkSize || Position.y >= this.chunkSize) { outsideRange = true; } if (pos >= this.tiles.Capacity || pos < 0 || outsideRange) { // Anti recursion check, catches invalid 'states' if (this.fetchTileInProgress) { // bail! < TODO return default dat TileDat transparent = new TileDat(); transparent.tile = new Tile(); transparent.tile.prop = TilePropType.prop_air; this.fetchTileInProgress = false; return(transparent); } // try and fetch from parent! slow af, mark fetch to handle fail state this.fetchTileInProgress = true; return(this.parent.getParent().getTileAtPosition((Vector2)this.position + Position, (LayerType)this.parent.LayerType, makeDirty)); this.fetchTileInProgress = false; } return(this.tiles[pos]); }
public void setTile(Vector2 Position, Tile Tile) { int pos = this.vectorToArrayPosition(Position); bool outsideRange = false; // end of the chunk if (Position.x < 0 || Position.y < 0 || Position.x >= this.chunkSize || Position.y >= this.chunkSize) { outsideRange = true; } if (pos >= this.tiles.Capacity || pos < 0 || outsideRange) { // Anti recursion check, catches invalid 'states' if (this.fetchTileInProgress) { // bail! < do nothing return; } this.fetchTileInProgress = true; this.parent.getParent().setTile((Vector2)this.position + Position, Tile); this.fetchTileInProgress = false; return; } // Call on destroy for behaviours foreach (TileBehaviour behaviour in this.tiles[pos].tile.behaviours) { behaviour.onDestroy(this.tiles[pos]); } // Get the tile data object. TileDat tileData = this.tiles[pos]; tileData.flags = 0; tileData.tile = Tile; updateAjacentTiles(Position); // Call on init for behaviours foreach (TileBehaviour behaviour in Tile.behaviours) { behaviour.onInit(tileData); } // set the buffer dirty. this.isDirty = true; }
public void init() { float chunkOrigin = this.chunkSize * 0.5f; float unitScale = this.Parent.getParent().tileUnitSize; this.mesh = new Mesh(); this.geometry = new GameObject("TileChunk"); this.geometry.transform.parent = this.parent.gameObject.transform; this.geometry.transform.position = this.position + new Vector3(chunkOrigin * unitScale, chunkOrigin * unitScale, 0); this.geometry.transform.localScale = Vector3.one * unitScale; this.meshRenderer = this.geometry.AddComponent <MeshRenderer>(); this.meshFilter = this.geometry.AddComponent <MeshFilter>(); this.meshRenderer.material = this.parent.getParent().textureMap.getTextureForID(0).material; int chunkOffset = -(int)this.chunkSize / 2; // Add row by row for (int y = 0; y < this.chunkSize; ++y) { for (int x = 0; x < this.chunkSize; ++x) { // Create a new tile TileDat tileToAdd = new TileDat(); // Parents layer parent is the tile map itself, default use first tile in map, which is air! tileToAdd.tile = this.parent.getParent().getTile(0); tileToAdd.parent = this; // tiles are offset by chunk offset, so the gameobjects center is in the center of the chunk tileToAdd.position = new Vector3(x + chunkOffset, y + chunkOffset, 0) + this.geometry.transform.position; tiles.Add(tileToAdd); } } // updates enture tile layer! updateAjacentTiles(); // Call init on all tiles in the map! foreach (TileDat Tile in tiles) { foreach (TileBehaviour behaviour in Tile.tile.behaviours) { behaviour.onInit(Tile); } } }
void updateAjacentTiles(Vector2 Position) { // Optimise this don't do a parent fetch if we know it is in bounds todo < will make call alot faster most the time TileDat current = this.getTileAtPosition(Position); TileDat up = this.getTileAtPosition(Position + Vector2.up); TileDat down = this.getTileAtPosition(Position - Vector2.up); TileDat right = this.getTileAtPosition(Position + Vector2.right); TileDat left = this.getTileAtPosition(Position - Vector2.right); current.left = left; current.right = right; current.up = up; current.down = down; down.up = current; up.down = current; left.right = current; right.left = current; }
// returns a reference, get triggers the buffer to be marked as dirty? public TileDat getTileAtPosition(Vector2 Position, LayerType layer, bool dirtyBuffer = false) { // Work out which chunk the tile resides in, loses float precision however should be caught by out of range guard, regardless. uint chunkX = ((uint)Position.x / this.chunkSize); uint chunkY = ((uint)Position.y / this.chunkSize); // Optimise precalculate this uint _chunkDimensionXZ = this.dimensions / this.chunkSize; uint pos = (chunkX) + (chunkY * _chunkDimensionXZ); // Normalise the position to make relative to parent chunk. Vector2 normalisedPosition = Position - new Vector2(chunkX * this.chunkSize, chunkY * this.chunkSize); bool outOfRange = false; if (Position.x < 0 || Position.y < 0 || Position.x >= this.dimensions || Position.y >= this.dimensions) { outOfRange = true; } List <TileChunk> chunks = this.layers[(int)layer].getChunks(); if (pos > chunks.Count - 1 || outOfRange || pos < 0) { TileDat transparent = new TileDat(); transparent.tile = new Tile(); transparent.tile.prop = TilePropType.prop_air; return(transparent); } // Set the buffer dirty if (dirtyBuffer) { chunks[(int)pos].setDirty(); } return(chunks[(int)pos].getTileAtPosition(normalisedPosition)); }
/// <summary> /// Called by the tile system when a Tool is used on a tile /// </summary> /// <param name="Tile"> Tile that is being used. </param> /// <param name="Tool"> Tool that is being used </param> public virtual void onUse(TileDat Tile, Tool Tool) { }
// Examples below havent been thought out and may be subject to change /// <summary> /// Called by the tile system when a Tool is hit on a tile /// </summary> /// <param name="Tile"> Tile that is being hit. </param> /// <param name="Tool"> Tool thats is doing the hitting </param> public virtual void onHit(TileDat Tile, Tool Tool) { }
/// <summary> /// Called by the tile system every X ticks /// </summary> /// <param name="Tile"> The Tile it is operating on is passed into the update method. </param> public virtual void onUpdate(TileDat Tile, float fDelta) { }
/// <summary> /// Called by the tile system every X ticks /// </summary> /// <param name="Tile"> The Tile it is operating on is passed into the update method. </param> public virtual void onUpdate(TileDat Tile) { }
/// <summary> /// Called when the tile is removed from the map /// </summary> public virtual void onDestroy(TileDat Tile) { }
/// <summary> /// Called when the tile is added to the map! /// </summary> /// <param name="Tile"></param> public virtual void onInit(TileDat Tile) { }
void renderPass(RenderFlags RenderPass) { // Calculate vertex buffer size. 6 per face uint vertexBufferSize = 6 * (this.chunkSize * this.chunkSize); List <Vector3> vertices = new List <Vector3>(); List <Vector2> uvs = new List <Vector2>(); List <Vector3> normals = new List <Vector3>(); int vertexOffset = 0; int chunkOffset = -(int)this.chunkSize / 2; for (int x = 0; x < this.chunkSize; ++x) { for (int y = 0; y < this.chunkSize; ++y) { int z = 0; // Tile were rendering TileDat tile = this[x, y]; // DON'T render air -> this should be figured out earlier then pushed to be rendered or simplified if (!tile.tile.rendered || tile.tile.prop == TilePropType.prop_air || tile.tile.prop == TilePropType.prop_vacumn) { continue; } // Used to determine the vertex offset & whether we need to add to the sort list ( not used ) byte _offset = 0; // Back vertices.Add(new Vector3(x + chunkOffset, y + chunkOffset, z)); vertices.Add(new Vector3(x + chunkOffset, y + chunkOffset + 1, z)); vertices.Add(new Vector3(x + chunkOffset + 1, y + chunkOffset + 1, z)); vertices.Add(new Vector3(x + chunkOffset, y + chunkOffset, z)); vertices.Add(new Vector3(x + chunkOffset + 1, y + chunkOffset + 1, z)); vertices.Add(new Vector3(x + chunkOffset + 1, y + chunkOffset, z)); uvs.Add(tile.tile.material.textureCoords[0]); uvs.Add(tile.tile.material.textureCoords[1]); uvs.Add(tile.tile.material.textureCoords[2]); uvs.Add(tile.tile.material.textureCoords[0]); uvs.Add(tile.tile.material.textureCoords[2]); uvs.Add(tile.tile.material.textureCoords[3]); normals.Add(Vector3.forward); normals.Add(Vector3.forward); normals.Add(Vector3.forward); normals.Add(Vector3.forward); normals.Add(Vector3.forward); normals.Add(Vector3.forward); _offset += 6; vertexOffset += _offset; } } int[] triangles = new int[vertexOffset]; for (int i = 0; i < vertexOffset; ++i) { triangles[i] = i; } this.mesh.vertices = vertices.ToArray(); this.mesh.uv = uvs.ToArray(); //this.mesh.triangles = triangles; this.mesh.SetTriangles(triangles, 0, false); this.mesh.normals = normals.ToArray(); }