public async Task ToggleAntInv()
{
var Guild = Context.Guild as SocketGuild;
var gldConfig = GuildHandler.GuildConfigs[Guild.Id];
if (!gldConfig.NoInvites)
{
gldConfig.NoInvites = true;
await ReplyAsync(":gear: Anti Invites has now been enabled!");
}
else
{
gldConfig.NoInvites = false;
await ReplyAsync(":skull_crossbones: Anti Invites has been disabled!.");
}
GuildHandler.GuildConfigs[Context.Guild.Id] = gldConfig;
await GuildHandler.SaveAsync(GuildHandler.GuildConfigs);
}
public async Task WelcomeMessageAsync([Remainder] string msg = null)
{
var Guild = Context.Guild as SocketGuild;
var gldConfig = GuildHandler.GuildConfigs[Guild.Id];
if (msg == null)
{
await ReplyAsync("Remember that you can use {user} to get the username and {guild} for server name\nCurrent Welcome message for this guild\n" + gldConfig.WelcomeMessages);
}
else
{
gldConfig.WelcomeMessages = msg;
GuildHandler.GuildConfigs[Context.Guild.Id] = gldConfig;
await GuildHandler.SaveAsync(GuildHandler.GuildConfigs);
await ReplyAsync($"Guild Welcome Message has been set to:\n```{msg}```");
}
}
private async Task SendMessage(CachedValue <List <string> > messages, params string[] findAndReplace)
{
SocketTextChannel channel = GuildHandler.GetChannel(_channelId.GetValue()) as SocketTextChannel;
string[] guildMessages = messages.GetValue().ToArray();
if (guildMessages.Any())
{
string message = guildMessages[new Random().Next(0, guildMessages.Length)];
for (int i = 0; i < findAndReplace.Length; i += 2)
{
message = message.Replace(findAndReplace[i], findAndReplace[i + 1]);
}
await MessageControl.SendMessage(channel, message);
}
}
public async Task ToggleBansAsync()
{
var Guild = Context.Guild as SocketGuild;
var gldConfig = GuildHandler.GuildConfigs[Guild.Id];
if (!gldConfig.AdminLog.IsEnabled)
{
gldConfig.AdminLog.IsEnabled = true;
await ReplyAsync(":gear: Now logging bans.");
}
else
{
gldConfig.AdminLog.IsEnabled = false;
await ReplyAsync(":skull_crossbones: No longer logging bans.");
}
GuildHandler.GuildConfigs[Context.Guild.Id] = gldConfig;
await GuildHandler.SaveAsync(GuildHandler.GuildConfigs);
}
/// <summary>
/// Disbands the guild
/// </summary>
/// <param name="update">if true, sends event to the guild</param>
public void Disband()
{
//using (syncRoot.Enter())
lock (this)
{
GuildHandler.SendEventToGuild(this, GuildEvents.DISBANDED);
var members = Members.Values.ToArray();
foreach (var member in members)
{
RemoveMember(member, false);
}
GuildMgr.Instance.UnregisterGuild(this);
RealmServer.IOQueue.AddMessage(() => Delete());
}
}
public void WithdrawMoney(Character withdrawer, GameObject bankObj, uint withdrawl)
{
if (!CheckBankObj(withdrawer, bankObj))
{
return;
}
if (withdrawl == 0)
{
return;
}
if (Guild.Money < withdrawl)
{
return;
}
var member = withdrawer.GuildMember;
if (member == null)
{
return;
}
if (!member.HasRight(GuildPrivileges.WITHDRAW_GOLD) ||
member.HasRight(GuildPrivileges.WITHDRAW_GOLD_LOCK))
{
return;
}
if (member.BankMoneyWithdrawlAllowance < withdrawl)
{
return;
}
Guild.Money -= withdrawl;
withdrawer.Money += withdrawl;
member.BankMoneyWithdrawlAllowance -= withdrawl;
BankLog.LogEvent(GuildBankLogEntryType.WithdrawMoney, withdrawer, withdrawl, null, 0, null);
GuildHandler.SendMemberRemainingDailyWithdrawlAllowance(withdrawer, member.BankMoneyWithdrawlAllowance);
GuildHandler.SendGuildBankTabNames(withdrawer, bankObj);
GuildHandler.SendGuildBankTabContents(withdrawer, bankObj, 0);
GuildHandler.SendGuildBankMoneyUpdate(withdrawer, bankObj);
}
public static void CommonCharacterBasicInformations(WorldClient client)
{
CharacterHandler.SendCharacterSelectedSuccessMessage(client);
ContextHandler.SendNotificationListMessage(client, new int[] { 2147483647 });
InventoryHandler.SendInventoryContentMessage(client);
ShortcutHandler.SendShortcutBarContentMessage(client, ShortcutBarEnum.GENERAL_SHORTCUT_BAR);
ShortcutHandler.SendShortcutBarContentMessage(client, ShortcutBarEnum.SPELL_SHORTCUT_BAR);
ContextRoleplayHandler.SendEmoteListMessage(client, (
from entry in Enumerable.Range(0, 21)
select(byte) entry).ToList <byte>());
PvPHandler.SendAlignmentRankUpdateMessage(client);
if (client.Character.Guild != null)
{
GuildHandler.SendGuildMembershipMessage(client, client.Character.GuildMember);
GuildHandler.SendGuildInformationsGeneralMessage(client, client.Character.Guild);
GuildHandler.SendGuildInformationsMembersMessage(client, client.Character.Guild);
if (client.Character.Guild.Alliance != null)
{
AllianceHandler.SendAllianceMembershipMessage(client, client.Character.Guild.Alliance);
AllianceHandler.SendAllianceInsiderInfoMessage(client, client.Character.Guild.Alliance);
}
}
ChatHandler.SendEnabledChannelsMessage(client, new sbyte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13 }, new sbyte[0]);
InventoryHandler.SendSpellListMessage(client, true);
InitializationHandler.SendSetCharacterRestrictionsMessage(client);
InventoryHandler.SendInventoryWeightMessage(client);
FriendHandler.SendFriendWarnOnConnectionStateMessage(client, client.Character.FriendsBook.WarnOnConnection);
FriendHandler.SendFriendWarnOnLevelGainStateMessage(client, client.Character.FriendsBook.WarnOnLevel);
GuildHandler.SendGuildMemberWarnOnConnectionStateMessage(client, client.Character.WarnOnGuildConnection);
AchievementHandler.SendAchievementListMessage(client, client.Character.Record.FinishedAchievements, client.Character.Achievement.GetRewardableAchievements());
client.Character.SendConnectionMessages();
ContextRoleplayHandler.SendGameRolePlayArenaUpdatePlayerInfosMessage(client);
CharacterHandler.SendCharacterCapabilitiesMessage(client);
client.WorldAccount.LastConnection = new System.DateTime?(System.DateTime.Now);
client.WorldAccount.LastIp = client.IP;
client.WorldAccount.ConnectedCharacter = new int?(client.Character.Id);
client.Character.Record.LastUsage = new System.DateTime?(System.DateTime.Now);
ServerBase <WorldServer> .Instance.DBAccessor.Database.Update(client.WorldAccount);
ServerBase <WorldServer> .Instance.DBAccessor.Database.Update(client.Character.Record);
}
/// <summary>
/// Cleanup character invitations and group leader, looter change on character logout/disconnect
/// </summary>
/// <param name="member">The GuildMember logging out / disconnecting (or null if the corresponding Character is not in a Guild)</param>
internal void OnCharacterLogout(GuildMember member)
{
if (member == null)
{
// null check is only required because we stated in the documentation of this method that memeber is allowed to be null
return;
}
var chr = member.Character;
var listInviters = RelationMgr.Instance.GetPassiveRelations(chr.EntityId.Low, CharacterRelationType.GuildInvite);
foreach (IBaseRelation inviteRelation in listInviters)
{
RelationMgr.Instance.RemoveRelation(inviteRelation);
}
foreach (var activeSkill in chr.Guild.ActiveSkills)
{
activeSkill.RemoveFromCharacter(chr);
}
var guild = member.Guild;
if (guild == null) // ???
{
return;
}
member.LastLogin = DateTime.Now;
var zone = member.Character.Zone;
member.ZoneId = zone != null ? (int)zone.Id : 0;
member.Class = member.Character.Class;
member.Level = member.Character.Level;
member.Character = null;
member.UpdateLater();
using (membersLock.EnterWriteLock())
{
OfflineMembers[chr.EntityId.Low] = member;
}
GuildHandler.SendEventToGuild(member.Guild, GuildEvents.OFFLINE, member);
}
public async Task UnMute(IUser user)
{
var Config = GuildHandler.GuildConfigs[Context.Guild.Id];
var muted = Config.MutedList.Select(x => x.id);
var muts = Config.MutedList.Where(x => x.id == user.Id).FirstOrDefault();
if (user == null)
{
await ReplyAsync("Cant UnMute someone that dont exist");
return;
}
if (!muted.Contains(user.Id))
{
await ReplyAsync("This person is not muted");
return;
}
var User = (user as SocketGuildUser);
var MuteRole = User.Guild.GetRole(Config.MuteRoleID);
await User.RemoveRoleAsync(MuteRole);
await User.ModifyAsync(x => x.Mute = false);
if (muted.Contains(user.Id))
{
Config.MutedList.Remove(muts);
}
var SUser = Context.Message.Author as SocketGuildUser;
var xx = user as SocketGuildUser;
await ReplyAsync($"{SUser.Nickname ?? SUser.Username} successfully UnMuted {xx.Nickname ?? xx.Username}");
GuildHandler.GuildConfigs[Context.Guild.Id] = Config;
await GuildHandler.SaveAsync(GuildHandler.GuildConfigs);
}
public bool ChangeParameters(Character modifier, GuildMember member, short rank, byte xpPercent, uint rights)
{
bool result;
lock (this.m_lock)
{
if (modifier.Guild != member.Guild)
{
result = false;
}
else
{
if (modifier.GuildMember != member && modifier.GuildMember.IsBoss && rank == 1)
{
this.SetBoss(member);
}
else
{
if (modifier.GuildMember == member || !member.IsBoss)
{
if (modifier.GuildMember.HasRight(GuildRightsBitEnum.GUILD_RIGHT_MANAGE_RANKS) && rank >= 0 && rank <= 35)
{
member.RankId = rank;
}
if (modifier.GuildMember.HasRight(GuildRightsBitEnum.GUILD_RIGHT_MANAGE_RIGHTS))
{
member.Rights = (GuildRightsBitEnum)rights;
}
}
}
if (modifier.GuildMember.HasRight(GuildRightsBitEnum.GUILD_RIGHT_MANAGE_XP_CONTRIBUTION) || (modifier.GuildMember == member && modifier.GuildMember.HasRight(GuildRightsBitEnum.GUILD_RIGHT_MANAGE_MY_XP_CONTRIBUTION)))
{
member.GivenPercent = Convert.ToByte((xpPercent < 90) ? xpPercent : 90);
}
this.UpdateMember(member);
if (member.IsConnected)
{
GuildHandler.SendGuildMembershipMessage(member.Character.Client, member);
}
result = true;
}
}
return(result);
}
public override void Initialize()
{
commandSet = new VoiceNameSet()
{
ParentPlugin = this
};
GuildHandler.ChannelCreated += OnChannelCreated;
GuildHandler.ChannelDestroyed += OnChannelDestroyed;
GuildHandler.UserVoiceStateUpdated += OnVoiceStateUpdated;
GuildHandler.GuildMemberUpdated += OnGuildMemberUpdated;
InitDefaultTags();
_channelNames = GetConfigCache("ChannelNames", x => x.GetGuild().VoiceChannels.ToDictionary(y => y.Id, z => z.Name));
_toIgnore = GetConfigCache("ToIgnore", x => new List <ulong>()
{
(x.GetGuild().AFKChannel?.Id).GetValueOrDefault()
});
//_nameFormat = GetConfigCache("NameFormat", x => "[TAGS][NAME] - [GAME]");
_musicBotId = GetConfigCache("MusicBotId", x => (ulong)0);
_internationalRoleId = GetConfigCache("MusicBotId", x => (ulong)0);
AddConfigInfo("Set Channel Name", "Display channel names", () => "Current channel names:\n" + string.Join('\n', _channelNames.GetValue().Select(x => x.Value).ToArray()));
AddConfigInfo("Set Channel Name", "Set channel name", new Action <SocketVoiceChannel, string>((x, y) => _channelNames.MutateValue(z => z[x.Id] = y)), () => "Succesfully set channel names.", "Channel", "New name");
AddConfigInfo("Set Channel Name", "Set channel name", new Action <string, string>((x, y) => _channelNames.MutateValue(z => z[GuildHandler.FindVoiceChannel(x).Id] = y)), () => "Succesfully set channel names.", "Channel", "New name");
AddConfigInfo("Dont Name Channel", "Ignore channel", new Action <SocketVoiceChannel>((x) => _toIgnore.MutateValue(y => y.Add(x.Id))), () => "Added channel to list of ignored.", "Channel");
AddConfigInfo("Dont Name Channel", "Ignore channel", new Action <ulong>((x) => _toIgnore.MutateValue(y => y.Add(x))), () => "Added channel to list of default.", "ignored");
AddConfigInfo("Dont Name Channel", "Ignore channel", new Action <string>((x) => _toIgnore.MutateValue(y => y.Add(GuildHandler.FindVoiceChannel(x).Id))), () => "Added channel to list of ignored.", "Channel");
AddConfigInfo("Do Name Channel", "Unignore channel", new Action <SocketVoiceChannel>((x) => _toIgnore.MutateValue(y => y.Remove(x.Id))), () => "Removed channel from list of ignored.", "Channel");
AddConfigInfo("Do Name Channel", "Unignore channel", new Action <ulong>((x) => _toIgnore.MutateValue(y => y.Remove(x))), () => "Removed channel from list of ignored.", "Channel");
AddConfigInfo("Do Name Channel", "Unignore channel", new Action <string>((x) => _toIgnore.MutateValue(y => y.Remove(GuildHandler.FindVoiceChannel(x).Id))), () => "Removed channel from list of ignored.", "Channel");
AddConfigInfo("Set Music Bot", "Set music bot.", new Action <SocketGuildUser>((x) => _musicBotId.SetValue(x.Id)), () => $"Set music bot to be {GuildHandler.GetUser(_musicBotId.GetValue()).GetShownName()}.", "Music Bot");
AddConfigInfo("Set Music Bot", "Set music bot.", new Action <string>((x) => _musicBotId.SetValue(GuildHandler.FindUser(x).Id)), () => $"Set music bot to be {GuildHandler.GetUser(_musicBotId.GetValue()).GetShownName()}.", "Music Bot");
AddConfigInfo("Set Music Bot", "Show music bot.", () => GuildHandler.GetUser(_musicBotId.GetValue()) == null ? "Current music bot doesn't exist :(" : "Current music bot is " + GuildHandler.GetUser(_musicBotId.GetValue()).GetShownName());
AddConfigInfo("Set International Role", "Set role.", new Action <SocketRole>((x) => _internationalRoleId.SetValue(x.Id)), () => $"Set international role to be {GuildHandler.GetRole(_internationalRoleId.GetValue()).Name}.", "Role");
AddConfigInfo("Set International Role", "Set role.", new Action <string>((x) => _internationalRoleId.SetValue(GuildHandler.FindRole(x).Id)), () => $"Set international role to be {GuildHandler.GetRole(_internationalRoleId.GetValue()).Name}.", "Role Name");
AddConfigInfo("Set International Role", "Show role.", () => GuildHandler.GetRole(_internationalRoleId.GetValue()) == null ? "Current international role doesn't exist :(" : "Current international role is " + GuildHandler.GetRole(_internationalRoleId.GetValue()).Name);
SendMessage("Lomztein-Command Root", "AddCommand", commandSet);
}
public override void Initialize()
{
GuildHandler.ReactionAdded += OnReactionAdded;
GuildHandler.ReactionRemoved += OnReactionRemoved;
SendMessage("Lomztein-Command Root", "AddCommand", karmaCommand);
karmaCommand.ParentPlugin = this;
_upvoteEmoteId = GetConfigCache("UpvoteEmoteId", x => x.GetGuild().Emotes.Where(y => y.Name == "upvote").FirstOrDefault().ZeroIfNull());
_downvoteEmoteId = GetConfigCache("DownvoteEmoteId", x => x.GetGuild().Emotes.Where(y => y.Name == "downvote").FirstOrDefault().ZeroIfNull());
_karma = GetDataCache("Karma", x => new Dictionary <ulong, Selfworth>());
AddConfigInfo("Set Upvote Emote", "Get emote", () => $"Current upvote emote is '{GuildHandler.GetGuild().GetEmoteAsync(_upvoteEmoteId.GetValue()).Result.Name}'.");
AddConfigInfo("Set Upvote Emote", "Set emote", new Action <string>(x => _upvoteEmoteId.SetValue((GuildHandler.GetGuild().GetEmoteAsync(_upvoteEmoteId.GetValue()).Result?.Id).GetValueOrDefault())),
() => $"Set upvote emote to '{GuildHandler.GetGuild().GetEmoteAsync(_upvoteEmoteId.GetValue()).Result?.Name}'.", "Emote");
AddConfigInfo("Set Downvote Emote", "Get emote", () => $"Current downvote emote is '{GuildHandler.GetGuild().GetEmoteAsync(_downvoteEmoteId.GetValue()).Result.Name}'.");
AddConfigInfo("Set Downvote Emote", "Set emote", new Action <string>(x => _downvoteEmoteId.SetValue((GuildHandler.GetGuild().GetEmoteAsync(_downvoteEmoteId.GetValue()).Result?.Id).GetValueOrDefault())),
() => $"Set downote emote to '{GuildHandler.GetGuild().GetEmoteAsync(_downvoteEmoteId.GetValue()).Result?.Name}'.", "Emote");
}
public async Task bssssssessjjjx(string hex)
{
var Config = GuildHandler.GuildConfigs[Context.Guild.Id];
if (!hex.Contains("#") || hex.Length > 7)
{
await ReplyAsync("Has a color hex starting with #");
return;
}
else
{
Config.callcard.WelcomeColor = hex;
GuildHandler.GuildConfigs[Context.Guild.Id] = Config;
await GuildHandler.SaveAsync(GuildHandler.GuildConfigs);
await ReplyAsync("Card welcome Color set");
}
}
public void SetBankTabText(Character chr, byte tabId, string newText)
{
var member = chr.GuildMember;
if (member == null)
{
return;
}
var rank = member.Rank;
if (rank == null)
{
return;
}
if (tabId < 0 || tabId >= GuildMgr.MAX_BANK_TABS)
{
return;
}
if (tabId > Guild.PurchasedBankTabCount)
{
return;
}
var tab = this[tabId];
if (tab == null)
{
return;
}
if (!rank.BankTabRights[tabId].Privileges.HasFlag(GuildBankTabPrivileges.UpdateText))
{
return;
}
tab.Text = newText.Length < 501 ? newText : newText.Substring(0, 500);
tab.UpdateLater();
Guild.Broadcast(GuildHandler.CreateBankTabTextPacket(tabId, newText));
}
public void GetBankTabText(Character chr, byte tabId)
{
if (tabId < 0 || tabId >= GuildMgr.MAX_BANK_TABS)
{
return;
}
if (tabId > Guild.PurchasedBankTabCount)
{
return;
}
var tab = this[tabId];
if (tab == null)
{
return;
}
GuildHandler.SendGuildBankTabText(chr, tabId, tab.Text);
}
public void QueryBankLog(Character chr, byte tabId)
{
if (tabId < 0 || tabId >= GuildMgr.MAX_BANK_TABS)
{
return;
}
if (tabId > Guild.PurchasedBankTabCount)
{
return;
}
var tab = this[tabId];
if (tab == null)
{
return;
}
GuildHandler.SendGuildBankLog(chr, BankLog, tabId);
}
private async Task TestBirthdays(DateTime now)
{
foreach (var user in _allBirthdays.GetValue())
{
if (user.Value.IsNow())
{
SocketGuildUser guildUser = GuildHandler.GetUser(user.Key);
if (guildUser == null)
{
return; // User doesn't exist anymore, may have left the server.
}
SocketTextChannel guildChannel = GuildHandler.GetTextChannel(_announcementChannel.GetValue());
await AnnounceBirthday(guildChannel, guildUser, user.Value);
user.Value.SetLastPassedToNow();
}
}
return;
}
public async Task bshex(string hex)
{
if (!hex.Contains("#") || hex.Length > 7)
{
await ReplyAsync("Has a color hex starting with #");
return;
}
else
{
var Config = GuildHandler.GuildConfigs[Context.Guild.Id];
Config.callcard.descriptioncolor = hex;
GuildHandler.GuildConfigs[Context.Guild.Id] = Config;
await GuildHandler.SaveAsync(GuildHandler.GuildConfigs);
await ReplyAsync("Card info Color set");
}
}
static async Task CleanUpAsync(SocketGuildUser User)
{
var GuildConfig = GuildHandler.GuildConfigs[User.Guild.Id];
if (GuildConfig.AFKList.ContainsKey(User.Id))
{
GuildConfig.AFKList.Remove(User.Id);
Logger.Log(LogType.Warning, LogSource.Configuration, $"{User.Username} removed from {User.Guild.Name}'s AFK List.");
}
foreach (var tag in GuildConfig.TagsList)
{
if (tag.Owner == User.Id)
{
GuildConfig.TagsList.Remove(tag);
Logger.Log(LogType.Warning, LogSource.Configuration, $"Removed {tag.Name} by {User.Username}.");
}
}
GuildHandler.GuildConfigs[User.Guild.Id] = GuildConfig;
await GuildHandler.SaveAsync(GuildHandler.GuildConfigs);
}
public Task <Result> Execute(CommandMetadata _, string guildHandler)
{
GuildHandler handler = ParentPlugin.GuildHandler.Shard.GetGuildHandlers().FirstOrDefault(x => x.Name.ToUpperInvariant() == guildHandler.ToUpperInvariant());
if (handler != null)
{
string status = handler.ToString();
string activePlugins = string.Join("\n", handler.Plugins.GetActivePlugins().Select(x => Plugin.GetVersionedFullName(x.GetType())));
return(TaskResult(new EmbedBuilder()
.WithTitle(handler.Name + " status")
.WithDescription($"```{status}```")
.AddField("Active Plugins", $"```{activePlugins}```")
.WithCurrentTimestamp()
.Build(), string.Empty));
}
else
{
return(TaskResult(null, $"Failed to fetch GuildHandler status, no GuildHandler matching '{guildHandler}' could be found."));
}
}
public static void HandlePetitionRename(IRealmClient client, RealmPacketIn packet)
{
var petitionGuid = packet.ReadEntityId();
var newName = packet.ReadCString().Trim();
var charter = client.ActiveCharacter.Inventory.GetItem(petitionGuid) as PetitionCharter;
var chr = client.ActiveCharacter;
if (charter.Petition.Type == PetitionType.Guild)
{
if (!GuildMgr.IsValidGuildName(newName))
{
GuildHandler.SendResult(chr, GuildCommandId.CREATE, newName, GuildResult.NAME_INVALID);
return;
}
else if (GuildMgr.DoesGuildExist(newName))
{
GuildHandler.SendResult(chr, GuildCommandId.CREATE, newName, GuildResult.NAME_EXISTS);
return;
}
}
else
{
if (!ArenaMgr.IsValidArenaTeamName(newName))
{
ArenaTeamHandler.SendResult(chr, ArenaTeamCommandId.CREATE, newName, string.Empty, ArenaTeamResult.NAME_INVALID);
return;
}
else if (ArenaMgr.DoesArenaTeamExist(newName))
{
ArenaTeamHandler.SendResult(chr, ArenaTeamCommandId.CREATE, newName, string.Empty, ArenaTeamResult.NAME_EXISTS);
return;
}
}
charter.Petition.Name = newName;
charter.Petition.Update();
SendPetitionRename(client, charter);
}
/// <summary>
/// Checks whether a guild member may make another guild member the guild leader
/// </summary>
/// <param name="reqChar">requester's character, can be null. If null, sending result is suppressed</param>
/// <param name="targetChar">target's character, can be null</param>
/// <param name="targetName">target character's name</param>
/// <returns>result of operation</returns>
public static GuildResult CheckIsLeader(Character reqChar, Character targetChar, GuildCommandId cmd,
string targetName)
{
GuildMember guildMember1 = reqChar.GuildMember;
GuildResult resultCode;
if (guildMember1 == null)
{
resultCode = GuildResult.PLAYER_NOT_IN_GUILD;
}
else if (targetChar == null)
{
resultCode = GuildResult.PLAYER_NOT_FOUND;
}
else
{
GuildMember guildMember2;
if ((guildMember2 = targetChar.GuildMember) == null || guildMember2.Guild != guildMember1.Guild)
{
resultCode = GuildResult.PLAYER_NOT_IN_GUILD;
}
else if (guildMember1 == guildMember2)
{
resultCode = GuildResult.PERMISSIONS;
targetName = string.Empty;
}
else
{
if (guildMember1.IsLeader)
{
return(GuildResult.SUCCESS);
}
resultCode = GuildResult.PERMISSIONS;
targetName = string.Empty;
}
}
GuildHandler.SendResult((IPacketReceiver)reqChar, cmd, targetName, resultCode);
return(resultCode);
}
public async Task toggleErrorasync()
{
var Guild = Context.Guild as SocketGuild;
var gldConfig = GuildHandler.GuildConfigs[Guild.Id];
if (!gldConfig.Error.OnOff)
{
gldConfig.Error.OnOff = true;
await ReplyAsync(":gear: errors Disabled!");
}
else
{
gldConfig.Error.OnOff = false;
await ReplyAsync(":skull_crossbones: Errors Enabled.");
}
GuildHandler.GuildConfigs[Context.Guild.Id] = gldConfig;
await GuildHandler.SaveAsync(GuildHandler.GuildConfigs);
}
/// <summary>
/// Adds a new guild member
/// Calls GuildMgr.OnJoinGuild
/// </summary>
/// <param name="chr">character to add</param>
/// <param name="update">if true, sends event to the guild</param>
/// <returns>GuildMember of new member</returns>
public GuildMember AddMember(CharacterRecord chr)
{
GuildMember newMember;
using (syncRoot.Enter())
{
if (Members.TryGetValue(chr.EntityLowId, out newMember))
{
return(newMember);
}
newMember = new GuildMember(chr, this, m_ranks.Last());
Members.Add(newMember.Id, newMember);
newMember.Create();
}
GuildMgr.Instance.RegisterGuildMember(newMember);
EventLog.AddJoinEvent(newMember.Id);
GuildHandler.SendEventToGuild(this, GuildEvents.JOINED, newMember);
return(newMember);
}
public async Task togglejoinroleasync()
{
var Guild = Context.Guild as SocketGuild;
var gldConfig = GuildHandler.GuildConfigs[Guild.Id];
if (!gldConfig.JoinRole.IsEnabled)
{
gldConfig.JoinRole.IsEnabled = true;
await ReplyAsync(":gear: joinrole enable!");
}
else
{
gldConfig.JoinRole.IsEnabled = false;
await ReplyAsync(":skull_crossbones: Joinrole Disabled.");
}
GuildHandler.GuildConfigs[Context.Guild.Id] = gldConfig;
await GuildHandler.SaveAsync(GuildHandler.GuildConfigs);
}
/// <summary>
/// Checks if given character has necessary priviliges
/// CheckInGuild call is done automatically
/// </summary>
/// <param name="character">character to check. May be null</param>
/// <param name="commandId">executed command (used for sending result)</param>
/// <param name="reqPrivs">required privileges</param>
/// <returns>The Character's guild if the character has required privileges within the guild, otherwise null</returns>
public static Guild CheckPrivs(Character character, GuildCommandId commandId, GuildPrivileges reqPrivs)
{
GuildMember guildMember = character.GuildMember;
if (guildMember == null)
{
GuildHandler.SendResult((IPacketReceiver)character, commandId, GuildResult.PLAYER_NOT_IN_GUILD);
return((Guild)null);
}
if (guildMember.HasRight(reqPrivs))
{
return(guildMember.Guild);
}
Character character1 = guildMember.Character;
if (character1 != null)
{
GuildHandler.SendResult((IPacketReceiver)character1, commandId, GuildResult.PERMISSIONS);
}
return((Guild)null);
}
public SocialGroupCreationResultEnum SetGuildName(Character character, string name)
{
var potion = character.Inventory.TryGetItem(ItemManager.Instance.TryGetTemplate(ItemIdEnum.POTION_DE_RENOMMAGE_DE_GUILDE_13273));
if (potion == null)
{
return(SocialGroupCreationResultEnum.SOCIAL_GROUP_CREATE_ERROR_REQUIREMENT_UNMET);
}
if (!Regex.IsMatch(name, "^([A-Z][a-z\u00E0-\u00FC']{2,14}(\\s|-)?)([A-Z]?[a-z\u00E0-\u00FC']{1,15}(\\s|-)?){0,2}([A-Z]?[a-z\u00E0-\u00FC']{1,15})?$", RegexOptions.Compiled))
{
return(SocialGroupCreationResultEnum.SOCIAL_GROUP_CREATE_ERROR_NAME_INVALID);
}
if (GuildManager.Instance.DoesNameExist(name))
{
return(SocialGroupCreationResultEnum.SOCIAL_GROUP_CREATE_ERROR_NAME_ALREADY_EXISTS);
}
character.Inventory.RemoveItem(potion, 1);
Name = name;
foreach (var taxCollector in TaxCollectors)
{
taxCollector.RefreshLook();
taxCollector.Map.Refresh(taxCollector);
}
foreach (var member in Members)
{
member.Character.SendInformationMessage(TextInformationTypeEnum.TEXT_INFORMATION_MESSAGE, 383);
GuildHandler.SendGuildMembershipMessage(member.Character.Client, member.Character.GuildMember);
member.Character.RefreshActor();
}
return(SocialGroupCreationResultEnum.SOCIAL_GROUP_CREATE_OK);
}
protected virtual void OnMemberRemoved(GuildMember member)
{
IsDirty = true;
GuildManager.Instance.DeleteGuildMember(member);
UnBindMemberEvents(member);
if (Members.Count == 0)
{
GuildManager.Instance.DeleteGuild(this);
}
else if (member.IsBoss)
{
var newBoss = Members.OrderBy(x => x.RankId).FirstOrDefault();
if (newBoss != null)
{
SetBoss(newBoss);
// <b>%1</b> a remplacé <b>%2</b> au poste de meneur de la guilde <b>%3</b>
BasicHandler.SendTextInformationMessage(m_clients,
TextInformationTypeEnum.TEXT_INFORMATION_ERROR, 199,
newBoss.Name, member.Name, Name);
}
}
if (!member.IsConnected)
{
return;
}
member.Character.RemoveEmote(EmotesEnum.EMOTE_GUILD);
member.Character.GuildMember = null;
member.Character.RefreshActor();
// Vous avez quitté la guilde.
member.Character.SendInformationMessage(TextInformationTypeEnum.TEXT_INFORMATION_MESSAGE, 176);
GuildHandler.SendGuildLeftMessage(member.Character.Client);
}
/// <summary>
/// Checks whether the given target exists in requester's guild and whether the given requestMember has needed privs
/// Sends result of action to the requester
/// </summary>
/// <param name="reqChar">requester's character, can be null. If null, sending result is suppressed</param>
/// <param name="targetChar">target's character, can be null</param>
/// <param name="targetName">target character's name</param>
/// <param name="commandId">executed command. Used for sending result</param>
/// <param name="reqPrivs">priviliges required for executing this action</param>
/// <param name="canAffectSelf">can this action be executed on self?</param>
/// <returns>result of operation</returns>
public static GuildResult CheckAction(Character reqChar, Character targetChar, string targetName, GuildCommandId commandId,
GuildPrivileges reqPrivs, bool canAffectSelf)
{
GuildResult err;
var requester = reqChar.GuildMember;
if (requester == null)
{
err = GuildResult.PLAYER_NOT_IN_GUILD;
targetName = string.Empty;
}
else if (targetChar == null)
{
err = GuildResult.PLAYER_NOT_FOUND;
}
else if (!canAffectSelf && (reqChar == targetChar))
{
err = GuildResult.PERMISSIONS;
}
else if (reqChar.Guild != targetChar.Guild)
{
// Member is offline or doesn't exist
err = GuildResult.PLAYER_NOT_IN_GUILD;
}
else if (!requester.HasRight(reqPrivs))
{
err = GuildResult.PERMISSIONS;
targetName = string.Empty;
}
else
{
return(GuildResult.SUCCESS);
}
GuildHandler.SendResult(reqChar.Client, commandId, targetName, err);
return(err);
}
public void ModifyTabInfo(Character chr, GameObject bank, byte tabId, string newName, string newIcon)
{
if (!CheckBankObj(chr, bank))
{
return;
}
var member = chr.GuildMember;
if (member == null)
{
return;
}
if (!member.IsLeader)
{
return;
}
if (tabId < 0 || tabId > Guild.PurchasedBankTabCount)
{
return;
}
var tab = this[tabId];
if (tab == null)
{
return;
}
tab.Name = newName;
tab.Icon = newIcon;
tab.UpdateLater();
GuildHandler.SendGuildBankTabNames(chr, bank);
GuildHandler.SendGuildBankTabContents(chr, bank, tabId);
}
