//public static GuildRoster ooj = null;
protected void Page_Load(object sender, EventArgs e)
{
if (!this.IsPostBack)
{
if(ooj == null){
RequestXml.basePath = MapPath("./armory/");
RequestData.SqlConnectionString = ""; // Omitted for GitHub
ooj = new Guild("Terenas", "Overlords of Justice");
}
}
//OOJ Roster
//http://www.wowarmory.com/guild-info.xml?r=Terenas&gn=Overlords+of+Justice&rhtml=n
BodyText.Text = ooj.roster.ReturnRoster();
try
{
//BodyText.Text = ooj.ReturnRoster();
}catch
{
BodyText.Text = "Roster is currently loading...";
}
if (this.IsPostBack)
{
}
else { }
}
public GuildTitlePrompt( Mobile from, Mobile target, Guild g )
: base(from)
{
m_Mobile = from;
m_Target = target;
m_Guild = g;
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
switch ( version )
{
case 1:
{
m_Guild = reader.ReadGuild() as Guild;
goto case 0;
}
case 0:
{
break;
}
}
if ( m_Guild == null )
{
this.Delete();
}
}
public GuildAllyPrompt( Mobile leader, Guild target, Guild g )
: base(leader)
{
m_Leader = leader;
m_Target = target;
m_Guild = g;
}
public const ushort MaxMembers = 60; // Yes, its up to the server. Max is: 65535
#endregion Fields
#region Constructors
public GuildAcademy(Guild Guild)
{
this.Guild = Guild;
Members = new List<GuildAcademyMember>();
Load();
}
Guild CreateGuild(CmdTrigger<RealmServerCmdArgs> trigger, string name, CharacterRecord record)
{
var guild = new Guild(record, name);
trigger.Reply("Guild created");
return guild;
}
/// <summary>
/// Send message to a guild
/// </summary>
/// <param name="message">The message</param>
/// <param name="guild">The guild</param>
public static void SendMessageToGuild(string message, Guild guild)
{
if (guild == null)
return;
message = "[Guild] [" + message + "]";
guild.SendMessageToGuildMembers(message, eChatType.CT_Guild, eChatLoc.CL_ChatWindow);
}
public GuildEventLogEntry(Guild guild, GuildEventLogEntryType type, int character1LowId, int character2LowId, int newRankId, DateTime timeStamp)
{
GuildId = guild.Id;
Type = type;
Character1LowId = character1LowId;
Character2LowId = character2LowId;
NewRankId = newRankId;
TimeStamp = timeStamp;
}
public Guild ChangeGuild(Account acc, int guildid, int rank, int fame, bool renounce)
{
Guild guild;
if (renounce)
{
guild = new Guild
{
Name = "",
Id = 0,
Rank = 0,
Fame = 0
};
MySqlCommand cmd = CreateQuery();
cmd.CommandText = "UPDATE accounts SET guild=0, guildRank=0, guildFame=0 WHERE id=@aid";
cmd.Parameters.AddWithValue("@aid", acc.AccountId);
if (cmd.ExecuteNonQuery() == 0)
{
throw new Exception("Could not change player's guild in the SQL!");
}
UpdateGuild(guildid);
return guild;
}
else
{
guild = new Guild
{
Id = guildid,
Name = GetGuildName(guildid),
Rank = rank,
Fame = fame
};
if (guild.Name == "")
{
throw new Exception("Guild not found!");
}
MySqlCommand cmd = CreateQuery();
cmd.CommandText = "UPDATE accounts SET guild=@gid, guildRank=@gr, guildFame=@gf WHERE id=@aid";
cmd.Parameters.AddWithValue("@gid", guildid);
cmd.Parameters.AddWithValue("@gr", rank);
cmd.Parameters.AddWithValue("@gf", fame);
cmd.Parameters.AddWithValue("@aid", acc.AccountId);
if (cmd.ExecuteNonQuery() == 0)
{
throw new Exception("Could not change player's guild in the SQL!");
}
UpdateGuild(guildid);
return guild;
}
}
/// <summary>
/// Sends GuildInfoNoGuild to creature's client.
/// </summary>
/// <param name="creature"></param>
/// <param name="guild"></param>
public static void GuildInfoNoGuild(Creature creature, Guild guild)
{
var packet = new Packet(Op.GuildInfoNoGuild, creature.EntityId);
packet.PutLong(guild.Id);
packet.PutString(guild.Name);
packet.PutString(guild.LeaderName);
packet.PutInt(guild.MemberCount);
packet.PutString(guild.IntroMessage);
creature.Client.Send(packet);
}
internal GuildEventLog(Guild guild, bool isNew)
: this(guild)
{
if (!isNew)
{
var entries = GuildEventLogEntry.FindAllByProperty("m_GuildId", (int)guild.Id);
foreach (var entry in entries)
{
m_entries.Enqueue(entry);
}
}
}
/// <summary>
/// Sends GuildInfoApplied to creature's client.
/// </summary>
/// <param name="creature"></param>
/// <param name="guild"></param>
public static void GuildInfoApplied(Creature creature, Guild guild)
{
// The fields of this packet were guessed, something might be missing.
var packet = new Packet(Op.GuildInfoApplied, creature.EntityId);
packet.PutLong(guild.Id);
packet.PutString(guild.Server);
packet.PutLong(creature.EntityId);
packet.PutString(guild.Name);
creature.Client.Send(packet);
}
/// <summary>
/// Sends GuildPanel to creature's client.
/// </summary>
/// <param name="creature"></param>
/// <param name="guild"></param>
public static void GuildPanel(Creature creature, Guild guild)
{
var packet = new Packet(Op.GuildPanel, creature.EntityId);
packet.PutLong(guild.Id);
packet.PutByte(creature.GuildMember.IsLeader);
if (creature.GuildMember.IsLeader)
{
packet.PutInt(guild.WithdrawMaxAmount);
packet.PutLong(guild.WithdrawDeadline);
packet.PutInt(guild.MaxMembers);
}
packet.PutByte(0);
packet.PutByte(0); // 1: Go To Guild Hall, 2: Go To Guild Stone
creature.Client.Send(packet);
}
/// <summary>
/// Executes the given action for all members of guild that are online.
/// </summary>
/// <param name="guild"></param>
/// <param name="action"></param>
public static void ForOnlineMembers(Guild guild, Action<User> action)
{
var members = guild.GetMembers();
foreach (var member in members)
{
// Applicants aren't full members and shouldn't receive
// "broadcasts" yet.
if (member.Rank > GuildMemberRank.Member)
continue;
var user = MsgrServer.Instance.UserManager.GetUserByCharacterId(member.CharacterId);
if (user == null)
continue;
action(user);
}
}
public GuildMember(CharacterRecord chr, Guild guild, GuildRank rank)
: this()
{
var zoneId = (int)chr.Zone;
Guild = guild;
CharacterLowId = (int)chr.EntityLowId;
_rankId = rank.RankIndex;
_name = chr.Name;
_lastLevel = chr.Level;
_lastLogin = DateTime.Now;
_lastZoneId = zoneId;
_class = (int)chr.Class;
_publicNote = string.Empty;
_officerNote = string.Empty;
}
private void LoadGuilds()
{
MySqlCommand mysqlCmd = new MySqlCommand("SELECT * FROM Guilds", Program.DatabaseManager.GetClient().GetConnection());
int GuildCount = 0;
MySqlDataReader GuildReader = mysqlCmd.ExecuteReader();
{
for (int i = 0; i < GuildReader.FieldCount; i++)
{
while (GuildReader.Read())
{
Guild g = new Guild(Program.DatabaseManager.GetClient().GetConnection(), GuildReader);
GuildManager.AddGuildToList(g);
GuildCount++;
}
}
}
GuildReader.Close();
Log.WriteLine(LogLevel.Info, "Load {0} Guilds", GuildCount);
}
protected override void OnSyncGuildMemberAdded(Guild guild, GuildMember member)
{
// Only announce new members once they've become actual members,
// no applicants.
if (member.Rank > GuildMemberRank.Member)
return;
var user = MsgrServer.Instance.UserManager.GetUserByCharacterId(member.CharacterId);
if (user == null)
{
user = MsgrServer.Instance.Database.GetUserByCharacterId(member.CharacterId);
user.Status = ContactStatus.Offline;
}
ForOnlineMembers(guild, memberUser =>
{
if (memberUser != user)
Send.GuildMemberState(memberUser.Client, guild, member, user, user.Status);
});
}
protected void Page_Load(object sender, EventArgs e)
{
if (Request["k"] != "L0ngnubby") return;
RequestData.SqlConnectionString = ""; // Omitted for GitHub
Guild ooj = new Guild("Terenas", "Overlords of Justice");
TimeSpan ts = TimeSpan.Zero;
DateTime lastUpdate = DateTime.Now;
foreach (ArmoryCharacter c in ooj.roster.members)
{
lastUpdate =RequestData.CharacterSheetLastUpdateTime(c.name, c.server);
ts = DateTime.Now - lastUpdate;
if (ts > new TimeSpan(2, 0, 0, 0))
{
RequestData.AddCharacterSheetToQueue(c.name, c.server, c.armoryUrl);
Response.Write("*");
}
Response.Write(c.server + " " + c.name + " " + lastUpdate.ToShortDateString() + " " + lastUpdate.ToShortTimeString() +"\n");
}
}
public DeclareWarGump( Mobile from, Guild target )
: base(10, 10)
{
m_Mobile = from;
m_Guild = m_Mobile.Guild as Guild;
t_Guild = target as Guild;
Intern( "0" );
Intern( "0" );
AddPage( 0 );
AddBackground( 0, 0, 500, 340, 0x24AE );
AddBackground( 65, 50, 370, 30, 0x2486 );
AddHtmlLocalized( 75, 55, 370, 30, 1062979, 0x3C00, false, false );
AddImage( 410, 45, 0x232C );
AddHtmlLocalized( 65, 95, 200, 20, 1063009, 0x14AF, false, false );
AddHtmlLocalized( 65, 120, 400, 20, 1063010, 0x0, false, false );
AddBackground( 65, 150, 40, 30, 0x2486 );
AddTextEntryIntern( 68, 154, 25, 20, 0x481, 175, 0 );
AddHtmlLocalized( 65, 195, 200, 20, 1063011, 0x14AF, false, false );
AddHtmlLocalized( 65, 220, 400, 20, 1063012, 0x0, false, false );
AddBackground( 65, 250, 40, 30, 0x2486 );
AddTextEntryIntern( 68, 254, 25, 20, 0x481, 176, 1 );
AddBackground( 190, 270, 130, 26, 0x2486 );
AddButton( 195, 275, 0x845, 0x846, 0, GumpButtonType.Reply, 0 );
AddHtmlLocalized( 220, 273, 90, 26, 1006045, 0x0, false, false );
AddBackground( 330, 270, 130, 26, 0x2486 );
AddButton( 335, 275, 0x845, 0x846, 1, GumpButtonType.Reply, 0 );
AddHtmlLocalized( 360, 273, 90, 26, 1062989, 0x5000, false, false );
}
/// <summary>
///
/// </summary>
internal GuildBank(Guild guild, bool isNew)
{
Guild = guild;
BankLog = new GuildBankLog(this);
if (isNew)
{
bankTabs = new[] {
new GuildBankTab(this)
{
BankSlot = 0,
Icon = "",
Name = "Slot 0",
Text = ""
}
};
}
else
{
// load an existing guild bank
bankTabs = RealmWorldDBMgr.DatabaseProvider.Query<GuildBankTab>().Where(tab => tab.Guild == guild).ToArray(); //.FindAllByProperty("_guildId", (int)guild.Id); //TODO: Check this gets all guild bank tabs as intended
BankLog.LoadLogs();
}
}
/// <summary>
///
/// </summary>
internal GuildBank(Guild guild, bool isNew)
{
Guild = guild;
BankLog = new GuildBankLog(this);
if (isNew)
{
bankTabs = new [] {
new GuildBankTab(this)
{
BankSlot = 0,
Icon = "",
Name = "Slot 0",
Text = ""
}
};
}
else
{
// load an existing guild bank
bankTabs = GuildBankTab.FindAllByProperty("_guildId", (int)guild.Id);
BankLog.LoadLogs();
}
}
public void UpdateZone(uint newZone, uint newArea)
{
if (!IsInWorld)
{
return;
}
uint oldZone = m_zoneUpdateId;
m_zoneUpdateId = newZone;
m_zoneUpdateTimer = 1 * Time.InMilliseconds;
GetMap().UpdatePlayerZoneStats(oldZone, newZone);
// call leave script hooks immedately (before updating flags)
if (oldZone != newZone)
{
Global.OutdoorPvPMgr.HandlePlayerLeaveZone(this, oldZone);
Global.BattleFieldMgr.HandlePlayerLeaveZone(this, oldZone);
}
// group update
if (GetGroup())
{
SetGroupUpdateFlag(GroupUpdateFlags.Full);
Pet pet = GetPet();
if (pet)
{
pet.SetGroupUpdateFlag(GroupUpdatePetFlags.Full);
}
}
// zone changed, so area changed as well, update it
UpdateArea(newArea);
AreaTableRecord zone = CliDB.AreaTableStorage.LookupByKey(newZone);
if (zone == null)
{
return;
}
if (WorldConfig.GetBoolValue(WorldCfg.Weather))
{
GetMap().GetOrGenerateZoneDefaultWeather(newZone);
}
GetMap().SendZoneDynamicInfo(newZone, this);
UpdateWarModeAuras();
UpdateHostileAreaState(zone);
if (zone.HasFlag(AreaFlags.Capital)) // Is in a capital city
{
if (!pvpInfo.IsInHostileArea || zone.IsSanctuary())
{
_restMgr.SetRestFlag(RestFlag.City);
}
pvpInfo.IsInNoPvPArea = true;
}
else
{
_restMgr.RemoveRestFlag(RestFlag.City);
}
UpdatePvPState();
// remove items with area/map limitations (delete only for alive player to allow back in ghost mode)
// if player resurrected at teleport this will be applied in resurrect code
if (IsAlive())
{
DestroyZoneLimitedItem(true, newZone);
}
// check some item equip limitations (in result lost CanTitanGrip at talent reset, for example)
AutoUnequipOffhandIfNeed();
// recent client version not send leave/join channel packets for built-in local channels
UpdateLocalChannels(newZone);
UpdateZoneDependentAuras(newZone);
// call enter script hooks after everyting else has processed
Global.ScriptMgr.OnPlayerUpdateZone(this, newZone, newArea);
if (oldZone != newZone)
{
Global.OutdoorPvPMgr.HandlePlayerEnterZone(this, newZone);
Global.BattleFieldMgr.HandlePlayerEnterZone(this, newZone);
SendInitWorldStates(newZone, newArea); // only if really enters to new zone, not just area change, works strange...
Guild guild = GetGuild();
if (guild)
{
guild.UpdateMemberData(this, GuildMemberData.ZoneId, newZone);
}
}
}
public GrantGuildTitleGump(Mobile from, Guild guild) : base(from, guild, true, guild.Members)
{
}
/// <summary>
/// released the keep of the guild
/// </summary>
public virtual void Release()
{
this.Guild.ClaimedKeeps.Remove(this);
PlayerMgr.BroadcastRelease(this);
this.m_guild = null;
StopDeductionTimer();
StopChangeLevelTimer();
ChangeLevel((byte)ServerProperties.Properties.STARTING_KEEP_LEVEL);
foreach (GameKeepGuard guard in Guards.Values)
{
guard.ChangeGuild();
}
foreach (GameKeepBanner banner in Banners.Values)
{
banner.ChangeGuild();
}
this.SaveIntoDatabase();
}
/// <inheritdoc />
public async Task <IAudioClient> ConnectAsync(bool selfDeaf = false, bool selfMute = false, bool external = false)
{
return(await Guild.ConnectAudioAsync(Id, selfDeaf, selfMute, external).ConfigureAwait(false));
}
public ReceiveWarGump(Mobile from, Guild guild)
: base(10, 40)
{
m_Mobile = from;
m_Guild = from.Guild as Guild;
i_Guild = guild;
int h, m;
uint ET;
ET = i_Guild.GetWarTime(m_Guild);
h = (int)(ET / 60);
m = (int)(ET - h * 60);
/*0*/
Intern("Unknown");
/*1*/
Intern("");
/*2*/
Intern("");
/*3*/
Intern("0/0");
/*4*/
Intern("0/0");
/*5*/
Intern("00:00");
/*6*/
Intern(guild.Name);
/*7*/
Intern(String.Format("<basefont color=#black>{0}</basefont>", guild.AllianceName));
/*8*/
Intern(guild.Abbreviation);
/*9*/
Intern(String.Format("<basefont color=#990000>0/{0}</basefont>", i_Guild.GetMaxKills(m_Guild)));
/*10*/
Intern(String.Format("<basefont color=#990000>{0}:{1}</basefont>", h, m));
/*11*/
Intern(String.Format("<basefont color=#990000>0/{0}</basefont>", i_Guild.GetMaxKills(m_Guild)));
AddPage(0);
AddBackground(0, 0, 520, 335, 0x242C);
AddHtmlLocalized(20, 15, 480, 26, 1062975, 0x0, false, false); // Guild Relationship
AddImageTiled(20, 40, 480, 2, 0x2711);
AddHtmlLocalized(20, 50, 120, 26, 1062954, 0x0, true, false); // Guild Name
AddHtmlIntern(150, 53, 360, 26, 6, false, false);
AddHtmlLocalized(20, 80, 120, 26, 1063025, 0x0, true, false); // Alliance
AddHtmlIntern(150, 83, 360, 26, 7, false, false);
AddHtmlLocalized(20, 110, 120, 26, 1063139, 0x0, true, false); // Abbreviation
AddHtmlIntern(150, 113, 120, 26, 8, false, false);
AddHtmlLocalized(280, 110, 120, 26, 1062966, 0x0, true, false); // Your Kills
AddHtmlIntern(410, 113, 120, 26, 9, false, false);
AddHtmlLocalized(20, 140, 120, 26, 1062968, 0x0, true, false); // Time Remaining
AddHtmlIntern(150, 143, 120, 26, 10, false, false);
AddHtmlLocalized(280, 140, 120, 26, 1062967, 0x0, true, false); // Their Kills
AddHtmlIntern(410, 143, 120, 26, 11, false, false);
AddImageTiled(20, 172, 480, 2, 0x2711);
AddBackground(275, 290, 225, 26, 0x2486);
AddButton(280, 295, 0x845, 0x846, 0, GumpButtonType.Reply, 0);
AddHtmlLocalized(305, 293, 185, 26, 3000091, 0x0, false, false); // Cancel
AddBackground(20, 290, 225, 26, 0x2486);
AddButton(25, 295, 0x845, 0x846, 201, GumpButtonType.Reply, 0);
AddHtmlLocalized(50, 293, 185, 26, 1062982, 0x0, false, false); // Dismiss Challenge
AddBackground(20, 260, 225, 26, 0x2486);
AddButton(25, 265, 0x845, 0x846, 200, GumpButtonType.Reply, 0);
AddHtmlLocalized(50, 263, 185, 26, 1062981, 0x0, false, false); // Accept Challenge
AddBackground(275, 260, 225, 26, 0x2486);
AddButton(280, 265, 0x845, 0x846, 202, GumpButtonType.Reply, 0);
AddHtmlLocalized(305, 263, 185, 26, 1062983, 0x0, false, false); // Modify Terms
AddHtmlLocalized(20, 180, 480, 30, 1062969, 0x0, true, false); // This guild has challenged you to war!
AddImageTiled(20, 245, 480, 2, 0x2711);
//AddMasterGump( 725 );
}
public async Task GetQuestion(int id = -100)
{
// question which will be fetch from server database
Question question = null;
// if question was already seen
bool wasSeen = false;
// Get server informations
Guild guild = Guilds.GetGuild(Context.Guild.Id);
// Get user account
UserAccount userAccount = UserAccounts.GetUserAccount(Context.User.Id, guild.UserAccounts, guild.Categories);
// check if question id is valid
if (id >= 0)
{
// check if user already seen this question
if (userAccount.SeenQuestionsIds.Contains(id))
{
wasSeen = true;
}
// get question with id from database
question = Questions.GetQuestion(id, guild.Categories);
}
else
{
Random random = new Random(DateTime.Now.Millisecond);
List <Question> allQuestions = new List <Question>();
// Get maximum question id
foreach (Category category in guild.Categories)
{
allQuestions.AddRange(category.Questions); // and all questions as well
}
// get all unseen questions
IEnumerable <Question> unseenQuestions = from q in allQuestions
where !userAccount.SeenQuestionsIds.Contains(q.Id)
select q;
int unseenQuestionsCount = unseenQuestions.ToList().Count;
// if list of unseen questions is empty
if (unseenQuestionsCount == 0)
{
// send random question
wasSeen = true;
question = allQuestions.ElementAt(random.Next(0, allQuestions.Count));
}
else
{
// send unseen question
question = unseenQuestions.ElementAt(random.Next(0, unseenQuestionsCount));
}
id = question.Id;
}
// Create embed for message with question
EmbedBuilder embedBuild = new EmbedBuilder
{
Title = $"Pytanie #{question.Id}",
Description = question.Description
};
// add possible answers
for (int i = 0; i < question.PossibleAnswers.Count; i++)
{
embedBuild.AddField(Util.AnswersEmojis.ToList()[i].Name, question.PossibleAnswers[i], true);
}
// add image
if (question.ImageURL != null)
{
embedBuild.ImageUrl = question.ImageURL;
}
// build embed
Embed embed = embedBuild.Build();
// ReactionCallbackData(message content, embed, expires after first use, if command should react to only one answer from 1 user,
// command timeout, what to do if command expires)
ReactionCallbackData reactionData = new ReactionCallbackData("", embed, true, true, TimeSpan.FromSeconds(120), (c) => Timeout(c.Channel));
// Iterate all possible answers and add answer placeholder
for (int i = 0; i < question.PossibleAnswers.Count; i++)
{
// check if this iteration answer is right
if (i == question.RightAnswer)
{
// Add answer placecholder with information what if user select this answer
// reactionData.WithCallback(answer emoji, what to do if user select answer)
// CheckScore(if question was seen, is this good answer, question id, question category, user account, source channel)
reactionData.WithCallback(Util.AnswersEmojis.ToList()[i], (c, r) => CheckScore(wasSeen, true, id, GetCategoryContainingQuestionId(id, guild.Categories), userAccount, c.Channel));
}
else
{
reactionData.WithCallback(Util.AnswersEmojis.ToList()[i], (c, r) => CheckScore(wasSeen, false, id, GetCategoryContainingQuestionId(id, guild.Categories), userAccount, c.Channel));
}
}
// Send quiz message and await user selection
await InlineReactionReplyAsync(reactionData, true);
}
/// <inheritdoc /> public async Task DisconnectAsync() => await Guild.DisconnectAudioAsync();
public void OnJoinAccepted(Mobile mob)
{
PlayerMobile pm = mob as PlayerMobile;
if (pm == null)
{
return; // sanity
}
PlayerState pl = PlayerState.Find(pm);
// no young on siege
/*if (pm.Young)
* pm.SendLocalizedMessage(1010104); // You cannot join a faction as a young player
* else*/
if (pl != null && pl.IsLeaving)
{
pm.SendLocalizedMessage(1005051); // You cannot use the faction stone until you have finished quitting your current faction
}
else if (AlreadyHasCharInFaction(pm))
{
pm.SendLocalizedMessage(1005059); // You cannot join a faction because you already declared your allegiance with another character
}
else if (IsFactionBanned(mob))
{
pm.SendLocalizedMessage(1005052); // You are currently banned from the faction system
}
else if (pm.Guild != null)
{
Guild guild = pm.Guild as Guild;
if (guild.Leader != pm)
{
pm.SendLocalizedMessage(1005057); // You cannot join a faction because you are in a guild and not the guildmaster
}
else if (!Guild.NewGuildSystem && guild.Type != GuildType.Regular)
{
pm.SendLocalizedMessage(1042161); // You cannot join a faction because your guild is an Order or Chaos type.
}
else if (!Guild.NewGuildSystem && guild.Enemies != null && guild.Enemies.Count > 0) //CAN join w/wars in new system
{
pm.SendLocalizedMessage(1005056); // You cannot join a faction with active Wars
}
else if (!CanHandleInflux(guild.Members.Count))
{
pm.SendLocalizedMessage(1018031); // In the interest of faction stability, this faction declines to accept new members for now.
}
else
{
// List<Mobile> members = new List<Mobile>(guild.Members);
for (int i = 0; i < guild.Members.Count; ++i)
{
PlayerMobile member = guild.Members[i] as PlayerMobile;
if (member == null)
{
continue;
}
JoinGuilded(member, guild);
}
}
}
else if (!CanHandleInflux(1))
{
pm.SendLocalizedMessage(1018031); // In the interest of faction stability, this faction declines to accept new members for now.
}
else
{
JoinAlone(mob);
}
}
private void Handle(Player player, CreateGuildPacket packet)
{
try
{
string name = packet.Name;
if (player.Client.Account.Stats.Fame >= 1000)
{
if (name != "")
{
player.Manager.Data.AddDatabaseOperation(db =>
{
if (db.GetGuild(name) != null)
{
player.Client.SendPacket(new CreateGuildResultPacket
{
Success = false,
ResultMessage = "Guild already exists!"
});
return;
}
try
{
if (player.Client.Account.Guild.Name == "")
{
if (packet.Name != "")
{
Guild g = db.CreateGuild(player.Client.Account, packet.Name);
player.Client.Account.Guild.Id = g.Id;
player.Client.Account.Guild.Name = g.Name;
player.Client.Account.Guild.Rank = g.Rank;
player.Client.Account.Guild.Fame = g.Fame;
player.Guild = g.Name;
player.GuildRank = g.Rank;
player.Client.SendPacket(new NotificationPacket
{
Color = new ARGB(0xFF00FF00),
ObjectId = player.Id,
Text = "Guild Created"
});
player.SendInfo(g.Name + " has successfully been created");
player.Client.SendPacket(new CreateGuildResultPacket
{
Success = true
});
player.CurrentFame =
player.Client.Account.Stats.Fame =
db.UpdateFame(player.Client.Account, -1000);
player.UpdateCount++;
}
player.Client.SendPacket(new CreateGuildResultPacket
{
Success = false,
ResultMessage = "Guild name cannot be blank!"
});
return;
}
player.Client.SendPacket(new CreateGuildResultPacket
{
Success = false,
ResultMessage = "You cannot create a guild as a guild member!"
});
return;
}
catch (Exception e)
{
player.Client.SendPacket(new CreateGuildResultPacket
{
Success = false,
ResultMessage = e.Message
});
}
});
}
player.Client.SendPacket(new CreateGuildResultPacket
{
Success = false,
ResultMessage = "Name cannot be empty!"
});
}
else
{
player.Client.SendPacket(new CreateGuildResultPacket
{
Success = false,
ResultMessage = "Not enough fame!"
});
}
}
catch (Exception)
{
Console.WriteLine("Error at line 755 of Player.cs");
player.Client.SendPacket(new TextPacket
{
Name = "",
Stars = -1,
BubbleTime = 0,
Text = "Error creating guild!"
});
}
}
private async ValueTask <bool> TryHandleProxy(Shard shard, MessageCreateEvent evt, Guild guild, Channel channel, MessageContext ctx)
{
var botPermissions = _bot.PermissionsIn(channel.Id);
try
{
return(await _proxy.HandleIncomingMessage(shard, evt, ctx, guild, channel, allowAutoproxy : ctx.AllowAutoproxy, botPermissions));
}
catch (PKError e)
{
// User-facing errors, print to the channel properly formatted
if (botPermissions.HasFlag(PermissionSet.SendMessages))
{
await _rest.CreateMessage(evt.ChannelId,
new MessageRequest { Content = $"{Emojis.Error} {e.Message}" });
}
}
return(false);
}
public BattleStatsGump(PlayerMobile pm, VvVBattle battle)
: base(50, 50)
{
Battle = battle;
BattleTeam leader = battle.GetLeader();
Guild myGuild = pm.Guild as Guild;
if (leader == null || leader.Guild == null || myGuild == null)
{
return;
}
AddBackground(0, 0, 500, 500, 9380);
AddHtmlLocalized(0, 40, 500, 20, 1154645, "#1154945", Color16, false, false); // The Battle between Vice and Virtue has ended!
AddHtml(40, 65, 420, 20, string.Format("<basefont color=#B22222>{0} [{1}] has won the battle!", leader.Guild.Name, leader.Guild.Abbreviation), false, false);
int y = 90;
if (leader.Guild.Alliance != null)
{
AddHtml(40, y, 420, 20, string.Format("<basefont color=#B22222>The {0} Alliance has won the battle!", leader.Guild.Alliance.Name), false, false);
y += 25;
}
BattleTeam team = Battle.GetTeam(myGuild);
//TODO: Are totals the PLAYERS OVERALL totals, or the guild/alliance totals for that battle??? Or that players totals for that battle
/*silver += (int)ViceVsVirtueSystem.Instance.GetPoints(pm);
*
* VvVPlayerEntry entry = ViceVsVirtueSystem.Instance.GetPlayerEntry<VvVPlayerEntry>(pm);
*
* if (entry != null)
* {
* score = entry.Score;
* }*/
AddHtmlLocalized(40, y, 420, 20, 1154947, team.Silver.ToString("N0", CultureInfo.GetCultureInfo("en-US")), Color16, false, false); // Total Silver Points: ~1_val~
y += 25;
AddHtmlLocalized(40, y, 420, 20, 1154948, team.Score.ToString("N0", CultureInfo.GetCultureInfo("en-US")), Color16, false, false); // Total Score: ~1_val~
y += 25;
AddHtmlLocalized(40, y, 420, 20, 1154949, team.Kills.ToString("N0", CultureInfo.GetCultureInfo("en-US")), Color16, false, false);
y += 25;
AddHtmlLocalized(40, y, 420, 20, 1154950, team.Assists.ToString("N0", CultureInfo.GetCultureInfo("en-US")), Color16, false, false);
y += 25;
AddHtmlLocalized(40, y, 420, 20, 1154951, team.Deaths.ToString("N0", CultureInfo.GetCultureInfo("en-US")), Color16, false, false);
y += 25;
AddHtmlLocalized(40, y, 420, 20, 1154952, team.Stolen.ToString("N0", CultureInfo.GetCultureInfo("en-US")), Color16, false, false);
y += 25;
AddHtmlLocalized(40, y, 420, 20, 1154953, team.ReturnedSigils.ToString("N0", CultureInfo.GetCultureInfo("en-US")), Color16, false, false);
y += 25;
AddHtmlLocalized(40, y, 420, 20, 1154954, team.ViceReturned.ToString("N0", CultureInfo.GetCultureInfo("en-US")), Color16, false, false);
y += 25;
AddHtmlLocalized(40, y, 420, 20, 1154955, team.VirtueReturned.ToString("N0", CultureInfo.GetCultureInfo("en-US")), Color16, false, false);
y += 25;
AddHtmlLocalized(40, y, 420, 20, 1154956, team.Disarmed.ToString("N0", CultureInfo.GetCultureInfo("en-US")), Color16, false, false);
}
/* Must be thread-safe */
public static int MobileNotoriety(Mobile source, Mobile target)
{
BaseCreature bcTarg = target as BaseCreature;
if (Core.AOS && (target.Blessed || bcTarg?.IsInvulnerable == true || target is PlayerVendor ||
target is TownCrier))
{
return(Notoriety.Invulnerable);
}
PlayerMobile pmFrom = source as PlayerMobile;
PlayerMobile pmTarg = target as PlayerMobile;
#region Dueling
if (pmFrom != null && pmTarg != null)
{
if (pmFrom.DuelContext?.StartedBeginCountdown == true && !pmFrom.DuelContext.Finished && pmFrom.DuelContext == pmTarg.DuelContext)
{
return(pmFrom.DuelContext.IsAlly(pmFrom, pmTarg) ? Notoriety.Ally : Notoriety.Enemy);
}
}
#endregion
if (target.AccessLevel > AccessLevel.Player)
{
return(Notoriety.CanBeAttacked);
}
if (source.Player && !target.Player && pmFrom != null && bcTarg != null)
{
Mobile master = bcTarg.GetMaster();
if (master?.AccessLevel > AccessLevel.Player)
{
return(Notoriety.CanBeAttacked);
}
master = bcTarg.ControlMaster;
if (Core.ML && master != null)
{
if (source == master && CheckAggressor(bcTarg.Aggressors, source) ||
CheckAggressor(source.Aggressors, bcTarg))
{
return(Notoriety.CanBeAttacked);
}
return(MobileNotoriety(source, master));
}
if (!bcTarg.Summoned && !bcTarg.Controlled && pmFrom.EnemyOfOneType == bcTarg.GetType())
{
return(Notoriety.Enemy);
}
}
if (target.Kills >= 5 ||
target.Body.IsMonster && IsSummoned(bcTarg) && !(target is BaseFamiliar) && !(target is ArcaneFey) &&
!(target is Golem) || bcTarg?.AlwaysMurderer == true || bcTarg?.IsAnimatedDead == true)
{
return(Notoriety.Murderer);
}
if (target.Criminal)
{
return(Notoriety.Criminal);
}
Guild sourceGuild = GetGuildFor(source.Guild as Guild, source);
Guild targetGuild = GetGuildFor(target.Guild as Guild, target);
if (sourceGuild != null && targetGuild != null)
{
if (sourceGuild == targetGuild || sourceGuild.IsAlly(targetGuild))
{
return(Notoriety.Ally);
}
if (sourceGuild.IsEnemy(targetGuild))
{
return(Notoriety.Enemy);
}
}
Faction srcFaction = Faction.Find(source, true, true);
Faction trgFaction = Faction.Find(target, true, true);
if (srcFaction != null && trgFaction != null && srcFaction != trgFaction && source.Map == Faction.Facet)
{
return(Notoriety.Enemy);
}
if (Stealing.ClassicMode && pmTarg?.PermaFlags.Contains(source) == true)
{
return(Notoriety.CanBeAttacked);
}
if (bcTarg?.AlwaysAttackable == true)
{
return(Notoriety.CanBeAttacked);
}
if (CheckHouseFlag(source, target, target.Location, target.Map))
{
return(Notoriety.CanBeAttacked);
}
if (bcTarg?.InitialInnocent != true)
{
if (!target.Body.IsHuman && !target.Body.IsGhost && !IsPet(bcTarg) && pmTarg == null ||
!Core.ML && !target.CanBeginAction <PolymorphSpell>())
{
return(Notoriety.CanBeAttacked);
}
}
if (CheckAggressor(source.Aggressors, target))
{
return(Notoriety.CanBeAttacked);
}
if (CheckAggressed(source.Aggressed, target))
{
return(Notoriety.CanBeAttacked);
}
if (bcTarg?.Controlled == true && bcTarg.ControlOrder == OrderType.Guard &&
bcTarg.ControlTarget == source)
{
return(Notoriety.CanBeAttacked);
}
if (source is BaseCreature bc)
{
Mobile master = bc.GetMaster();
if (master != null && CheckAggressor(master.Aggressors, target) ||
MobileNotoriety(master, target) == Notoriety.CanBeAttacked || bcTarg != null)
{
return(Notoriety.CanBeAttacked);
}
}
return(Notoriety.Innocent);
}
public static int CorpseNotoriety(Mobile source, Corpse target)
{
if (target.AccessLevel > AccessLevel.Player)
{
return(Notoriety.CanBeAttacked);
}
Body body = target.Amount;
Guild sourceGuild = GetGuildFor(source.Guild as Guild, source);
Guild targetGuild = GetGuildFor(target.Guild, target.Owner);
Faction srcFaction = Faction.Find(source, true, true);
Faction trgFaction = Faction.Find(target.Owner, true, true);
List <Mobile> list = target.Aggressors;
if (sourceGuild != null && targetGuild != null)
{
if (sourceGuild == targetGuild || sourceGuild.IsAlly(targetGuild))
{
return(Notoriety.Ally);
}
if (sourceGuild.IsEnemy(targetGuild))
{
return(Notoriety.Enemy);
}
}
if (target.Owner is BaseCreature creature)
{
if (srcFaction != null && trgFaction != null && srcFaction != trgFaction && source.Map == Faction.Facet)
{
return(Notoriety.Enemy);
}
if (CheckHouseFlag(source, creature, target.Location, target.Map))
{
return(Notoriety.CanBeAttacked);
}
int actual = Notoriety.CanBeAttacked;
if (target.Kills >= 5 || body.IsMonster && IsSummoned(creature) || creature.AlwaysMurderer ||
creature.IsAnimatedDead)
{
actual = Notoriety.Murderer;
}
if (DateTime.UtcNow >= target.TimeOfDeath + Corpse.MonsterLootRightSacrifice)
{
return(actual);
}
Party sourceParty = Party.Get(source);
for (int i = 0; i < list.Count; ++i)
{
if (list[i] == source || sourceParty != null && Party.Get(list[i]) == sourceParty)
{
return(actual);
}
}
return(Notoriety.Innocent);
}
if (target.Kills >= 5 || body.IsMonster)
{
return(Notoriety.Murderer);
}
if (target.Criminal && target.Map != null && (target.Map.Rules & MapRules.HarmfulRestrictions) == 0)
{
return(Notoriety.Criminal);
}
if (srcFaction != null && trgFaction != null && srcFaction != trgFaction && source.Map == Faction.Facet)
{
for (int i = 0; i < list.Count; ++i)
{
if (list[i] == source || list[i] is BaseFactionGuard)
{
return(Notoriety.Enemy);
}
}
}
if (CheckHouseFlag(source, target.Owner, target.Location, target.Map))
{
return(Notoriety.CanBeAttacked);
}
if (!(target.Owner is PlayerMobile))
{
return(Notoriety.CanBeAttacked);
}
for (int i = 0; i < list.Count; ++i)
{
if (list[i] == source)
{
return(Notoriety.CanBeAttacked);
}
}
return(Notoriety.Innocent);
}
public static bool Mobile_AllowHarmful(Mobile from, Mobile target)
{
if (from == null || target == null || from.AccessLevel > AccessLevel.Player ||
target.AccessLevel > AccessLevel.Player)
{
return(true);
}
#region Dueling
PlayerMobile pmFrom = from as PlayerMobile;
PlayerMobile pmTarg = target as PlayerMobile;
BaseCreature bcTarg = target as BaseCreature;
if (pmFrom == null && from is BaseCreature bcFrom && bcFrom.Summoned)
{
pmFrom = bcFrom.SummonMaster as PlayerMobile;
}
if (pmTarg == null && bcTarg?.Summoned == true)
{
pmTarg = bcTarg.SummonMaster as PlayerMobile;
}
if (pmFrom != null && pmTarg != null)
{
if (pmFrom.DuelContext != pmTarg.DuelContext &&
(pmFrom.DuelContext?.Started == true || pmTarg.DuelContext?.Started == true))
{
return(false);
}
if (pmFrom.DuelContext != null && pmFrom.DuelContext == pmTarg.DuelContext &&
(pmFrom.DuelContext.StartedReadyCountdown && !pmFrom.DuelContext.Started || pmFrom.DuelContext.Tied ||
pmFrom.DuelPlayer.Eliminated || pmTarg.DuelPlayer.Eliminated))
{
return(false);
}
if (pmFrom.DuelContext != null && pmFrom.DuelContext == pmTarg.DuelContext &&
pmFrom.DuelContext.m_Tournament?.IsNotoRestricted == true &&
pmFrom.DuelPlayer != null && pmTarg.DuelPlayer != null &&
pmFrom.DuelPlayer.Participant == pmTarg.DuelPlayer.Participant)
{
return(false);
}
if (pmFrom.DuelContext?.Started == true && pmFrom.DuelContext == pmTarg.DuelContext)
{
return(true);
}
}
if (pmFrom?.DuelContext?.Started == true || pmTarg?.DuelContext?.Started == true)
{
return(false);
}
if (from.Region.IsPartOf <SafeZone>() || target.Region.IsPartOf <SafeZone>())
{
return(false);
}
#endregion
Map map = from.Map;
if ((map?.Rules & MapRules.HarmfulRestrictions) == 0)
{
return(true); // In felucca, anything goes
}
if (!from.Player && !(from is BaseCreature bc && bc.GetMaster() != null &&
bc.GetMaster().AccessLevel == AccessLevel.Player))
{
if (!CheckAggressor(from.Aggressors, target) && !CheckAggressed(from.Aggressed, target) &&
pmTarg?.CheckYoungProtection(from) == true)
{
return(false);
}
return(true); // Uncontrolled NPCs are only restricted by the young system
}
Guild fromGuild = GetGuildFor(from.Guild as Guild, from);
Guild targetGuild = GetGuildFor(target.Guild as Guild, target);
if (fromGuild != null && targetGuild != null &&
(fromGuild == targetGuild || fromGuild.IsAlly(targetGuild) || fromGuild.IsEnemy(targetGuild)))
{
return(true); // Guild allies or enemies can be harmful
}
if (bcTarg?.Controlled == true || bcTarg?.Summoned == true && bcTarg?.SummonMaster != from)
{
return(false); // Cannot harm other controlled mobiles
}
if (target.Player)
{
return(false); // Cannot harm other players
}
return(bcTarg?.InitialInnocent == true || Notoriety.Compute(from, target) != Notoriety.Innocent);
}
public async static Task AddGuild(PlayerContext context, ulong playerId, Guild guild)
{
var player = await GetPlayerWithId(playerId, context, includeGuildPlayer : true);
await AddGuild(context, player, guild);
}
public void SendObjectGuildID(GameObject obj, Guild guild)
{
}
/// <summary>
/// Called when a guild is removed from the manager during
/// synchronization.
/// </summary>
/// <param name="guild"></param>
protected virtual void OnSyncGuildRemoved(Guild guild)
{
}
public void SocketMessage(object sender, MessageEventArgs e)
{
RPayload payload = JsonConvert.DeserializeObject <RPayload>(e.Data);
if (payload.Sequence.HasValue)
{
client.Sequence = payload.Sequence.Value;
}
if (client.Settings.Debugging)
{
Interface.Oxide.LogDebug($"Recieved socket message, OpCode: {payload.OpCode}");
}
switch (payload.OpCode)
{
// Dispatch (dispatches an event)
case OpCodes.Dispatch:
{
if (client.Settings.Debugging)
{
Interface.Oxide.LogDebug($"Recieved OpCode 0, event: {payload.EventName}");
}
// Listed here: https://discordapp.com/developers/docs/topics/gateway#commands-and-events-gateway-events
switch (payload.EventName)
{
case "READY":
{
/*
* Moved to DiscordClient.Initialized -> Not at all cases will READY be called.
* client.UpdatePluginReference();
* client.CallHook("DiscordSocket_Initialized");
*/
Ready ready = payload.EventData.ToObject <Ready>();
if (ready.Guilds.Count != 0)
{
Interface.Oxide.LogWarning($"[Discord Extension] Your bot was found in {ready.Guilds.Count} Guilds!");
}
if (ready.Guilds.Count == 0 && client.Settings.Debugging)
{
Interface.Oxide.LogDebug($"[Discord Extension] Ready event but no Guilds sent.");
}
client.DiscordServers = ready.Guilds;
client.SessionID = ready.SessionID;
client.CallHook("Discord_Ready", null, ready);
break;
}
case "RESUMED":
{
Resumed resumed = payload.EventData.ToObject <Resumed>();
Interface.Oxide.LogWarning("[Discord Extension] Session resumed!");
client.CallHook("Discord_Resumed", null, resumed);
break;
}
case "CHANNEL_CREATE":
{
Channel channelCreate = payload.EventData.ToObject <Channel>();
if (channelCreate.type == ChannelType.DM || channelCreate.type == ChannelType.GROUP_DM)
{
client.DMs.Add(channelCreate);
}
else
{
client.GetGuild(channelCreate.guild_id).channels.Add(channelCreate);
}
client.CallHook("Discord_ChannelCreate", null, channelCreate);
break;
}
case "CHANNEL_UPDATE":
{
Channel channelUpdated = payload.EventData.ToObject <Channel>();
Channel channelPrevious = (channelUpdated.type == ChannelType.DM || channelUpdated.type == ChannelType.GROUP_DM)
? client.DMs?.FirstOrDefault(x => x.id == channelUpdated.id)
: client.GetGuild(channelUpdated.guild_id).channels.FirstOrDefault(x => x.id == channelUpdated.id);
if (channelPrevious != null)
{
if (channelUpdated.type == ChannelType.DM || channelUpdated.type == ChannelType.GROUP_DM)
{
client.DMs.Remove(channelPrevious);
}
else
{
client.GetGuild(channelUpdated.guild_id).channels.Remove(channelPrevious);
}
}
if (channelUpdated.type == ChannelType.DM || channelUpdated.type == ChannelType.GROUP_DM)
{
client.DMs.Add(channelUpdated);
}
else
{
client.GetGuild(channelUpdated.guild_id).channels.Add(channelUpdated);
}
client.CallHook("Discord_ChannelUpdate", null, channelUpdated, channelPrevious);
break;
}
case "CHANNEL_DELETE":
{
Channel channelDelete = payload.EventData.ToObject <Channel>();
client.GetGuild(channelDelete.guild_id).channels.Remove(channelDelete);
client.CallHook("Discord_ChannelDelete", null, channelDelete);
break;
}
case "CHANNEL_PINS_UPDATE":
{
ChannelPinsUpdate channelPinsUpdate = payload.EventData.ToObject <ChannelPinsUpdate>();
client.CallHook("Discord_ChannelPinsUpdate", null, channelPinsUpdate);
break;
}
// NOTE: Some elements of Guild object is only sent with GUILD_CREATE
case "GUILD_CREATE":
{
Guild guildCreate = payload.EventData.ToObject <Guild>();
string g_id = guildCreate.id;
bool g_unavail = guildCreate.unavailable ?? false;
if (client.GetGuild(g_id) == null)
{
client.DiscordServers.Add(guildCreate);
if (client.Settings.Debugging)
{
Interface.Oxide.LogDebug($"[Discord Extension] Guild ID ({g_id}) added to list.");
}
}
else if (g_unavail == false && (client.GetGuild(g_id)?.unavailable ?? false) == true)
{
client.UpdateGuild(g_id, guildCreate);
if (client.Settings.Debugging)
{
Interface.Oxide.LogDebug($"[Discord Extension] Guild ID ({g_id}) updated to list.");
}
}
client.CallHook("Discord_GuildCreate", null, guildCreate);
break;
}
case "GUILD_UPDATE":
{
Guild guildUpdate = payload.EventData.ToObject <Guild>();
//client.UpdateGuild(guildUpdate.id, guildUpdate); // <-- DON'T REPLACE GUILD REFERENCE!!!!
client.GetGuild(guildUpdate.id).Update(guildUpdate);
client.CallHook("Discord_GuildUpdate", null, guildUpdate);
break;
}
case "GUILD_DELETE":
{
Guild guildDelete = payload.EventData.ToObject <Guild>();
if (guildDelete.unavailable ?? false == true) // outage
{
Interface.Oxide.LogDebug($"[DEBUG] Guild ID {guildDelete.id} outage!");
client.UpdateGuild(guildDelete.id, guildDelete);
}
else
{
Interface.Oxide.LogDebug($"[DEBUG] Guild ID {guildDelete.id} removed from list");
client.DiscordServers.Remove(client.GetGuild(guildDelete.id)); // guildDelete may not be same reference
}
client.CallHook("Discord_GuildDelete", null, guildDelete);
break;
}
case "GUILD_BAN_ADD":
{
User bannedUser = payload.EventData.ToObject <BanObject>().user;
client.CallHook("Discord_GuildBanAdd", null, bannedUser);
break;
}
case "GUILD_BAN_REMOVE":
{
User unbannedUser = payload.EventData.ToObject <BanObject>().user;
client.CallHook("Discord_GuildBanRemove", null, unbannedUser);
break;
}
case "GUILD_EMOJIS_UPDATE":
{
GuildEmojisUpdate guildEmojisUpdate = payload.EventData.ToObject <GuildEmojisUpdate>();
client.CallHook("Discord_GuildEmojisUpdate", null, guildEmojisUpdate);
break;
}
case "GUILD_INTEGRATIONS_UPDATE":
{
GuildIntergrationsUpdate guildIntergrationsUpdate = payload.EventData.ToObject <GuildIntergrationsUpdate>();
client.CallHook("Discord_GuildIntergrationsUpdate", null, guildIntergrationsUpdate);
break;
}
case "GUILD_MEMBER_ADD":
{
GuildMemberAdd memberAdded = payload.EventData.ToObject <GuildMemberAdd>();
GuildMember guildMember = memberAdded as GuildMember;
client.GetGuild(memberAdded.guild_id)?.members.Add(guildMember);
client.CallHook("Discord_MemberAdded", null, guildMember);
break;
}
case "GUILD_MEMBER_REMOVE":
{
GuildMemberRemove memberRemoved = payload.EventData.ToObject <GuildMemberRemove>();
GuildMember member = client.GetGuild(memberRemoved.guild_id)?.members.FirstOrDefault(x => x.user.id == memberRemoved.user.id);
if (member != null)
{
client.GetGuild(memberRemoved.guild_id)?.members.Remove(member);
}
client.CallHook("Discord_MemberRemoved", null, member);
break;
}
case "GUILD_MEMBER_UPDATE":
{
GuildMemberUpdate memberUpdated = payload.EventData.ToObject <GuildMemberUpdate>();
GuildMember newMember = client.GetGuild(memberUpdated.guild_id)?.members.FirstOrDefault(x => x.user.id == memberUpdated.user.id);
GuildMember oldMember = Newtonsoft.Json.Linq.JObject.FromObject(newMember).ToObject <GuildMember>(); // lazy way to copy the object
if (newMember != null)
{
if (memberUpdated.user != null)
{
newMember.user = memberUpdated.user;
}
if (memberUpdated.nick != null)
{
newMember.nick = memberUpdated.nick;
}
if (memberUpdated.roles != null)
{
newMember.roles = memberUpdated.roles;
}
}
client.CallHook("Discord_GuildMemberUpdate", null, memberUpdated, oldMember);
break;
}
case "GUILD_MEMBERS_CHUNK":
{
GuildMembersChunk guildMembersChunk = payload.EventData.ToObject <GuildMembersChunk>();
client.CallHook("Discord_GuildMembersChunk", null, guildMembersChunk);
break;
}
case "GUILD_ROLE_CREATE":
{
GuildRoleCreate guildRoleCreate = payload.EventData.ToObject <GuildRoleCreate>();
client.GetGuild(guildRoleCreate.guild_id)?.roles.Add(guildRoleCreate.role);
client.CallHook("Discord_GuildRoleCreate", null, guildRoleCreate.role);
break;
}
case "GUILD_ROLE_UPDATE":
{
GuildRoleUpdate guildRoleUpdate = payload.EventData.ToObject <GuildRoleUpdate>();
Role newRole = guildRoleUpdate.role;
Role oldRole = client.GetGuild(guildRoleUpdate.guild_id).roles.FirstOrDefault(x => x.id == newRole.id);
if (oldRole != null)
{
client.GetGuild(guildRoleUpdate.guild_id).roles.Remove(oldRole);
}
client.GetGuild(guildRoleUpdate.guild_id).roles.Add(newRole);
client.CallHook("Discord_GuildRoleUpdate", null, newRole, oldRole);
break;
}
case "GUILD_ROLE_DELETE":
{
GuildRoleDelete guildRoleDelete = payload.EventData.ToObject <GuildRoleDelete>();
Role deletedRole = client.GetGuild(guildRoleDelete.guild_id)?.roles.FirstOrDefault(x => x.id == guildRoleDelete.role_id);
if (deletedRole != null)
{
client.GetGuild(guildRoleDelete.guild_id).roles.Remove(deletedRole);
}
client.CallHook("Discord_GuildRoleDelete", null, deletedRole);
break;
}
case "MESSAGE_CREATE":
{
Message messageCreate = payload.EventData.ToObject <Message>();
Channel c;
if (messageCreate.guild_id != null)
{
c = client.GetGuild(messageCreate.guild_id)?.channels.FirstOrDefault(x => x.id == messageCreate.channel_id);
}
else
{
c = client.DMs.FirstOrDefault(x => x.id == messageCreate.channel_id);
}
if (c != null)
{
c.last_message_id = messageCreate.id;
}
client.CallHook("Discord_MessageCreate", null, messageCreate);
break;
}
case "MESSAGE_UPDATE":
{
Message messageUpdate = payload.EventData.ToObject <Message>();
client.CallHook("Discord_MessageUpdate", null, messageUpdate);
break;
}
case "MESSAGE_DELETE":
{
MessageDelete messageDelete = payload.EventData.ToObject <MessageDelete>();
client.CallHook("Discord_MessageDelete", null, messageDelete);
break;
}
case "MESSAGE_DELETE_BULK":
{
MessageDeleteBulk messageDeleteBulk = payload.EventData.ToObject <MessageDeleteBulk>();
client.CallHook("Discord_MessageDeleteBulk", null, messageDeleteBulk);
break;
}
case "MESSAGE_REACTION_ADD":
{
MessageReactionUpdate messageReactionAdd = payload.EventData.ToObject <MessageReactionUpdate>();
client.CallHook("Discord_MessageReactionAdd", null, messageReactionAdd);
break;
}
case "MESSAGE_REACTION_REMOVE":
{
MessageReactionUpdate messageReactionRemove = payload.EventData.ToObject <MessageReactionUpdate>();
client.CallHook("Discord_MessageReactionRemove", null, messageReactionRemove);
break;
}
case "MESSAGE_REACTION_REMOVE_ALL":
{
MessageReactionRemoveAll messageReactionRemoveAll = payload.EventData.ToObject <MessageReactionRemoveAll>();
client.CallHook("Discord_MessageReactionRemoveAll", null, messageReactionRemoveAll);
break;
}
/*
* From Discord API docs:
* The user object within this event can be partial, the only field which must be sent is the id field, everything else is optional.
* Along with this limitation, no fields are required, and the types of the fields are not validated.
* Your client should expect any combination of fields and types within this event.
*/
case "PRESENCE_UPDATE":
{
PresenceUpdate presenceUpdate = payload.EventData.ToObject <PresenceUpdate>();
User updatedPresence = presenceUpdate?.user;
if (updatedPresence != null)
{
var updatedMember = client.GetGuild(presenceUpdate.guild_id)?.members.FirstOrDefault(x => x.user.id == updatedPresence.id);
if (updatedMember != null)
{
//updatedMember.user = updatedPresence;
updatedMember.user.Update(updatedPresence);
}
}
client.CallHook("Discord_PresenceUpdate", null, updatedPresence);
break;
}
// Bots should ignore this
case "PRESENCES_REPLACE":
break;
case "TYPING_START":
{
TypingStart typingStart = payload.EventData.ToObject <TypingStart>();
client.CallHook("Discord_TypingStart", null, typingStart);
break;
}
case "USER_UPDATE":
{
User userUpdate = payload.EventData.ToObject <User>();
//GuildMember memberUpdate = client.DiscordServer.members.FirstOrDefault(x => x.user.id == userUpdate.id);
//memberUpdate.user = userUpdate;
var guilds = client.DiscordServers.Where(x => x.members.FirstOrDefault(y => y.user.id == userUpdate.id) != null).ToList();
foreach (Guild g in guilds)
{
GuildMember memberUpdate = g.members.FirstOrDefault(x => x.user.id == userUpdate.id);
memberUpdate.user = userUpdate;
}
client.CallHook("Discord_UserUpdate", null, userUpdate);
break;
}
case "VOICE_STATE_UPDATE":
{
VoiceState voiceStateUpdate = payload.EventData.ToObject <VoiceState>();
client.CallHook("Discord_VoiceStateUpdate", null, voiceStateUpdate);
break;
}
case "VOICE_SERVER_UPDATE":
{
VoiceServerUpdate voiceServerUpdate = payload.EventData.ToObject <VoiceServerUpdate>();
client.CallHook("Discord_VoiceServerUpdate", null, voiceServerUpdate);
break;
}
case "WEBHOOKS_UPDATE":
{
WebhooksUpdate webhooksUpdate = payload.EventData.ToObject <WebhooksUpdate>();
client.CallHook("Discord_WebhooksUpdate", null, webhooksUpdate);
break;
}
case "INVITE_CREATE":
{
InviteCreated invitecreatedUpdate = payload.EventData.ToObject <InviteCreated>();
client.CallHook("Discord_InviteCreated", null, invitecreatedUpdate);
break;
}
case "INVITE_DELETE":
{
InviteDeleted invitedeletedUpdate = payload.EventData.ToObject <InviteDeleted>();
client.CallHook("Discord_InviteDeleted", null, invitedeletedUpdate);
break;
}
default:
{
client.CallHook("Discord_UnhandledEvent", null, payload);
Interface.Oxide.LogWarning($"[Discord Extension] [Debug] Unhandled event: {payload.EventName}");
break;
}
}
break;
}
// Heartbeat
// https://discordapp.com/developers/docs/topics/gateway#gateway-heartbeat
case OpCodes.Heartbeat:
{
Interface.Oxide.LogInfo($"[Discord Extension] Manully sent heartbeat (received opcode 1)");
client.SendHeartbeat();
break;
}
// Reconnect (used to tell clients to reconnect to the gateway)
// we should immediately reconnect here
case OpCodes.Reconnect:
{
Interface.Oxide.LogInfo($"[Discord Extension] Reconnect has been called (opcode 7)! Reconnecting...");
webSocket.hasConnectedOnce = true; // attempt resume opcode
webSocket.Connect(client.WSSURL);
break;
}
// Invalid Session (used to notify client they have an invalid session ID)
case OpCodes.InvalidSession:
{
Interface.Oxide.LogInfo($"[Discord Extension] Invalid Session ID opcode recieved!");
client.requestReconnect = true;
webSocket.hasConnectedOnce = false;
webSocket.Disconnect(false);
break;
}
// Hello (sent immediately after connecting, contains heartbeat and server debug information)
case OpCodes.Hello:
{
Hello hello = payload.EventData.ToObject <Hello>();
client.CreateHeartbeat(hello.HeartbeatInterval);
// Client should now perform identification
//client.Identify();
if (webSocket.hasConnectedOnce)
{
Interface.Oxide.LogWarning("[Discord Extension] Attempting resume opcode...");
client.Resume();
}
else
{
client.Identify();
webSocket.hasConnectedOnce = true;
}
break;
}
// Heartbeat ACK (sent immediately following a client heartbeat
// that was received)
// (See 'zombied or failed connections')
case OpCodes.HeartbeatACK:
{
client.HeartbeatACK = true;
break;
}
default:
{
Interface.Oxide.LogInfo($"[Discord Extension] Unhandled OP code: code {payload.OpCode}");
break;
}
}
}
/// <summary>
/// Called when a guild member is accepted into a guild during
/// synchronization.
/// </summary>
/// <param name="guild"></param>
protected virtual void OnSyncGuildMemberAccepted(Guild guild, GuildMember guildMember)
{
}
public async Task HandleCommandAsync(SocketMessage socketMessage)
{
if (!(socketMessage is SocketUserMessage message) ||
message.Author.IsWebhook ||
message.Channel is IPrivateChannel)
{
return;
}
if (!(socketMessage.Author is SocketGuildUser guildAuthor))
{
return;
}
Guild guild = null;
try { guild = await Guilds.GetAsync(guildAuthor.Guild); }
catch
{
await message.Channel.SendMessageAsync(embed :
await EmbedHandler.CreateErrorEmbed("Database",
"Server configuration corrupted. Please type /reset to reset it."));
return;
}
var prefix = guild?.General.CommandPrefix ?? ".";
int position = 0;
bool isCommand = message.HasStringPrefix(prefix, ref position);
bool userCanEarnEXP = guild.XP.Enabled && !message.Author.IsBot;
if (!isCommand && userCanEarnEXP)
{
try { await Leveling.ValidateForEXPAsync(message, guild); }
catch {}
return;
}
if (message.Author.IsBot)
{
return;
}
var context = new CustomCommandContext(Global.Client, message)
{
CurrentGuild = guild
};
CommandValidation validation;
try { validation = ValidateCommandExists(position, context); }
catch (ArgumentNullException) { return; }
var command = validation.Command;
try { ValidateCommand(command, guild, message); }
catch (InvalidOperationException ex)
{
await message.Channel.SendMessageAsync(embed : await EmbedHandler.CreateErrorEmbed("Commands", ex.Message));
return;
}
var execution = commands.ExecuteAsync(context, position, services, MultiMatchHandling.Best);
if (!execution.Result.IsSuccess)
{
await HandleFailedExecution(message, prefix, execution);
}
}
/// <summary>
/// Called when a guild member's rank changes during synchronization.
/// </summary>
/// <param name="guild"></param>
protected virtual void OnSyncGuildMemberUpdated(Guild guild, GuildMember guildMember)
{
}
public GuildBreakAllianceGump(Mobile from, Guild guild)
: base(from, guild, true, guild.Allies)
{
}
public void LogoutPlayer(bool save)
{
// finish pending transfers before starting the logout
while (_player && _player.IsBeingTeleportedFar())
{
HandleMoveWorldportAck();
}
m_playerLogout = true;
m_playerSave = save;
if (_player)
{
if (!_player.GetLootGUID().IsEmpty())
{
DoLootReleaseAll();
}
// If the player just died before logging out, make him appear as a ghost
//FIXME: logout must be delayed in case lost connection with client in time of combat
if (GetPlayer().GetDeathTimer() != 0)
{
_player.getHostileRefManager().deleteReferences();
_player.BuildPlayerRepop();
_player.RepopAtGraveyard();
}
else if (GetPlayer().HasAuraType(AuraType.SpiritOfRedemption))
{
// this will kill character by SPELL_AURA_SPIRIT_OF_REDEMPTION
_player.RemoveAurasByType(AuraType.ModShapeshift);
_player.KillPlayer();
_player.BuildPlayerRepop();
_player.RepopAtGraveyard();
}
else if (GetPlayer().HasPendingBind())
{
_player.RepopAtGraveyard();
_player.SetPendingBind(0, 0);
}
//drop a flag if player is carrying it
Battleground bg = GetPlayer().GetBattleground();
if (bg)
{
bg.EventPlayerLoggedOut(GetPlayer());
}
// Teleport to home if the player is in an invalid instance
if (!_player.m_InstanceValid && !_player.IsGameMaster())
{
_player.TeleportTo(_player.GetHomebind());
}
Global.OutdoorPvPMgr.HandlePlayerLeaveZone(_player, _player.GetZoneId());
for (uint i = 0; i < SharedConst.MaxPlayerBGQueues; ++i)
{
BattlegroundQueueTypeId bgQueueTypeId = GetPlayer().GetBattlegroundQueueTypeId(i);
if (bgQueueTypeId != 0)
{
_player.RemoveBattlegroundQueueId(bgQueueTypeId);
BattlegroundQueue queue = Global.BattlegroundMgr.GetBattlegroundQueue(bgQueueTypeId);
queue.RemovePlayer(_player.GetGUID(), true);
}
}
// Repop at GraveYard or other player far teleport will prevent saving player because of not present map
// Teleport player immediately for correct player save
while (_player.IsBeingTeleportedFar())
{
HandleMoveWorldportAck();
}
// If the player is in a guild, update the guild roster and broadcast a logout message to other guild members
Guild guild = Global.GuildMgr.GetGuildById(_player.GetGuildId());
if (guild)
{
guild.HandleMemberLogout(this);
}
// Remove pet
_player.RemovePet(null, PetSaveMode.AsCurrent, true);
// Clear whisper whitelist
_player.ClearWhisperWhiteList();
// empty buyback items and save the player in the database
// some save parts only correctly work in case player present in map/player_lists (pets, etc)
if (save)
{
for (int j = InventorySlots.BuyBackStart; j < InventorySlots.BuyBackEnd; ++j)
{
int eslot = j - InventorySlots.BuyBackStart;
_player.SetGuidValue(PlayerFields.InvSlotHead + (j * 4), ObjectGuid.Empty);
_player.SetUInt32Value(PlayerFields.BuyBackPrice1 + eslot, 0);
_player.SetUInt32Value(PlayerFields.BuyBackTimestamp1 + eslot, 0);
}
_player.SaveToDB();
}
// Leave all channels before player delete...
_player.CleanupChannels();
// If the player is in a group (or invited), remove him. If the group if then only 1 person, disband the group.
_player.UninviteFromGroup();
// remove player from the group if he is:
// a) in group; b) not in raid group; c) logging out normally (not being kicked or disconnected)
if (_player.GetGroup() && !_player.GetGroup().isRaidGroup() && m_Socket[(int)ConnectionType.Realm] != null)
{
_player.RemoveFromGroup();
}
//! Send update to group and reset stored max enchanting level
if (_player.GetGroup())
{
_player.GetGroup().SendUpdate();
_player.GetGroup().ResetMaxEnchantingLevel();
}
//! Broadcast a logout message to the player's friends
Global.SocialMgr.SendFriendStatus(_player, FriendsResult.Offline, _player.GetGUID(), true);
_player.RemoveSocial();
//! Call script hook before deletion
Global.ScriptMgr.OnPlayerLogout(GetPlayer());
//! Remove the player from the world
// the player may not be in the world when logging out
// e.g if he got disconnected during a transfer to another map
// calls to GetMap in this case may cause crashes
GetPlayer().CleanupsBeforeDelete();
Log.outInfo(LogFilter.Player, "Account: {0} (IP: {1}) Logout Character:[{2}] (GUID: {3}) Level: {4}",
GetAccountId(), GetRemoteAddress(), _player.GetName(), _player.GetGUID().ToString(), _player.getLevel());
Map map = GetPlayer().GetMap();
if (map != null)
{
map.RemovePlayerFromMap(GetPlayer(), true);
}
SetPlayer(null);
//! Send the 'logout complete' packet to the client
//! Client will respond by sending 3x CMSG_CANCEL_TRADE, which we currently dont handle
LogoutComplete logoutComplete = new LogoutComplete();
SendPacket(logoutComplete);
//! Since each account can only have one online character at any given time, ensure all characters for active account are marked as offline
PreparedStatement stmt = DB.Characters.GetPreparedStatement(CharStatements.UPD_ACCOUNT_ONLINE);
stmt.AddValue(0, GetAccountId());
DB.Characters.Execute(stmt);
}
if (m_Socket[(int)ConnectionType.Instance] != null)
{
m_Socket[(int)ConnectionType.Instance].CloseSocket();
m_Socket[(int)ConnectionType.Instance] = null;
}
m_playerLogout = false;
m_playerSave = false;
m_playerRecentlyLogout = true;
SetLogoutStartTime(0);
}
public static bool ValidIndirectTarget(Mobile from, Mobile to)
{
if (from == to)
{
return(true);
}
if (to.Hidden && to.AccessLevel > from.AccessLevel)
{
return(false);
}
Guild fromGuild = GetGuildFor(from);
Guild toGuild = GetGuildFor(to);
if (fromGuild != null && toGuild != null && (fromGuild == toGuild || fromGuild.IsAlly(toGuild)))
{
return(false);
}
Party p = Party.Get(from);
if (p != null && p.Contains(to))
{
return(false);
}
if (to is BaseCreature)
{
BaseCreature c = (BaseCreature)to;
if (c.Controlled || c.Summoned)
{
if (c.ControlMaster == from || c.SummonMaster == from)
{
return(false);
}
if (p != null && (p.Contains(c.ControlMaster) || p.Contains(c.SummonMaster)))
{
return(false);
}
}
}
if (from is BaseCreature)
{
BaseCreature c = (BaseCreature)from;
if (c.Controlled || c.Summoned)
{
if (c.ControlMaster == to || c.SummonMaster == to)
{
return(false);
}
p = Party.Get(to);
if (p != null && (p.Contains(c.ControlMaster) || p.Contains(c.SummonMaster)))
{
return(false);
}
}
}
if (to is BaseCreature && !((BaseCreature)to).Controlled && ((BaseCreature)to).InitialInnocent)
{
return(true);
}
int noto = Notoriety.Compute(from, to);
return(noto != Notoriety.Innocent || from.Kills >= 5);
}
public async Task NewEmbed()
{
if (Users.Contains(Context.User))
{
int index = Users.FindIndex(user => user == Context.User);
UserEmbeds[index] = new EmbedBuilder();
var message = await ReplyAsync("Your embed has been reset.");
message.DeleteAfter(5);
}
else
{
Users.Add(Context.User);
UserEmbeds.Add(new EmbedBuilder());
var message = await ReplyAsync("Your embed has been created. Please type `" + Guild.Load(Context.Guild.Id).Prefix + "embed` to see the available commands.");
message.DeleteAfter(5);
}
}
public GuildDeclareWarPrompt(Mobile m, Guild g)
{
m_Mobile = m;
m_Guild = g;
}
public async Task ListRequestQuotes()
{
EmbedBuilder eb;
if (!RequestQuote.RequestQuotes.Any())
{
eb = new EmbedBuilder
{
Title = "Pending Request Quotes",
Description = "There is currently 0 quotes pending review.",
Color = new Color(235, 160, 40)
};
await ReplyAsync("", false, eb.Build());
return;
}
AdminLog.Log(Context.User.Id, Context.Message.Content, Context.Guild.Id);
List <string> quotePages = new List <string>();
RequestQuote.RequestQuotes.Select((v, i) => new { Value = v, Index = i / 10 })
.GroupBy(x => x.Index).ToList()
.ForEach(x => quotePages.Add(String.Join("\n", x.Select(z => z.Value.QuoteText + " (ID: " + z.Value.RequestId + " | BY: " + z.Value.CreatedBy.GetUser().Mention + ")"))));
PaginatedMessage msg = new PaginatedMessage
{
Title = "Request Quotes",
Pages = quotePages,
Color = new Color(211, 214, 77),
Options = new PaginatedAppearanceOptions()
{
DisplayInformationIcon = false
}
};
await PagedReplyAsync(msg);
await ReplyAsync(
$"You can accept quotes by using the command `{Guild.Load(Context.Guild.Id).Prefix}acceptquote [id]`, and reject quotes by using the command `{Guild.Load(Context.Guild.Id).Prefix}denyquote [id]`");
}
/// <summary>
/// claim the keep to a guild
/// </summary>
/// <param name="player">the player who have claim the keep</param>
public virtual void Claim(GamePlayer player)
{
this.m_guild = player.Guild;
player.Guild.ClaimedKeeps.Add(this);
if (ServerProperties.Properties.GUILDS_CLAIM_LIMIT > 1)
player.Guild.SendMessageToGuildMembers("Your guild has currently claimed " + player.Guild.ClaimedKeeps.Count + " keeps of a maximum of " + ServerProperties.Properties.GUILDS_CLAIM_LIMIT, eChatType.CT_Guild, eChatLoc.CL_ChatWindow);
ChangeLevel((byte)ServerProperties.Properties.STARTING_KEEP_CLAIM_LEVEL);
PlayerMgr.BroadcastClaim(this);
foreach (GameKeepGuard guard in Guards.Values)
{
guard.ChangeGuild();
}
foreach (GameKeepBanner banner in Banners.Values)
{
banner.ChangeGuild();
}
GameEventMgr.Notify(KeepEvent.KeepClaimed, this, new KeepEventArgs(this));
StartDeductionTimer();
this.SaveIntoDatabase();
}
public async Task SendWelcomeMessage(SocketGuildUser user)
{
await Guild.Load(Context.Guild.Id).WelcomeChannelID.GetTextChannel().SendMessageAsync(Guild.Load(Context.Guild.Id).WelcomeMessage.ModifyStringFlags(user));
AdminLog.Log(Context.User.Id, Context.Message.Content, Context.Guild.Id, user.Id);
await Guild.Load(Context.Guild.Id).LogChannelID.GetTextChannel().SendMessageAsync("A welcome message for " + user.Mention + " has been posted. (Forced by: " + Context.User.Mention + ")");
}
public void CheckExpiredWars()
{
for (int i = 0; i < AcceptedWars.Count; i++)
{
WarDeclaration w = AcceptedWars[i];
Guild g = w.Opponent;
WarStatus status = w.Status;
if (status != WarStatus.InProgress)
{
AllianceInfo myAlliance = Alliance;
bool inAlliance = myAlliance?.IsMember(this) == true;
AllianceInfo otherAlliance = g?.Alliance;
bool otherInAlliance = otherAlliance?.IsMember(this) == true;
if (inAlliance)
{
myAlliance.AllianceMessage(1070739 + (int)status,
g == null ? "a deleted opponent" : otherInAlliance ? otherAlliance.Name : g.Name);
myAlliance.InvalidateMemberProperties();
}
else
{
GuildMessage(1070739 + (int)status,
g == null ? "a deleted opponent" : otherInAlliance?otherAlliance.Name: g.Name);
InvalidateMemberProperties();
}
AcceptedWars.Remove(w);
if (g == null)
{
continue;
}
if (status != WarStatus.Draw)
{
status = (WarStatus)((int)status + 1 % 2);
}
if (otherInAlliance)
{
otherAlliance.AllianceMessage(1070739 + (int)status, inAlliance ? Alliance.Name : Name);
otherAlliance.InvalidateMemberProperties();
}
else
{
g.GuildMessage(1070739 + (int)status, inAlliance ? Alliance.Name : Name);
g.InvalidateMemberProperties();
}
g.AcceptedWars.Remove(g.FindActiveWar(this));
}
}
for (int i = 0; i < PendingWars.Count; i++)
{
WarDeclaration w = PendingWars[i];
Guild g = w.Opponent;
if (w.Status != WarStatus.Pending)
{
//All sanity in here
PendingWars.Remove(w);
g?.PendingWars.Remove(g.FindPendingWar(this));
}
}
}
public GuildAcceptWarGump(Mobile from, Guild guild) : base(from, guild, true, guild.WarInvitations)
{
}
/// <summary>
/// Called when a guild is removed from the manager during
/// synchronization.
/// </summary>
/// <param name="guild"></param>
protected virtual void OnSyncGuildAdded(Guild guild)
{
}
public bool IsAlly(Guild g) => NewGuildSystem?Alliance?.IsMember(this) == true && Alliance.IsMember(g) : Allies.Contains(g);
/// <summary>
/// Called when a guild member is removed from a guild during
/// synchronization.
/// </summary>
/// <param name="guild"></param>
protected virtual void OnSyncGuildMemberRemoved(Guild guild, GuildMember guildMember)
{
}
public bool IsEnemy(Guild g) => Type != GuildType.Regular && g.Type != GuildType.Regular && Type != g.Type || IsWar(g);
/// <summary>
/// Called when a guild member is declined from a guild during
/// synchronization.
/// </summary>
/// <param name="guild"></param>
protected virtual void OnSyncGuildMemberDeclined(Guild guild, GuildMember guildMember)
{
}
public override void Deserialize(IGenericReader reader)
{
int version = reader.ReadInt();
switch (version)
{
case 5:
{
int count = reader.ReadInt();
PendingWars = new List <WarDeclaration>();
for (int i = 0; i < count; i++)
{
PendingWars.Add(new WarDeclaration(reader));
}
count = reader.ReadInt();
AcceptedWars = new List <WarDeclaration>();
for (int i = 0; i < count; i++)
{
AcceptedWars.Add(new WarDeclaration(reader));
}
bool isAllianceLeader = reader.ReadBool();
if (isAllianceLeader)
{
m_AllianceInfo = new AllianceInfo(reader);
}
else
{
m_AllianceLeader = reader.ReadGuild() as Guild;
}
goto case 4;
}
case 4:
{
AllyDeclarations = reader.ReadStrongGuildList <Guild>();
AllyInvitations = reader.ReadStrongGuildList <Guild>();
goto case 3;
}
case 3:
{
TypeLastChange = reader.ReadDateTime();
goto case 2;
}
case 2:
{
m_Type = (GuildType)reader.ReadInt();
goto case 1;
}
case 1:
{
LastFealty = reader.ReadDateTime();
goto case 0;
}
case 0:
{
m_Leader = reader.ReadMobile();
if (m_Leader is PlayerMobile mobile)
{
mobile.GuildRank = RankDefinition.Leader;
}
m_Name = reader.ReadString();
m_Abbreviation = reader.ReadString();
Allies = reader.ReadStrongGuildList <Guild>();
Enemies = reader.ReadStrongGuildList <Guild>();
WarDeclarations = reader.ReadStrongGuildList <Guild>();
WarInvitations = reader.ReadStrongGuildList <Guild>();
Members = reader.ReadStrongMobileList();
Candidates = reader.ReadStrongMobileList();
Accepted = reader.ReadStrongMobileList();
Guildstone = reader.ReadItem();
Teleporter = reader.ReadItem();
Charter = reader.ReadString();
Website = reader.ReadString();
break;
}
}
AllyDeclarations ??= new List <Guild>();
AllyInvitations ??= new List <Guild>();
AcceptedWars ??= new List <WarDeclaration>();
PendingWars ??= new List <WarDeclaration>();
Timer.DelayCall(TimeSpan.Zero, VerifyGuild_Callback);
}
/// <summary>
/// Loads given guild, adding it to the manager.
/// </summary>
/// <param name="guild"></param>
protected virtual void LoadGuild(Guild guild)
{
lock (_syncLock)
_guilds[guild.Id] = guild;
}
public async Task EmbedWithColor(int r = -1, int g = -1, int b = -1)
{
if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255)
{
await ReplyAsync(Context.User.Mention + ", you have entered an invalid value. You can use this website to help get your RGB values - <http://www.colorhexa.com/>\n\n" +
"**Syntax:** " + Guild.Load(Context.Guild.Id).Prefix + "embed withcolor [R value] [G value] [B value]\n**Example:** " + Guild.Load(Context.Guild.Id).Prefix + "embed withcolor 140 90 210");
return;
}
byte rValue, gValue, bValue;
try
{
byte.TryParse(r.ToString(), out rValue);
byte.TryParse(g.ToString(), out gValue);
byte.TryParse(b.ToString(), out bValue);
}
catch (Exception e)
{
await new LogMessage(LogSeverity.Warning, "EmbedModule", e.Message).PrintToConsole();
await ReplyAsync("An unexpected error has happened. Please ensure that you have passed through a byte value! (A number between 0 and 255)");
return;
}
if (Users.Contains(Context.User))
{
int index = Users.FindIndex(user => user == Context.User);
UserEmbeds[index].WithColor(rValue, gValue, bValue);
var message = await ReplyAsync("added");
message.DeleteAfter(10);
}
else
{
await NewEmbed().ConfigureAwait(false);
await EmbedWithColor(r, g, b).ConfigureAwait(false);
}
}
