//=====================================================
public static ChestReward GetChestReward(eChestType type,
eTradingCardClassification cardClassification,
eTradingCardRarity cardRarity,
eTradingCardCondition cardCondition)
{
var reward = new ChestReward();
var rewardCard = (type == eChestType.LARGE &&
cardClassification != eTradingCardClassification.NULL &&
cardRarity != eTradingCardRarity.NULL);
// 50% chance of awarding a card or gem
if (rewardCard == false && Random.Range(0, 99) % 2 == 0)
{
rewardCard = true;
}
if (rewardCard == true)
{
reward.Card = TradingCardItemsManager.GetCard(type, cardClassification, cardRarity, cardCondition);
reward.CardCondition = cardCondition;
//Debug.Log( "SceneManager: Reward card" );
}
else
{
// Small, medium or large number of gems
var maxGems = Convert.ToInt32(SettingsManager.GetSettingsItem("AWARD_GEMS_CHEST_" + type, -1));
reward.Gems = Random.Range(maxGems / 2, maxGems);
//Debug.Log( "SceneManager: Reward gems" );
}
return(reward);
}
//=====================================================
private void SetRewardItem(eSwitchItem switchItem,
eTradingCardClassification cardClassification,
eTradingCardRarity cardRarity,
eTradingCardCondition cardCondition)
{
if (switchItem == eSwitchItem.NULL)
{
// Reset reward to gems or a card
_reward = SceneManager.GetChestReward(_type, cardClassification, cardRarity, cardCondition);
}
else
{
if (_reward == null)
{
_reward = new ChestReward();
}
// Clear other reward items if switchItem is set
_reward.Gems = 0;
_reward.Card = null;
_reward.SwitchItem = switchItem;
}
//Debug.Log( "Chest: " + _type + " : " + _reward );
// Initialise chest switchItem as reward
if (_chestReward != null && _reward != null)
{
_chestReward.Init(_reward);
}
}
//==================================================================
static void OffsetPageCount(eTradingCardClassification Classification, int Offset)
{
if (!isItemListLoaded)
{
LoadItemsList();
}
foreach (TradingCardSpreadsheetItem item in itemList)
{
if (Classification == item.classification)
{
item.page += Offset;
}
}
}
public TradingCardSpreadsheetItem()
{
id = string.Empty;
classification = eTradingCardClassification.NULL;
value = 0;
valueScuffed = 0;
rarity = eTradingCardRarity.NULL;
waitTime = 0;
revealPrice = 0;
page = 0;
position = 0;
globalPosition = 0;
smallGuiTexture2D = string.Empty;
largeGuiTexture2D = string.Empty;
}
//==================================================================
static int GetPageCount(eTradingCardClassification Classification)
{
int MaxPage = 0;
if (!isItemListLoaded)
{
LoadItemsList();
}
foreach (TradingCardSpreadsheetItem item in itemList)
{
if (Classification == item.classification)
{
MaxPage = Mathf.Max(MaxPage, item.page + 1);
}
}
return(MaxPage);
}
//=====================================================
string GetCategoryText(eTradingCardClassification Category)
{
switch (Category)
{
case eTradingCardClassification.WINX:
return(TextManager.GetText("TRADINGCARDS_WINXMAGIC"));
case eTradingCardClassification.WILD:
return(TextManager.GetText("TRADINGCARDS_WILDMAGIC"));
case eTradingCardClassification.STORY:
return(""); //TextManager.GetText( "TRADINGCARDS_STORY" ) );
case eTradingCardClassification.STANDARD:
return(TextManager.GetText("TRADINGCARDS_STANDARD"));
}
return("");
}
//==================================================================
public static TradingCardSpreadsheetItem GetCard(eChestType type, eTradingCardClassification cardClassification, eTradingCardRarity cardRarity, eTradingCardCondition cardCondition)
{
TradingCardSpreadsheetItem card = new TradingCardSpreadsheetItem();
//if( _forceRareCardReward )
// type = eChestType.LARGE;
if ((cardClassification != eTradingCardClassification.NULL) || (cardRarity != eTradingCardRarity.NULL))
{
// Use a specific classification/type rather than a random one
eNPC UnlockedNPC = eNPC.NULL;
card = GetSpecificCardType(cardClassification, cardRarity, cardCondition, ref UnlockedNPC);
return(card);
}
switch (type)
{
case eChestType.SMALL:
// Return common card
//card = TradingCardItemsManager.GetRandomCard( eTradingCardRarity.COMMON , 30.0f , eTradingCardRarity.VERYCOMMON , 70.0f );
card = GetRandomCard(eTradingCardRarity.COMMON, 30.0f, eTradingCardRarity.COMMON, 70.0f);
break;
case eChestType.MEDIUM:
// Return common or uncommon card
card = GetRandomCard(eTradingCardRarity.RARE, 100.0f, eTradingCardRarity.NULL, 0.0f);
break;
case eChestType.LARGE:
// Return uncmmon or rare card
//card = TradingCardItemsManager.GetRandomCard( eTradingCardRarity.VERYRARE , 80.0f , eTradingCardRarity.UNIQUE , 20.0f );
card = GetRandomCard(eTradingCardRarity.VERYRARE, 80.0f, eTradingCardRarity.VERYRARE, 20.0f);
break;
}
return(card);
}
//==================================================================
public static int GetNumCards(eTradingCardClassification Classification)
{
if (!isItemListLoaded)
{
LoadItemsList();
}
int Count = 0;
foreach (TradingCardSpreadsheetItem item in itemList)
{
if (Classification == eTradingCardClassification.NULL)
{
if (item.classification == eTradingCardClassification.WINX)
{
Count++;
}
if (item.classification == eTradingCardClassification.WILD)
{
Count++;
}
if (item.classification == eTradingCardClassification.STANDARD)
{
Count++;
}
}
else
{
if (Classification == item.classification)
{
Count++;
}
}
}
return(Count);
}
//==================================================================
// Use a specific classification/type rather than a random one
public static TradingCardSpreadsheetItem GetSpecificCardType(eTradingCardClassification CardClassification, eTradingCardRarity CardRarity, eTradingCardCondition CardCondition, ref eNPC UnlockedNPC)
{
UnlockedNPC = eNPC.NULL;
if (!isItemListLoaded)
{
LoadItemsList();
}
if (CardRarity == eTradingCardRarity.TEACHER)
{
// If this is a 'teacher' card then unlock the next NPC in the list
// If we can't unlock any switch it to a random 'rare' card instead
// Get current population and find the first teacher above it
// If teacher isn't owned then give the card
int PlayerPopulation = GameDataManager.Instance.PlayerPopulation;
int NumNPCs = NPCItemsManager.GetNumItems();
NPCItemData FoundNPCItem = null;
bool bNPCFound = false;
Debug.Log("Looking for TEACHER card - current population: " + PlayerPopulation);
for (int Idx = 0; Idx < NumNPCs; Idx++)
{
NPCItemData CurNPCItem = NPCItemsManager.GetNPCItem(Idx);
// Ignore CurNPCItem.PopulationUnlock of zero (default)
if (CurNPCItem.PopulationUnlock == 0)
{
continue;
}
if (bNPCFound == false)
{
if (PlayerPopulation >= CurNPCItem.PopulationUnlock)
{
// Do we have this card already?
int NumMint = 0;
int NumScuffed = 0;
TradingCardHeldItem CurHeldCard = GameDataManager.Instance.GetHeldTradingCard(CurNPCItem.CardId, ref NumMint, ref NumScuffed);
if ((NumMint > 0) || (NumScuffed > 0))
{
// Has card,keep searching
}
else
{
// Doesn't have card - add it
bNPCFound = true;
FoundNPCItem = CurNPCItem;
Debug.Log("Found TEACHER card: " + FoundNPCItem.Id + " " + FoundNPCItem.CardId);
}
}
}
//Debug.Log( CurNPCItem.PopulationUnlock );
}
// If no teacher card was given then use a random 'rare' card instead
if (bNPCFound == false)
{
Debug.Log("No TEACHER card found - giving very rare card instead");
CardClassification = eTradingCardClassification.NULL;
CardRarity = eTradingCardRarity.VERYRARE;
}
else
{
eNPC FoundNPCId = eNPC.NULL;
try { FoundNPCId = (eNPC)Enum.Parse(typeof(eNPC), FoundNPCItem.Id); }
catch
{
Debug.Log("Warning: FoundNPCId state not recognised!");
}
UnlockedNPC = FoundNPCId; //GameDataManager.Instance.UnlockPlayerNPC( FoundNPCId );
return(GetTradingCardItem(FoundNPCItem.CardId));
}
}
if (CardClassification == eTradingCardClassification.NULL)
{
// Pick a random classification
switch (UnityEngine.Random.Range(0, 3))
{
case 0:
CardClassification = eTradingCardClassification.WINX;
break;
case 1:
CardClassification = eTradingCardClassification.WILD;
break;
case 2:
CardClassification = eTradingCardClassification.STORY;
break;
}
}
if (CardRarity == eTradingCardRarity.NULL)
{
// Pick a random rarity (exclude teacher cards)
CardRarity = (eTradingCardRarity)(UnityEngine.Random.Range((int)eTradingCardRarity.UNIQUE, (int)eTradingCardRarity.TEACHER));
}
// Find all cards with this specification and pick a random one
List <TradingCardSpreadsheetItem> CardList = new List <TradingCardSpreadsheetItem>();
foreach (TradingCardSpreadsheetItem Item in itemList)
{
if ((Item.classification == CardClassification) && (Item.rarity == CardRarity))
{
CardList.Add(Item);
}
}
// Pick from card list
int CardIdx = UnityEngine.Random.Range(0, CardList.Count);
if (CardList.Count == 0)
{
Debug.LogWarning("No cards to reward player!");
Debug.LogWarning("Classification: " + CardClassification + " Rarity: " + CardRarity + " Condition: " + CardCondition);
return(itemList[0]);
}
else
{
return(CardList[CardIdx]);
}
}
//==================================================================
public static int GetPageOffset(eTradingCardClassification Classification)
{
return(pageTypeOffsets[(int)Classification] + 1);
}
//=====================================================
void UpdateViewingBook()
{
// Update sprite that shows which page type we're on
eTradingCardClassification VisibleClassification = TradingCardItemsManager.GetPageClassification(BookManager.instance.GetCurrentPage());
foreach (GameObject sprClassification in m_sprPageTypes)
{
if (sprClassification != null)
{
sprClassification.SetActive(false);
}
}
m_sprPageTypes[(int)VisibleClassification].SetActive(true);
// Set the page shortcuts for this classification (prev/next)
int PrevCategory = (int)VisibleClassification - 1;
int NextCategory = (int)VisibleClassification + 1;
// Skip 'story' class
if (VisibleClassification == eTradingCardClassification.STANDARD)
{
PrevCategory--;
}
if (VisibleClassification == eTradingCardClassification.WILD)
{
NextCategory++;
}
//m_txtCategoryPrev.text = GetCategoryText( (eTradingCardClassification)PrevCategory );
//m_txtCategoryNext.text = GetCategoryText( (eTradingCardClassification)NextCategory );
// Check for swiping
if (BookManager.instance.IsPageTurning())
{
return;
}
// Update area scrolling list position
if (m_bSwiping)
{
m_SwipeTime += Time.deltaTime;
m_SwipeTimeAccum += Time.deltaTime;
Vector3 WorldPos = m_BookCamera.ScreenToViewportPoint(Input.mousePosition);
WorldPos *= 384.0f;
float SwipingDeltaX = WorldPos.x - m_SwipingStartX;
m_SwipingAccel = (WorldPos - m_LastWorldPos[3]).x;
if (m_SwipeTimeAccum > (1.0f / 60.0f))
{
for (int MIdx = 3; MIdx > 0; MIdx--)
{
m_LastWorldPos[MIdx] = m_LastWorldPos[MIdx - 1];
}
m_LastWorldPos[0] = WorldPos;
m_SwipeTimeAccum -= (1.0f / 60.0f);
}
if (Input.GetMouseButtonUp(0))
{
m_bSwiping = false;
m_SwipingAccel = Mathf.Clamp(m_SwipingAccel, -12.0f, 12.0f);
bool bMinimumDistTravelled = true;
if (Mathf.Abs(SwipingDeltaX) < 28.0f)
{
bMinimumDistTravelled = false;
}
//Debug.Log( m_SwipingAccel + " " + bMinimumDistTravelled );
if ((Mathf.Abs(m_SwipingAccel) < 7.0f) || (bMinimumDistTravelled == false))
{
// No swipe - selection of a card?
m_SwipingAccel = 0.0f;
if ((m_SwipeTime < 0.25f) && (bMinimumDistTravelled == false))
{
// Selected card - check collision
int CurrentPage = BookManager.instance.GetCurrentPage();
int CurrentPosition = BookManager.instance.GetPositionAtMouse();
// For first and last pages don't allow card selection
if (BookManager.instance.IsValidPage() == false)
{
CurrentPosition = -1;
}
if (CurrentPosition != -1)
{
// Valid card?
bool bValidCard = true;
TradingCardSpreadsheetItem CurSpreadsheetCard = TradingCardItemsManager.GetTradingCardItem(CurrentPage, CurrentPosition);
if (CurSpreadsheetCard == null)
{
bValidCard = false;
}
if (bValidCard)
{
// Set buy/sell mode based on whether we have the card or not
int NumMint = 0;
int NumScuffed = 0;
TradingCardHeldItem CurHeldCard = GameDataManager.Instance.GetHeldTradingCard(CurSpreadsheetCard.id, ref NumMint, ref NumScuffed);
if (CurHeldCard != null)
{
m_SelectedCardMode = eSelectedCardMode.Selling;
}
else
{
m_SelectedCardMode = eSelectedCardMode.Buying;
}
// Show selected card panel
SelectedCardManager.instance.SetupPanel(m_SelectedCardMode, CurSpreadsheetCard, CurrentPosition, NumMint, NumScuffed);
SelectedCardManager.instance.ShowPanel(true);
SetRoomMode(eRoomMode.SelectedCard);
SoundFXManager.instance.PlaySound("CardSelect");
// Hide this card on the book so we can zoom into it
BookManager.instance.HideCard(CurrentPage, CurrentPosition);
}
}
}
}
else
{
// Quick Swipe
if (m_SwipingAccel < 0.0f)
{
BookManager.instance.TurnPage(1);
SoundFXManager.instance.PlaySound("PageTurn");
}
else
{
BookManager.instance.TurnPage(-1);
SoundFXManager.instance.PlaySound("PageTurn");
}
m_SwipingAccel = 0.0f;
}
}
}
else
{
// Not swiping
Vector3 WorldPos = m_BookCamera.ScreenToViewportPoint(Input.mousePosition);
WorldPos *= 384.0f;
for (int MIdx = 3; MIdx > 0; MIdx--)
{
m_LastWorldPos[MIdx] = WorldPos;
}
m_SwipingStartX = WorldPos.x;
m_SwipeTimeAccum = 0.0f;
// Make sure pause menu or shop menu isn't active
if ((PopupPause.Instance.IsActive == false) && (ShopManager.instance == false))
{
if (Input.GetMouseButtonDown(0))
{
if ((WorldPos.y > 48.0f) && (WorldPos.y < 323.0f))
{
m_bSwiping = true;
m_SwipingAccel = 0.0f;
m_SwipeTime = 0.0f;
}
}
}
}
}
