void ChooseCard(TarotCardData card, Button button)
{
if (gameRunner.cardsSelectedToDeal.Contains(card.order))
{
// this card is already selected; remove it!
Debug.Log("removing card " + card.name);
button.image.color = cardButtonDefaultColor;
gameRunner.RemoveChosenCard(card);
Destroy(deckOrderToSelectedCardButtonMap[card.order]);
deckOrderToSelectedCardButtonMap.Remove(card.order);
deckOrderToDeckCardButtonMap.Remove(card.order);
MaybeEnableAllButtons();
}
else
{
Debug.Log("choosing card " + card.name);
button.interactable = false;
gameRunner.ChooseCard(card);
deckOrderToDeckCardButtonMap.Add(card.order, button.gameObject);
Button selectedCardButton = Instantiate(cardChooseButtonPrefab);
selectedCardButton.transform.SetParent(chosenCardsList);
selectedCardButton.image.color = cardButtonSelectedColor;
TextMeshProUGUI textComp = null;
textComp = selectedCardButton.GetComponentInChildren <TextMeshProUGUI>();
selectedCardButton.onClick.AddListener(() => ChooseCard(card, selectedCardButton));
if (textComp)
{
textComp.text = card.cardName;
}
deckOrderToSelectedCardButtonMap.Add(card.order, selectedCardButton.gameObject);
MaybeDisableAllButtons();
}
}
private static void UpdateTarotData2DB(GameClient client, TarotCardData tarotData, TarotKingData tarotKingBuffData)
{
string[] dbFields = null;
string tarotStrInfo = (tarotData == null) ? "-1" : tarotData.GetDataStrInfo();
string kingBuffStrInfo = (tarotKingBuffData == null) ? "-1" : tarotKingBuffData.GetDataStrInfo();
string sCmd = string.Format("{0}:{1}:{2}", client.ClientData.RoleID, tarotStrInfo, kingBuffStrInfo);
TCPProcessCmdResults retcmd = Global.RequestToDBServer(Global._TCPManager.tcpClientPool, Global._TCPManager.TcpOutPacketPool, 20100, sCmd, out dbFields, client.ServerId);
}
// public bool isReversed;
// Start is called before the first frame update
public void Init(TarotCardData cd, string cardMeaning, int order, GameRunner gr)
{
readingOrder = order;
gameRunner = gr;
cardMeaningText.text = cardMeaning;
cardData = cd;
cardFront.sprite = cardData.cardPicture2x;
EnableButton(false);
}
/// <summary>
/// 处理塔罗牌升级或激活
/// </summary>
/// <param name="client"></param>
/// <param name="goodID"></param>
/// <param name="partCount"></param>
/// <returns></returns>
public ETarotResult ProcessTarotUpCmd(GameClient client, int goodID)
{
//判断功能是否开启
if (!GlobalNew.IsGongNengOpened(client, GongNengIDs.TarotCard))
{
return(ETarotResult.NotOpen);
}
TarotSystemData tarotData = client.ClientData.TarotData;
//获取要升级的塔罗牌数据
TarotCardData currentTarot = tarotData.TarotCardDatas.Find(x => x.GoodId == goodID);
if (currentTarot == null)
{
//激活
currentTarot = new TarotCardData();
currentTarot.GoodId = goodID;
tarotData.TarotCardDatas.Add(currentTarot);
}
//判断是否可以升级
if (currentTarot.Level >= TarotMaxLevelDict[goodID])
{
return(ETarotResult.MaxLevel);
}
//获取下级塔罗牌对应配置模板
TarotTemplate nextTemp = TarotTemplates.Find(x => x.GoodsID == goodID && x.Level == currentTarot.Level + 1);
if (nextTemp == null)
{
return(ETarotResult.Error);
}
//判断背包碎片是否足够
var hasPartCount = Global.GetTotalGoodsCountByID(client, nextTemp.NeedGoodID);
if (hasPartCount < nextTemp.NeedPartCount)
{
return(ETarotResult.NeedPart);
}
//使用物品 优先使用绑定物品
bool usedBinding = false;
bool usedTimeLimited = false;
if (Global.UseGoodsBindOrNot(client, nextTemp.NeedGoodID, nextTemp.NeedPartCount, true, out usedBinding, out usedTimeLimited) < 1)
{
return(ETarotResult.NeedPart);
}
//处理升级
currentTarot.Level += 1;
//更新玩家数据
UpdataPalyerTarotAttr(client);
//向DB服更新数据
UpdateTarotData2DB(client, currentTarot, null);
return(ETarotResult.Success);
}
public IEnumerator DoRereadCard(int cardToReread)
{
Debug.Log("rereading card " + cardToReread);
SetGameState(GameState.RereadingCard);
TarotCardData cardData = selectedCardData[cardToReread];
readingUI.Init(selectedCardData[cardToReread], true);
yield return(StartCoroutine(readingUI.FadeIn()));
Cursor.SetCursor(null, Vector2.zero, CursorMode.Auto);
SetGameState(GameState.ReadingCardDone);
}
void CallbackFunction(object in_cookie, AkCallbackType in_type, object in_info)
{
if (gameState == GameState.PreReading)
{
StartCoroutine(ReadCard());
}
else if (gameState == GameState.GenerativePhase || gameState == GameState.ShowingEndInstructions)
{
if (new int[] { 0, 2, 5, 8 }.Contains(generativeSection))
{
videoCanvas.gameObject.SetActive(false);
videoCardUI.cardDefinitionText.gameObject.SetActive(false);
videoPlayer.clip = videoClips[playingClipNumber];
videoPlayer.Stop();
videoPlayer.targetTexture.Release();
if (generativeSection != 0)
{
if (new int[] { 5, 8 }.Contains(generativeSection))
{
currentGenerativeCard++;
}
StartCoroutine(generativeUI.ShowMeaningText(cardMeanings[currentGenerativeCard]));
}
generativeSection++;
}
else if (generativeSection >= 11)
{
SetGameState(GameState.GenerativePhaseDone);
}
else
{
StartCoroutine(generativeUI.HideTitleText());
StartCoroutine(generativeUI.HideMeaningText());
videoPlayer.clip = videoClips[playingClipNumber];
videoPlayer.Play();
videoCanvas.gameObject.SetActive(true);
if (new int[] { 3, 6, 9 }.Contains(generativeSection))
{
TarotCardData cardData = selectedCardData[currentGenerativeCard];
videoCardUI.SetTextFromCardData(cardData);
videoCardUI.cardDefinitionText.gameObject.SetActive(true);
}
else
{
videoCardUI.cardDefinitionText.gameObject.SetActive(false);
}
playingClipNumber++;
generativeSection++;
}
}
}
//更新数据库资料
private static void UpdateTarotData2DB(GameClient client, TarotCardData tarotData, TarotKingData tarotKingBuffData)
{
string[] dbFields = null;
var tarotStrInfo = tarotData == null ? "-1" : tarotData.GetDataStrInfo();
var kingBuffStrInfo = tarotKingBuffData == null ? "-1" : tarotKingBuffData.GetDataStrInfo();
var sCmd = string.Format("{0}:{1}:{2}", client.ClientData.RoleID, tarotStrInfo, kingBuffStrInfo);
TCPProcessCmdResults retcmd = Global.RequestToDBServer(Global._TCPManager.tcpClientPool, Global._TCPManager.TcpOutPacketPool,
(int)TCPGameServerCmds.CMD_DB_UPDATA_TAROT, sCmd, out dbFields, client.ServerId);
}
/// <summary>
/// 设置塔罗牌上阵位置 （0=为上阵）
/// </summary>
/// <param name="client"></param>
/// <param name="goodID"></param>
/// <param name="pos"></param>
/// <returns></returns>
public ETarotResult ProcessSetTarotPosCmd(GameClient client, int goodID, byte pos)
{
//判断功能是否开启
if (!GlobalNew.IsGongNengOpened(client, GongNengIDs.TarotCard))
{
return(ETarotResult.NotOpen);
}
//判断位置是否合法
if (pos < 0 || pos > 6)
{
return(ETarotResult.Error);
}
TarotSystemData tarotData = client.ClientData.TarotData;
//获取塔罗牌数据
TarotCardData currentTarot = tarotData.TarotCardDatas.Find(x => x.GoodId == goodID);
if (currentTarot == null)
{
return(ETarotResult.Error);
}
if (currentTarot.Postion == pos)
{
return(ETarotResult.Error);
}
//上阵
if (pos > 0)
{
//判断当前卡牌是否已在阵上
if (currentTarot.Postion > 0)
{
return(ETarotResult.Error);
}
//判断装备的位置是否为空
TarotCardData targetTarot = tarotData.TarotCardDatas.Find(x => x.Postion == pos);
if (targetTarot != null)
{
targetTarot.Postion = 0;
}
}
currentTarot.Postion = pos;
//更新玩家塔罗牌加成属性
UpdataPalyerTarotAttr(client);
//向DB服更新数据
UpdateTarotData2DB(client, currentTarot, null);
return(ETarotResult.Success);
}
public TarotManager.ETarotResult ProcessSetTarotPosCmd(GameClient client, int goodID, byte pos)
{
TarotManager.ETarotResult result;
if (!GlobalNew.IsGongNengOpened(client, GongNengIDs.TarotCard, false))
{
result = TarotManager.ETarotResult.NotOpen;
}
else if (pos < 0 || pos > 6)
{
result = TarotManager.ETarotResult.Error;
}
else
{
TarotSystemData tarotData = client.ClientData.TarotData;
TarotCardData currentTarot = tarotData.TarotCardDatas.Find((TarotCardData x) => x.GoodId == goodID);
if (currentTarot == null)
{
result = TarotManager.ETarotResult.Error;
}
else if (currentTarot.Postion == pos)
{
result = TarotManager.ETarotResult.Error;
}
else
{
if (pos > 0)
{
if (currentTarot.Postion > 0)
{
return(TarotManager.ETarotResult.Error);
}
TarotCardData targetTarot = tarotData.TarotCardDatas.Find((TarotCardData x) => x.Postion == pos);
if (targetTarot != null)
{
targetTarot.Postion = 0;
}
}
currentTarot.Postion = pos;
this.UpdataPalyerTarotAttr(client);
TarotManager.UpdateTarotData2DB(client, currentTarot, null);
result = TarotManager.ETarotResult.Success;
}
}
return(result);
}
public TarotManager.ETarotResult ProcessTarotUpCmd(GameClient client, int goodID)
{
TarotManager.ETarotResult result;
if (!GlobalNew.IsGongNengOpened(client, GongNengIDs.TarotCard, false))
{
result = TarotManager.ETarotResult.NotOpen;
}
else
{
TarotSystemData tarotData = client.ClientData.TarotData;
TarotCardData currentTarot = tarotData.TarotCardDatas.Find((TarotCardData x) => x.GoodId == goodID);
if (currentTarot == null)
{
currentTarot = new TarotCardData();
currentTarot.GoodId = goodID;
tarotData.TarotCardDatas.Add(currentTarot);
}
if (currentTarot.Level >= TarotManager.TarotMaxLevelDict[goodID])
{
result = TarotManager.ETarotResult.MaxLevel;
}
else
{
TarotManager.TarotTemplate nextTemp = TarotManager.TarotTemplates.Find((TarotManager.TarotTemplate x) => x.GoodsID == goodID && x.Level == currentTarot.Level + 1);
if (nextTemp == null)
{
result = TarotManager.ETarotResult.Error;
}
else if (currentTarot.TarotMoney < nextTemp.NeedPartCount)
{
result = TarotManager.ETarotResult.NeedPart;
}
else
{
currentTarot.TarotMoney -= nextTemp.NeedPartCount;
currentTarot.Level++;
this.UpdataPalyerTarotAttr(client);
TarotManager.UpdateTarotData2DB(client, currentTarot, null);
result = TarotManager.ETarotResult.Success;
}
}
}
return(result);
}
void CreateChooseCardButton(TarotCardData card)
{
TextMeshProUGUI textComp;
Button button = Instantiate(cardChooseButtonPrefab).GetComponent <Button>();
button.transform.parent = cardsList;
button.image.color = cardButtonDefaultColor;
textComp = null;
textComp = button.GetComponentInChildren <TextMeshProUGUI>();
button.onClick.AddListener(() => ChooseCard(card, button));
if (textComp)
{
textComp.text = card.cardName;
}
if (gameRunner.cardsSelectedToDeal.Contains(card.order))
{
button.interactable = false;
}
}
IEnumerator FadeInCard()
{
float t = 0;
TarotCardData cardData = selectedCardData[numCardsAlreadyRead];
cardReadingSpots[numCardsAlreadyRead].Init(cardData, cardMeanings[numCardsAlreadyRead], numCardsAlreadyRead, this);
int groupNumber = cardData.thematicGroup;
Color sparkColor = groupSparkColors[groupNumber - 1];
Debug.Log(groupNumber + " " + sparkColor);
ParticleSystem.MainModule ma = sparks[numCardsAlreadyRead].main;
ma.startColor = sparkColor;
sparks[numCardsAlreadyRead].Play();
while (t < 1)
{
t += Time.deltaTime / cardFlipSpeed;
cardReadingSpots[numCardsAlreadyRead].canvasGroup.alpha = t;
yield return(null);
}
SetGameState(GameState.FadingCardInDone);
}
public void Init(TarotCardData cardData, bool isReread = false)
{
cardImage.sprite = cardData.cardPicture2x;
totalReadingTime = DEBUG_gottaGoFast ? 2f : (cardData.clipDuration - 2);
cardText.text = cardData.cardLongDescription.ToString() + ReadingUtils.readingBreakCharacter + "\n\n";
if (cardData.suit == CardSuit.Cups)
{
backgroundColor.color = cupsBGColor;
}
else if (cardData.suit == CardSuit.Wands)
{
backgroundColor.color = wandsBGColor;
}
else if (cardData.suit == CardSuit.Swords)
{
backgroundColor.color = swordsBGColor;
}
else if (cardData.suit == CardSuit.Pentacles)
{
backgroundColor.color = pentaclesBGColor;
}
else
{
backgroundColor.color = majorArcanaBGColor;
}
if (isReread)
{
ReadingUtils.ShowAllCharacters(cardText);
}
else
{
ReadingUtils.HideAllCharacters(cardText);
}
}
IEnumerator ReadCard()
{
SetGameState(GameState.ReadingCard);
TarotCardData cardData = selectedCardData[numCardsAlreadyRead];
cardData.readingMusicEvent.Post(gameObject);
readingUI.Init(selectedCardData[numCardsAlreadyRead]);
yield return(StartCoroutine(readingUI.FadeIn()));
Coroutine readingCoroutine = StartCoroutine(readingUI.ReadCard());
while (readingUI.reading)
{
yield return(null);
}
if (readingCoroutine != null)
{
StopCoroutine(readingCoroutine);
}
cardReadingSpots[numCardsAlreadyRead].EnableButton(true);
numCardsAlreadyRead++;
Cursor.SetCursor(null, Vector2.zero, CursorMode.Auto);
SetGameState(GameState.ReadingCardDone);
}
public void SetTextFromCardData(TarotCardData cardData)
{
cardTitleText.text = cardData.name;
cardDescriptionShortText.text = cardData.cardShortDescription;
}
public void RemoveChosenCard(TarotCardData card)
{
cardsSelectedToDeal.Remove(card.order);
}
public static TCPProcessCmdResults ProcessUpdateTarotDataCmd(DBManager dbMgr, TCPOutPacketPool pool, int nID, byte[] data, int count, out TCPOutPacket tcpOutPacket)
{
tcpOutPacket = null;
string cmdData = null;
try
{
cmdData = new UTF8Encoding().GetString(data, 0, count);
}
catch (Exception)
{
LogManager.WriteLog(LogTypes.Error, string.Format("解析指令字符串错误, CMD={0}", (TCPGameServerCmds)nID), null, true);
tcpOutPacket = TCPOutPacket.MakeTCPOutPacket(pool, "0", 20100);
return(TCPProcessCmdResults.RESULT_DATA);
}
try
{
string[] fields = cmdData.Split(new char[]
{
':'
});
if (fields.Length != 3)
{
LogManager.WriteLog(LogTypes.Error, string.Format("指令参数个数错误, CMD={0}, Recv={1}, CmdData={2}", (TCPGameServerCmds)nID, fields.Length, cmdData), null, true);
tcpOutPacket = TCPOutPacket.MakeTCPOutPacket(pool, "0", 30767);
return(TCPProcessCmdResults.RESULT_DATA);
}
int roleID = Convert.ToInt32(fields[0]);
string dataInfo = fields[1];
string kingBuffInfo = fields[2];
string dbTarotInfo = string.Empty;
string dbKingInfo = string.Empty;
DBRoleInfo dbRoleInfo = dbMgr.GetDBRoleInfo(ref roleID);
if (null != dbRoleInfo)
{
lock (dbRoleInfo)
{
TarotCardData tarotData = new TarotCardData(dataInfo);
if (tarotData.GoodId > 0)
{
TarotCardData oldData = dbRoleInfo.TarotData.TarotCardDatas.Find((TarotCardData x) => x.GoodId == tarotData.GoodId);
if (oldData == null)
{
dbRoleInfo.TarotData.TarotCardDatas.Add(tarotData);
}
else
{
TarotCardData targetData = dbRoleInfo.TarotData.TarotCardDatas.Find((TarotCardData x) => x.Postion == tarotData.Postion);
if (targetData != null)
{
targetData.Postion = 0;
}
oldData.Level = tarotData.Level;
oldData.Postion = tarotData.Postion;
oldData.TarotMoney = tarotData.TarotMoney;
}
}
foreach (TarotCardData info in dbRoleInfo.TarotData.TarotCardDatas)
{
dbTarotInfo += info.GetDataStrInfo();
}
if (kingBuffInfo != "-1")
{
TarotKingData kingBuffData = new TarotKingData(kingBuffInfo);
dbRoleInfo.TarotData.KingData = kingBuffData;
}
}
}
else
{
LogManager.WriteLog(LogTypes.Error, string.Format("指令参数个数错误, CMD={0}, Recv={1}, CmdData={2}", (TCPGameServerCmds)nID, fields.Length, cmdData), null, true);
tcpOutPacket = TCPOutPacket.MakeTCPOutPacket(pool, "0", 0x782f);
return(TCPProcessCmdResults.RESULT_DATA);
}
string strcmd = DBWriter.UpdateTarotData(dbMgr, roleID, dbTarotInfo, dbRoleInfo.TarotData.KingData.GetDataStrInfo()) ? "1" : "0";
tcpOutPacket = TCPOutPacket.MakeTCPOutPacket(pool, strcmd, nID);
return(TCPProcessCmdResults.RESULT_DATA);
}
catch (Exception ex)
{
DataHelper.WriteFormatExceptionLog(ex, "", false, false);
}
tcpOutPacket = TCPOutPacket.MakeTCPOutPacket(pool, "0", 30767);
return(TCPProcessCmdResults.RESULT_DATA);
}
void AddCardData(int cardOrder)
{
TarotCardData cardData = GetCardData(cardOrder);
selectedCardData.Add(cardData);
videoClips[setClipNumber] = cardData.cardAndGroupClips[setClipNumber - 1];
Debug.Log("Card Clip " + setClipNumber + " chosen.");
setClipNumber++;
videoClips[setClipNumber] = cardData.cardAndGroupClips[setClipNumber - 1];
Debug.Log("Group Clip " + setClipNumber + " chosen.");
setClipNumber++;
if (numberCardsAlreadyDealt == 0)
{
groupMelodyEvents[0] = card1MelodyEvents[cardData.thematicGroup - 1];
int s = (int)cardData.suit;
cardSuitMelodyEvents[numberCardsAlreadyDealt] = card1SuitEvents[s];
}
else if (numberCardsAlreadyDealt == 1)
{
groupMelodyEvents[1] = card2MelodyEvents[cardData.thematicGroup - 1];
int s = (int)cardData.suit;
cardSuitMelodyEvents[numberCardsAlreadyDealt] = card2SuitEvents[s];
}
else if (numberCardsAlreadyDealt == 2)
{
groupMelodyEvents[2] = card3MelodyEvents[cardData.thematicGroup - 1];
int s = (int)cardData.suit;
cardSuitMelodyEvents[numberCardsAlreadyDealt] = card3SuitEvents[s];
foreach (AK.Wwise.Event e in groupMelodyEvents)
{
e.Post(gameObject);
}
foreach (AK.Wwise.Event e in cardSuitMelodyEvents)
{
e.Post(gameObject);
Debug.Log(cardSuitMelodyEvents[0] + " " + cardSuitMelodyEvents[1] + " " + cardSuitMelodyEvents[2]);
}
setClipNumber = 1;
}
numberCardsAlreadyDealt++;
if (cardData.suit == CardSuit.MajorArcana)
{
majorArcanaTotal++;
}
else if (cardData.suit == CardSuit.Cups)
{
cupsTotal++;
}
else if (cardData.suit == CardSuit.Wands)
{
wandsTotal++;
}
else if (cardData.suit == CardSuit.Swords)
{
swordsTotal++;
}
else if (cardData.suit == CardSuit.Pentacles)
{
pentaclesTotal++;
}
}
public TarotManager.ETarotResult ProcessTarotMoneyCmd(GameClient client, int goodId, int num, int dbid, out int resNum)
{
resNum = 0;
TarotManager.ETarotResult result;
if (!GlobalNew.IsGongNengOpened(client, GongNengIDs.TarotCard, false))
{
result = TarotManager.ETarotResult.NotOpen;
}
else
{
GoodsData Data = Global.GetGoodsByDbID(client, dbid);
if (Data == null)
{
result = TarotManager.ETarotResult.Error;
}
else if (TarotManager.TarotNeedCardNum.ContainsKey(goodId))
{
if (num < 0 || num > Data.GCount)
{
result = TarotManager.ETarotResult.MoneyNumError;
}
else
{
TarotManager.TarotTemplate nextTemp = TarotManager.TarotTemplates.Find((TarotManager.TarotTemplate x) => x.NeedGoodID == goodId);
if (nextTemp == null)
{
result = TarotManager.ETarotResult.NotFindGood;
}
else
{
TarotSystemData tarotData = client.ClientData.TarotData;
TarotCardData currentTarot = tarotData.TarotCardDatas.Find((TarotCardData x) => x.GoodId == nextTemp.GoodsID);
if (currentTarot == null)
{
currentTarot = new TarotCardData();
currentTarot.GoodId = nextTemp.GoodsID;
tarotData.TarotCardDatas.Add(currentTarot);
}
int reNum = TarotManager.TarotNeedCardNum[goodId] - this.CountTarotNowToCurrLevel(goodId, currentTarot.Level) - currentTarot.TarotMoney;
if (reNum == 0)
{
result = TarotManager.ETarotResult.HasMaxNum;
}
else
{
if (num > reNum)
{
num = reNum;
}
if (GameManager.ClientMgr.NotifyUseGoodsByDbId(Global._TCPManager.MySocketListener, Global._TCPManager.tcpClientPool, Global._TCPManager.TcpOutPacketPool, client, dbid, num, false, false))
{
GoodsData goodsData = Global.GetGoodsByDbID(client, dbid);
if (null != goodsData)
{
resNum = goodsData.GCount;
}
currentTarot.TarotMoney += num;
EventLogManager.AddRoleEvent(client, OpTypes.Trace, OpTags.TarotMoney, LogRecordType.TarotMoney, new object[]
{
num,
currentTarot.TarotMoney,
dbid,
"塔罗牌货币增加"
});
this.UpdataPalyerTarotAttr(client);
TarotManager.UpdateTarotData2DB(client, currentTarot, null);
GameManager.logDBCmdMgr.AddDBLogInfo(dbid, "塔罗牌货币", "塔罗牌", client.ClientData.RoleName, "系统", "修改", 0, client.ClientData.ZoneID, client.strUserID, num, client.ServerId, null);
result = TarotManager.ETarotResult.Success;
}
else
{
result = TarotManager.ETarotResult.UseGoodError;
}
}
}
}
}
else
{
result = TarotManager.ETarotResult.GoodIdError;
}
}
return(result);
}
public void ChooseCard(TarotCardData card)
{
cardsSelectedToDeal.Add(card.order);
}
