public override bool CheckTileValidity(Vector2 pTileWorldPos) { if (CheckTileNotOccupied(pTileWorldPos) == false) { return(false); } STETilemap affectedLayer = GetTileAffectedLayer(pTileWorldPos); if (affectedLayer == null) { return(false); } STETilemap lowerLayer = GetLowerLayer(affectedLayer); if (lowerLayer == null) { return(false); } uint rawTileData = GetTileData(pTileWorldPos, lowerLayer); TileData tileData = new TileData(rawTileData); if (tileData.tileId == 65535) { return(false); } return(true); }
void Start() { subsets = new List <List <TileBehaviour> > (); tilemap = GameObject.Find("Grid").GetComponent <STETilemap>(); SetMatrix(); SetInteractuables(); }
protected void DoColorPaintAction() { var go = Fsm.GetOwnerDefaultTarget(gameObject); if (UpdateCache(go)) { STETilemap tilemap = cachedComponent as STETilemap; Vector2 center; if ((ePositionType)positionType.Value == ePositionType.LocalPosition) { center = position.Value; } else// if ((ePositionType)positionType.Value == ePositionType.GridPosition) { center = TilemapUtils.GetTileCenterPosition(tilemap, (int)position.Value.x, (int)position.Value.y); } if (applyToTilemapGroup.Value && tilemap.ParentTilemapGroup) { tilemap.ParentTilemapGroup.IterateTilemapWithAction( (STETilemap tmap) => { TilemapVertexPaintUtils.VertexPaintCircle(tmap, center, radius.Value, tileColor.Value, (eBlendMode)blendingMode.Value, (eTileColorPaintMode)tileColorPaintMode.Value == eTileColorPaintMode.Vertex, intensityCurve.curve); tmap.UpdateMesh(); } ); } else { TilemapVertexPaintUtils.VertexPaintCircle(tilemap, center, radius.Value, tileColor.Value, (eBlendMode)blendingMode.Value, (eTileColorPaintMode)tileColorPaintMode.Value == eTileColorPaintMode.Vertex, intensityCurve.curve); tilemap.UpdateMesh(); } } }
protected override void DrawDebugPoints() { if (m_debugPoints.Count == 0) { return; } STETilemap tilemap = GetTargetTilemap(); Vector2 cellSizeDiv2 = tilemap.CellSize / 2f; Vector2 realCellSizeDiv2 = tilemap.transform.TransformPoint(cellSizeDiv2); float size = Mathf.Min(realCellSizeDiv2.x, realCellSizeDiv2.y); Vector2 s0 = m_action.startPaintingPosition.Value; Vector2 s1 = m_action.endPaintingPosition.Value; Vector2 dir0 = s1 - s0; Vector2 dir1 = m_debugPoints[m_debugPoints.Count - 1] - m_debugPoints[0]; int idx = Mathf.Sign(dir0.x) != Mathf.Sign(dir1.x) || Mathf.Sign(dir0.y) != Mathf.Sign(dir1.y) ? m_debugPoints.Count - 1 : 0; Vector2 c0 = tilemap.transform.TransformPoint(m_debugPoints[idx]); for (int i = 0; i < m_debugPoints.Count; ++i) { Vector2 p0 = tilemap.transform.TransformPoint(m_debugPoints[i]); EditorCompatibilityUtils.CircleCap(0, p0, Quaternion.identity, size); //Handles.Label(p0, i.ToString()); if (i != idx) { EditorCompatibilityUtils.CircleCap(0, 2 * c0 - p0, Quaternion.identity, size); } } }
private void Awake() { if (thisTilemap == null) { thisTilemap = GetComponent <STETilemap>(); } }
public override void OnEnter() { var go = Fsm.GetOwnerDefaultTarget(gameObject); Tile tile = null; if (UpdateCache(go)) { STETilemap tilemap = cachedComponent as STETilemap; if ((ePositionType)positionType.Value == ePositionType.LocalPosition) { tile = tilemap.GetTile(position.Value); } else// if ((ePositionType)positionType.Value == ePositionType.GridPosition) { tile = tilemap.GetTile((int)position.Value.x, (int)position.Value.y); } if (tile == null) { parameterValue.Value = defaultValue.Value; } else { parameterValue.Value = tile.paramContainer.GetObjectParam(parameterName.Value, defaultValue.Value); } } Finish(); }
protected virtual void RecalculateDebugPoints(Vector2 startPoint, Vector2 endPoint, DrawingFunction drawingFunc) { STETilemap tilemap = GetTargetTilemap(); if (!tilemap) { return; } Vector2 cellSizeDiv2 = tilemap.CellSize / 2f; m_debugPoints.Clear(); int x0, y0, x1, y1; if ((ePositionType)m_action.positionType.Value == ePositionType.LocalPosition) { x0 = TilemapUtils.GetGridX(tilemap, startPoint); y0 = TilemapUtils.GetGridY(tilemap, startPoint); x1 = TilemapUtils.GetGridX(tilemap, endPoint); y1 = TilemapUtils.GetGridY(tilemap, endPoint); } else //if ((ePositionType)m_action.positionType.Value == ePositionType.GridPosition) { x0 = (int)startPoint.x; y0 = (int)startPoint.y; x1 = (int)endPoint.x; y1 = (int)endPoint.y; } drawingFunc(x0, y0, x1, y1, (x, y) => { m_debugPoints.Add(new Vector2(x * tilemap.CellSize.x + cellSizeDiv2.x, y * tilemap.CellSize.y + cellSizeDiv2.y)); return(true); }); }
public SpaceShipEnvironmentTicker(TilemapGroup shipTilemapGroup) { _doodadsBackgroundTilemap = shipTilemapGroup.Tilemaps.First(tilemap => tilemap.name == "DoodadsBackground"); _shipBackgroundTilemap = shipTilemapGroup.Tilemaps.First(tilemap => tilemap.name == "ShipBackground"); SetDirtiableTiles(); }
void OnEnable() { OccupiedLayer = GameObject.FindWithTag("Occupied Tiles").GetComponent <STETilemap>(); if (OccupyOnStart) { OccupyTiles(); } }
//Assign references attached to this object and generate the level upon initialisation private void Start() { drunkManWalking = GetComponent <PCG.DrunkManWalking>(); tileMap = GetComponent <STETilemap>(); tileSize = tileMap.CellSize.x; GenerateLevel(); }
public static void MakeMaterialInstancedIfNecessary(STETilemap tileMap) { // TODO: this feels kidn of kludgey if (!tileMap.Material.name.Contains("Instance")) { tileMap.Material = new Material(tileMap.Material); } }
private void SetMaterialDistance(STETilemap actualTilemap, float distance) { if (mReverse) { distance = -distance; } actualTilemap.Material.SetFloat("_Distance", distance); }
public void OnTilePrefabCreation(TilemapChunk.OnTilePrefabCreationData data) { Debug.Assert(data.ParentTilemap.name.Equals("DoodadsBackground"), "Captains chair must be on DoodadsBackground"); LeftTilePosition = new Vector2(data.GridX, data.GridY); RightTilePosition = new Vector2(data.GridX + 1, data.GridY); DoodadsForeground = data.ParentTilemap.ParentTilemapGroup.FindTilemapByName("DoodadsForeground"); DoodadsBackground = data.ParentTilemap.ParentTilemapGroup.FindTilemapByName("DoodadsBackground"); gameObject.name = $"CptnChair\n{LeftTilePosition}"; }
private void Start() { if (SceneManager.GetActiveScene().buildIndex != 0) { StartCoroutine(SetUpBlink()); } StartCoroutine(EnableJump()); // Change this pls tilemap = FindObjectOfType <STETilemap>(); }
public void GenerateBackgroundTilemap(STETilemap existingTilemap) { //Clear the current background tilemap thisTilemap.ClearMap(); //If background type chosen is perlin, run the perlin background generation functionality if (backgroundType == BackgroundType.perlin) { //random seed for variation float rand = Random.Range(0f, 999999f); //Loop through and assign tiles based on whether their perlin value at the given tile (with the seed/scale taken into account) is above a set threshold //If its above the threshold, set it as a tile, if not, leave it blank //This leads to organic and natural looking curves of tiles and a nice looking randomised background for (int x = 0; x < existingTilemap.GridWidth; x++) { for (int y = 0; y < existingTilemap.GridHeight; y++) { float xCoord = rand + (float)x / (float)existingTilemap.GridWidth * perlinScale; float yCoord = rand + (float)y / (float)existingTilemap.GridHeight * perlinScale; float p = Mathf.PerlinNoise(xCoord, yCoord); if (p > perlinThreshold) { thisTilemap.SetTile(x, y, 0, brushId, eTileFlags.None); } } } } //If the background mode is set from the main map, set any tile behind a foreground tile to a rubbly/destroyed tile, and the rest to regular background tiles else if (backgroundType == BackgroundType.fromMainMap) { for (int x = 0; x < existingTilemap.GridWidth; x++) { for (int y = 0; y < existingTilemap.GridHeight; y++) { uint raw = existingTilemap.GetTileData(x, y); TileData processed = new TileData(raw); if (processed.tileId != 65535) { thisTilemap.SetTile(x, y, 0, brushId, eTileFlags.None); } else { thisTilemap.SetTile(x, y, 0, brushId, eTileFlags.None); } } } } //Update the background mesh after all generation is complete thisTilemap.UpdateMesh(); }
void OnTileChanged(STETilemap tilemap, int gridX, int gridY, uint tileData) { //Find chunk var chunk = FindChunk(gridX, gridY); if (chunk != null) { var collider = UpdateCollider(chunk); collider.DirtyCollider(); } }
public static void DeserializeTilemap(TilemapSerializedData data, STETilemap tilemap) { foreach (TilemapSerializedData.TileData dataItem in data.tileDataList) { tilemap.SetTileData(dataItem.gridX, dataItem.gridY, dataItem.tileData); // NOT SURE ABOUT THIS LINE. } tilemap.UpdateMesh(); //TilemapUtils.IterateTilemapWithAction(tilemap, action); //return data; }
protected void DoColorPaintAction() { var go = Fsm.GetOwnerDefaultTarget(gameObject); if (UpdateCache(go)) { STETilemap tilemap = cachedComponent as STETilemap; tilemap.RemoveColorChannel(); tilemap.UpdateMesh(); } }
public override void OnEnter() { var go = Fsm.GetOwnerDefaultTarget(gameObject); if (UpdateCache(go)) { STETilemap tilemap = cachedComponent as STETilemap; tilemap.Refresh(refreshRenderMesh.Value, refreshColliderMesh.Value, refreshTileObjects.Value, invalidateBrushes.Value); } Finish(); }
// RecordData() is called when saving. It returns a string representation of the save data. public override string RecordData() { STETilemap tilemap = GetComponent <STETilemap>(); if (tilemap == null) { return(string.Empty); } TilemapSerializedData data = SerializeTilemap(tilemap); return(SaveSystem.Serialize(data)); }
public override void OnEnter() { var go = Fsm.GetOwnerDefaultTarget(gameObject); if (UpdateCache(go)) { STETilemap tilemap = cachedComponent as STETilemap; tilemap.TintColor = tintColor.Value; } Finish(); }
// Start is called before the first frame update private void Start() { Debug.Assert(ParentTilemapGroup != null); _currentCapacity = DefaultRoombaCapacity; navMeshAgent2D = GetComponent <NavMeshAgent2D>(); _doodadsBackgroundTilemap = ParentTilemapGroup.Tilemaps.First(tilemap => tilemap.name == "DoodadsBackground"); _doodadsForegroundTilemap = ParentTilemapGroup.Tilemaps.First(tilemap => tilemap.name == "DoodadsForeground"); Debug.Assert(_doodadsBackgroundTilemap != null); Debug.Assert(_doodadsForegroundTilemap != null); }
public override void OnEnter() { var go = Fsm.GetOwnerDefaultTarget(gameObject); if (UpdateCache(go)) { STETilemap tilemap = cachedComponent as STETilemap; tilemap.ColliderType = eColliderType.None; tilemap.Refresh(false, true); } Finish(); }
public static TilemapSerializedData SerializeTilemap(STETilemap tilemap) { TilemapSerializedData data = new TilemapSerializedData(); System.Action <STETilemap, int, int, uint> action = (tmap, gridX, gridY, tileData) => { data.tileDataList.Add(new TilemapSerializedData.TileData() { gridX = gridX, gridY = gridY, tileData = tileData }); }; TilemapUtils.IterateTilemapWithAction(tilemap, action); return(data); }
private void LoadMap(int mapIndex) { // Load Objects var map = Maps[mapIndex]; // Create objs Transform obj; foreach (var item in map.NormalObjs) _mapPool.Spawn(item.Prefab, item.Position, Quaternion.identity); // Create platform foreach (var item in map.Platforms) { obj = _mapPool.Spawn(item.Prefab); obj.GetComponent<Platform>().Init(item); } // Load tile ground _tileMap = _mapPool.Spawn(TileGrounds[mapIndex]).GetChild(0).GetComponent<STETilemap>(); SetBounds(); // Load background Transform bgContain = transform.Find("Background"); SpriteRenderer render; foreach (var bg in map.Bgs) { obj = _bgPool.Spawn(BgPrefab, bgContain); obj.position = bg.Position; render = obj.GetComponent<SpriteRenderer>(); render.sprite = bg.Sprite; render.sortingOrder = bg.Order; render.sortingLayerName = bg.LayerName; render.drawMode = bg.DrawMode; render.size = bg.Size; #if UNITY_EDITOR render.name = render.sprite.name; #endif obj.localScale = bg.Scale; } // Load pipe foreach (var pipe in map.PipeObjs) { obj = _mapPool.Spawn(pipe.Prefab, pipe.Position, pipe.Rotation); obj.GetComponent<Pipe>().Init(pipe); } }
public override bool OnGUI() { if (!m_tilemap) { m_tilemap = GetTargetTilemap(); } bool isDirty = DrawDefaultInspector(); if (isDirty && !m_tilemap) { m_tileset = GuessTileset(); } return(isDirty); }
public override void OnEnter() { var go = Fsm.GetOwnerDefaultTarget(gameObject); if (UpdateCache(go)) { STETilemap tilemap = cachedComponent as STETilemap; tilemap.ColliderType = eColliderType._2D; tilemap.Collider2DType = (e2DColliderType)collider2DType.Value; tilemap.PhysicMaterial2D = physicMaterial2D.Value as PhysicsMaterial2D; tilemap.IsTrigger = isTrigger.Value; tilemap.Refresh(false, true); } Finish(); }
bool CheckTileNotOccupied(Vector2 pTileWorldPos) { STETilemap occupiedLayer = GameObject.FindGameObjectWithTag("Occupied Tiles").GetComponent <STETilemap>(); uint rawTileData = GetTileData(pTileWorldPos, occupiedLayer); TileData tileData = new TileData(rawTileData); //if tile is already occupied if (tileData.tileId != 65535) { return(false); } else { return(true); } }
public override bool CheckTileValidity(Vector2 pTileWorldPos) { FarmPlot plot = GetPlot(pTileWorldPos); if (CheckTileNotOccupied(pTileWorldPos) == false && plot == null || plot != null && plot.Crop == null) { return(false); } STETilemap affectedLayer = GetTileAffectedLayer(pTileWorldPos); if (affectedLayer == null && plot == null) { return(false); } return(true); }
public override void OnEnter() { var go = Fsm.GetOwnerDefaultTarget(gameObject); if (UpdateCache(go)) { STETilemap tilemap = cachedComponent as STETilemap; tilemap.CellSize = cellSize.Value; if (refreshTilemap.Value) { tilemap.Refresh(); } } Finish(); }