public void SetPlayerBoard(Player player)
{
_player = player;
_playerBoard = player.PlayerBoard;
RefreshControls();
}
void OnMouseRightDown()
{
Debug.Log("OnMouseRightDown() - " + this.name);
GameState gs = GameState.GetCurrentGameState();
PlayerBoard currentPlayer = gs.currentPlayer;
OnRightClick(currentPlayer);
}
static void printBoards(CompetitorBoard competitorBoard, PlayerBoard playerBoard)
{
Console.Clear();
Console.WriteLine("Enemy board:");
Console.WriteLine(competitorBoard);
Console.WriteLine("\nYour board");
Console.WriteLine(playerBoard);
}
public override void OnAcquireUndo(PlayerBoard plr)
{
base.OnAcquireUndo(plr);
foreach(Scarab sc in scarabList)
{
plr.DestroyScarab(sc);
}
}
public override void OnAcquireUndo(PlayerBoard plr)
{
base.OnAcquireUndo(plr);
foreach (Scarab sc in scarabList)
{
plr.DestroyScarab(sc);
}
}
// ********************* TileAbility stuff
public void FireTrigger(TileAbility.PlayerTurnStateTriggers trigState, PlayerBoard plr)
{
TileAbility[] abilityList = GetComponents<TileAbility>();
foreach(TileAbility ability in abilityList)
{
ability.FireTrigger(trigState, plr);
}
}
void OnMouseDown()
{
Debug.Log("SelectableObject.OnMouseDown()");
GameState gs = GameState.GetCurrentGameState();
PlayerBoard currentPlayer = gs.currentPlayer;
OnSelect(currentPlayer);
}
// happens when equip one on top of other
public void AllowMultipleWeaponsOnBoard()
{
_cards.Add(new EntityBuilder("", 3, 0)
.Weapon().JustPlayed().Durability(2).ToCardEntity());
var board = new PlayerBoard(_cards, true);
Assert.IsTrue(board.Hero.HasWeapon);
}
public override void OnEndOfTurn(PlayerBoard plr)
{
if (myDie)
{
if (myDie.isTemporary())
plr.DestroyDie(myDie);
}
}
void Awake()
{
curState = PlayerGameStates.WaitingNextTurn;
mayRollDice = false;
diceLockedThisTurn = 0;
lastDiceLockedThisTurn = 0;
myPlayer = GetComponent <PlayerBoard>();
}
// does something when we select this tile
public virtual void OnSelect(PlayerBoard plr)
{
GameState.Message("Tile " + this.name + " triggered OnSelect TileAbility " + this.GetType().ToString() + "\n");
if (isArtifact)
{
isArtifactUsed = true;
}
}
void OnMouseRightDown()
{
Debug.Log("DiceCup.RightClick()");
GameState gs = GameState.GetCurrentGameState();
PlayerBoard currentPlayer = gs.currentPlayer;
currentPlayer.EndTurn();
}
public override void OnStartTurn(PlayerBoard plr)
{
base.OnStartTurn(plr);
this.isUsedThisTurn = false; // refresh this every turn.
hasBeenActivatedBySpecificRoll = false;
curDie = null;
adjustedDice.Clear();
}
protected override ActionContext DoAction(ActionContext context)
{
if (context.Game == null)
{
throw new InvalidOperationException("Action context missing required property (Game)");
}
if (context.Board == null)
{
throw new InvalidOperationException("Action context missing required property (Board)");
}
GameActionData actionData = MakeActionData(context);
Game game = context.Game;
Board board = context.Board;
string[] turnOrder = game.TurnOrder;
game.CurrentTurn++;
game.CurrentTurn %= turnOrder.Length;
game.turnCount++;
game.TilesActiveThisTurn = new int[0];
if (game.FirstPlayer != game.CurrentPlayer)
{
game.AddGameAction(actionData);
return(context);
}
game.CurrentTurn++;
game.CurrentTurn %= turnOrder.Length;
game.FirstPlayer = turnOrder[game.CurrentTurn];
game.SunPosition =
(SunPosition)(((int)game.SunPosition + 1) % Enum.GetNames(typeof(SunPosition)).Length);
if (game.SunPosition == SunPosition.NorthWest)
{
game.Revolution++;
if (game.Revolution == game.LengthOfGame)
{
game.Status = GameStatus.Ended;
game.AddGameAction(actionData);
context.Game = game;
context.Board = board;
return(context);
}
}
board.Tiles = Shadow.UpdateAllShadows(board, game.SunPosition);
foreach (string playerId in game.TurnOrder)
{
PlayerBoard playerBoard = PlayerBoard.Get(game, playerId);
int earnedLight = BoardOperations.CountLight(board, playerBoard.TreeType);
Console.WriteLine($"{playerId} - {earnedLight}");
playerBoard.RecoverLight(earnedLight);
game.SetPlayerBoard(playerId, playerBoard);
}
game.AddGameAction(actionData);
return(context);
}
virtual public void OnRightClick(PlayerBoard currentPlayer)
{
if (isSetDie())
{
if (this.isUndoable)
{
MoveToSetDieArea();
}
}
}
public ShotResult PlayAIMove(GameField gameField = null)
{
gameField ??= _aiPlayer.GetGameFieldToShoot();
var shotResult = PlayerBoard.ShootAt(gameField);
AIBoard.AddShotResult(shotResult);
return(shotResult);
}
public void DrawBoard(int xSt, int ySt)
{
Console.SetCursorPosition(xSt, ySt - 2);
Console.WriteLine(" Игрок:");
PlayerBoard.DrawBoard(xSt, ySt);
Console.SetCursorPosition(xSt + 15, ySt - 2);
Console.WriteLine("Противник:");
EnemyBoard.DrawBoard(xSt + 17, ySt);
}
private void StartGame()
{
Game = new Game();
PlayerBoard.UpdateBoard(Game.Player1.GameBoard);
EnemyBoard.UpdateBoard(Game.Player1.EnemyBoard);
Game.RoundCompleted.Subscribe(UpdateBoards);
Game.GameFinished.Subscribe(GameFinished);
EndMessage = string.Empty;
EnemyBoard.IsActive = true;
}
public ShootResultDTO MakeComputerMovement()
{
CheckIfGameEnded();
var shotCoordinates = _difficulty.ChooseShotCoordinates(PlayerBoard);
var result = PlayerBoard.Shoot(shotCoordinates.Key, shotCoordinates.Value);
return(result);
}
public override void OnEndOfTurn(PlayerBoard plr)
{
if (myDie)
{
if (myDie.isTemporary())
{
plr.DestroyDie(myDie);
}
}
}
//接受操作
//播放动画
//处理流程功能
public void Draw(PlayerBoard _turnplayer)
{
//切换界面
GameObject[] container = null;
switch (Main.Inst.lv_ctrl.map_data.my_type)
{
case eMapType.PvE_Solo:
//PvE下仅一人，不做显示处理
break;
case eMapType.PvE_Mult:
//PvP 正式游戏的单个客户端只显示一个人的数据
break;
case eMapType.PvP_2P:
//PvP下的处理
if (_turnplayer.ID == ePlayer.Player1)
{
container = Main.Inst.cardcont_p1;
Main.Inst.player_1.setBorderOn();
Main.Inst.player_2.setBorderOff();
}
else
{
container = Main.Inst.cardcont_p2;
Main.Inst.player_1.setBorderOff();
Main.Inst.player_2.setBorderOn();
}
Main.Inst.setHand(_turnplayer.hand_cards, container);
break;
}
//回合开始秀
// Main.Instance.TurnStart(_turnplayer.ID);
//清空操作标记
Main.Inst.b_attacked = false;
Main.Inst.b_moving_chess = false;
//玩家抽牌逻辑
if (_turnplayer.hand_cards.Count < 5)
{
if (!_turnplayer.orenotan_draw())
{
Debug.Log("牌堆没牌了");
//return;
}
//removeCard((Card)_turnplayer.hand_cards[0]);
}
Main.Inst.b_setchess = false;
Main.Inst.setHand(_turnplayer.hand_cards, container);
//clickCardContainer(container[0].GetComponent<CardContainer>());
Main.Inst.b_phase_trigger = true;
Main.Inst.now_phase_type++;
}
// a click on the Dice Cup means the player may want to roll dice OR end the turn
void OnMouseDown()
{
Debug.Log("DiceCup.OnMouseDown()");
GameState gs = GameState.GetCurrentGameState();
PlayerBoard currentPlayer = gs.currentPlayer;
if (currentPlayer.RollDice()) // attempt to roll dice
{
StartRolling();
}
// otherwise, if no dice were rolled, it implies end of turn
}
protected override ActionContext DoAction(ActionContext context)
{
if (context.Game == null)
{
throw new InvalidOperationException("Action context missing required property (Game)");
}
if (context.Board == null)
{
throw new InvalidOperationException("Action context missing required property (Board)");
}
if (context.Origin == null)
{
throw new InvalidOperationException("Action context missing required property (Origin)");
}
if (context.Target == null)
{
throw new InvalidOperationException("Action context missing required property (Target)");
}
GameActionData actionData = MakeActionData(context);
Game game = context.Game;
Board board = context.Board;
Hex origin = context.Origin.Value;
string playerId = context.PlayerId;
int tileCode = board[origin];
int growingTypeCode = (int)(Tile.GetPieceType(tileCode) ?? 0);
int grownTypeCode = growingTypeCode + 1;
int price = grownTypeCode;
PlayerBoard playerBoard = PlayerBoard.Get(game, playerId);
playerBoard.Pieces((PieceType)grownTypeCode).DecreaseAvailable();
int resultingTile = Tile.SetPieceType(tileCode, (PieceType)grownTypeCode);
playerBoard.Pieces((PieceType)growingTypeCode).IncreaseOnPlayerBoard();
playerBoard.SpendLight(price);
game.SetPlayerBoard(playerId, playerBoard);
board[origin] = resultingTile;
board.Tiles = Shadow.UpdateAllShadows(board, game.SunPosition);
game.TilesActiveThisTurn =
game.TilesActiveThisTurn.Where(h => h != origin.HexCode).Append(origin.HexCode).ToArray();
game.AddGameAction(actionData);
context.Game = game;
context.Board = board;
return(context);
}
public override void OnSelect(PlayerBoard plr)
{
if (!isArtifactUsed)
{
base.OnSelect(plr);
OnAcquire(plr); // do the same thing as acquire.
}
else
{
GameState.Message("Artifact " + this.name + " has already been used this game.");
}
}
public override void OnSelect(PlayerBoard plr)
{
if (!isArtifactUsed)
{
base.OnSelect(plr);
OnAcquire(plr); // do the same thing as acquire.
}
else
{
GameState.Message("Artifact " + this.name + " has already been used this game.");
}
}
PlayerBoard NextPlayer()
{
int idx = GetPlayerIndex(currentPlayer);
idx++;
if (idx >= allPlayers.Count)
{
idx = 0;
}
PlayerBoard nextPlr = allPlayers [idx];
return(nextPlr);
}
public ResourceSegment(PopulationType type, PlayerBoard board)
{
var msg = "Storage: {0}[placeholder]</br>Production: {1}</br>Next Production: {2}";
msg = String.Format(msg, board.GetStorage(type), board.GetProduction(type), board.GetNextProduction(type));
if (type == PopulationType.Money)
msg= msg.Replace("[placeholder]", "</br>Production less upkeep: " + (board.GetProduction(PopulationType.Money) - board.GetUpkeep()).ToString());
else
msg = msg.Replace("[placeholder]", "");
Description = msg;
Name = type.ToString();
}
void NewGame(int numPlrs)
{
Message("Starting new game with " + numPlrs.ToString() + " players.");
foreach (PlayerBoard plr in allPlayers)
{
plr.NewGame();
}
int rndIndex = (int)(Random.value * (float)allPlayers.Count);
currentPlayer = allPlayers [rndIndex];
currentPlayer.SetStartPlayer();
StartTurn();
}
protected override ActionContext DoAction(ActionContext context)
{
if (context.Game == null)
{
throw new InvalidOperationException("Action context missing required property (Game)");
}
if (context.Board == null)
{
throw new InvalidOperationException("Action context missing required property (Board)");
}
if (context.Origin == null)
{
throw new InvalidOperationException("Action context missing required property (Origin)");
}
if (context.Target == null)
{
throw new InvalidOperationException("Action context missing required property (Target)");
}
GameActionData actionData = MakeActionData(context);
string playerId = context.PlayerId;
Game game = context.Game;
Board board = context.Board;
Hex origin = (Hex)context.Origin;
PlayerBoard playerBoard = PlayerBoard.Get(game, playerId);
Scoring.Token[] playerScore = game.Scores[playerId];
playerBoard.SpendLight(4);
board[origin] = Tile.Empty;
playerBoard.Pieces(PieceType.LargeTree).IncreaseOnPlayerBoard();
if (ScoreTokens.Take(game, origin, out Scoring.Token? token))
{
if (token != null)
{
game.Scores[playerId] = playerScore !.Append(token).ToArray();
}
}
PlayerBoard.Set(game, playerId, playerBoard);
board.Tiles = Shadow.UpdateAllShadows(board, game.SunPosition);
game.TilesActiveThisTurn =
game.TilesActiveThisTurn.Where(h => h != origin.HexCode).Append(origin.HexCode).ToArray();
game.AddGameAction(actionData);
return(context);
}
public BuyAction(Params actionParams) : base(actionParams)
{
(ActionRequest request, string playerId, Game? game, _, _) = actionParams;
Game = game !;
PieceType pieceType = (PieceType)request.PieceType !;
int cost = PlayerBoard.Get(Game, playerId).Pieces(pieceType).NextPrice;
AddValidators(
new AActionValidator[] {
new PlayerHasPieceOnPlayerBoard(playerId, pieceType, Game),
new PlayerCanAffordCost(PlayerId, cost, Game),
}
);
}
int GetPlayerIndex(PlayerBoard match_plr)
{
int idx = -1;
foreach (PlayerBoard plr in allPlayers)
{
idx++;
if (plr == match_plr)
{
return(idx);
}
}
return(idx);
}
public override void OnLockedAny(PlayerBoard plr)
{
base.OnLockedAny(plr);
// check to see if the player already has a Herder Die
if (plr.hasHerderDie()) return; // early bail. Probably print some sort of message and give the scarab tokens.
// check to see if the player has a locked pair
// if so, do the same thing as acquire
if (isQualified())
{
myDie = GetNewDie(plr);
plr.GiveHerderDie(myDie);
}
}
// this calls the actual delegates for the triggers
public virtual void ActualFireTrigger(PlayerTurnStateTriggers trig, PlayerBoard plr)
{
switch (trig)
{
default:
case PlayerTurnStateTriggers.OnSpecificRoll: // my die has rolled. Send the trigger of what that roll was so that the TileAbility may react to it.
int dieRoll = this.myDie.GetValue();
OnSpecificDie(dieRoll);
break;
case PlayerTurnStateTriggers.NoTrigger:
break;
case PlayerTurnStateTriggers.StartOfRoll:
OnStartRoll(plr);
break;
case PlayerTurnStateTriggers.StartOfTurn:
OnStartTurn(plr);
break;
case PlayerTurnStateTriggers.EndOfTurn:
OnEndOfTurn(plr);
break;
case PlayerTurnStateTriggers.AllLocked:
OnAllLocked(plr);
break;
case PlayerTurnStateTriggers.Acquire:
OnAcquire(plr);
break;
case PlayerTurnStateTriggers.AcquireUndo:
OnAcquireUndo(plr);
break;
case PlayerTurnStateTriggers.Select:
OnSelect(plr);
break;
case PlayerTurnStateTriggers.ChooseDie:
OnChooseDie(plr);
break;
case PlayerTurnStateTriggers.LockedAny:
OnLockedAny(plr);
break;
}
}
} // UpdatePlayer output
private void LoadBoards()
{
var xmlSerializer = new ExtendedXmlSerializer(string.Empty);
InitialGameMasterBoard =
xmlSerializer.DeserializeFromXmlFile <GameMasterBoard>(ScenarioFileBase + GMInitialSufix);
UpdatedGameMasterBoard =
xmlSerializer.DeserializeFromXmlFile <GameMasterBoard>(ScenarioFileBase + GMUpdatedSufix);
InitialPlayerBoard =
xmlSerializer.DeserializeFromXmlFile <PlayerBoard>(ScenarioFileBase + PlayerInitialSufix);
UpdatedPlayerBoard =
xmlSerializer.DeserializeFromXmlFile <PlayerBoard>(ScenarioFileBase + PlayerUpdatedSufix);
}
public WinnerType GetWinner()
{
if (AIBoard.AllShipsAreSunk())
{
return(WinnerType.Player);
}
if (PlayerBoard.AllShipsAreSunk())
{
return(WinnerType.Computer);
}
return(WinnerType.None);
}
public void CalculateEndGameBonus_Unocupplied()
{
//Arrange
var cityHall = new CityHall();
cityHall.Occupation.Add(false);
var playerBoard = new PlayerBoard(null);
playerBoard.CitySpaces.Add(cityHall);
//Act
var result = cityHall.CalculateEndGameBonus(playerBoard);
//Assert
Assert.AreEqual(result, 0);
}
public ComputerAttackResult AttackPlayer()
{
ComputerAttackResult compu = new ComputerAttackResult();
compu.Row = RandomManager.GetNext(0, PlayerBoard.Size);
compu.Col = RandomManager.GetNext(0, PlayerBoard.Size);
compu.Result = PlayerBoard.Attack(new Location(compu.Row, compu.Col));
while (compu.Result == AttackResult.repeat)
{
compu.Row = RandomManager.GetNext(0, PlayerBoard.Size);
compu.Col = RandomManager.GetNext(0, PlayerBoard.Size);
compu.Result = PlayerBoard.Attack(new Location(compu.Row, compu.Col));
}
return(compu);
}
List<Scarab> scarabList; // the scarab that is associated with this tile.
#endregion Fields
#region Methods
// does something when we acquire this tile
public override void OnAcquire(PlayerBoard plr)
{
base.OnAcquire(plr);
if (doubleCurrentTokens_Ankh)
{
nScarabs = plr.CountScarabs();
}
for (int ii = 0; ii < nScarabs; ii++)
{
rndType = (Scarab.ScarabType)Random.Range(0, 2);
Scarab bug = plr.AddScarab(rndType);
scarabList.Add(bug);
bug.name = "Scarab " + rndType.ToString();
}
}
public override void OnSelect(PlayerBoard plr)
{
base.OnSelect(plr);
if (this.isUsedThisTurn && this.onlyOneUsePerTurn)
{
GameState.Message("Already used " + this.name + "\nduring this turn.");
return;
}
if (this.isUsedThisRoll)
{
GameState.Message("Already used " + this.name + "\nduring this roll.");
return;
}
// sometimes, this is a DieAbility rather than a TileAbility. SOme die abilities only are allowed on certain rolls of that die.
if (specificRoll > 0)
{
if (this.myDie != null)
{
if (this.myDie.GetValue() != specificRoll)
{
GameState.Message("Die " + this.myDie.name + " must be " + specificRoll.ToString() + " to use this ability.\n");
return;
}
}
}
curDie = null;
adjustedDice.Clear();
if (nDice == -1)
{
actualNumDice = plr.GetNumValidDice(onlyFor);
}
else
{
actualNumDice = nDice;
}
myPlayer = plr;
plr.SetTileInUse(this.GetComponent<Tile>());
plr.AskToChooseDie(this.PickDie, this.GetType().ToString()); // ask the player to choose a die or dice
plr.AskToChooseCancel(this.OnCancel);
plr.AskToChooseDone(this.OnDone);
}
// this calls the actual delegates for the triggers
public virtual void ActualFireTrigger(PlayerTurnStateTriggers trig, PlayerBoard plr)
{
switch (trig)
{
default:
case PlayerTurnStateTriggers.OnSpecificRoll: // my die has rolled. Send the trigger of what that roll was so that the TileAbility may react to it.
int dieRoll = this.myDie.GetValue();
OnSpecificDie(dieRoll);
break;
case PlayerTurnStateTriggers.NoTrigger:
break;
case PlayerTurnStateTriggers.StartOfRoll:
OnStartRoll(plr);
break;
case PlayerTurnStateTriggers.StartOfTurn:
OnStartTurn(plr);
break;
case PlayerTurnStateTriggers.EndOfTurn:
OnEndOfTurn(plr);
break;
case PlayerTurnStateTriggers.AllLocked:
OnAllLocked(plr);
break;
case PlayerTurnStateTriggers.Acquire:
OnAcquire(plr);
break;
case PlayerTurnStateTriggers.AcquireUndo:
OnAcquireUndo(plr);
break;
case PlayerTurnStateTriggers.Select:
OnSelect(plr);
break;
case PlayerTurnStateTriggers.ChooseDie:
OnChooseDie(plr);
break;
case PlayerTurnStateTriggers.LockedAny:
OnLockedAny(plr);
break;
}
}
protected override void SetupStorage(PlayerBoard board)
{
board.MoneyStorage = board.ScienceStorage = 3;
board.MaterialsStorage = 5;
}
public override void OnChooseDie(PlayerBoard plr)
{
base.OnChooseDie(plr);
}
public override void OnStartTurn(PlayerBoard plr)
{
base.OnStartTurn(plr);
myDie = GetNewDie(plr);
}
// does something on the start of each turn
public virtual void OnStartTurn(PlayerBoard plr)
{
GameState.Message("Tile " + this.name + " triggered OnStartTurn TileAbility " + this.GetType().ToString() + "\n");
}
public override void OnStartRoll(PlayerBoard plr)
{
this.isUsedThisRoll = false;
}
// returns true - if trigger is allowed to fire its delegate
// returns false - if trigger is not selected as one of the allowed triggers
public virtual bool FilterTriggers(PlayerTurnStateTriggers trig, PlayerBoard plr)
{
bool isAllowed = false;
if (onStateTrigger==PlayerTurnStateTriggers.AllTrigger) isAllowed = true;
if (trig == PlayerTurnStateTriggers.AcquireUndo) isAllowed = true;
if (trig == onStateTrigger) isAllowed = true;
foreach(PlayerTurnStateTriggers testTrig in fireOnTriggerList)
{
if (testTrig == trig) isAllowed = true;
}
return isAllowed;
}
// does something when we select this tile
public virtual void OnSelect(PlayerBoard plr)
{
GameState.Message("Tile " + this.name + " triggered OnSelect TileAbility " + this.GetType().ToString() + "\n");
if (isArtifact)
isArtifactUsed = true;
}
void Awake()
{
curState = PlayerGameStates.WaitingNextTurn;
mayRollDice = false;
diceLockedThisTurn = 0;
lastDiceLockedThisTurn = 0;
myPlayer = GetComponent<PlayerBoard>();
}
public override void OnStartTurn(PlayerBoard plr)
{
base.OnStartTurn(plr);
OnAcquire(plr); // do the same thing as acquire.
}
public void OnAcquire(PlayerBoard plr)
{
TileAbility[] abilities = GetComponents<TileAbility>();
foreach(TileAbility ability in abilities) {
ability.OnAcquire(plr);
}
}
public override void OnAcquireUndo(PlayerBoard plr)
{
base.OnAcquireUndo(plr);
plr.DestroyDie(myDie);
myDie = null;
}
public override void OnStartTurn(PlayerBoard plr)
{
base.OnStartTurn(plr);
this.isUsedThisTurn = false; // refresh this every turn.
hasBeenActivatedBySpecificRoll = false;
curDie = null;
adjustedDice.Clear();
}
// received a type of trigger from somewhere. If this TileAbility is listening for it, then fire it off using the appropriate delegate
// AllTrigger - listens to all triggers and fires off delegates (if any) on all of them.
// AcquireUndo - is a system level trigger and must always fire.
public virtual void FireTrigger(PlayerTurnStateTriggers trig, PlayerBoard plr)
{
/* // old logic
if (onStateTrigger != PlayerTurnStateTriggers.AllTrigger) // if we trigger on all triggers, ignore this bail.
{
if (trig != PlayerTurnStateTriggers.AcquireUndo) // undo does not bail but always goes through
{
if (onStateTrigger != trig) return; // bail if it's not the right trigger.
}
}
*/
bool allowTriggerToFire = FilterTriggers(trig, plr);
if (allowTriggerToFire)
ActualFireTrigger(trig, plr);
}
public virtual void OnSelect(PlayerBoard currentPlayer)
{
Debug.Log("SelectableObject.OnSelect():" + this.gameObject.name + " by: " + currentPlayer.name);
}
// get a new die that is ready to roll immediately
PharoahDie GetNewDie(PlayerBoard plr)
{
PharoahDie die = plr.AddDie(type);
myDie = die; // remember the die that this tileAbility bought. We may need to do something with it later.
if (setDieValue > 0)
{
die.MakeSetDie(setDieValue);
}
if (isTemporary)
die.MakeTemporary();
return die;
}
// does something when we acquire this tile
public override void OnAcquire(PlayerBoard plr)
{
base.OnAcquire(plr);
myDie = GetNewDie(plr);
myDie.PurchasedDie(this);
}
public override void OnSelect(PlayerBoard currentPlayer)
{
base.OnSelect(currentPlayer);
if (GameState.GetCurrentGameState().CheatModeEnabled)
{
// if the player does not have this tile and we're not in a slot and we're in cheat mode, then acquire this tile temporarily because it's probably for testing.
if (!currentPlayer.Has(this) && !mySlot)
{
// minghack: Put this tile into the player's temporary tile stack so that we may test loose tiles easily.
GameState.Message("Cheat:" + currentPlayer.name + " adds temp tile" + this.name);
currentPlayer.AddTempTile(this);
}
}
if (currentPlayer.Has(this)) {
if (this.canUndo)
{
this.ReturnToSlot();
currentPlayer.Drop(this);
}
else if (this.canActivate())
{
this.FireTrigger(TileAbility.PlayerTurnStateTriggers.Select, currentPlayer);
}
}
else {
bool bQualifiedToPurchase = false;
if (mySlot)
{
bQualifiedToPurchase = mySlot.isQualified();
}
else
{
Debug.LogError("No Slot found for Tile " + this.name);
}
if (bQualifiedToPurchase) {
bool bGotOne = mySlot.HasOne();
if (bGotOne) {
bool bSuccessfulTake = currentPlayer.Take(this);
if (bSuccessfulTake)
mySlot.TakeOne();
}
else {
GameState.Message(mySlot.name + " is out of " + this.name + " so " + currentPlayer.name + " got none!");
}
}
else {
//string msg = (mySlot.name + " is not qualified to buy " + this.name + "\nbecause it didn't satisfy" + mySlot.name);
string msg = "";
if (mySlot)
{
msg = ("Cannot claim " + this.name + "\nbecause locked dice did not satisfy\n" + mySlot.name);
}
else
{
msg = this.name + " was not in a slot.";
}
GameState.Message(msg);
}
}
}
