public void CreateBoard(GameBoard board)
{
if (board == null)
{
return;
}
GameObject newBoard = new GameObject(board.Id, typeof(RectTransform));
RectTransform rt = (RectTransform)newBoard.transform;
rt.SetParent(playAreaContent);
rt.anchorMin = Vector2.zero;
rt.anchorMax = Vector2.zero;
rt.offsetMin = board.OffsetMin * CardGameManager.PixelsPerInch;
rt.offsetMax = board.Size * CardGameManager.PixelsPerInch + rt.offsetMin;
string boardFilepath = CardGameManager.Current.GameBoardsFilePath + "/" + board.Id + "." +
CardGameManager.Current.GameBoardFileType;
Sprite boardImageSprite = UnityExtensionMethods.CreateSprite(boardFilepath);
if (boardImageSprite != null)
{
newBoard.AddComponent <Image>().sprite = boardImageSprite;
}
rt.localScale = Vector3.one;
}
private void CreateBoard(GameBoard board)
{
var newBoard = new GameObject(board.Id, typeof(RectTransform));
var boardRectTransform = (RectTransform)newBoard.transform;
boardRectTransform.SetParent(playArea.transform);
boardRectTransform.anchorMin = Vector2.zero;
boardRectTransform.anchorMax = Vector2.zero;
boardRectTransform.offsetMin =
new Vector2(board.OffsetMin.X, board.OffsetMin.Y) * CardGameManager.PixelsPerInch;
boardRectTransform.offsetMax =
new Vector2(board.OffsetMin.X, board.OffsetMin.Y) * CardGameManager.PixelsPerInch +
boardRectTransform.offsetMin;
string boardFilepath = CardGameManager.Current.GameBoardsDirectoryPath + "/" + board.Id + "." +
CardGameManager.Current.GameBoardImageFileType;
Sprite boardImageSprite = File.Exists(boardFilepath)
? UnityExtensionMethods.CreateSprite(boardFilepath)
: null;
if (boardImageSprite != null)
{
newBoard.AddComponent <Image>().sprite = boardImageSprite;
}
boardRectTransform.localScale = Vector3.one;
}
private void assert(PlayerImplementation Player, Context context)
{
int PlayerCount = context.playersToGetAction.Count;
int Pot = context.CurrentPot;
int bigBlind = context.BigBlind;
string status = context.currentAction.ToString();
float HandStrength = Player.HandStrength;
float HandPotential = Player.HandPotential;
string state = context.state().ToString();
int callAmount = context.CallAmount;
int PlayerMoney = Player.Chips;
Debug.Log(PlayerCount);
Debug.Log(Pot);
Debug.Log(bigBlind);
Debug.Log(status);
Debug.Log(HandStrength);
Debug.Log(HandPotential);
Debug.Log(state);
Debug.Log(callAmount);
Debug.Log(PlayerMoney);
Debug.Log("*******");
string goal = "decisionResult(" + PlayerCount + "," +
Pot + "," + bigBlind + "," + status + "," + HandStrength + "," +
HandPotential + "," + state + "," + callAmount + "," + PlayerMoney + ").";
UnityExtensionMethods.IsTrueParsed(kB, goal);
}
// Returns true iff the entity type matched and
public bool TryToApplyPosition(Position positionData)
{
if (positionData.entityType != (int)Entity_Type.objects)
{
return(false);
}
int entityId = positionData.entityId;
if (!networkedObjectFromEntityId.ContainsKey(entityId))
{
Debug.LogWarning("Entity ID : " + positionData.entityId + "not found in Dictionary dropping object movement packet");
return(false);
}
Transform netObjTransform = networkedObjectFromEntityId[entityId].transform;
if (!netObjTransform)
{
Debug.LogError($"TryToApplyPosition: NetObj with entityID {entityId} had no Transform component");
return(false);
}
netObjTransform.position = positionData.pos;
netObjTransform.rotation = positionData.rot;
UnityExtensionMethods.SetGlobalScale(netObjTransform, Vector3.one * positionData.scaleFactor);
return(true);
}
public void Load(bool didDownload = false)
{
try
{
if (!didDownload)
{
JsonConvert.PopulateObject(File.ReadAllText(ConfigFilePath), this);
}
CreateEnumLookups();
if (CoroutineRunner != null)
{
CoroutineRunner.StartCoroutine(CGS.CardGameManager.Instance.LoadCards());
}
LoadSets();
BackgroundImageSprite = UnityExtensionMethods.CreateSprite(BackgroundImageFilePath);
CardBackImageSprite = UnityExtensionMethods.CreateSprite(CardBackImageFilePath);
IsLoaded = true;
// Kick off auto-update in the background, even though it won't load until next time the app restarts
if (AutoUpdate && !didDownload && CoroutineRunner != null)
{
CoroutineRunner.StartCoroutine(Download());
}
}
catch (Exception e)
{
Error += e.Message + e.StackTrace + Environment.NewLine;
IsLoaded = false;
}
}
public void ApplyPositionToStart(Position positionData)
{
//alternate kinematic to allow for sending non physics transform updates;
if (NetworkedObjectsManager.Instance.networkedObjectFromEntityId.ContainsKey(positionData.entityId))
{
if (!rigidbodyFromEntityId.ContainsKey(positionData.entityId))
{
rigidbodyFromEntityId.Add(positionData.entityId, NetworkedObjectsManager.Instance.networkedObjectFromEntityId[positionData.entityId].GetComponent <Rigidbody>());
}
var rb = rigidbodyFromEntityId[positionData.entityId];
if (!rb)
{
Debug.LogError("There is no rigidbody in netobject entity id: " + positionData.entityId);
return;
}
rb.isKinematic = true;
NetworkedObjectsManager.Instance.networkedObjectFromEntityId[positionData.entityId].transform.position = positionData.pos;
NetworkedObjectsManager.Instance.networkedObjectFromEntityId[positionData.entityId].transform.rotation = positionData.rot;
UnityExtensionMethods.SetGlobalScale(NetworkedObjectsManager.Instance.networkedObjectFromEntityId[positionData.entityId].transform, Vector3.one * positionData.scaleFactor);
}
else
{
Debug.LogWarning("Entity ID : " + positionData.entityId + "not found in Dictionary dropping physics object movement packet");
}
}
public EvaluatedHand evaluateHand(List <Card> cards)
{
if (cards.Count <= 2)
{
return(null);
}
assert(cards);
string goal = "X:evaluate(X).";
string result = UnityExtensionMethods.SolveForParsed(kB, goal).ToString();
List <Card> EvaluatedCards = new List <Card> ();
for (int i = 1; i < 6; i++)
{
string cardValue = "X:cardValue(X," + i.ToString() + ").";
string cardSuit = "Y:cardSuit(Y," + i.ToString() + ").";
int v = int.Parse(UnityExtensionMethods.SolveForParsed(kB, cardValue).ToString());
var s = UnityExtensionMethods.SolveForParsed(kB, cardSuit);
EvaluatedCards.Add(new Card(v, s.ToString()));
}
string straightPotentialCase = "Y:straightPotential(Y).";
int straightPotential = int.Parse(UnityExtensionMethods.SolveForParsed(kB, straightPotentialCase).ToString());
string flushPotentialCase = "Y:flushPotential(Y).";
int flushPotential = int.Parse(UnityExtensionMethods.SolveForParsed(kB, flushPotentialCase).ToString());
EvaluatedHand evaluatedhand = new EvaluatedHand(result, EvaluatedCards, straightPotential, flushPotential);
retract();
return(evaluatedhand);
}
private void CreateDefaultCardGames()
{
#if UNITY_ANDROID && !UNITY_EDITOR
UnityExtensionMethods.ExtractAndroidStreamingAssets(CardGame.GamesDirectoryPath);
#else
UnityExtensionMethods.CopyDirectory(Application.streamingAssetsPath, CardGame.GamesDirectoryPath);
#endif
}
private void retract(bool raised)
{
UnityExtensionMethods.IsTrueParsed(kB, "retractall(finalDecision(X)).");
if (raised)
{
UnityExtensionMethods.IsTrueParsed(kB, "retractall(raiseAmount(X)).");
}
}
private void retract()
{
UnityExtensionMethods.IsTrueParsed(kB, "retractall(player(card(value(X),suit(Y)))).");
UnityExtensionMethods.IsTrueParsed(kB, "retractall(cardSuit(X,Y)).");
UnityExtensionMethods.IsTrueParsed(kB, "retractall(cardValue(X,Y)).");
UnityExtensionMethods.IsTrueParsed(kB, "retractall(flushPotential(X)).");
UnityExtensionMethods.IsTrueParsed(kB, "retractall(straightPotential(Y)).");
}
private void assert(List <Card> cards)
{
foreach (Card card in cards)
{
string goal = "assert(player(card(value(" + card.CardValue.ToString() + "),suit(" + card.suitValue + ")))).";
UnityExtensionMethods.IsTrueParsed(kB, goal);
}
}
public string UpdateDeckName(string newName)
{
if (newName == null)
{
newName = string.Empty;
}
newName = UnityExtensionMethods.GetSafeFileName(newName);
nameText.text = newName + (HasChanged ? ChangeIndicator : string.Empty);
return(newName);
}
private void LoadSets()
{
if (AllSetsUrlZipped)
{
UnityExtensionMethods.ExtractZip(SetsFilePath + UnityExtensionMethods.ZipExtension, GameFolderPath);
}
if (AllSetsUrlWrapped)
{
UnityExtensionMethods.UnwrapFile(SetsFilePath);
}
LoadJsonFromFile(SetsFilePath, LoadSetFromJToken, SetDataIdentifier);
}
public void Load(CardGameCoroutineDelegate updateCoroutine, CardGameCoroutineDelegate loadCardsCoroutine)
{
// We should have already read the *Game:Name*.json, but we need to be sure
if (!HasReadProperties)
{
ReadProperties();
if (!HasReadProperties)
{
// ReadProperties() should have already populated the Error
HasLoaded = false;
return;
}
}
// Don't waste time loading if we need to update first
int daysSinceUpdate = 0;
try { daysSinceUpdate = (int)DateTime.Today.Subtract(File.GetLastWriteTime(GameFilePath).Date).TotalDays; } catch { };
if (AutoUpdate >= 0 && daysSinceUpdate >= AutoUpdate && CoroutineRunner != null)
{
CoroutineRunner.StartCoroutine(updateCoroutine(this));
return;
}
// These enum lookups need to be initialized before we load cards and sets
foreach (EnumDef enumDef in Enums)
{
enumDef.InitializeLookups();
}
// The main load action is to load cards and sets
if (CoroutineRunner != null)
{
CoroutineRunner.StartCoroutine(loadCardsCoroutine(this));
}
LoadSets();
// We also re-load the banner and cardback images now in case they've changed since we ReadProperties
if (File.Exists(BannerImageFilePath))
{
BannerImageSprite = UnityExtensionMethods.CreateSprite(BannerImageFilePath);
}
if (File.Exists(CardBackImageFilePath))
{
CardBackImageSprite = UnityExtensionMethods.CreateSprite(CardBackImageFilePath);
}
// Only considered as loaded if none of the steps failed
if (string.IsNullOrEmpty(Error))
{
HasLoaded = true;
}
}
private IEnumerator LoadSetCards(UnityCardGame cardGame)
{
if (cardGame == null)
{
cardGame = Current;
}
var setCardsLoaded = false;
foreach (Set set in cardGame.Sets.Values)
{
if (string.IsNullOrEmpty(set.CardsUrl))
{
continue;
}
if (!setCardsLoaded)
{
Messenger.Show(string.Format(SetCardsLoadingMessage, cardGame.Name));
}
setCardsLoaded = true;
string setCardsFilePath = Path.Combine(cardGame.SetsDirectoryPath,
UnityExtensionMethods.GetSafeFileName(set.Code + UnityExtensionMethods.JsonExtension));
if (!File.Exists(setCardsFilePath))
{
yield return(UnityExtensionMethods.SaveUrlToFile(set.CardsUrl, setCardsFilePath));
}
if (File.Exists(setCardsFilePath))
{
cardGame.LoadCards(setCardsFilePath, set.Code);
}
else
{
Debug.LogError(LoadErrorMessage + set.CardsUrl);
yield break;
}
}
if (!string.IsNullOrEmpty(cardGame.Error))
{
Debug.LogError(LoadErrorMessage + cardGame.Error);
}
else if (setCardsLoaded)
{
Messenger.Show(string.Format(SetCardsLoadedMessage, cardGame.Name));
}
}
public IEnumerator GetAndSetImageSprite()
{
if (IsLoadingImage)
{
yield break;
}
IsLoadingImage = true;
UnityEngine.Sprite newSprite = null;
yield return(UnityExtensionMethods.RunOutputCoroutine <UnityEngine.Sprite>(
UnityExtensionMethods.CreateAndOutputSpriteFromImageFile(ImageFilePath, ImageWebUrl)
, output => newSprite = output));
if (newSprite != null)
{
ImageSprite = newSprite;
}
IsLoadingImage = false;
}
public void UpdatePosition()
{
#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
if (SecondaryDragAction != Rotate && IsProcessingSecondaryDragAction)
{
return;
}
#else
if (Input.GetMouseButton(1) || Input.GetMouseButtonUp(1) || Input.GetMouseButton(2) || Input.GetMouseButtonUp(2))
{
return;
}
#endif
if (PointerPositions.Count < 1 || PointerDragOffsets.Count < 1 || (IsOnline && !hasAuthority))
{
return;
}
Vector2 targetPosition = UnityExtensionMethods.CalculateMean(PointerPositions.Values.ToList());
targetPosition = targetPosition + UnityExtensionMethods.CalculateMean(PointerDragOffsets.Values.ToList());
if (ParentCardStack != null)
{
UpdateCardStackPosition(targetPosition);
}
else if (!IsStatic)
{
transform.position = targetPosition;
}
if (!IsStatic)
{
if (PlaceHolderCardStack != null)
{
PlaceHolderCardStack.UpdateLayout(PlaceHolder, targetPosition);
}
if (IsOnline)
{
CmdUpdatePosition(((RectTransform)transform).anchoredPosition);
}
}
}
private void CreateDefaultCardGames()
{
#if UNITY_ANDROID && !UNITY_EDITOR
UnityExtensionMethods.ExtractAndroidStreamingAssets(UnityCardGame.GamesDirectoryPath);
#elif UNITY_WEBGL
if (!Directory.Exists(UnityCardGame.GamesDirectoryPath))
{
Directory.CreateDirectory(UnityCardGame.GamesDirectoryPath);
}
string standardPlayingCardsDirectory =
UnityCardGame.GamesDirectoryPath + "/" + Tags.StandardPlayingCardsDirectoryName;
if (!Directory.Exists(standardPlayingCardsDirectory))
{
Directory.CreateDirectory(standardPlayingCardsDirectory);
}
File.WriteAllText(standardPlayingCardsDirectory + "/" + Tags.StandardPlayingCardsJsonFileName, Tags.StandPlayingCardsJsonFileContent);
string dominoesDirectory = UnityCardGame.GamesDirectoryPath + "/" + Tags.DominoesDirectoryName;
if (!Directory.Exists(dominoesDirectory))
{
Directory.CreateDirectory(dominoesDirectory);
}
File.WriteAllText(dominoesDirectory + "/" + Tags.DominoesJsonFileName, Tags.DominoesJsonFileContent);
StartCoroutine(UnityExtensionMethods.SaveUrlToFile(Tags.DominoesCardBackUrl, dominoesDirectory + "/CardBack.png"));
string mahjongDirectory = UnityCardGame.GamesDirectoryPath + "/" + Tags.MahjongDirectoryName;
if (!Directory.Exists(mahjongDirectory))
{
Directory.CreateDirectory(mahjongDirectory);
}
File.WriteAllText(mahjongDirectory + "/" + Tags.MahjongJsonFileName, Tags.MahjongJsonFileContent);
StartCoroutine(UnityExtensionMethods.SaveUrlToFile(Tags.MahjongCardBackUrl, mahjongDirectory + "/CardBack.png"));
string arcmageDirectory = UnityCardGame.GamesDirectoryPath + "/" + Tags.ArcmageDirectoryName;
if (!Directory.Exists(arcmageDirectory))
{
Directory.CreateDirectory(arcmageDirectory);
}
File.WriteAllText(arcmageDirectory + "/" + Tags.ArcmageJsonFileName, Tags.ArcmageJsonFileContent);
StartCoroutine(UnityExtensionMethods.SaveUrlToFile(Tags.ArcmageCardBackUrl, arcmageDirectory + "/CardBack.png"));
#else
UnityExtensionMethods.CopyDirectory(Application.streamingAssetsPath, UnityCardGame.GamesDirectoryPath);
#endif
}
private void LoadCards(int page)
{
string cardsFilePath = CardsFilePath + (page != AllCardsUrlPageCountStartIndex ? page.ToString() : string.Empty);
try
{
if (AllCardsUrlZipped)
{
UnityExtensionMethods.ExtractZip(cardsFilePath + UnityExtensionMethods.ZipExtension, GameFolderPath);
}
if (AllCardsUrlWrapped)
{
UnityExtensionMethods.UnwrapFile(cardsFilePath);
}
LoadJsonFromFile(cardsFilePath, LoadCardFromJToken, CardDataIdentifier);
}
catch (Exception e)
{
Error += e.Message + e.StackTrace + Environment.NewLine;
}
}
public int compareTwoHands(PlayerImplementation player1, PlayerImplementation player2)
{
int rank1 = HandStrengthEvaluater.rank(player1.evaluatedCards.name);
int rank2 = HandStrengthEvaluater.rank(player2.evaluatedCards.name);
string cardsEvaluated1 = "[";
for (int i = 0; i < player1.evaluatedCards.Cards.Count; i++)
{
if (i < player1.evaluatedCards.Cards.Count - 1)
{
cardsEvaluated1 += player1.evaluatedCards.Cards [i].CardValue + ",";
}
else
{
cardsEvaluated1 += player1.evaluatedCards.Cards [i].CardValue + "]";
}
}
string cardsEvaluated2 = "[";
for (int i = 0; i < player2.evaluatedCards.Cards.Count; i++)
{
if (i < player2.evaluatedCards.Cards.Count - 1)
{
cardsEvaluated2 += player2.evaluatedCards.Cards [i].CardValue + ",";
}
else
{
cardsEvaluated2 += player2.evaluatedCards.Cards [i].CardValue + "]";
}
}
string query = "X:result(" + rank1 + "," + rank2 + "," + cardsEvaluated1 + "," + cardsEvaluated2 + ",X).";
int result = int.Parse(UnityExtensionMethods.SolveForParsed(kB, query).ToString());
return(result);
}
public PlayerAction MakeDecision(PlayerImplementation Player, Context context)
{
PlayerAction playerAction = new PlayerAction();
assert(Player, context);
bool raised = false;
int raiseAmount;
string decision = "Y:finalDecision(Y).";
string result = UnityExtensionMethods.SolveForParsed(kB, decision).ToString();
if (result.Equals("fold"))
{
playerAction.set(PlayerAction.Action.Fold);
}
if (result.Equals("call"))
{
playerAction.set(PlayerAction.Action.Call);
}
if (result.Equals("raise"))
{
raised = true;
string raiseAmountQuery = "X:raiseAmount(X).";
raiseAmount = int.Parse(UnityExtensionMethods.SolveForParsed(kB, raiseAmountQuery).ToString());
if (raiseAmount == 0)
{
playerAction.set(PlayerAction.Action.Check);
}
else
{
playerAction.raise(new PlayerAction.Raise(raiseAmount));
}
}
retract(raised);
return(playerAction);
}
public void ReadProperties()
{
try
{
// We need to read the *Game:Name*.json file, but reading it can cause *Game:Name* to change, so account for that
string gameFilePath = GameFilePath;
string gameDirectoryPath = GameDirectoryPath;
ClearDefinitionLists();
JsonConvert.PopulateObject(File.ReadAllText(GameFilePath), this);
if (!gameFilePath.Equals(GameFilePath) && File.Exists(gameFilePath))
{
string tempGameFilePath = gameDirectoryPath + "/" + UnityExtensionMethods.GetSafeFileName(Name) + ".json";
File.Move(gameFilePath, tempGameFilePath);
}
if (!gameDirectoryPath.Equals(GameDirectoryPath) && Directory.Exists(gameDirectoryPath))
{
Directory.Move(gameDirectoryPath, GameDirectoryPath);
}
// We're being greedy about loading these now, since these could be shown before the game is selected
if (File.Exists(BannerImageFilePath))
{
BannerImageSprite = UnityExtensionMethods.CreateSprite(BannerImageFilePath);
}
if (File.Exists(CardBackImageFilePath))
{
CardBackImageSprite = UnityExtensionMethods.CreateSprite(CardBackImageFilePath);
}
HasReadProperties = true;
}
catch (Exception e)
{
Error += e.Message + e.StackTrace + Environment.NewLine;
HasReadProperties = false;
}
}
public IEnumerator Download()
{
if (IsDownloading)
{
yield break;
}
IsDownloading = true;
string initialDirectory = GameFolderPath;
yield return(UnityExtensionMethods.SaveUrlToFile(AutoUpdateUrl, ConfigFilePath));
try
{
if (!IsLoaded)
{
JsonConvert.PopulateObject(File.ReadAllText(ConfigFilePath), this);
}
}
catch (Exception e)
{
Error += e.Message;
IsDownloading = false;
yield break;
}
// If the name of the game doesn't match our initial game name, we need to move to the new directory and delete the old one
if (!initialDirectory.Equals(GameFolderPath))
{
// Downloading the config file twice is slightly inefficient, but it shouldn't cause a noticeable difference for the user
yield return(UnityExtensionMethods.SaveUrlToFile(AutoUpdateUrl, ConfigFilePath));
Directory.Delete(initialDirectory, true);
}
for (int page = AllCardsUrlPageCountStartIndex; page < AllCardsUrlPageCountStartIndex + AllCardsUrlPageCount; page++)
{
string cardsUrl = AllCardsUrl;
if (AllCardsUrlPageCount > 1 && string.IsNullOrEmpty(AllCardsUrlPostBodyContent))
{
cardsUrl += AllCardsUrlPageIdentifier + page;
}
string cardsFile = CardsFilePath;
if (page != AllCardsUrlPageCountStartIndex)
{
cardsFile += page.ToString();
}
if (AllCardsUrlZipped)
{
cardsFile += UnityExtensionMethods.ZipExtension;
}
string jsonBody = null;
if (!string.IsNullOrEmpty(AllCardsUrlPostBodyContent))
{
jsonBody = "{" + AllCardsUrlPostBodyContent;
jsonBody += AllCardsUrlPageIdentifier + page;
jsonBody += "}";
}
yield return(UnityExtensionMethods.SaveUrlToFile(cardsUrl, cardsFile, jsonBody));
// Sometimes, we need to get the AllCardsUrlPageCount from the first page of AllCardsUrl
if (page == AllCardsUrlPageCountStartIndex && !string.IsNullOrEmpty(AllCardsUrlPageCountIdentifier))
{
LoadCards(page);
}
}
string setsFilePath = SetsFilePath + (AllSetsUrlZipped ? UnityExtensionMethods.ZipExtension : string.Empty);
if (!string.IsNullOrEmpty(AllSetsUrl))
{
yield return(UnityExtensionMethods.SaveUrlToFile(AllSetsUrl, setsFilePath));
}
yield return(UnityExtensionMethods.SaveUrlToFile(BackgroundImageUrl, BackgroundImageFilePath));
yield return(UnityExtensionMethods.SaveUrlToFile(CardBackImageUrl, CardBackImageFilePath));
foreach (GameBoardUrl boardUrl in GameBoardUrls)
{
yield return(UnityExtensionMethods.SaveUrlToFile(boardUrl.Url, GameBoardsFilePath + "/" + boardUrl.Id + "." + GameBoardFileType));
}
foreach (DeckUrl deckUrl in DeckUrls)
{
yield return(UnityExtensionMethods.SaveUrlToFile(deckUrl.Url, DecksFilePath + "/" + deckUrl.Name + "." + DeckFileType));
}
if (!IsLoaded)
{
Load(true);
}
IsDownloading = false;
}
public void ValidateDeckName(string deckName)
{
nameInputField.text = UnityExtensionMethods.GetSafeFileName(deckName);
}
public IEnumerator Download()
{
if (IsDownloading)
{
yield break;
}
IsDownloading = true;
// We should always first get the *Game:Name*.json file and read it before doing anything else
DownloadProgress = 0f / (7f + AllCardsUrlPageCount);
DownloadStatus = "Downloading: CardGameDef...";
yield return(UnityExtensionMethods.SaveUrlToFile(AutoUpdateUrl, GameFilePath));
ReadProperties();
if (!HasReadProperties)
{
// ReadProperties() should have already populated the Error
IsDownloading = false;
HasDownloaded = false;
yield break;
}
DownloadProgress = 1f / (7f + AllCardsUrlPageCount);
DownloadStatus = "Downloading: Banner";
if (!string.IsNullOrEmpty(BannerImageUrl))
{
yield return(UnityExtensionMethods.SaveUrlToFile(BannerImageUrl, BannerImageFilePath));
}
DownloadProgress = 2f / (7f + AllCardsUrlPageCount);
DownloadStatus = "Downloading: CardBack";
if (!string.IsNullOrEmpty(CardBackImageUrl))
{
yield return(UnityExtensionMethods.SaveUrlToFile(CardBackImageUrl, CardBackImageFilePath));
}
DownloadProgress = 3f / (7f + AllCardsUrlPageCount);
DownloadStatus = "Downloading: Boards";
foreach (GameBoardUrl boardUrl in GameBoardUrls)
{
yield return(UnityExtensionMethods.SaveUrlToFile(boardUrl.Url, GameBoardsFilePath + "/" + boardUrl.Id + "." + GameBoardFileType));
}
DownloadProgress = 4f / (7f + AllCardsUrlPageCount);
DownloadStatus = "Downloading: Decks";
foreach (DeckUrl deckUrl in DeckUrls)
{
yield return(UnityExtensionMethods.SaveUrlToFile(deckUrl.Url, DecksFilePath + "/" + deckUrl.Name + "." + DeckFileType));
}
DownloadProgress = 5f / (7f + AllCardsUrlPageCount);
DownloadStatus = "Downloading: AllSets.json";
string setsFilePath = SetsFilePath + (AllSetsUrlZipped ? UnityExtensionMethods.ZipExtension : string.Empty);
if (!string.IsNullOrEmpty(AllSetsUrl))
{
yield return(UnityExtensionMethods.SaveUrlToFile(AllSetsUrl, setsFilePath));
}
if (AllSetsUrlZipped)
{
UnityExtensionMethods.ExtractZip(setsFilePath, GameDirectoryPath);
}
if (AllSetsUrlWrapped)
{
UnityExtensionMethods.UnwrapFile(SetsFilePath);
}
if (!string.IsNullOrEmpty(AllCardsUrl))
{
for (int page = AllCardsUrlPageCountStartIndex; page < AllCardsUrlPageCountStartIndex + AllCardsUrlPageCount; page++)
{
DownloadProgress = (6f + page - AllCardsUrlPageCountStartIndex) / (7f + AllCardsUrlPageCount - AllCardsUrlPageCountStartIndex);
DownloadStatus = $"Downloading: Cards: {page,5} / {AllCardsUrlPageCountStartIndex + AllCardsUrlPageCount}";
string cardsUrl = AllCardsUrl;
if (AllCardsUrlPageCount > 1 && string.IsNullOrEmpty(AllCardsUrlPostBodyContent))
{
cardsUrl += AllCardsUrlPageIdentifier + page;
}
string cardsFile = CardsFilePath;
if (page != AllCardsUrlPageCountStartIndex)
{
cardsFile += page.ToString();
}
if (AllCardsUrlZipped)
{
cardsFile += UnityExtensionMethods.ZipExtension;
}
string jsonBody = null;
if (!string.IsNullOrEmpty(AllCardsUrlPostBodyContent))
{
jsonBody = "{" + AllCardsUrlPostBodyContent;
jsonBody += AllCardsUrlPageIdentifier + page;
jsonBody += "}";
}
yield return(UnityExtensionMethods.SaveUrlToFile(cardsUrl, cardsFile, jsonBody));
if (AllCardsUrlZipped)
{
UnityExtensionMethods.ExtractZip(cardsFile, GameDirectoryPath);
}
if (AllCardsUrlWrapped)
{
UnityExtensionMethods.UnwrapFile(cardsFile.EndsWith(UnityExtensionMethods.ZipExtension)
? cardsFile.Remove(cardsFile.Length - UnityExtensionMethods.ZipExtension.Length) : cardsFile);
}
// Sometimes, we need to get the AllCardsUrlPageCount from the first page of AllCardsUrl
if (page == AllCardsUrlPageCountStartIndex && !string.IsNullOrEmpty(AllCardsUrlPageCountIdentifier))
{
LoadCards(page);
}
}
}
IsDownloading = false;
DownloadStatus = "Complete!";
HasDownloaded = true;
HasLoaded = false;
}
