private void OnUpdateSquadWarSuccess(GetSquadWarStatusResponse response, object cookie)
{
SquadMsg squadMsg = SquadMsgUtils.GenerateMessageFromGetSquadWarStatusResponse(response);
this.controller.InitSquadWarState(squadMsg.CurrentSquadWarData);
Service.Get <EventManager>().SendEvent(EventId.SquadUpdateCompleted, null);
}
public void PublishMessage(string message)
{
if (string.IsNullOrEmpty(message))
{
return;
}
string message2 = message;
if (this.filter != null)
{
message2 = this.filter.Filter(message);
}
SquadMsg item = SquadMsgUtils.GenerateMessageFromChatMessage(message2);
this.list.Clear();
this.list.Add(item);
this.callback(this.list);
this.queuedMessagesToPublish.Enqueue(item);
if (this.photonChatWrapper.SessionState == PhotonChatSessionState.Disconnected)
{
this.ReconnectSession();
}
else if (this.photonChatWrapper.SessionState == PhotonChatSessionState.Connected)
{
this.StartPublishTimer();
}
}
private void OnRejectClicked(UXButton button)
{
SquadMsg message = SquadMsgUtils.CreateRejectSquadInviteMessage(this.invite.SquadId, new SquadController.ActionCallback(this.OnRejectSquadInviteComplete), null);
Service.SquadController.TakeAction(message);
Service.EventManager.SendEvent(EventId.SquadNext, null);
ProcessingScreen.Show();
}
private void PopulateSquadMsgsReceivedFromPhoton(string channelName, string[] senders, object[] messages)
{
if (senders == null && messages == null && senders.Length != messages.Length)
{
Service.Logger.Error("Cannot populate squad messages, senders and messages count mismatch!");
return;
}
if (messages.Length == 0)
{
return;
}
if (string.IsNullOrEmpty(this.messageEncryptionKey))
{
Service.Logger.Error("Failed to update received messages, message encryption key is null or blank!");
return;
}
int i = 0;
int num = messages.Length;
while (i < num)
{
string messageAndIV = messages[i] as string;
string text = ChatCryptographyUtils.DecryptMessageWithIV(messageAndIV, this.messageEncryptionKey);
object obj = null;
if (!string.IsNullOrEmpty(text) && text.StartsWith("{"))
{
obj = new JsonParser(text).Parse();
}
if (obj == null)
{
Service.Logger.WarnFormat("Decrypted chat message is invalid:{0}", new object[]
{
(text != null) ? text : string.Empty
});
}
else
{
PhotonChatMessageTO photonChatMessageTO = new PhotonChatMessageTO(obj);
if (this.filter != null)
{
photonChatMessageTO.Text = this.filter.Filter(photonChatMessageTO.Text);
}
SquadMsg squadMsg = SquadMsgUtils.GenerateMessageFromPhotonChatMessage(senders[i], photonChatMessageTO);
if (squadMsg != null)
{
if (this.IsMsgValid(squadMsg))
{
this.list.Add(squadMsg);
if (this.latestMsg == null || squadMsg.TimeSent > this.latestMsg.TimeSent)
{
this.latestMsg = squadMsg;
}
}
}
}
i++;
}
}
private void OnLeaveAndCreateSquad(object result, object cookie)
{
if (result != null)
{
ProcessingScreen.Show();
SquadMsg message = SquadMsgUtils.CreateLeaveSquadMessage(new SquadController.ActionCallback(this.OnLeaveComplete), null);
Service.SquadController.TakeAction(message);
}
}
public void SendTroopRequest(string requestText, bool isWarRequest = false)
{
bool flag = true;
bool payToSkip = false;
uint serverTime = Service.ServerAPI.ServerTime;
SquadController squadController = Service.SquadController;
uint troopRequestDate;
if (isWarRequest)
{
troopRequestDate = squadController.StateManager.WarTroopRequestDate;
}
else
{
troopRequestDate = squadController.StateManager.TroopRequestDate;
}
int troopRequestCrystalCost = SquadUtils.GetTroopRequestCrystalCost(serverTime, troopRequestDate);
if (troopRequestCrystalCost > 0)
{
payToSkip = true;
flag = GameUtils.SpendCrystals(troopRequestCrystalCost);
}
if (flag)
{
string empty = string.Empty;
string itemId = "requestTroops";
int itemCount = 1;
string type = "squad_action";
string subType = "consumable";
Service.DMOAnalyticsController.LogInAppCurrencyAction(-troopRequestCrystalCost, empty, itemId, itemCount, type, subType);
if (string.IsNullOrEmpty(requestText))
{
if (isWarRequest)
{
requestText = Service.Lang.Get("REQUEST_WAR_TROOPS_DEFAULT", new object[0]);
}
else
{
requestText = Service.Lang.Get("REQUEST_TROOPS_DEFAULT", new object[0]);
}
}
SquadMsg message;
if (isWarRequest)
{
message = SquadMsgUtils.CreateRequestWarTroopsMessage(payToSkip, troopRequestCrystalCost, requestText);
Service.EventManager.SendEvent(EventId.SquadWarTroopsRequestStartedByCurrentPlayer, null);
}
else
{
message = SquadMsgUtils.CreateRequestTroopsMessage(payToSkip, troopRequestCrystalCost, requestText);
}
this.TakeAction(message);
}
Service.EventManager.SendEvent(EventId.SquadEdited, null);
}
private void OnLeaveAndJoinSquad(object result, object cookie)
{
if (result != null)
{
ProcessingScreen.Show();
SquadMsg message = SquadMsgUtils.CreateLeaveSquadMessage(new SquadController.ActionCallback(this.OnLeaveComplete), null);
Service.Get <SquadController>().TakeAction(message);
return;
}
this.button.Enabled = true;
}
private void ActualCreateSquad()
{
Service.EventManager.SendEvent(EventId.SquadCredits, null);
string text = this.inputName.Text;
string text2 = this.inputDescription.Text;
SquadMsg message = SquadMsgUtils.CreateNewSquadMessage(text, text2, this.symbolName, this.scoreReq, this.openEnrollment, new SquadController.ActionCallback(this.OnCreateComplete), text);
Service.SquadController.TakeAction(message);
this.buttonPurchase.Enabled = false;
base.AllowClose = false;
ProcessingScreen.Show();
}
private void OnAlertDemoteMemberResult(object result, object cookie)
{
if (result == null)
{
return;
}
SquadMember squadMember = cookie as SquadMember;
SquadMsg message = SquadMsgUtils.CreateDemoteMemberMessage(squadMember.MemberID, new SquadController.ActionCallback(this.OnMemberChangeComplete), squadMember);
SquadController squadController = Service.SquadController;
squadController.TakeAction(message);
ProcessingScreen.Show();
}
private void SendRequest()
{
Service.EventManager.SendEvent(EventId.SquadEdited, null);
string text = this.input.Text;
if (string.IsNullOrEmpty(text))
{
text = this.lang.Get("APPLY_REQUEST_DEFAULT", new object[0]);
}
SquadMsg message = SquadMsgUtils.CreateApplyToJoinSquadMessage(this.squad.SquadID, text, this.callback, this.cookie);
Service.SquadController.TakeAction(message);
Service.ScreenController.CloseAll();
}
private void OnEditClicked(UXButton button)
{
bool flag = this.CheckForValidInput(false);
if (flag)
{
Service.EventManager.SendEvent(EventId.SquadEdited, null);
string text = this.inputDescription.Text;
SquadMsg message = SquadMsgUtils.CreateEditSquadMessage(text, this.symbolName, this.scoreReq, this.openEnrollment, new SquadController.ActionCallback(this.OnEditComplete), null);
Service.SquadController.TakeAction(message);
this.buttonEdit.Enabled = false;
base.AllowClose = false;
ProcessingScreen.Show();
}
}
private void OnActionCommandSuccess(AbstractResponse response, object cookie)
{
SquadMsg squadMsg = (SquadMsg)cookie;
SqmActionData actionData = squadMsg.ActionData;
SquadAction type = actionData.Type;
SquadMsg squadMsg2;
switch (type)
{
case SquadAction.Create:
case SquadAction.Join:
squadMsg2 = SquadMsgUtils.GenerateMessageFromSquadResponse((SquadResponse)response, Service.LeaderboardController);
goto IL_B5;
case SquadAction.Leave:
squadMsg2 = squadMsg;
this.controller.WarManager.ClearSquadWarData();
goto IL_B5;
case SquadAction.Edit:
case SquadAction.ApplyToJoin:
IL_35:
switch (type)
{
case SquadAction.DonateTroops:
case SquadAction.DonateWarTroops:
squadMsg2 = SquadMsgUtils.GenerateMessageFromTroopDonateResponse((TroopDonateResponse)response);
Service.TroopDonationTrackController.UpdateTroopDonationProgress((TroopDonateResponse)response);
goto IL_B5;
}
squadMsg2 = squadMsg;
goto IL_B5;
case SquadAction.AcceptApplicationToJoin:
squadMsg2 = SquadMsgUtils.GenerateMessageFromSquadMemberResponse((SquadMemberResponse)response);
goto IL_B5;
}
goto IL_35;
IL_B5:
squadMsg2.BISource = squadMsg.BISource;
this.controller.OnPlayerActionSuccess(actionData.Type, squadMsg2);
if (actionData.Callback != null)
{
actionData.Callback(true, actionData.Cookie);
}
}
private void OnDonateConfirm(UXButton button)
{
SquadMsg message;
if (this.isWarRequest)
{
message = SquadMsgUtils.CreateWarDonateMessage(this.recipientId, this.troopsToDonate, this.GetNumberOfTroopsDonated(), this.requestId, new SquadController.ActionCallback(this.OnDonationComplete), null);
}
else
{
message = SquadMsgUtils.CreateDonateMessage(this.recipientId, this.troopsToDonate, this.GetNumberOfTroopsDonated(), this.requestId, new SquadController.ActionCallback(this.OnDonationComplete), null);
}
SquadController squadController = Service.Get <SquadController>();
squadController.TakeAction(message);
ProcessingScreen.Show();
}
public override void Perform()
{
Service.BotRunner.Log("Donating Troops", new object[0]);
Service.BotRunner.Performing = true;
SquadMsg squadMsg = (SquadMsg)Service.BotRunner.BotProperties[(string)this.arg];
Dictionary <string, int> dictionary = new Dictionary <string, int>();
CurrentPlayer currentPlayer = Service.CurrentPlayer;
string text = (currentPlayer.Faction != FactionType.Empire) ? "Soldier" : "Storm";
int level = currentPlayer.UnlockedLevels.Troops.GetLevel(text);
TroopTypeVO byLevel = Service.TroopUpgradeCatalog.GetByLevel(text, level);
int num = 4;
dictionary.Add(byLevel.Uid, num);
SquadMsg message = SquadMsgUtils.CreateDonateMessage(squadMsg.OwnerData.PlayerId, dictionary, num, squadMsg.NotifId, new SquadController.ActionCallback(this.OnComplete), squadMsg);
SquadController squadController = Service.SquadController;
squadController.TakeAction(message);
}
protected override void OnClicked(UXButton btn)
{
if (!base.CheckForValidInput())
{
return;
}
string text = this.input.Text;
if (string.IsNullOrEmpty(text))
{
text = this.lang.Get("BATTLE_REPLAY_SHARE_DEFAULT", new object[0]);
}
SquadMsg message = SquadMsgUtils.CreateShareReplayMessage(text, this.battleEntry);
SquadController squadController = Service.SquadController;
squadController.TakeAction(message);
this.Close(null);
}
private void OnInviteToSquadClicked(UXButton button)
{
this.secondaryButton.Enabled = false;
string fbFriendId = null;
string fbAccessToken = null;
Dictionary <string, SocialFriendData> playerIdToFriendData = Service.ISocialDataController.PlayerIdToFriendData;
SocialFriendData socialFriendData = null;
if (playerIdToFriendData != null && playerIdToFriendData.TryGetValue(this.player.PlayerID, out socialFriendData))
{
fbFriendId = socialFriendData.Id;
fbAccessToken = AccessToken.CurrentAccessToken.TokenString;
}
SquadMsg message = SquadMsgUtils.CreateSendInviteMessage(this.player.PlayerID, fbFriendId, fbAccessToken, new SquadController.ActionCallback(this.OnInviteToSquadComplete), null);
Service.SquadController.TakeAction(message);
Service.EventManager.SendEvent(EventId.SquadNext, null);
ProcessingScreen.Show();
}
protected override void PopulateSquadMsgsReceived(object response)
{
string text = response as string;
if (text == null)
{
return;
}
text = text.Replace("}{", "},{");
text = "[" + text + "]";
SquadMsg squadMsg = null;
object obj = new JsonParser(text).Parse();
List <object> list = obj as List <object>;
if (list != null)
{
int i = 0;
int count = list.Count;
while (i < count)
{
SquadMsg squadMsg2 = SquadMsgUtils.GenerateMessageFromChatObject(list[i]);
if (squadMsg2 != null && this.IsMsgValid(squadMsg2))
{
this.list.Add(squadMsg2);
if (squadMsg == null || squadMsg2.TimeSent > squadMsg.TimeSent)
{
squadMsg = squadMsg2;
}
}
i++;
}
}
if (squadMsg != null && squadMsg.ChatData != null)
{
string text2 = WWW.EscapeURL(squadMsg.ChatData.Time).Replace("+", "%20");
this.sessionTimeTag = string.Format("&tag={0}&time={1}", new object[]
{
squadMsg.ChatData.Tag,
text2
});
}
}
private void OnAlertLeaveResult(object result, object cookie)
{
if (result != null)
{
SquadMsg message = SquadMsgUtils.CreateLeaveSquadMessage(new SquadController.ActionCallback(this.OnLeaveSquadComplete), null);
Service.SquadController.TakeAction(message);
if (Service.GameStateMachine.CurrentState is WarBoardState)
{
SquadWarScreen highestLevelScreen = Service.ScreenController.GetHighestLevelScreen <SquadWarScreen>();
if (highestLevelScreen != null)
{
highestLevelScreen.CloseSquadWarScreen(null);
}
}
}
else
{
this.screen.ShowSquadSlideButton();
}
}
private void OnShareReplayClicked(UXButton btn)
{
CurrentPlayer currentPlayer = Service.Get <CurrentPlayer>();
BattleEntry latestValidPvPBattle = currentPlayer.BattleHistory.GetLatestValidPvPBattle();
if (latestValidPvPBattle != null)
{
string text = this.shareInputBox.Text;
if (string.IsNullOrEmpty(text))
{
text = this.defaultShareText;
}
SquadMsg message = SquadMsgUtils.CreateSendReplayMessage(latestValidPvPBattle.RecordID, text);
SquadController squadController = Service.Get <SquadController>();
squadController.TakeAction(message);
this.shareInputBox.Text = string.Empty;
this.shareInputBox.InitText(this.defaultShareText);
btn.Enabled = false;
this.shareButtonTimer = Service.Get <ViewTimerManager>().CreateViewTimer(5f, false, new TimerDelegate(this.OnShareButtonTimer), btn);
}
}
public void PublishMessage(string message)
{
if (string.IsNullOrEmpty(message))
{
return;
}
SquadMsg item = SquadMsgUtils.GenerateMessageFromChatMessage(message);
this.list.Clear();
this.list.Add(item);
this.callback(this.list);
string item2 = string.Format("https://startswin-prod-chat-manager.playdom.com/dsg/chat/v1/strtw/postMessage?session={0}&message={1}", new object[]
{
this.signedSession,
WWW.EscapeURL(message)
});
this.queuedPublishUrls.Enqueue(item2);
if (this.publishTimerId == 0u)
{
this.publishTimerId = Service.Get <ViewTimerManager>().CreateViewTimer(this.publishTimerDelay, true, new TimerDelegate(this.OnPublishTimer), null);
}
Service.Get <EventManager>().SendEvent(EventId.SquadChatSent, null);
}
protected override void PopulateSquadMsgsReceived(object response)
{
SquadNotifsResponse squadNotifsResponse = (SquadNotifsResponse)response;
List <object> notifs = squadNotifsResponse.Notifs;
if (notifs != null)
{
int i = 0;
int count = notifs.Count;
while (i < count)
{
SquadMsg squadMsg = SquadMsgUtils.GenerateMessageFromNotifObject(notifs[i]);
if (squadMsg != null)
{
this.list.Add(squadMsg);
if (squadMsg.TimeSent > this.request.Since)
{
this.request.Since = squadMsg.TimeSent;
}
}
i++;
}
}
}
public void ActualJoinSquad()
{
SquadMsg message = SquadMsgUtils.CreateJoinSquadMessage(this.squad.SquadID, this.biSource, new SquadController.ActionCallback(this.OnJoinComplete), null);
Service.SquadController.TakeAction(message);
}
public void TakeAction(SquadMsg message)
{
switch (message.ActionData.Type)
{
case SquadAction.Create:
this.SendCommandRequest <CreateSquadRequest, SquadResponse>(new CreateSquadCommand(SquadMsgUtils.GenerateCreateSquadRequest(message)), message);
return;
case SquadAction.Join:
this.SendCommandRequest <SquadIDRequest, SquadResponse>(new JoinSquadCommand(SquadMsgUtils.GenerateSquadIdRequest(message)), message);
return;
case SquadAction.Leave:
this.SendCommandRequest <PlayerIdRequest, DefaultResponse>(new LeaveSquadCommand(SquadMsgUtils.GeneratePlayerIdRequest(message)), message);
return;
case SquadAction.Edit:
this.SendCommandRequest <EditSquadRequest, DefaultResponse>(new EditSquadCommand(SquadMsgUtils.GenerateEditSquadRequest(message)), message);
return;
case SquadAction.ApplyToJoin:
this.SendCommandRequest <ApplyToSquadRequest, DefaultResponse>(new ApplyToSquadCommand(SquadMsgUtils.GenerateApplyToSquadRequest(message)), message);
return;
case SquadAction.AcceptApplicationToJoin:
this.SendCommandRequest <MemberIdRequest, SquadMemberResponse>(new AcceptSquadRequestCommand(SquadMsgUtils.GenerateMemberIdRequest(message)), message);
return;
case SquadAction.RejectApplicationToJoin:
this.SendCommandRequest <MemberIdRequest, DefaultResponse>(new RejectSquadRequestCommand(SquadMsgUtils.GenerateMemberIdRequest(message)), message);
return;
case SquadAction.SendInviteToJoin:
this.SendCommandRequest <SendSquadInviteRequest, DefaultResponse>(new SendSquadInviteCommand(SquadMsgUtils.GenerateSendInviteRequest(message)), message);
return;
case SquadAction.AcceptInviteToJoin:
this.SendCommandRequest <SquadIDRequest, DefaultResponse>(new AcceptSquadInviteCommand(SquadMsgUtils.GenerateSquadIdRequest(message)), message);
return;
case SquadAction.RejectInviteToJoin:
this.SendCommandRequest <SquadIDRequest, DefaultResponse>(new RejectSquadInviteCommand(SquadMsgUtils.GenerateSquadIdRequest(message)), message);
return;
case SquadAction.PromoteMember:
this.SendCommandRequest <MemberIdRequest, DefaultResponse>(new PromoteSquadMemberCommand(SquadMsgUtils.GenerateMemberIdRequest(message)), message);
return;
case SquadAction.DemoteMember:
this.SendCommandRequest <MemberIdRequest, DefaultResponse>(new DemoteSquadMemberCommand(SquadMsgUtils.GenerateMemberIdRequest(message)), message);
return;
case SquadAction.RemoveMember:
this.SendCommandRequest <MemberIdRequest, DefaultResponse>(new RemoveSquadMemberCommand(SquadMsgUtils.GenerateMemberIdRequest(message)), message);
return;
case SquadAction.RequestTroops:
this.SendCommandRequest <TroopSquadRequest, DefaultResponse>(new SquadTroopRequestCommand(SquadMsgUtils.GenerateTroopRequest(message)), message);
return;
case SquadAction.DonateTroops:
this.SendCommandRequest <TroopDonateRequest, TroopDonateResponse>(new SquadTroopDonateCommand(SquadMsgUtils.GenerateTroopDonateRequest(message)), message);
return;
case SquadAction.RequestWarTroops:
this.SendCommandRequest <TroopSquadRequest, DefaultResponse>(new SquadWarTroopRequestCommand(SquadMsgUtils.GenerateTroopRequest(message)), message);
return;
case SquadAction.DonateWarTroops:
this.SendCommandRequest <TroopDonateRequest, TroopDonateResponse>(new SquadWarTroopDonateCommand(SquadMsgUtils.GenerateTroopDonateRequest(message)), message);
return;
case SquadAction.ShareReplay:
this.SendCommandRequest <ShareReplayRequest, DefaultResponse>(new ShareReplayCommand(SquadMsgUtils.GenerateShareReplayRequest(message)), message);
return;
case SquadAction.ShareVideo:
this.SendCommandRequest <ShareVideoRequest, DefaultResponse>(new ShareVideoCommand(SquadMsgUtils.GenerateShareVideoRequest(message)), message);
return;
case SquadAction.StartWarMatchmaking:
this.SendCommandRequest <SquadWarStartMatchmakingRequest, DefaultResponse>(new SquadWarStartMatchmakingCommand(SquadMsgUtils.GenerateStartWarMatchmakingRequest(message)), message);
return;
case SquadAction.CancelWarMatchmaking:
this.SendCommandRequest <PlayerIdChecksumRequest, DefaultResponse>(new SquadWarCancelMatchmakingCommand(SquadMsgUtils.GeneratePlayerIdChecksumRequest(message)), message);
return;
default:
return;
}
}
private void OnVideoDetailsSquad(VideoData videoData, string userMessage)
{
SquadMsg message = SquadMsgUtils.CreateShareVideoMessage(videoData.Guid, userMessage);
Service.Get <SquadController>().TakeAction(message);
}
public EatResponse OnEvent(EventId id, object cookie)
{
if (id <= EventId.SquadScreenOpenedOrClosed)
{
if (id != EventId.GameStateChanged)
{
if (id == EventId.SquadScreenOpenedOrClosed)
{
this.UpdatePollFrequency();
}
}
else
{
SquadWarManager warManager = this.controller.WarManager;
if (this.IsValidUpdateGameState() && warManager.WarExists())
{
this.UpdateSquadWar(warManager.CurrentSquadWar.WarId, true);
Service.Get <EventManager>().UnregisterObserver(this, EventId.GameStateChanged);
}
}
}
else if (id != EventId.SquadUpdated)
{
if (id != EventId.SquadServerMessage)
{
if (id == EventId.WarPhaseChanged)
{
SquadWarStatusType squadWarStatusType = (SquadWarStatusType)cookie;
this.UpdateCurrentSquadWar();
if (squadWarStatusType == SquadWarStatusType.PhaseCooldown)
{
this.controller.UpdateCurrentSquad();
}
}
}
else
{
SquadServerMessage squadServerMessage = (SquadServerMessage)cookie;
if (squadServerMessage.Messages != null)
{
if (this.serverMessages == null)
{
this.serverMessages = new List <SquadMsg>();
}
else
{
this.serverMessages.Clear();
}
uint num = 0u;
int i = 0;
int count = squadServerMessage.Messages.Count;
while (i < count)
{
SquadMsg squadMsg = SquadMsgUtils.GenerateMessageFromServerMessageObject(squadServerMessage.Messages[i]);
if (squadMsg != null)
{
this.serverMessages.Add(squadMsg);
if (!string.IsNullOrEmpty(squadMsg.NotifId) && squadMsg.TimeSent > num)
{
num = squadMsg.TimeSent;
}
}
i++;
}
if (num > 0u)
{
this.notifAdapter.ResetPollTimer(num);
}
this.OnNewSquadMsgs(this.serverMessages);
}
}
}
else if (cookie == null)
{
this.DisablePolling();
}
else
{
this.EnablePolling();
}
return(EatResponse.NotEaten);
}
public void OnNewSquadMsgsReceived(List <SquadMsg> msgs)
{
bool flag = false;
Squad currentSquad = this.StateManager.GetCurrentSquad();
bool flag2 = false;
string playerId = Service.CurrentPlayer.PlayerId;
int i = 0;
int count = msgs.Count;
while (i < count)
{
SquadMsg squadMsg = msgs[i];
uint timeForNewMsgFiltering = this.GetTimeForNewMsgFiltering(squadMsg);
if (squadMsg.TimeSent >= timeForNewMsgFiltering)
{
bool flag3 = squadMsg.OwnerData == null || squadMsg.OwnerData.PlayerId == null;
bool flag4 = squadMsg.OwnerData != null && squadMsg.OwnerData.PlayerId == playerId;
switch (squadMsg.Type)
{
case SquadMsgType.Join:
case SquadMsgType.InviteAccepted:
case SquadMsgType.Leave:
flag = true;
break;
case SquadMsgType.JoinRequestAccepted:
{
string text = (squadMsg.SquadData == null) ? null : squadMsg.SquadData.Id;
if (flag4 && !string.IsNullOrEmpty(text))
{
this.StateManager.OnSquadJoinApplicationAccepted(text);
Squad currentSquad2 = this.StateManager.GetCurrentSquad();
this.ClearPrefsForNewSquad(currentSquad2.Level);
}
flag = true;
break;
}
case SquadMsgType.JoinRequestRejected:
{
string text2 = (squadMsg.SquadData == null) ? null : squadMsg.SquadData.Id;
if (flag3 && !string.IsNullOrEmpty(text2))
{
this.StateManager.OnSquadJoinApplicationRejected(text2);
}
break;
}
case SquadMsgType.Ejected:
if (flag3)
{
this.LeaveSquad(Service.Lang.Get("CURRENT_PLAYER_EJECTED", new object[0]));
}
else
{
SquadUtils.RemoveSquadMember(currentSquad, squadMsg.OwnerData.PlayerId);
}
flag = true;
break;
case SquadMsgType.Promotion:
case SquadMsgType.Demotion:
{
SquadRole role = (squadMsg.MemberData == null) ? SquadRole.Member : squadMsg.MemberData.MemberRole;
if (flag4)
{
this.StateManager.Role = role;
}
SquadUtils.SetSquadMemberRole(currentSquad, squadMsg.OwnerData.PlayerId, role);
break;
}
case SquadMsgType.TroopDonation:
if (squadMsg.DonationData != null && squadMsg.DonationData.RecipientId == playerId)
{
if (!string.IsNullOrEmpty(squadMsg.DonationData.RequestId))
{
SquadMsg msgById = this.MsgManager.GetMsgById(squadMsg.DonationData.RequestId);
if (msgById != null && msgById.RequestData != null && msgById.RequestData.IsWarRequest)
{
flag = true;
break;
}
}
string text3 = (squadMsg.OwnerData == null) ? null : squadMsg.OwnerData.PlayerId;
Dictionary <string, int> donations = squadMsg.DonationData.Donations;
if (text3 != null && donations != null)
{
SquadMember squadMemberById = SquadUtils.GetSquadMemberById(currentSquad, text3);
string donorName = (squadMemberById == null) ? null : squadMemberById.MemberName;
this.StateManager.OnSquadTroopsReceived(donations, text3, donorName);
}
}
break;
case SquadMsgType.WarMatchMakingBegin:
flag = true;
this.WarManager.OnWarMatchMakingBegin();
break;
case SquadMsgType.WarMatchMakingCancel:
if (!flag4)
{
this.WarManager.CancelMatchMaking();
}
flag = true;
break;
case SquadMsgType.WarStarted:
case SquadMsgType.WarBuffBaseAttackStart:
case SquadMsgType.WarBuffBaseAttackComplete:
case SquadMsgType.WarPlayerAttackStart:
case SquadMsgType.WarPlayerAttackComplete:
case SquadMsgType.WarEnded:
this.WarManager.HandleWarEventMsg(squadMsg);
break;
case SquadMsgType.WarPrepared:
flag = true;
break;
case SquadMsgType.SquadLevelUp:
flag2 = true;
this.OnSquadLeveledUp(squadMsg);
break;
case SquadMsgType.PerkUnlocked:
flag2 = true;
this.OnPerkUnlocked(squadMsg);
break;
case SquadMsgType.PerkUpgraded:
flag2 = true;
this.OnPerkUpgraded(squadMsg);
break;
case SquadMsgType.PerkInvest:
flag2 = true;
this.OnPerkInvestment(squadMsg);
break;
case SquadMsgType.Invite:
if (squadMsg.FriendInviteData != null && flag3)
{
SquadInvite invite = SquadMsgUtils.GenerateSquadInvite(squadMsg);
this.StateManager.AddSquadInvite(invite);
}
break;
case SquadMsgType.InviteRejected:
{
string text4 = (squadMsg.FriendInviteData == null) ? null : squadMsg.FriendInviteData.PlayerId;
if (text4 != null && flag3)
{
this.StateManager.PlayersInvitedToSquad.Remove(text4);
}
break;
}
}
SquadMsgType[] array = null;
switch (squadMsg.Type)
{
case SquadMsgType.JoinRequestAccepted:
case SquadMsgType.JoinRequestRejected:
array = new SquadMsgType[]
{
SquadMsgType.JoinRequest
};
break;
case SquadMsgType.Leave:
case SquadMsgType.Ejected:
array = new SquadMsgType[]
{
SquadMsgType.JoinRequest,
SquadMsgType.ShareBattle,
SquadMsgType.TroopRequest
};
break;
}
if (array != null && squadMsg.OwnerData != null)
{
this.MsgManager.RemoveMsgsByType(squadMsg.OwnerData.PlayerId, array);
}
}
i++;
}
if (flag2)
{
Service.PerkViewController.UpdateLastViewedPerkTime();
}
if (flag)
{
this.UpdateCurrentSquad();
}
}
