private static void HandleInviteResponse(GameSession session, PacketReader packet)
{
long clubId = packet.ReadLong();
string clubName = packet.ReadUnicodeString();
string clubLeader = packet.ReadUnicodeString();
string invitee = packet.ReadUnicodeString();
bool accept = packet.ReadBool();
if (invitee != session.Player.Name)
{
return;
}
Club club = GameServer.ClubManager.GetClubById(clubId);
if (club == null)
{
return;
}
Player leader = GameServer.PlayerManager.GetPlayerById(club.LeaderCharacterId);
leader?.Session.Send(ClubPacket.LeaderInviteResponse(club, invitee, accept));
session.Send(ClubPacket.InviteResponse(club, session.Player));
if (accept)
{
club.AcceptInvite(session.Player);
}
}
private static void HandleCreate(GameSession session, PacketReader packet)
{
Party party = GameServer.PartyManager.GetPartyByLeader(session.Player);
if (party is null || party.Leader.CharacterId != session.Player.CharacterId)
{
return;
}
int maxClubCount = int.Parse(ConstantsMetadataStorage.GetConstant("ClubMaxCount"));
// Fail if a party member is offline or if member has joined max amount of clubs
if (party.Members.Any(x => !x.Session.Connected()) || party.Members.Any(x => x.Clubs.Count >= maxClubCount))
{
session.Send(ClubPacket.ErrorNotice((int)ClubErrorNotice.SomePartyMembersCannotBeInvited));
return;
}
string clubName = packet.ReadUnicodeString();
if (!ValidClubName(session, clubName))
{
return;
}
Club club = new(party, clubName);
GameServer.ClubManager.AddClub(club);
party.BroadcastPacketParty(ClubPacket.Create(party, club));
}
private static void HandleRename(GameSession session, PacketReader packet)
{
long clubId = packet.ReadLong();
string clubNewName = packet.ReadUnicodeString();
Club club = GameServer.ClubManager.GetClubById(clubId);
if (club is null)
{
return;
}
if (club.LastNameChangeTimestamp > TimeInfo.Now() + 3600) // 1 hour restriction to change names
{
session.Send(ClubPacket.ErrorNotice((int)ClubErrorNotice.CanOnlyBeRenamedOnceAnHour));
return;
}
if (!ValidClubName(session, clubNewName))
{
return;
}
if (clubNewName == club.Name)
{
session.Send(ClubPacket.ErrorNotice((int)ClubErrorNotice.NewNameIsCurrentName));
return;
}
club.SetName(clubNewName);
}
public void InvitedPlayerResponse(Player player, ClubInviteResponse inviteResponse)
{
if (!Members.Any(x => x.Player.CharacterId == player.CharacterId))
{
return;
}
ClubMember member = player.ClubMembers.FirstOrDefault(x => x.ClubId == Id);
member.InviteResponse = inviteResponse;
if (inviteResponse == ClubInviteResponse.Reject)
{
List <GameSession> memberSessions = GetSessions();
foreach (GameSession session in memberSessions)
{
session.Send(ClubPacket.ClubProposalInviteResponse(Id, inviteResponse, player.Name));
session.Send(ClubPacket.DeleteUnestablishedClub(Id));
ClubMember membership = session.Player.ClubMembers.First(x => x.ClubId == Id);
session.Player.ClubMembers.Remove(membership);
session.Player.Clubs.Remove(this);
}
GameServer.ClubManager.RemoveClub(this);
return;
}
EstablishClub(player);
}
private void EstablishClub(Player player)
{
if (IsEstablished)
{
// player joins normally
AcceptInvite(player);
return;
}
if (Members.Any(x => x.InviteResponse == ClubInviteResponse.Pending))
{
return;
}
IsEstablished = true;
DatabaseManager.Clubs.Update(this);
foreach (ClubMember member in Members)
{
if (member.InviteResponse != ClubInviteResponse.Accept)
{
continue;
}
if (member.Player.CharacterId == LeaderCharacterId)
{
member?.Player.Session?.Send(ClubPacket.Join(member.Player.Name, this));
member?.Player.Session?.Send(ClubPacket.Establish(this));
}
member?.Player.Session?.Send(ClubPacket.ClubProposalInviteResponse(Id, ClubInviteResponse.Accept, member.Player.Name));
}
}
private static void HandleLeave(GameSession session, PacketReader packet)
{
long clubId = packet.ReadLong();
Club club = GameServer.ClubManager.GetClubById(clubId);
if (club == null)
{
return;
}
if (session.Player.CharacterId == club.Leader.CharacterId)
{
if (club.Members.Count < 2)
{
// TODO fix disbanding
club.BroadcastPacketClub(ClubPacket.Disband(club));
club.BroadcastPacketClub(ClubPacket.UpdatePlayerClubList(session.Player, club));
}
else
{
// TODO fix reassigning leader
session.Send(ClubPacket.LeaveClub(club));
club.BroadcastPacketClub(ClubPacket.LeaveNotice(club, session.Player));
club.BroadcastPacketClub(ClubPacket.AssignNewLeader(session.Player, club));
}
}
else
{
session.Send(ClubPacket.LeaveClub(club));
club.BroadcastPacketClub(ClubPacket.LeaveNotice(club, session.Player));
// TODO remove member from club (club.RemoveMember(session.Player);)
}
}
public void SetName(string newName)
{
Name = newName;
LastNameChangeTimestamp = TimeInfo.Now();
DatabaseManager.Clubs.Update(this);
BroadcastPacketClub(ClubPacket.Rename(this));
}
private static void HandleNameVoucher(GameSession session, PacketReader packet, Item item)
{
string newName = packet.ReadUnicodeString();
string oldName = session.Player.Name;
session.Player.Name = newName;
session.Player.Inventory.ConsumeItem(session, item.Uid, 1);
session.Send(CharacterListPacket.NameChanged(session.Player.CharacterId, newName));
// Update name on socials
foreach (Club club in session.Player.Clubs)
{
club.BroadcastPacketClub(ClubPacket.UpdateMemberName(oldName, newName, session.Player.CharacterId));
if (club.LeaderCharacterId == session.Player.CharacterId)
{
club.LeaderName = newName;
}
}
if (session.Player.Guild is not null)
{
session.Player.Guild?.BroadcastPacketGuild(GuildPacket.UpdateMemberName(oldName, newName));
if (session.Player.Guild.LeaderCharacterId == session.Player.CharacterId)
{
session.Player.Guild.LeaderName = newName;
}
}
session.Player.Party?.BroadcastPacketParty(PartyPacket.UpdatePlayer(session.Player));
// TODO: Needs to redirect player to character selection screen after pop-up
}
public void AcceptInvite(Player player)
{
AddMember(player, out ClubMember member);
BroadcastPacketClub(ClubPacket.ConfirmInvite(this, member));
player.Session.Send(ClubPacket.Join(player.Name, this));
player.Session.Send(ClubPacket.UpdateClub(this));
BroadcastPacketClub(ClubPacket.UpdatePlayer(member, this));
}
public void RemoveMember(Player player)
{
player.Session.Send(ClubPacket.LeaveClub(this));
player.Clubs.Remove(this);
BroadcastPacketClub(ClubPacket.LeaveNotice(this, player));
ClubMember member = player.ClubMembers.First(x => x.ClubId == Id);
Members.Remove(member);
player.ClubMembers.Remove(member);
DatabaseManager.ClubMembers.Delete(Id, player.CharacterId);
DatabaseManager.Clubs.Update(this);
}
private static void HandleRename(PacketReader packet)
{
long clubId = packet.ReadLong();
string clubNewName = packet.ReadUnicodeString();
Club club = GameServer.ClubManager.GetClubById(clubId);
if (club == null)
{
return;
}
club.BroadcastPacketClub(ClubPacket.Rename(club, clubNewName));
// TODO rename club (club.SetName(clubNewName);)
}
public void Disband()
{
BroadcastPacketClub(ClubPacket.Disband(this));
List <GameSession> memberSessions = GetSessions();
foreach (GameSession session in memberSessions)
{
session.Player.Clubs.Remove(this);
ClubMember membership = session.Player.ClubMembers.FirstOrDefault(x => x.ClubId == Id);
session.Player.ClubMembers.Remove(membership);
DatabaseManager.ClubMembers.Delete(Id, session.Player.CharacterId);
}
GameServer.ClubManager.RemoveClub(this);
}
private static void HandleBuff(PacketReader packet)
{
long clubId = packet.ReadLong();
int buffId = packet.ReadInt();
Club club = GameServer.ClubManager.GetClubById(clubId);
if (club == null)
{
return;
}
// TODO add buff effect packet
club.Leader.Session.Send(ClubPacket.ChangeBuffReceipt(club, buffId));
club.BroadcastPacketClub(ClubPacket.ChangeBuff(club, buffId));
}
private static void HandleCreate(GameSession session, PacketReader packet)
{
// TODO fix creating for a party of more than 2. Currently if a member does not respond, despite atleast one other member accepting, it does not get created.
Party party = GameServer.PartyManager.GetPartyByLeader(session.Player);
if (party == null)
{
return;
}
string clubName = packet.ReadUnicodeString();
Club club = new Club(party, clubName);
GameServer.ClubManager.AddClub(club);
party.BroadcastPacketParty(ClubPacket.Create(party, club));
}
private static bool ValidClubName(GameSession session, string clubName)
{
if (DatabaseManager.Clubs.NameExists(clubName))
{
session.Send(ClubPacket.ErrorNotice((int)ClubErrorNotice.ClubWithNameAlreadyExists));
return(false);
}
if (clubName.Contains(' '))
{
session.Send(ClubPacket.ErrorNotice((int)ClubErrorNotice.NoSpacesInName));
return(false);
}
return(true);
}
public void AssignNewLeader(Player oldLeader)
{
if (Members.Count <= 2)
{
Disband();
return;
}
Player player = Members.OrderBy(x => x.JoinTimestamp)
.First(x => x.Player != oldLeader).Player;
LeaderAccountId = player.AccountId;
LeaderCharacterId = player.CharacterId;
LeaderName = player.Name;
BroadcastPacketClub(ClubPacket.AssignNewLeader(oldLeader, this));
DatabaseManager.Clubs.Update(this);
}
private static void HandleJoin(GameSession session, PacketReader packet)
{
Party party = GameServer.PartyManager.GetPartyById(session.Player.PartyId);
if (party == null)
{
return;
}
long clubId = packet.ReadLong();
Club club = GameServer.ClubManager.GetClubById(clubId);
if (club == null)
{
return;
}
if (club.Leader.CharacterId == session.Player.CharacterId)
{
party.BroadcastPacketParty(ClubPacket.UpdatePlayerClubList(session.Player, club));
}
else
{
int response = packet.ReadInt(); // 0 = accept, 76 (0x4C) = reject
if (response == 0)
{
party.BroadcastPacketParty(ClubPacket.ConfirmCreate(club.Id));
club.Leader.Session.Send(ClubPacket.Join(session.Player, club));
club.Leader.Session.Send(ClubPacket.Establish(club));
// TODO add member to club (club.AddMember(session.Player);)
}
else
{
// TODO update to proper rejection packet
party.Leader.Session.Send(ChatPacket.Send(party.Leader, session.Player.Name + " declined the invitation.", ChatType.NoticeAlert2));
}
}
}
private static void HandleSendInvite(GameSession session, PacketReader packet)
{
long clubId = packet.ReadLong();
string invitee = packet.ReadUnicodeString();
Player other = GameServer.PlayerManager.GetPlayerByName(invitee);
if (other == null)
{
return;
}
if (other.Clubs.Any(x => x.Id == clubId))
{
session.Send(ClubPacket.ErrorNotice((int)ClubErrorNotice.AlreadyInClub));
return;
}
if (other.Clubs.Count >= int.Parse(ConstantsMetadataStorage.GetConstant("ClubMaxCount")))
{
session.Send(ClubPacket.ErrorNotice((int)ClubErrorNotice.PlayerCannotJoinMoreClubs));
return;
}
Club club = GameServer.ClubManager.GetClubById(clubId);
if (club == null)
{
return;
}
if (club.Members.Count >= int.Parse(ConstantsMetadataStorage.GetConstant("ClubMaxMembers")))
{
session.Send(ClubPacket.ErrorNotice((int)ClubErrorNotice.ClubIsFull));
return;
}
session.Send(ClubPacket.InviteSentReceipt(clubId, other));
other.Session.Send(ClubPacket.Invite(club, other));
}
private static void HandleSendInvite(GameSession session, PacketReader packet)
{
long clubId = packet.ReadLong();
string invitee = packet.ReadUnicodeString();
Player other = GameServer.Storage.GetPlayerByName(invitee);
if (other == null)
{
return;
}
Club club = GameServer.ClubManager.GetClubById(clubId);
if (club == null)
{
return;
}
// TODO check that the club can fit more people, if it's at max members, return/leave error
session.Send(ClubPacket.InviteSentReceipt(clubId, other));
other.Session.Send(ClubPacket.Invite(club, other));
}
private static void HandleInviteResponse(GameSession session, PacketReader packet)
{
long clubId = packet.ReadLong();
string clubName = packet.ReadUnicodeString();
string clubLeader = packet.ReadUnicodeString();
string invitee = packet.ReadUnicodeString(); //playerName. TODO: verify player name
byte response = packet.ReadByte(); // 1 = accept
Club club = GameServer.ClubManager.GetClubById(clubId);
if (club == null)
{
return;
}
Player other = GameServer.Storage.GetPlayerByName(invitee);
if (other == null)
{
return;
}
if (response == 1)
{
club.Leader.Session.Send(ClubPacket.LeaderInviteResponse(club, invitee, response));
club.BroadcastPacketClub(ClubPacket.ConfirmInvite(club, other.Session.Player));
other.Session.Send(ClubPacket.InviteResponse(club, session.Player));
other.Session.Send(ClubPacket.Join(session.Player, club));
other.Session.Send(ClubPacket.UpdateClub(club));
club.BroadcastPacketClub(ClubPacket.UpdatePlayerClubList(session.Player, club));
// TODO add member to club (club.AddMember(other);)
}
else
{
club.Leader.Session.Send(ClubPacket.LeaderInviteResponse(club, invitee, response));
other.Session.Send(ClubPacket.InviteResponse(club, session.Player));
}
}
protected override void EndSession(bool logoutNotice)
{
if (Player is null || FieldManager is null)
{
return;
}
FieldManager.RemovePlayer(Player);
GameServer.PlayerManager.RemovePlayer(Player);
Player.OnlineCTS.Cancel();
Player.OnlineTimeThread = null;
CoordF safeCoord = Player.SafeBlock;
safeCoord.Z += Block.BLOCK_SIZE;
Player.SavedCoord = safeCoord;
// if session is not changing channels or servers, send the logout message
if (logoutNotice)
{
Player.Session = null;
GameServer.BuddyManager.SetFriendSessions(Player);
Player.Party?.CheckOfflineParty(Player);
Player.Guild?.BroadcastPacketGuild(GuildPacket.MemberLoggedOff(Player));
Player.UpdateBuddies();
foreach (Club club in Player.Clubs)
{
club?.BroadcastPacketClub(ClubPacket.LogoutNotice(Player, club));
}
foreach (GroupChat groupChat in Player.GroupChats)
{
groupChat?.BroadcastPacketGroupChat(GroupChatPacket.LogoutNotice(groupChat, Player));
groupChat?.CheckOfflineGroupChat();
}
Player.IsMigrating = false;
if (MapMetadataStorage.MapIsInstancedOnly(Player.MapId) && !MapMetadataStorage.MapIsTutorial(Player.MapId))
{
Player.SavedCoord = Player.ReturnCoord;
Player.MapId = Player.ReturnMapId;
}
AuthData authData = Player.Account.AuthData;
authData.OnlineCharacterId = 0;
DatabaseManager.AuthData.UpdateOnlineCharacterId(authData);
}
List <GameEventUserValue> userTimeValues = Player.EventUserValues.Where(x => x.EventType == GameEventUserValueType.AttendanceAccumulatedTime).ToList();
foreach (GameEventUserValue userValue in userTimeValues)
{
if (!long.TryParse(userValue.EventValue, out long timeAccumulated))
{
timeAccumulated = 0;
}
timeAccumulated += TimeInfo.Now() - Player.LastLogTime;
userValue.EventValue = timeAccumulated.ToString();
DatabaseManager.GameEventUserValue.Update(userValue);
}
Player.LastLogTime = TimeInfo.Now();
Player.Account.LastLogTime = TimeInfo.Now();
if (Player.GuildMember is not null)
{
Player.GuildMember.LastLogTimestamp = TimeInfo.Now();
}
DatabaseManager.Characters.Update(Player);
}
public override void Handle(GameSession session, PacketReader packet)
{
long accountId = packet.ReadLong();
if (accountId is 0)
{
Logger.Error("Account ID was 0. Login has failed or connection was made directly to game server.");
session.Send(LoginResultPacket.SendLoginMode(LoginMode.SessionVerificationFailed));
return;
}
AuthData authData = DatabaseManager.AuthData.GetByAccountId(accountId);
if (authData is null)
{
Logger.Error("AuthData with account ID {accountId} was not found in database.", accountId);
session.Send(LoginResultPacket.SendLoginMode(LoginMode.SystemErrorDB));
return;
}
Player dbPlayer = DatabaseManager.Characters.FindPlayerById(authData.OnlineCharacterId, session);
// Backwards seeking because we read accountId here
packet.Skip(-8);
HandleCommon(session, packet);
session.InitPlayer(dbPlayer);
Player player = session.Player;
player.BuddyList = GameServer.BuddyManager.GetBuddies(player.CharacterId);
player.Mailbox = GameServer.MailManager.GetMails(player.CharacterId);
GameServer.PlayerManager.AddPlayer(player);
GameServer.BuddyManager.SetFriendSessions(player);
// Only send buddy login notification if player is not changing channels
if (!player.IsMigrating)
{
player.UpdateBuddies();
}
if (player.GuildId != 0)
{
Guild guild = GameServer.GuildManager.GetGuildById(player.GuildId);
player.Guild = guild;
GuildMember guildMember = guild.Members.First(x => x.Id == player.CharacterId);
guildMember.Player = player;
player.GuildMember = guildMember;
session.Send(GuildPacket.UpdateGuild(guild));
guild.BroadcastPacketGuild(GuildPacket.UpdatePlayer(player));
if (!player.IsMigrating)
{
guild.BroadcastPacketGuild(GuildPacket.MemberLoggedIn(player), session);
}
}
// Get Clubs
foreach (ClubMember member in player.ClubMembers)
{
Club club = GameServer.ClubManager.GetClubById(member.ClubId);
club.Members.First(x => x.Player.CharacterId == player.CharacterId).Player = player;
club.BroadcastPacketClub(ClubPacket.UpdateClub(club));
if (!player.IsMigrating)
{
club.BroadcastPacketClub(ClubPacket.LoginNotice(player, club), session);
}
player.Clubs.Add(club);
member.Player = player;
}
// Get Group Chats
player.GroupChats = GameServer.GroupChatManager.GetGroupChatsByMember(player.CharacterId);
foreach (GroupChat groupChat in player.GroupChats)
{
session.Send(GroupChatPacket.Update(groupChat));
if (!player.IsMigrating)
{
groupChat.BroadcastPacketGroupChat(GroupChatPacket.LoginNotice(groupChat, player));
}
}
//session.Send(0x27, 0x01); // Meret market related...?
session.Send(MushkingRoyaleSystemPacket.LoadStats(player.Account.MushkingRoyaleStats));
session.Send(MushkingRoyaleSystemPacket.LoadMedals(player.Account));
player.GetUnreadMailCount();
session.Send(BuddyPacket.Initialize());
session.Send(BuddyPacket.LoadList(player.BuddyList));
session.Send(BuddyPacket.EndList(player.BuddyList.Count));
// Meret market
session.Player.GetMeretMarketPersonalListings();
session.Player.GetMeretMarketSales();
// UserConditionEvent
//session.Send("BF 00 00 00 00 00 00".ToByteArray());
// PCBangBonus
//session.Send("A7 00 03 00 00 00 00 00 00 00 00 00 00 00 00 00".ToByteArray());
session.Send(TimeSyncPacket.SetInitial1());
session.Send(TimeSyncPacket.SetInitial2());
session.Send(StatPacket.SetStats(session.Player.FieldPlayer));
// session.Send(StatPacket.SetStats(session.Player.FieldPlayer)); // Second packet is meant to send the stats initialized, for now we'll just send the first one
session.Player.ClientTickSyncLoop();
session.Send(DynamicChannelPacket.DynamicChannel(short.Parse(ConstantsMetadataStorage.GetConstant("ChannelCount"))));
session.Send(ServerEnterPacket.Enter(session));
session.Send(UGCPacket.Unknown22());
session.Send(CashPacket.Unknown09());
// SendContentShutdown f(0x01, 0x04)
session.Send(PvpPacket.Mode0C());
session.Send(SyncNumberPacket.Send());
session.Send(SyncValuePacket.SetSyncValue(120000)); // unknown what this value means
session.Send(PrestigePacket.SetLevels(player));
session.Send(PrestigePacket.WeeklyMissions(player.PrestigeMissions));
// Load inventory tabs
foreach (InventoryTab tab in Enum.GetValues(typeof(InventoryTab)))
{
player.Inventory.LoadInventoryTab(session, tab);
}
if (player.Account.HomeId != 0)
{
Home home = GameServer.HomeManager.GetHomeById(player.Account.HomeId);
player.Account.Home = home;
session.Send(WarehouseInventoryPacket.StartList());
int counter = 0;
foreach (KeyValuePair <long, Item> kvp in home.WarehouseInventory)
{
session.Send(WarehouseInventoryPacket.Load(kvp.Value, ++counter));
}
session.Send(WarehouseInventoryPacket.EndList());
session.Send(FurnishingInventoryPacket.StartList());
foreach (Cube cube in home.FurnishingInventory.Values.Where(x => x.Item != null))
{
session.Send(FurnishingInventoryPacket.Load(cube));
}
session.Send(FurnishingInventoryPacket.EndList());
}
session.Send(QuestPacket.StartList());
session.Send(QuestPacket.Packet1F());
session.Send(QuestPacket.Packet20());
IEnumerable <List <QuestStatus> > packetCount = player.QuestData.Values.ToList().SplitList(200); // Split the quest list in 200 quests per packet
foreach (List <QuestStatus> item in packetCount)
{
session.Send(QuestPacket.SendQuests(item));
}
session.Send(QuestPacket.EndList());
session.Send(TrophyPacket.WriteTableStart());
List <Trophy> trophyList = new(player.TrophyData.Values);
IEnumerable <List <Trophy> > trophyListPackets = trophyList.SplitList(60);
foreach (List <Trophy> trophy in trophyListPackets)
{
session.Send(TrophyPacket.WriteTableContent(trophy));
}
// SendQuest, SendAchieve, SendManufacturer, SendUserMaid
session.Send(UserEnvPacket.SetTitles(player));
session.Send(UserEnvPacket.Send04());
session.Send(UserEnvPacket.Send05());
session.Send(UserEnvPacket.UpdateLifeSkills(player.GatheringCount));
session.Send(UserEnvPacket.Send09());
session.Send(UserEnvPacket.Send10());
session.Send(UserEnvPacket.Send12());
session.Send(MeretMarketPacket.ModeC9());
session.Send(FishingPacket.LoadAlbum(player));
session.Send(PvpPacket.Mode16());
session.Send(PvpPacket.Mode17());
session.Send(ResponsePetPacket.LoadAlbum());
// LegionBattle (0xF6)
// CharacterAbility
// E1 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
// If the character is not a new character, this is what we would send
session.Send(KeyTablePacket.SendFullOptions(player.GameOptions));
if (player.MapId == (int)Map.UnknownLocation) // tutorial map
{
session.Send(KeyTablePacket.AskKeyboardOrMouse());
}
GameEventHelper.LoadEvents(session.Player);
List <GameEvent> gameEvents = DatabaseManager.Events.FindAll();
IEnumerable <List <GameEvent> > gameEventPackets = gameEvents.SplitList(5);
foreach (List <GameEvent> gameEvent in gameEventPackets)
{
session.Send(GameEventPacket.Load(gameEvent));
}
// SendKeyTable f(0x00), SendGuideRecord f(0x03), GameEvent f(0x00)
// SendBannerList f(0x19), SendRoomDungeon f(0x05, 0x14, 0x17)
session.Send(DungeonListPacket.DungeonList());
// 0xF0, ResponsePet P(0F 01)
// RequestFieldEnter
//session.Send("16 00 00 41 75 19 03 00 01 8A 42 0F 00 00 00 00 00 00 C0 28 C4 00 40 03 44 00 00 16 44 00 00 00 00 00 00 00 00 55 FF 33 42 E8 49 01 00".ToByteArray());
session.Send(RequestFieldEnterPacket.RequestEnter(player.FieldPlayer));
Party party = GameServer.PartyManager.GetPartyByMember(player.CharacterId);
if (party != null)
{
player.Party = party;
if (!player.IsMigrating)
{
party.BroadcastPacketParty(PartyPacket.LoginNotice(player), session);
}
session.Send(PartyPacket.Create(party, false));
party.BroadcastPacketParty(PartyPacket.UpdatePlayer(player));
party.BroadcastPacketParty(PartyPacket.UpdateDungeonInfo(player));
}
player.IsMigrating = false;
// SendUgc: 15 01 00 00 00 00 00 00 00 00 00 00 00 4B 00 00 00
session.Send(HomeCommandPacket.LoadHome(player));
player.TimeSyncLoop();
session.Send(TimeSyncPacket.SetSessionServerTick(0));
//session.Send("B9 00 00 E1 0F 26 89 7F 98 3C 26 00 00 00 00 00 00 00 00".ToByteArray());
session.Send(ServerEnterPacket.Confirm());
//session.Send(0xF0, 0x00, 0x1F, 0x78, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00);
//session.Send(0x28, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00);
}
