private void OnPvpButtonClicked(UXButton button)
{
StringBuilder stringBuilder = new StringBuilder();
TournamentVO currentPlanetActiveTournament = Service.Get <TournamentController>().CurrentPlanetActiveTournament;
stringBuilder.Append((currentPlanetActiveTournament != null) ? currentPlanetActiveTournament.Uid : "no_tournament");
if (!GameUtils.HasAvailableTroops(false, null))
{
AlertScreen.ShowModal(false, base.LangController.Get("NOT_ENOUGH_TROOPS_TITLE", new object[0]), base.LangController.Get("NOT_ENOUGH_TROOPS_FOR_ATTACK", new object[0]), null, null);
stringBuilder.Append("|");
stringBuilder.Append("no_troops");
Service.Get <EventManager>().SendEvent(EventId.UIAttackScreenSelection, new ActionMessageBIData("PvP", stringBuilder.ToString()));
return;
}
if (!GameUtils.CanAffordCredits(Service.Get <PvpManager>().GetPvpMatchCost()))
{
PayMeScreen.ShowIfNotEnoughCurrency(Service.Get <PvpManager>().GetPvpMatchCost(), 0, 0, "PvP_battle", new OnScreenModalResult(this.OnNotEnoughCreditsModalResult));
return;
}
if (base.Player.ProtectedUntil > ServerTime.Time)
{
DisableProtectionAlertScreen.ShowModal(new OnScreenModalResult(this.OnConfirmInvalidation), null);
return;
}
this.PurchaseNextBattle();
base.EvtManager.SendEvent(EventId.UIAttackScreenSelection, new ActionMessageBIData("PvP", stringBuilder.ToString()));
}
public TournamentEndedScreen(Tournament tournament) : base("gui_tournaments")
{
this.tournament = tournament;
this.tournamentVO = Service.StaticDataController.Get <TournamentVO>(tournament.Uid);
this.playerRank = tournament.FinalRank;
this.tierVO = Service.StaticDataController.Get <TournamentTierVO>(this.playerRank.TierUid);
}
private Tournament ParseLastTournament(TournamentResponse response)
{
Tournament tournament = null;
if (response.TournamentsData.Count == 0)
{
Service.Get <StaRTSLogger>().WarnFormat("Client is trying to redeem tournament(s), however server does not redeem anything. Player ID: {0}", new object[]
{
this.currentPlayer.PlayerId
});
}
foreach (Tournament current in response.TournamentsData)
{
tournament = this.currentPlayer.TournamentProgress.GetTournament(current.Uid);
tournament.Sync(current);
this.NotifyEndForTournamentVO = Service.Get <IDataController>().Get <TournamentVO>(tournament.Uid);
}
InventoryCrates crates = Service.Get <CurrentPlayer>().Prizes.Crates;
Dictionary <string, object> cratesJsonData = response.CratesJsonData;
if (response.Rewards.Count > 0)
{
crates.UpdateAndBadgeFromServerObject(cratesJsonData);
}
else
{
crates.FromObject(cratesJsonData);
}
return(tournament);
}
public EatResponse OnEvent(EventId id, object cookie)
{
if (id != EventId.WorldInTransitionComplete)
{
if (id == EventId.PlanetRelocate)
{
this.CurrentPlanetActiveTournament = this.GetActiveTournamentOnCurrentPlanet();
}
}
else if (Service.Get <GameStateMachine>().CurrentState is HomeState)
{
if (this.showConflictPopup)
{
this.showConflictPopup = false;
this.SetConflictPopupIsShown();
AlertScreen.ShowModal(false, null, Service.Get <Lang>().Get("VICTORY_BONUS_MESSAGE", new object[0]), null, null);
}
else if (this.NotifyEndForTournamentVO != null)
{
this.ShowTournamentEnded();
}
else
{
TournamentRank tournamentCurrentRank = this.currentPlayer.TournamentProgress.GetTournamentCurrentRank(this.CurrentPlanetActiveTournament.Uid);
Service.Get <ScreenController>().AddScreen(new TournamentTierChangedScreen(tournamentCurrentRank));
string newValue = ServerTime.Time.ToString();
Service.Get <ServerPlayerPrefs>().SetPref(ServerPref.TournamentTierChangeTimeViewed, newValue);
SetPrefsCommand command = new SetPrefsCommand(false);
Service.Get <ServerAPI>().Enqueue(command);
}
Service.Get <EventManager>().UnregisterObserver(this, EventId.WorldInTransitionComplete);
}
return(EatResponse.NotEaten);
}
public bool ShouldShowTournamentLeaderboard(TournamentVO tournamentVO)
{
if (tournamentVO != null)
{
TimedEventState state = TimedEventUtils.GetState(tournamentVO);
return(state == TimedEventState.Live || state == TimedEventState.Closing);
}
return(false);
}
public bool IsPlayerInTournament(TournamentVO tournamentVO)
{
bool result = false;
if (tournamentVO != null)
{
result = this.currentPlayer.TournamentProgress.HasTournament(tournamentVO);
}
return(result);
}
public bool IsTournamentRedeemed(TournamentVO tournamentVO)
{
bool result = false;
if (tournamentVO != null && this.currentPlayer.TournamentProgress.HasTournament(tournamentVO))
{
Tournament tournament = this.currentPlayer.TournamentProgress.GetTournament(tournamentVO.Uid);
result = tournament.Collected;
}
return(result);
}
private void ShowTournamentEnded()
{
if (this.NotifyEndForTournamentVO != null)
{
Tournament tournament = this.currentPlayer.TournamentProgress.GetTournament(this.NotifyEndForTournamentVO.Uid);
if (tournament != null)
{
Service.Get <ScreenController>().AddScreen(new TournamentEndedScreen(tournament));
}
this.NotifyEndForTournamentVO = null;
}
}
public void UpdatePvpPanel(bool showTournamentRating, TournamentVO tournamentVO)
{
this.pvpView.UpdatePvpPanel(showTournamentRating, tournamentVO);
if (tournamentVO != null && GameUtils.ConflictStartsInBadgePeriod(tournamentVO))
{
this.tournamentController.OnTournamentViewed(tournamentVO.Uid);
}
if (tournamentVO == null)
{
this.featuredView.ShowNoActiveEventsAvailable();
}
this.galaxyJewel.Value = this.tournamentController.NumberOfTournamentsNotViewed();
}
public TransmissionsHolonetPopupView(HolonetScreen screen)
{
this.conflictEndVO = null;
this.lang = Service.Get <Lang>();
this.eventManager = Service.Get <EventManager>();
this.holonetScreen = screen;
this.holoPositioner = null;
this.currentCharacter = null;
this.currentTransmission = null;
this.currentIndex = 1;
this.maxIndex = 0;
this.InitView();
}
private void EnterTournament(TournamentVO tournamentVO)
{
if (tournamentVO == null || tournamentVO.PlanetId != this.currentPlayer.PlanetId)
{
return;
}
Tournament tournament = new Tournament();
tournament.Uid = tournamentVO.Uid;
tournament.Rating = tournamentVO.StartingRating;
tournament.RedeemedRewards.Clear();
tournament.Collected = false;
this.currentPlayer.TournamentProgress.AddTournament(tournamentVO.Uid, tournament);
Service.Get <EventManager>().SendEvent(EventId.TournamentEntered, tournamentVO);
}
public void UpdatePvpPanel(bool showTournamentRating, TournamentVO tournamentVO)
{
this.tournamentMedalsGroup.Visible = showTournamentRating;
this.labelBattleTitle.Text = base.LangController.Get("s_AttackRival", new object[0]);
if (showTournamentRating && !string.IsNullOrEmpty(tournamentVO.PlanetId))
{
int tournamentRating = Service.Get <TournamentController>().GetTournamentRating(tournamentVO);
this.tournamentMedalsLabel.Text = tournamentRating.ToString();
this.tournamentMedalsSprite.SpriteName = GameUtils.GetTournamentPointIconName(tournamentVO.PlanetId);
if (Service.Get <TournamentController>().IsPlayerInTournament(tournamentVO))
{
this.labelBattleTitle.Text = LangUtils.GetTournamentTitle(tournamentVO);
}
}
}
public int NumberOfTournamentsNotViewed()
{
int num = 0;
bool flag = Service.Get <BuildingLookupController>().HasNavigationCenter();
List <TournamentVO> allActiveTournaments = TournamentController.GetAllActiveTournaments();
for (int i = 0; i < allActiveTournaments.Count; i++)
{
TournamentVO tournamentVO = allActiveTournaments[i];
if (tournamentVO != null && this.viewedTournaments != null && !this.viewedTournaments.ContainsKey(tournamentVO.Uid) && GameUtils.ConflictStartsInBadgePeriod(tournamentVO) && (flag || this.currentPlayer.PlanetId == tournamentVO.PlanetId))
{
num++;
}
}
return(num);
}
public TournamentTiersScreen(TournamentVO tournamentVO, Tournament tournament) : base("gui_conflict_leagues")
{
Dictionary <string, TournamentTierVO> .ValueCollection all = Service.Get <IDataController>().GetAll <TournamentTierVO>();
this.tiers = new List <TournamentTierVO>();
foreach (TournamentTierVO current in all)
{
this.tiers.Add(current);
}
this.tiers.Sort(new Comparison <TournamentTierVO>(this.CompareTiers));
this.particleElements = new List <string>();
this.currentTournamentVO = tournamentVO;
this.currentPlayerRank = ((tournament != null) ? tournament.CurrentRank : null);
EventManager eventManager = Service.Get <EventManager>();
eventManager.RegisterObserver(this, EventId.ScreenLoaded, EventPriority.Default);
eventManager.RegisterObserver(this, EventId.ScreenClosing, EventPriority.Default);
}
public void UpdateTournamentsData(bool canShowDialog)
{
this.FindNextExpiringConflict();
this.CurrentPlanetActiveTournament = this.GetActiveTournamentOnCurrentPlanet();
List <TournamentVO> tournamentVOs = TournamentController.GetTournamentVOs(TournamentFilter.All);
for (int i = 0; i < tournamentVOs.Count; i++)
{
TournamentVO tournamentVO = tournamentVOs[i];
TimedEventState state = TimedEventUtils.GetState(tournamentVO);
if (tournamentVO != null && state != TimedEventState.Live && state != TimedEventState.Upcoming && this.IsPlayerInTournament(tournamentVO) && !this.IsTournamentRedeemed(tournamentVO))
{
this.RedeemTournaments(canShowDialog);
return;
}
}
}
public int GetTournamentRating(TournamentVO tournamentVO)
{
int result = 0;
if (tournamentVO != null)
{
Tournament tournament = this.currentPlayer.TournamentProgress.GetTournament(tournamentVO.Uid);
if (tournament != null)
{
result = tournament.Rating;
}
else
{
result = tournamentVO.StartingRating;
}
}
return(result);
}
private void InitBattleStats(string id, out LeaderboardBattleHistory battleHistory)
{
battleHistory = null;
bool flag = this.tab == SocialTabs.Tournament;
this.medalGroup.Visible = !flag;
this.tournamentMedalGroup.Visible = flag;
if (flag)
{
if (!string.IsNullOrEmpty(this.planetUid))
{
this.tournamentMedalLabel.Text = Service.Lang.ThousandsSeparated(this.player.BattleScore);
this.tournamentMedalSprite.SpriteName = GameUtils.GetTournamentPointIconName(this.planetUid);
}
else
{
this.tournamentMedalGroup.Visible = false;
}
if (this.player.TournamentBattleHistory != null && !string.IsNullOrEmpty(this.planetUid))
{
TournamentVO activeTournamentOnPlanet = TournamentController.GetActiveTournamentOnPlanet(this.planetUid);
if (activeTournamentOnPlanet != null)
{
this.player.TournamentBattleHistory.TryGetValue(activeTournamentOnPlanet.Uid, out battleHistory);
}
}
}
else
{
this.medalLabel.Text = Service.Lang.ThousandsSeparated(this.player.BattleScore);
battleHistory = this.player.BattleHistory;
}
int num = (battleHistory == null) ? 0 : battleHistory.AttacksWon;
int num2 = (battleHistory == null) ? 0 : battleHistory.DefensesWon;
this.attacksLabel.Text = Service.Lang.Get("ATTACKS_WON", new object[]
{
num
});
this.defensesLabel.Text = Service.Lang.Get("DEFENSES_WON", new object[]
{
num2
});
}
public void OnGalaxyViewed()
{
bool flag = false;
List <TournamentVO> allActiveTournaments = TournamentController.GetAllActiveTournaments();
for (int i = 0; i < allActiveTournaments.Count; i++)
{
TournamentVO tournamentVO = allActiveTournaments[i];
if (tournamentVO != null && this.viewedTournaments != null && GameUtils.ConflictStartsInBadgePeriod(tournamentVO) && !this.viewedTournaments.ContainsKey(tournamentVO.Uid))
{
this.viewedTournaments.Add(tournamentVO.Uid, true);
flag = true;
}
}
if (flag)
{
this.UpdateAndSyncTournamentViewedData();
}
}
public void RefreshView()
{
this.currentTournamentVO = TournamentController.GetActiveTournamentOnPlanet(this.screen.viewingPlanetVO.Uid);
if (this.currentTournamentVO != null)
{
this.comingSoonEventTitleLabel.Text = LangUtils.GetTournamentTitle(this.currentTournamentVO);
this.currentEventState = TimedEventUtils.GetState(this.currentTournamentVO);
this.screen.UpdatePvpPanel(this.currentEventState == TimedEventState.Live, this.currentTournamentVO);
bool isPlayerInTournament = this.tournamentController.IsPlayerInTournament(this.currentTournamentVO);
this.ShowTimedEventDetails(isPlayerInTournament);
}
else
{
this.observingClockTime = false;
Service.ViewTimeEngine.UnregisterClockTimeObserver(this);
this.currentEventState = TimedEventState.Invalid;
this.screen.UpdatePvpPanel(false, null);
}
TimedEventState timedEventState = this.currentEventState;
if (timedEventState != TimedEventState.Upcoming)
{
if (timedEventState == TimedEventState.Live)
{
this.inProgressEventTimerLabel.TextColor = this.planetActiveTextColor;
this.comingSoonEventTimerLabel.TextColor = this.planetActiveTextColor;
this.comingSoonBg.Color = this.planetActiveTextColor;
this.comingSoonBgGlow.Color = this.planetActiveTextGlowColor;
this.comingSoonDividerLeft.Color = this.planetActiveTextColor;
this.comingSoonDividerCenter.Color = this.planetActiveTextColor;
}
}
else
{
this.comingSoonEventTimerLabel.TextColor = this.planetUpcomingTextColor;
this.comingSoonBg.Color = this.planetUpcomingTextColor;
this.comingSoonBgGlow.Color = this.planetUpcomingTextGlowColor;
this.comingSoonDividerLeft.Color = this.planetUpcomingTextColor;
this.comingSoonDividerCenter.Color = this.planetUpcomingTextColor;
}
this.UpdateTimeRemaining();
}
public bool UpdatePlanetTournamentState()
{
bool result = false;
TournamentVO activeTournamentOnPlanet = TournamentController.GetActiveTournamentOnPlanet(this.VO.Uid);
if (activeTournamentOnPlanet != this.tournamentVO)
{
result = true;
}
else if (activeTournamentOnPlanet != null)
{
TimedEventState state = TimedEventUtils.GetState(this.tournamentVO);
if (state != this.tournamentState)
{
result = true;
}
}
this.Tournament = activeTournamentOnPlanet;
return(result);
}
private void FindNextExpiringConflict()
{
this.NextExpiringConflict = null;
uint num = 4294967295u;
List <TournamentVO> tournamentVOs = TournamentController.GetTournamentVOs(TournamentFilter.Live);
for (int i = 0; i < tournamentVOs.Count; i++)
{
TournamentVO tournamentVO = tournamentVOs[i];
if (tournamentVO != null && !this.IsTournamentRedeemed(tournamentVO) && (long)tournamentVO.EndTimestamp < (long)((ulong)num))
{
num = (uint)tournamentVO.EndTimestamp;
this.NextExpiringConflict = tournamentVO;
}
}
if (this.NextExpiringConflict != null)
{
Service.Get <ViewTimeEngine>().RegisterFrameTimeObserver(this);
}
}
public void OnViewFrameTime(float dt)
{
if (this.selectedPlanet == null)
{
return;
}
TournamentVO activeTournamentOnPlanet = TournamentController.GetActiveTournamentOnPlanet(this.selectedPlanet.Uid);
if (activeTournamentOnPlanet != null)
{
TimedEventState state = TimedEventUtils.GetState(activeTournamentOnPlanet);
if (state == TimedEventState.Live)
{
int secondsRemaining = TimedEventUtils.GetSecondsRemaining(activeTournamentOnPlanet);
string text = LangUtils.FormatTime((long)secondsRemaining);
this.labelUnlockPlanetTimer.Text = this.lang.Get("PLANETS_GNC_UPGRADE_CONFLICT_ENDS", new object[]
{
text
});
}
else if (state == TimedEventState.Upcoming)
{
int secondsRemaining2 = TimedEventUtils.GetSecondsRemaining(activeTournamentOnPlanet);
string text2 = LangUtils.FormatTime((long)secondsRemaining2);
this.labelUnlockPlanetTimer.Text = this.lang.Get("PLANETS_GNC_UPGRADE_NEXT_CONFLICT_BEGINS", new object[]
{
text2
});
}
else
{
this.labelUnlockPlanetTimer.Text = string.Empty;
}
}
else
{
this.labelUnlockPlanetTimer.Text = string.Empty;
}
}
public static TournamentVO GetActiveTournamentOnPlanet(string planetId)
{
StaticDataController staticDataController = Service.StaticDataController;
TournamentVO result = null;
foreach (TournamentVO current in staticDataController.GetAll <TournamentVO>())
{
if (!(current.PlanetId != planetId))
{
if (TimedEventUtils.IsTimedEventActive(current))
{
TimedEventState state = TimedEventUtils.GetState(current);
if (state == TimedEventState.Live || state == TimedEventState.Closing)
{
return(current);
}
result = current;
}
}
}
return(result);
}
private void RefreshView(bool reloadTexture)
{
TournamentController tournamentController = Service.TournamentController;
TournamentVO activeTournamentOnPlanet = TournamentController.GetActiveTournamentOnPlanet(this.screen.viewingPlanetVO.Uid);
if (activeTournamentOnPlanet == null)
{
this.ShowNoActiveEventsAvailable();
if (reloadTexture)
{
this.timedEventFooterTexture.LoadTexture(this.screen.viewingPlanetVO.FooterTexture);
}
}
else if (tournamentController.IsThisTournamentLive(activeTournamentOnPlanet))
{
this.timedEventFooterTexture.LoadTexture(this.screen.viewingPlanetVO.FooterConflictTexture);
}
else
{
this.timedEventFooterTexture.LoadTexture(this.screen.viewingPlanetVO.FooterTexture);
}
this.tournamentsView.RefreshView();
}
private static bool IsPlanetaryConflict(TournamentVO tournamentVO)
{
return(!string.IsNullOrEmpty(tournamentVO.PlanetId));
}
public void InitPlanets(string startPlanetUid)
{
PlanetStatsCommand planetStatsCommand = null;
PlanetStatsRequest planetStatsRequest = null;
AssetManager assetManager = Service.Get <AssetManager>();
if (this.updatePlanetPopulations)
{
this.updatePlanetPopulations = false;
planetStatsRequest = new PlanetStatsRequest();
planetStatsCommand = new PlanetStatsCommand(planetStatsRequest);
}
this.planetIndex = 0;
this.planetsWithEvent.Clear();
this.planetsWithActiveEvents.Clear();
List <PlanetVO> allPlayerFacingPlanets = PlanetUtils.GetAllPlayerFacingPlanets();
int i = 0;
int count = allPlayerFacingPlanets.Count;
while (i < count)
{
Planet planet = new Planet(allPlayerFacingPlanets[i]);
AssetHandle handle = AssetHandle.Invalid;
if (planet.VO.Uid == startPlanetUid)
{
this.currentlyForegroundedPlanet = planet;
this.InitialPlanetPosition = this.GetPlanetVect3Position(planet.VO.Angle, planet.VO.Radius, -planet.VO.HeightOffset);
}
if (planetStatsRequest != null)
{
planetStatsRequest.AddPlanetID(planet.VO.Uid);
}
else
{
planet.ThrashingPopulation = planet.VO.Population;
}
planet.IsCurrentPlanet = (startPlanetUid == planet.VO.Uid);
this.planets.Add(planet);
this.planetLookupDict[planet.VO.Uid] = planet;
planet.Tournament = null;
TournamentVO activeTournamentOnPlanet = TournamentController.GetActiveTournamentOnPlanet(planet.VO.Uid);
if (activeTournamentOnPlanet != null)
{
TimedEventState state = TimedEventUtils.GetState(activeTournamentOnPlanet);
if (state == TimedEventState.Live)
{
this.planetsWithEvent.Add(planet);
planet.Tournament = activeTournamentOnPlanet;
this.planetsWithActiveEvents.Add(planet);
}
else if (state == TimedEventState.Upcoming)
{
this.planetsWithEvent.Add(planet);
}
}
planet.UpdatePlanetTournamentState();
assetManager.Load(ref handle, planet.VO.GalaxyAssetName, new AssetSuccessDelegate(this.OnPlanetLoaded), null, planet);
planet.Handle = handle;
i++;
}
this.UpdatePlanetsFriendData();
this.UpdatePlanetsSquadData();
if (planetStatsCommand != null)
{
Service.Get <ServerAPI>().Sync(planetStatsCommand);
}
this.planets.Sort(new Comparison <Planet>(this.ComparePlanetOrder));
}
public TransmissionsHolonetTab(HolonetScreen holoScreen, HolonetControllerType holonetControllerType) : base(holoScreen, holonetControllerType)
{
base.InitializeTab("TransmissionsLogTab", "hn_transmissions_tab");
List <TransmissionVO> transmissions = Service.HolonetController.TransmissionsController.Transmissions;
int count = transmissions.Count;
this.table = holoScreen.GetElement <UXTable>("TransmissionsLogTable");
this.table.SetTemplateItem("TransmissionsLogItem");
string title = string.Empty;
string body = string.Empty;
for (int i = 0; i < count; i++)
{
bool flag = false;
TransmissionVO transmissionVO = transmissions[i];
switch (transmissionVO.Type)
{
case TransmissionType.Research:
title = this.lang.Get("hn_transmission_research_title", new object[]
{
this.GetResearchDisplayName(transmissionVO.TransData)
});
body = this.lang.Get("hn_transmission_research_body", new object[]
{
this.GetResearchDisplayName(transmissionVO.TransData),
transmissionVO.Btn1Data
});
flag = true;
break;
case TransmissionType.HqUpgrade:
title = this.lang.Get("hn_transmission_hqupgrade_title", new object[0]);
body = this.lang.Get("hn_transmission_hqupgrade_body", new object[]
{
transmissionVO.Btn1Data
});
flag = true;
break;
case TransmissionType.NavigationCenterUpgrade:
title = this.lang.Get("hn_transmission_pcupgrade_title", new object[0]);
body = this.lang.Get("hn_transmission_pcupgrade_body", new object[]
{
transmissionVO.Btn1Data
});
flag = true;
break;
case TransmissionType.Conflict:
{
string text = string.Empty;
string text2 = string.Empty;
StaticDataController staticDataController = Service.StaticDataController;
TournamentVO optional = staticDataController.GetOptional <TournamentVO>(transmissionVO.TransData);
TournamentTierVO optional2 = staticDataController.GetOptional <TournamentTierVO>(transmissionVO.Btn1Data);
if (optional != null && optional2 != null)
{
text = LangUtils.GetPlanetDisplayName(optional.PlanetId);
text2 = this.lang.Get(optional2.RankName, new object[0]) + " " + this.lang.Get(optional2.Division, new object[0]);
}
title = this.lang.Get("hn_transmission_conflict_title", new object[0]);
body = this.lang.Get("hn_transmission_conflict_body", new object[]
{
text,
text2
});
flag = true;
break;
}
case TransmissionType.WarPreparation:
title = this.lang.Get(LangUtils.AppendPlayerFactionToKey("transm_war_prep_title"), new object[0]);
body = this.lang.Get(LangUtils.AppendPlayerFactionToKey("transm_war_prep_body"), new object[0]);
flag = true;
break;
case TransmissionType.WarStart:
title = this.lang.Get(LangUtils.AppendPlayerFactionToKey("transm_war_start_title"), new object[0]);
body = this.lang.Get(LangUtils.AppendPlayerFactionToKey("transm_war_start_body"), new object[0]);
flag = true;
break;
case TransmissionType.WarEnded:
title = this.lang.Get(LangUtils.AppendPlayerFactionToKey("transm_war_end_title"), new object[0]);
body = this.lang.Get(LangUtils.AppendPlayerFactionToKey("transm_war_end_body"), new object[0]);
flag = true;
break;
case TransmissionType.SquadChange:
{
object[] array = (transmissionVO.TransData ?? string.Empty).Split(new char[]
{
'\\'
});
if (array.Length > 1)
{
title = this.lang.Get("hn_squad_application_accepted_title", new object[]
{
array[1]
});
body = this.lang.Get("hn_squad_application_accepted_body", array);
}
flag = true;
break;
}
case TransmissionType.GuildLevelUp:
title = this.lang.Get("hn_perks_squad_level_up_title", new object[0]);
body = this.lang.Get("hn_perks_squad_level_up_body", new object[]
{
transmissionVO.SquadLevel
});
flag = true;
break;
case TransmissionType.DailyCrateReward:
{
title = this.lang.Get("hn_daily_crate_reward_title", new object[0]);
CrateVO crateVO = Service.StaticDataController.Get <CrateVO>(transmissionVO.CrateId);
body = this.lang.Get("hn_daily_crate_reward_body", new object[]
{
LangUtils.GetCrateDisplayName(crateVO)
});
flag = true;
break;
}
}
if (flag)
{
this.AddCustomTransmission(transmissionVO, title, body, i);
}
else
{
this.AddGenericTransmission(transmissionVO, i);
}
}
}
public void UpdatePlayerRank(TournamentController.PlayerRankUpdatedCallback callback, TournamentVO tournamentVO)
{
if (tournamentVO != null)
{
GetTournamentRankCommand getTournamentRankCommand = new GetTournamentRankCommand(new TournamentRankRequest
{
PlayerId = this.currentPlayer.PlayerId,
PlanetId = tournamentVO.PlanetId
});
getTournamentRankCommand.AddSuccessCallback(new AbstractCommand <TournamentRankRequest, TournamentRankResponse> .OnSuccessCallback(this.OnGetTournamentRank));
getTournamentRankCommand.Context = new Dictionary <string, object>
{
{
"tournamentId",
tournamentVO.Uid
},
{
"callback",
callback
}
};
Service.Get <ServerAPI>().Sync(getTournamentRankCommand);
}
}
public bool IsThisTournamentLive(TournamentVO tournamentVO)
{
return(tournamentVO != null && TimedEventUtils.GetState(tournamentVO) == TimedEventState.Live);
}
public bool HasTournament(TournamentVO tournamentVO)
{
return(this.tournaments.ContainsKey(tournamentVO.Uid));
}
