public static bool IsAchievementClaimed(this AchievementLevelInfo achievementLevelInfo)
{
AchievementToken achievementToken = InfoResolver.Resolve <FortInfo>().Achievement.AchievementTokens[achievementLevelInfo.Id];
int achievementClaimedIndex = ServiceLocator.Resolve <IAchievementService>().GetAchievementClaimedIndex(achievementToken.AchievementInfo.GetType());
return(achievementToken.Index <= achievementClaimedIndex);
}
void Start()
{
if (InfoResolver.Resolve <FortInfo>().ServerConnectionProvider != null && IsRegistered)
{
FullUpdate();
}
}
public Object Resolve(GameItemInfo gameItem)
{
Initialize();
ResourceGameItem item = gameItem as ResourceGameItem;
if (item != null)
{
return(Resources.Load(item.Address));
}
AssetBundleGameItem assetBundleGameItem = gameItem as AssetBundleGameItem;
if (assetBundleGameItem != null)
{
if (_assetBundles.ContainsKey(assetBundleGameItem.AssetBundle))
{
return(_assetBundles[assetBundleGameItem.AssetBundle].LoadAsset(assetBundleGameItem.ItemName));
}
if (!IsAssetBundleDownloaded(assetBundleGameItem.AssetBundle))
{
throw new Exception(string.Format("Asset bundle {0} is not downloaded", assetBundleGameItem.AssetBundle));
}
Uri bundleServerAddress = GetBundleServerAddress(assetBundleGameItem.AssetBundle);
UnityEngine.AssetBundle assetBundle =
UnityEngine.AssetBundle.LoadFromFile(
InfoResolver.Resolve <FortInfo>()
.ServerConnectionProvider.UserConnection.LoadFromCache(bundleServerAddress));
_assetBundles[assetBundleGameItem.AssetBundle] = assetBundle;
return(assetBundle.LoadAsset(assetBundleGameItem.ItemName));
}
return((Object)gameItem.GetType().GetProperty("GameItem").GetValue(gameItem, new object[0]));
}
public void StatGameLevelFinished(GameLevelInfo gameLevelInfo, ILevelFinishStat levelFinishStat)
{
if (InfoResolver.Resolve <FortInfo>().Analytic.AnalyticsProvider == null)
{
return;
}
if (!InfoResolver.Resolve <FortInfo>().Analytic.StatGameLevelFinished)
{
return;
}
GameLevelCategory gameLevelCategory =
InfoResolver.Resolve <FortInfo>().GameLevel.LevelCategoriesParentMap[gameLevelInfo.Id];
InfoResolver.Resolve <FortInfo>()
.Analytic.AnalyticsProvider.StateEvent(gameLevelInfo.Name, gameLevelInfo.DisplayName,
"GameLevelFinished",
new GameLevelFinishedAnalyticStat
{
LevelFinishStat = levelFinishStat,
GameLevelId = gameLevelInfo.Id,
GameLevelName = gameLevelInfo.Name,
GameLevelCategoryId = gameLevelCategory.Id,
GameLevelCategoryName = gameLevelCategory.Name
});
}
public ScoreBalance ResolveAchievementScoreBalance(string id)
{
AchievementStoredData achievementStoredData =
ServiceLocator.Resolve <IStorageService>().ResolveData <AchievementStoredData>();
if (achievementStoredData == null)
{
achievementStoredData = new AchievementStoredData();
}
if (achievementStoredData.ServerAchievementInfos.ContainsKey(id))
{
return(new ScoreBalance
{
Balance = achievementStoredData.ServerAchievementInfos[id].Balance,
Score = achievementStoredData.ServerAchievementInfos[id].Score
});
}
AchievementToken achievementToken = InfoResolver.Resolve <FortInfo>().Achievement.AchievementTokens[id];
if (achievementToken.NoneLevelBase)
{
return(new ScoreBalance
{
Balance = ((NoneLevelBaseAchievementInfo)achievementToken.AchievementInfo).Balance,
Score = ((NoneLevelBaseAchievementInfo)achievementToken.AchievementInfo).Score
});
}
return(new ScoreBalance
{
Balance = achievementToken.AchievementLevelInfo.Balance,
Score = achievementToken.AchievementLevelInfo.Score
});
}
public bool IsAssetBundleDownloaded(string assetBundle)
{
Uri bundleServerAddress = GetBundleServerAddress(assetBundle);
return(InfoResolver.Resolve <FortInfo>()
.ServerConnectionProvider.UserConnection.IsCached(bundleServerAddress));
}
public void StatItemPurchased(string itemId, Balance cost, int discount)
{
if (InfoResolver.Resolve <FortInfo>().Analytic.AnalyticsProvider == null)
{
return;
}
if (!InfoResolver.Resolve <FortInfo>().Analytic.StatItemPurchased)
{
return;
}
PurchasableToken purchasableToken = InfoResolver.Resolve <FortInfo>().Purchase.PurchasableTokens[itemId];
if (purchasableToken.NoneLevelBase)
{
InfoResolver.Resolve <FortInfo>().Analytic.AnalyticsProvider.StateEvent(purchasableToken.PurchasableItemInfo.Name,
purchasableToken.PurchasableItemInfo.DisplayName, "ItemPurchased",
new ItemPurchaseAnalyticStat {
ItemId = itemId, ItemName = purchasableToken.PurchasableItemInfo.Name, Cost = cost, Discount = discount
});
}
else
{
InfoResolver.Resolve <FortInfo>().Analytic.AnalyticsProvider.StateEvent(purchasableToken.PurchasableItemInfo.Name,
purchasableToken.PurchasableItemInfo.DisplayName, "ItemPurchased",
new ItemPurchaseAnalyticStat
{
ItemId = itemId,
ItemName = purchasableToken.PurchasableItemInfo.Name,
Level = purchasableToken.Index,
Cost = cost,
Discount = discount
});
}
}
void Start()
{
if (InfoResolver.Resolve <FortInfo>().ServerConnectionProvider != null)
{
ResolveServerSettings();
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JToken jToken = JToken.ReadFrom(reader);
if (jToken.Type == JTokenType.Null || jToken.Type == JTokenType.None)
{
return(new PurchaseData[0]);
}
return(jToken.ToObject <string[]>().Select(s =>
{
PurchaseData result;
if (!InfoResolver.Resolve <FortInfo>().Purchase.PurchasableTokens.ContainsKey(s))
{
return null;
}
PurchasableToken purchasableToken = InfoResolver.Resolve <FortInfo>().Purchase.PurchasableTokens[s];
if (purchasableToken.NoneLevelBase)
{
result = new PurchaseNoneLevelBaseData
{
PurchasableItemInfo = (NoneLevelBasePurchasableItemInfo)purchasableToken.PurchasableItemInfo
};
}
else
{
result = new PurchaseLevelBaseData
{
PurchasableItemInfo = (LevelBasePurchasableItemInfo)purchasableToken.PurchasableItemInfo,
Level = purchasableToken.Index
};
}
return result;
}).Where(info => info != null).ToArray());
}
public void HideStandardBanner()
{
foreach (AdvertisementPriority advertisementPriority in InfoResolver.Resolve <FortInfo>().Advertisement.AdvertisementProviders.Where(priority => priority.AdvertisementProvider != null && priority.AdvertisementProvider.IsStandardBannerSupported))
{
advertisementPriority.AdvertisementProvider.HideStandardBanner();
}
}
public void ShareLink()
{
try
{
if (!ServiceLocator.Resolve <IUserManagementService>().IsRegistered)
{
throw new Exception("User not registered yet");
}
ServiceLocator.Resolve <IServerService>().Call <string>("GetInvitaionToken", null).Then(token =>
{
ServiceLocator.Resolve <IAnalyticsService>().StatInvitationShare();
AndroidJavaClass jc = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
AndroidJavaObject jo = jc.GetStatic <AndroidJavaObject>("currentActivity");
AndroidJavaClass intentClass = new AndroidJavaClass("com.redcap.textshare.ShareHelper");
StringBuilder builder = new StringBuilder();
foreach (MarketInfo marketInfo in InfoResolver.Resolve <FortInfo>().MarketInfos)
{
builder.AppendLine(string.Format("لینک بازی در {0}", marketInfo.MarketDisplayName));
builder.AppendLine(marketInfo.ApplicationUrl);
}
builder.AppendLine("لینک اضافه شدن سکه به " +
ServiceLocator.Resolve <IUserManagementService>().Username + "(بعد از نصب)");
builder.AppendLine(InfoResolver.Resolve <FortInfo>().InvitationInfo.ShareUrl + token);
intentClass.CallStatic("ShareText", jo, builder.ToString(), "دعوت و دریافت سکه");
});
}
catch (Exception)
{
Debug.LogError("Invitation not supported in editor app");
}
}
private static Promise InternalUpdateAchievementToServer(bool showDialog)
{
Deferred deferred = new Deferred();
//BacktoryCloudUrl.Url = "http://localhost:8086";
UpdateAchievementsRequest request = new UpdateAchievementsRequest();
List <ServerAchievement> serverAchievements = new List <ServerAchievement>();
foreach (
AchievementInfo achievementInfo in
InfoResolver.Resolve <FortInfo>().Achievement.AchievementInfos.Where(info => info != null))
{
NoneLevelBaseAchievementInfo noneLevelBaseAchievementInfo = achievementInfo as NoneLevelBaseAchievementInfo;
if (noneLevelBaseAchievementInfo != null)
{
serverAchievements.Add(new ServerAchievement
{
Name = noneLevelBaseAchievementInfo.Name,
AchievementId = noneLevelBaseAchievementInfo.Id,
Score = noneLevelBaseAchievementInfo.Score,
Values = noneLevelBaseAchievementInfo.Balance.Values
});
}
else
{
LevelBaseAchievementInfo levelBaseAchievementInfo = (LevelBaseAchievementInfo)achievementInfo;
AchievementLevelInfo[] achievementLevelInfos = levelBaseAchievementInfo.GetAchievementLevelInfos();
for (int i = 0; i < achievementLevelInfos.Length; i++)
{
serverAchievements.Add(new ServerAchievement
{
Name = achievementLevelInfos[i].Name,
AchievementId = achievementLevelInfos[i].Id,
Score = achievementLevelInfos[i].Score,
Values = achievementLevelInfos[i].Balance.Values
});
}
}
}
request.Items = serverAchievements.ToArray();
EditorUtility.DisplayProgressBar("Syncronizing Achievements", "Syncronizing Achievements", 0);
InfoResolver.Resolve <FortInfo>()
.ServerConnectionProvider.EditorConnection.Call <object>("UpdateAchievements", request)
.Then(
o =>
{
EditorUtility.ClearProgressBar();
if (showDialog)
{
EditorUtility.DisplayDialog("Syncronizing Achievements", "Achievemet syncronization succeeded", "Ok");
}
deferred.Resolve();
}, error =>
{
EditorUtility.ClearProgressBar();
deferred.Reject();
throw new Exception("Achievemet syncronization failed");
});
return(deferred.Promise());
}
public ErrorPromise <RegisterationErrorResultStatus> Register(string username, string password)
{
IDispatcher dispatcher = GameDispatcher.Dispatcher;
ErrorDeferred <RegisterationErrorResultStatus> deferred = new ErrorDeferred <RegisterationErrorResultStatus>();
string authenticationId = InfoResolver.Resolve <BacktoryInfo>().AuthenticationId;
string url = "https://api.backtory.com/auth/users";
ThreadPool.QueueUserWorkItem(state =>
{
try
{
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(new Uri(url));
webRequest.KeepAlive = true;
webRequest.Method = "POST";
webRequest.ContentType = "application/json; charset=utf-8";
webRequest.Headers.Add("X-Backtory-Authentication-Id", authenticationId);
string body = JsonConvert.SerializeObject(new { username, password });
byte[] resoponse = Encoding.UTF8.GetBytes(body);
webRequest.ContentLength = resoponse.Length;
using (System.IO.Stream requestStream = webRequest.GetRequestStream())
{
requestStream.Write(resoponse, 0, resoponse.Length);
}
using (WebResponse webResponse = webRequest.GetResponse())
{
using (System.IO.Stream responseStream = webResponse.GetResponseStream())
{
using (StreamReader reader = new StreamReader(responseStream))
{
reader.ReadToEnd();
}
}
}
dispatcher.Dispach(() =>
{
deferred.Resolve();
});
}
catch (WebException we)
{
dispatcher.Dispach(() =>
{
HttpWebResponse httpWebResponse = we.Response as HttpWebResponse;
if (httpWebResponse != null)
{
if (httpWebResponse.StatusCode == HttpStatusCode.Conflict)
{
deferred.Reject(RegisterationErrorResultStatus.UsernameIsInUse);
return;
}
}
deferred.Reject(RegisterationErrorResultStatus.CannotConnectToServer);
});
}
});
return(deferred.Promise());
}
public void ShowInterstiatialBanner()
{
AdvertisementSavedData advertisementSavedData =
ServiceLocator.Resolve <IStorageService>().ResolveData <AdvertisementSavedData>() ??
new AdvertisementSavedData();
if (advertisementSavedData.IsAdRemoved)
{
return;
}
ServerSettings serverSettings = ServiceLocator.Resolve <ISettingService>().ResolveCachedServerSetting();
string advertisementProvider = string.Empty;
if (serverSettings != null && serverSettings.AdvertisementSettings != null &&
string.IsNullOrEmpty(serverSettings.AdvertisementSettings.InterstiatialBannerPriority))
{
if (InfoResolver.Resolve <FortInfo>().Advertisement.AdvertisementProviders != null)
{
AdvertisementPriority advertisementPriority =
InfoResolver.Resolve <FortInfo>().Advertisement.AdvertisementProviders.FirstOrDefault(
priority => priority.AdvertisementProvider != null &&
priority.AdvertisementProvider.IsInterstitialBannerSupported);
if (advertisementPriority != null)
{
advertisementProvider = advertisementPriority.AdvertisementProvider.Name;
}
}
}
if (string.IsNullOrEmpty(advertisementProvider))
{
if (InfoResolver.Resolve <FortInfo>().Advertisement.AdvertisementProviders != null)
{
AdvertisementPriority advertisementPriority =
InfoResolver.Resolve <FortInfo>().Advertisement.AdvertisementProviders.Where(
priority =>
priority.AdvertisementProvider != null &&
priority.AdvertisementProvider.IsInterstitialBannerSupported)
.Select((priority, i) => new { Priority = priority, Index = i })
.OrderBy(
arg => arg.Priority.VideoPriority < 0 ? arg.Index * 10000 : arg.Priority.VideoPriority)
.Select(arg => arg.Priority)
.FirstOrDefault();
if (advertisementPriority != null)
{
advertisementProvider = advertisementPriority.AdvertisementProvider.Name;
}
}
}
if (string.IsNullOrEmpty(advertisementProvider))
{
throw new Exception("No Advertisement provider found for Interstitial Banner");
}
if (InfoResolver.Resolve <FortInfo>().Advertisement.AdvertisementProviders != null)
{
InfoResolver.Resolve <FortInfo>().Advertisement.AdvertisementProviders.First(priority => priority.AdvertisementProvider.Name == advertisementProvider).AdvertisementProvider.ShowStandardBanner();
ServiceLocator.Resolve <IAnalyticsService>().StatInterstitialBanner(advertisementProvider);
}
}
public Promise DownloadAssetBundle(string assetBundle, Action <DownloadProgress> progress)
{
Deferred deferred = new Deferred();
Uri bundleServerAddress = GetBundleServerAddress(assetBundle);
InfoResolver.Resolve <FortInfo>().ServerConnectionProvider.UserConnection.LoadFromStorage(bundleServerAddress, progress).Then(s => deferred.Resolve(), deferred.Reject);
return(deferred.Promise());
}
void Start()
{
if (InfoResolver.Resolve <FortInfo>().Analytic.AnalyticsProvider == null)
{
return;
}
InfoResolver.Resolve <FortInfo>().Analytic.AnalyticsProvider.Initialize();
}
public Promise Login(string username, string password)
{
if (InfoResolver.Resolve <FortInfo>().ServerConnectionProvider == null)
{
throw new Exception("No Server connection provider added");
}
return(InfoResolver.Resolve <FortInfo>().ServerConnectionProvider.UserConnection.Login(username, password));
}
public void ChangeStandardBannerPosition(StandardBannerVerticalAlignment verticalAlignment,
StandardBannerHorizantalAlignment horizantalAlignment)
{
foreach (AdvertisementPriority advertisementPriority in InfoResolver.Resolve <FortInfo>().Advertisement.AdvertisementProviders.Where(priority => priority.AdvertisementProvider != null && priority.AdvertisementProvider.IsStandardBannerSupported))
{
advertisementPriority.AdvertisementProvider.ChangeStandardBannerPosition(verticalAlignment, horizantalAlignment);
}
}
public static void ExportLanguages()
{
string path = EditorUtility.SaveFilePanel("Export Languages", "", "", "xls");
if (string.IsNullOrEmpty(path))
{
return;
}
using (Stream writer = File.Create(path))
{
LanguageItem[] allLanguageItems =
TypeHelper.GetAllTypes(AllTypeCategory.All)
.Where(type => typeof(IInfo).IsAssignableFrom(type))
.Select(type => TypeHelper.FindType(InfoResolver.Resolve(type), typeof(LanguageItem <string>)))
.SelectMany(objects => objects)
.Cast <LanguageItem>()
.ToArray();
LanguageEditorInfo languageEditorInfo = EditorInfoResolver.Resolve <LanguageEditorInfo>();
string[] languageNames = languageEditorInfo.Languages.Select(info => info.Name).ToArray();
HSSFWorkbook workbook = new HSSFWorkbook();
HSSFSheet sheet = (HSSFSheet)workbook.CreateSheet("Languages");
HSSFRow header = (HSSFRow)sheet.CreateRow(0);
HSSFCell hssfCell = (HSSFCell)header.CreateCell(0);
hssfCell.SetCellValue("Item Id");
for (int i = 0; i < languageNames.Length; i++)
{
HSSFCell cell = (HSSFCell)header.CreateCell(i + 1);
cell.SetCellValue(languageNames[i]);
}
for (int i = 0; i < allLanguageItems.Length; i++)
{
HSSFRow row = (HSSFRow)sheet.CreateRow(i + 1);
HSSFCell itemIdcell = (HSSFCell)row.CreateCell(0);
itemIdcell.SetCellValue(allLanguageItems[i].Id);
for (int j = 0; j < languageNames.Length; j++)
{
HSSFCell cell = (HSSFCell)row.CreateCell(j + 1);
if (languageEditorInfo.Languages[j].LanguageDatas.ContainsKey(allLanguageItems[i].Id))
{
object languageData = languageEditorInfo.Languages[j].LanguageDatas[allLanguageItems[i].Id];
cell.SetCellValue(languageData == null?string.Empty:languageData.ToString());
}
else
{
cell.SetCellValue(string.Empty);
}
}
}
for (int i = 0; i < languageNames.Length + 1; i++)
{
sheet.AutoSizeColumn(i);
}
workbook.Write(writer);
}
}
public static void ImportGameLevels()
{
string path = EditorUtility.OpenFilePanel("Import Game Levels", "", "xls");
if (string.IsNullOrEmpty(path))
{
return;
}
using (Stream reader = File.OpenRead(path))
{
IDictionary <string, PropertyInfo> customPossibleProperties =
ExportData.GetCustomPossibleProperties(
TypeHelper.GetAllTypes(AllTypeCategory.Game)
.Where(type => typeof(GameLevelInfo).IsAssignableFrom(type))
.ToArray());
Dictionary <string, Type> parameters = new Dictionary <string, Type>();
parameters["Id"] = typeof(string);
//parameters["Scene"] = typeof(string);
//parameters["DisplayName"] = typeof(string);
parameters["Name"] = typeof(string);
foreach (KeyValuePair <string, PropertyInfo> pair in customPossibleProperties)
{
parameters[pair.Key] = pair.Value.PropertyType;
}
HSSFWorkbook workbook = new HSSFWorkbook(reader);
ExportData exportData = ExportData.DeserializeFromSheet(parameters, workbook.GetSheetAt(0));
foreach (ExportRow exportRow in exportData.ExportRows)
{
if (!exportRow.ContainsParameter("Id"))
{
continue;
}
string id = (string)exportRow.GetValue("Id").Value;
if (!InfoResolver.Resolve <FortInfo>().GameLevel.GameLevelInfos.ContainsKey(id))
{
continue;
}
GameLevelInfo gameLevelInfo = InfoResolver.Resolve <FortInfo>().GameLevel.GameLevelInfos[id];
if (exportRow.ContainsParameter("Scene"))
{
/* gameLevelInfo.Scene = new FortScene();
* gameLevelInfo.Scene.SceneName = (string)exportRow.GetValue("Scene").Value;*/
}
/* if (exportRow.ContainsParameter("DisplayName"))
* {
* gameLevelInfo.DisplayName = (string)exportRow.GetValue("DisplayName").Value;
* }*/
if (exportRow.ContainsParameter("Name"))
{
gameLevelInfo.Name = (string)exportRow.GetValue("Name").Value;
}
exportRow.FillCustomExportParameter(gameLevelInfo);
}
}
InfoResolver.Resolve <FortInfo>().Save();
}
private Uri GetBundleServerAddress(string assetBundle)
{
if (!_serverAssetBundleVersions.ContainsKey(assetBundle))
{
throw new Exception("Asset bundle not found in server");
}
return(new Uri(InfoResolver.Resolve <FortInfo>().ServerConnectionProvider.UserConnection.GetStorageAddress(), new Uri(_serverAssetBundleVersions[assetBundle].Path, UriKind.Relative)));
}
public void ClaimAchievement(Type levelBaseType, int achivementLevelIndex)
{
AchievementInfo achievementinfo = InfoResolver.Resolve <FortInfo>().Achievement.AchievementTypes[levelBaseType];
Array achivementLevelInfos =
(Array)achievementinfo.GetType().GetProperty("LevelInfoes").GetValue(achievementinfo, new object[0]);
if (achivementLevelIndex >= achivementLevelInfos.Length)
{
throw new Exception("Claim Achievement AchievementLevelInfoes out of index");
}
//AchivementLevelInfo achivementLevelInfo = (AchivementLevelInfo)achivementLevelInfos.GetValue(achivementLevelIndex);
string achievementId = achievementinfo.Id;
AchievementStoredData achievementStoredData =
ServiceLocator.Resolve <IStorageService>().ResolveData <AchievementStoredData>();
if (achievementStoredData == null)
{
achievementStoredData = new AchievementStoredData();
}
if (achievementStoredData.Achievements.ContainsKey(achievementId) &&
achievementStoredData.Achievements[achievementId] <= achivementLevelIndex)
{
return; //throw new Exception("Achievement Already Claimed");
}
achievementStoredData.Achievements[achievementId] = achivementLevelIndex;
ServiceLocator.Resolve <IStorageService>().UpdateData(achievementStoredData);
string[] possibleAchievementIds =
achivementLevelInfos.Cast <AchievementLevelInfo>()
.Take(achivementLevelIndex + 1)
.Select(info => info.Id)
.ToArray();
AchievementCache achievementCache =
ServiceLocator.Resolve <IStorageService>().ResolveData <AchievementCache>();
if (achievementCache == null)
{
achievementCache = new AchievementCache();
}
foreach (string possibleAchievementId in possibleAchievementIds)
{
if (!achievementCache.ServerAchievementIds.ContainsKey(possibleAchievementId))
{
achievementCache.ServerAchievementIds.Add(possibleAchievementId, false);
}
}
ServiceLocator.Resolve <IStorageService>().UpdateData(achievementCache);
AchievementLevelInfo achievementLevelInfo =
(AchievementLevelInfo)achivementLevelInfos.GetValue(achivementLevelIndex);
ScoreBalance scoreBalance = ResolveAchievementScoreBalance(achievementLevelInfo.Id);
ServiceLocator.Resolve <IUserManagementService>()
.AddScoreAndBalance(scoreBalance.Score, scoreBalance.Balance);
ServiceLocator.Resolve <IAnalyticsService>().StatAchievementClaimed(achievementLevelInfo.Id, scoreBalance);
ServiceLocator.Resolve <IEventAggregatorService>().GetEvent <AchievementClaimedEvent>().Publish(new LevelBaseAchievementClaimedEventArgs((LevelBaseAchievementInfo)achievementinfo, achivementLevelIndex));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JToken jToken = JToken.ReadFrom(reader);
if (jToken.Type == JTokenType.Null || jToken.Type == JTokenType.None)
{
return(null);
}
return(InfoResolver.Resolve <FortInfo>().SkinnerBox.BoxInfos.FirstOrDefault(info => info.Id == jToken.ToObject <string>()));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JToken jToken = JToken.ReadFrom(reader);
if (jToken.Type == JTokenType.Null || jToken.Type == JTokenType.None)
{
return(new MarketInfo[0]);
}
return(jToken.ToObject <string[]>().Select(s => InfoResolver.Resolve <FortInfo>().MarketInfos.FirstOrDefault(info => info.MarketName == s)).Where(info => info != null).ToArray());
}
public Promise Relogin()
{
IDispatcher dispatcher = GameDispatcher.Dispatcher;
Deferred deferred = new Deferred();
if (!IsReloginCapable())
{
throw new Exception("Relogin is not capable.No saved refresh token found");
}
string authenticationId = InfoResolver.Resolve <BacktoryInfo>().AuthenticationId;
string authenticationClientKey = InfoResolver.Resolve <BacktoryInfo>().AuthenticationClientKey;
string url = "https://api.backtory.com/auth/login";
ThreadPool.QueueUserWorkItem(state =>
{
try
{
BacktoryAccessData backtoryAccessData = ServiceLocator.Resolve <IStorageService>().ResolveData <BacktoryAccessData>();
string result = MultiPartCall(url, new Dictionary <string, string>
{
{ "refresh_token", backtoryAccessData.RefreshToken },
}, new Dictionary <string, string>
{
{ "X-Backtory-Authentication-Id", authenticationId },
{ "X-Backtory-Authentication-Key", authenticationClientKey },
{ "X-Backtory-Authentication-Refresh", "1" }
});
LoginResponse loginResponse = JsonConvert.DeserializeObject <LoginResponse>(result);
dispatcher.Dispach(() =>
{
if (string.IsNullOrEmpty(loginResponse.AccessToken))
{
deferred.Reject();
}
else
{
backtoryAccessData = ServiceLocator.Resolve <IStorageService>().ResolveData <BacktoryAccessData>();
backtoryAccessData.AccessToken = loginResponse.AccessToken;
backtoryAccessData.RefreshToken = loginResponse.RefreshToken;
backtoryAccessData.TokenType = loginResponse.TokenType;
ServiceLocator.Resolve <IStorageService>().UpdateData(backtoryAccessData);
deferred.Resolve();
}
});
}
catch (Exception)
{
dispatcher.Dispach(() =>
{
deferred.Reject();
});
}
});
return(deferred.Promise());
}
public void OnServerAchievementResolved(Dictionary <string, ServerAchievementInfo> achievementInfos, string[] claimedAchievementIds)
{
AchievementCache achievementCache =
ServiceLocator.Resolve <IStorageService>().ResolveData <AchievementCache>();
if (achievementCache == null)
{
achievementCache = new AchievementCache();
}
foreach (string claimedAchievementId in claimedAchievementIds)
{
achievementCache.ServerAchievementIds[claimedAchievementId] = true;
}
ServiceLocator.Resolve <IStorageService>().UpdateData(achievementCache);
AchievementStoredData achievementStoredData =
ServiceLocator.Resolve <IStorageService>().ResolveData <AchievementStoredData>();
if (achievementStoredData == null)
{
achievementStoredData = new AchievementStoredData();
}
Dictionary <AchievementInfo, AchievementToken[]> achievementTokenses =
claimedAchievementIds.Where(s => InfoResolver.Resolve <FortInfo>().Achievement.AchievementTokens.ContainsKey(s))
.Select(s => InfoResolver.Resolve <FortInfo>().Achievement.AchievementTokens[s])
.GroupBy(token => token.AchievementInfo)
.ToDictionary(tokens => tokens.Key, tokens => tokens.Select(token => token).ToArray());
foreach (KeyValuePair <AchievementInfo, AchievementToken[]> pair in achievementTokenses)
{
if (pair.Value.Length > 0)
{
if (pair.Key is NoneLevelBaseAchievementInfo)
{
achievementStoredData.Achievements[pair.Key.Id] = 0;
}
else
{
int max = pair.Value.Max(token => token.Index);
if (
!(achievementStoredData.Achievements.ContainsKey(pair.Key.Id) &&
achievementStoredData.Achievements[pair.Key.Id] >= max))
{
achievementStoredData.Achievements[pair.Key.Id] = max;
}
}
}
}
foreach (KeyValuePair <string, ServerAchievementInfo> pair in achievementInfos)
{
achievementStoredData.ServerAchievementInfos[pair.Key] = pair.Value;
}
ServiceLocator.Resolve <IStorageService>().UpdateData(achievementStoredData);
}
public InstanceResolverResult ResolvePossibleData(object baseObject, object data, PropertyInfo property)
{
InstanceResolverResult result = new InstanceResolverResult
{
PossibleInstanceTokens = InfoResolver.Resolve <FortInfo>().Purchase.GetAllPurchasableItemInfos().OfType <NoneLevelBasePurchasableItemInfo>().Select(info => new InstanceToken(info.Name, info)).ToArray()//InfoResolver.Resolve<FortInfo>().Package.Packages.Where(info => !(info is DiscountIapPackage)).Select(info => new InstanceToken(info.Sku, info)).ToArray()
};
InstanceToken instanceToken =
result.PossibleInstanceTokens.FirstOrDefault(token => ReferenceEquals(token.Value, data));
result.PresentableInstanceTokens = instanceToken == null ? new InstanceToken[0] : new[] { instanceToken };
return(result);
}
public InstanceResolverResult ResolvePossibleData(object baseObject, object data, PropertyInfo property)
{
InstanceResolverResult result = new InstanceResolverResult
{
PossibleInstanceTokens = InfoResolver.Resolve <FortInfo>().SkinnerBox.BoxInfos.OfType <PurchableSkinnerBoxInfo>().Select(info => new InstanceToken(info.Name, info)).ToArray()
};
InstanceToken instanceToken =
result.PossibleInstanceTokens.FirstOrDefault(token => ReferenceEquals(token.Value, data));
result.PresentableInstanceTokens = instanceToken == null ? new InstanceToken[0] : new[] { instanceToken };
return(result);
}
public static AchievementLevelInfo GetNextClaimableAchievementLevelInfo(this IAchievementService achievementService, Type levelBaseType)
{
int index = achievementService.GetAchievementClaimedIndex(levelBaseType) + 1;
AchievementInfo achievementInfo = InfoResolver.Resolve <FortInfo>().Achievement.AchievementTypes[levelBaseType];
Array value = (Array)levelBaseType.GetProperty("LevelInfo").GetValue(achievementInfo, new object[0]);
if (index >= value.Length)
{
return(null);
}
return((AchievementLevelInfo)value.GetValue(index));
}
public bool IsAchievementClaimed(Type noneLevelBaseType)
{
string achievementId = InfoResolver.Resolve <FortInfo>().Achievement.AchievementTypes[noneLevelBaseType].Id;
AchievementStoredData achievementStoredData =
ServiceLocator.Resolve <IStorageService>().ResolveData <AchievementStoredData>();
if (achievementStoredData == null)
{
achievementStoredData = new AchievementStoredData();
}
return(achievementStoredData.Achievements.ContainsKey(achievementId));
}
