private static double EvalCard(GameDescriptor descriptor, Unit.OwnerEnum owner)
{
double value = 0;
for (Unit.TypeEnum type = Unit.TypeEnum.Bread; type < Unit.TypeEnum.Void; type++)
{
int tmp = descriptor.GetPlayerInfo(type, owner);
if (tmp <= 2)
{
value += CardEval[(int)type] * tmp;
}
else
{
value += CardEval[(int)type] * (tmp - 2) / 2 + CardEval[(int)type] * 2;
}
tmp = descriptor.GetPlayerInfo(type, Unit.Opposite(owner));
if (tmp <= 2)
{
value -= CardEval[(int)type] * tmp;
}
else
{
value -= CardEval[(int)type] * (tmp - 2) / 2 + CardEval[(int)type] * 2;
}
}
return(value);
}
public GameDescriptor(Board board, Unit.OwnerEnum turn)
{
units = new UnitInfo[BoardInfo.Row, BoardInfo.Col];
grids = new Board.GridState[BoardInfo.Row, BoardInfo.Col];
playerInfo = new int[2][] { new int[(int)(Unit.TypeEnum.Void)], new int[(int)(Unit.TypeEnum.Void)] };
for (int i = 0; i < BoardInfo.Row; i++)
{
for (int j = 0; j < BoardInfo.Col; j++)
{
units[i, j] = board.GetUnitInfo(new Position(i, j));
if (units[i, j].type == Unit.TypeEnum.Bread)
{
units[i, j].type = Unit.TypeEnum.Void;
}
grids[i, j] = board.GetGridState(new Position(i, j));
}
}
for (Unit.TypeEnum type = Unit.TypeEnum.Bread; type < Unit.TypeEnum.Void; type++)
{
playerInfo[(int)Unit.OwnerEnum.Black][(int)type] = board.GetPlayerInfo(type, Unit.OwnerEnum.Black);
playerInfo[(int)Unit.OwnerEnum.White][(int)type] = board.GetPlayerInfo(type, Unit.OwnerEnum.White);
}
restResource = board.RestBread;
hasMove = false;
hasBuy = false;
this.turn = turn;
}
public bool CanBuy(Unit.TypeEnum type, Unit.OwnerEnum owner)
{
if (hasBuy)
{
return(false);
}
if (!Unit.IsSoldier(type))
{
return(false);
}
if (playerInfo[(int)owner][(int)Unit.TypeEnum.Bread] < StorageInfo.CardCost[Storage.TypeToIndex(type)])
{
return(false);
}
if (GetInfo(BoardInfo.Base[(int)owner]).owner != Unit.OwnerEnum.None)
{
return(false);
}
if (type == Unit.TypeEnum.Boss && GetPlayerInfo(Unit.TypeEnum.Boss, turn) != 0)
{
return(false);
}
if (GetPlayerTotalCount(turn) - GetPlayerInfo(Unit.TypeEnum.Bread, turn) >= 5)
{
return(false);
}
return(true);
}
/// <summary>
/// Check whether now player can buy specific card or not
/// </summary>
/// <param name="type">the card's type</param>
/// <returns></returns>
private bool CanBuy(Unit.TypeEnum type)
{
if (m_hasbuy || GameInfo.Instance.controller.IsEffecting)
{
return(false);
}
if (NowPlayer.Resource < StorageInfo.CardCost[TypeToIndex(type)])
{
return(false);
}
if (GameInfo.Instance.board.GetUnitOwner(BoardInfo.Base[(int)m_turn]) != Unit.OwnerEnum.None)
{
return(false);
}
if (type == Unit.TypeEnum.Bomb && GameInfo.Instance.board.GetPlayerInfo(Unit.TypeEnum.Bomb, m_turn) >= 2)
{
return(false);
}
if (type == Unit.TypeEnum.Boss && GameInfo.Instance.board.GetPlayerInfo(Unit.TypeEnum.Boss, m_turn) != 0)
{
return(false);
}
if (GameInfo.Instance.board.GetPlayerTotalCount(m_turn) - GameInfo.Instance.board.GetPlayerInfo(Unit.TypeEnum.Bread, m_turn) >= 5)
{
return(false);
}
return(true);
}
/// <summary>
/// Rollback the board to cached state.
/// </summary>
public void RollbackGame(GameCache cache)
{
ClearGame();
boardUnit = new Unit[BoardInfo.Row, BoardInfo.Col];
boardBread = new Unit[BoardInfo.Row, BoardInfo.Col];
boardState = new GridState[BoardInfo.Row, BoardInfo.Col];
playerInfo = new Dictionary <Unit.TypeEnum, int>[2] {
new Dictionary <Unit.TypeEnum, int>(), new Dictionary <Unit.TypeEnum, int>()
};
restBreadNum = 0;
for (int i = 0; i < BoardInfo.Row; i++)
{
for (int j = 0; j < BoardInfo.Col; j++)
{
boardState[i, j] = cache.descriptor.GetGridState(i, j);
if (boardState[i, j] == GridState.Bread)
{
CreateUnit(new UnitInfo(new Position(i, j), Unit.TypeEnum.Bread));
}
var unitInfo = cache.descriptor.GetUnitInfo(i, j);
if (unitInfo.type >= Unit.TypeEnum.Scout && unitInfo.type <= Unit.TypeEnum.Bomb)
{
CreateUnit(unitInfo);
}
}
}
for (Unit.TypeEnum type = Unit.TypeEnum.Bread; type < Unit.TypeEnum.Void; type++)
{
playerInfo[(int)Unit.OwnerEnum.Black][type] = cache.descriptor.GetPlayerInfo(type, Unit.OwnerEnum.Black);
playerInfo[(int)Unit.OwnerEnum.White][type] = cache.descriptor.GetPlayerInfo(type, Unit.OwnerEnum.White);
}
restBreadNum = cache.descriptor.RestResource;
SwitchTurn(cache.descriptor.Turn);
}
void Update()
{
if (GameInfo.Instance.controller.Phase == Controller.PhaseState.Player)
{
for (var i = 0; i < NowPlayer.cards.Length; i++)
{
var card = NowPlayer.cards[i];
Unit.TypeEnum type = StorageInfo.CardTypeList[i];
if (!CanBuy(type))
{
card.Interactable = false;
}
else
{
card.Interactable = true;
}
}
}
else
{
foreach (var card in NowPlayer.cards)
{
card.Interactable = false;
}
}
}
/// <summary>
/// Check whether now player can buy specific card or not
/// </summary>
/// <param name="type">the card's type</param>
/// <returns></returns>
private bool CanBuy(Unit.TypeEnum type)
{
if (hasbuy)
{
return(false);
}
if (resourceNum[(int)turn] < StorageInfo.CardCost[TypeToIndex(type)])
{
return(false);
}
if (GlobalInfo.Instance.board.GetUnitOwner(BoardInfo.Base[(int)turn]) != Unit.OwnerEnum.None)
{
return(false);
}
if (type == Unit.TypeEnum.Boss && GlobalInfo.Instance.board.GetPlayerInfo(Unit.TypeEnum.Boss, turn) != 0)
{
return(false);
}
if (GlobalInfo.Instance.board.GetPlayerTotalCount(turn) - GlobalInfo.Instance.board.GetPlayerInfo(Unit.TypeEnum.Bread, turn) >= 5)
{
return(false);
}
return(true);
}
/// <summary>
/// To Check the result of a conflict move(or simple move when one of side is null)
/// </summary>
/// <param name="src">Source Unit's Type</param>
/// <param name="des">Destination Unit's Type</param>
/// <returns>The result of the conflict</returns>
static public ConflictResult CheckConflict(Unit.TypeEnum src, Unit.TypeEnum des)
{
if (!Unit.IsSoldier(src) || des == Unit.TypeEnum.Void)
{
return(ConflictResult.Nothing);
}
if (des == Unit.TypeEnum.Bread)
{
if (src == Unit.TypeEnum.Scout)
{
return(ConflictResult.Eat_Bread);
}
else
{
return(ConflictResult.Nothing);
}
}
else if (src == Unit.TypeEnum.Bomb || des == Unit.TypeEnum.Bomb)
{
return(ConflictResult.Boom);
}
else if (src >= des)
{
return(ConflictResult.Src_Win);
}
else
{
return(ConflictResult.Des_Win);
}
}
void Update()
{
if (GlobalInfo.Instance.controller.Phase != Controller.PhaseState.Other)
{
Transform board = NowBoard.transform.Find("Unit");
foreach (Transform card in board)
{
RaycastHit hit;
Unit.TypeEnum type = StorageInfo.CardTypeList[Convert.ToInt32(card.name)];
if (!CanBuy(type))
{
card.gameObject.SetActive(false);
card.GetComponent <Unit>().Focus = false;
}
else
{
card.gameObject.SetActive(true);
if (GlobalInfo.Instance.controller.Phase == Controller.PhaseState.Player &&
card.collider.Raycast(GlobalInfo.Instance.mainCamera.ScreenPointToRay(Input.mousePosition), out hit, 1000f))
{
card.GetComponent <Unit>().Focus = true;
if (Input.GetMouseButtonUp(0))
{
BuyCard(type, turn);
}
}
else
{
card.GetComponent <Unit>().Focus = false;
}
}
}
}
}
public void EnterUICard(int index)
{
if (GameInfo.Instance.controller.Phase == Controller.PhaseState.Player)
{
Unit.TypeEnum type = StorageInfo.CardTypeList[index];
GameInfo.Instance.characterImage.Show(ArtManager.GetCardName(type, m_turn));
}
}
private bool VerifyBoardFromProperties(Hashtable hashtable)
{
if (global::GameInfo.Instance.controller == null || !global::GameInfo.Instance.controller.IsStart)
{
return(true);
}
var board = global::GameInfo.Instance.board == null ? null : global::GameInfo.Instance.board.GenerateBoardSummary();
if (board == null)
{
return(true);
}
Debug.Log(GetBoardDebugInfo(board));
// Verify opponent resourceNum (not need for my own)
var resourceKey = Consts.PropNames.GetPlayerResourceKey(Opponent.ID);
if (hashtable.ContainsKey(resourceKey))
{
int resource = (int)hashtable[resourceKey];
if (resource != global::GameInfo.Instance.storage.GetResourceNum(OpponentTurn))
{
Debug.LogWarning(string.Format("[GameClient] resource unmatch, the local is {0}, remote is {1}.",
global::GameInfo.Instance.storage.GetResourceNum(OpponentTurn), resource));
return(false);
}
}
// Verify board slots
for (int i = 0; i < BoardInfo.Row; i++)
{
for (int j = 0; j < BoardInfo.Col; j++)
{
var slotTypeKey = Consts.PropNames.GetBoardSlotTypeKey(i, j);
var slotOwnerKey = Consts.PropNames.GetBoardSlotOwnerKey(i, j);
var slotBreadKey = Consts.PropNames.GetBoardSlotBreadKey(i, j);
if (hashtable.ContainsKey(slotTypeKey) && hashtable.ContainsKey(slotOwnerKey) && hashtable.ContainsKey(slotBreadKey))
{
Unit.TypeEnum type = (Unit.TypeEnum)hashtable[slotTypeKey];
Unit.OwnerEnum owner = (Unit.OwnerEnum)hashtable[slotOwnerKey];
bool hasBread = (bool)hashtable[slotBreadKey];
if (type != board[i, j].type || owner != board[i, j].owner || hasBread != board[i, j].hasBread)
{
Debug.LogWarning(string.Format("[GameClient] board unmatch at ({0}, {1}), the local is {2}, remote is {3}.",
i, j, board[i, j], new SlotInfo()
{
type = type, owner = owner, hasBread = hasBread
}));
return(false);
}
}
}
}
return(true);
}
public int GetPlayerTotalCount(Unit.OwnerEnum owner)
{
int sum = 0;
for (Unit.TypeEnum type = Unit.TypeEnum.Bread; type < Unit.TypeEnum.Void; type++)
{
sum += playerInfo[(int)owner][(int)type];
}
return(sum);
}
public void ClickCard(int num)
{
if (GameInfo.Instance.controller.Phase == Controller.PhaseState.Player)
{
Unit.TypeEnum type = StorageInfo.CardTypeList[num];
if (CanBuy(type))
{
GameInfo.Instance.controller.DoAction(PlayerAction.CreateBuy(type));
}
}
}
/// <summary>
/// transform card type into index of Storage card list
/// </summary>
/// <param name="type">the card's type</param>
/// <returns></returns>
static public int TypeToIndex(Unit.TypeEnum type)
{
for (int i = 0; i < StorageInfo.CardTypeList.Length; i++)
{
if (type == StorageInfo.CardTypeList[i])
{
return(i);
}
}
return(-1);
}
/// <summary>
/// Get the count of specific type&owner card in this game
/// </summary>
/// <param name="type">the type to query</param>
/// <param name="owner">the owner to query</param>
/// <returns></returns>
public int GetPlayerInfo(Unit.TypeEnum type, Unit.OwnerEnum owner)
{
if (playerInfo[(int)owner].ContainsKey(type))
{
return(playerInfo[(int)owner][type]);
}
else
{
return(0);
}
}
public bool Buy(Unit.TypeEnum type, Unit.OwnerEnum owner)
{
if (!CanBuy(type, owner))
{
return(false);
}
Put(BoardInfo.Base[(int)owner], new UnitInfo(type, owner));
playerInfo[(int)owner][(int)Unit.TypeEnum.Bread] -= StorageInfo.CardCost[Storage.TypeToIndex(type)];
hasBuy = true;
return(true);
}
public List <BuyAction> QueryBuyActions()
{
List <BuyAction> actionList = new List <BuyAction>();
for (Unit.TypeEnum type = Unit.TypeEnum.Bread + 1; type < Unit.TypeEnum.Void; type++)
{
if (CanBuy(type, turn))
{
actionList.Add(new BuyAction(type));
}
}
return(actionList);
}
/// <summary>
/// Do buy card action
/// </summary>
/// <param name="type"></param>
/// <param name="owner"></param>
/// <returns></returns>
public bool BuyCard(Unit.TypeEnum type, Unit.OwnerEnum owner)
{
Unit newCard = CreateUnit(new UnitInfo(BoardInfo.Base[(int)turn], type, owner));
Transform card = NowBoard.transform.Find("Unit").transform.Find(TypeToIndex(type).ToString());
newCard.transform.position = card.transform.position;
hasbuy = true;
newCard.Owner = owner;
GlobalInfo.Instance.board.ModifyPlayerInfo(Unit.TypeEnum.Bread, turn, -StorageInfo.CardCost[TypeToIndex(newCard.Type)]);
GlobalInfo.Instance.controller.BuyCardEffect(newCard, owner);
return(true);
}
/// <summary>
/// Do buy card action
/// </summary>
/// <param name="type"></param>
/// <param name="owner"></param>
/// <returns></returns>
public bool BuyCard(Unit.TypeEnum type, Unit.OwnerEnum owner)
{
Unit newCard = GameInfo.Instance.board.InstantiateUnit(new UnitInfo(BoardInfo.Base[(int)m_turn], type, owner));
Transform card = NowPlayer.cards[TypeToIndex(type)].transform;
newCard.transform.position = UI2WorldPosition(card.transform.position);
m_hasbuy = true;
newCard.Owner = owner;
newCard.CardActive = true;
GameInfo.Instance.board.ModifyPlayerInfo(Unit.TypeEnum.Bread, m_turn, -StorageInfo.CardCost[TypeToIndex(newCard.Type)]);
GameInfo.Instance.controller.BuyCardEffect(newCard, owner);
return(true);
}
/// <summary>
/// Modify specific type&owner info with delta
/// </summary>
/// <param name="type">the type to modify</param>
/// <param name="owner">the owner to modify</param>
/// <param name="delta">the delta to modify</param>
/// <returns></returns>
public int ModifyPlayerInfo(Unit.TypeEnum type, Unit.OwnerEnum owner, int delta)
{
if (!playerInfo[(int)owner].ContainsKey(type))
{
playerInfo[(int)owner][type] = delta;
}
else
{
playerInfo[(int)owner][type] += delta;
}
if (type == Unit.TypeEnum.Bread)
{
GameInfo.Instance.storage.UpdateResourceNum(GameInfo.Instance.board.GetPlayerInfo(Unit.TypeEnum.Bread, Unit.OwnerEnum.Black),
GameInfo.Instance.board.GetPlayerInfo(Unit.TypeEnum.Bread, Unit.OwnerEnum.White));
}
return(playerInfo[(int)owner][type]);
}
public static string GetCardName(Unit.TypeEnum type, Unit.OwnerEnum owner)
{
string spriteName;
if (type == Unit.TypeEnum.Bread)
{
spriteName = "bread";
}
else if (type == Unit.TypeEnum.Void)
{
spriteName = "void";
}
else if (type == Unit.TypeEnum.Tile)
{
spriteName = "tile";
}
else
{
spriteName = type.ToString().ToLower() + ((int)owner).ToString();
}
return(spriteName);
}
public int GetPlayerInfo(Unit.TypeEnum type, Unit.OwnerEnum owner)
{
return(playerInfo[(int)owner][(int)type]);
}
public void SetPlayerInfo(Unit.TypeEnum type, Unit.OwnerEnum owner, int value)
{
playerInfo[(int)owner][(int)type] = value;
}
public UnitInfo(Unit.TypeEnum type, Unit.OwnerEnum owner = Unit.OwnerEnum.None)
{
this.pos = new Position();
this.type = type;
this.owner = owner;
}
public Card GetBattleCardGraphics(Unit.TypeEnum type, Unit.OwnerEnum owner)
{
string spriteName = GetCardName(type, owner);
return(battleCards.ContainsKey(spriteName) ? battleCards[spriteName] : null);
}
public BuyAction(Unit.TypeEnum type = Unit.TypeEnum.Void)
{
this.type = type;
}
public UnitInfo(Unit.TypeEnum type, Unit.OwnerEnum owner = Unit.OwnerEnum.None)
{
this.pos = new Position();
this.type = type;
this.owner = owner;
}
public UnitInfo(Position pos, Unit.TypeEnum type, Unit.OwnerEnum owner = Unit.OwnerEnum.None)
{
this.pos = pos;
this.type = type;
this.owner = owner;
}
public UnitInfo(Position pos, Unit.TypeEnum type, Unit.OwnerEnum owner = Unit.OwnerEnum.None)
{
this.pos = pos;
this.type = type;
this.owner = owner;
}
public Sprite GetStorageCardSprite(Unit.TypeEnum type, Unit.OwnerEnum owner)
{
var name = GetCardName(type, owner);
return(storageCards.ContainsKey(name) ? storageCards[name] : null);
}
public BuyAction(Unit.TypeEnum type = Unit.TypeEnum.Void)
{
this.type = type;
}
public static PlayerAction CreateBuy(Unit.TypeEnum type)
{
return(new PlayerAction(new BuyAction(type)));
}
private bool _DoBuy(Unit.TypeEnum type)
{
SoundManager.Instance.PlaySound("build");
return(GameInfo.Instance.storage.BuyCard(type, turn));
}
