private static void HandleUpgradeBuff(GameSession session, PacketReader packet)
{
int buffId = packet.ReadInt();
Guild guild = GameServer.GuildManager.GetGuildById(session.Player.Guild.Id);
if (guild == null)
{
return;
}
GuildBuff buff = guild.Buffs.First(x => x.Id == buffId);
// get next level's data
GuildBuffLevel metadata = GuildBuffMetadataStorage.GetGuildBuffLevelData(buffId, buff.Level + 1);
GuildPropertyMetadata guildProperty = GuildPropertyMetadataStorage.GetMetadata(guild.Exp);
if (guildProperty.Level < metadata.LevelRequirement)
{
return;
}
if (guild.Funds < metadata.UpgradeCost)
{
return;
}
guild.ModifyFunds(session, guildProperty, -metadata.UpgradeCost);
buff.Level++;
guild.BroadcastPacketGuild(GuildPacket.UpgradeBuff(buffId, buff.Level, session.Player.Name));
}
private static void HandleTransferLeader(GameSession session, PacketReader packet)
{
string target = packet.ReadUnicodeString();
Player newLeader = GameServer.Storage.GetPlayerByName(target);
if (newLeader == null)
{
return;
}
Player oldLeader = session.Player;
Guild guild = GameServer.GuildManager.GetGuildByLeader(oldLeader);
if (guild == null || guild.LeaderCharacterId != oldLeader.CharacterId)
{
return;
}
GuildMember newLeaderMember = guild.Members.FirstOrDefault(x => x.Player.CharacterId == newLeader.CharacterId);
GuildMember oldLeaderMember = guild.Members.FirstOrDefault(x => x.Player.CharacterId == oldLeader.CharacterId);
newLeaderMember.Rank = 0;
oldLeaderMember.Rank = 1;
guild.LeaderCharacterId = newLeader.CharacterId;
guild.LeaderAccountId = newLeader.AccountId;
guild.LeaderName = newLeader.Name;
session.Send(GuildPacket.TransferLeaderConfirm(newLeader));
guild.BroadcastPacketGuild(GuildPacket.AssignNewLeader(newLeader, oldLeader));
guild.AssignNewLeader(oldLeader, newLeader);
}
public static void Handle(Entities.GameClient client, GuildPacket guild)
{
if (client.Guild != null)
{
client.Guild.DonateCPs(client, guild.Data);
}
}
private static void HandleUpgradeHome(GameSession session, PacketReader packet)
{
int themeId = packet.ReadInt();
Guild guild = GameServer.GuildManager.GetGuildById(session.Player.Guild.Id);
if (guild == null || guild.Leader != session.Player)
{
return;
}
GuildHouseMetadata houseMetadata = GuildHouseMetadataStorage.GetMetadataByThemeId(guild.HouseRank + 1, themeId);
if (houseMetadata == null)
{
return;
}
GuildPropertyMetadata guildProperty = GuildPropertyMetadataStorage.GetMetadata(guild.Exp);
if (guildProperty.Level < houseMetadata.RequiredLevel ||
guild.Funds < houseMetadata.UpgradeCost)
{
return;
}
guild.ModifyFunds(session, guildProperty, -houseMetadata.UpgradeCost);
guild.HouseRank = houseMetadata.Level;
guild.HouseTheme = houseMetadata.Theme;
guild.BroadcastPacketGuild(GuildPacket.ChangeHouse(session.Player.Name, guild.HouseRank, guild.HouseTheme)); // need to confirm if this is the packet used when upgrading
}
private static void HandleInvite(GameSession session, PacketReader packet)
{
string targetPlayer = packet.ReadUnicodeString();
Guild guild = GameServer.GuildManager.GetGuildByLeader(session.Player);
if (guild == null)
{
return;
}
Player playerInvited = GameServer.Storage.GetPlayerByName(targetPlayer);
if (playerInvited == null)
{
session.Send(GuildPacket.ErrorNotice((byte)GuildErrorNotice.UnableToSendInvite));
}
if (playerInvited.Guild != null)
{
session.Send(GuildPacket.ErrorNotice((byte)GuildErrorNotice.CharacterIsAlreadyInAGuild));
return;
}
if (guild.Members.Count >= guild.Capacity)
{
//TODO Plug in 'full guild' error packets
return;
}
session.Send(GuildPacket.InviteConfirm(playerInvited));
playerInvited.Session.Send(GuildPacket.SendInvite(session.Player, playerInvited, guild));
}
private static void HandleGuildNotice(GameSession session, PacketReader packet)
{
packet.ReadByte();
string notice = packet.ReadUnicodeString();
Guild guild = GameServer.GuildManager.GetGuildById(session.Player.Guild.Id);
if (guild == null)
{
return;
}
GuildMember member = guild.Members.FirstOrDefault(x => x.Player == session.Player);
if (member == null)
{
return;
}
if (!((GuildRights)guild.Ranks[member.Rank].Rights).HasFlag(GuildRights.CanGuildNotice))
{
return;
}
session.Send(GuildPacket.GuildNoticeConfirm(notice));
guild.BroadcastPacketGuild(GuildPacket.GuildNoticeChange(session.Player, notice));
}
private static void HandleSubmitApplication(GameSession session, PacketReader packet)
{
long guildId = packet.ReadLong();
if (session.Player.GuildApplications.Count >= 10)
{
return;
}
Guild guild = GameServer.GuildManager.GetGuildById(guildId);
if (guild == null)
{
return;
}
GuildApplication application = new GuildApplication(session.Player.CharacterId, guild.Id);
application.Add(session.Player, guild);
session.Send(GuildPacket.SubmitApplication(application, guild.Name));
foreach (GuildMember member in guild.Members)
{
if (((GuildRights)guild.Ranks[member.Rank].Rights).HasFlag(GuildRights.CanInvite))
{
member.Player.Session.Send(GuildPacket.SendApplication(application, session.Player));
}
}
}
private static void HandleDisband(GameSession session)
{
Guild guild = GameServer.GuildManager.GetGuildByLeader(session.Player);
if (guild == null)
{
return;
}
// Remove any applications
if (guild.Applications.Count > 0)
{
foreach (GuildApplication application in guild.Applications)
{
Player player = GameServer.Storage.GetPlayerById(application.CharacterId);
if (player == null)
{
continue;
}
application.Remove(player, guild);
// TODO: Send mail to player as rejected auto message
}
}
session.Send(GuildPacket.DisbandConfirm());
session.FieldManager.BroadcastPacket(GuildPacket.UpdateGuildTag(session.Player));
guild.RemoveMember(session.Player);
GameServer.GuildManager.RemoveGuild(guild);
DatabaseManager.Guilds.Delete(guild.Id);
}
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
}
private static void HandleWithdrawApplication(GameSession session, PacketReader packet)
{
long guildApplicationId = packet.ReadLong();
GuildApplication application = session.Player.GuildApplications.FirstOrDefault(x => x.Id == guildApplicationId);
if (application == null)
{
return;
}
Guild guild = GameServer.GuildManager.GetGuildById(application.GuildId);
if (guild == null)
{
return;
}
application.Remove(session.Player, guild);
session.Send(GuildPacket.WithdrawApplicationPlayerUpdate(application, guild.Name));
foreach (GuildMember member in guild.Members)
{
if (((GuildRights)guild.Ranks[member.Rank].Rights).HasFlag(GuildRights.CanInvite))
{
member.Player.Session.Send(GuildPacket.WithdrawApplicationGuildUpdate(application.Id));
}
}
}
private static void HandleCheckIn(GameSession session)
{
Guild guild = GameServer.GuildManager.GetGuildById(session.Player.Guild.Id);
if (guild == null)
{
return;
}
GuildMember member = guild.Members.First(x => x.Player == session.Player);
// Check if attendance timestamp is today
DateTimeOffset date = DateTimeOffset.FromUnixTimeSeconds(member.AttendanceTimestamp);
if (date == DateTime.Today)
{
return;
}
int contributionAmount = GuildContributionMetadataStorage.GetContributionAmount("attend");
GuildPropertyMetadata property = GuildPropertyMetadataStorage.GetMetadata(guild.Exp);
member.AddContribution(contributionAmount);
member.AttendanceTimestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds() + Environment.TickCount;
session.Send(GuildPacket.CheckInBegin());
Item guildCoins = new Item(30000861)
{
Amount = property.AttendGuildCoin
};
InventoryController.Add(session, guildCoins, true);
guild.AddExp(session, property.AttendExp);
guild.ModifyFunds(session, property, property.AttendFunds);
guild.BroadcastPacketGuild(GuildPacket.UpdatePlayerContribution(member, contributionAmount));
session.Send(GuildPacket.FinishCheckIn(member));
}
private static void HandleChangeHomeTheme(GameSession session, PacketReader packet)
{
int themeId = packet.ReadInt();
Guild guild = GameServer.GuildManager.GetGuildById(session.Player.Guild.Id);
if (guild == null || guild.LeaderCharacterId != session.Player.CharacterId)
{
return;
}
GuildHouseMetadata houseMetadata = GuildHouseMetadataStorage.GetMetadataByThemeId(guild.HouseRank, themeId);
if (houseMetadata == null)
{
return;
}
GuildPropertyMetadata guildProperty = GuildPropertyMetadataStorage.GetMetadata(guild.Exp);
if (guild.Funds < houseMetadata.UpgradeCost)
{
return;
}
guild.ModifyFunds(session, guildProperty, -houseMetadata.RethemeCost);
guild.HouseTheme = houseMetadata.Theme;
guild.BroadcastPacketGuild(GuildPacket.ChangeHouse(session.Player.Name, guild.HouseRank, guild.HouseTheme));
}
private static void HandleGuildMail(GameSession session, IPacketReader packet)
{
string title = packet.ReadUnicodeString();
string body = packet.ReadUnicodeString();
Player sender = session.Player;
Guild guild = sender.Guild;
if (guild == null)
{
return;
}
byte senderRank = sender.GuildMember.Rank;
GuildRank guildRank = guild.Ranks[senderRank];
if (!guildRank.HasRight(GuildRights.CanGuildMail))
{
session.Send(GuildPacket.ErrorNotice((byte)GuildErrorNotice.InsufficientPermissions));
return;
}
session.Send(GuildPacket.SendMail());
IEnumerable <long> recipientIds = guild.Members.Select(c => c.Player.CharacterId);
foreach (long recipientId in recipientIds)
{
MailHelper.SendMail(MailType.Player, recipientId, sender.CharacterId, sender.Name, title, body, "", "", new(), 0, 0, out Mail mail);
}
}
public void AddExp(GameSession session, int expGain)
{
Exp += expGain;
BroadcastPacketGuild(GuildPacket.UpdateGuildExp(Exp));
session.Send(GuildPacket.UpdateGuildStatsNotice(expGain, 0));
DatabaseManager.Guilds.Update(this);
}
private static void HandleSearchGuildByName(GameSession session, PacketReader packet)
{
string name = packet.ReadUnicodeString();
List <Guild> guildList = GameServer.GuildManager.GetGuildListByName(name);
session.Send(GuildPacket.DisplayGuildList(guildList));
}
public static void Handle(Entities.GameClient client, GuildPacket guild)
{
if (client.Guild != null)
{
if (client.GuildMemberInfo.Rank == Enums.GuildRank.GuildLeader)
client.Guild.SetBullentin(client, guild.Strings[0]);
}
}
private static void HandleApplicationResponse(GameSession session, PacketReader packet)
{
long guildApplicationId = packet.ReadLong();
byte response = packet.ReadByte();
Guild guild = GameServer.GuildManager.GetGuildById(session.Player.Guild.Id);
if (guild == null)
{
return;
}
GuildApplication application = guild.Applications.FirstOrDefault(x => x.Id == guildApplicationId);
if (application == null)
{
return;
}
Player applier = GameServer.Storage.GetPlayerById(application.CharacterId);
session.Send(GuildPacket.ApplicationResponse(guildApplicationId, applier.Name, response));
if (response == 1)
{
session.Send(GuildPacket.InviteNotification(applier.Name, response));
}
guild.BroadcastPacketGuild(GuildPacket.ApplicationResponseBroadcastNotice(session.Player.Name, applier.Name, response, guildApplicationId));
application.Remove(applier, guild);
if (applier.Session != null)
{
applier.Session.Send(GuildPacket.ApplicationResponseToApplier(guild.Name, guildApplicationId, response));
}
if (response == 0)
{
if (applier.Session != null)
{
// TODO: Send System mail for rejection
}
return;
}
guild.AddMember(applier);
if (applier.Session != null)
{
applier.Session.Send(GuildPacket.InviteResponseConfirm(session.Player, applier, guild, response));
applier.Session.FieldManager.BroadcastPacket(GuildPacket.UpdateGuildTag2(applier, guild.Name));
}
GuildMember member = guild.Members.FirstOrDefault(x => x.Player == applier);
guild.BroadcastPacketGuild(GuildPacket.MemberBroadcastJoinNotice(member, session.Player.Name, false));
guild.BroadcastPacketGuild(GuildPacket.MemberJoin(applier));
guild.BroadcastPacketGuild(GuildPacket.UpdateGuild(guild));
}
public static void Handle(Entities.GameClient client, GuildPacket guild)
{
if (guild.Data == 0)
return;
if (guild.Data == client.EntityUID)
return;
if (client.Guild == null)
return;
if (client.ApplyGuildMemberUID == 0)
{
Entities.GameClient inviteto;
if (Core.Kernel.Clients.TrySelect(guild.Data, out inviteto))
{
if (!inviteto.IsInMap(client))
return;
if (inviteto.Guild == null && client.Guild != null)
{
if (client.GuildMemberInfo.Rank == Enums.GuildRank.DeputyLeader ||
client.GuildMemberInfo.Rank == Enums.GuildRank.GuildLeader)
{
inviteto.ApplyGuildMemberUID = client.EntityUID;
using (var invite = new Packets.GuildPacket(new Packets.StringPacker()))
{
invite.Action = Enums.GuildAction.InviteJoin;
invite.Data = client.EntityUID;
inviteto.Send(invite);
}
}
}
}
return;
}
if (client.ApplyGuildMemberUID != guild.Data)
return;
client.ApplyGuildMemberUID = 0;
Entities.GameClient newclient;
if (Core.Kernel.Clients.TrySelect(guild.Data, out newclient))
{
if (!newclient.IsInMap(client))
return;
if (newclient.Guild == null && client.Guild != null)
{
if (client.GuildMemberInfo.Rank == Enums.GuildRank.DeputyLeader ||
client.GuildMemberInfo.Rank == Enums.GuildRank.GuildLeader)
{
client.Guild.AddMember(newclient);
newclient.LoadGuildInfo();
//newclient.Screen.FullUpdate();
}
}
}
}
public static void Handle(Entities.GameClient client, GuildPacket guild)
{
if (client.Guild != null)
{
if (client.GuildMemberInfo.Rank != Enums.GuildRank.GuildLeader)
{
client.Guild.RemoveMember(client.GuildMemberInfo);
}
}
}
public static void Handle(Entities.GameClient client, GuildPacket guild)
{
if (client.Guild != null)
{
if (client.GuildMemberInfo.Rank == Enums.GuildRank.GuildLeader)
{
client.Guild.KickMember(guild.Strings[0]);
}
}
}
public static void Handle(Entities.GameClient client, GuildPacket guild)
{
if (client.Guild != null)
{
if (client.GuildMemberInfo.Rank != Enums.GuildRank.GuildLeader)
{
client.Guild.RemoveMember(client.GuildMemberInfo);
}
}
}
public static void Handle(Entities.GameClient client, GuildPacket guild)
{
if (client.Guild != null)
{
client.SendGuild();
using (var announce = new Packets.GuildPacket(new Packets.StringPacker(client.Guild.Bullentin)))
{
announce.Data = Core.Kernel.TimeGet(Enums.TimeType.Day);
announce.Action = Enums.GuildAction.SetAnnounce;
client.Send(announce);
}
}
}
public static void Handle(Entities.GameClient client, GuildPacket guild)
{
if (client.Guild != null)
{
client.SendGuild();
using (var announce = new Packets.GuildPacket(new Packets.StringPacker(client.Guild.Bullentin)))
{
announce.Data = Core.Kernel.TimeGet(Enums.TimeType.Day);
announce.Action = Enums.GuildAction.SetAnnounce;
client.Send(announce);
}
}
}
private static void HandleCreate(GameSession session, PacketReader packet)
{
string guildName = packet.ReadUnicodeString();
if (session.Player.Guild != null)
{
return;
}
if (!session.Player.Wallet.Meso.Modify(-2000))
{
session.Send(GuildPacket.ErrorNotice((byte)GuildErrorNotice.NotEnoughMesos));
return;
}
Guild newGuild;
if (DatabaseManager.GuildExists(guildName))
{
session.Send(GuildPacket.ErrorNotice((byte)GuildErrorNotice.GuildWithSameNameExists));
return;
}
newGuild = new(guildName);
if (!DatabaseManager.CreateGuild(newGuild))
{
throw new ArgumentException("Could not create guild");
}
GameServer.GuildManager.AddGuild(newGuild);
newGuild.AddLeader(session.Player);
session.FieldManager.BroadcastPacket(GuildPacket.UpdateGuildTag2(session.Player, guildName));
session.Send(GuildPacket.Create(guildName));
string inviter = ""; // nobody because nobody invited the guild leader
GuildMember member = newGuild.Members.FirstOrDefault(x => x.Player == session.Player);
session.Send(GuildPacket.UpdateGuild(newGuild));
session.Send(GuildPacket.MemberBroadcastJoinNotice(member, inviter, false));
session.Send(GuildPacket.MemberJoin(session.Player));
// Remove any applications
foreach (GuildApplication application in session.Player.GuildApplications)
{
Guild guild = GameServer.GuildManager.GetGuildById(application.GuildId);
application.Remove(session.Player, guild);
}
}
private static void HandleLeave(GameSession session)
{
Guild guild = GameServer.GuildManager.GetGuildById(session.Player.Guild.Id);
if (guild == null)
{
return;
}
session.Send(GuildPacket.LeaveConfirm());
session.FieldManager.BroadcastPacket(GuildPacket.UpdateGuildTag(session.Player));
guild.BroadcastPacketGuild(GuildPacket.MemberLeaveNotice(session.Player));
guild.RemoveMember(session.Player);
}
private static void HandleListGuild(GameSession session, PacketReader packet)
{
bool toggle = packet.ReadBool();
Guild guild = GameServer.GuildManager.GetGuildByLeader(session.Player);
if (guild == null)
{
return;
}
guild.Searchable = toggle;
session.Send(GuildPacket.ListGuildConfirm(toggle));
session.Send(GuildPacket.ListGuildUpdate(session.Player, toggle));
}
private static void HandleInviteResponse(GameSession session, PacketReader packet)
{
long guildId = packet.ReadLong();
string guildName = packet.ReadUnicodeString();
packet.ReadShort();
string inviterName = packet.ReadUnicodeString();
string inviteeName = packet.ReadUnicodeString();
byte response = packet.ReadByte(); // 01 accept
Guild guild = GameServer.GuildManager.GetGuildById(guildId);
if (guild == null)
{
return;
}
Player inviter = GameServer.PlayerManager.GetPlayerByName(inviterName);
if (inviter == null)
{
return;
}
if (response == 00)
{
inviter.Session.Send(GuildPacket.InviteNotification(inviteeName, 256));
session.Send(GuildPacket.InviteResponseConfirm(inviter, session.Player, guild, response));
return;
}
guild.AddMember(session.Player);
GuildMember member = guild.Members.FirstOrDefault(x => x.Player == session.Player);
if (member == null)
{
return;
}
inviter.Session.Send(GuildPacket.InviteNotification(inviteeName, response));
session.Send(GuildPacket.InviteResponseConfirm(inviter, session.Player, guild, response));
session.FieldManager.BroadcastPacket(GuildPacket.UpdateGuildTag2(session.Player, guildName));
guild.BroadcastPacketGuild(GuildPacket.MemberBroadcastJoinNotice(member, inviterName, true));
guild.BroadcastPacketGuild(GuildPacket.MemberJoin(session.Player), session);
session.Send(GuildPacket.UpdateGuild(guild));
TrophyManager.OnGuildJoin(session.Player);
}
public static void Handle(Entities.GameClient client, GuildPacket guild)
{
uint guilduid = guild.Data;
if (guilduid > 0)
{
Data.Guild realguild;
if (Core.Kernel.Guilds.TrySelect(guilduid, out realguild))
{
using (var stringpacket = new Packets.StringPacket(new StringPacker(realguild.StringInfo)))
{
stringpacket.Action = Enums.StringAction.Guild;
stringpacket.Data = guilduid;
client.Send(stringpacket);
}
}
}
}
private static void HandleKick(GameSession session, PacketReader packet)
{
string target = packet.ReadUnicodeString();
Player targetPlayer = GameServer.Storage.GetPlayerByName(target);
if (targetPlayer == null)
{
return;
}
Guild guild = GameServer.GuildManager.GetGuildByLeader(session.Player);
if (guild == null)
{
return;
}
if (targetPlayer.CharacterId == guild.LeaderCharacterId)
{
//TODO: Error packets
return;
}
GuildMember selfPlayer = guild.Members.FirstOrDefault(x => x.Player == session.Player);
if (selfPlayer == null)
{
return;
}
if (!((GuildRights)guild.Ranks[selfPlayer.Rank].Rights).HasFlag(GuildRights.CanInvite))
{
return;
}
session.Send(GuildPacket.KickConfirm(targetPlayer));
if (targetPlayer.Session != null)
{
targetPlayer.Session.Send(GuildPacket.KickNotification(session.Player));
targetPlayer.Session.FieldManager.BroadcastPacket(GuildPacket.UpdateGuildTag(targetPlayer));
}
guild.RemoveMember(targetPlayer);
guild.BroadcastPacketGuild(GuildPacket.KickMember(targetPlayer, session.Player));
}
public static void Handle(Entities.GameClient client, GuildPacket guild)
{
uint guilduid = guild.Data;
if (guilduid > 0)
{
Data.Guild realguild;
if (Core.Kernel.Guilds.TrySelect(guilduid, out realguild))
{
using (var stringpacket = new Packets.StringPacket(new StringPacker(realguild.StringInfo)))
{
stringpacket.Action = Enums.StringAction.Guild;
stringpacket.Data = guilduid;
client.Send(stringpacket);
}
}
}
}
private static void HandleGuildDonate(GameSession session, PacketReader packet)
{
int donateQuantity = packet.ReadInt();
int donationAmount = donateQuantity * 10000;
Guild guild = GameServer.GuildManager.GetGuildById(session.Player.Guild.Id);
if (guild == null)
{
return;
}
GuildPropertyMetadata guildProperty = GuildPropertyMetadataStorage.GetMetadata(guild.Exp);
GuildMember member = guild.Members.First(x => x.Player == session.Player);
if (member.DailyDonationCount >= guildProperty.DonationMax)
{
return;
}
if (!session.Player.Wallet.Meso.Modify(-donationAmount))
{
session.Send(GuildPacket.ErrorNotice((byte)GuildErrorNotice.NotEnoughMesos));
return;
}
Item coins = new(30000861)
{
Rarity = 4,
Amount = guildProperty.DonateGuildCoin * donateQuantity
};
session.Player.Inventory.AddItem(session, coins, true);
int contribution = GuildContributionMetadataStorage.GetContributionAmount("donation");
member.DailyDonationCount += (byte)donateQuantity;
member.AddContribution(contribution * donateQuantity);
guild.ModifyFunds(session, guildProperty, donationAmount);
session.Send(GuildPacket.UpdatePlayerDonation());
guild.BroadcastPacketGuild(GuildPacket.UpdatePlayerContribution(member, donateQuantity));
}
private static void HandleUpdateRank(GameSession session, PacketReader packet)
{
byte rankIndex = packet.ReadByte();
byte rankIndex2 = packet.ReadByte(); // repeat
string rankName = packet.ReadUnicodeString();
int rights = packet.ReadInt();
Guild guild = GameServer.GuildManager.GetGuildByLeader(session.Player);
if (guild == null || guild.LeaderCharacterId != session.Player.CharacterId)
{
return;
}
guild.Ranks[rankIndex].Name = rankName;
guild.Ranks[rankIndex].Rights = rights;
session.Send(GuildPacket.UpdateRankConfirm(guild, rankIndex));
guild.BroadcastPacketGuild(GuildPacket.UpdateRankNotice(guild, rankIndex));
}
private static void HandleLoadGuildList(GameSession session, PacketReader packet)
{
int focusAttributes = packet.ReadInt();
List <Guild> guildList = GameServer.GuildManager.GetGuildList();
if (guildList.Count == 0)
{
return;
}
if (focusAttributes == -1)
{
session.Send(GuildPacket.DisplayGuildList(guildList));
return;
}
// TODO: Filter guilds with focusAttributes
session.Send(GuildPacket.DisplayGuildList(guildList));
}
public override void Execute(GameCommandTrigger trigger)
{
Guild guild = GameServer.GuildManager.GetGuildById(trigger.Session.Player.Guild.Id);
if (guild == null)
{
trigger.Session.SendNotice("Player is not in a guild to add funds. Make sure you join one.");
return;
}
int guildFunds = trigger.Get <int>("amount");
if (guildFunds <= 0)
{
trigger.Session.SendNotice("Amount must be more than 0 to add.");
return;
}
guild.Funds = guildFunds;
guild.BroadcastPacketGuild(GuildPacket.UpdateGuildFunds(guild.Funds));
DatabaseManager.Guilds.Update(guild);
}
private void HandleCreate(GameSession session, PacketReader packet)
{
string guildName = packet.ReadUnicodeString();
if (!session.Player.Wallet.Meso.Modify(-2000))
{
short NoticeCode = 5121;
session.Send(GuildPacket.ErrorNotice(NoticeCode));
return;
}
session.FieldManager.BroadcastPacket(GuildPacket.UpdateGuildTag(session.Player, guildName));
session.Send(GuildPacket.Create(guildName));
string inviter = ""; // nobody because nobody invited the guild leader
byte response = 0; // 0 to not display invite notification
byte rank = 0; // set to leader rank
Guild newGuild = new(guildName, new List <Player> {
session.Player
});
public static void Handle(Entities.GameClient client, GuildPacket guild)
{
using (var msg = Packets.Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.USE_GUILD_DIRECTOR))
client.Send(msg);
}
public static void Handle(Entities.GameClient client, GuildPacket guild)
{
if (client.Guild != null)
client.Guild.DonateCPs(client, guild.Data);
}
