public static PlayerIdRequest GeneratePlayerIdRequest(SquadMsg message)
{
return(new PlayerIdRequest
{
PlayerId = message.OwnerData.PlayerId
});
}
public static SquadMsg CreatePromoteMemberMessage(string memberId, SquadController.ActionCallback callback, object cookie)
{
SquadMsg squadMsg = SquadMsgUtils.CreateMemberIdMessage(memberId, SquadAction.PromoteMember, callback, cookie);
squadMsg.MemberData.MemberRole = SquadRole.Officer;
return(squadMsg);
}
public static SquadMsg CreateAcceptJoinRequestMessage(string requesterId, string biSource, SquadController.ActionCallback callback, object cookie)
{
SquadMsg squadMsg = SquadMsgUtils.CreateMemberIdMessage(requesterId, SquadAction.AcceptApplicationToJoin, callback, cookie);
squadMsg.BISource = biSource;
return(squadMsg);
}
private void TrimMessages(List <SquadMsg> msgs, List <SquadMsg> msgsToProcess)
{
List <SquadMsg> list = new List <SquadMsg>();
for (int i = msgs.Count - 1 - this.controller.MessageLimit; i >= 0; i--)
{
SquadMsg squadMsg = msgs[i];
if (squadMsg.Type != SquadMsgType.TroopDonation)
{
list.Add(squadMsg);
if (!string.IsNullOrEmpty(squadMsg.NotifId) && this.linkedMsgs.ContainsKey(squadMsg.NotifId))
{
List <SquadMsg> list2 = this.linkedMsgs[squadMsg.NotifId];
if (list2 != null)
{
list.AddRange(list2);
}
}
}
}
int j = 0;
int count = list.Count;
while (j < count)
{
SquadMsg squadMsg2 = list[j];
this.RemoveMsg(squadMsg2, false);
msgsToProcess.Remove(squadMsg2);
j++;
}
}
public static SquadMsg CreateJoinSquadMessage(string squadId, string biSource, SquadController.ActionCallback callback, object cookie)
{
SquadMsg squadMsg = SquadMsgUtils.CreateSquadMessage(squadId, SquadAction.Join, callback, cookie);
squadMsg.BISource = biSource;
return(squadMsg);
}
private void OnSetupChatDisplayTimer(uint timerId, object cookie)
{
if (this.chatDisplay != null)
{
List <SquadMsg> existingMessages = Service.SquadController.MsgManager.GetExistingMessages();
int count = existingMessages.Count;
int num = count - this.numExistingMsgsProcessed;
if (num > 10)
{
num = 10;
}
if (num > 0)
{
int i = this.numExistingMsgsProcessed;
int num2 = this.numExistingMsgsProcessed + num;
while (i < num2)
{
SquadMsg item = existingMessages[i];
if (!this.existingMsgsProcessed.Contains(item))
{
this.numExistingMsgsProcessed++;
this.chatDisplay.ProcessMessage(existingMessages[i], false);
this.existingMsgsProcessed.Add(existingMessages[i]);
}
i++;
}
}
else
{
this.KillExistingTimers();
this.chatDisplay.OnExistingMessagesSetup();
ProcessingScreen.Hide();
}
}
}
private void OnPerkUpgraded(SquadMsg msg)
{
StaticDataController staticDataController = Service.StaticDataController;
Squad currentSquad = Service.SquadController.StateManager.GetCurrentSquad();
if (currentSquad == null)
{
Service.Logger.Error("SquadController.OnPerkUpgraded: Current Squad Null");
return;
}
SquadPerks perks = currentSquad.Perks;
string perkUId = msg.PerkData.PerkUId;
PerkVO optional = staticDataController.GetOptional <PerkVO>(perkUId);
if (optional == null)
{
Service.Logger.ErrorFormat("SquadController.OnPerkUpgraded: Given Perk is Null {0}", new object[]
{
perkUId
});
return;
}
perks.UpdateUnlockedPerk(perkUId);
Service.PerkViewController.AddToPerkBadgeList(perkUId);
Service.EventManager.SendEvent(EventId.SquadPerkUpdated, null);
Service.EventManager.SendEvent(EventId.PerkUpgraded, optional);
}
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 OnUpdateSquadWarSuccess(GetSquadWarStatusResponse response, object cookie)
{
SquadMsg squadMsg = SquadMsgUtils.GenerateMessageFromGetSquadWarStatusResponse(response);
this.controller.InitSquadWarState(squadMsg.CurrentSquadWarData);
Service.Get <EventManager>().SendEvent(EventId.SquadUpdateCompleted, null);
}
private bool IsMsgValid(SquadMsg msg)
{
CurrentPlayer currentPlayer = Service.CurrentPlayer;
if (msg.OwnerData != null && this.encryptedPlayerId == msg.OwnerData.PlayerId && currentPlayer.LoginTime < msg.TimeSent)
{
return(false);
}
if (GameConstants.PHOTON_CHAT_COMPLEX_COMPARE_ENABLED)
{
if (this.latestMsg != null)
{
bool flag = msg.TimeSent < this.latestMsg.TimeSent;
bool flag2 = msg.TimeSent == this.latestMsg.TimeSent;
bool flag3 = msg.ChatData != null && this.latestMsg.ChatData != null && msg.ChatData.Message == this.latestMsg.ChatData.Message;
bool flag4 = msg.OwnerData != null && this.latestMsg.OwnerData != null && msg.OwnerData.PlayerId == this.latestMsg.OwnerData.PlayerId;
if (flag || (flag2 && flag3 && flag4))
{
return(false);
}
}
}
else if (this.latestMsg != null && msg.TimeSent <= this.latestMsg.TimeSent)
{
return(false);
}
return(true);
}
public void RemoveMsgsByType(string playerId, SquadMsgType[] types)
{
if (types == null)
{
return;
}
for (int i = this.msgs.Count - 1; i >= 0; i--)
{
SquadMsg squadMsg = this.msgs[i];
if (squadMsg.OwnerData != null && squadMsg.OwnerData.PlayerId == playerId)
{
int j = 0;
int num = types.Length;
while (j < num)
{
if (squadMsg.Type == types[j])
{
this.RemoveMsg(squadMsg, true);
break;
}
j++;
}
}
}
}
private void CountChatMessages()
{
this.msgCount = 0;
this.requestCount = 0;
this.replayCount = 0;
this.updateCount = 0;
this.videoCount = 0;
this.totalChatCount = 0;
SquadController squadController = Service.Get <SquadController>();
List <SquadMsg> existingMessages = squadController.MsgManager.GetExistingMessages();
CurrentPlayer currentPlayer = Service.Get <CurrentPlayer>();
int i = 0;
int count = existingMessages.Count;
while (i < count)
{
SquadMsg squadMsg = existingMessages[i];
if (squadMsg != null && squadMsg.OwnerData != null && squadMsg.OwnerData.PlayerId != currentPlayer.PlayerId && squadMsg.TimeSent > this.GetLastViewedTimeByMessageType(squadMsg.Type))
{
this.IncrementBadgeByMessageType(squadMsg.Type);
}
i++;
}
this.totalChatCount = this.msgCount + this.requestCount + this.replayCount + this.updateCount + this.videoCount;
}
public static MemberIdRequest GenerateMemberIdRequest(SquadMsg message)
{
return(new MemberIdRequest
{
PlayerId = message.OwnerData.PlayerId,
MemberId = message.MemberData.MemberId
});
}
public static SquadIDRequest GenerateSquadIdRequest(SquadMsg message)
{
return(new SquadIDRequest
{
SquadId = message.SquadData.Id,
PlayerId = message.OwnerData.PlayerId
});
}
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++;
}
}
public static TroopSquadRequest GenerateTroopRequest(SquadMsg message)
{
return(new TroopSquadRequest
{
PlayerId = message.OwnerData.PlayerId,
PayToSkip = message.RequestData.PayToSkip,
Message = WWW.EscapeURL(message.RequestData.Text)
});
}
public static ShareReplayRequest GenerateShareReplayRequest(SquadMsg message)
{
return(new ShareReplayRequest
{
PlayerId = message.OwnerData.PlayerId,
BattleId = message.ReplayData.BattleId,
Message = WWW.EscapeURL(message.ReplayData.Text)
});
}
public static SquadInvite GenerateSquadInvite(SquadMsg message)
{
return(new SquadInvite
{
SquadId = message.SquadData.Id,
SenderId = message.FriendInviteData.SenderId,
SenderName = message.FriendInviteData.SenderName
});
}
public static ApplyToSquadRequest GenerateApplyToSquadRequest(SquadMsg message)
{
return(new ApplyToSquadRequest
{
SquadId = message.SquadData.Id,
PlayerId = message.OwnerData.PlayerId,
Message = WWW.EscapeURL(message.RequestData.Text)
});
}
public static CreateSquadRequest GenerateCreateSquadRequest(SquadMsg message)
{
SqmSquadData squadData = message.SquadData;
return(new CreateSquadRequest(WWW.EscapeURL(squadData.Name), WWW.EscapeURL(squadData.Desc), squadData.Icon, squadData.MinTrophies, squadData.Open)
{
PlayerId = message.OwnerData.PlayerId
});
}
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);
}
}
private void OnActionCommandFailure(uint status, object cookie)
{
SquadMsg squadMsg = (SquadMsg)cookie;
this.controller.OnPlayerActionFailure(squadMsg, status);
if (squadMsg.ActionData.Callback != null)
{
squadMsg.ActionData.Callback(false, cookie);
}
}
private SquadMsg GetParentMsg(SquadMsg msg)
{
SquadMsg result = null;
if (msg.Type == SquadMsgType.TroopDonation && msg.DonationData != null && !string.IsNullOrEmpty(msg.DonationData.RequestId) && this.msgsByIds.ContainsKey(msg.DonationData.RequestId))
{
result = this.msgsByIds[msg.DonationData.RequestId];
}
return(result);
}
private static SquadMsg CreateSquadMessage(string squadId, SquadAction action, SquadController.ActionCallback callback, object cookie)
{
SqmSquadData sqmSquadData = new SqmSquadData();
sqmSquadData.Id = squadId;
SquadMsg squadMsg = SquadMsgUtils.CreateActionMessage(action, callback, cookie);
squadMsg.SquadData = sqmSquadData;
return(squadMsg);
}
public static SquadMsg CreateApplyToJoinSquadMessage(string squadId, string message, SquadController.ActionCallback callback, object cookie)
{
SqmRequestData sqmRequestData = new SqmRequestData();
sqmRequestData.Text = message;
SquadMsg squadMsg = SquadMsgUtils.CreateSquadMessage(squadId, SquadAction.ApplyToJoin, callback, cookie);
squadMsg.RequestData = sqmRequestData;
return(squadMsg);
}
public static TroopDonateRequest GenerateTroopDonateRequest(SquadMsg message)
{
return(new TroopDonateRequest
{
PlayerId = message.OwnerData.PlayerId,
RecipientId = message.DonationData.RecipientId,
RequestId = message.DonationData.RequestId,
Donations = new Dictionary <string, int>(message.DonationData.Donations)
});
}
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;
}
public static SquadMsg CreateSendReplayMessage(string battleId, string message)
{
SqmReplayData sqmReplayData = new SqmReplayData();
sqmReplayData.BattleId = battleId;
sqmReplayData.Text = message;
SquadMsg squadMsg = SquadMsgUtils.CreateActionMessage(SquadAction.ShareReplay, null, null);
squadMsg.ReplayData = sqmReplayData;
return(squadMsg);
}
public static SquadMsg CreateShareReplayMessage(string message, BattleEntry entry)
{
SqmReplayData sqmReplayData = new SqmReplayData();
sqmReplayData.BattleId = entry.RecordID;
sqmReplayData.Text = message;
SquadMsg squadMsg = SquadMsgUtils.CreateActionMessage(SquadAction.ShareReplay, null, null);
squadMsg.ReplayData = sqmReplayData;
return(squadMsg);
}
