public override void Execute(TileManager tileManager, Tile tile, TilePosition center) { for (int d = 1; d <= radius; d++) { int rDamage = damage * (radius - d + 1) / radius; TilePosition[] tiles = Manhattan.GetTilesAtDistance(d); for(int i = 0; i < tiles.Length; i++) { TilePosition p = center + tiles[i]; if (tileManager.IsValidTile(p)) if (tileManager.DamageTile(p, rDamage) == false) if (setOnFire && tileManager.GetTileDefinition(tileManager.GetTileType(p)).burns) tileManager.SetTileOnFire(p, true); } } if (setOnFire) { TilePosition[] tiles = Manhattan.GetTilesAtDistance(radius + 1); for(int i = 0; i < tiles.Length; i++) { TilePosition p = center + tiles[i]; if (tileManager.IsValidTile(p)) if (setOnFire && tileManager.GetTileDefinition(tileManager.GetTileType(p)).burns) tileManager.SetTileOnFire(p, true); } } }
public override void Execute(TileManager tileManager, Tile tile, TilePosition pos) { pos += delta; if (tileManager.IsValidTile(pos)) tileManager.world.gameplay.CreateItem(itemDefinition, Graphics.TilePositionToVector3(pos)); }
public void Init() { // We create the first three base tiles positions suburbs_pos = new TilePosition(0, 0); park_pos = new TilePosition(0, 2); heavy_factory_pos = new TilePosition(0, 4); }
public override void Execute(TileManager tileManager, Tile tile, TilePosition pos) { pos += delta; if (tileManager.IsValidTile(pos)) tileManager.SetTileType(pos, tileType); }
public void TestEquality() { TilePosition suburbs_pos_idem = new TilePosition(0, 0); Assert.AreEqual(suburbs_pos, suburbs_pos_idem); Assert.AreNotEqual(suburbs_pos, park_pos); }
public override void Execute(TileManager tileManager, Tile tile, TilePosition pos) { pos += delta; if (tileManager.IsValidTile(pos)) tileManager.EnqueueInvalidatedTile(pos); }
public override bool Generate(CubeWorld world) { int fromY = fromYRV.EvaluateInt(world); int toY = toYRV.EvaluateInt(world); TileManager tileManager = world.tileManager; Random rnd = new Random(); for (int x = 0; x < tileManager.sizeX; x++) for (int z = 0; z < tileManager.sizeZ; z++) for (int y = fromY; y < toY; y++) { TilePosition pos = new TilePosition(x, y, z); if (tileManager.GetTileType(pos) == TileDefinition.EMPTY_TILE_TYPE) { int n = rnd.Next(0, probabilityRange); foreach (TileTypeProbability s in probabilities) { if (n < s.probability) { tileManager.SetTileType(pos, s.tileType); break; } } } } return true; }
public override void Execute(TileManager tileManager, Tile tile, TilePosition pos) { pos += delta; if (tileManager.IsValidTile(pos)) tileManager.DamageTile(pos, damage); }
public static FreePositionView InstantiateWithParent(TilePosition p_position, Transform p_parent, Player p_owner) { try { // Creation of the new instance. GameObject _new_instance = UnityEngine.Object.Instantiate (RESOURCE) as GameObject; _new_instance.transform.parent = p_parent; // Get the script associated with the new tile. FreePositionView _this = _new_instance.AddComponent<FreePositionView> (); // Set the common properties _this.m_position = p_position; _this.m_player = p_owner; if(_this.m_position != null) { // TODO Rework this Duplicate from TileView. Vector3 position = new Vector3(_this.m_position.x * 1.5f * TileView.OffsetX, 0, (_this.m_position.y + 1 ) * TileView.OffsetY); _this.transform.position = p_parent.TransformPoint(position); } else { Debug.LogError("Position for FreePositionView null !"); } return _this; } catch (Exception) { Debug.LogError ("Error while instantiating FreePosition! Prefab not found !"); return null; } }
public bool CheckConditions(TileManager tileManager, Tile tile, TilePosition pos) { if (condition != null) return condition.Validate(tileManager, tile, pos); return true; }
public void TestAssignOwner() { TileInstance instance = new TileInstance(); TilePosition position = new TilePosition(0, 0); Player player = new Player(); Assert.AreEqual(0, player.tiles.Count); instance.owner = player; instance.position = position; Assert.AreEqual(player, instance.owner); Assert.AreEqual(1, player.tiles.Count); Assert.AreEqual(true, player.tiles.Contains(instance)); // And now the other way around instance = new TileInstance(); player = new Player(); instance.position = position; Assert.AreEqual(0, player.tiles.Count); player.AddTileInstance(instance); Assert.AreEqual(player, instance.owner); Assert.AreEqual(1, player.tiles.Count); Assert.AreEqual(true, player.tiles.Contains(instance)); }
public Tile this[TilePosition p] { get { return this[p.Column, p.Row]; } }
public void removeTile(TilePosition tilePosition) { GameTile tile = tiles[tilePosition]; levelData.tiles.Remove (tile.myData); tiles.Remove (tilePosition); Destroy (tile.gameObject); }
/// <summary> /// Find the shortest path using the A* algorithm and a Euclidean distance heuristic /// </summary> public TilePath Plan(TilePosition start, TileRect end) { heap.Clear(); searchedTilesOverlay.Clear(); var startNode = heap.NodeAt(start); startNode.Predecessor = null; heap.DecreaseKey(startNode, 0, 0); var currentNode = startNode; while (!heap.IsEmpty && !end.Contains((currentNode = heap.ExtractMin()).Position)) { searchedTilesOverlay.Add(currentNode.Position); foreach (var n in currentNode.Neighbors) { float newDistanceFromStart = currentNode.DistanceFromStart // Cost so far + TilePosition.EuclideanDistance(currentNode.Position, n.Position) // Edge cost + TilePosition.EuclideanDistance(n.Position, end); // Estimated cost to end if (n.DistanceFromStart > newDistanceFromStart) { n.Predecessor = currentNode; heap.DecreaseKey(n, newDistanceFromStart, newDistanceFromStart); } } } heap.SetOverlayToComputedPath(this.computedPathOverlay, currentNode); searchedTilesOverlay.Clear(); searchedTilesOverlay.SetRect(end); if (!end.Contains(currentNode.Position)) return null; return this.MakePath(currentNode); }
public override void Load(System.IO.BinaryReader br) { base.Load(br); resetPosition = SerializationUtils.ReadTilePosition(br); inventory.Load(br); }
public Sector GetSectorTile(TilePosition pos) { pos.x >>= SECTOR_SIZE_BITS; pos.y >>= SECTOR_SIZE_BITS; pos.z >>= SECTOR_SIZE_BITS; return sectors[pos.x | (pos.y << xSectorsBits) | (pos.z << xySectorsBits)]; }
public static TilePosition ReadTilePosition(BinaryReader br) { TilePosition v = new TilePosition(); v.x = br.ReadInt32(); v.y = br.ReadInt32(); v.z = br.ReadInt32(); return v; }
public override void Execute(TileManager tileManager, Tile tile, TilePosition pos) { TileDefinition tileDefinition = tileManager.GetTileDefinition(tile.tileType); ItemDefinition itemDefinition = tileManager.world.itemManager.GetItemDefinitionById(tileDefinition.id); tileManager.world.gameplay.CreateItem(itemDefinition, Graphics.TilePositionToVector3(pos)); }
public override CubeWorld.World.Generator.GeneratorProcess Generate(CubeWorld.Configuration.Config config) { RoguelikeWorldGenerator generator = new RoguelikeWorldGenerator(world); this.playerStartPosition = generator.playerStartPosition; return world.tileManager.Generate(generator); }
public RoguelikeWorldGenerator(CubeWorld world) { playerStartPosition = new TilePosition( LEVEL_HEIGHT / 2, world.sizeY - LEVEL_HEIGHT + 3, LEVEL_HEIGHT / 2); }
public TileRuleSetDynamic(TilePosition delta, bool value, bool gravity, int timeout, TileRuleCondition condition) : base(condition) { this.delta = delta; this.value = value; this.gravity = gravity; this.timeout = timeout; }
public override bool Validate(TileManager tileManager, Tile tile, TilePosition pos) { tileManager.world.stats.checkedConditions++; pos += delta; return tileManager.IsValidTile(pos) && tileManager.GetTileType(pos) == tileType; }
public Tile this[TilePosition position] { get { return puzzleState[position.HComponent, position.VComponent];} private set { value.CurrentPosition = position; puzzleState[position.HComponent, position.VComponent] = value; } }
public override bool Validate(TileManager tileManager, Tile tile, TilePosition pos) { tileManager.world.stats.checkedConditions++; foreach (TileRuleCondition condition in conditions) if (condition.Validate(tileManager, tile, pos)) return true; return false; }
public override bool Validate(TileManager tileManager, Tile tile, TilePosition pos) { tileManager.world.stats.checkedConditions++; int amount = 0; foreach (TilePosition delta in Manhattan.GetTilesAtDistance(1)) if (tileManager.IsValidTile(pos + delta) && tileManager.GetTileType(pos + delta) == tileType) amount++; return amount >= minValue; }
public override void TileClicked(TilePosition tilePosition) { //base.TileClicked(tilePosition); client.AddAction( new MultiplayerAction(MultiplayerAction.Action.TILE_CLICKED, new String[] { tilePosition.x.ToString(), tilePosition.y.ToString(), tilePosition.z.ToString() })); }
public override void Execute(TileManager tileManager, Tile tile, TilePosition pos) { pos += delta; if (tileManager.IsValidTile(pos)) { if (tileManager.GetTileDynamic(pos)) { DynamicTile dynamicTile = tileManager.GetDynamicTile(pos); tileManager.world.fxListener.PlayEffect(effectId, dynamicTile); } } }
public override void TileHit(TilePosition tilePosition, ItemDefinition itemDefinition) { //base.TileHit(tilePosition, item); client.AddAction( new MultiplayerAction(MultiplayerAction.Action.TILE_HIT, new String[] { itemDefinition.id, tilePosition.x.ToString(), tilePosition.y.ToString(), tilePosition.z.ToString() })); }
public override void CreateTile(TilePosition tileCreatePosition, byte tileType) { //base.CreateTile(tileCreatePosition, tileType); client.AddAction( new MultiplayerAction(MultiplayerAction.Action.TILE_CREATE, new String[] { tileType.ToString(), tileCreatePosition.x.ToString(), tileCreatePosition.y.ToString(), tileCreatePosition.z.ToString() })); }
private void CreateSector(TilePosition posSector, bool inmediate) { TilePosition sectorOffset = new TilePosition(posSector.x << SECTOR_SIZE_BITS, posSector.y << SECTOR_SIZE_BITS, posSector.z << SECTOR_SIZE_BITS); Sector sector = new Sector(world, posSector, sectorOffset); sectors[posSector.x | (posSector.y << xSectorsBits) | (posSector.z << xySectorsBits)] = sector; if (inmediate == false) pendingSectorsUpdate.Add(sector); else sector.UpdateMesh(); }
private void DrawTile(Bitmap baseBitmap, TilePosition tilePos) { using (baseBitmap) { using (var tileImg = new Bitmap(TileSize.Width, TileSize.Height)) { using (var g = tileImg.GetGraphics()) { g.DrawImage(baseBitmap, new Rectangle(0, 0, TileSize.Width, TileSize.Height)); } var tilePath = Path.Combine(BasePath, tilePos.Zoom.ToString(), tilePos.X + "_" + tilePos.Z + ".png"); tileImg.SaveToFile(tilePath); //Log.InfoFormat("Saved Tile {0} to {1}", tilePos, tilePath); } } }
public void Serialize(ref TilePosition v, string fieldName) { if (serialization) { binaryWriter.Write(TYPE_TILEPOSITION); binaryWriter.Write(fieldName); binaryWriter.Write(v.x); binaryWriter.Write(v.y); binaryWriter.Write(v.z); } else { if (currentObject.ContainsKey(fieldName)) { v = (TilePosition)currentObject[fieldName]; } } }
public static void RetileMap() { tileMap = Object.FindObjectOfType <TileMap>(); tileMap.RebuildMap(); for (int row = 0; row < tileMap.MapRows; row++) { for (int column = 0; column < tileMap.MapColumns; column++) { var tilePosition = new TilePosition(column, row); var newSprite = TileSpriteAt(tilePosition); if (newSprite != null) { tileMap.SetTileSprite(tilePosition, newSprite); } } } Debug.Log("Reset background tiles."); }
public void Move(TilePosition newPosition) { MoveDefenseObjectRequestParameter request = new MoveDefenseObjectRequestParameter(); request.NewPositionRow = newPosition.Row; request.NewPositionColumn = newPosition.Column; if (this.m_Data.DefenseObjectID > 0) { request.DefenseObjectID = this.m_Data.DefenseObjectID; } else { request.OldPositionRow = this.m_Data.Position.Row; request.OldPositionColumn = this.m_Data.Position.Column; } this.m_Data.Position = newPosition; CommunicationUtility.Instance.MoveDefenseObject(request); }
public void ConstructRemovableObject(RemovableObjectType type, TilePosition position) { RemovableObjectConfigData configData = ConfigInterface.Instance.RemovableConfigHelper.GetRemovableObjectData(type); string prefabName = string.Format("{0}{1}{2}", ClientStringConstants.BATTLE_SCENE_RESOURCE_PREFAB_PREFIX_NAME, ClientStringConstants.REMOVABLE_OBJECT_PREFAB_PREFIX_NAME, configData.PrefabName); GameObject objectPrefab = Resources.Load(prefabName) as GameObject; GameObject newObject = GameObject.Instantiate(objectPrefab) as GameObject; EditorRemovableObjectBehavior objectBehavior = newObject.AddComponent <EditorRemovableObjectBehavior>(); objectBehavior.Position = position; objectBehavior.RemovableObjectType = type; newObject.transform.position = PositionConvertor.GetWorldPositionByBuildingTileIndex(position); newObject.transform.parent = this.m_SceneParent; this.PopulateMapData(position, configData.BuildingObstacleList, newObject); }
private void BuyBuilding(BuildingType type, int buildingNO, TilePosition position) { BuildingData data = new BuildingData(); int initialLevel = ConfigInterface.Instance.BuildingConfigHelper.GetInitialLevel(type); BuildingConfigData configData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(type, initialLevel); data.ConfigData = configData; data.BuildingID = new BuildingIdentity(type, buildingNO); data.Level = initialLevel; data.BuildingPosition = position; if (!this.m_Buildings.ContainsKey(type)) { this.m_Buildings.Add(type, new Dictionary <int, BuildingLogicObject>()); } this.m_Buildings[type].Add(data.BuildingID.buildingNO, this.ConstructBuildingLogicObject(data)); this.ReCalculateResource(); }
void OnDrag(Vector2 delta) { if (UICamera.currentTouchID == -1) { Vector3 worldPosition = EditorConfigInterface.Instance.SceneCamera.ScreenToWorldPoint(Input.mousePosition); TilePosition currentPosition = PositionConvertor.GetBuildingTileIndexFromWorldPosition(worldPosition) + this.m_SelectOffset; this.Position = currentPosition; this.gameObject.transform.position = PositionConvertor.GetWorldPositionByBuildingTileIndex(this.Position); foreach (var b in this.m_Selections) { if (b != this) { b.OnDrag(delta); } } } }
static public void InitLuminance(TileManager tileManager) { for (int x = 0; x < tileManager.sizeX; x++) { for (int y = 0; y < tileManager.sizeY; y++) { for (int z = 0; z < tileManager.sizeZ; z++) { TilePosition pos = new TilePosition(x, y, z); if (tileManager.GetTileLightSource(pos)) { pendingUpdateLights.Add(PositionToInt(x, y, z)); } } } } UpdateLuminanceLightVector(tileManager); }
private void SetNoWallBuildingToTarget() { foreach (GameObject item in this.m_TargetsObjects) { if (item != null) { BuildingBasePropertyBehavior property = item.GetComponent <BuildingBasePropertyBehavior>(); TilePosition destination = property.GetBuildingFirstActorPosition(); IgnoreTargetAndAttackScopeWeightStrategy findPathStrategy = new IgnoreTargetAndAttackScopeWeightStrategy( this.CharacterAI.BattleMapData, destination.Row, destination.Column, this.CharacterAI.AttackBehavior.AttackScope); //KodoPathFindStrage findPathStrategy = new KodoPathFindStrage( // this.CharacterAI.BattleMapData, destination.Row, destination.Column); List <TilePosition> aStarPath; List <TilePosition> linePath = AStarPathFinder.CalculatePathTile(findPathStrategy, this.CharacterAI.BattleMapData.ActorObstacleArray, this.m_CurrentPosition, destination, out aStarPath); TilePosition endPoint = linePath[linePath.Count - 1]; GameObject targetBuilding = this.CharacterAI.BattleMapData.GetBulidingObjectFromActorObstacleMap(endPoint.Row, endPoint.Column); if (targetBuilding != null) { property = targetBuilding.GetComponent <BuildingBasePropertyBehavior>(); if (property != null) { if (BattleEffectConfig.Instance.TargetEffectPrefab != null && this.CharacterAI.IsShowTarget) { GameObject targetEffect = GameObject.Instantiate(BattleEffectConfig.Instance.TargetEffectPrefab) as GameObject; Vector3 offset = targetEffect.transform.position; Vector3 targetEffectPosition = property.AnchorTransform.position; targetEffect.transform.position = targetEffectPosition + offset; targetEffect.transform.parent = BattleObjectCache.Instance.EffectObjectParent.transform; } BombermanWalkState walkState = new BombermanWalkState(this.CharacterAI.BattleMapData, endPoint, this.m_AIBehavior, targetBuilding); walkState.SetPath(linePath); this.m_AIBehavior.ChangeState(walkState); break; } } } } }
public override void Execute(TileManager tileManager, Tile tile, TilePosition center) { for (int d = 1; d <= radius; d++) { int rDamage = damage * (radius - d + 1) / radius; TilePosition[] tiles = Manhattan.GetTilesAtDistance(d); for (int i = 0; i < tiles.Length; i++) { TilePosition p = center + tiles[i]; if (tileManager.IsValidTile(p)) { if (tileManager.DamageTile(p, rDamage) == false) { if (setOnFire && tileManager.GetTileDefinition(tileManager.GetTileType(p)).burns) { tileManager.SetTileOnFire(p, true); } } } } } if (setOnFire) { TilePosition[] tiles = Manhattan.GetTilesAtDistance(radius + 1); for (int i = 0; i < tiles.Length; i++) { TilePosition p = center + tiles[i]; if (tileManager.IsValidTile(p)) { if (setOnFire && tileManager.GetTileDefinition(tileManager.GetTileType(p)).burns) { tileManager.SetTileOnFire(p, true); } } } } }
private static List <TilePosition> CalculateLinePath(List <TilePosition> aStarPath, bool[,] obstacleMap) { List <TilePosition> result = new List <TilePosition>(); for (int i = 0; i < aStarPath.Count - 1;) { TilePosition start = aStarPath[i]; if (i == 0) { result.Add(start); } for (int j = aStarPath.Count - 1; j > i; j--) { TilePosition end = aStarPath[j]; List <TilePosition> line = LinearizationHelper.BresenhamLine(start, end); bool blocked = false; foreach (TilePosition lineIndex in line) { if (obstacleMap[lineIndex.Row, lineIndex.Column]) { blocked = true; break; } } if (!blocked) { result.Add(end); i = j; } else { if (j == i + 1) { result.Add(end); return(result); } } } } return(result); }
public void ConstructAchievementBuilding(AchievementBuildingType type, TilePosition position) { AchievementBuildingConfigData configData = ConfigInterface.Instance.AchievementBuildingConfigHelper.GetAchievementBuildingData(type); string prefabName = string.Format("{0}{1}{2}", ClientStringConstants.BATTLE_SCENE_RESOURCE_PREFAB_PREFIX_NAME, ClientStringConstants.ACHIEVEMENT_BULIDING_PREFAB_PREFIX_NAME, configData.PrefabName); GameObject objectPrefab = Resources.Load(prefabName) as GameObject; GameObject newObject = GameObject.Instantiate(objectPrefab) as GameObject; GameObject.DestroyImmediate(newObject.GetComponent <AchievementBuildingHPBehavior>()); EditorAchievementBuildingBehavior objectBehavior = newObject.AddComponent <EditorAchievementBuildingBehavior>(); objectBehavior.Position = position; objectBehavior.AchievementBuildingType = type; newObject.transform.position = PositionConvertor.GetWorldPositionByBuildingTileIndex(position); newObject.transform.parent = this.m_SceneParent; this.PopulateMapData(position, configData.BuildingObstacleList, newObject); }
void DrawCube(TilePosition tile) { tile.Y = GetTileHeight(tile); var translation = GridLocationToTranslation(tile); //Add to geometry the top face AddQuad(translation, SpaceMathService.LooksUp); var tileData = new TileData { textureOffset = chunkTextureOffset }; AddUV(UVOffsetTopFace, tileData); foreach (var pair in SpaceMathService.DirectionToRotation) { var gridDirection = pair.Key; var rot = pair.Value; DrawDirectionFace(tile, gridDirection, rot, tileData); } }
public static int DetermineH(HeuristicFormula heuristicFormula, TilePosition end, int heuristicEstimate, int newLocationY, int newLocationX) { int h; switch (heuristicFormula) { case HeuristicFormula.MaxDXDY: h = heuristicEstimate * (Math.Max(Math.Abs(newLocationX - end.X), Math.Abs(newLocationY - end.Y))); break; case HeuristicFormula.DiagonalShortCut: var hDiagonal = Math.Min(Math.Abs(newLocationX - end.X), Math.Abs(newLocationY - end.Y)); var hStraight = (Math.Abs(newLocationX - end.X) + Math.Abs(newLocationY - end.Y)); h = (heuristicEstimate * 2) * hDiagonal + heuristicEstimate * (hStraight - 2 * hDiagonal); break; case HeuristicFormula.Euclidean: h = (int)(heuristicEstimate * Math.Sqrt(Math.Pow((newLocationY - end.X), 2) + Math.Pow((newLocationY - end.Y), 2))); break; case HeuristicFormula.EuclideanNoSQR: h = (int)(heuristicEstimate * (Math.Pow((newLocationX - end.X), 2) + Math.Pow((newLocationY - end.Y), 2))); break; case HeuristicFormula.Custom1: var dxy = new TilePosition(Math.Abs(end.X - newLocationX), Math.Abs(end.Y - newLocationY)); var Orthogonal = Math.Abs(dxy.X - dxy.Y); var Diagonal = Math.Abs(((dxy.X + dxy.Y) - Orthogonal) / 2); h = heuristicEstimate * (Diagonal + Orthogonal + dxy.X + dxy.Y); break; // ReSharper disable once RedundantCaseLabel case HeuristicFormula.Manhattan: default: h = heuristicEstimate * (Math.Abs(newLocationX - end.X) + Math.Abs(newLocationY - end.Y)); break; } return(h); }
void Update() { TilePosition upPosition = new TilePosition(this.m_BuildingBehavior.Position.Column, this.m_BuildingBehavior.Position.Row + 1); TilePosition rightPosition = new TilePosition(this.m_BuildingBehavior.Position.Column + 1, this.m_BuildingBehavior.Position.Row); if (upPosition.IsValidBuildingTilePosition()) { GameObject upObject = EditorFactory.Instance.MapData[upPosition.Row, upPosition.Column]; if (upObject != null && upObject.GetComponent <EditorBuildingBehavior>() != null && upObject.GetComponent <EditorBuildingBehavior>().BuildingType == BuildingType.Wall) { this.m_UpWall.SetActive(true); } else { this.m_UpWall.SetActive(false); } } else { this.m_UpWall.SetActive(false); } if (rightPosition.IsValidBuildingTilePosition()) { GameObject rightObject = EditorFactory.Instance.MapData[rightPosition.Row, rightPosition.Column]; if (rightObject != null && rightObject.GetComponent <EditorBuildingBehavior>() != null && rightObject.GetComponent <EditorBuildingBehavior>().BuildingType == BuildingType.Wall) { this.m_RightWall.SetActive(true); } else { this.m_RightWall.SetActive(false); } } else { this.m_RightWall.SetActive(false); } }
public override void Update() { TilePosition playerTilePosition = Graphics.Vector3ToTilePosition(player.position); Sector playerSector = sectorManager.GetSectorTile(playerTilePosition); if (playerSector != currentPlayerSector) { currentPlayerSector = playerSector; List <Sector> newVisibleVectors = FindSectorsNearPlayer(); //Disable sectors far away for (int i = visibleSectors.Count - 1; i >= 0; i--) { Sector sector = visibleSectors[i]; int pos = newVisibleVectors.IndexOf(sector); if (pos < 0) { sectorManagerUnity.ReturnSectorUnityToCache((SectorUnity)sector.GetSectorGraphics()); visibleSectors.RemoveAt(i); } else { newVisibleVectors.RemoveAt(pos); } } //Enable sectors near for (int i = newVisibleVectors.Count - 1; i >= 0; i--) { Sector sector = newVisibleVectors[i]; visibleSectors.Add(sector); sectorManagerUnity.GetSectorUnityFromCache(sector); } } }
void Update() { TilePosition currentTilePosition = autoTileSet.ScreenToTilePosition(Input.mousePosition); if (Input.GetMouseButton(0)) { if ((currentTilePosition - autoTileSet.lastModifiedTileCoords).taxicabDistance > 0) { TileType existingTileType = autoTileSet.GetTileTypeFromPosition(currentTilePosition); switch (existingTileType) { case TileType.None: autoTileSet.AddTile(currentTilePosition); break; case TileType.Front: autoTileSet.PushTile(currentTilePosition); break; case TileType.Back: autoTileSet.PullTile(currentTilePosition); break; } } } if (Input.GetMouseButton(1)) { Transform existingTileType = autoTileSet.GetTileTransformFromPosition(currentTilePosition); if (existingTileType != null) { autoTileSet.RemoveTile(currentTilePosition); } } if (Input.GetMouseButtonUp(0) || Input.GetMouseButtonUp(1)) { autoTileSet.lastModifiedTileCoords = null; } }