private void DoSave()
{
var filePathFinder = new UnityDeck(CardGameManager.Current, nameInputField.text,
CardGameManager.Current.DeckFileType);
try
{
if (!Directory.Exists(CardGameManager.Current.DecksDirectoryPath))
{
Directory.CreateDirectory(CardGameManager.Current.DecksDirectoryPath);
}
File.WriteAllText(filePathFinder.FilePath, textInputField.text);
_selectedFilePath = filePathFinder.FilePath;
HideNewDeckPanel();
BuildDeckFileSelectionOptions();
foreach (var path in _deckFiles.Keys)
{
Debug.Log(path);
}
LoadFromFileAndHide();
}
catch (Exception e)
{
Debug.LogError(DeckSaveErrorMessage + e.Message);
}
}
public void ShowDeckSaveMenu()
{
UnityDeck deckToSave = CurrentDeck;
bool overwrite = SavedDeck != null && deckToSave.Name.Equals(SavedDeck.Name);
DeckSaver.Show(deckToSave, UpdateDeckName, OnSaveDeck, overwrite);
}
public void PrintPdf()
{
_currentDeck.Name = nameInputField.text;
UnityDeck deck = _currentDeck;
Uri pdfUri = null;
try
{
pdfUri = deck.PrintPdf();
}
catch (Exception e)
{
Debug.LogError(DeckPrintErrorMessage + e.Message + e.StackTrace);
CardGameManager.Instance.Messenger.Show(DeckPrintErrorMessage + e.Message);
}
if (pdfUri == null || !pdfUri.IsAbsoluteUri)
{
Debug.LogError(DeckPrintOpenErrorMessage);
CardGameManager.Instance.Messenger.Show(DeckPrintOpenErrorMessage);
return;
}
#if ENABLE_WINMD_SUPPORT
UnityEngine.WSA.Application.InvokeOnUIThread(async() => {
try
{
var file = await Windows.Storage.StorageFile.GetFileFromPathAsync(pdfUri.LocalPath);
if (file != null)
{
// Launch the retrieved file
bool success = await Windows.System.Launcher.LaunchFileAsync(file);
if (!success)
{
Debug.LogError(DeckPrintOpenPathErrorMessage + pdfUri.LocalPath);
CardGameManager.Instance.Messenger.Show(DeckPrintOpenPathErrorMessage + pdfUri.LocalPath);
}
}
else
{
Debug.LogError(DeckPrintOpenPathErrorMessage + pdfUri.LocalPath);
CardGameManager.Instance.Messenger.Show(DeckPrintOpenPathErrorMessage + pdfUri.LocalPath);
}
}
catch (Exception e)
{
Debug.LogError(e.Message + e.StackTrace);
CardGameManager.Instance.Messenger.Show(DeckPrintOpenPathErrorMessage + pdfUri.LocalPath);
}
}, false);
#else
Application.OpenURL(pdfUri.AbsoluteUri); // This likely fails, so show the file location
CardGameManager.Instance.Messenger.Show(DeckPrintOpenPathErrorMessage + pdfUri.AbsoluteUri);
#endif
}
public void Show(UnityDeck deckToShow, OnNameChangeDelegate nameChangeCallback = null,
OnDeckSavedDelegate deckSaveCallback = null, bool overwrite = false)
{
Show();
_currentDeck = deckToShow ?? new UnityDeck(CardGameManager.Current);
_nameChangeCallback = nameChangeCallback;
_deckSaveCallback = deckSaveCallback;
_doesAutoOverwrite = overwrite;
nameInputField.text = _currentDeck.Name;
textOutputArea.text = _currentDeck.ToString();
}
private void LoadDeck(UnityDeck deck)
{
foreach (Card card in deck.Cards)
{
foreach (GameBoardCard boardCard in CardGameManager.Current.GameBoardCards.Where(boardCard =>
card.Id.Equals(boardCard.Card)))
{
CreateGameBoards(boardCard.Boards);
}
}
Dictionary <string, List <Card> > extraGroups = deck.GetExtraGroups();
List <Card> extraCards = deck.GetExtraCards();
List <UnityCard> deckCards = deck.Cards.Where(card => !extraCards.Contains(card)).Cast <UnityCard>().ToList();
deckCards.Shuffle();
string deckName = !string.IsNullOrEmpty(CardGameManager.Current.GamePlayDeckName)
? CardGameManager.Current.GamePlayDeckName
: deck.Name;
if (CgsNetManager.Instance.isNetworkActive && CgsNetManager.Instance.LocalPlayer != null)
{
CgsNetManager.Instance.LocalPlayer.RequestNewDeck(deckName, deckCards);
var i = 1;
foreach (KeyValuePair <string, List <Card> > cardGroup in extraGroups)
{
Vector2 position = NextDeckPosition + Vector2.right * CardGameManager.PixelsPerInch * i *
CardGameManager.Current.CardSize.X;
CgsNetManager.Instance.LocalPlayer.RequestNewCardStack(cardGroup.Key,
cardGroup.Value.Cast <UnityCard>(), position);
i++;
}
}
else
{
_soloDeckStack = CreateCardStack(deckName, deckCards, NextDeckPosition);
var i = 1;
foreach (KeyValuePair <string, List <Card> > cardGroup in extraGroups)
{
Vector2 position = NextDeckPosition + Vector2.right * CardGameManager.PixelsPerInch * i *
CardGameManager.Current.CardSize.X;
CreateCardStack(cardGroup.Key, (List <UnityCard>)cardGroup.Value.Cast <UnityCard>(), position);
i++;
}
}
NextDeckPosition += Vector2.down * CardGameManager.PixelsPerInch * CardGameManager.Current.CardSize.Y;
PromptForHand();
}
private void LoadDeck(UnityDeck deck)
{
foreach (var card in deck.Cards)
{
foreach (var gameBoardCard in CardGameManager.Current.GameBoardCards.Where(boardCard =>
card.Id.Equals(boardCard.Card)))
{
CreateGameBoards(gameBoardCard.Boards);
}
}
var extraGroups = deck.GetExtraGroups();
var extraCards = deck.GetExtraCards();
var deckCards = deck.Cards.Where(card => !extraCards.Contains(card)).Cast <UnityCard>().ToList();
deckCards.Shuffle();
var deckName = !string.IsNullOrEmpty(CardGameManager.Current.GamePlayDeckName)
? CardGameManager.Current.GamePlayDeckName
: deck.Name;
var newDeckPosition = NewDeckPosition;
if (CgsNetManager.Instance.isNetworkActive && CgsNetManager.Instance.LocalPlayer != null)
{
CgsNetManager.Instance.LocalPlayer.RequestNewDeck(deckName, deckCards);
var i = 1;
foreach (var cardGroup in extraGroups)
{
var position = newDeckPosition + Vector2.right *
(CardGameManager.PixelsPerInch * i * CardGameManager.Current.CardSize.X + DeckPositionBuffer);
CgsNetManager.Instance.LocalPlayer.RequestNewCardStack(cardGroup.Key,
cardGroup.Value.Cast <UnityCard>(), position);
i++;
}
}
else
{
_soloDeckStack = CreateCardStack(deckName, deckCards, newDeckPosition);
var i = 1;
foreach (var cardGroup in extraGroups)
{
var position = newDeckPosition + Vector2.right *
(CardGameManager.PixelsPerInch * i * CardGameManager.Current.CardSize.X);
CreateCardStack(cardGroup.Key, cardGroup.Value.Cast <UnityCard>().ToList(), position);
i++;
}
}
PromptForHand();
}
public void DoSaveDontOverwrite()
{
var filePathFinder = new UnityDeck(CardGameManager.Current, nameInputField.text,
CardGameManager.Current.DeckFileType);
if (File.Exists(filePathFinder.FilePath))
{
CardGameManager.Instance.StartCoroutine(WaitToPromptOverwrite());
}
else
{
DoSave();
}
}
public void Sort()
{
UnityDeck sortedDeck = CurrentDeck;
sortedDeck.Sort();
foreach (CardZone zone in CardZones)
{
zone.transform.DestroyAllChildren();
}
foreach (Card card in sortedDeck.Cards)
{
AddCard((UnityCard)card);
}
}
public void AttemptSaveAndHide()
{
var filePathFinder = new UnityDeck(CardGameManager.Current, nameInputField.text,
CardGameManager.Current.DeckFileType);
if (!_doesAutoOverwrite && File.Exists(filePathFinder.FilePath))
{
CardGameManager.Instance.Messenger.Prompt(OverWriteDeckPrompt, SaveToFile);
}
else
{
SaveToFile();
}
Hide();
}
public void LoadFromFileAndHide()
{
try
{
var deckText = File.ReadAllText(_selectedFilePath);
var newDeck = UnityDeck.Parse(CardGameManager.Current, _deckFiles[_selectedFilePath],
CardGameManager.Current.DeckFileType, deckText);
_loadCallback?.Invoke(newDeck);
Hide();
}
catch (Exception e)
{
Debug.LogError(DeckLoadErrorMessage + e.Message);
CardGameManager.Instance.Messenger.Show(DeckLoadErrorMessage + e.Message);
}
}
private void LoadDeck(UnityDeck deck)
{
if (deck == null)
{
return;
}
Clear();
foreach (Card card in deck.Cards)
{
AddCard((UnityCard)card);
}
SavedDeck = deck;
UpdateDeckStats();
scrollRect.horizontalNormalizedPosition = 0;
}
private static void SaveToFile(UnityDeck deck, OnDeckSavedDelegate deckSaveCallback = null)
{
try
{
if (!Directory.Exists(CardGameManager.Current.DecksDirectoryPath))
{
Directory.CreateDirectory(CardGameManager.Current.DecksDirectoryPath);
}
File.WriteAllText(deck.FilePath, deck.ToString());
}
catch (Exception e)
{
Debug.LogError(DeckSaveErrorMessage + e.Message);
}
deckSaveCallback?.Invoke(deck);
}
public void ChangeName(string newName)
{
if (_nameChangeCallback != null)
{
newName = _nameChangeCallback(newName);
}
if (!string.IsNullOrEmpty(newName))
{
nameInputField.text = newName;
}
var deck = new UnityDeck(CardGameManager.Current, newName, CardGameManager.Current.DeckFileType);
foreach (var card in _currentDeck.Cards)
{
deck.Add((UnityCard)card);
}
textOutputArea.text = deck.ToString();
}
