/* * * * * * * * *
* ON STONE MOVE
*/
public void PieceMoved(PlayerStone stone)
{
if (!p.dr.CanRoll)
{
this.p.UrHandler.NewTurn();
}
}
//float aggressivenessBonus = 0.25f;// Gets added for bops, and removed for staying on safe spaces
override protected PlayerStone PickStoneToMove(PlayerStone[] legalStones)
{
Debug.Log("AIPlayer_UtilityAI");
if (legalStones == null || legalStones.Length == 0)
{
Debug.LogError("Why are we being asked to pick from no stones");
return(null);
}
CalcTileDanger(legalStones[0].PlayerId);
//For each stone we rank how good it would be to pick it, where 1 is good -1 is bad
PlayerStone bestStone = null;
float goodness = -Mathf.Infinity;
foreach (PlayerStone ps in legalStones)
{
float g = GetStoneGoodness(ps, ps.CurrentTile, ps.GetTileAhead());
if (bestStone == null || g > goodness)
{
bestStone = ps;
goodness = g;
}
}
Debug.Log("Chosen Stone Goodness: " + goodness);
return(bestStone);
}
// Update is called once per frame
void Update()
{
if (isAnimating == false)
{
// Nothing for us to do.
return;
}
if (Vector3.Distance(
new Vector3(this.transform.position.x, targetPosition.y, this.transform.position.z),
targetPosition) < smoothDistance)
{
// We've reached the target position -- do we still have moves in the queue?
if (
(moveQueue == null || moveQueueIndex == (moveQueue.Length))
&&
((this.transform.position.y - smoothDistance) > targetPosition.y)
)
{
// We are totally out of moves (and too high up), the only thing left to do is drop down.
this.transform.position = Vector3.SmoothDamp(
this.transform.position,
new Vector3(this.transform.position.x, targetPosition.y, this.transform.position.z),
ref velocity,
smoothTimeVertical);
// Check for bops
if (stoneToBop != null)
{
stoneToBop.ReturnToStorage();
stoneToBop = null;
}
}
else
{
// Right position, right height -- let's advance the queue
AdvanceMoveQueue();
}
}
else if (this.transform.position.y < (smoothHeight - smoothDistance))
{
// We want to rise up before we move sideways.
this.transform.position = Vector3.SmoothDamp(
this.transform.position,
new Vector3(this.transform.position.x, smoothHeight, this.transform.position.z),
ref velocity,
smoothTimeVertical);
}
else
{
// Normal movement (sideways)
this.transform.position = Vector3.SmoothDamp(
this.transform.position,
new Vector3(targetPosition.x, smoothHeight, targetPosition.z),
ref velocity,
smoothTime);
}
}
void Update()
{
if (isAnimating == false)
{
return;
}
if (Vector3.Distance(
new Vector3(this.transform.position.x, targetPosition.y, this.transform.position.z),
targetPosition) < smoothDistance)
{
// We've reached the target position -- do we still have moves in the queue?
if ((moveQueue == null || moveQueueIndex == moveQueue.Length)
&&
(this.transform.position.y - smoothDistance) > targetPosition.y
)
{
// We are above target position
// Out of moves, drop down the stone
this.transform.position = Vector3.SmoothDamp(
this.transform.position,
new Vector3(this.transform.position.x, targetPosition.y, this.transform.position.z),
ref velocity,
smoothTimeVertical);
// Check for bops
if (stoneToBop != null)
{
stoneToBop.ReturnToStorage();
stoneToBop = null;
}
}
else
{
// Right position, right height, advance cube
AdvanceMoveQueue();
}
}
// Rise stone up before moving sideways
else if (this.transform.position.y < (smoothHeight - smoothDistance))
{
this.transform.position = Vector3.SmoothDamp(
this.transform.position,
new Vector3(this.transform.position.x, smoothHeight, this.transform.position.z),
ref velocity,
smoothTimeVertical);
}
else
{
this.transform.position = Vector3.SmoothDamp(
this.transform.position,
new Vector3(targetPosition.x, smoothHeight, targetPosition.z),
ref velocity,
smoothTime);
}
}
private void Update()
{
if (m_IsAnimating == false)
{
return;
}
if (Vector3.Distance(
new Vector3(this.transform.position.x, m_TargetPosition.y, this.transform.position.z),
m_TargetPosition) < m_SmoothDistance)
{
// Reached the target position
if (
(moveQueue == null || moveQueueIndex == (moveQueue.Length))
&&
((this.transform.position.y - m_SmoothDistance) > m_TargetPosition.y)
)
{
// Out of moves, need to do is drop down.
this.transform.position = Vector3.SmoothDamp(
this.transform.position,
new Vector3(this.transform.position.x, m_TargetPosition.y, this.transform.position.z),
ref m_Velocity,
m_SmoothTimeVertical);
// Check to see if we need to remove an opponents stone
if (m_StoneToBop != null)
{
m_StoneToBop.ReturnToStorage();
m_StoneToBop = null;
}
}
else
{
AdvanceMoveQueue();
}
}
else if (this.transform.position.y < (m_SmoothHeight - m_SmoothDistance))
{
// Rise up before moving sideways.
this.transform.position = Vector3.SmoothDamp(
this.transform.position,
new Vector3(this.transform.position.x, m_SmoothHeight, this.transform.position.z),
ref m_Velocity,
m_SmoothTimeVertical);
}
else
{
// Sideways movement
this.transform.position = Vector3.SmoothDamp(
this.transform.position,
new Vector3(m_TargetPosition.x, m_SmoothHeight, m_TargetPosition.z),
ref m_Velocity,
m_SmoothTime);
}
}
// Update is called once per frame
void Update()
{
if (isAnimating == false)
{
//nothing for us todo.
return;
}
if (Vector3.Distance(new Vector3(this.transform.position.x, targetPosition.y, this.transform.position.z), targetPosition) < smoothDiatance)
{
//we've reached the target position -- do we still have moves in the queue?
if ((moveQueue == null || moveQueueIndex == (moveQueue.Length))
&&
((this.transform.position.y - smoothDiatance) > targetPosition.y)
)
{
// drop down
this.transform.position = Vector3.SmoothDamp(this.transform.position,
new Vector3(this.transform.position.x, targetPosition.y, this.transform.position.z),
ref velocity,
smoothTimeVertical);
//check for bops
if (stoneToBop != null)
{
stoneToBop.ReturnToStorage();
stoneToBop = null;
}
}
else
{
//right position,right height.
AdvanceMoveQueue();
}
}
else if (this.transform.position.y < (smoothHeight - smoothDiatance))
{
// rise up before move sideways.
this.transform.position = Vector3.SmoothDamp(this.transform.position,
new Vector3(this.transform.position.x, smoothHeight, this.transform.position.z),
ref velocity,
smoothTimeVertical);
}
else
{
//normal movement
this.transform.position = Vector3.SmoothDamp(this.transform.position,
new Vector3(targetPosition.x, smoothHeight, targetPosition.z),
ref velocity,
smoothTime);
}
}
/* * * * * * * * *
* ON STONE CLICK
*/
public void PieceClicked(PlayerStone stone)
{
if (stone.CanMoveTo())
{
foreach (PlayerStone s in p.Pieces)
{
s.CanMove = false;
}
stone.StartMove();
}
}
void OnStoneKilled(int position)
{
PlayerStone stoneToMove = FindObjectsOfType <PlayerStone>()
.FirstOrDefault(stone => stone.Position == position && stone.Player == _game.OtherPlayer);
if (stoneToMove != null)
{
stoneToMove.MoveHome();
}
else
{
Debug.LogError("No stone to kill at " + position);
}
}
// Update is called once per frame
void Update()
{
if (isAnimating == false)
{
return;
}
if (Vector3.Distance(new Vector3(this.transform.position.x, targetPosition.y, this.transform.position.z), targetPosition) < smoothDistance)
{
//we have reached the target. do we still have moves in the queue?
if ((moveQueue == null || moveQueueIndex == (moveQueue.Length)) &&
(this.transform.position.y - smoothDistance) > targetPosition.y)
{
//we are above our target
//we are totally out of moves, only thing to do is drop down.
this.transform.position = Vector3.SmoothDamp(this.transform.position,
new Vector3(this.transform.position.x, targetPosition.y, this.transform.position.z), ref velocity, smoothTimeVertical);
//check for bops
if (stoneToBop != null)
{
stoneToBop.ReturnToStorage();
stoneToBop = null;
}
}
else
{
//right pos, heigh -- advance queue
AdvanceMoveQueue();
}
}
// we want to rise up before we move sideways
else if (this.transform.position.y < (smoothHeight - smoothDistance))
{
this.transform.position = Vector3.SmoothDamp(this.transform.position,
new Vector3(this.transform.position.x, smoothHeight, this.transform.position.z), ref velocity, smoothTimeVertical);
}
else
{
this.transform.position = Vector3.SmoothDamp(this.transform.position,
new Vector3(targetPosition.x, smoothHeight, targetPosition.z), ref velocity, smoothTime);
}
}
virtual protected float GetStoneGoodness(PlayerStone stone, Tile currentTile, Tile futureTile)
{
float goodness = 0;//Random.Range(-0.1f, 0.1f);
if (currentTile == null)
{
// We aren't on the board yet, and it's always nice to add more to the board to open up more options.
goodness += 0.20f;
}
if (currentTile != null && (currentTile.IsRollAgain == true && currentTile.IsSideline == false))
{
// We are sitting on a roll-again space in the middle. Let's resist moving just because
// it blocks the space from our opponent
goodness -= 0.10f;
}
if (futureTile.IsRollAgain == true)
{
goodness += 0.50f;
}
if (futureTile.PlayerStone != null && futureTile.PlayerStone.PlayerId != stone.PlayerId)
{
// There's an enemy stone to bop!
goodness += 0.50f;
}
if (futureTile.IsScoringSpace == true)
{
goodness += 0.50f;
}
float currentDanger = 0;
if (currentTile != null)
{
currentDanger = tileDanger[currentTile];
}
goodness += currentDanger - tileDanger[futureTile];
// TODO: Add goodness for tiles that are behind enemies, and therefore likely to contribute to future boppage
// TODO: Add goodness for moving a stone forward when we might be blocking friendlies
return(goodness);
}
virtual protected void DoClick()
{
//pick stone and click it
PlayerStone[] legalStones = GetLegalMoves();
if (legalStones == null || legalStones.Length == 0)
{
//we have no legal moves how did we get here?
//we might still be in a delayed corutine somewhere?
return;
}
//basic AI simply picks a legal move at random
PlayerStone pickedStone = PickStoneToMove(legalStones);
pickedStone.MoveMe();
}
virtual protected float GetStoneGoodness(PlayerStone stone, Tile currentTile, Tile futureTile)
{
float goodness = Random.Range(-0.1f, 0.1f);
if (currentTile == null)
{
//we arent on the board yet and its alaways nice to add more to the board
goodness += 0.2f;
}
if (currentTile != null && (currentTile.IsRollAgain == true && currentTile.IsSideLine == false))
{
//we are sitting on a roll again space in the middle. it is better to resist moving
goodness -= 0.10f;
}
if (futureTile.IsRollAgain == true)
{
goodness += 0.50f;
}
if (futureTile.PlayerStone != null && futureTile.PlayerStone.PlayerId != stone.PlayerId)
{
//there's an enemy stone to bop
goodness += 0.50f;
}
if (futureTile.IsScoringSpace == true)
{
goodness += 0.50f;
}
float currentDanger = 0;
if (currentTile != null)
{
currentDanger = tileDanger[currentTile];
}
goodness += currentDanger - tileDanger[futureTile];
//Add goodness for tiles in our private sidelines
//TODO: add goodness ofremoving stone forward when we block friendly.
return(goodness);
}
virtual protected void DoClick()
{
//pick a stone to move, then "click" it.
PlayerStone[] legalStones = GetLegalMoves();
if (legalStones == null || legalStones.Length == 0)
{
//we have no legal moves. how did we get here?
//we might still be in a delayed coroutine somewhere. let's no freak out.
return;
}
//basicAi simply picks a legal move at random.
PlayerStone pickStone = legalStones[Random.Range(0, legalStones.Length)];
pickStone.MoveMe();
}
virtual protected void DoClick()
{
//pick a stone to move.
PlayerStone[] legalStones = GetLegalMoves();
if (legalStones == null || legalStones.Length == 0)
{
//we have no legal moves.
return;
}
// picks a legal move at random.
PlayerStone pickStone = PickStoneToMove(legalStones);
pickStone.MoveMe();
}
void OnStoneMoved(int startPosition, int endPosition)
{
if (LastClickedStone == null)
{
LastClickedStone = FindObjectsOfType <PlayerStone>()
.FirstOrDefault(stone => stone.Position == startPosition && stone.Player == _game.CurrPlayer);
}
if (LastClickedStone != null)
{
LastClickedStone.MoveTo(endPosition);
}
else
{
Debug.LogError("No stone to move from " + startPosition + " to " + endPosition);
}
LastClickedStone = null;
}
virtual protected void DoClick()
{
// Pick a stone to move, then "click" it.
PlayerStone[] legalStones = GetLegalMoves();
if (legalStones == null || legalStones.Length == 0)
{
// We have no legal moves. How did we get here?
// We might still be in a delayed coroutine somewhere. Let's not freak out.
return;
}
// BasicAI simply picks a legal move at random
PlayerStone pickedStone = PickStoneToMove(legalStones);
pickedStone.MoveMe();
}
virtual protected float GetStonefitness(PlayerStone stone, Tile currentTile, Tile futureTile)
{
float fitness = Random.Range(-0.1f, 0.1f);
if (currentTile == null)
{
// We aren't on the board yet
fitness += 0.20f;
}
if (futureTile.PlayerStone != null && futureTile.PlayerStone.PlayerId != stone.PlayerId)
{
// There's an enemy
fitness += 0.50f;
}
if (futureTile.IsScoringSpace == true)
{
fitness += 0.50f;
}
float currentDanger = 0;
if (currentTile != null)
{
currentDanger = tileDanger[currentTile];
}
fitness += currentDanger - tileDanger[futureTile];
return(fitness);
}
public void MoveMe()
{
// Is this the correct player?
if (theStateManager.CurrentPlayerId != PlayerId)
{
return;
}
// Have we rolled the dice?
if (theStateManager.IsDoneRolling == false)
{
// We can't move yet.
return;
}
if (theStateManager.IsDoneClicking == true)
{
// We've already done a move!
return;
}
int spacesToMove = theStateManager.DiceTotal;
if (spacesToMove == 0)
{
return;
}
// Where should we end up?
moveQueue = GetTilesAhead(spacesToMove);
Tile finalTile = moveQueue[moveQueue.Length - 1];
if (finalTile != null)
{
if (CanLegallyMoveTo(finalTile) == false)
{
// Not allowed!
finalTile = CurrentTile;
moveQueue = null;
return;
}
// If there is an enemy tile in our legal space, the we kick it out.
if (finalTile.PlayerStone != null)
{
//finalTile.PlayerStone.ReturnToStorage();
stoneToFight = finalTile.PlayerStone;
stoneToFight.CurrentTile.PlayerStone = null;
stoneToFight.CurrentTile = null;
//NEED TO ADD FIGHT SCENE
}
}
this.transform.SetParent(null);
// Remove ourselves from our old tile
if (CurrentTile != null)
{
CurrentTile.PlayerStone = null;
}
// Even before the animation is done, set our current tile to the new tile
CurrentTile = finalTile;
if (finalTile.IsScoringSpace == false) // "Scoring" tiles are always "empty"
{
finalTile.PlayerStone = this;
}
moveQueueIndex = 0;
theStateManager.IsDoneClicking = true;
this.isAnimating = true;
theStateManager.AnimationsPlaying++;
}
void OnMouseUp()
{
// TODO: Is the mouse over a UI element? Ignore this click.
// Is this the correct player?
if (theStateManager.CurrentPlayerID != PlayerId)
{
return;
}
// Have we rolled the dice?
if (theStateManager.IsDoneRolling == false)
{
// We can't move yet.
return;
}
if (theStateManager.IsDoneClicking == true)
{
// We've already done a move!
return;
}
int spacesToMove = theStateManager.DiceTotal;
if (spacesToMove == 0)
{
return;
}
//Where should we end up?
moveQueue = GetTilesAhead(spacesToMove);
Tile finalTile = moveQueue[moveQueue.Length - 1];
// TODO: Check to see if the destination is legal!
if (finalTile == null)
{
// Hey, wer're scoring this stone!
//scoreMe = true;
}
else
{
if (CanLegallyMoveTo(finalTile) == false)
{
// Not allowed!
finalTile = currentTile;
moveQueue = null;
return;
}
//if there is an enemy tile in our legal space, then we kick it out.
if (finalTile.PlayerStone != null)
{
//finalTile.PlayerStone.ReturnToStorage();
stoneToBop = finalTile.PlayerStone;
stoneToBop.currentTile.PlayerStone = null;
stoneToBop.currentTile = null;
}
}
this.transform.SetParent(null);
// Remove ourselves from our old tile
if (currentTile != null)
{
currentTile.PlayerStone = null;
}
// Put ourselves in our new tile.
finalTile.PlayerStone = this;
moveQueueIndex = 0;
currentTile = finalTile;
theStateManager.IsDoneClicking = true;
this.isAnimating = true;
}
public void MoveMe()
{
// Is this the correct player?
if (theStateManager.CurrentPlayerId != PlayerId)
{
return;
}
// Have we rolled the dice?
if (theStateManager.IsDoneRolling == false)
{
// We can't move yet.
return;
}
if (theStateManager.IsDoneClicking == true)
{
// We've already done a move!
return;
}
int spacesToMove = theStateManager.DiceTotal;
if (spacesToMove == 0)
{
return;
}
// Where should we end up?
moveQueue = GetTilesAhead(spacesToMove);
Tile finalTile = moveQueue[moveQueue.Length - 1];
// TODO: Check to see if the destination is legal!
if (finalTile == null)
{
// Hey, we're scoring this stone!
scoreMe = true;
}
else
{
if (CanLegallyMoveTo(finalTile) == false)
{
// Not allowed!
finalTile = CurrentTile;
moveQueue = null;
return;
}
// If there is an enemy tile in our legal space, the we kick it out.
if (finalTile.PlayerStone != null)
{
//finalTile.PlayerStone.ReturnToStorage();
stoneToBop = finalTile.PlayerStone;
stoneToBop.CurrentTile.PlayerStone = null;
stoneToBop.CurrentTile = null;
}
}
this.transform.SetParent(null); // Become Batman
// Remove ourselves from our old tile
if (CurrentTile != null)
{
CurrentTile.PlayerStone = null;
}
// Even before the animation is done, set our current tile to the new tile
storedCurrentTile = CurrentTile;
CurrentTile = finalTile;
try{
if (finalTile.IsScoringSpace == false) // "Scoring" tiles are always "empty"
{
finalTile.PlayerStone = this;
//Debug.Log("Scored!!!!!!!!!!!!!!!!!!!!!!!!!!!");
}
if (finalTile.IsScoringSpace == true) // "Scoring" tiles are always "empty"
{
//finalTile.PlayerStone = this;
Debug.Log("Scored!!!!!!!!!!!!!!!!!!!!!!!!!!!");
Debug.Log("PlayerId" + PlayerId);
if (PlayerId == 0)
{
theStateManager.WhiteScore += 1;
Debug.Log("WhiteScore: " + theStateManager.WhiteScore);
if (theStateManager.WhiteScore == 6)
{
Debug.Log("White won");
theStateManager.winText.text = "WHITE HAS WON";
theStateManager.GameOverPanel.SetActive(true);
}
}
if (PlayerId == 1)
{
theStateManager.RedScore += 1;
Debug.Log("RedScore: " + theStateManager.RedScore);
if (theStateManager.RedScore == 6)
{
Debug.Log("Red won");
theStateManager.winText.text = "RED HAS WON";
theStateManager.GameOverPanel.SetActive(true);
}
}
}
}
catch (Exception e) {
Debug.Log(e, this);
CurrentTile = storedCurrentTile;
return;
}
moveQueueIndex = 0;
theStateManager.IsDoneClicking = true;
this.isAnimating = true;
theStateManager.AnimationsPlaying++;
}
public void MoveMe()
{
//is this the correct plauer?
if (theStateManager.CurrentPlayerId != PlayerId)
{
return;
}
if (theStateManager.IsDoneRolling == false)
{
//we can't move yet
return;
}
if (theStateManager.IsDoneClicking == true)
{
//we've already done move
return;
}
int spacesToMove = theStateManager.DiceTotal;
if (spacesToMove == 0)
{
return;
}
//where should we end up?
//if(spacesToMove ==0)
//{
// return;
//}
moveQueue = GetTilesAhead(spacesToMove);
Tile finalTile = moveQueue[moveQueue.Length - 1];
if (finalTile == null)
{
//Hey, we're scoring this stone
scoreMe = true;
}
if (finalTile != null)
{
if (CanLegallyMoveTo(finalTile) == false)
{
//not allowed
finalTile = CurrentTile;
moveQueue = null;
return;
}
//If there is an enemy tile in our legal space, then we kick it out.
if (finalTile.PlayerStone != null)
{
//finalTile.PlayerStone.ReturnToStorage();
stoneToBop = finalTile.PlayerStone;
stoneToBop.CurrentTile.PlayerStone = null;
stoneToBop.CurrentTile = null;
}
}
this.transform.SetParent(null);//we have no parent
if (CurrentTile != null)
{
CurrentTile.PlayerStone = null;
}
CurrentTile = finalTile;
if (finalTile.IsScoringSpace == false)// Scoring tiles are always empty
{
finalTile.PlayerStone = this;
}
//Even before the animation is done, set our current tile to the new tile
moveQueueIndex = 0;
theStateManager.IsDoneClicking = true;
this.isAnimating = true;
theStateManager.AnimationsPlaying++;
}
public void ToggleOccupant(PlayerStone player)
{
occupant = player;
}
public void MoveMe()
{
// Make sure each player can only move their own stones
if (m_StateManager.m_CurrentPlayerId != m_PlayerId)
{
return;
}
// Don't allow for stones to move if no roll has taken place
if (m_StateManager.m_IsDoneRolling == false)
{
return;
}
// Don't allow player to roll again once they have moved
if (m_StateManager.m_IsDoneClicking == true)
{
return;
}
int spacesToMove = m_StateManager.m_DiceTotal;
if (spacesToMove == 0)
{
return;
}
moveQueue = GetTilesAhead(spacesToMove);
GameTile finalTile = moveQueue[moveQueue.Length - 1];
if (finalTile == null)
{
m_ScoreMe = true;
}
else
{
if (CanLegallyMoveTo(finalTile) == false)
{
finalTile = m_CurrentTile;
moveQueue = null;
return;
}
// If opponent's stone in on our space remove their stone from the space
if (finalTile.m_PlayerStone != null)
{
m_StoneToBop = finalTile.m_PlayerStone;
m_StoneToBop.m_CurrentTile.m_PlayerStone = null;
m_StoneToBop.m_CurrentTile = null;
}
}
this.transform.SetParent(null);
// Remove our stone from the old tile
if (m_CurrentTile != null)
{
m_CurrentTile.m_PlayerStone = null;
}
m_CurrentTile = finalTile;
if (finalTile.m_IsScoringTile == false)
{
finalTile.m_PlayerStone = this;
}
moveQueueIndex = 0;
m_StateManager.m_IsDoneClicking = true;
this.m_IsAnimating = true;
m_StateManager.m_AnimationsPlaying++;
}
public void MoveMe()
{
//is this the correct player?
if (theStateManager.CurrentPlayerId != PlayerId)
{
return;
}
//have we rolled the dice?
if (theStateManager.IsDoneRolling == false)
{
//we haven't move yet.
return;
}
if (theStateManager.IsDoneClicking == true)
{
//we've already done a move
return;
}
int spacesToMove = theStateManager.DiceTotal;
//where should we end up.
moveQueue = GetTilesAhead(spacesToMove);
Tile FinalTile = moveQueue[moveQueue.Length - 1];
// if the destination is legal!
if (FinalTile == null && CanLegallyMoveto(FinalTile) == true)
{
return;
}
else
{
if (CanLegallyMoveto(FinalTile) == false)
{
//not allowed
FinalTile = currentTile;
moveQueue = null;
return;
}
// kik it out.
if (FinalTile.PlayerStone != null)
{
stoneToBop = FinalTile.PlayerStone;
stoneToBop.currentTile.PlayerStone = null;
stoneToBop.currentTile = null;
}
}
this.transform.SetParent(null);
//remove ourselves from our old tile
if (currentTile != null)
{
currentTile.PlayerStone = null;
}
// set our current tile to the new tile.
currentTile = FinalTile;
if (FinalTile.IsScoringSpace == false) //scoring tiles are always empty.
{
FinalTile.PlayerStone = this;
}
moveQueueIndex = 0;
theStateManager.IsDoneClicking = true;
this.isAnimating = true;
theStateManager.AnimationsPlaying++;
}
void OnMouseUp()
{
// TODO: Check if mouse is over a UI element, ignore command if true
// Is this correct player?
if (stateManager.CurrentPlayerId != playerId)
{
return;
}
// Have we rolled the dice
if (stateManager.IsDoneRolling == false)
{
// We can't move yet
return;
}
if (stateManager.IsDoneClicking == true)
{
// We already done a move
return;
}
int spacesToMove = stateManager.DiceTotal;
moveQueue = GetTilesAhead(spacesToMove);
Tile finalTile = moveQueue [moveQueue.Length - 1];
if (finalTile == null)
{
// Scoring stone
scoreMe = true;
}
else
{
if (CanLegallyMoveTo(finalTile) == false)
{
// Not allowed
finalTile = currentTile;
moveQueue = null;
// stateManager.IsDoneClicking = false;
return;
}
// If there is enemy tile in legal space, kick it out
if (finalTile.PlayerStone != null)
{
stoneToBop = finalTile.PlayerStone;
stoneToBop.currentTile.PlayerStone = null;
stoneToBop.currentTile = null;
// finalTile.PlayerStone.ReturnToStorage ();
}
}
this.transform.SetParent(null); // Become Batman
// Remove ourselves from our old tile
if (currentTile != null)
{
currentTile.PlayerStone = null;
}
// Put ourselves in our new tile
finalTile.PlayerStone = this;
moveQueueIndex = 0;
currentTile = finalTile;
stateManager.IsDoneClicking = true;
this.isAnimating = true;
}
