/// <summary>
/// Loads the board given the definition and the tile prefab.
/// </summary>
/// <param name="definition">Definition.</param>
public void LoadBoard(BoardDefinition definition, TileController tilePrefab)
{
// Cache the board dimensions.
this.Width = definition.Width;
this.Height = definition.Height;
// Instantiate new tiles layer.
GameObject tilesLayerObject = new GameObject ("Tiles");
tilesLayerObject.transform.SetParent (transform);
// Calculate tile dimensions.
BoxCollider2D bounds = tilePrefab.transform.FindChild ("Sprite").GetComponent<BoxCollider2D> ();
float tileWidth = bounds.size.x;
float tileHeight = bounds.size.y;
// Initialize the tiles on the board.
for (int x = 0; x < this.Width; x++) {
for (int y = 0; y < this.Width; y++) {
// Instantiate tile GameObject.
TileController tile = Instantiate (tilePrefab) as TileController;
tile.transform.SetParent (tilesLayerObject.transform);
// Initialize and position the tile.
tile.Initialize (definition [x, y], tileWidth, tileHeight);
}
}
}
public override void Initialize(BaseController _tileController)
{
m_tileController = (TileController)_tileController;
base.Initialize(_tileController);
SetupWorldPosition(ReferencesHolder.Instance.GameConfigurationHolder.GetGameConfiguration().BoardConfiguration);
SetupColor();
SetupNumberText();
}
internal void Move(MoveType type, TileController start, TileController stop) {
string moveType = type == MoveType.Empty
? "MoveToEmpty"
: type == MoveType.Merge ? "MoveToMerge" : type == MoveType.Attack ? "MoveToAttack" : "";
_tcpClient.Send(string.Format("[Notify:{0}:{1}|({2}:{3})|({4}:{5})]", moveType, _guid, start.Position.x,
start.Position.y, stop.Position.x, stop.Position.y));
}
/// <summary>
/// Use this if an object that was on this tile was moved and not necessarily destroyed
/// </summary>
public void ObjectMoved()
{
if (!canBeBuiltOn)
return;
if (tileController == null){
tileController = transform.parent.GetComponent<TileController>();
}
this.renderer.material.mainTexture = tileController.regular;
placedObject = null;
this.name = "RegularTile";//mark this tile as unwalkable anymore
}
public void tileClicked(TileController tc)
{
if(this.selectedPiece != null) {
foreach(Position pos in this.selectedPiece.model.getAvailableSpaces(this)) {
if(tc.gridPosition.x == pos.x && tc.gridPosition.y == pos.y) {
int movingPlayer = this.selectedPiece.model.playerNum;
this.selectedPiece.move(pos);
ai.move(this, movingPlayer == 2);
return;
}
}
}
}
public void SpawnTile()
{
GameObject _currentGameObject = null;
int random = randomCountToSpawn();
if (random == 0)
{
_currentGameObject = (GameObject)TopTilePrefab.gameObject.Spawn(CurrentTile.TopAnchor.transform.position);
}
else if(random == 1)
{
_currentGameObject = (GameObject)LeftTilePrefab.gameObject.Spawn(CurrentTile.LeftAnchor.transform.position);
}
CurrentTile = _currentGameObject.GetComponent<TileController>();
CurrentTile._TileManager = this;
CurrentTile.RandomSpawnPickUp();
}
public static PathFindingResult FindPath(TileController startTile, TileController endTile) {
if (startTile == endTile)
return new PathFindingResult() {
Path = new List<TileController>(),
ValidPath = true,
FoundEndPoint = true
};
Node end = GetEndNode(startTile, endTile, (tile, unit) => {
if (tile == endTile)
return true;
return tile.IsTraversable(unit);
});
if (end.Tile == endTile)
return new PathFindingResult() {
Path = ConvertNodesToList(end),
FoundEndPoint = true,
ValidPath = true
};
end = GetEndNode(startTile, endTile, (tile, unit) => {
if (tile == endTile)
return true;
return tile.IsTraversableUnitOnly(unit);
});
if (end.Tile == endTile)
return new PathFindingResult() {
Path = ConvertNodesToList(end),
FoundEndPoint = true,
ValidPath = false
};
end = GetEndNode(startTile, endTile, (tile, unit) => true);
return new PathFindingResult() {
Path = ConvertNodesToList(end),
FoundEndPoint = false,
ValidPath = false
};
}
public void SwapTile(TileController otherTile, System.Action onCompleted = null)
{
StartCoroutine(board.SwapTilePosition(this, otherTile, onCompleted));
}
private void setTileMaterialRenderingMode(TileController targetTileController, RenderingMode renderingMode)
{
switch (renderingMode)
{
case RenderingMode.Cutout:
break;
case RenderingMode.Transparent:
if (targetTileController is FlowerTileController)
{
foreach (Renderer thisRenderer in targetTileController.GetComponentsInChildren <Renderer>())
{
if (thisRenderer.gameObject.name == "Plane (3)")
{
thisRenderer.material.color = new Color(thisRenderer.material.color.r, thisRenderer.material.color.g, thisRenderer.material.color.b, 0.7f);
}
else
{
thisRenderer.material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
thisRenderer.material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
thisRenderer.material.SetInt("_ZWrite", 0);
thisRenderer.material.DisableKeyword("_ALPHATEST_ON");
thisRenderer.material.DisableKeyword("_ALPHABLEND_ON");
thisRenderer.material.EnableKeyword("_ALPHAPREMULTIPLY_ON");
thisRenderer.material.renderQueue = 3000;
if (thisRenderer.material.HasProperty("_Color"))
{
thisRenderer.material.color = new Color(thisRenderer.material.color.r, thisRenderer.material.color.g, thisRenderer.material.color.b, 0.5f);
}
}
}
}
else if (targetTileController is GrassTileController)
{
foreach (Renderer thisRenderer in targetTileController.GetComponentsInChildren <Renderer>())
{
if (!thisRenderer.gameObject.name.Contains("Grass Tile"))
{
thisRenderer.material = GameController.getInstance().transparentGrassMaterial;
}
}
}
else if (targetTileController is HiveTileController)
{
foreach (Renderer thisRenderer in targetTileController.GetComponentsInChildren <Renderer>())
{
thisRenderer.material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
thisRenderer.material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
thisRenderer.material.SetInt("_ZWrite", 0);
thisRenderer.material.DisableKeyword("_ALPHATEST_ON");
thisRenderer.material.DisableKeyword("_ALPHABLEND_ON");
thisRenderer.material.EnableKeyword("_ALPHAPREMULTIPLY_ON");
thisRenderer.material.renderQueue = 3000;
if (thisRenderer.material.HasProperty("_Color"))
{
thisRenderer.material.color = new Color(thisRenderer.material.color.r, thisRenderer.material.color.g, thisRenderer.material.color.b, 0.3f);
}
}
}
break;
}
}
// Use this for initialization
void Start()
{
if (this.tag.Equals("CrackedTile")){
SetCracked(true);
}
else
isCracked = false;
//get a reference to the tile controller - it is this tile's parent
tileController = transform.parent.GetComponent<TileController>();
}
public void LoadMap()
{
var jsonStr = Resources.Load <TextAsset>("Map/Map").text;
var data = JsonUtility.FromJson <TiledMapData>(jsonStr);
MapWidth = data.width;
MapHeight = data.height;
Dictionary <string, UnityEngine.Object> tileGoMap = new Dictionary <string, UnityEngine.Object>();
for (int i = 0; i < data.tilesets.Length; i++)
{
var tileset = data.tilesets[i];
tileGoMap.Add(tileset.name, Resources.Load("Map/" + tileset.name));
}
m_TileGoMap.Clear();
for (int j = 0; j < data.layers.Length; j++)
{
var layer = data.layers[j];
var layerDatas = layer.data;
var tileType = MapHelper.GetTileType(layer.name);
var isObject = layer.name == "object" || layer.name == "npc";
for (int i = 0; i < layerDatas.Length; i++)
{
var id = layerDatas[i];
if (id <= 0)
{
continue;
}
int x = i % 20;
int y = i / 20;
var cid = MapHelper.GetCid(x, y);
TileController tileController = null;
GameObject tileGo = null;
if (!m_TileGoMap.TryGetValue(cid, out tileGo))
{
tileGo = new GameObject(x + "_" + y);
tileController = tileGo.AddComponent <TileController>();
tileController.SortingOrder = MapHelper.GetTileSortOrder(i);
tileGo.transform.SetParent(transform, true);
tileGo.transform.localPosition = MapHelper.GetMapPosition(x, y);
m_TileGoMap.Add(cid, tileGo);
}
if (tileController == null)
{
tileController = tileGo.GetComponent <TileController>();
}
var tileset = data.tilesets[id - 1];
var go = Instantiate(tileGoMap[tileset.name]) as GameObject;
go.transform.SetParent(tileGo.transform, true);
var spriteRenderer = go.transform.GetChild(0).GetComponent <SpriteRenderer>();
if (spriteRenderer != null)
{
spriteRenderer.sortingOrder = MapHelper.GetTileUnitSortOrder(tileController.SortingOrder, tileType);
}
else
{
go.transform.GetChild(0).GetComponent <UnityArmatureComponent>().sortingOrder = MapHelper.GetTileUnitSortOrder(tileController.SortingOrder, tileType);
}
go.transform.localPosition = Vector3.zero;
if (isObject)
{
tileController.MapObjectType = (int)Enum.Parse(typeof(MapHelper.EMapObject), tileset.name);
var tileObject = go.AddComponent <TileObject>();
tileObject.Type = tileController.MapObjectType;
}
else
{
tileController.MapObjectType = 0;
}
}
}
}
public override void OnMouseEnter(GameObject ownTile, GameObject hoveredTile) {
if (!_isBuilding || ownTile == hoveredTile)
return;
TileController hoverTile = hoveredTile.GetComponent<TileController>();
if (!ModifiedTiles.Contains(hoverTile)) {
_hoveredTile = hoverTile;
_hoveredTile.GetComponent<SpriteRenderer>().color = BuildNotAllowedColor;
}
}
public void GotoTile(TileController tile, string tileName, bool vacation = false, bool jail = false)
{
photonView.RPC("TeleportToTile_CMD", RpcTarget.All, tile.index, tileName, vacation, jail);
}
void SelectTile(TileController tile)
{
platform.SetActiveTile(tile);
actionStore--;
}
private void ChooseNextTile(int y, int x)
{
_destinationTile = fieldController.GetTile(_currentTile.y + y, _currentTile.x + x);
}
public void SpawnLeftTile()
{
GameObject _currentGameObject = (GameObject)LeftTilePrefab.gameObject.Spawn(CurrentTile.LeftAnchor.transform.position);
CurrentTile = _currentGameObject.GetComponent<TileController>();
CurrentTile._TileManager = this;
}
// Use this for initialization
void Start()
{
tileController = mapParent.GetComponent<TileController>();
table = new Hashtable();
GameObject startTile = GameObject.FindGameObjectWithTag("StartTile");
GameObject endTile = GameObject.FindGameObjectWithTag("EndTile");
if (startTile && endTile){
table.Add(startTile.transform.position,startTile);
table.Add(endTile.transform.position,endTile);
}
else{
Debug.Log("No start or end tile found - please add the appropriate tags to a start and/or end tile");
}
}
public override void OnMouseLeave(GameObject ownTile, GameObject hoveredTile) {
if (!_isBuilding) {
base.OnMouseLeave(ownTile, hoveredTile);
return;
}
if(_hoveredTile != null && !_surroundingTiles.Contains(_hoveredTile))
_hoveredTile.ResetSprite();
_hoveredTile = null;
}
public bool PlaceObject(GameObject obj)
{
if (!canBeBuiltOn)
return false;
placedObject = obj;
if (isCracked){
SetCracked(false);
}
this.name = "UnWalkableTile";//mark this tile as unwalkable anymore
if (tileController == null){
tileController = transform.parent.GetComponent<TileController>();
}
this.renderer.material.mainTexture = tileController.unwalkable;
return true;
}
public override void OnMouseEnter(GameObject ownTile, GameObject hoveredTile) {
if (!_isBuilding || ownTile == hoveredTile) {
base.OnMouseEnter(ownTile, hoveredTile);
return;
}
if (!GetComponent<BaseUnit>().CurrentPlayerPredicate(ownTile.GetComponent<TileController>()))
return;
TileController hoverTile = hoveredTile.GetComponent<TileController>();
if (!_surroundingTiles.Contains(hoverTile)) {
_hoveredTile = hoverTile;
_hoveredTile.GetComponent<SpriteRenderer>().color = BuildNotAllowedColor;
}
}
public virtual DeselectStatus Split(GameObject mock, TileController ownTile, TileController targetTile) {
IsSplitting = false;
BaseUnit unit = mock.GetComponent<BaseUnit>();
if (GetComponent<BaseUnit>().StackSize <= unit.StackSize) {
ownTile.Unit = null;
Destroy(gameObject);
}
else
ownTile.Unit.StackSize -= SplitAmount;
LandUnitEventController landUnit = mock.GetComponent<LandUnitEventController>();
if (targetTile.Unit == null)
landUnit.MoveToEmpty(null, new List<TileController>() { targetTile });
else
landUnit.MoveToMerge(null, new List<TileController>() { targetTile });
unit.Owner.Moves--;
ResetSplitTiles();
return DeselectStatus.Both;
}
public virtual void ShowUnitStack(TileController ownTile) {
GameObject stackOverlay = GameObject.Find("UnitStack");
StackWindow window = stackOverlay.GetComponent<StackWindow>();
BaseUnit unit = GetComponent<BaseUnit>();
window.Show(StackSizeSprite, unit.Owner.Color, unit.StackSize, unit.CurrentPlayerPredicate(ownTile), UnitSplitCallback);
}
public AStar(TileController tileController)
{
this.tileController = tileController;
LoadMapData(tileController.Map);
}
public override void drawMovementIcons(UnitScript selectedUnit)
{
for (int i = 0; i < adjustedDirections.Count; i++)
{
int j = 0;
Vector2 currentTileLoc = selectedUnit.getOccupyingHex().getCoords();
HexTile lastTile = null;
InteractionIcon.createInteractionIcon("PathIcon", selectedUnit.getCoords(), Color.cyan, 3);
while (j < ranges[i] || ranges[i] == -1)
{
currentTileLoc += adjustedDirections[i];
HexTile currentTile = gameControllerRef.getTileController().getTileFromHexCoord(currentTileLoc);
//prevTile = currentTile;
if (currentTile)
{
if (currentTile.getOccupyingUnit())
{
if (currentTile.getOccupyingUnit().getTeam() != selectedUnit.getTeam())
{
lastTile = currentTile;
InteractionIcon.createInteractionIcon("AttackIcon", currentTile.getCoords(), Color.red, 4);
}
else
{
InteractionIcon.createInteractionIcon("CrossIcon", currentTile.getCoords(), Color.red, 4);
}
break;
}
lastTile = currentTile;
}
else
{
InteractionIcon.createInteractionIcon("CrossIcon", currentTileLoc, Color.red, 4);
break;
}
j++;
}
if (lastTile)
{
InteractionIcon m = InteractionIcon.createInteractionIcon("PathConnectionIcon", selectedUnit.getCoords(), Color.cyan, 1);
Vector2 lastTileCoords = TileController.hexCoordToPixelCoord(lastTile.getCoords());
Vector2 startTileCoords = TileController.hexCoordToPixelCoord(selectedUnit.getCoords());
Vector2 Q = lastTileCoords - startTileCoords;
float dist = Q.magnitude * 100 - 15;
if (dist < 0)
{
dist = 0;
}
float angle = Mathf.Atan2(Q.y, Q.x) * 180 / Mathf.PI;
//gameControllerRef.printString(dist.ToString());
m.transform.Rotate(Vector3.forward, angle);
m.transform.localScale = new Vector2(dist / 24, 1.0f);
InteractionIcon mHead = InteractionIcon.createInteractionIcon("ArrowHeadIcon", lastTileCoords, Color.cyan, 2, true);
mHead.transform.Rotate(Vector3.forward, angle);
InteractionIcon.createInteractionIcon("PathIcon", lastTileCoords, Color.cyan, 1, true);
}
}
}
public CompleteCommand(TileController objective)
{
this.objective = objective;
}
int TileIndex(TileController tile)
{
return(tiles.IndexOf(tile));
}
private void OnTileVFXRequested(TileVFXRequestEvent obj)
{
tileHovered = FindTileControllerFromTile(obj.tile);
ActivateVFX(tileHovered, obj.element);
}
private void LoadWorld(WorldData worldData)
{
GameManager.Instance.SetGoalAtStart(worldData.BadAssGoal);
//LOAD TILES
foreach (TileData tile in worldData.Tiles)
{
TileController tileController = Instantiate(tile.TilePrefab);
tileController.transform.SetParent(TileParent);
tileController.transform.eulerAngles = new Vector3(0, tile.Rotation, 0);
tileController.transform.position = tile.Position;
LoadedTiles.Add(tileController);
bool canHaveBuilding = false;
foreach (TileController tileC in TileSetData.TilesThatCanHaveBuildingsOnThem)
{
if (tile.TilePrefab.name == tileC.name)
{
canHaveBuilding = true;
break;
}
}
if (canHaveBuilding)
{
int chanceToSpawnHouse = 70;
if (chanceToSpawnHouse > Random.Range(0, 100))
{
int randomInt = Random.Range(0, TileSetData.BuildingTiles.Length);
bool rotate = Random.Range(0, 2) > 0;
TileController buildingTileController = Instantiate(TileSetData.BuildingTiles[randomInt]);
buildingTileController.transform.SetParent(tileController.transform);
buildingTileController.transform.eulerAngles = new Vector3(0, rotate ? 90 : 0, 0);
buildingTileController.transform.localPosition = new Vector3(-0.5f, 0.6f, -0.5f);
}
}
bool canHaveTrees = false;
foreach (TileController tileC in TileSetData.TilesThatCanHaveTreesOnThem)
{
if (tile.TilePrefab.name == tileC.name)
{
canHaveTrees = true;
break;
}
}
if (canHaveTrees)
{
int chanceToSpawnTrees = 80;
if (chanceToSpawnTrees > Random.Range(0, 100))
{
int randomInt = Random.Range(0, TileSetData.TreeTiles.Length);
int rotate = Random.Range(0, 4);
TileController treeTileController = Instantiate(TileSetData.TreeTiles[randomInt]);
treeTileController.transform.SetParent(tileController.transform, false);
treeTileController.transform.eulerAngles = new Vector3(0, 90 * rotate, 0);
}
}
}
//LOAD HUMANS
HumanSpawner humanSpawnerPrefab = LevelManager.Instance.GetHumanSpawnerPrefab();
foreach (HumanSpawnerData data in worldData.HumanSpawnerDatas)
{
HumanSpawner humanSpawner = Instantiate(humanSpawnerPrefab);
humanSpawner.transform.SetParent(HumanSpawnerParent);
humanSpawner.Init(data);
HumanSpawners.Add(humanSpawner);
}
//LOAD CAR AI
CarAIController carAIControllerPrefab = LevelManager.Instance.GetCarAiControllerPrefab();
foreach (CarAIData data in worldData.CarAIDatas)
{
CarAIController carAiController = Instantiate(carAIControllerPrefab);
carAiController.transform.SetParent(CarAIParent);
carAiController.Init(data);
CarAIControllers.Add(carAiController);
}
}
public Node(TileController tile)
{
Tile = tile;
}
public void SetActiveTile(TileController tile)
{
if (activeTile) {
if (activeTile.GetInstanceID() != tile.GetInstanceID()) {
activeTile.SetActive(false);
activeTile = tile;
activeTile.SetActive(true);
}
} else {
activeTile = tile;
activeTile.SetActive(true);
}
if (activeTile && !activeTile.building && isPlayer) {
uiHandler.SetBuildUI(buildButtons);
}
}
void SetTileAt(TileController tile, int xBoardPos, int yBoardPos)
{
Tiles[xBoardPos, yBoardPos] = tile;
}
internal void CreateUnit(TileController target, string unitType) {
_tcpClient.Send(string.Format("[Notify:UnitCreated:{0}|({1}:{2})|{3}]", _guid, target.Position.x,
target.Position.y, unitType));
}
public void InitiatePopSequence()
{
if (highlightedTiles.Count < currentChainRequiredCombo) // Check if the combo requirement is met
{
CancelHighlight();
StartCoroutine(Shake(0.15f, 0.2f));
// Sounds
audioSource.PlayOneShot(failedSound);
}
else
{
// Sounds - pop
audioSource.PlayOneShot(popSound);
CancelInvoke(); // clear highlight flags and cancel the dynamic check
Vector3 notifPos = tappedTile.transform.position; // capture tappedtile pos before clear
tappedTile = null;
highlightMode = false;
List <GameObject> tilesToPop = new List <GameObject>();
// Combo variables
int comboTotal = 0;
int noOfComboTiles = 0;
foreach (KeyValuePair <int, GameObject> tile in highlightedTiles) // clear the flags on highlighted tiles and add them to pop list
{
tile.Value.SendMessage("UncheckTrigger");
TileController tc = tile.Value.GetComponent <TileController>();
if (tc.isOverloading) // check for overloading tiles
{
DecreaseOverload();
}
// Combo checker
if (tc.comboCounter > 0)
{
comboTotal += tc.comboCounter;
noOfComboTiles++;
}
tc.isPopping = true;
tilesToPop.Add(tile.Value);
}
highlightedTiles.Clear(); // remove the highlighted tiles from the list
int poppedColorCode = tilesToPop[0].GetComponent <TileController>().colorCode;
int scoreIncrement = ScoreProcessing(tilesToPop.Count, poppedColorCode, comboTotal, noOfComboTiles); // handle scoring depending on player's combo and required chain
// Sounds - reward
if (scoreIncrement > 300)
{
audioSource.PlayOneShot(highRewardSound);
}
else if (scoreIncrement > 100)
{
audioSource.PlayOneShot(lowRewardSound);
}
foreach (GameObject go in tilesToPop.ToArray()) // Loop the tiles to destroy
{
// Create particle effects
Vector3 psp = go.transform.position;
psp.z = -2;
ParticleSystemRenderer psr = Instantiate(popEffectObj, psp, go.transform.rotation).GetComponent <ParticleSystem>().GetComponent <ParticleSystemRenderer>();
psr.material = Resources.Load <Material>("Materials/" + ColorToString(poppedColorCode));
// Remove popped tile from tiles dictionary
RemoveTile(go.transform.GetInstanceID());
// Destroy the tile
Destroy(go);
}
// Create score notifications
notifPos.z = -3;
ScoreIncrementNotificationController scoreNotifier = Instantiate(scoreIncrementObj, notifPos, Quaternion.identity).GetComponentInChildren <ScoreIncrementNotificationController>();
scoreNotifier.TriggerScoreIncrementNotification(scoreIncrement);
totalPops++; // increment of total pops counter
highlightMode = false; // deactivate highlight mode
currentChainRequiredCombo = 0; // reset required combo counter
}
}
internal void SplitUnit(TileController start, TileController stop, int amount) {
_tcpClient.Send(string.Format("[Notify:SplitUnit:{0}|({1}:{2})|({3}:{4})|{5}]", _guid, start.Position.x,
start.Position.y, stop.Position.x, stop.Position.y, amount));
}
private void Start()
{
_myTileController = GetComponent <TileController>();
}
public override DeselectStatus MoveToEmpty(TileController start, List<TileController> path) {
MoveWaterUnit(start, path, QueueNextItem);
return DeselectStatus.Both;
}
public TileNode(TileController controller, Vector2Int pos)
{
this.controller = controller;
this.pos = pos;
}
public override DeselectStatus MoveToAttack(TileController start, List<TileController> path) {
LandUnit carry = ((WaterUnit) start.Unit).CarryUnit.GetComponent<LandUnit>();
List<TileController> movePath = path.Take(path.Count - carry.Range).ToList();
MoveWaterUnit(start, movePath,
() => {
path.Last().Unit.DamageUnit(carry._stackDamage, GetComponent<BaseUnit>());
//carry.Attack(path.Last().Unit);
QueueNextItem();
});
return DeselectStatus.Both;
}
private void Deselect()
{
isSelected = false;
render.color = normalColor;
previousSelected = null;
}
public override DeselectStatus MoveToMerge(TileController start, List<TileController> path) {
LandUnit carry = ((WaterUnit) start.Unit).CarryUnit.GetComponent<LandUnit>();
LandUnit mergeTarget = (LandUnit) path.Last().Unit;
MoveWaterUnit(start, path, () => {
mergeTarget.Merge(carry);
QueueNextItem();
});
path.Last().Unit = mergeTarget;
return DeselectStatus.Both;
}
private void Select()
{
isSelected = true;
render.color = selectedColor;
previousSelected = this;
}
private void MoveWaterUnit(TileController startTile, List<TileController> path, Action finalAction) {
GameObject carryUnit = GetComponent<WaterUnit>().CarryUnit;
WaterUnit startBoat = (WaterUnit) startTile.Unit;
BaseUnit unit = null;
int index = -1;
if (carryUnit != null) {
unit = carryUnit.GetComponent<BaseUnit>();
index = path.FindIndex(x => x.IsTraversable(carryUnit));
}
if (index < 0) {
StartCoroutine(AnimateToTile(path, finalAction));
if(path.Count > 0)
path.Last().Unit = GetComponent<BaseUnit>();
}
else {
if (!path.Last ().IsTraversable (carryUnit)) {
carryUnit.GetComponent<BaseUnit> ().Owner.Moves += path.Count;
return;
}
TileController[] boatPath = path.Take(index).ToArray();
TileController[] unitPath = path.Skip(index).ToArray();
if (boatPath.Length > 0) {
StartCoroutine (AnimateToTile (boatPath, () => {
startBoat.UnloadUnit (boatPath.Last ().gameObject);
unit.StartCoroutine (unit.GetComponent<LandUnitEventController> ().AnimateToTile (unitPath, finalAction));
}));
boatPath.Last ().Unit = GetComponent<BaseUnit> ();
unitPath.Last ().Unit = unit;
} else {
startBoat.UnloadUnit (unitPath.First ().gameObject);
unit.StartCoroutine(unit.GetComponent<LandUnitEventController>().AnimateToTile(unitPath, finalAction));
unitPath.Last ().Unit = unit;
}
}
if(index != 0 && path.Count > 0) // If boat also moves.
startTile.Unit = null;
}
void Awake()
{
tileModel = GetComponent <TileController>();
}
public override void ShowUnitStack(TileController ownTile) {
GameObject carry = GetComponent<WaterUnit>().CarryUnit;
if (carry == null)
return;
GameObject stackOverlay = GameObject.Find("UnitStack");
StackWindow window = stackOverlay.GetComponent<StackWindow>();
BaseUnit unit = carry.GetComponent<BaseUnit>();
window.Show(unit.GetComponent<LandUnitEventController>().StackSizeSprite, unit.Owner.Color, unit.StackSize, unit.CurrentPlayerPredicate(ownTile), UnitSplitCallback);
}
private void Awake()
{
tileController = GetComponent <TileController>();
}
public override DeselectStatus Split(GameObject mock, TileController ownTile, TileController targetTile) {
IsSplitting = false;
BaseUnit unit = mock.GetComponent<BaseUnit>();
WaterUnit water = GetComponent<WaterUnit>();
if (water.CarryUnit.GetComponent<BaseUnit>().StackSize <= unit.StackSize) {
Destroy(water.CarryUnit);
water.CarryUnit = null;
}
else
water.CarryUnit.GetComponent<BaseUnit>().StackSize -= SplitAmount;
LandUnitEventController landUnit = mock.GetComponent<LandUnitEventController>();
mock.SetActive(true);
if (targetTile.Unit == null)
landUnit.MoveToEmpty(null, new List<TileController>() { targetTile });
else
landUnit.MoveToMerge(null, new List<TileController>() { targetTile });
unit.Owner.Moves--;
ResetSplitTiles();
return DeselectStatus.Both;
}
public Astar_SM(TileController tileController)
{
this.tileController = tileController;
}
public void Select()
{
isSelected = true;
spriteRenderer.color = selectedColor;
previousSelected = this;
}
IEnumerator PlayRoundCoroutine()
{
GameState state = GameManager.instance.state;
yield return(new WaitForSeconds(.5f));
m_feedControl.Pay();
UpdateFoodCount();
UpdateHappinessCount();
Alert("Feeding the empire...");
yield return(new WaitForSeconds(ALERT_TIME));
m_investControl.Pay();
UpdateMoneyCount();
UpdateHappinessCount();
Alert("Managing investments...");
yield return(new WaitForSeconds(ALERT_TIME));
int taxes = m_MapManager.CollectTaxes();
state.m_Money += taxes;
UpdateMoneyCount();
Alert("Collecting taxes...");
yield return(new WaitForSeconds(ALERT_TIME));
int harvest = m_MapManager.HarvestFarms();
if (harvest > 0)
{
state.m_Food += harvest;
UpdateFoodCount();
Alert("Harvesting farms...");
yield return(new WaitForSeconds(ALERT_TIME));
}
int mined = m_MapManager.Mine();
if (mined > 0)
{
state.m_Money += mined;
UpdateMoneyCount();
Alert("Carving jade...");
yield return(new WaitForSeconds(ALERT_TIME));
}
yield return(StartCoroutine(TileController.ExpandTiles()));
if (state.enemyFactions.Count > 0)
{
foreach (Faction faction in state.enemyFactions)
{
int count = Random.Range(1, 3);
for (int i = 0; i < count; i++)
{
if (faction != Faction.None)
{
faction.AddSoldier();
}
}
}
Alert("The enemies have expanded their forces!");
yield return(new WaitForSeconds(ALERT_TIME));
foreach (Faction faction in state.enemyFactions)
{
bool expand = Random.value < Constants.CHANCE_TO_EXPAND;
if (expand)
{
// -1 = unable to siege, 0 = basic expansion, 1 = successful siege to player, 2 = successful siege to nonplayer, 3 = failed siege
int result = faction.MaybeSiege();
switch (result)
{
case 0:
Alert("The enemy has expanded their territory!", SIEGE_ALERT_TIME);
break;
case 1:
Alert("The enemy has taken some of your land!", SIEGE_ALERT_TIME);
state.m_Happiness += Constants.FAILED_INVADE_HAPPINESS;
state.m_Happiness = Mathf.Min(state.m_Happiness, 100);
UpdateHappinessCount();
break;
case 2:
Alert("The enemies fought each other!", SIEGE_ALERT_TIME);
break;
case 3:
Alert("The enemies failed to expand their land...", SIEGE_ALERT_TIME);
break;
}
if (result != -1)
{
yield return(new WaitForSeconds(SIEGE_ALERT_TIME));
}
}
}
}
//Random Events
if (Random.value < Constants.CHANCE_RANDOM_EVENT)
{
RandomEvents.RandomEvent randomEvent = RandomEvents.GetEvent();
yield return(StartCoroutine(EventPopup(randomEvent.message)));
randomEvent.eventFunc();
Alert(randomEvent.alert);
yield return(new WaitForSeconds(ALERT_TIME));
}
if (Faction.GetPlayer().TerritoryCount() == 0)
{
GameManager.instance.LoadLose();
}
else if (GameManager.instance.state.m_Happiness <= 0)
{
StartRebellion();
}
else if (GameManager.instance.state.m_Happiness == 100)
{
GameManager.instance.LoadWin();
}
NextRound();
}
private void SwapTile(TileController otherTile, System.Action OnComplete = null)
{
StartCoroutine(board.SwapTilePosition(this, otherTile, OnComplete));
}
public SurfaceGestureStrategy(TileController tileController,
ScreenTransformGesture twoFingerMoveGesture,
ScreenTransformGesture manipulationGesture) :
base(tileController, twoFingerMoveGesture, manipulationGesture)
{
}
public void UnCompleteView(TileController objective)
{
stateMachine.handleEvent(new CompleteCommand(objective));
}
public override void OnMouseLeave(GameObject ownTile, GameObject hoveredTile) {
if (_hoveredTile != null && !ModifiedTiles.Contains(_hoveredTile))
_hoveredTile.ResetSprite();
_hoveredTile = null;
}
public IGameState TileClicked(GameController myGameController, TileController clickedTile)
{
//nothing happens
SoundController._instance.PlayClick();
return(null);
}
private void Awake()
{
tileController = grid.GetComponent <TileController>();
nodes = tileController.GetAllNodes();
}
protected virtual void OnMouseDown()
{
lastClicked = this;
Clicked.Invoke();
}
public bool HasTile(TileController tile)
{
return(GetTileAt(tile.BoardPos) != null);
}
void SetTileAt(TileController tile, Vector2Int boardPos)
{
SetTileAt(tile, boardPos.x, boardPos.y);
}
static Node GetEndNode(TileController start, TileController end, Func<TileController, GameObject, bool> traversableCheck) {
_openList = new List<Node>();
_closedList = new List<TileController>();
Node startNode = new Node(start);
return PathFinder(startNode, new Node(end), startNode, traversableCheck);
}
public virtual DeselectStatus MoveToMerge(TileController start, List<TileController> path) {
if(start != null)
start.Unit = null;
LandUnit mergeTarget = (LandUnit) path.Last().Unit;
StartCoroutine(AnimateToTile(path, () => {
mergeTarget.Merge(GetComponent<BaseUnit>());
QueueNextItem();
}));
return DeselectStatus.Both;
}
