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;
}
}
