public void Initialize()
{
var settingsDB = PlayerSettingsDB.Get();
var modelProxyDB = ModelProxyDB.Get();
favDecks.SuspendNotifies();
foreach (var favDeckOb in settingsDB.favDecks)
{
var deck = new CardCollectionViewModel()
{
Name = favDeckOb.Name
};
foreach (var cardOb in favDeckOb.knownCards)
{
var cardVM = new CardViewModel()
{
CardModel = modelProxyDB.GetCardProxy(cardOb)
};
deck.Cards.Add(cardVM);
}
var favDeck = new SolvableDeckViewModel()
{
Deck = deck
};
favDecks.Add(favDeck);
favDeck.RefreshSolver(gameModel, favDeckOb);
}
favDecks.ResumeNotifies();
}
public static async void CloudStorageInit()
{
cachedApiState = GoogleDriveService.EState.AuthInProgress;
OnCloudStorageApiUpdate.Invoke(cachedApiState);
try
{
await CloudStorage.InitFileList();
}
catch (Exception ex)
{
Logger.WriteLine("Exception: " + ex);
}
OnCloudStorageApiUpdate.Invoke(CloudStorage.GetState());
var settingsDB = PlayerSettingsDB.Get();
settingsDB.cloudToken = CloudStorage.GetAuthToken().refreshToken;
bool needsSave = await CloudStorageLoad();
cloudSettingsInitialized = true;
if (needsSave)
{
await CloudStorageSave();
}
}
private static async Task <bool> CloudStorageLoad()
{
string fileContent = null;
try
{
fileContent = await CloudStorage.DownloadTextFile("FFTriadBuddy-settings.json");
Logger.WriteLine("Loaded cloud save, API response: " + CloudStorage.GetLastApiResponse());
}
catch (Exception ex)
{
Logger.WriteLine("Exception: " + ex);
}
CloudStorageSendNotifies(CloudSaveState.Loaded);
bool needsSave = true;
if (!string.IsNullOrEmpty(fileContent))
{
needsSave = PlayerSettingsDB.Get().MergeWithContent(fileContent);
}
return(needsSave);
}
private TriadDeck FindDeckToUseFor(TriadNpc npc)
{
PlayerSettingsDB settingsDB = PlayerSettingsDB.Get();
TriadCard[] cardsCopy = null;
if (settingsDB.lastDeck.ContainsKey(npc))
{
TriadDeck savedDeck = PlayerSettingsDB.Get().lastDeck[npc];
if (savedDeck != null && savedDeck.knownCards.Count == 5)
{
cardsCopy = savedDeck.knownCards.ToArray();
}
}
if (cardsCopy == null)
{
cardsCopy = new TriadCard[5];
if (PlayerDeck == null)
{
Array.Copy(settingsDB.starterCards, cardsCopy, cardsCopy.Length);
}
else
{
Array.Copy(PlayerDeck.knownCards.ToArray(), cardsCopy, cardsCopy.Length);
}
}
return(new TriadDeck(cardsCopy));
}
private void LoadOwnedCards()
{
List <CardModelProxy> removeList = new List <CardModelProxy>();
removeList.AddRange(ownedCards);
ownedCards.SuspendNotifies();
ownedCards.Clear();
var settingsDB = PlayerSettingsDB.Get();
foreach (var card in settingsDB.ownedCards)
{
var cardProxy = cards.Find(x => x.cardOb.Id == card.Id);
if (cardProxy != null)
{
cardProxy.IsOwned = true;
ownedCards.Add(cardProxy);
removeList.Remove(cardProxy);
}
}
foreach (var card in removeList)
{
card.IsOwned = false;
}
ownedCards.ResumeNotifies();
}
private void AssignFavDeckFrom(SolvableDeckViewModel favDeck, DeckViewModel sourceDeck)
{
if (sourceDeck.Cards.Count == favDeck.Deck.Cards.Count)
{
favDeck.Deck.Cards.SuspendNotifies();
var cards = new List <TriadCard>();
for (int idx = 0; idx < sourceDeck.Cards.Count; idx++)
{
var cardProxy = sourceDeck.Cards[idx].CardModel;
favDeck.Deck.Cards[idx].CardModel = cardProxy;
cards.Add(cardProxy.cardOb);
}
favDeck.Deck.Cards.ResumeNotifies();
int slotIdx = favDecks.IndexOf(favDeck);
var namedDeck = new TriadDeckNamed(new TriadDeck(cards))
{
Name = favDeck.Deck.Name
};
PlayerSettingsDB.Get().UpdateFavDeck(slotIdx, namedDeck);
favDeck.RefreshSolver(gameModel, namedDeck);
}
}
private void CommandExportFunc(object dummyParam)
{
var dialog = new Microsoft.Win32.SaveFileDialog
{
FileName = "export",
DefaultExt = ".json",
Filter = "Settings|*.json",
InitialDirectory = defaultPath,
OverwritePrompt = true
};
var result = dialog.ShowDialog();
if (result == true)
{
try
{
var fileName = dialog.FileName;
Logger.WriteLine("Exporting settings to: {0}", fileName);
string jsonStr = PlayerSettingsDB.Get().SaveToJson(true);
if (File.Exists(fileName))
{
File.Delete(fileName);
}
File.WriteAllText(fileName, jsonStr);
}
catch (Exception ex)
{
Logger.WriteLine("Failed to export: {0}", ex);
}
}
}
private void CommandImportFunc(object dummyParam)
{
var dialog = new Microsoft.Win32.OpenFileDialog
{
FileName = "export",
DefaultExt = ".json",
Filter = "Settings|*.json",
InitialDirectory = defaultPath,
CheckFileExists = true
};
var result = dialog.ShowDialog();
if (result == true)
{
try
{
var fileName = dialog.FileName;
Logger.WriteLine("Importing settings from: {0}", fileName);
string jsonStr = File.ReadAllText(fileName);
var settingsDB = PlayerSettingsDB.Get();
settingsDB.LoadFromJson(jsonStr);
settingsDB.OnImport();
}
catch (Exception ex)
{
Logger.WriteLine("Failed to import: {0}", ex);
}
}
}
public void UpdateOwnedCard(CardModelProxy cardProxy)
{
if (!ownedCards.IsNotifySuspended)
{
var settingsDB = PlayerSettingsDB.Get();
var hasChanges = false;
if (cardProxy.IsOwned && !OwnedCards.Contains(cardProxy))
{
//Logger.WriteLine("Adding owned card: {0}", cardProxy.cardOb.Name.GetCodeName());
OwnedCards.Add(cardProxy);
settingsDB.ownedCards.Add(cardProxy.cardOb);
hasChanges = true;
}
else if (!cardProxy.IsOwned && OwnedCards.Contains(cardProxy))
{
//Logger.WriteLine("Removing owned card: {0}", cardProxy.cardOb.Name.GetCodeName());
OwnedCards.Remove(cardProxy);
settingsDB.ownedCards.Remove(cardProxy.cardOb);
hasChanges = true;
}
if (hasChanges)
{
settingsDB.MarkDirty();
UpdateCompletedNpcs();
OnCardOwnerChanged?.Invoke(cardProxy);
}
}
}
private void Window_SizeChanged(object sender, SizeChangedEventArgs e)
{
var settingsDB = PlayerSettingsDB.Get();
settingsDB.lastWidth = (float)Width;
settingsDB.lastHeight = (float)Height;
}
public static void Initialize()
{
var settingsDB = PlayerSettingsDB.Get();
bool loaded = settingsDB.Load();
if (loaded)
{
settingsDB.SaveBackup();
}
else
{
Logger.WriteLine("Warning: failed to load player settings!");
}
if (!string.IsNullOrEmpty(settingsDB.forcedLanguage))
{
LocalizationDB.SetCurrentUserLanguage(settingsDB.forcedLanguage);
}
if (settingsDB.useXInput)
{
XInputStub.StartPolling();
}
CloudStorage = new GoogleDriveService(
GoogleClientIdentifiers.Keys,
new GoogleOAuth2.Token()
{
refreshToken = settingsDB.cloudToken
});
}
public LocalSavesViewModel()
{
CommandExport = new RelayCommand <object>(CommandExportFunc);
CommandImport = new RelayCommand <object>(CommandImportFunc);
CommandViewBackups = new RelayCommand <object>(CommandViewBackupFunc);
defaultPath = PlayerSettingsDB.Get().GetBackupFolderPath();
}
public OverlayWindowInteractive()
{
InitializeComponent();
if (PlayerSettingsDB.Get().useXInput)
{
XInputStub.StartPolling();
}
}
public static void SetUseCloudSaves(bool useCloud)
{
GoogleOAuth2.KillPendingAuthorization();
var settingsDB = PlayerSettingsDB.Get();
settingsDB.useCloudStorage = useCloud;
if (useCloud && CloudStorage != null)
{
if (!cloudSettingsInitialized)
{
CloudStorageInit();
}
else
{
CloudStorageSendNotifies(CloudSaveState.UpToDate);
}
}
lock (cloudSettingsSyncLock)
{
cloudSettingsCanSave = useCloud;
}
if (cloudSettingsUpdateTask == null)
{
cloudSettingsUpdateTask = new Task(async() =>
{
const int intervalMs = 2 * 60 * 1000;
while (true)
{
await Task.Delay(intervalMs);
bool canSave = false;
lock (cloudSettingsSyncLock)
{
canSave = cloudSettingsCanSave;
}
if (canSave)
{
if (PlayerSettingsDB.Get().isDirty)
{
await CloudStorageSave();
}
else
{
CloudStorageSendNotifies(CloudSaveState.UpToDate);
}
}
}
});
cloudSettingsUpdateTask.Start();
}
}
private void UpdateCompletedNpcs()
{
var settingsDB = PlayerSettingsDB.Get();
foreach (var npc in npcs)
{
var notOwnedReward = npc.npcOb.Rewards.Find(x => !settingsDB.ownedCards.Contains(x));
npc.IsCompleted = notOwnedReward == null;
npc.UpdateCachedText();
}
}
public TriadGameModel()
{
TriadNpc npcOb = TriadNpcDB.Get().npcs.Find(x => x?.Id == PlayerSettingsDB.Get().lastNpcId);
if (npcOb == null)
{
npcOb = TriadNpcDB.Get().Find("Triple Triad master");
}
SetNpc(npcOb);
}
public void Load()
{
LoadCards();
LoadOwnedCards();
LoadNpc();
LoadRules();
LoadTournaments();
PlayerSettingsDB.Get().OnUpdated += ModelProxyDB_OnUpdated;
UpdateCompletedNpcs();
LocalizationDB.OnLanguageChanged += LocalizationDB_OnLanguageChanged;
}
private void CommandFavRemoveFunc(SolvableDeckViewModel favDeck)
{
int slotIdx = favDecks.IndexOf(favDeck);
if (slotIdx >= 0)
{
var result = MessageBox.Show(loc.strings.FavDeckForm_Dynamic_RemoveMsg, loc.strings.App_Title, MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (result == MessageBoxResult.Yes)
{
PlayerSettingsDB.Get().UpdateFavDeck(slotIdx, null);
favDecks.RemoveAt(slotIdx);
}
}
}
public static void Close()
{
lock (cloudSettingsSyncLock)
{
cloudSettingsCanSave = false;
}
var settingsDB = PlayerSettingsDB.Get();
if (settingsDB.isDirty && settingsDB.useCloudStorage)
{
_ = CloudStorageSave();
}
settingsDB.Save();
}
public void SetPlayerDeck(TriadDeck deck, bool notifySetupChange = true)
{
Logger.WriteLine("Game.SetPlayerDeck: {0}", deck);
PlayerDeck = deck;
if (Npc != null && deck != null)
{
PlayerSettingsDB.Get().UpdatePlayerDeckForNpc(Npc, deck);
}
OnDeckChanged?.Invoke(deck);
if (notifySetupChange)
{
OnSetupChanged?.Invoke(this);
}
}
public void UpdateCachedText(bool sendNotifies = true)
{
var newDescRules = "";
foreach (var rule in npcOb.Rules)
{
if (newDescRules.Length > 0)
{
newDescRules += ", ";
}
newDescRules += rule.GetLocalizedName();
}
if (newDescRules.Length == 0)
{
newDescRules = loc.strings.MainForm_Dynamic_RuleListEmpty;
}
PlayerSettingsDB settingsDB = PlayerSettingsDB.Get();
var newDescRewards = "";
foreach (var reward in npcOb.Rewards)
{
if (!settingsDB.ownedCards.Contains(reward))
{
if (newDescRewards.Length > 0)
{
newDescRewards += ", ";
}
newDescRewards += reward.Name.GetLocalized();
}
}
descRules = newDescRules;
descReward = newDescRewards;
descCompleted = IsCompleted ? loc.strings.MainForm_Dynamic_NpcCompletedColumn : "";
if (sendNotifies)
{
DescRules = descRules;
DescReward = descReward;
DescCompleted = descCompleted;
}
}
public void SetNpc(TriadNpc npc)
{
if (npc == Npc)
{
return;
}
Logger.WriteLine("Game.SetNpc: {0}:{1}", npc?.Id, npc?.Name.GetCodeName());
Npc = npc;
OnNpcChanged?.Invoke(npc);
var useDeck = FindDeckToUseFor(npc);
SetPlayerDeck(useDeck, notifySetupChange: false);
UpdateSession();
PlayerSettingsDB.Get().lastNpcId = npc.Id;
}
private static async Task CloudStorageSave()
{
string fileContent = PlayerSettingsDB.Get().SaveToString();
if (!string.IsNullOrEmpty(fileContent))
{
try
{
await CloudStorage.UploadTextFile("FFTriadBuddy-settings.json", fileContent);
Logger.WriteLine("Created cloud save, API response: " + CloudStorage.GetLastApiResponse());
}
catch (Exception ex)
{
Logger.WriteLine("Exception: " + ex);
}
CloudStorageSendNotifies(CloudSaveState.Saved);
}
}
private void Application_Startup(object sender, StartupEventArgs e)
{
Logger.Initialize(e.Args);
bool canStart = false;
bool updatePending = GithubUpdater.FindAndApplyUpdates();
if (!updatePending)
{
bool hasAssets = LoadAssets();
if (hasAssets)
{
canStart = true;
}
else
{
string appName = Assembly.GetEntryAssembly().GetName().Name;
MessageBox.Show("Failed to initialize resources!", appName, MessageBoxButton.OK, MessageBoxImage.Stop);
}
}
#if DEBUG
if (Array.Find(e.Args, x => x == "-runTests") != null)
{
TestManager.RunTests();
canStart = false;
}
else if (Array.Find(e.Args, x => x == "-dataConvert") != null)
{
var converter = new DataConverter();
converter.Run();
canStart = false;
}
#endif // DEBUG
if (canStart)
{
DialogWindowService.Initialize();
OverlayWindowService.Initialize();
AppWindowService.Initialize();
canSaveSettings = true;
var window = new MainWindow();
var settingsDB = PlayerSettingsDB.Get();
window.FontSize = settingsDB.fontSize;
window.Topmost = settingsDB.alwaysOnTop;
if (settingsDB.lastHeight > window.MinHeight)
{
window.Height = settingsDB.lastHeight;
}
if (settingsDB.lastWidth > window.MinWidth)
{
window.Width = settingsDB.lastWidth;
}
window.Show();
}
else
{
Shutdown();
}
}
