static void S_1(int turn, MemoryData memory, CardPool cardPool, GameFlow gameFlow)
{
cardPool.GetCard("Basic_000").priority = 5;
cardPool.GetCard("Basic_001").priority = 5;
cardPool.GetCard("Basic_002").priority = 5;
cardPool.GetCard("Basic_003").priority = 5;;
}
static void S_12(int turn, MemoryData memory, CardPool cardPool, GameFlow gameFlow)
{
cardPool.GetCard("Adv_000").priority = 30;
cardPool.GetCard("Adv_001").priority = 30;
cardPool.GetCard("Adv_002").priority = 30;
cardPool.GetCard("Adv_003").priority = 30;;
}
public void ApplyView(CardPool.CardContext [] contexts)
{
this.contexts = contexts;
cardLT.SetCardContext(contexts[0]);
cardRT.SetCardContext(contexts[1]);
cardLB.SetCardContext(contexts[2]);
cardRB.SetCardContext(contexts[3]);
}
public void SetCardContext(CardPool.CardContext cx)
{
this.cx = cx;
title.text = cx.title;
image.sprite = cx.image;
description.text = cx.description;
fullDescription.text = cx.fullDescription;
}
void Awake()
{
instance = this;
timer = GetComponent<WorldTimer>();
noteRef = GetComponent<WorldNoteRef>();
memory = GetComponent<Memory>();
cardPool = GetComponent<CardPool>();
triggerMgr = GetComponent<TriggerMgr>();
cardCanvas = _cardCanvas;
eventCanvas = _eventCanvas;
}
private void InitCardPool(string cdbFile, int mainNum, int exNum)
{
List <string> CardPoolLocal = new List <string>();
List <string> CardPoolExLocal = new List <string>();
SQLiteConnection sqlcon = new SQLiteConnection($"Data Source={cdbFile}");
sqlcon.Open();
SQLiteCommand cmd = new SQLiteCommand("SELECT id,type FROM datas", sqlcon);
var reader = cmd.ExecuteReader();
while (reader.Read())
{
string id = reader["id"].ToString();
long type = (long)reader["type"];
int num = 3;
CardPoolLFList.Add(id, 0);
if (LFList.ContainsKey(id))
{
num = LFList[id];
}
if (((type & TYPE_FUSION) > 0) || ((type & TYPE_XYZ) > 0) ||
((type & TYPE_LINK) > 0) || ((type & TYPE_SYNCHRO) > 0))
{
for (int i = 0; i < num; i++)
{
CardPoolExLocal.Add(id);
}
}
else
{
for (int i = 0; i < num; i++)
{
CardPoolLocal.Add(id);
}
}
}
for (int i = 0; i < mainNum; i++)
{
int index = _rd.Next(0, CardPoolLocal.Count);
CardPool.Add(CardPoolLocal[index]);
CardPoolLocal.RemoveAt(index);
if (!CardPoolLFList.ContainsKey(CardPoolLocal[index]))
{
CardPoolLFList.Add(CardPoolLocal[index], 1);
}
else
{
CardPoolLFList[CardPoolLocal[index]]++;
}
}
for (int i = 0; i < exNum; i++)
{
int index = _rd.Next(0, CardPoolExLocal.Count);
CardPoolEx.Add(CardPoolExLocal[index]);
CardPoolLFList[CardPoolExLocal[index]]++;
CardPoolExLocal.RemoveAt(index);
}
reader.Close();
cmd.Dispose();
sqlcon.Dispose();
CardPoolLocal.Clear();
CardPoolExLocal.Clear();
}
void IReturnCard.OnReturnCard(PlayerId id, CardHand cardHand, CardPool cardPool, PositionId positionId) => UiPool.AddCard(cardPool, positionId, false);
void IRevealCard.OnRevealCard(PlayerId id, CardPool cardPool, PositionId positionId) => UiPool.AddCard(cardPool, positionId);
// Token: 0x060076EC RID: 30444 RVA: 0x00208350 File Offset: 0x00206550
private void __callBase_SelectCardUseCrystal(CardPool cardPool, bool isSingleSelect)
{
base.SelectCardUseCrystal(cardPool, isSingleSelect);
}
public void TestDealingCardsWithEightDeck()
{
CardPool eightDeckCardPool = new CardPool(8);
DealCardsAndCheckProbability(eightDeckCardPool, 30);
}
static void S_7(int turn, MemoryData memory, CardPool cardPool, GameFlow gameFlow)
{
memory.Fear = 100;;
}
static void S_11(int turn, MemoryData memory, CardPool cardPool, GameFlow gameFlow)
{
memory.Approval +=10;;
}
// Token: 0x06007704 RID: 30468 RVA: 0x002086AC File Offset: 0x002068AC
public void __callBase_SelectCardUseTickets(CardPool cardPool, bool isSingleSelect)
{
this.m_owner.__callBase_SelectCardUseTickets(cardPool, isSingleSelect);
}
static void S_2(int turn, MemoryData memory, CardPool cardPool, GameFlow gameFlow)
{
memory.Fund += 5;
}
// Token: 0x06007700 RID: 30464 RVA: 0x0020866C File Offset: 0x0020686C
public bool __callBase_IsUsedOutActivityCardPoolSelectOpportunity(CardPool cardPool)
{
return(this.m_owner.__callBase_IsUsedOutActivityCardPoolSelectOpportunity(cardPool));
}
// Token: 0x06007703 RID: 30467 RVA: 0x0020869C File Offset: 0x0020689C
public int __callBase_GetCrystalCount(CardPool cardPool, bool isSingleSelect, out bool isTenSelectDiscount)
{
return(this.m_owner.__callBase_GetCrystalCount(cardPool, isSingleSelect, out isTenSelectDiscount));
}
// Token: 0x060076F0 RID: 30448 RVA: 0x00208380 File Offset: 0x00206580
private void __callBase_SelectCardSpendTicketsOrCrystal(CardPool cardPool, bool isSingleSelect, bool isUsingTickets)
{
base.SelectCardSpendTicketsOrCrystal(cardPool, isSingleSelect, isUsingTickets);
}
// Token: 0x060076EF RID: 30447 RVA: 0x00208374 File Offset: 0x00206574
private int __callBase_CanUseTicketSelectCard(CardPool cardPool, int ticketNums)
{
return(base.CanUseTicketSelectCard(cardPool, ticketNums));
}
// Token: 0x060076ED RID: 30445 RVA: 0x0020835C File Offset: 0x0020655C
private int __callBase_CanSelectCard(CardPool cardPool, bool isSingleSelect, bool isUsingTickets)
{
return(base.CanSelectCard(cardPool, isSingleSelect, isUsingTickets));
}
private bool GenerateDeck(int numOfMain, int numOfEx, string file)
{
if (CardPool.Count < numOfMain || CardPoolEx.Count < numOfEx)
{
return(false);
}
Dictionary <string, int> main = new Dictionary <string, int>();
Dictionary <string, int> ex = new Dictionary <string, int>();
for (int i = 0; i < numOfMain; i++)
{
int index = _rd.Next(CardPool.Count);
if (main.ContainsKey(CardPool[index]))
{
main[CardPool[index]]++;
}
else
{
main.Add(CardPool[index], 1);
}
CardPool.RemoveAt(index);
}
for (int i = 0; i < numOfEx; i++)
{
if (CardPoolEx.Count == 0)
{
break;
}
int index = _rd.Next(CardPoolEx.Count);
if (ex.ContainsKey(CardPoolEx[index]))
{
ex[CardPoolEx[index]]++;
}
else
{
ex.Add(CardPoolEx[index], 1);
}
CardPoolEx.RemoveAt(index);
}
FileStream fs = new FileStream(file, FileMode.Create);
StreamWriter sw = new StreamWriter(fs);
sw.WriteLine("#created by DeckGen");
sw.WriteLine("#main");
foreach (var kvp in main)
{
for (int i = 0; i < kvp.Value; i++)
{
sw.WriteLine(kvp.Key);
}
}
sw.WriteLine("#extra");
foreach (var kvp in ex)
{
for (int i = 0; i < kvp.Value; i++)
{
sw.WriteLine(kvp.Key);
}
}
sw.WriteLine("!side");
sw.Close();
fs.Close();
main.Clear();
ex.Clear();
return(true);
}
// Token: 0x060076EA RID: 30442 RVA: 0x00208338 File Offset: 0x00206538
private int __callBase_GetCrystalCount(CardPool cardPool, bool isSingleSelect, out bool isTenSelectDiscount)
{
return(base.GetCrystalCount(cardPool, isSingleSelect, out isTenSelectDiscount));
}
static void S_4(int turn, MemoryData memory, CardPool cardPool, GameFlow gameFlow)
{
memory.Approval +=5;
memory.Fear +=5;;
}
// Token: 0x060076E7 RID: 30439 RVA: 0x00208314 File Offset: 0x00206514
private bool __callBase_IsUsedOutActivityCardPoolSelectOpportunity(CardPool cardPool)
{
return(base.IsUsedOutActivityCardPoolSelectOpportunity(cardPool));
}
private void Awake()
{
_defaultPosition = transform.position;
_unfocusedPosition = _defaultPosition - unfocusedOffset;
_cardPool = new CardPool(maxCards, this, cardPrototype, cardRotation);
}
public CardPoolScriptController(CardPool self)
{
this.self = self;
}
// Token: 0x06007705 RID: 30469 RVA: 0x002086BC File Offset: 0x002068BC
public void __callBase_SelectCardUseCrystal(CardPool cardPool, bool isSingleSelect)
{
this.m_owner.__callBase_SelectCardUseCrystal(cardPool, isSingleSelect);
}
// Token: 0x060076EB RID: 30443 RVA: 0x00208344 File Offset: 0x00206544
private void __callBase_SelectCardUseTickets(CardPool cardPool, bool isSingleSelect)
{
base.SelectCardUseTickets(cardPool, isSingleSelect);
}
static void S_3(int turn, MemoryData memory, CardPool cardPool, GameFlow gameFlow)
{
memory.Fear += 5;;
}
// Token: 0x06007706 RID: 30470 RVA: 0x002086CC File Offset: 0x002068CC
public int __callBase_CanSelectCard(CardPool cardPool, bool isSingleSelect, bool isUsingTickets)
{
return(this.m_owner.__callBase_CanSelectCard(cardPool, isSingleSelect, isUsingTickets));
}
// Token: 0x06007708 RID: 30472 RVA: 0x002086EC File Offset: 0x002068EC
public int __callBase_CanUseTicketSelectCard(CardPool cardPool, int ticketNums)
{
return(this.m_owner.__callBase_CanUseTicketSelectCard(cardPool, ticketNums));
}
// Token: 0x06007709 RID: 30473 RVA: 0x002086FC File Offset: 0x002068FC
public void __callBase_SelectCardSpendTicketsOrCrystal(CardPool cardPool, bool isSingleSelect, bool isUsingTickets)
{
this.m_owner.__callBase_SelectCardSpendTicketsOrCrystal(cardPool, isSingleSelect, isUsingTickets);
}
void ApplyView(CardView view, CardPool.CardContext cx)
{
view.title.text = cx.title;
view.image.sprite = cx.image;
view.description.text = cx.description;
}
private void RemoveDeckCard(object sender, RoutedEventArgs e)
{
var src = e.OriginalSource as FrameworkElement;
if (src == null)
{
return;
}
var element = (src.DataContext as ObservableMultiCard);
if (element == null)
{
return;
}
var section = deckTabs.SelectedItem as ObservableSection;
if (element.Quantity > 1)
{
OpenQuantityPopup(qty =>
{
int actuallyRemoved = Math.Min(qty, element.Quantity);
if (!UnlimitedPool.Contains(element))
{
for (int i = 0; i < actuallyRemoved; ++i)
{
// When there are multiple copies of the same card, we insert clones of the CardModel.
// Otherwise, the ListBox gets confused with selection.
if (element.Quantity > 1)
{
var tempElement = element.AsObservable();
tempElement.Quantity = 1;
CardPool.Add(tempElement);
}
else
{
var tempElement = element.AsObservable();
tempElement.Quantity = 1;
CardPool.Add(tempElement);
}
element.Quantity -= 1;
if (element.Quantity <= 0)
{
element.Quantity = 0;
section.Cards.RemoveCard(element);
break;
}
}
}
else
{
if (qty >= element.Quantity)
{
section.Cards.RemoveCard(element);
}
else
{
element.Quantity -= qty;
}
}
});
}
else
{
if (section != null)
{
element.Quantity = 1;
section.Cards.RemoveCard(element);
}
if (!UnlimitedPool.Contains(element))
{
CardPool.Add(element);
}
}
}
public CardView MakeCardView(CardPool.CardContext cx)
{
return null;
}
private static int DealCardsAndCheckProbability(CardPool cardPool, int cardsToDeal, int[] dealingOrder = null, int dealingPosition = 0)
{
int[] cardsByValueLocal = new int[13];
int cardCountLocal = cardPool.CardCount;
Random rand = new Random();
Assert.IsTrue(cardCountLocal > 0, "Empty card pool is used.");
// Save card pool state to local
for (int i = 0; i < cardsByValueLocal.Length; i++)
{
cardsByValueLocal[i] = (int)Math.Round(cardCountLocal * cardPool.GetValueRangeProbability(i, i), 0);
}
// Deal card and update local state
for (int i = 0; i < cardsToDeal; i++)
{
int cardValue;
if (dealingOrder != null)
{
if (dealingPosition >= dealingOrder.Length)
{
cardValue = -1;
}
else
{
cardValue = cardPool.DealCard(dealingOrder[dealingPosition++]);
}
}
else
{
int[] availableValues = cardPool.GetAvailableCardValues().ToArray();
if (availableValues.Length == 0)
{
cardValue = -1;
}
else
{
int valIndex = rand.Next(0, availableValues.Length - 1);
cardValue = cardPool.DealCard(availableValues[valIndex]);
}
}
Console.WriteLine("Deal Card {0}.", cardValue);
if (cardValue < 0)
{
break;
}
cardCountLocal--;
cardsByValueLocal[cardValue]--;
}
// Check local against the card pool
Assert.AreEqual(cardPool.CardCount, cardCountLocal, "Local card count is incorrect.");
if (cardCountLocal > 0)
{
for (int i = 0; i < cardsByValueLocal.Length; i++)
{
decimal probabilityLocal = (decimal)cardsByValueLocal[i] / cardCountLocal;
Assert.AreEqual(cardPool.GetValueRangeProbability(i, i), probabilityLocal, string.Format("Local probability is incorrect for card value {0}", i));
}
}
return(dealingPosition);
}
