public void EnableChoice()
{
CurStep = eCHOICE_STEP.None;
ViewSelectIndex = -1;
ThrowSelectIndex = -1;
gameObject.SetActive(true);
ThrowText.SetActive(true);
OpenText.SetActive(false);
for (int i = CardList.Count - 1; i >= 0; --i)
{
Destroy(CardList[i].gameObject);
}
CardList.Clear();
PlayerBase player = GameSingleton.GetPlay().ToSevenPoker().GetMyPlayer();
var list = player.CardList;
assert.set(list.Count == 4);
for (int i = 0; i < list.Count; ++i)
{
CardInfo_Trump info = new CardInfo_Trump();
info.Clone(list[i]);
info.EnableSelectBtn = true;
Card_Base cardClass = GameSingleton.GetPlay().CreateCard(CardSetTr, info);
cardClass.SetSelectBtnDelegate(OnClick_ChoiceCard, i);
cardClass.ToTrump().SetBackBtnDelegate(OnClick_ChoiceCard, i);
CardList.Add(cardClass);
}
}
public void AddNewCard(GameObject CardPrefab)
{
Card_Base card = Instantiate(CardPrefab).GetComponent <Card_Base>();
UIManager.instance.AddCard(card.gameObject, camp);
AddToUsedCards(card);
}
public Card_Base CreateCard(Transform parent, CardInfoBase cardInfo)
{
Card_Base CardClass = null;
if (cardInfo is CardInfo_Trump)
{
GameObject prefab = GlobalFunc.Load("Play/_PlayCommon/TrumpCard");
GameObject CardObject = Instantiate <GameObject>(prefab, parent);
assert.set(CardObject);
Card_Trump newCardClass = CardObject.GetComponent <Card_Trump>();
newCardClass.CardInfo.Clone(cardInfo);
CardClass = newCardClass;
}
else
{
assert.set(cardInfo is CardInfo_Gostop);
GameObject prefab = GlobalFunc.Load("Play/_PlayCommon/GostopCard");
GameObject CardObject = Instantiate <GameObject>(prefab, parent);
assert.set(CardObject);
Card_Gostop newCardClass = CardObject.GetComponent <Card_Gostop>();
newCardClass.CardInfo.Clone(cardInfo);
CardClass = newCardClass;
}
assert.set(CardClass);
return(CardClass);
}
public void SetCard(GameObject _cardPrefab)
{
cardPrefab = _cardPrefab;
Card_Base card = cardPrefab.GetComponent <Card_Base>();
cardAppearence.RefreshAppearence(card);
}
public void MouseDownOnCard(Card_Base card)
{
if (SelectCard == null && InGameManager.isGameState(GameStateType.Decision) && card.isActive)
{
SelectCard = card;
UpdateInteractableCells(true, card);
PlayerController.instance.jobType = PointerJobType.UseCard;
}
}
public void AddToUsedCards(Card_Base card)
{
UsedCardsDeck.Add(card);
card.gameObject.SetActive(false);
card.isActive = false;
Cards.Remove(card);
}
//public void AddCard_ByInfo(CardInfoBase cardInfo, Transform cardSet = null)
//{
// CardList.Add(cardInfo);
// // 카드 오브젝트 생성
// if( cardSet == null )
// {
// cardSet = GetPlayerUI().GetCardSet();
// }
// Card_Base cardClass = GameSingleton.GetPlay().CreateCard(cardSet, cardInfo);
// assert.set(cardClass);
// GetPlayerUI().AddCardClass(cardClass);
//}
public void AddCard_ByClass(Card_Base cardClass)
{
// 부모 연결
cardClass.transform.SetParent(GetPlayerUI().GetCardSet());
// 알파 변동
GlobalFunc.SetAlpha(cardClass.GetCardImage(), 1.0f);
CardList.Add(cardClass.GetCardInfo());
GetPlayerUI().AddCardClass(cardClass);
}
public void CardMoveToTail(int CardIndex)
{
assert.set(CardUIList.Count > CardIndex && CardIndex >= 0);
Card_Base cardClass = CardUIList[CardIndex];
CardUIList.RemoveAt(CardIndex);
CardUIList.Add(cardClass);
cardClass.transform.SetAsLastSibling();
}
public void OnClick_ChoiceCard(int ChoiceIndex)
{
assert.set(ChoiceIndex < 4);
assert.set(ChoiceIndex >= 0);
switch (CurStep)
{
case eCHOICE_STEP.None:
{
CurStep = eCHOICE_STEP.ThrowSelect;
ThrowSelectIndex = ChoiceIndex;
Card_Base cardClass = CardList[ChoiceIndex];
cardClass.SetCardView(PlayTypes.CardView.Back);
cardClass.SetEnableSelectBtn(false);
cardClass.ToTrump().SetEnableBackBtn(true);
ThrowText.SetActive(false);
OpenText.SetActive(true);
}
break;
case eCHOICE_STEP.ThrowSelect:
{
if (ThrowSelectIndex == ChoiceIndex)
{
Card_Base cardClass = CardList[ChoiceIndex];
cardClass.SetCardView(PlayTypes.CardView.Front);
cardClass.SetEnableSelectBtn(true);
cardClass.ToTrump().SetEnableBackBtn(false);
ThrowText.SetActive(true);
OpenText.SetActive(false);
CurStep = eCHOICE_STEP.None;
ThrowSelectIndex = -1;
}
else
{
CurStep = eCHOICE_STEP.ViewSelect;
ViewSelectIndex = ChoiceIndex;
// 버리고 나서의 선택카드 인덱싱 - 서버 전달 헷갈리지 말자
if (ViewSelectIndex > ThrowSelectIndex)
{
--ViewSelectIndex;
}
GameSingleton.GetPlay().ToSevenPoker().Send_ChoiceComplete(ThrowSelectIndex, ViewSelectIndex);
}
}
break;
}
}
public void InstantiateMarkPoint(Card_Base card, List <Defines.Position> pos, bool isCopy = true)
{
m_targetCard = card;
m_playerPos = Managers.Object.Player.GetComponent <Char_BaseCtr>().Position;
for (int i = 0; i < pos.Count; i++)
{
GameObject go = GameObject.Instantiate(m_markPoint.gameObject, m_markPointHolder);
go.GetComponent <SelectingMarkBehavior>().SetPosition(new Defines.Position(pos[i].posX, pos[i].posY));
m_listfMarkPoints.Add(go.transform);
}
}
public void UseCard(Card_Base card, HexCell cell)
{
if (card.CanUseCard(this, cell))
{
card.CardEffect(this, cell);
AddToUsedCards(card);
ActionPoint -= card.ActionPointCost();
// 向服务器汇报使用卡的ID
CardIDSystem.instance.GetCardID(card.CardName);
}
}
public Card_Base CreateBoardCard(CardInfoBase cardInfo, Vector3 Position, float Alpha = 1.0f)
{
Card_Base CardClass = CreateCard(GetBoard().transform, cardInfo);
assert.set(CardClass);
CardClass.transform.position = Position;
if (Alpha < 1.0f)
{
GlobalFunc.SetAlpha(CardClass.GetCardImage(), Alpha);
}
return(CardClass);
}
public void StartChooseCard(GameObject[] cards, HexCell cell)
{
gameObject.SetActive(true);
CardButtons = new GameObject[cards.Length];
for (int i = 0; i < cards.Length; i++)
{
Card_Base card = cards[i].GetComponent <Card_Base>();
GameObject g = Instantiate(cardButtonObj, cardHolderTransform);
g.GetComponent <UI_ChooseCardButton>().SetCard(cards[i]);
CardButtons[i] = g;
}
HintText.text = "你占领了" + ArtResourceManager.ConverCellTypeText(cell.CellType) + "\n选择一张卡牌";
}
public void shuffleDraw()
{
int cardsToShuffle = draw.Count;
System.Random rng = new System.Random();
while (cardsToShuffle > 0)
{
cardsToShuffle--;
int differentCard = rng.Next(cardsToShuffle);
Card_Base temp = draw[differentCard];
draw[differentCard] = draw[cardsToShuffle];
draw[cardsToShuffle] = temp;
}
}
public void ArrangeCards()
{
if (playerCardManager.Cards != null)
{
int count = playerCardManager.Cards.Count;
for (int i = 0; i < count; i++)
{
float PosIndex = i - (count - 1f) / 2f;
Vector3 position;
Card_Base card = playerCardManager.Cards[i];
if (card != SelectCard)
{
float angle;
angle = PosIndex * CardAngle;
position = new Vector3(0, yM, 0);
position = Quaternion.Euler(0, 0, angle) * position;
position += PlayerCardHolder.transform.position + new Vector3(0, YOffset, 0);
card.transform.position = Vector3.Lerp(card.transform.position, position, 0.15f);
Quaternion q = Quaternion.Euler(0, 0, angle);
card.transform.rotation = Quaternion.Slerp(card.transform.rotation, q, 0.15f);
}
else
{
position = Input.mousePosition;
position.z = 0;
card.transform.position = Vector3.Lerp(card.transform.position, position, 0.2f);
card.transform.rotation = Quaternion.Slerp(card.transform.rotation, Quaternion.identity, 0.15f);
if (Input.mousePosition.y > ReleaseThreshold)
{
if (!SelectCard.NoneTargetCard())
{
UI_ArrowMesh.instance.SetVisibility(true);
SelectCard.GetComponent <CardAppearence>().SetVisibility(false);
}
if (SelectCell != null)
{
//UI_ArrowMesh.instance.UpdatePosition(MousePoint);
}
}
}
}
}
}
protected void _CardShareToPlayer(CardInfoBase info, PlayerBase player, Vector3 Start, float time, iTween.EaseType easeType = iTween.EaseType.easeOutQuad)
{
Card_Base newCardClass = CreateBoardCard(info, Start, 0.3f);
newCardClass.TargetPlayer = player;
iTween.MoveTo(newCardClass.gameObject,
iTween.Hash("position", player.GetPlayerUI().GetNextCardPosition(),
"easetype", easeType,
"oncomplete", "OnCompleteCardShareToPlayer",
"oncompletetarget", gameObject,
"oncompleteparams", newCardClass,
"time", time)
);
}
// ===========================================================================
//
// Card
//
// ===========================================================================
override public void AddCardClass(Card_Base cardClas)
{
base.AddCardClass(cardClas);
if (GetPlayer().ToSevenPoker().IsMyPlayer() == true)
{
switch (CurStep)
{
case PlayTypes.SevenPokerStep.Begin:
{
cardClas.SetCardView(PlayTypes.CardView.Front);
}
break;
}
}
}
public void UpdateInteractableCells(bool ShowGrid, Card_Base card)
{
InteractableCells = new List <HexCell>();
if (ShowGrid)
{
if (card != null)
{
InteractableCells = card.GetCanUseCells(playerCardManager);
}
else
{
InteractableCells = playerCardManager.CanMoveCells;
}
}
foreach (HexCell cell in HexGrid.instance.cells)
{
cell.HighLightCell(InteractableCells.Contains(cell));
}
}
private IEnumerator PlayCardProcess()
{
yield return(new WaitForSeconds(0.5f));
EvaluateGridValue();
bool haveCardToUse = true;
while (haveCardToUse)
{
yield return(new WaitForSeconds(0.02f));
haveCardToUse = false;
for (int i = 0; i < cardManager.Cards.Count; i++)
{
Card_Base card = cardManager.Cards[i];
HexCell cell = null;
List <HexCell> canUseCells = card.GetCanUseCells(cardManager);
if (canUseCells.Count > 0)
{
cell = GetMVC(canUseCells);
}
if (card.CanUseCard(cardManager, cell))
{
print("AI use card:" + card);
haveCardToUse = true;
cardManager.UseCard(cardManager.Cards[i], cell);
break;
}
}
if (!haveCardToUse)
{
cardManager.UpdateCanMoveCells();
if (cardManager.CanMoveCells.Count > 0)
{
cardManager.SetUnitMoveTo(GetMVC(cardManager.CanMoveCells));
}
}
}
}
public void DrawCard()
{
if (InGameCardDeck.Count == 0)
{
RefreshInGameCardDeck();
}
if (InGameCardDeck.Count == 0)
{
return;
}
Card_Base card = InGameCardDeck[0];
card.isActive = true;
Cards.Add(card);
card.gameObject.SetActive(true);
UIManager.instance.AddCard(card.gameObject, camp);
InGameCardDeck.RemoveAt(0);
}
public void MouseUp()
{
if (!Input.GetMouseButton(0) && InGameManager.isGameState(GameStateType.Decision))
{
if (PlayerController.instance.jobType == PointerJobType.UseCard)
{
PlayerController.instance.jobType = PointerJobType.none;
UpdateInteractableCells(true, null);
SelectCard.GetComponent <CardAppearence>().SetVisibility(true);
}
if (SelectCard != null)
{
if (Input.mousePosition.y > ReleaseThreshold)
{
playerCardManager.UseCard(SelectCard, PlayerController.instance.SelectCell);
}
SelectCard = null;
UI_ArrowMesh.instance.SetVisibility(false);
}
}
}
// ===========================================================================
//
// Card
//
// ===========================================================================
virtual public void OnCompleteCardShareToPlayer(Card_Base cardClass)
{
assert.set(cardClass.TargetPlayer);
cardClass.TargetPlayer.AddCard_ByClass(cardClass);
}
public void RefreshAppearence(Card_Base card)
{
CardImage.sprite = card.CardImage;
NameText.text = card.CardName;
DescriptionText.text = card.CardDescription;
}
public void setData(Card_Base newData)
{
data = newData;
cost.text = data.cost.ToString();
description.text = data.setDescription();
}
public void addCardToDiscard(Card_Base discardedCard)
{
discard.Add(discardedCard);
}
virtual public void AddCardClass(Card_Base cardClass)
{
CardUIList.Add(cardClass);
}
