public static Variant GetPartyAttributeVariant(PartyId partyId, string attributeKey)
{
Variant variant = new Variant();
EntityId partyId2 = partyId.ToEntityId();
long intValue;
if (BattleNet.GetPartyAttributeLong(partyId2, attributeKey, out intValue))
{
variant.IntValue = intValue;
}
else
{
string text;
BattleNet.GetPartyAttributeString(partyId2, attributeKey, out text);
if (text != null)
{
variant.StringValue = text;
}
else
{
byte[] array;
BattleNet.GetPartyAttributeBlob(partyId2, attributeKey, out array);
if (array != null)
{
variant.BlobValue = array;
}
}
}
return(variant);
}
public static void IgnoreInviteRequest(PartyId partyId, BnetGameAccountId requestedTargetId)
{
EntityId partyId2 = partyId.ToEntityId();
EntityId requestedTargetId2 = BnetEntityId.CreateEntityId(requestedTargetId);
BattleNet.IgnoreInviteRequest(partyId2, requestedTargetId2);
}
public static KeyValuePair <string, object>[] GetAllPartyAttributes(PartyId partyId)
{
if (partyId == null)
{
return(new KeyValuePair <string, object> [0]);
}
string[] array;
BattleNet.GetAllPartyAttributes(partyId.ToEntityId(), out array);
KeyValuePair <string, object>[] array2 = new KeyValuePair <string, object> [array.Length];
for (int i = 0; i < array2.Length; i++)
{
string text = array[i];
object value = null;
long? partyAttributeLong = BnetParty.GetPartyAttributeLong(partyId, text);
if (partyAttributeLong != null)
{
value = partyAttributeLong;
}
string partyAttributeString = BnetParty.GetPartyAttributeString(partyId, text);
if (partyAttributeString != null)
{
value = partyAttributeString;
}
byte[] partyAttributeBlob = BnetParty.GetPartyAttributeBlob(partyId, text);
if (partyAttributeBlob != null)
{
value = partyAttributeBlob;
}
array2[i] = new KeyValuePair <string, object>(text, value);
}
return(array2);
}
public static void SendChatMessage(PartyId partyId, string chatMessage)
{
if (!BnetParty.IsInParty(partyId))
{
return;
}
BattleNet.SendPartyChatMessage(partyId.ToEntityId(), chatMessage);
}
public static void RevokeSentInvite(PartyId partyId, ulong inviteId)
{
if (!BnetParty.IsInParty(partyId))
{
return;
}
BattleNet.RevokePartyInvite(partyId.ToEntityId(), inviteId);
}
public static PrivacyLevel GetPrivacyLevel(PartyId partyId)
{
if (partyId == null)
{
return(PrivacyLevel.CLOSED);
}
return((PrivacyLevel)BattleNet.GetPartyPrivacy(partyId.ToEntityId()));
}
public static int CountMembers(PartyId partyId)
{
if (partyId == null)
{
return(0);
}
return(BattleNet.GetCountPartyMembers(partyId.ToEntityId()));
}
public static PartyInvite GetSentInvite(PartyId partyId, ulong inviteId)
{
if (partyId == null)
{
return(null);
}
PartyInvite[] sentInvites = BnetParty.GetSentInvites(partyId);
return(sentInvites.FirstOrDefault((PartyInvite i) => i.InviteId == inviteId));
}
public static bool IsMember(PartyId partyId, BnetGameAccountId memberId)
{
if (partyId == null)
{
return(false);
}
PartyMember member = BnetParty.GetMember(partyId, memberId);
return(member != null);
}
public static void DissolveParty(PartyId partyId)
{
if (!BnetParty.IsInParty(partyId))
{
return;
}
EntityId partyId2 = partyId.ToEntityId();
BattleNet.DissolveParty(partyId2);
}
public static InviteRequest[] GetInviteRequests(PartyId partyId)
{
if (partyId == null)
{
return(new InviteRequest[0]);
}
InviteRequest[] result;
BattleNet.GetPartyInviteRequests(partyId.ToEntityId(), out result);
return(result);
}
public static PartyInvite[] GetSentInvites(PartyId partyId)
{
if (partyId == null)
{
return(new PartyInvite[0]);
}
PartyInvite[] result;
BattleNet.GetPartySentInvites(partyId.ToEntityId(), out result);
return(result);
}
public static void SetPrivacy(PartyId partyId, PrivacyLevel privacyLevel)
{
if (!BnetParty.IsInParty(partyId))
{
return;
}
EntityId partyId2 = partyId.ToEntityId();
BattleNet.SetPartyPrivacy(partyId2, (int)privacyLevel);
}
public static byte[] GetPartyAttributeBlob(PartyId partyId, string attributeKey)
{
if (partyId == null)
{
return(null);
}
byte[] result;
BattleNet.GetPartyAttributeBlob(partyId.ToEntityId(), attributeKey, out result);
return(result);
}
public static PartyType GetPartyType(PartyId partyId)
{
PartyType result = PartyType.DEFAULT;
if (partyId == null)
{
return(result);
}
BnetParty.s_joinedParties.TryGetValue(partyId, out result);
return(result);
}
public static PartyMember GetMember(PartyId partyId, BnetGameAccountId memberId)
{
foreach (PartyMember partyMember in BnetParty.GetMembers(partyId))
{
if (partyMember.GameAccountId == memberId)
{
return(partyMember);
}
}
return(null);
}
public static void KickMember(PartyId partyId, BnetGameAccountId memberId)
{
if (!BnetParty.IsInParty(partyId))
{
return;
}
EntityId partyId2 = partyId.ToEntityId();
EntityId memberId2 = BnetEntityId.CreateEntityId(memberId);
BattleNet.KickPartyMember(partyId2, memberId2);
}
public static string GetPartyAttributeString(PartyId partyId, string attributeKey)
{
if (partyId == null)
{
return(null);
}
string result;
BattleNet.GetPartyAttributeString(partyId.ToEntityId(), attributeKey, out result);
return(result);
}
public static void SendInvite(PartyId toWhichPartyId, BnetGameAccountId recipientId)
{
if (!BnetParty.IsInParty(toWhichPartyId))
{
return;
}
EntityId partyId = toWhichPartyId.ToEntityId();
EntityId inviteeId = BnetEntityId.CreateEntityId(recipientId);
BattleNet.SendPartyInvite(partyId, inviteeId, false);
}
public static bool IsPartyFull(PartyId partyId, bool includeInvites = true)
{
if (partyId == null)
{
return(false);
}
int num = BnetParty.CountMembers(partyId);
int num2 = (!includeInvites) ? 0 : BnetParty.GetSentInvites(partyId).Length;
int maxPartyMembers = BattleNet.GetMaxPartyMembers(partyId.ToEntityId());
return(num + num2 >= maxPartyMembers);
}
public static void SetLeader(PartyId partyId, BnetGameAccountId memberId)
{
if (!BnetParty.IsInParty(partyId))
{
return;
}
EntityId partyId2 = partyId.ToEntityId();
EntityId memberId2 = BnetEntityId.CreateEntityId(memberId);
PartyType partyType = BnetParty.GetPartyType(partyId);
uint leaderRoleId = PartyMember.GetLeaderRoleId(partyType);
BattleNet.AssignPartyRole(partyId2, memberId2, leaderRoleId);
}
public static PartyInfo GetJoinedParty(PartyId partyId)
{
if (partyId == null)
{
return(null);
}
PartyType type = PartyType.DEFAULT;
if (BnetParty.s_joinedParties.TryGetValue(partyId, out type))
{
return(new PartyInfo(partyId, type));
}
return(null);
}
public static PartyMember GetMyselfMember(PartyId partyId)
{
if (partyId == null)
{
return(null);
}
BnetGameAccountId bnetGameAccountId = BnetGameAccountId.CreateFromEntityId(BattleNet.GetMyGameAccountId());
if (bnetGameAccountId == null)
{
return(null);
}
return(BnetParty.GetMember(partyId, bnetGameAccountId));
}
public static long?GetPartyAttributeLong(PartyId partyId, string attributeKey)
{
if (partyId == null)
{
return(null);
}
long value;
if (BattleNet.GetPartyAttributeLong(partyId.ToEntityId(), attributeKey, out value))
{
return(new long?(value));
}
return(null);
}
public static PartyMember GetLeader(PartyId partyId)
{
if (partyId == null)
{
return(null);
}
PartyMember[] members = BnetParty.GetMembers(partyId);
PartyType partyType = BnetParty.GetPartyType(partyId);
foreach (PartyMember partyMember in members)
{
if (partyMember.IsLeader(partyType))
{
return(partyMember);
}
}
return(null);
}
public static bool IsLeader(PartyId partyId)
{
if (partyId == null)
{
return(false);
}
PartyMember myselfMember = BnetParty.GetMyselfMember(partyId);
if (myselfMember != null)
{
PartyType partyType = BnetParty.GetPartyType(partyId);
if (myselfMember.IsLeader(partyType))
{
return(true);
}
}
return(false);
}
public static void RequestInvite(PartyId partyId, BnetGameAccountId whomToAskForApproval, BnetGameAccountId whomToInvite, PartyType partyType)
{
if (BnetParty.IsLeader(partyId))
{
PartyError error = default(PartyError);
error.IsOperationCallback = true;
error.DebugContext = "RequestInvite";
error.ErrorCode = BattleNetErrors.ERROR_INVALID_TARGET_ID;
error.Feature = BnetFeature.Party;
error.FeatureEvent = BnetFeatureEvent.Party_RequestPartyInvite_Callback;
error.PartyId = partyId;
error.szPartyType = EnumUtils.GetString <PartyType>(partyType);
error.StringData = "leaders cannot RequestInvite - use SendInvite instead.";
BnetParty.OnError(error);
return;
}
EntityId partyId2 = partyId.ToEntityId();
EntityId whomToAskForApproval2 = BnetEntityId.CreateEntityId(whomToAskForApproval);
EntityId whomToInvite2 = BnetEntityId.CreateEntityId(whomToInvite);
string @string = EnumUtils.GetString <PartyType>(partyType);
BattleNet.RequestPartyInvite(partyId2, whomToAskForApproval2, whomToInvite2, @string);
}
public static PartyMember[] GetMembers(PartyId partyId)
{
if (partyId == null)
{
return(new PartyMember[0]);
}
PartyMember[] array;
BattleNet.GetPartyMembers(partyId.ToEntityId(), out array);
PartyMember[] array2 = new PartyMember[array.Length];
for (int i = 0; i < array2.Length; i++)
{
PartyMember partyMember = array[i];
array2[i] = new PartyMember
{
GameAccountId = BnetGameAccountId.CreateFromEntityId(partyMember.memberGameAccountId),
RoleIds = new uint[]
{
partyMember.firstMemberRole
}
};
}
return(array2);
}
public PartyInvite(ulong inviteId, PartyId partyId, PartyType type)
{
this.InviteId = inviteId;
this.PartyId = partyId;
this.PartyType = type;
}
public static void Process()
{
PartyListenerEvent[] array;
BattleNet.GetPartyListenerEvents(out array);
BattleNet.ClearPartyListenerEvents();
int i = 0;
while (i < array.Length)
{
PartyListenerEvent partyListenerEvent = array[i];
PartyId partyId = partyListenerEvent.PartyId;
switch (partyListenerEvent.Type)
{
case PartyListenerEventType.ERROR_RAISED:
case PartyListenerEventType.OPERATION_CALLBACK:
{
PartyError error = partyListenerEvent.ToPartyError();
if (error.ErrorCode != BattleNetErrors.ERROR_OK)
{
if (BnetParty.IsIgnorableError(error.FeatureEvent, error.ErrorCode.EnumVal))
{
error.ErrorCode = BattleNetErrors.ERROR_OK;
if (error.FeatureEvent == BnetFeatureEvent.Party_Leave_Callback)
{
if (!BnetParty.s_joinedParties.ContainsKey(partyId))
{
BnetParty.s_joinedParties[partyId] = PartyType.SPECTATOR_PARTY;
}
goto IL_22D;
}
}
if (error.IsOperationCallback && error.FeatureEvent == BnetFeatureEvent.Party_Create_Callback)
{
PartyType partyType = error.PartyType;
if (BnetParty.s_pendingPartyCreates.ContainsKey(partyType))
{
BnetParty.s_pendingPartyCreates.Remove(partyType);
}
}
}
if (error.ErrorCode != BattleNetErrors.ERROR_OK)
{
BnetParty.RaisePartyError(error);
}
break;
}
case PartyListenerEventType.JOINED_PARTY:
{
string stringData = partyListenerEvent.StringData;
PartyType partyTypeFromString = BnetParty.GetPartyTypeFromString(stringData);
BnetParty.s_joinedParties[partyId] = partyTypeFromString;
if (BnetParty.s_pendingPartyCreates != null)
{
BnetParty.CreateSuccessCallback createSuccessCallback = null;
if (BnetParty.s_pendingPartyCreates.ContainsKey(partyTypeFromString))
{
createSuccessCallback = BnetParty.s_pendingPartyCreates[partyTypeFromString];
BnetParty.s_pendingPartyCreates.Remove(partyTypeFromString);
}
else if (stringData == "default" && BnetParty.s_pendingPartyCreates.Count == 0)
{
createSuccessCallback = BnetParty.s_pendingPartyCreates.First <KeyValuePair <PartyType, BnetParty.CreateSuccessCallback> >().Value;
BnetParty.s_pendingPartyCreates.Clear();
}
if (createSuccessCallback != null)
{
createSuccessCallback(partyTypeFromString, partyId);
}
}
if (BnetParty.OnJoined != null)
{
BnetParty.OnJoined(OnlineEventType.ADDED, new PartyInfo(partyId, partyTypeFromString), null);
}
break;
}
case PartyListenerEventType.LEFT_PARTY:
goto IL_22D;
case PartyListenerEventType.PRIVACY_CHANGED:
if (BnetParty.OnPrivacyLevelChanged != null)
{
BnetParty.OnPrivacyLevelChanged(BnetParty.GetJoinedParty(partyId), (PrivacyLevel)partyListenerEvent.UintData);
}
break;
case PartyListenerEventType.MEMBER_JOINED:
case PartyListenerEventType.MEMBER_LEFT:
if (BnetParty.OnMemberEvent != null)
{
OnlineEventType evt = (partyListenerEvent.Type != PartyListenerEventType.MEMBER_JOINED) ? OnlineEventType.REMOVED : OnlineEventType.ADDED;
LeaveReason? reason = null;
if (partyListenerEvent.Type == PartyListenerEventType.MEMBER_LEFT)
{
reason = new LeaveReason?((LeaveReason)partyListenerEvent.UintData);
}
BnetParty.OnMemberEvent(evt, BnetParty.GetJoinedParty(partyId), partyListenerEvent.SubjectMemberId, false, reason);
}
break;
case PartyListenerEventType.MEMBER_ROLE_CHANGED:
if (BnetParty.OnMemberEvent != null)
{
BnetParty.OnMemberEvent(OnlineEventType.UPDATED, BnetParty.GetJoinedParty(partyId), partyListenerEvent.SubjectMemberId, true, null);
}
break;
case PartyListenerEventType.RECEIVED_INVITE_ADDED:
case PartyListenerEventType.RECEIVED_INVITE_REMOVED:
if (BnetParty.OnReceivedInvite != null)
{
OnlineEventType evt2 = (partyListenerEvent.Type != PartyListenerEventType.RECEIVED_INVITE_ADDED) ? OnlineEventType.REMOVED : OnlineEventType.ADDED;
PartyType type = PartyType.DEFAULT;
if (partyListenerEvent.StringData != null)
{
EnumUtils.TryGetEnum <PartyType>(partyListenerEvent.StringData, out type);
}
PartyInfo party = new PartyInfo(partyId, type);
InviteRemoveReason?reason2 = null;
if (partyListenerEvent.Type == PartyListenerEventType.RECEIVED_INVITE_REMOVED)
{
reason2 = new InviteRemoveReason?((InviteRemoveReason)partyListenerEvent.UintData);
}
BnetParty.OnReceivedInvite(evt2, party, partyListenerEvent.UlongData, reason2);
}
break;
case PartyListenerEventType.PARTY_INVITE_SENT:
case PartyListenerEventType.PARTY_INVITE_REMOVED:
if (BnetParty.OnSentInvite != null)
{
bool senderIsMyself = partyListenerEvent.SubjectMemberId == BnetGameAccountId.CreateFromEntityId(BattleNet.GetMyGameAccountId());
OnlineEventType evt3 = (partyListenerEvent.Type != PartyListenerEventType.PARTY_INVITE_SENT) ? OnlineEventType.REMOVED : OnlineEventType.ADDED;
PartyType type2 = PartyType.DEFAULT;
if (partyListenerEvent.StringData != null)
{
EnumUtils.TryGetEnum <PartyType>(partyListenerEvent.StringData, out type2);
}
PartyInfo party2 = new PartyInfo(partyId, type2);
InviteRemoveReason?reason3 = null;
if (partyListenerEvent.Type == PartyListenerEventType.PARTY_INVITE_REMOVED)
{
reason3 = new InviteRemoveReason?((InviteRemoveReason)partyListenerEvent.UintData);
}
BnetParty.OnSentInvite(evt3, party2, partyListenerEvent.UlongData, senderIsMyself, reason3);
}
break;
case PartyListenerEventType.INVITE_REQUEST_ADDED:
case PartyListenerEventType.INVITE_REQUEST_REMOVED:
if (BnetParty.OnSentInvite != null)
{
OnlineEventType evt4 = (partyListenerEvent.Type != PartyListenerEventType.INVITE_REQUEST_ADDED) ? OnlineEventType.REMOVED : OnlineEventType.ADDED;
PartyInfo joinedParty = BnetParty.GetJoinedParty(partyId);
InviteRequestRemovedReason?reason4 = null;
if (partyListenerEvent.Type == PartyListenerEventType.INVITE_REQUEST_REMOVED)
{
reason4 = new InviteRequestRemovedReason?((InviteRequestRemovedReason)partyListenerEvent.UintData);
}
InviteRequest inviteRequest = new InviteRequest();
inviteRequest.TargetId = partyListenerEvent.TargetMemberId;
inviteRequest.TargetName = partyListenerEvent.StringData2;
inviteRequest.RequesterId = partyListenerEvent.SubjectMemberId;
inviteRequest.RequesterName = partyListenerEvent.StringData;
BnetParty.OnReceivedInviteRequest(evt4, joinedParty, inviteRequest, reason4);
}
break;
case PartyListenerEventType.CHAT_MESSAGE_RECEIVED:
if (BnetParty.OnChatMessage != null)
{
BnetParty.OnChatMessage(BnetParty.GetJoinedParty(partyId), partyListenerEvent.SubjectMemberId, partyListenerEvent.StringData);
}
break;
case PartyListenerEventType.PARTY_ATTRIBUTE_CHANGED:
{
PartyInfo joinedParty2 = BnetParty.GetJoinedParty(partyId);
string stringData2 = partyListenerEvent.StringData;
if (stringData2 == "WTCG.Party.Type")
{
string partyAttributeString = BnetParty.GetPartyAttributeString(partyId, "WTCG.Party.Type");
PartyType partyTypeFromString2 = BnetParty.GetPartyTypeFromString(partyAttributeString);
if (partyTypeFromString2 != PartyType.DEFAULT)
{
BnetParty.s_joinedParties[partyId] = partyTypeFromString2;
}
}
Variant variant = null;
switch (partyListenerEvent.UintData)
{
case 1u:
variant = new Variant();
variant.IntValue = (long)partyListenerEvent.UlongData;
break;
case 2u:
variant = new Variant();
variant.StringValue = partyListenerEvent.StringData2;
break;
case 3u:
variant = new Variant();
variant.BlobValue = partyListenerEvent.BlobData;
break;
}
IL_611:
if (BnetParty.OnPartyAttributeChanged != null)
{
BnetParty.OnPartyAttributeChanged(joinedParty2, stringData2, variant);
}
List <BnetParty.PartyAttributeChangedHandler> list;
if (BnetParty.s_attributeChangedSubscribers != null && BnetParty.s_attributeChangedSubscribers.TryGetValue(stringData2, out list))
{
BnetParty.PartyAttributeChangedHandler[] array2 = list.ToArray();
foreach (BnetParty.PartyAttributeChangedHandler partyAttributeChangedHandler in array2)
{
partyAttributeChangedHandler(joinedParty2, stringData2, variant);
}
}
break;
goto IL_611;
}
}
IL_68C:
i++;
continue;
IL_22D:
if (BnetParty.s_joinedParties.ContainsKey(partyId))
{
PartyType type3 = BnetParty.s_joinedParties[partyId];
BnetParty.s_joinedParties.Remove(partyId);
if (BnetParty.OnJoined != null)
{
BnetParty.OnJoined(OnlineEventType.REMOVED, new PartyInfo(partyId, type3), new LeaveReason?((LeaveReason)partyListenerEvent.UintData));
}
}
goto IL_68C;
}
}
