protected override void OnShutdown()
{
if (m_scriptController != null)
{
m_scriptController.Dispose();
m_scriptController = null;
}
Game.Screen.Elements.Remove(m_placementPreview);
m_placementPreview.Dispose();
m_placementPreview = null;
Game.Screen.Elements.Remove(m_placementPreviewText);
m_placementPreviewText.Dispose();
m_placementPreviewText = null;
Game.Screen.Elements.Remove(m_titleText);
m_titleText.Dispose();
m_titleText = null;
if (m_dialog != null)
{
Game.Screen.Elements.Remove(m_dialog);
if (m_disposeDialogOnClose)
{
m_dialog.Dispose();
}
m_dialog = null;
}
}
public void OnDayChange()
{
// Debug.Log ("yesterday was " + lastDayNum + ", today is " + dayNum);
mangroveList.Clear();
reedList.Clear();
mangroveList.AddRange(GameObject.FindGameObjectsWithTag("Mangrove"));
reedList.AddRange(GameObject.FindGameObjectsWithTag("Invasive"));
reedPosition = new Vector3(Mathf.Round(this.transform.position.x), 0, Mathf.Round(this.transform.position.z));
reedRight = reedPosition + new Vector3(10, 0, 0);
reedLeft = reedPosition + new Vector3(-10, 0, 0);
reedUp = reedPosition + new Vector3(0, 0, 10);
reedDown = reedPosition + new Vector3(0, 0, -10);
destroySpots.Clear();
// destroySpots.Add (reedPosition);
destroySpots.Add(reedUp);
destroySpots.Add(reedDown);
destroySpots.Add(reedRight);
destroySpots.Add(reedLeft);
foreach (GameObject tile in tileList)
{
tileReference = tile.GetComponent <TileSelect> ();
tileReference.TileReference();
foreach (Vector3 position in destroySpots)
{
if (Mathf.Approximately(tileReference.tilePosition.x, position.x) && Mathf.Approximately(tileReference.tilePosition.z, position.z))
{
// Debug.Log ("found tile");
if (tileReference.reedPresent != true && tileReference.mangrovePresent != true)
{
// Debug.Log ("time to spread");
Instantiate(newReed, position, Quaternion.identity);
}
}
// Debug.Log (marshPosition + " marsh spot position");
// if (Mathf.Approximately(position.x, marshPosition.x) && Mathf.Approximately(position.z, marshPosition.y)) {
// Debug.Log ("reed growth POTENTIAL");
// foreach (GameObject reed in reedList) {
// otherReed = reed.transform.position;
// if (position.x != otherReed.x && position.z != otherReed.z) {
// Debug.Log ("reed growth???");
//
//
// }
// }
// }
}
// foreach (GameObject mangrove in mangroveList) {
// mangrovePosition = mangrove.transform.position;
// if (position.x != mangrovePosition.x && position.z != mangrovePosition.z) {
// Debug.Log ("reed growth");
// Instantiate (reed, position, Quaternion.identity);
// }
// }
}
}
private void TilesetPictureBox_Click(object sender, EventArgs e)
{
if (tileset == null)
{
return;
}
MouseEventArgs mouseArgs = (MouseEventArgs)e;
MonoGamePoint mousePoint = new MonoGamePoint(mouseArgs.X, mouseArgs.Y);
List <MonoGameRectangle> frameRects = tileset.Frames;
for (int i = 0; i < frameRects.Count; i++)
{
MonoGameRectangle scaledRect = frameRects[i].Scale(zoomLevels[currentZoomLevel]);
if (scaledRect.Contains(mousePoint))
{
selectedFrameIndex = i;
TileSelect?.Invoke(tileset, selectedFrameIndex);
RefreshFrames();
}
}
}
public void endMovement()
{
var unit = UnitPlacement [selectUnitX, selectUnitY];
if (unit != null)
{
GameUnit unitStat = (GameUnit)unit.GetComponent("GameUnit");
if (targetTileX != selectUnitX || targetTileY != selectUnitY)
{
TileSelect tileOld = PlayMap.Grid.getTileSpec(selectUnitX, selectUnitY);
tileOld.resetCapture();
UnitPlacement [targetTileX, targetTileY] = UnitPlacement [selectUnitX, selectUnitY];
UnitPlacement [selectUnitX, selectUnitY] = null;
unitStat.x = targetTileX;
unitStat.y = targetTileY;
}
unitStat.ConfirmMovement();
}
//Resets selection
targetTileX = selectUnitX = selectTileX = -1;
targetTileY = selectUnitY = selectTileY = -1;
UnitMovementController.fullclear();
PlayMap.LockMovement = false;
PlayMap.UnitMenu.SetActive(false);
PlayMap.HideAttackInfo();
}
public void HighLightRangedMarks(int x, int y)
{
int maxRange = unit.UnitBodySpec.getMaxRange();
int yrange, distance;
for (int px = -maxRange; px <= maxRange; px++)
{
int tx = x + px;
if (tx >= 0 && tx < sizex)
{
yrange = maxRange - Mathf.Abs(px);
for (int py = -yrange; py <= yrange; py++)
{
int ty = y + py;
if (ty >= 0 && ty < sizey)
{
distance = Mathf.Abs(tx - x) + Mathf.Abs(ty - y);
if (((UnitControl)PlayMap.GridController).HasSeenEnemyUnit(tx, ty, unit.playerFactionSpec))
{
if (distance > 1 && UnitControlBattle.canTarget(unit, ((UnitControl)PlayMap.GridController).getUnitData(tx, ty), distance))
{
TileSelect tile = PlayMap.Grid.getTileSpec(tx, ty);
// Debug.Log ("RangePoint (" + tx + "," + ty +") for max " + maxRange);
tile.HighLightColorType = TileSelect.HighlightType.EnemyRTargetable;
highlightedTiles.Add(tile);
}
}
}
}
}
}
}
public void EndMovement()
{
if (!HasMoved)
{
TileSelect tile = PlayMap.Grid.getTileSpec(x, y);
tile.capture(this);
HasMoved = true;
}
}
public void OnDayChange () {
// Debug.Log ("yesterday was " + lastDayNum + ", today is " + dayNum);
mangroveList.Clear ();
reedList.Clear ();
mangroveList.AddRange (GameObject.FindGameObjectsWithTag ("Mangrove"));
reedList.AddRange(GameObject.FindGameObjectsWithTag ("Invasive"));
reedPosition = new Vector3 (Mathf.Round (this.transform.position.x), 0, Mathf.Round (this.transform.position.z));
reedRight = reedPosition + new Vector3 (10, 0, 0);
reedLeft = reedPosition + new Vector3 (-10, 0, 0);
reedUp = reedPosition + new Vector3 (0, 0, 10);
reedDown = reedPosition + new Vector3 (0, 0, -10);
destroySpots.Clear();
// destroySpots.Add (reedPosition);
destroySpots.Add (reedUp);
destroySpots.Add (reedDown);
destroySpots.Add (reedRight);
destroySpots.Add (reedLeft);
foreach (GameObject tile in tileList) {
tileReference = tile.GetComponent<TileSelect> ();
tileReference.TileReference();
foreach (Vector3 position in destroySpots) {
if (Mathf.Approximately(tileReference.tilePosition.x, position.x) && Mathf.Approximately(tileReference.tilePosition.z, position.z)) {
// Debug.Log ("found tile");
if (tileReference.reedPresent != true && tileReference.mangrovePresent != true){
// Debug.Log ("time to spread");
Instantiate (newReed, position, Quaternion.identity);
}
}
// Debug.Log (marshPosition + " marsh spot position");
// if (Mathf.Approximately(position.x, marshPosition.x) && Mathf.Approximately(position.z, marshPosition.y)) {
// Debug.Log ("reed growth POTENTIAL");
// foreach (GameObject reed in reedList) {
// otherReed = reed.transform.position;
// if (position.x != otherReed.x && position.z != otherReed.z) {
// Debug.Log ("reed growth???");
//
//
// }
// }
// }
}
// foreach (GameObject mangrove in mangroveList) {
// mangrovePosition = mangrove.transform.position;
// if (position.x != mangrovePosition.x && position.z != mangrovePosition.z) {
// Debug.Log ("reed growth");
// Instantiate (reed, position, Quaternion.identity);
// }
// }
}
}
public void ActionCallsTileSelect()
{
var mockController = new Mock <IController>();
var position = new Coordinate(3, 5);
var tileSelectAction = new TileSelect(mockController.Object, position);
tileSelectAction.Execute();
mockController.Verify(controller => controller.SelectTile(position), Times.Once());
}
public void addTileToPath(TileSelect tile)
{
pathList.Add(tile);
if (!inputManager.isFirstTileSelected())
{
inputManager.setTargetTile(tile);
inputManager.setFirstTileSelected(true);
inputManager.getTargetTile().setTileOccupied(true);
}
}
private void findCurrentTile()
{
for (int i = 0; i < tiles.Length; i++)
{
if ((x == tiles[i].GetComponent <TileBase>().getX()) && (z == tiles[i].GetComponent <TileBase>().getZ()))
{
currentTile = tiles[i].GetComponent <TileSelect>();
break;
}
}
}
public void OnDayChange()
{
trashPosition = new Vector3(Mathf.Round(this.transform.position.x), 0, Mathf.Round(this.transform.position.z));
trashRight = trashPosition + new Vector3(10, 0, 0);
// Debug.Log (personRight + " person, " + playerPosition + " player");
trashLeft = trashPosition + new Vector3(-10, 0, 0);
// Debug.Log (personLeft + " person, " + playerPosition + " player");
trashUp = trashPosition + new Vector3(0, 0, 10);
// Debug.Log (personUp + " person, " + playerPosition + " player");
trashDown = trashPosition + new Vector3(0, 0, -10);
// Debug.Log (personDown + " person, " + playerPosition + " player");
// Debug.Log ("the day changed.");
// Debug.Log ("trash at position " + trash.transform.position.x + "x, " + trash.transform.position.z + "y");
destroySpots.Clear();
// destroySpots.Add (trashPosition);
destroySpots.Add(trashUp);
destroySpots.Add(trashDown);
destroySpots.Add(trashRight);
destroySpots.Add(trashLeft);
openSpots.Clear();
foreach (GameObject tile in tileList)
{
tileReference = tile.GetComponent <TileSelect> ();
tileReference.TileReference();
foreach (Vector3 position in destroySpots)
{
if (Mathf.Approximately(tileReference.tilePosition.x, position.x) && Mathf.Approximately(tileReference.tilePosition.z, position.z))
{
// Debug.Log ("found tile");
if (tileReference.trashPresent != true || tileReference.mangrovePresent != true)
{
// Debug.Log (position + "is open");
openSpots.Add(position);
}
// if (tileReference.mangrovePresent != true) {
// Debug.Log (position + "removed");
// destroySpots.Remove (position);
// }
}
}
}
int spotIndex = Mathf.FloorToInt(Random.value * (float)openSpots.Count);
// Debug.Log (spotIndex + " out of " + openSpots.Count);
moveSpot = openSpots [spotIndex];
this.transform.position = moveSpot;
// Debug.Log ("trash moved to " + moveSpot);
}
public void OnDayChange () {
trashPosition = new Vector3 (Mathf.Round (this.transform.position.x), 0, Mathf.Round (this.transform.position.z));
trashRight = trashPosition + new Vector3 (10, 0, 0);
// Debug.Log (personRight + " person, " + playerPosition + " player");
trashLeft = trashPosition + new Vector3 (-10, 0, 0);
// Debug.Log (personLeft + " person, " + playerPosition + " player");
trashUp = trashPosition + new Vector3 (0, 0, 10);
// Debug.Log (personUp + " person, " + playerPosition + " player");
trashDown = trashPosition + new Vector3 (0, 0, -10);
// Debug.Log (personDown + " person, " + playerPosition + " player");
// Debug.Log ("the day changed.");
// Debug.Log ("trash at position " + trash.transform.position.x + "x, " + trash.transform.position.z + "y");
destroySpots.Clear();
// destroySpots.Add (trashPosition);
destroySpots.Add (trashUp);
destroySpots.Add (trashDown);
destroySpots.Add (trashRight);
destroySpots.Add (trashLeft);
openSpots.Clear ();
foreach (GameObject tile in tileList) {
tileReference = tile.GetComponent<TileSelect> ();
tileReference.TileReference ();
foreach (Vector3 position in destroySpots) {
if (Mathf.Approximately(tileReference.tilePosition.x, position.x) && Mathf.Approximately(tileReference.tilePosition.z, position.z)) {
// Debug.Log ("found tile");
if (tileReference.trashPresent != true || tileReference.mangrovePresent != true) {
// Debug.Log (position + "is open");
openSpots.Add (position);
}
// if (tileReference.mangrovePresent != true) {
// Debug.Log (position + "removed");
// destroySpots.Remove (position);
// }
}
}
}
int spotIndex = Mathf.FloorToInt (Random.value * (float)openSpots.Count);
// Debug.Log (spotIndex + " out of " + openSpots.Count);
moveSpot = openSpots [spotIndex];
this.transform.position = moveSpot;
// Debug.Log ("trash moved to " + moveSpot);
}
public static void ShowAttackInfo(int x, int y)
{
if (GridController is UnitControl)
{
TileSelect tile = Grid.getTileSpec(x, y);
bool highlight, cursor;
PlayMap.AttackInfo.SetActive(true);
Menu.DefenderImage.UpdateUnitImage();
AttackInfo attackInformation = (AttackInfo)PlayMap.AttackInfo.GetComponent("AttackInfo");
UnitControlBattle UnitBattleController = ((UnitControl)GridController).getBattleController();
float attack = UnitBattleController.AttackerPercentual100Damage();
float counter = UnitBattleController.CounterPercentual100Damage();
float attackerHp = UnitBattleController.Attacker.getPercentual100HP();
float defenderHp = UnitBattleController.Defender.getPercentual100HP();
attack *= attackerHp / 100.0f;
float edefenderHp = defenderHp - attack;
if (edefenderHp < 0)
{
edefenderHp = 0;
}
counter *= edefenderHp / 100.0f;
float eattackerHp = attackerHp - counter;
if (eattackerHp < 0)
{
eattackerHp = 0;
}
attackInformation.AttackDirection.text = UnitBattleController.AttackDirectionType();
attackInformation.AttackerHP.text = (int)(eattackerHp) + " %";
attackInformation.DefenderHP.text = (int)(edefenderHp) + " %";
attackInformation.EstimateAttack.text = (int)attack + " %";
if (counter > 0)
{
attackInformation.EstimateCounter.text = (int)counter + " %";
}
else
{
attackInformation.EstimateCounter.text = "--";
}
attackInformation.UnitName.text = UnitBattleController.Defender.name;
attackInformation.UnitHP.text = (int)defenderHp + " %";
}
}
public void UpdateConnect(TileSelect neighborspecs)
{
TileSelect thisspecs = (TileSelect)this.GetComponent("TileSelect");
Vector2 diff = thisspecs.coordinate - neighborspecs.coordinate;
if (diff.x > 0)
{
West = false;
}
else if (diff.x < 0)
{
East = false;
}
else if (diff.y > 0)
{
South = false;
}
else if (diff.y < 0)
{
North = false;
}
foreach (string tagString in TagConnect)
{
if (tagString.Equals(neighborspecs.gameObject.tag))
{
if (diff.x > 0)
{
West = true;
}
else if (diff.x < 0)
{
East = true;
}
else if (diff.y > 0)
{
South = true;
}
else if (diff.y < 0)
{
North = true;
}
break;
}
}
}
public LevelState(Game game, string levelLoadPath, LevelOptions options) : base(game)
{
// Load level
m_levelLoadPath = levelLoadPath;
m_levelOptions = options;
var data = Assets.Get <LevelData>(m_levelLoadPath);
m_level = Dan200.Game.Level.Level.Load(data, m_levelOptions);
m_level.Audio = game.Audio;
m_level.Visible = false;
// Load GUI
m_placementPreviewText = new Text(UIFonts.Default, "", UIColours.Text, TextAlignment.Left);
m_placementPreviewText.Visible = false;
m_placementPreviewText.Anchor = Anchor.TopLeft;
m_placementPreviewText.LocalPosition = new Vector2(
96.0f + (this is EditorState ? 80.0f : 0.0f),
32.0f
);
m_placementPreview = new TileSelect(Game, Tile.Get(Level.Info.ItemPath));
m_placementPreview.Visible = false;
m_placementPreview.Anchor = Anchor.TopLeft;
m_placementPreview.LocalPosition = new Vector2(
48.0f + (this is EditorState ? 80.0f : 0.0f),
48.0f
);
UpdatePlacementsLeft();
EnableTimeEffects = true;
m_titleText = new Text(UIFonts.Default, "", UIColours.Text, TextAlignment.Right);
m_titleText.Anchor = Anchor.TopRight;
m_titleText.LocalPosition = new Vector2(-24.0f, 16.0f);
m_titleText.Visible = false;
m_dialog = null;
m_disposeDialogOnClose = false;
m_cameraController = new InGameCameraController(Game);
m_timeInState = 0.0f;
if (!m_level.Info.InEditor && m_level.Info.ScriptPath != null)
{
m_scriptController = new ScriptController(this);
}
}
private void dijkstraTest(int x, int y, int debt, OriginDirection d, bool firstmove)
{
int movement = unit.getMovement();
UnitSpec.UnitMove movementType = unit.getMovementType();
if (x >= 0 && x < this.sizex && y >= 0 && y < this.sizey && // within boundaries
cost[x, y] >= 0 && // permission to map
(x != originx || y != originy) // Not unit origin
)
{
TileSelect tile = PlayMap.Grid.getTileSpec(x, y);
if (tile.HighLightColorType != TileSelect.HighlightType.EnemyRTargetable && //Ignore if there is a ranged marker
((UnitControl)PlayMap.GridController).HasSeenEnemyUnit(x, y, unit.playerFactionSpec))
{
if (UnitControlBattle.canTarget(unit, ((UnitControl)PlayMap.GridController).getUnitData(x, y), 1))
{
tile.HighLightColorType = TileSelect.HighlightType.EnemyTargetable;
}
else
{
tile.HighLightColorType = TileSelect.HighlightType.Enemy;
}
highlightedTiles.Add(tile);
}
else
{
int newcost = getMovementCost(movementType, tile.FloorType, unit.UnitBodySpec.isAmphibious());
if (newcost != 0)
{
newcost += debt;
if ((newcost < cost[x, y] || cost[x, y] <= 0) && (firstmove || newcost <= movement))
{
cost[x, y] = newcost;
direction[x, y] = d;
//tile.HighLightColorType = TileSelect.HighlightType.Movement;
highlightedTiles.Add(tile);
dijkstraTest(x, y + 1, newcost, OriginDirection.S, false);
dijkstraTest(x, y - 1, newcost, OriginDirection.N, false);
dijkstraTest(x + 1, y, newcost, OriginDirection.W, false);
dijkstraTest(x - 1, y, newcost, OriginDirection.E, false);
}
}
}
}
}
private void testTarget(int x, int y)
{
if (x >= 0 && x < this.sizex && y >= 0 && y < this.sizey)
{
TileSelect tile = PlayMap.Grid.getTileSpec(x, y);
if (tile.HighLightColorType != TileSelect.HighlightType.EnemyRTargetable && //Ignore if there is a ranged marker
((UnitControl)PlayMap.GridController).HasSeenEnemyUnit(x, y, unit.playerFactionSpec))
{
if (UnitControlBattle.canTarget(unit, ((UnitControl)PlayMap.GridController).getUnitData(x, y), 1))
{
tile.HighLightColorType = TileSelect.HighlightType.EnemyTargetable;
}
else
{
tile.HighLightColorType = TileSelect.HighlightType.Enemy;
}
highlightedTiles.Add(tile);
}
}
}
private void reMapMovement()
{
clear();
int x = -5, y = -5;
int debt = 0;
foreach (Vector2 coord in movementPattern)
{
x = (int)coord.x;
y = (int)coord.y;
TileSelect tile = PlayMap.Grid.getTileSpec(x, y);
debt += getMovementCost(unit.getMovementType(), tile.FloorType, unit.UnitBodySpec.isAmphibious());
cost[x, y] = -debt;
}
dijkstraTest(x, y + 1, debt, OriginDirection.S, false);
dijkstraTest(x, y - 1, debt, OriginDirection.N, false);
dijkstraTest(x + 1, y, debt, OriginDirection.W, false);
dijkstraTest(x - 1, y, debt, OriginDirection.E, false);
showHighlights();
}
void CreateGrid()
{
for (int x = 0; x < MapSize.x; x++)
{
for (int y = 0; y < MapSize.y; y++)
{
var tile = (GameObject)Instantiate(GetTile(MapTerrain[x, y]), new Vector3((x + 0.5f), 0, (y + 0.5f)), Quaternion.identity);
tile.transform.parent = this.transform.FindChild("Tiles").transform;
TileSelect tileSpec = (tile.GetComponent <TileSelect>());
RoadDraw thisroadDrawer = (tile.GetComponent <RoadDraw>());
tileSpec.coordinate = new Vector2(x, y);
MapTiles[x, y] = tile;
if (x > 0)
{
hideBorderY(y, x, x - 1);
RoadDraw neighborsroadDrawer = (MapTiles[x - 1, y].GetComponent <RoadDraw>());
if (thisroadDrawer != null)
{
thisroadDrawer.UpdateConnect(MapTiles[x - 1, y].GetComponent <TileSelect>());
}
if (neighborsroadDrawer != null)
{
neighborsroadDrawer.UpdateConnect(tileSpec);
}
}
if (y > 0)
{
hideBorderX(y, y - 1, x);
RoadDraw neighborsroadDrawer = (MapTiles[x, y - 1].GetComponent <RoadDraw>());
if (thisroadDrawer != null)
{
thisroadDrawer.UpdateConnect(MapTiles[x, y - 1].GetComponent <TileSelect>());
}
if (neighborsroadDrawer != null)
{
neighborsroadDrawer.UpdateConnect(tileSpec);
}
}
}
}
}
private void dijkstraTest(int x, int y, int movement, int debt, OriginDirection d, UnitSpec.UnitMove movementType, bool force)
{
if (x >= 0 && x < this.sizex && y >= 0 && y < this.sizey && cost[x, y] != -2)
{
TileSelect tile = TilesSpec.getTileSpec(x, y);
int newcost = getMovementCost(movementType, tile.FloorType);
if (newcost != 0)
{
newcost += debt;
if ((newcost < cost[x, y] || cost[x, y] <= 0) && (force || newcost <= movement))
{
cost[x, y] = newcost;
direction[x, y] = d;
highlightedTiles.Add(tile);
dijkstraTest(x, y + 1, movement, newcost, OriginDirection.S, movementType, false);
dijkstraTest(x, y - 1, movement, newcost, OriginDirection.N, movementType, false);
dijkstraTest(x + 1, y, movement, newcost, OriginDirection.W, movementType, false);
dijkstraTest(x - 1, y, movement, newcost, OriginDirection.E, movementType, false);
}
}
}
}
private IEnumerator moveToNextTile(TileSelect nextTile)
{
float timePassed = 0;
Vector3 currentPos = currentTile.transform.position;
currentPos.y = currentTile.getHeight();
Vector3 nextPos = nextTile.transform.position;
nextPos.y = currentTile.getHeight();
Vector3 pathToNext = nextPos - currentPos;
while (timePassed <= timeToMove)
{
Vector3 newPos = currentPos + pathToNext * (timePassed / timeToMove);
if (timePassed >= timeToMove / 2)
{
newPos.y = nextTile.getHeight();
}
transform.position = newPos;
yield return(null);
timePassed += Time.deltaTime;
}
nextPos.y = nextTile.getHeight();
transform.position = nextPos;
currentTile.setTileOccupied(false);
nextTile.setTileOccupied(true);
currentTile = nextTile;
}
public IEnumerator moveUnit()
{
stillMoving = true;
Stack <TileSelect> path = new Stack <TileSelect> (pathFinder.getPath().Reverse());
pathFinder.resetPath();
for (int i = path.Count; i > 0; i--)
{
int apCost = currentTile.GetComponent <TilePathFinder>().getAPCost(path.Peek().getTileID(), unitController.getMaxHeight());
if (apCost < unitController.getActionPoints())
{
unitController.updateActionPoints(-apCost);
nextTile = path.Pop();
yield return(StartCoroutine(moveToNextTile(nextTile)));
}
}
stillMoving = false;
}
void hideBorderX(int y1, int y2, int x)
{
int ylow, yhigh;
if (y1 < y2)
{
ylow = y1;
yhigh = y2;
}
else
{
ylow = y2;
yhigh = y1;
}
TileSelect north = (TileSelect)MapTiles[x, yhigh].GetComponent <TileSelect>();
TileSelect south = (TileSelect)MapTiles[x, ylow].GetComponent <TileSelect>();
if (north.borderOcclusion && south.borderOcclusion)
{
north.HideSouth();
south.HideNorth();
}
}
void hideBorderY(int y, int x1, int x2)
{
int xlow, xhigh;
if (x1 < x2)
{
xlow = x2;
xhigh = x1;
}
else
{
xlow = x1;
xhigh = x2;
}
TileSelect east = (TileSelect)MapTiles[xlow, y].GetComponent <TileSelect>();
TileSelect west = (TileSelect)MapTiles[xhigh, y].GetComponent <TileSelect>();
if (east.borderOcclusion && west.borderOcclusion)
{
east.HideWest();
west.HideEast();
}
}
public override void clickCoordinate(int x, int y)
{
bool pathconfirming = false;
if (PlayMap.LockMovement)
{
TileSelect tile = PlayMap.Grid.getTileSpec(x, y);
if (tile.HighLightColorType == TileSelect.HighlightType.EnemyTargetable || tile.HighLightColorType == TileSelect.HighlightType.EnemyRTargetable)
{
if (selectTileX == x && selectTileY == y)
{
confirmAttack();
}
else
{
var unit = UnitPlacement [selectUnitX, selectUnitY];
GameUnit unitStat = (GameUnit)unit.GetComponent("GameUnit");
UnitBattleController = UnitControlBattle.CalculateBattle(unitStat, targetTileX, targetTileY, x, y);
PlayMap.ShowAttackInfo(x, y);
}
}
else
{
PlayMap.HideAttackInfo();
}
selectTileX = x;
selectTileY = y;
}
else if (UnitPlacement [x, y] != null)
{
//Set tile selection
TileSelect tile = PlayMap.Grid.getTileSpec(x, y);
if (selectUnitX >= 0 && // there is a unit already selected
tile.HighLightColorType == TileSelect.HighlightType.EnemyTargetable) // selecting enemy target for direct combat
// Debug.Log("ENGAGE!");
//Second choosing of the same tile
{
if (selectTileX == x && selectTileY == y && confirmPath && UnitMovementController.getRouteSize() > 0)
{
confirmMovement();
}
else
{
GameUnit unit = (GameUnit)UnitPlacement[selectUnitX, selectUnitY].GetComponent("GameUnit");
if (!unit.HasMoved)
{
pathconfirming = UnitMovementController.attackSelect(x, y, unit);
}
}
selectTileX = x;
selectTileY = y;
}
else if (tile.HighLightColorType == TileSelect.HighlightType.EnemyRTargetable) // selecting indirect combat
// Debug.Log("BOMBARD!");
{
selectTileX = x;
selectTileY = y;
}
else
{
selectTileX = x;
selectTileY = y;
if (selectUnitX == x && selectUnitY == y) //Same unit
{
confirmMovement();
}
else
{
// a unit was selected
// Debug.Log("ATTENTION!");
UnitMovementController.fullclear();
GameUnit unit = (GameUnit)UnitPlacement[selectTileX, selectTileY].GetComponent("GameUnit");
if (!unit.HasMoved)
{
selectUnitX = x;
selectUnitY = y;
UnitMovementController.mapMovement(x, y, unit);
}
}
}
}
else
{
if (selectUnitX >= 0)
{
//Second choosing of the same tile
if (selectTileX == x && selectTileY == y && confirmPath && UnitMovementController.getRouteSize() > 0)
{
confirmMovement();
}
else
{
//Set tile selection
selectTileX = x;
selectTileY = y;
GameUnit unit = (GameUnit)UnitPlacement[selectUnitX, selectUnitY].GetComponent("GameUnit");
if (!unit.HasMoved)
{
pathconfirming = UnitMovementController.selectPath(x, y, unit);
}
if (!pathconfirming) // no valid selection
{
selectUnitX = selectTileX = -1;
selectUnitY = selectTileY = -1;
UnitMovementController.fullclear();
}
}
}
else
{
//Set tile selection
selectTileX = x;
selectTileY = y;
}
}
confirmPath = pathconfirming;
if (selectTileX >= 0)
{
placeSelectHighlight(x, y);
}
else
{
removeSelectHighlight();
}
}
public void ChangeTile(int x, int y, byte id)
{
if (x >= 0 && x < (int)MapSize.x &&
y >= 0 && y < (int)MapSize.y)
{
Destroy(MapTiles [x, y]);
MapTerrain[x, y] = id;
var tile = (GameObject)Instantiate(GetTile(MapTerrain[x, y]), new Vector3((x + 0.5f), 0, (y + 0.5f)), Quaternion.identity);
tile.transform.parent = this.transform.FindChild("Tiles").transform;
TileSelect tileSpec = (tile.GetComponent <TileSelect>());
RoadDraw thisroadDrawer = (tile.GetComponent <RoadDraw>());
tileSpec.coordinate = new Vector2(x, y);
MapTiles[x, y] = tile;
if (x > 0)
{
hideBorderY(y, x, x - 1);
RoadDraw neighborsroadDrawer = (MapTiles[x - 1, y].GetComponent <RoadDraw>());
if (thisroadDrawer != null)
{
thisroadDrawer.UpdateConnect(MapTiles[x - 1, y].GetComponent <TileSelect>());
}
if (neighborsroadDrawer != null)
{
neighborsroadDrawer.UpdateConnect(tileSpec);
neighborsroadDrawer.DrawConnections();
}
}
if (y > 0)
{
hideBorderX(y, y - 1, x);
RoadDraw neighborsroadDrawer = (MapTiles[x, y - 1].GetComponent <RoadDraw>());
if (thisroadDrawer != null)
{
thisroadDrawer.UpdateConnect(MapTiles[x, y - 1].GetComponent <TileSelect>());
}
if (neighborsroadDrawer != null)
{
neighborsroadDrawer.UpdateConnect(tileSpec);
neighborsroadDrawer.DrawConnections();
}
}
if (x + 1 < (int)MapSize.x)
{
hideBorderY(y, x, x + 1);
RoadDraw neighborsroadDrawer = (MapTiles[x + 1, y].GetComponent <RoadDraw>());
if (thisroadDrawer != null)
{
thisroadDrawer.UpdateConnect(MapTiles[x + 1, y].GetComponent <TileSelect>());
}
if (neighborsroadDrawer != null)
{
neighborsroadDrawer.UpdateConnect(tileSpec);
neighborsroadDrawer.DrawConnections();
}
}
if (y + 1 < (int)MapSize.y)
{
hideBorderX(y, y + 1, x);
RoadDraw neighborsroadDrawer = (MapTiles[x, y + 1].GetComponent <RoadDraw>());
if (thisroadDrawer != null)
{
thisroadDrawer.UpdateConnect(MapTiles[x, y + 1].GetComponent <TileSelect>());
}
if (neighborsroadDrawer != null)
{
neighborsroadDrawer.UpdateConnect(tileSpec);
neighborsroadDrawer.DrawConnections();
}
}
}
}
public float getFloorHeight(int x, int y)
{
TileSelect tile = (TileSelect)MapTiles [x, y].GetComponent <TileSelect> ();
return(tile.FloorHeight);
}
public void addWaypoint(Vector2 movement, UnitControlMovement.OriginDirection direction)
{
int x = (int)movement.x;
int y = (int)movement.y;
TileSelect tile = PlayMap.Grid.getTileSpec(x, y);
float height = tile.FloorHeight;
bool terrainDependent = true;
if (UnitBodySpec.getUnitMovementType() == UnitSpec.UnitMove.Fly ||
UnitBodySpec.getUnitMovementType() == UnitSpec.UnitMove.Sail ||
UnitBodySpec.getUnitMovementType() == UnitSpec.UnitMove.Dive ||
UnitBodySpec.getUnitMovementType() == UnitSpec.UnitMove.Heli)
{
terrainDependent = false;
}
if (terrainDependent)
{
// Hover units
if (UnitBodySpec.getUnitMovementType() == UnitSpec.UnitMove.Float)
{
switch (tile.FloorType)
{
case TileSelect.TileMovementType.Mountain:
terrainStatus = UnitTerrainStatus.HighFloat;
break;
default:
terrainStatus = UnitTerrainStatus.Float;
break;
}
if (height < 0.2f)
{
height = 0.25f;
}
else
{
height += 0.05f;
}
} // Ground units
else
{
switch (tile.FloorType)
{
case TileSelect.TileMovementType.Concrete:
terrainStatus = UnitTerrainStatus.Land;
break;
case TileSelect.TileMovementType.DeepWater:
terrainStatus = UnitTerrainStatus.Water;
break;
case TileSelect.TileMovementType.Hill:
terrainStatus = UnitTerrainStatus.Land;
break;
case TileSelect.TileMovementType.Normal:
terrainStatus = UnitTerrainStatus.Land;
break;
case TileSelect.TileMovementType.Obstructed:
terrainStatus = UnitTerrainStatus.Land;
break;
case TileSelect.TileMovementType.Sand:
terrainStatus = UnitTerrainStatus.Land;
break;
case TileSelect.TileMovementType.DeepBridge:
terrainStatus = UnitTerrainStatus.Land;
break;
case TileSelect.TileMovementType.ShallowBridge:
terrainStatus = UnitTerrainStatus.Land;
break;
case TileSelect.TileMovementType.ShallowWater:
terrainStatus = UnitTerrainStatus.Water;
break;
case TileSelect.TileMovementType.Mountain:
terrainStatus = UnitTerrainStatus.High;
break;
}
}
}
else // Sea and Air units
{
switch (terrainStatus)
{
case UnitTerrainStatus.Air:
height = 0.5f;
break;
case UnitTerrainStatus.Deep:
height = 0.15f;
break;
case UnitTerrainStatus.Water:
height = 0.2f;
break;
}
}
addWaypoint(new Vector3(movement.x + 0.5f, height, movement.y + 0.5f), direction);
}
public void setTargetTile(TileSelect targetTile)
{
this.targetTile = targetTile;
}
