private void SetPlayerDeck(MemTools.YdcDeck deck, int playerIndex, bool allowNull)
{
if (!allowNull && deck.Equals(default(MemTools.YdcDeck)))
{
return;
}
playerDecks[playerIndex] = deck;
switch (playerIndex)
{
case 0:
player1DeckLabel.Text = "P1: " + deck.DeckName;
break;
case 1:
player2DeckLabel.Text = "P2: " + deck.DeckName;
break;
case 2:
player3DeckLabel.Text = "P3: " + deck.DeckName;
break;
case 3:
player4DeckLabel.Text = "P4: " + deck.DeckName;
break;
}
}
private void viewDeckDelayTimer_Tick(object sender, EventArgs e)
{
// Throttle viewing decks as there is a crash if loading too fast
if (!nextViewDeck.Equals(default(MemTools.YdcDeck)))
{
ViewDeckNow(nextViewDeck);
nextViewDeck = default(MemTools.YdcDeck);
viewDeckDelayTimer.Enabled = false;
}
}
private void decksListBox_SelectedIndexChanged(object sender, EventArgs e)
{
MemTools.YdcDeck deck = GetSelectedDeck();
if (!deck.Equals(default(MemTools.YdcDeck)))
{
if (autoViewDeckCheckBox.Checked)
{
ViewDeck(deck);
}
}
}
private void ViewDeck(MemTools.YdcDeck deck)
{
if (deck.Equals(default(MemTools.YdcDeck)))
{
return;
}
if (lastViewDeck < DateTime.Now - TimeSpan.FromSeconds(0.5))
{
ViewDeckNow(deck);
}
else
{
nextViewDeck = deck;
viewDeckDelayTimer.Enabled = true;
}
}
private void ViewDeckNow(MemTools.YdcDeck deck)
{
if (!Program.MemTools.IsFullyLoaded)
{
return;
}
if (deck.Equals(default(MemTools.YdcDeck)))
{
return;
}
MemTools.ScreenState screenState = Program.MemTools.GetScreenState();
if (screenState == MemTools.ScreenState.Duel ||
screenState == MemTools.ScreenState.DuelLoadingScreen)
{
// Don't interrupt a duel
return;
}
lastViewDeck = DateTime.Now;
MemTools.YdcDeck[] userDecks = Program.MemTools.ReadUserDecks();
if (userDecks != null)
{
string deckName = reservedDeckSlotName;
int lastDeckIndex = userDecks.Length - 1;
MemTools.YdcDeck lastDeck = userDecks[lastDeckIndex];
if (lastDeck.DeckName != deckName)
{
if (MessageBox.Show("This will wipe over the deck in user slot 32. Continue?", "Warning", MessageBoxButtons.YesNo) !=
DialogResult.Yes)
{
return;
}
}
lastDeck = deck;
lastDeck.DeckName = deckName;
userDecks[lastDeckIndex] = lastDeck;
Program.MemTools.WriteUserDecks(userDecks);
Program.MemTools.SelectUserDeck(lastDeckIndex, true);
}
}
private void exportDeckButton_Click(object sender, EventArgs e)
{
MemTools.YdcDeck deck = GetSelectedDeck();
if (deck.Equals(default(MemTools.YdcDeck)))
{
return;
}
try
{
if (!Directory.Exists(deckFilesDir))
{
Directory.CreateDirectory(deckFilesDir);
}
}
catch
{
}
if (Directory.Exists(deckFilesDir))
{
string filename = MakeSafeFileName(deck.DeckName).Trim();
if (string.IsNullOrEmpty(filename))
{
return;
}
filename += deckFilesExtension;
string path = Path.Combine(deckFilesDir, filename);
try
{
DialogResult result = MessageBox.Show("Would you like to export this as YDK (instead of YDL)?", "Export", MessageBoxButtons.YesNoCancel);
if (result == DialogResult.Yes)
{
YdkHelper.SaveDeck(deck, Path.ChangeExtension(path, YdkHelper.FileExtension));
}
else if (result == DialogResult.No)
{
File.WriteAllBytes(path, MemTools.StructToByteArray(deck));
}
}
catch
{
}
}
}
public YdcDeckWrapper(MemTools.YdcDeck deck)
{
Deck = deck;
}
private void UpdateDecksList()
{
ydcDecks.Sort((x, y) => (x.DeckName != null ? x.DeckName : string.Empty).CompareTo(
y.DeckName != null ? y.DeckName : string.Empty));
userDecks.Sort((x, y) => (x.DeckName != null ? x.DeckName : string.Empty).CompareTo(
y.DeckName != null ? y.DeckName : string.Empty));
fileDecks.Sort((x, y) => (x.DeckName != null ? x.DeckName : string.Empty).CompareTo(
y.DeckName != null ? y.DeckName : string.Empty));
decksListBox.BeginUpdate();
decksListBox.Items.Clear();
string filter = deckFilterTextBox.Text;
if (string.IsNullOrEmpty(filter))
{
filter = string.Empty;
}
filter = filter.ToLower().Trim();
bool isUserDecks = false;
List <MemTools.YdcDeck> decks = null;
switch (deckTypeComboBox.SelectedIndex)
{
case 0:
decks = userDecks;
isUserDecks = true;
break;
case 1:
decks = ydcDecks;
break;
case 2:
decks = fileDecks;
break;
}
if (decks != null)
{
for (int i = 0; i < decks.Count; i++)
{
MemTools.YdcDeck deck = decks[i];
HashSet <short> cardIds = new HashSet <short>();
for (int j = 0; j < deck.NumMainDeckCards && j < deck.MainDeck.Length; j++)
{
cardIds.Add(deck.MainDeck[j]);
}
for (int j = 0; j < deck.NumExtraDeckCards && j < deck.ExtraDeck.Length; j++)
{
cardIds.Add(deck.ExtraDeck[j]);
}
for (int j = 0; j < deck.NumSideDeckCards && j < deck.SideDeck.Length; j++)
{
cardIds.Add(deck.SideDeck[j]);
}
bool hasXyz = false;
bool hasPendulum = false;
bool hasRitual = false;
bool hasSynchro = false;
bool hasFusion = false;
bool hasLink = false;
foreach (short cardId in cardIds)
{
CardInfo card;
if (Program.Manager.CardManager.Cards.TryGetValue(cardId, out card))
{
if (card.CardTypeFlags.HasFlag(CardTypeFlags.Xyz))
{
hasXyz = true;
}
if (card.CardTypeFlags.HasFlag(CardTypeFlags.Pendulum))
{
hasPendulum = true;
}
if (card.CardTypeFlags.HasFlag(CardTypeFlags.Ritual))
{
hasRitual = true;
}
if (card.CardTypeFlags.HasFlag(CardTypeFlags.Synchro) ||
card.CardTypeFlags.HasFlag(CardTypeFlags.DarkSynchro))
{
hasSynchro = true;
}
if (card.CardTypeFlags.HasFlag(CardTypeFlags.Fusion))
{
hasFusion = true;
}
if (card.CardTypeFlags.HasFlag(CardTypeFlags.Link))
{
hasLink = true;
}
}
}
if (!FilterMatched(filterDeckXyzCheckBox, hasXyz) ||
!FilterMatched(filterDeckPendulumCheckBox, hasPendulum) ||
!FilterMatched(filterDeckRitualCheckBox, hasRitual) ||
!FilterMatched(filterDeckSynchroCheckBox, hasSynchro) ||
!FilterMatched(filterDeckFusionCheckBox, hasFusion) ||
!FilterMatched(filterDeckLinkCheckBox, hasLink))
{
continue;
}
if (deck.IsDeckComplete || (isUserDecks && !string.IsNullOrEmpty(deck.DeckName)))
{
if (isUserDecks && deck.DeckName == reservedDeckSlotName && i == decks.Count - 1)
{
continue;
}
if (!string.IsNullOrEmpty(filter) &&
!(deck.DeckName != null ? deck.DeckName : string.Empty).ToLower().Contains(filter))
{
continue;
}
decksListBox.Items.Add(new YdcDeckWrapper(deck));
}
}
}
decksListBox.EndUpdate();
}
private void ReloadDecks()
{
if (!Program.MemTools.IsFullyLoaded)
{
return;
}
MemTools.YdcDeck[] yDecks = Program.MemTools.ReadYdcDecks();
if (yDecks != null)
{
ydcDecks.Clear();
// The last 4 decks are reserved for custom duels
for (int i = 0; i < yDecks.Length - 4; i++)
{
ydcDecks.Add(yDecks[i]);
}
}
MemTools.YdcDeck[] uDecks = Program.MemTools.ReadUserDecks();
if (uDecks != null)
{
userDecks.Clear();
userDecks.AddRange(uDecks);
}
if (Directory.Exists(deckFilesDir))
{
fileDecks.Clear();
foreach (string file in Directory.GetFiles(deckFilesDir, "*" + deckFilesExtension))
{
try
{
byte[] buffer = File.ReadAllBytes(file);
if (buffer.Length != System.Runtime.InteropServices.Marshal.SizeOf(typeof(MemTools.YdcDeck)))
{
continue;
}
MemTools.YdcDeck deck = MemTools.StructFromByteArray <MemTools.YdcDeck>(buffer);
if (deck.IsValid)
{
fileDecks.Add(deck);
}
}
catch
{
}
}
foreach (string file in Directory.GetFiles(deckFilesDir, "*" + YdkHelper.FileExtension))
{
try
{
MemTools.YdcDeck deck = YdkHelper.LoadDeck(file);
if (deck.IsValid)
{
fileDecks.Add(deck);
}
}
catch
{
}
}
}
UpdateDecksList();
}
