private void OnSceneLoaded(SceneMgr.Mode mode, Scene scene, object userData)
{
if (mode != SceneMgr.Mode.FATAL_ERROR)
{
this.m_suppressLoginTooltip = false;
this.m_currencyFrame.RefreshContents();
bool flag = (mode != SceneMgr.Mode.INVALID) && (mode != SceneMgr.Mode.FATAL_ERROR);
if (flag && SpectatorManager.Get().IsInSpectatorMode())
{
this.SpectatorManager_OnSpectatorModeChanged(OnlineEventType.ADDED, null);
}
else if ((this.m_spectatorModeIndicator != null) && this.m_spectatorModeIndicator.activeSelf)
{
this.m_spectatorModeIndicator.SetActive(false);
}
if (flag && (this.m_spectatorCountPanel != null))
{
bool flag2 = SpectatorManager.Get().IsBeingSpectated();
if (((UniversalInputManager.UsePhoneUI != null) && (SceneMgr.Get() != null)) && !SceneMgr.Get().IsInGame())
{
flag2 = false;
}
this.m_spectatorCountPanel.SetActive(flag2);
}
this.UpdateForDemoMode();
this.UpdateLayout();
if (UniversalInputManager.UsePhoneUI != null)
{
this.UpdateForPhone();
}
}
}
private FriendListAvailabilityBlockerReasons GetAvailabilityBlockerReason()
{
if (!this.m_netCacheReady)
{
return(FriendListAvailabilityBlockerReasons.NETCACHE_NOT_READY);
}
if (!this.m_myPlayerReady)
{
return(FriendListAvailabilityBlockerReasons.MY_PLAYER_NOT_READY);
}
if (this.HasChallenge())
{
return(FriendListAvailabilityBlockerReasons.HAS_EXISTING_CHALLENGE);
}
if (SpectatorManager.Get().IsInSpectatorMode())
{
return(FriendListAvailabilityBlockerReasons.SPECTATING_GAME);
}
if (GameMgr.Get().IsFindingGame())
{
return(FriendListAvailabilityBlockerReasons.FINDING_GAME);
}
if (SceneMgr.Get().IsModeRequested(SceneMgr.Mode.FATAL_ERROR))
{
return(FriendListAvailabilityBlockerReasons.HAS_FATAL_ERROR);
}
if (SceneMgr.Get().IsModeRequested(SceneMgr.Mode.LOGIN))
{
return(FriendListAvailabilityBlockerReasons.LOGGING_IN);
}
if (SceneMgr.Get().IsModeRequested(SceneMgr.Mode.STARTUP))
{
return(FriendListAvailabilityBlockerReasons.STARTING_UP);
}
if (SceneMgr.Get().IsModeRequested(SceneMgr.Mode.GAMEPLAY))
{
if (GameMgr.Get().IsSpectator() || GameMgr.Get().IsNextSpectator())
{
return(FriendListAvailabilityBlockerReasons.SPECTATING_GAME);
}
if (!GameMgr.Get().IsAI() && !GameMgr.Get().IsNextAI())
{
return(FriendListAvailabilityBlockerReasons.PLAYING_NON_AI_GAME);
}
return(FriendListAvailabilityBlockerReasons.PLAYING_AI_GAME);
}
if (!GameUtils.AreAllTutorialsComplete())
{
return(FriendListAvailabilityBlockerReasons.TUTORIALS_INCOMPLETE);
}
if (ShownUIMgr.Get().GetShownUI() == ShownUIMgr.UI_WINDOW.GENERAL_STORE)
{
return(FriendListAvailabilityBlockerReasons.STORE_IS_SHOWN);
}
if ((TavernBrawlDisplay.Get() != null) && TavernBrawlDisplay.Get().IsInDeckEditMode())
{
return(FriendListAvailabilityBlockerReasons.EDITING_TAVERN_BRAWL);
}
return(FriendListAvailabilityBlockerReasons.NONE);
}
private bool CanSendUI()
{
if (GameMgr.Get() == null)
{
return(false);
}
if (GameMgr.Get().IsSpectator())
{
return(false);
}
if ((GameMgr.Get().IsAI() && !SpectatorManager.Get().MyGameHasSpectators()) && SpectatorManager.Get().MyGameHasSpectators())
{
return(false);
}
float realtimeSinceStartup = UnityEngine.Time.realtimeSinceStartup;
float num2 = realtimeSinceStartup - this.m_lastSendTime;
if (this.IsSendingTargetingArrow() && (num2 > 0.25f))
{
this.m_lastSendTime = realtimeSinceStartup;
return(true);
}
if (num2 < 0.35f)
{
return(false);
}
this.m_lastSendTime = realtimeSinceStartup;
return(true);
}
private static void OnLeaveSpectatingDialogResponse(AlertPopup.Response response, object userData)
{
if (response == AlertPopup.Response.CONFIRM)
{
SpectatorManager.Get().LeaveSpectatorMode();
}
}
private void Update()
{
if ((GameState.Get() == null) || SpectatorManager.Get().IsInSpectatorMode())
{
this.state = State.None;
}
else
{
GameState.Get().RegisterTurnChangedListener(new GameState.TurnChangedCallback(this.OnTurnChanged));
GameState.Get().RegisterTurnTimerUpdateListener(new GameState.TurnTimerUpdateCallback(this.OnTurnTimerUpdate));
if (GameState.Get().IsMulliganPhase())
{
if (this.state == State.None)
{
this.state = State.GameStarted;
this.FireNotification();
}
}
else if (this.state == State.GameStarted)
{
this.state = !GameState.Get().IsFriendlySidePlayerTurn() ? State.None : State.YourTurn;
this.FireNotification();
}
}
}
private void Awake()
{
s_instance = this;
if (UniversalInputManager.UsePhoneUI != null)
{
Transform transform = this.m_menuButton.transform;
transform.localScale = (Vector3)(transform.localScale * 2f);
Transform transform2 = this.m_friendButton.transform;
transform2.localScale = (Vector3)(transform2.localScale * 2f);
}
else
{
this.m_connectionIndicator.gameObject.SetActive(false);
}
this.m_initialWidth = base.GetComponent <Renderer>().bounds.size.x;
this.m_initialFriendButtonScaleX = this.m_friendButton.transform.localScale.x;
this.m_initialMenuButtonScaleX = this.m_menuButton.transform.localScale.x;
this.m_menuButton.AddEventListener(UIEventType.RELEASE, new UIEvent.Handler(this.OnMenuButtonReleased));
this.m_friendButton.AddEventListener(UIEventType.RELEASE, new UIEvent.Handler(this.OnFriendButtonReleased));
this.ToggleEnableButtons(false);
this.m_batteryLevel.gameObject.SetActive(false);
FatalErrorMgr.Get().AddErrorListener(new FatalErrorMgr.ErrorCallback(this.OnFatalError));
SceneMgr.Get().RegisterSceneLoadedEvent(new SceneMgr.SceneLoadedCallback(this.OnSceneLoaded));
SpectatorManager.Get().OnInviteReceived += new SpectatorManager.InviteReceivedHandler(this.SpectatorManager_OnInviteReceived);
SpectatorManager.Get().OnSpectatorToMyGame += new SpectatorManager.SpectatorToMyGameHandler(this.SpectatorManager_OnSpectatorToMyGame);
SpectatorManager.Get().OnSpectatorModeChanged += new SpectatorManager.SpectatorModeChangedHandler(this.SpectatorManager_OnSpectatorModeChanged);
ApplicationMgr.Get().WillReset += new System.Action(this.WillReset);
this.m_lightingBlend = this.m_menuButtonMesh.GetComponent <Renderer>().material.GetFloat("_LightingBlend");
if (UniversalInputManager.UsePhoneUI != null)
{
this.m_batteryLevel = this.m_batteryLevelPhone;
this.m_currentTime.gameObject.SetActive(false);
}
this.m_menuButton.SetPhoneStatusBarState(0);
}
public static void OnPlayerChallengeButtonPressed(FriendListChallengeButton challengeButton, BnetPlayer player)
{
SoundManager.Get().LoadAndPlay("Small_Click");
if (ChatMgr.Get().FriendListFrame.IsInEditMode)
{
ChatMgr.Get().FriendListFrame.ShowRemoveFriendPopup(player);
}
else
{
BnetGameAccountId hearthstoneGameAccountId = player.GetHearthstoneGameAccountId();
SpectatorManager manager = SpectatorManager.Get();
if (manager.CanSpectate(player))
{
manager.SpectatePlayer(player);
}
else if (manager.IsSpectatingMe(hearthstoneGameAccountId))
{
AlertPopup.PopupInfo info = new AlertPopup.PopupInfo {
m_headerText = GameStrings.Get("GLOBAL_SPECTATOR_KICK_PROMPT_HEADER")
};
object[] args = new object[] { FriendUtils.GetUniqueName(player) };
info.m_text = GameStrings.Format("GLOBAL_SPECTATOR_KICK_PROMPT_TEXT", args);
info.m_showAlertIcon = true;
info.m_responseDisplay = AlertPopup.ResponseDisplay.CONFIRM_CANCEL;
info.m_responseCallback = new AlertPopup.ResponseCallback(FriendListFriendFrame.OnKickSpectatorDialogResponse);
info.m_responseUserData = player;
DialogManager.Get().ShowPopup(info);
}
else if (manager.CanInviteToSpectateMyGame(hearthstoneGameAccountId))
{
manager.InviteToSpectateMe(player);
}
else if (manager.IsSpectatingPlayer(hearthstoneGameAccountId))
{
if ((GameMgr.Get().IsFindingGame() || SceneMgr.Get().IsTransitioning()) || GameMgr.Get().IsTransitionPopupShown())
{
return;
}
AlertPopup.PopupInfo info2 = new AlertPopup.PopupInfo {
m_headerText = GameStrings.Get("GLOBAL_SPECTATOR_LEAVE_PROMPT_HEADER"),
m_text = GameStrings.Get("GLOBAL_SPECTATOR_LEAVE_PROMPT_TEXT"),
m_showAlertIcon = true,
m_responseDisplay = AlertPopup.ResponseDisplay.CONFIRM_CANCEL,
m_responseCallback = new AlertPopup.ResponseCallback(FriendListFriendFrame.OnLeaveSpectatingDialogResponse)
};
DialogManager.Get().ShowPopup(info2);
}
else if (!manager.IsInvitedToSpectateMyGame(hearthstoneGameAccountId) && challengeButton.CanChallenge())
{
FriendChallengeMgr.Get().SendChallenge(player);
}
else
{
return;
}
challengeButton.UpdateButton();
ChatMgr.Get().CloseChatUI();
}
}
private void OnDestroy()
{
SpectatorManager.Get().OnInviteReceived -= new SpectatorManager.InviteReceivedHandler(this.SpectatorManager_OnInviteReceived);
SpectatorManager.Get().OnSpectatorToMyGame -= new SpectatorManager.SpectatorToMyGameHandler(this.SpectatorManager_OnSpectatorToMyGame);
SpectatorManager.Get().OnSpectatorModeChanged -= new SpectatorManager.SpectatorModeChangedHandler(this.SpectatorManager_OnSpectatorModeChanged);
ApplicationMgr.Get().WillReset -= new System.Action(this.WillReset);
s_instance = null;
}
private void HandleDisconnect()
{
Log.GameMgr.PrintWarning("Gameplay is handling a game disconnect.", new object[0]);
if (!ReconnectMgr.Get().ReconnectFromGameplay() && !SpectatorManager.Get().HandleDisconnectFromGameplay())
{
DisconnectMgr.Get().DisconnectFromGameplay();
}
}
private void OnDestroy()
{
if ((GameState.Get() != null) && !SpectatorManager.Get().IsInSpectatorMode())
{
GameState.Get().UnregisterTurnChangedListener(new GameState.TurnChangedCallback(this.OnTurnChanged));
GameState.Get().UnregisterTurnTimerUpdateListener(new GameState.TurnTimerUpdateCallback(this.OnTurnTimerUpdate));
}
}
private void StartDrift(bool isFriendlySide)
{
if (isFriendlySide || !SpectatorManager.Get().IsSpectatingOpposingSide())
{
this.StandUpright(isFriendlySide);
}
this.DriftLeftAndRight(isFriendlySide);
}
private static void OnKickSpectatorDialogResponse(AlertPopup.Response response, object userData)
{
BnetPlayer player = (BnetPlayer)userData;
if (response == AlertPopup.Response.CONFIRM)
{
SpectatorManager.Get().KickSpectator(player, true);
}
}
private void ConcedeButtonPressed(UIEvent e)
{
if ((GameMgr.Get() != null) && GameMgr.Get().IsSpectator())
{
SpectatorManager.Get().LeaveSpectatorMode();
}
else if (GameState.Get() != null)
{
GameState.Get().Concede();
}
this.Hide();
}
private bool UpdateSpectateButtonState()
{
BnetGameAccountId hearthstoneGameAccountId = this.m_player.GetHearthstoneGameAccountId();
SpectatorManager manager = SpectatorManager.Get();
bool flag = false;
string str = null;
if (manager.HasInvitedMeToSpectate(hearthstoneGameAccountId))
{
str = "HasInvitedMeToSpectate";
flag = true;
}
else if (manager.CanSpectate(this.m_player))
{
str = "CanSpectateThisFriend";
}
else if (manager.IsSpectatingMe(hearthstoneGameAccountId))
{
str = "CurrentlySpectatingMe";
}
else if (manager.CanInviteToSpectateMyGame(hearthstoneGameAccountId))
{
str = "CanInviteToSpectateMe";
}
else if (manager.IsSpectatingPlayer(hearthstoneGameAccountId))
{
str = "CurrentlySpectatingThisFriend";
}
else if (manager.IsInvitedToSpectateMyGame(hearthstoneGameAccountId))
{
str = "DisabledInviteToSpectateMe";
}
if (this.m_SpectatorIcon != null)
{
this.m_SpectatorIcon.gameObject.SetActive(str != null);
if (str != null)
{
this.m_SpectatorIcon.CurrentState = str;
this.m_AvailableIcon.SetActive(false);
this.m_BusyIcon.SetActive(false);
this.m_TavernBrawlChallengeIcon.SetActive(false);
this.m_TavernBrawlBusyIcon.SetActive(false);
}
if (this.m_SpectatorIconHighlight != null)
{
this.m_SpectatorIconHighlight.gameObject.SetActive(flag);
}
}
return(str != null);
}
private void StandUpright(bool isFriendlySide)
{
Card card = !isFriendlySide ? this.enemyActualUI.held.card : this.friendlyActualUI.held.card;
if (this.CanAnimateHeldCard(card))
{
float num = 5f;
if (!isFriendlySide && SpectatorManager.Get().IsSpectatingOpposingSide())
{
num = 0.3f;
}
object[] args = new object[] { "name", "RemoteActionHandler", "rotation", Vector3.zero, "time", num, "easetype", iTween.EaseType.easeInOutSine };
Hashtable hashtable = iTween.Hash(args);
iTween.RotateTo(card.gameObject, hashtable);
}
}
private void UpdateRecentOpponent()
{
if (!SpectatorManager.Get().IsInSpectatorMode() && (GameState.Get() != null))
{
Player opposingSidePlayer = GameState.Get().GetOpposingSidePlayer();
if (opposingSidePlayer != null)
{
BnetPlayer player = BnetPresenceMgr.Get().GetPlayer(opposingSidePlayer.GetGameAccountId());
if ((player != null) && (this.m_recentOpponent != player))
{
this.m_recentOpponent = player;
this.FireRecentOpponentEvent(this.m_recentOpponent);
}
}
}
}
public Vector3 GetCardRotation(Card card, int overrideCardCount)
{
int num = card.GetZonePosition() - 1;
if (card.IsDoNotSort())
{
num = base.GetCards().Count - 1;
}
float num2 = 0f;
float num3 = 0f;
int count = base.m_cards.Count;
if ((overrideCardCount >= 0) && (overrideCardCount < base.m_cards.Count))
{
count = overrideCardCount;
}
if (!this.enemyHand)
{
count -= TurnStartManager.Get().GetNumCardsToDraw();
}
if (this.IsHandScrunched())
{
float num5 = 40f;
if (!this.enemyHand)
{
num5 += count * 2;
}
num2 = num5 / ((float)count);
num3 = -num5 / 2f;
}
float y = 0f;
if (this.enemyHand)
{
y = (0f - (num2 * (num + 0.5f))) - num3;
}
else
{
y += (num2 * num) + num3;
}
if (this.enemyHand && SpectatorManager.Get().IsSpectatingOpposingSide())
{
y += 180f;
}
return(new Vector3(0f, y, !this.m_flipHandCards ? 354.5f : 534.5f));
}
private static void SpectatorCount_OnRollover(UIEvent evt)
{
BnetBar bar = Get();
if (bar != null)
{
string str2;
string headline = GameStrings.Get("GLOBAL_SPECTATOR_COUNT_PANEL_HEADER");
BnetGameAccountId[] spectatorPartyMembers = SpectatorManager.Get().GetSpectatorPartyMembers(true, false);
if (spectatorPartyMembers.Length == 1)
{
string playerBestName = BnetUtils.GetPlayerBestName(spectatorPartyMembers[0]);
object[] args = new object[] { playerBestName };
str2 = GameStrings.Format("GLOBAL_SPECTATOR_COUNT_PANEL_TEXT_ONE", args);
}
else
{
if (< > f__am$cache20 == null)
{
private void UpdateSide()
{
if (GameMgr.Get().IsSpectator())
{
if (this.m_gameAccountId == SpectatorManager.Get().GetSpectateeFriendlySide())
{
this.m_side = Side.FRIENDLY;
}
else
{
this.m_side = Side.OPPOSING;
}
}
else if (this.IsLocalUser())
{
this.m_side = Side.FRIENDLY;
}
else
{
this.m_side = Side.OPPOSING;
}
}
public bool AmIAvailable()
{
if (!this.m_netCacheReady)
{
return(false);
}
if (!this.m_myPlayerReady)
{
return(false);
}
if (SpectatorManager.Get().IsInSpectatorMode())
{
return(false);
}
BnetGameAccount hearthstoneGameAccount = BnetPresenceMgr.Get().GetMyPlayer().GetHearthstoneGameAccount();
if (hearthstoneGameAccount == null)
{
return(false);
}
return(hearthstoneGameAccount.CanBeInvitedToGame());
}
private void UpdateLayoutImpl(int slotMousedOver, int overrideCardCount)
{
int num = 0;
if ((((this.lastMousedOver != slotMousedOver) && (this.lastMousedOver != -1)) && ((this.lastMousedOver < base.m_cards.Count) && (base.m_cards[this.lastMousedOver] != null))) && this.CanAnimateCard(base.m_cards[this.lastMousedOver]))
{
Card card = base.m_cards[this.lastMousedOver];
iTween.Stop(card.gameObject);
if (!this.enemyHand)
{
Vector3 mouseOverCardPosition = this.GetMouseOverCardPosition(card);
Vector3 cardPosition = this.GetCardPosition(card, overrideCardCount);
card.transform.position = new Vector3(mouseOverCardPosition.x, this.centerOfHand.y, cardPosition.z + 0.5f);
card.transform.localScale = this.GetCardScale(card);
card.transform.localEulerAngles = this.GetCardRotation(card);
}
card.NotifyMousedOut();
GameLayer cardRaycast = GameLayer.Default;
if ((base.m_Side == Player.Side.OPPOSING) && SpectatorManager.Get().IsSpectatingOpposingSide())
{
cardRaycast = GameLayer.CardRaycast;
}
SceneUtils.SetLayer(card.gameObject, cardRaycast);
}
float delaySec = 0f;
for (int i = 0; i < base.m_cards.Count; i++)
{
Vector3 vector3;
Card card2 = base.m_cards[i];
if (!this.CanAnimateCard(card2))
{
continue;
}
num++;
float z = !this.m_flipHandCards ? 354.5f : 534.5f;
card2.transform.rotation = Quaternion.Euler(new Vector3(card2.transform.localEulerAngles.x, card2.transform.localEulerAngles.y, z));
float num5 = 0.5f;
if (this.m_handMoving)
{
num5 = 0.25f;
}
if (this.enemyHand)
{
num5 = 1.5f;
}
float num6 = 0.25f;
iTween.EaseType easeOutExpo = iTween.EaseType.easeOutExpo;
float transitionDelay = card2.GetTransitionDelay();
card2.SetTransitionDelay(0f);
ZoneTransitionStyle transitionStyle = card2.GetTransitionStyle();
card2.SetTransitionStyle(ZoneTransitionStyle.NORMAL);
switch (transitionStyle)
{
case ZoneTransitionStyle.SLOW:
easeOutExpo = iTween.EaseType.easeInExpo;
num6 = num5;
break;
case ZoneTransitionStyle.VERY_SLOW:
easeOutExpo = iTween.EaseType.easeInOutCubic;
num6 = 1f;
num5 = 1f;
break;
case ZoneTransitionStyle.NORMAL:
goto Label_0265;
}
card2.GetActor().TurnOnCollider();
Label_0265:
vector3 = this.GetCardPosition(card2, overrideCardCount);
Vector3 cardRotation = this.GetCardRotation(card2, overrideCardCount);
Vector3 cardScale = this.GetCardScale(card2);
if (i == slotMousedOver)
{
easeOutExpo = iTween.EaseType.easeOutExpo;
if (this.enemyHand)
{
num6 = 0.15f;
float num8 = 0.3f;
vector3 = new Vector3(vector3.x, vector3.y, vector3.z - num8);
}
else
{
float num9 = 0.5f * i;
num9 -= (0.5f * base.m_cards.Count) / 2f;
float selectCardScale = (float)this.m_SelectCardScale;
float num11 = (float)this.m_SelectCardScale;
cardRotation = new Vector3(0f, 0f, 0f);
cardScale = new Vector3(selectCardScale, cardScale.y, num11);
card2.transform.localScale = cardScale;
num5 = 4f;
float num12 = 0.1f;
vector3 = this.GetMouseOverCardPosition(card2);
float x = vector3.x;
if (this.m_handEnlarged)
{
vector3.x = Mathf.Max(vector3.x, this.m_enlargedHandCardMinX);
vector3.x = Mathf.Min(vector3.x, this.m_enlargedHandCardMaxX);
}
card2.transform.position = new Vector3((x == vector3.x) ? card2.transform.position.x : vector3.x, vector3.y, vector3.z - num12);
card2.transform.localEulerAngles = new Vector3(0f, 0f, 0f);
iTween.Stop(card2.gameObject);
easeOutExpo = iTween.EaseType.easeOutExpo;
if (CardTypeBanner.Get() != null)
{
CardTypeBanner.Get().Show(card2.GetActor());
}
InputManager.Get().SetMousedOverCard(card2);
bool showOnRight = card2.GetActor().GetMeshRenderer().bounds.center.x < base.GetComponent <BoxCollider>().bounds.center.x;
float? overrideScale = null;
Vector3?overrideOffset = null;
KeywordHelpPanelManager.Get().UpdateKeywordHelp(card2, card2.GetActor(), showOnRight, overrideScale, overrideOffset);
SceneUtils.SetLayer(card2.gameObject, GameLayer.Tooltip);
}
}
else if (this.GetStandIn(card2) != null)
{
CardStandIn standIn = this.GetStandIn(card2);
iTween.Stop(standIn.gameObject);
standIn.transform.position = vector3;
if (!card2.CardStandInIsInteractive())
{
standIn.DisableStandIn();
}
else
{
standIn.EnableStandIn();
}
}
card2.EnableTransitioningZones(true);
string tweenName = ZoneMgr.Get().GetTweenName <ZoneHand>();
object[] args = new object[] { "scale", cardScale, "delay", transitionDelay, "time", num6, "easeType", easeOutExpo, "name", tweenName };
Hashtable hashtable = iTween.Hash(args);
iTween.ScaleTo(card2.gameObject, hashtable);
object[] objArray2 = new object[] { "rotation", cardRotation, "delay", transitionDelay, "time", num6, "easeType", easeOutExpo, "name", tweenName };
Hashtable hashtable2 = iTween.Hash(objArray2);
iTween.RotateTo(card2.gameObject, hashtable2);
object[] objArray3 = new object[] { "position", vector3, "delay", transitionDelay, "time", num5, "easeType", easeOutExpo, "name", tweenName };
Hashtable hashtable3 = iTween.Hash(objArray3);
iTween.MoveTo(card2.gameObject, hashtable3);
float[] values = new float[] { delaySec, transitionDelay + num5, transitionDelay + num6 };
delaySec = Mathf.Max(values);
}
this.lastMousedOver = slotMousedOver;
if (num > 0)
{
base.StartFinishLayoutTimer(delaySec);
}
else
{
base.UpdateLayoutFinished();
}
}
public Vector3 GetCardPosition(Card card, int overrideCardCount)
{
int num = card.GetZonePosition() - 1;
if (card.IsDoNotSort())
{
num = base.GetCards().Count - 1;
}
float num2 = 0f;
float num3 = 0f;
float num4 = 0f;
int count = base.m_cards.Count;
if ((overrideCardCount >= 0) && (overrideCardCount < base.m_cards.Count))
{
count = overrideCardCount;
}
if (!this.enemyHand)
{
count -= TurnStartManager.Get().GetNumCardsToDraw();
}
if (this.IsHandScrunched())
{
num4 = 1f;
float num6 = 40f;
if (!this.enemyHand)
{
num6 += count * 2;
}
num2 = num6 / ((float)count);
num3 = -num6 / 2f;
}
float f = 0f;
if (this.enemyHand)
{
f = (0f - (num2 * (num + 0.5f))) - num3;
}
else
{
f += (num2 * num) + num3;
}
float num8 = 0f;
if ((this.enemyHand && (f < 0f)) || (!this.enemyHand && (f > 0f)))
{
num8 = (Mathf.Sin((Mathf.Abs(f) * 3.141593f) / 180f) * this.GetCardSpacing()) / 2f;
}
float x = this.centerOfHand.x - ((this.GetCardSpacing() / 2f) * ((count - 1) - (num * 2)));
if (this.m_handEnlarged && this.m_targetingMode)
{
if ((count % 2) > 0)
{
if (num < ((count + 1) / 2))
{
x -= this.m_heroWidthInHand;
}
}
else if (num < (count / 2))
{
x -= this.m_heroWidthInHand / 2f;
}
else
{
x += this.m_heroWidthInHand / 2f;
}
}
float y = this.centerOfHand.y;
float z = this.centerOfHand.z;
if (count > 1)
{
if (this.enemyHand)
{
z += ((Mathf.Pow((float)Mathf.Abs((int)(num - (count / 2))), 2f) / ((float)(4 * count))) * num4) + num8;
}
else
{
z = (this.centerOfHand.z - ((Mathf.Pow((float)Mathf.Abs((int)(num - (count / 2))), 2f) / ((float)(4 * count))) * num4)) - num8;
}
}
if (this.enemyHand && SpectatorManager.Get().IsSpectatingOpposingSide())
{
z -= 0.2f;
}
return(new Vector3(x, y, z));
}
private void ShowTooltip()
{
string str;
string str2;
BnetGameAccountId hearthstoneGameAccountId = this.m_player.GetHearthstoneGameAccountId();
SpectatorManager manager = SpectatorManager.Get();
if (manager.HasInvitedMeToSpectate(hearthstoneGameAccountId))
{
str = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_AVAILABLE_HEADER";
str2 = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_RECEIVED_INVITE_TEXT";
}
else if (manager.CanSpectate(this.m_player))
{
str = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_AVAILABLE_HEADER";
str2 = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_AVAILABLE_TEXT";
}
else if (manager.IsSpectatingMe(hearthstoneGameAccountId))
{
str = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_KICK_HEADER";
str2 = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_KICK_TEXT";
}
else if (manager.CanInviteToSpectateMyGame(hearthstoneGameAccountId))
{
if (manager.IsPlayerSpectatingMyGamesOpposingSide(hearthstoneGameAccountId))
{
str = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_INVITE_OTHER_SIDE_HEADER";
str2 = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_INVITE_OTHER_SIDE_TEXT";
}
else
{
str = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_INVITE_HEADER";
str2 = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_INVITE_TEXT";
}
}
else if (manager.IsInvitedToSpectateMyGame(hearthstoneGameAccountId))
{
str = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_INVITED_HEADER";
str2 = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_INVITED_TEXT";
}
else if (manager.IsSpectatingPlayer(hearthstoneGameAccountId))
{
str = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_SPECTATING_HEADER";
str2 = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_SPECTATING_TEXT";
}
else if (manager.HasPreviouslyKickedMeFromGame(hearthstoneGameAccountId))
{
str = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_PREVIOUSLY_KICKED_HEADER";
str2 = "GLOBAL_FRIENDLIST_SPECTATE_TOOLTIP_PREVIOUSLY_KICKED_TEXT";
}
else
{
bool flag = TavernBrawlManager.Get().ShouldNewFriendlyChallengeBeTavernBrawl();
if (flag)
{
str = "GLOBAL_FRIENDLIST_TAVERN_BRAWL_CHALLENGE_BUTTON_HEADER";
}
else
{
str = "GLOBAL_FRIENDLIST_CHALLENGE_BUTTON_HEADER";
}
if (!FriendChallengeMgr.Get().AmIAvailable())
{
str2 = "GLOBAL_FRIENDLIST_CHALLENGE_BUTTON_IM_UNAVAILABLE";
}
else if (!FriendChallengeMgr.Get().CanChallenge(this.m_player))
{
str2 = null;
TavernBrawlMission mission = TavernBrawlManager.Get().CurrentMission();
if ((flag && mission.canCreateDeck) && !TavernBrawlManager.Get().HasValidDeck())
{
str2 = "GLOBAL_FRIENDLIST_CHALLENGE_BUTTON_TAVERN_BRAWL_MUST_CREATE_DECK";
}
if (str2 == null)
{
str2 = "GLOBAL_FRIENDLIST_CHALLENGE_BUTTON_THEYRE_UNAVAILABLE";
}
}
else if (flag)
{
str2 = "GLOBAL_FRIENDLIST_TAVERN_BRAWL_CHALLENGE_BUTTON_AVAILABLE";
}
else
{
str2 = "GLOBAL_FRIENDLIST_CHALLENGE_BUTTON_AVAILABLE";
}
}
if (UniversalInputManager.Get().IsTouchMode())
{
if (GameStrings.HasKey(str + "_TOUCH"))
{
str = str + "_TOUCH";
}
if (GameStrings.HasKey(str2 + "_TOUCH"))
{
str2 = str2 + "_TOUCH";
}
}
string headline = GameStrings.Get(str);
object[] args = new object[] { this.m_player.GetBestName() };
string bodytext = GameStrings.Format(str2, args);
this.m_TooltipZone.ShowSocialTooltip(this, headline, bodytext, 75f, GameLayer.BattleNetDialog);
}
public bool IsRevealed()
{
return(this.IsFriendlySide() || SpectatorManager.Get().IsSpectatingPlayer(this.m_gameAccountId));
}
private void UpdateCardHeld()
{
Card card = this.enemyActualUI.held.card;
Card card2 = this.enemyWantedUI.held.card;
if (card != card2)
{
this.enemyActualUI.held.card = card2;
if (card != null)
{
card.MarkAsGrabbedByEnemyActionHandler(false);
}
if (this.IsCardInHand(card))
{
card.GetZone().UpdateLayout();
}
if (this.CanAnimateHeldCard(card2))
{
card2.MarkAsGrabbedByEnemyActionHandler(true);
if (SpectatorManager.Get().IsSpectatingOpposingSide())
{
this.StandUpright(false);
}
object[] args = new object[] { "name", "RemoteActionHandler", "position", Board.Get().FindBone("OpponentCardPlayingSpot").position, "time", 1f, "oncomplete", o => this.StartDrift(false), "oncompletetarget", base.gameObject };
Hashtable hashtable = iTween.Hash(args);
iTween.MoveTo(card2.gameObject, hashtable);
}
}
if (GameMgr.Get().IsSpectator())
{
Card card3 = this.friendlyActualUI.held.card;
Card card4 = this.friendlyWantedUI.held.card;
if (card3 != card4)
{
this.friendlyActualUI.held.card = card4;
if (card3 != null)
{
card3.MarkAsGrabbedByEnemyActionHandler(false);
}
if (this.IsCardInHand(card3))
{
card3.GetZone().UpdateLayout();
}
if (this.CanAnimateHeldCard(card4))
{
Hashtable hashtable2;
card4.MarkAsGrabbedByEnemyActionHandler(true);
if (card4 == this.GetFriendlyHoverCard())
{
ZoneHand zone = card4.GetZone() as ZoneHand;
if (zone != null)
{
card4.NotifyMousedOut();
Vector3 cardScale = zone.GetCardScale(card4);
object[] objArray2 = new object[] { "scale", cardScale, "time", 0.15f, "easeType", iTween.EaseType.easeOutExpo, "name", "RemoteActionHandler" };
hashtable2 = iTween.Hash(objArray2);
iTween.ScaleTo(card4.gameObject, hashtable2);
}
}
object[] objArray3 = new object[] { "name", "RemoteActionHandler", "position", Board.Get().FindBone("FriendlyCardPlayingSpot").position, "time", 1f, "oncomplete", o => this.StartDrift(true), "oncompletetarget", base.gameObject };
hashtable2 = iTween.Hash(objArray3);
iTween.MoveTo(card4.gameObject, hashtable2);
}
}
}
}
private void AssetsVersionCheckCompleted()
{
if (!string.IsNullOrEmpty(UpdateManager.Get().GetError()) && UpdateManager.Get().UpdateIsRequired())
{
Error.AddFatalLoc("GLUE_PATCHING_ERROR", new object[0]);
}
else
{
if (Network.ShouldBeConnectedToAurora())
{
BnetPresenceMgr.Get().Initialize();
BnetFriendMgr.Get().Initialize();
BnetChallengeMgr.Get().Initialize();
BnetWhisperMgr.Get().Initialize();
BnetNearbyPlayerMgr.Get().Initialize();
FriendChallengeMgr.Get().OnLoggedIn();
SpectatorManager.Get().Initialize();
if (!Options.Get().GetBool(Option.CONNECT_TO_AURORA))
{
Options.Get().SetBool(Option.CONNECT_TO_AURORA, true);
}
TutorialProgress progress = Options.Get().GetEnum <TutorialProgress>(Option.LOCAL_TUTORIAL_PROGRESS);
if (progress > TutorialProgress.NOTHING_COMPLETE)
{
this.m_waitingForSetProgress = true;
ConnectAPI.SetProgress((long)progress);
}
if (WebAuth.GetIsNewCreatedAccount())
{
AdTrackingManager.Get().TrackAccountCreated();
WebAuth.SetIsNewCreatedAccount(false);
}
}
ConnectAPI.RequestAccountLicenses();
ConnectAPI.RequestGameLicenses();
Box.Get().OnLoggedIn();
BaseUI.Get().OnLoggedIn();
InactivePlayerKicker.Get().OnLoggedIn();
HealthyGamingMgr.Get().OnLoggedIn();
DefLoader.Get().Initialize();
CollectionManager.Init();
AdventureProgressMgr.Init();
Tournament.Init();
GameMgr.Get().OnLoggedIn();
if (Network.ShouldBeConnectedToAurora())
{
StoreManager.Get().Init();
}
Network.TrackClient(Network.TrackLevel.LEVEL_INFO, Network.TrackWhat.TRACK_LOGIN_FINISHED);
Network.ResetConnectionFailureCount();
if (Network.ShouldBeConnectedToAurora())
{
ConnectAPI.DoLoginUpdate();
}
else
{
this.m_waitingForUpdateLoginComplete = false;
}
Enum[] args = new Enum[] { PresenceStatus.LOGIN };
PresenceMgr.Get().SetStatus(args);
if (SplashScreen.Get() != null)
{
SplashScreen.Get().StopPatching();
SplashScreen.Get().ShowRatings();
}
this.PreloadActors();
if (!Network.ShouldBeConnectedToAurora())
{
base.StartCoroutine(this.RegisterScreenWhenReady());
}
SceneMgr.Get().LoadShaderPreCompiler();
}
}
public static string GetZoneActor(TAG_CARDTYPE cardType, TAG_CLASS classTag, TAG_ZONE zoneTag, Player controller, TAG_PREMIUM premium)
{
switch (zoneTag)
{
case TAG_ZONE.PLAY:
if (cardType != TAG_CARDTYPE.MINION)
{
if (cardType == TAG_CARDTYPE.WEAPON)
{
return(GetNameWithPremiumType("Card_Play_Weapon", premium));
}
if (cardType == TAG_CARDTYPE.HERO)
{
return("Card_Play_Hero");
}
if (cardType == TAG_CARDTYPE.HERO_POWER)
{
return(GetNameWithPremiumType("Card_Play_HeroPower", premium));
}
if (cardType != TAG_CARDTYPE.ENCHANTMENT)
{
break;
}
return("Card_Play_Enchantment");
}
return(GetNameWithPremiumType("Card_Play_Ally", premium));
case TAG_ZONE.DECK:
case TAG_ZONE.REMOVEDFROMGAME:
case TAG_ZONE.SETASIDE:
return("Card_Invisible");
case TAG_ZONE.HAND:
if ((controller == null) || ((!controller.IsFriendlySide() && !controller.HasTag(GAME_TAG.HAND_REVEALED)) && !SpectatorManager.Get().IsSpectatingOpposingSide()))
{
return("Card_Hidden");
}
if (cardType == TAG_CARDTYPE.MINION)
{
return(GetNameWithPremiumType("Card_Hand_Ally", premium));
}
if (cardType == TAG_CARDTYPE.WEAPON)
{
return(GetNameWithPremiumType("Card_Hand_Weapon", premium));
}
if (cardType == TAG_CARDTYPE.SPELL)
{
return(GetNameWithPremiumType("Card_Hand_Ability", premium));
}
if (cardType != TAG_CARDTYPE.HERO_POWER)
{
break;
}
return(GetNameWithPremiumType("History_HeroPower", premium));
case TAG_ZONE.GRAVEYARD:
if (cardType != TAG_CARDTYPE.MINION)
{
if (cardType == TAG_CARDTYPE.WEAPON)
{
return(GetNameWithPremiumType("Card_Hand_Weapon", premium));
}
if (cardType == TAG_CARDTYPE.SPELL)
{
return(GetNameWithPremiumType("Card_Hand_Ability", premium));
}
if (cardType == TAG_CARDTYPE.HERO)
{
return("Card_Play_Hero");
}
break;
}
return(GetNameWithPremiumType("Card_Hand_Ally", premium));
case TAG_ZONE.SECRET:
if (classTag != TAG_CLASS.HUNTER)
{
if ((classTag != TAG_CLASS.MAGE) && (classTag == TAG_CLASS.PALADIN))
{
return("Card_Play_Secret_Paladin");
}
return("Card_Play_Secret_Mage");
}
return("Card_Play_Secret_Hunter");
}
Debug.LogWarning(string.Format("ActorNames.GetZoneActor() - Can't determine actor for {0}. Returning {1} instead.", cardType, "Card_Hand_Ally"));
return("Card_Hand_Ally");
}
