/// <summary>
/// Handles an incoming group invite request (/invite Player)
/// </summary>
/// <param name="client">the Session the incoming packet belongs to</param>
/// <param name="packet">the full packet</param>
public static void GroupInviteRequest(IRealmClient client, RealmPacketIn packet)
{
string str = packet.ReadCString();
Character activeCharacter = client.ActiveCharacter;
Group group = activeCharacter.Group;
Character target;
if (Group.CheckInvite(activeCharacter, out target, str) != GroupResult.NoError)
{
return;
}
HashSet <IBaseRelation> relations =
Singleton <RelationMgr> .Instance.GetRelations(activeCharacter.EntityId.Low,
CharacterRelationType.GroupInvite);
if (group != null && relations.Count >= group.InvitesLeft)
{
return;
}
Singleton <RelationMgr> .Instance.AddRelation(RelationMgr.CreateRelation(activeCharacter.EntityId.Low,
target.EntityId.Low, CharacterRelationType.GroupInvite));
Group.SendResult(activeCharacter.Client, GroupResult.NoError, str);
SendGroupInvite(target.Client, activeCharacter.Name);
}
/// <summary>
/// Handles an incoming group invite request (/invite Player)
/// </summary>
/// <param name="client">the Session the incoming packet belongs to</param>
/// <param name="packet">the full packet</param>
//[ClientPacketHandler((RealmServerOpCode.CMSG_GROUP_INVITE)]
public static void GroupInviteRequest(IRealmClient client, RealmPacketIn packet)
{
var inviteeName = packet.ReadCString();
var inviter = client.ActiveCharacter;
var group = inviter.Group;
Character invitee;
if (Group.CheckInvite(inviter, out invitee, inviteeName) == GroupResult.NoError)
{
var listInvitees = Singleton <RelationMgr> .Instance.GetRelations(inviter.EntityId.Low,
CharacterRelationType.GroupInvite);
if (group == null || listInvitees.Count < group.InvitesLeft)
{
BaseRelation inviteRelation = RelationMgr.CreateRelation(inviter.EntityId.Low,
invitee.EntityId.Low, CharacterRelationType.GroupInvite);
Singleton <RelationMgr> .Instance.AddRelation(inviteRelation);
// Target has been invited
Group.SendResult(inviter.Client, GroupResult.NoError, inviteeName);
SendGroupInvite(invitee.Client, inviter.Name);
}
}
}
public void LoadDBData(List <DBBaseAlert> data)
{
if (data == null)
{
return;
}
foreach (var item in data)
{
if (item.Type == AlertType.Continue)
{
continue;
}
var alert = Add(item.TDID, GetEntity(item.Cast));
alert.TipStr = item.TipStr;
alert.DetailStr = item.DetailStr;
alert.TitleStr = item.TitleStr;
alert.Illustration = item.Illustration;
alert.CurTurn = item.CurTurn;
alert.ID = item.ID;
alert.IsCommingTimeOutFalg = item.IsCommingTimeOutFalg;
alert.StartSFX = item.StartSFX;
alert.IsAutoTrigger = item.IsAutoTrigger;
alert.Bg = item.Bg;
alert.Icon = item.Icon;
alert.WarfareData = RelationMgr.GetWarfareData <IBaseWarfareData>(item.War);
item.SelfArticle.ForEach(x => alert.SelfArticle.Add(ArticleMgr.Get <TDBaseArticleData>(x)));
item.TargetArticle.ForEach(x => alert.TargetArticle.Add(ArticleMgr.Get <TDBaseArticleData>(x)));
}
}
private static void OnPartyInviteRequest(IRealmClient client, Character destChr)
{
if (!destChr.EnablePartyRequest)
{
client.ActiveCharacter.SendSystemMessage(string.Format("Sorry ,but {0} rejects all party requests.",
(object)destChr.Name));
}
else if (client.ActiveCharacter.Asda2FactionId != (short)-1 && destChr.Asda2FactionId != (short)-1 &&
(int)destChr.Asda2FactionId != (int)client.ActiveCharacter.Asda2FactionId)
{
client.ActiveCharacter.SendSystemMessage(string.Format("Sorry ,but {0} is in other faction.",
(object)destChr.Name));
}
else
{
string name = destChr.Name;
Character activeCharacter = client.ActiveCharacter;
Group group = activeCharacter.Group;
IBaseRelation relation1 = Singleton <RelationMgr> .Instance
.GetPassiveRelations(destChr.EntityId.Low, CharacterRelationType.GroupInvite)
.FirstOrDefault <IBaseRelation>();
if (relation1 != null && Environment.TickCount - int.Parse(relation1.Note) > 30000)
{
Singleton <RelationMgr> .Instance.RemoveRelation(relation1);
}
Character target;
if (Group.CheckInvite(activeCharacter, out target, name) == GroupResult.NoError)
{
HashSet <IBaseRelation> relations =
Singleton <RelationMgr> .Instance.GetRelations(activeCharacter.EntityId.Low,
CharacterRelationType.GroupInvite);
if (group != null && relations.Count >= (int)group.InvitesLeft)
{
return;
}
BaseRelation relation2 = RelationMgr.CreateRelation(activeCharacter.EntityId.Low,
target.EntityId.Low, CharacterRelationType.GroupInvite);
relation2.Note = Environment.TickCount.ToString((IFormatProvider)CultureInfo.InvariantCulture);
Singleton <RelationMgr> .Instance.AddRelation(relation2);
Asda2GroupHandler.SendInviteToPartyResponseOrRequestToAnotherPlayerResponse(target.Client,
PartyInviteStatusRequest.Invite, client.ActiveCharacter.Name);
Asda2GroupHandler.SendPartyIniteResponseResponse(client, activeCharacter, target,
PartyInviteStatusResponse.SomeOneRevicingYourInvation);
}
else
{
Asda2GroupHandler.SendPartyIniteResponseResponse(client, activeCharacter, target,
PartyInviteStatusResponse.ThereIsNoOneToInvite);
}
}
}
private static void OnPartyInviteRequest(IRealmClient client, Character destChr)
{
if (!destChr.EnablePartyRequest)
{
client.ActiveCharacter.SendSystemMessage(string.Format("Sorry ,but {0} rejects all party requests.", destChr.Name));
return;
}
var inviteeName = destChr.Name;
var inviter = client.ActiveCharacter;
var group = inviter.Group;
Character invitee;
var listInviters = Singleton <RelationMgr> .Instance.GetPassiveRelations(destChr.EntityId.Low,
CharacterRelationType.GroupInvite);
var invite = listInviters.FirstOrDefault();
if (invite != null)
{
var ticks = int.Parse(invite.Note);
var timeFromLastInvite = Environment.TickCount - ticks;
if (timeFromLastInvite > 30000)
{
RelationMgr.Instance.RemoveRelation(invite);
}
}
var res = Group.CheckInvite(inviter, out invitee, inviteeName);
if (res == GroupResult.NoError)
{
var listInvitees = Singleton <RelationMgr> .Instance.GetRelations(inviter.EntityId.Low,
CharacterRelationType.GroupInvite);
if (group == null || listInvitees.Count < group.InvitesLeft)
{
BaseRelation inviteRelation = RelationMgr.CreateRelation(inviter.EntityId.Low,
invitee.EntityId.Low, CharacterRelationType.GroupInvite);
inviteRelation.Note = Environment.TickCount.ToString(CultureInfo.InvariantCulture);
Singleton <RelationMgr> .Instance.AddRelation(inviteRelation);
// Target has been invited
//Group.SendResult(inviter.Client, GroupResult.NoError, inviteeName);
SendInviteToPartyResponseOrRequestToAnotherPlayerResponse(invitee.Client, PartyInviteStatusRequest.Invite, client.ActiveCharacter.Name);
SendPartyIniteResponseResponse(client, inviter, invitee, PartyInviteStatusResponse.SomeOneRevicingYourInvation);
}
}
else
{
SendPartyIniteResponseResponse(client, inviter, invitee, PartyInviteStatusResponse.ThereIsNoOneToInvite);
}
}
public void TestRelationAdd()
{
BaseRelation relation = null;
BaseRelation storedRelation = null;
int i = 0;
foreach (CharacterRelationType type in Enum.GetValues(typeof(CharacterRelationType)))
{
if (type != CharacterRelationType.Invalid && type != CharacterRelationType.Count)
{
relation = RelationMgr.CreateRelation(_allianceChars[i].EntityId.Low,
_allianceChars[i + 1].EntityId.Low, type);
RelationMgr.Instance.AddRelation(relation);
storedRelation = RelationMgr.Instance.GetRelation(_allianceChars[i].EntityId.Low,
_allianceChars[i + 1].EntityId.Low, type);
Assert.AreEqual(relation, storedRelation);
i++;
}
}
}
public bool IsHaveSuzerain() => RelationMgr.IsHaveSuzerain(SelfUnit);
public bool IsHaveVassal() => RelationMgr.IsHaveVassal(SelfUnit);
public bool IsHaveMarriage() => RelationMgr.IsHaveMarriage(SelfUnit);
public bool IsHaveAlliance() => RelationMgr.IsHaveAlliance(SelfUnit);
public bool IsFriend(TUnit target)
{
return(RelationMgr.IsFriend(SelfUnit, target));
}
public bool IsInWar()
{
return(RelationMgr.IsInWarfare(SelfBaseUnit));
}
public int GetRelationShip(TUnit target)
{
return(RelationMgr.GetRelationShip(SelfUnit, target));
}
public MailError SendMail(string recipientName,
string subject,
string body,
MailStationary stationary,
ICollection <Item> items,
uint money,
uint cod)
{
FactionGroup recipientFaction;
int recipientMailCount;
// Find and verify the recipient
var normalizedName = recipientName;
var recipient = World.GetCharacter(normalizedName, false);
CharacterRecord recipientRecord;
if (recipient != null)
{
// receiving character is online, get info from the character object
recipientFaction = recipient.Faction.Group;
recipientMailCount = recipient.MailAccount.AllMail.Count;
recipientRecord = recipient.Record;
}
else
{
// no character online with that name, get info from the CharacterRecord
var charRecord = CharacterRecord.GetRecordByName(normalizedName);
if (charRecord == null)
{
MailHandler.SendResult(m_chr.Client, 0, MailResult.MailSent, MailError.RECIPIENT_NOT_FOUND);
return(MailError.RECIPIENT_NOT_FOUND);
}
recipientFaction = FactionMgr.GetFactionGroup(charRecord.Race);
recipientMailCount = charRecord.MailCount;
recipientRecord = charRecord;
}
if (!m_chr.GodMode)
{
if (stationary == MailStationary.GM)
{
MailHandler.SendResult(m_chr.Client, 0, MailResult.MailSent, MailError.INTERNAL_ERROR);
return(MailError.INTERNAL_ERROR);
}
// Can't send to people who ignore you
if (RelationMgr.IsIgnoring(recipientRecord.EntityLowId, m_chr.EntityId.Low))
{
MailHandler.SendResult(m_chr.Client, 0, MailResult.MailSent, MailError.RECIPIENT_NOT_FOUND);
return(MailError.RECIPIENT_NOT_FOUND);
}
// Can't send mail to people on the other team
if (!MailMgr.AllowInterFactionMail && !m_chr.GodMode)
{
if (recipientFaction != m_chr.Faction.Group)
{
MailHandler.SendResult(m_chr, 0u, MailResult.MailSent, MailError.NOT_YOUR_ALLIANCE);
return(MailError.NOT_YOUR_ALLIANCE);
}
}
// Check that the recipient can recieve more mail.
if (recipientMailCount > MailMgr.MaxMailCount)
{
MailHandler.SendResult(m_chr, 0u, MailResult.MailSent, MailError.RECIPIENT_CAP_REACHED);
return(MailError.RECIPIENT_CAP_REACHED);
}
}
return(SendMail(recipientRecord, subject, body, stationary, items, money, cod));
}
public MailError SendMail(string recipientName, string subject, string body, MailStationary stationary,
ICollection <Item> items, uint money, uint cod)
{
string name = recipientName;
Character character = World.GetCharacter(name, false);
FactionGroup factionGroup;
int num;
CharacterRecord recipient;
if (character != null)
{
factionGroup = character.Faction.Group;
num = character.MailAccount.AllMail.Count;
recipient = character.Record;
}
else
{
CharacterRecord recordByName = CharacterRecord.GetRecordByName(name);
if (recordByName == null)
{
MailHandler.SendResult(m_chr.Client, 0U, MailResult.MailSent,
MailError.RECIPIENT_NOT_FOUND);
return(MailError.RECIPIENT_NOT_FOUND);
}
factionGroup = FactionMgr.GetFactionGroup(recordByName.Race);
num = recordByName.MailCount;
recipient = recordByName;
}
if (!m_chr.GodMode)
{
if (stationary == MailStationary.GM)
{
MailHandler.SendResult(m_chr.Client, 0U, MailResult.MailSent,
MailError.INTERNAL_ERROR);
return(MailError.INTERNAL_ERROR);
}
if (RelationMgr.IsIgnoring(recipient.EntityLowId, m_chr.EntityId.Low))
{
MailHandler.SendResult(m_chr.Client, 0U, MailResult.MailSent,
MailError.RECIPIENT_NOT_FOUND);
return(MailError.RECIPIENT_NOT_FOUND);
}
if (!MailMgr.AllowInterFactionMail && !m_chr.GodMode && factionGroup != m_chr.Faction.Group)
{
MailHandler.SendResult(m_chr, 0U, MailResult.MailSent,
MailError.NOT_YOUR_ALLIANCE);
return(MailError.NOT_YOUR_ALLIANCE);
}
if (num > MailMgr.MaxMailCount)
{
MailHandler.SendResult(m_chr, 0U, MailResult.MailSent,
MailError.RECIPIENT_CAP_REACHED);
return(MailError.RECIPIENT_CAP_REACHED);
}
}
return(SendMail(recipient, subject, body, stationary, items, money, cod));
}
