public override IEnumerable <object> Run()
{
yield return(null);
if (base.Feedback is long)
{
long guildID = (long)base.Feedback;
yield return(null);
string guildName = (string)base.Feedback;
yield return(null);
int guildLevel = (int)base.Feedback;
yield return(null);
GuildMemberRank rank = (GuildMemberRank)base.Feedback;
yield return(null);
int MaxMemberLimit = (int)base.Feedback;
base.Operation.BriefGuildInfo = new BriefGuildInfo(guildID, guildName, guildLevel, rank, MaxMemberLimit);
}
else
{
base.Result = false;
base.Operation.BriefGuildInfo = null;
}
yield break;
}
/*
* public List<Player> LoadPlayerGuild(string accName)
* {
* string cmdString = "SELECT * FROM `guilds` WHERE AccountName=?username AND deleted = ?delete";
* MySqlCommand command = new MySqlCommand(cmdString, GuildDAOConnection);
* command.Parameters.AddWithValue("?username", accName);
* command.Parameters.AddWithValue("?delete", 0);
* MySqlDataReader reader = command.ExecuteReader();
*
* List<Player> players = new List<Player>();
* if (reader.HasRows)
* {
* while (reader.Read())
* {
* Player player = new Player()
* {
* Id = reader.GetInt32(0),
* AccountName = reader.GetString(1),
* Level = reader.GetInt32(2),
* Exp = reader.GetInt64(3),
* ExpRecoverable = reader.GetInt64(4),
* Mount = reader.GetInt32(5),
* UiSettings = (reader.GetString(6) != null) ? HexToBytes(reader.GetString(6)) : new byte[0],
* GuildAccepted = (byte)reader.GetInt16(7),
* PraiseGiven = (byte)reader.GetInt16(8),
* LastPraise = reader.GetInt32(9),
* CurrentBankSection = reader.GetInt32(10),
* CreationDate = reader.GetInt32(11),
* LastOnline = reader.GetInt32(12)
* };
* players.Add(player);
* }
* }
* reader.Close();
*
* foreach (var player in players)
* {
* cmdString = "SELECT * FROM character_data WHERE PlayerId=?id";
* command = new MySqlCommand(cmdString, PlayerDAOConnection);
* command.Parameters.AddWithValue("?id", player.Id);
* reader = command.ExecuteReader();
* if (reader.HasRows)
* {
* while (reader.Read())
* {
*
* player.PlayerData = new PlayerData()
* {
* Name = reader.GetString(1),
* Gender = (Gender)Enum.Parse(typeof(Gender), reader.GetString(2)),
* Race = (Race)Enum.Parse(typeof(Race), reader.GetString(3)),
* Class = (PlayerClass)Enum.Parse(typeof(PlayerClass), reader.GetString(4)),
* Data = HexToBytes(reader.GetString(5)),
* Details = HexToBytes(reader.GetString(6)),
* };
*
* player.Position = new Structures.World.WorldPosition()
* {
* MapId = reader.GetInt32(7),
* X = reader.GetFloat(8),
* Y = reader.GetFloat(9),
* Z = reader.GetFloat(10),
* Heading = reader.GetInt16(11)
* };
* }
* }
* reader.Close();
* }
*
*
* return players;
* }
*/
public bool AddGuildRank(Guild g, GuildMemberRank gmr)
{
string SQL = "INSERT INTO guild_ranks "
+ "(gid, rankprivileges, rankname) "
+ "VALUES(?gid, ?rankpriv, ?rankname);";
// Are we GM
if (gmr.RankName == "GuildMaster")
{
gmr.RankPrivileges = 7;
}
else
{
gmr.RankPrivileges = 0;
}
MySqlCommand cmd = new MySqlCommand(SQL, GuildDAOConnection);
cmd.Parameters.AddWithValue("?gid", g.GuildId);
cmd.Parameters.AddWithValue("?rankpriv", gmr.RankPrivileges);
cmd.Parameters.AddWithValue("?rankname", gmr.RankName);
try
{
cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
Logger.WriteLine(LogState.Exception, "DAO: Guild Rank Add Error!" + ex.Message);
return(false);
}
return(true);
}
public bool AcceptJoin(GuildEntity guild, GuildMemberRank operatorRank, GuildMember targetMember, bool accept)
{
Log <GuildAPI> .Logger.InfoFormat("AcceptJoin: GuildMemberRank[{0}]", operatorRank);
if (!operatorRank.HasAcceptJoinPermission(targetMember.Rank))
{
return(false);
}
if (accept)
{
Log <GuildAPI> .Logger.InfoFormat("UserJoinApply: GuildSN[{0}], NexonSN[{1}], CharacterSN[{2}], CharacterName[{3}]", new object[]
{
guild.GuildSN,
targetMember.Key.NexonSN,
targetMember.Key.CharacterSN,
targetMember.Key.CharacterName
});
HeroesGuild.UserJoinApply(GuildAPI.ServerCode, guild.GuildSN, targetMember.Key.NexonSN, targetMember.Key.CharacterSN, targetMember.Key.CharacterName);
return(true);
}
Log <GuildAPI> .Logger.InfoFormat("UserJoinReject: GuildSN[{0}], NexonSN[{1}], CharacterSN[{2}], CharacterName[{3}]", new object[]
{
guild.GuildSN,
targetMember.Key.NexonSN,
targetMember.Key.CharacterSN,
targetMember.Key.CharacterName
});
HeroesGuild.UserJoinReject(GuildAPI.ServerCode, guild.GuildSN, targetMember.Key.NexonSN, targetMember.Key.CharacterSN, targetMember.Key.CharacterName);
return(true);
}
public GuildMemberEntry(PlayerMobile player, GuildMemberRank rank, DateTime joinDate, PlayerMobile declaredFealty)
{
m_Player = player;
m_Rank = rank;
m_JoinDate = joinDate;
m_DeclaredFealty = declaredFealty;
}
public bool ChangeRank(GuildEntity guild, GuildMemberRank operatorRank, GuildMember targetMember, GuildMemberRank toRank)
{
Log <GuildAPI> .Logger.InfoFormat("ChangeRank: MemberRank[{0}], MemberSN[{1}], ToRank[{2}]", operatorRank, targetMember.Key.NexonSN, toRank);
if (toRank == GuildMemberRank.Unknown)
{
if (operatorRank.HasSecedePermission(targetMember.Rank, toRank))
{
Log <GuildAPI> .Logger.InfoFormat("UserSecede: ServiceCode[{0}], GuildSN[{1}], MemberNexonSN[{2}]", GuildAPI.ServerCode, guild.GuildSN, targetMember.Key.NexonSN);
HeroesGuild.UserSecede(GuildAPI.ServerCode, guild.GuildSN, targetMember.Key.NexonSN, targetMember.Key.CharacterSN, targetMember.Key.CharacterName);
using (HeroesDataContext heroesDataContext = new HeroesDataContext())
{
heroesDataContext.UpdateGuildCharacterInfo(new long?(targetMember.Key.CID), new long?(0L));
GuildLog.AddGuildLedger(new LogData((long)guild.GuildSN, targetMember.Key.CID, OperationType.GainGuildPoint, GuildLedgerEventType.UpdateGuildUserPoint, "0", "Secede"));
}
return(true);
}
}
else if (operatorRank.HasRankChangePermission(targetMember.Rank, toRank))
{
Log <GuildAPI> .Logger.InfoFormat("UserTypeModify: ServiceCode[{0}], GuildSN[{1}], MemberNexonSN[{2}]", GuildAPI.ServerCode, guild.GuildSN, targetMember.Key.NexonSN);
HeroesGuild.UserTypeModify(GuildAPI.ServerCode, guild.GuildSN, targetMember.Key.NexonSN, targetMember.Key.CharacterSN, targetMember.Key.CharacterName, this.ConvertToGroupUserType(toRank.ToGroupUserType()));
return(true);
}
return(false);
}
public BriefGuildInfo(long guildID, string guildName, int guildLevel, GuildMemberRank rank, int maxMemberLimit)
{
this.GuildID = guildID;
this.GuildName = guildName;
this.GuildLevel = guildLevel;
this.MyRank = rank;
this.MaxMemberLimit = maxMemberLimit;
}
public GuildMemberInfo(string characterName, int level, GuildMemberRank rank, long point, DateTime lastLoginTime, bool isOnline)
{
this.CharacterName = characterName;
this.GameLevel = level;
this.Rank = (int)rank;
this.Point = point;
DateTime d = (lastLoginTime.Kind == DateTimeKind.Local) ? lastLoginTime.ToUniversalTime() : lastLoginTime;
this.LastLoginTime = (DateTime.UtcNow - d).Days;
this.IsOnline = isOnline;
}
public string GetRankName(GuildMemberRank rank)
{
string rankName = "";
int rankIndex = (int)rank;
if (rankIndex < m_RankNames.Length)
{
rankName = m_RankNames[rankIndex];
}
return(rankName);
}
public static bool HasRankChangePermission(this GuildMemberRank operatorRank, GuildMemberRank fromRank, GuildMemberRank toRank)
{
if (operatorRank == GuildMemberRank.Master)
{
if (fromRank == GuildMemberRank.Member && toRank == GuildMemberRank.Operator)
{
return(true);
}
if (fromRank == GuildMemberRank.Operator && toRank == GuildMemberRank.Member)
{
return(true);
}
}
return(false);
}
public bool CanApproveCandidates(GuildMemberRank rank)
{
switch (rank)
{
case GuildMemberRank.Recruit: return(false);
case GuildMemberRank.Initiate: return(false);
case GuildMemberRank.Veteran: return(false);
case GuildMemberRank.Officer: return(true);
case GuildMemberRank.Guildmaster: return(true);
}
return(false);
}
/// <summary>
/// Sends info on guild membership status changed. Pass null for guild to remove.
/// </summary>
/// <param name="guild"></param>
/// <param name="creature"></param>
/// <returns></returns>
public static MabiPacket GuildMembershipChanged(MabiGuild guild, MabiCreature creature, GuildMemberRank rank = GuildMemberRank.Member)
{
var p = new MabiPacket(Op.GuildMembershipChanged, creature.Id);
if (guild == null)
{
p.PutInt(0);
}
else
{
p.PutInt(1);
p.PutString(guild.Name);
p.PutLong(guild.Id);
p.PutInt((uint)rank); // (5) Member Rank?
p.PutByte(0);
}
return p;
}
public static bool HasSecedePermission(this GuildMemberRank operatorRank, GuildMemberRank fromRank, GuildMemberRank toRank)
{
if (toRank == GuildMemberRank.Unknown)
{
if (operatorRank == GuildMemberRank.Master)
{
if (fromRank == GuildMemberRank.Operator || fromRank == GuildMemberRank.Member)
{
return(true);
}
}
else if (operatorRank == GuildMemberRank.Operator && fromRank == GuildMemberRank.Member)
{
return(true);
}
}
return(false);
}
public int GetRankHue(GuildMemberRank rank)
{
int rankHue = 0;
switch (rank)
{
case GuildMemberRank.Recruit: rankHue = 2655; break;
case GuildMemberRank.Initiate: rankHue = 2599; break;
case GuildMemberRank.Veteran: rankHue = 169; break;
case GuildMemberRank.Officer: rankHue = 2603; break;
case GuildMemberRank.Guildmaster: rankHue = 1259; break;
}
return(rankHue);
}
public static HeroesGuildUserType ToGroupUserType(this GuildMemberRank value)
{
switch (value)
{
case GuildMemberRank.Master:
return(HeroesGuildUserType.master);
case GuildMemberRank.Operator:
return(HeroesGuildUserType.sysop);
case GuildMemberRank.Member:
return(HeroesGuildUserType.member_lv1);
case GuildMemberRank.Wait:
return(HeroesGuildUserType.memberWaiting);
default:
return(HeroesGuildUserType.unknown);
}
}
private void AddNewRank(Guild guild, GuildMemberRank rank)
{
if (guild == null)
{
return;
}
if (rank.RankName == "Guildmaster")
{
rank.RankPrivileges = 7;
}
guild.GuildRanks.Add(rank);
AddHistoryEvent(guild, new HistoryEvent {
Args = GuildHistoryStrings.AddNewRank(rank.RankName)
});
UpdateGuild(guild);
}
public bool AcceptJoin(GuildEntity guild, GuildMemberRank operatorRank, GuildMember targetMember, bool accept)
{
int num = -1;
try
{
if (operatorRank.HasAcceptJoinPermission(targetMember.Rank))
{
HeroesGuildDBDataContext heroesGuildDBDataContext = new HeroesGuildDBDataContext();
if (accept)
{
num = heroesGuildDBDataContext.GuildUserJoinApply(new int?(GuildAPI.ServerCode), new int?(guild.GuildSN), new int?(targetMember.Key.NexonSN), new long?((long)targetMember.Key.CharacterSN), targetMember.Key.CharacterName);
}
else
{
num = heroesGuildDBDataContext.GuildUserJoinReject(new int?(GuildAPI.ServerCode), new int?(guild.GuildSN), new int?(targetMember.Key.NexonSN), new long?((long)targetMember.Key.CharacterSN), targetMember.Key.CharacterName);
}
}
}
catch (Exception ex)
{
Log <HeroesGuildAPI> .Logger.Error("Error in AcceptJoin(GuildEntity guild, GuildMemberRank operatorRank, GuildMember targetMember, bool accept)", ex);
}
GuildLedgerEventType eventType;
if (num == 0)
{
eventType = GuildLedgerEventType.Success;
}
else
{
eventType = GuildLedgerEventType.DatabaseFail;
}
GuildLog.AddGuildLedger(new LogData((long)guild.GuildSN, targetMember.Key.CID, OperationType.HeroesCore_ResponseJoin, eventType, string.Format("GuildSn: {0}, isAccept: {1}", guild.GuildSN, accept.ToString()), targetMember.Key.ToString()));
return(num == 0);
}
public void ChangeRankPrivileges(Player initiator, int rankId, int newPrivileges, string newName)
{
if (initiator.Guild == null)
{
return;
}
if (!GetLeader(initiator.Guild).Equals(initiator))
{
return;
}
GuildMemberRank r = initiator.Guild.GuildRanks.FirstOrDefault(rank => rank.RankId == rankId);
if (r == null)
{
return;
}
r.RankPrivileges = newPrivileges;
r.RankName = newName;
UpdateGuild(initiator.Guild);
}
public bool ChangeRank(GuildEntity guild, GuildMemberRank operatorRank, GuildMember targetMember, GuildMemberRank toRank)
{
int num = -1;
HeroesGuildDBDataContext heroesGuildDBDataContext = new HeroesGuildDBDataContext();
if (toRank == GuildMemberRank.Unknown)
{
if (operatorRank.HasSecedePermission(targetMember.Rank, toRank))
{
try
{
num = heroesGuildDBDataContext.GuildUserSecede(new int?(GuildAPI.ServerCode), new int?(guild.GuildSN), new int?(targetMember.Key.NexonSN), new long?((long)targetMember.Key.CharacterSN), targetMember.Key.CharacterName);
}
catch
{
Log <GuildAPI> .Logger.ErrorFormat("GuildUserSecede fail in ChangeRank : ServiceCode[{0}], GuildSN[{1}], MemberNexonSN[{2}]", GuildAPI.ServerCode, guild.GuildSN, targetMember.Key.NexonSN);
}
if (num == 0)
{
GuildLog.AddGuildLedger(new LogData((long)guild.GuildSN, targetMember.Key.CID, OperationType.GainGuildPoint, GuildLedgerEventType.UpdateGuildUserPoint, "0", "Secede"));
int num2 = -1;
try
{
using (HeroesDataContext heroesDataContext = new HeroesDataContext())
{
num2 = heroesDataContext.UpdateGuildCharacterInfo(new long?(targetMember.Key.CID), new long?(0L));
}
}
catch
{
Log <GuildAPI> .Logger.ErrorFormat("UpdateGuildCharacterInfo fail in ChangeRank : ServiceCode[{0}], GuildSN[{1}], MemberNexonSN[{2}], toRank[{3}]", new object[]
{
GuildAPI.ServerCode,
guild.GuildSN,
targetMember.Key.NexonSN,
toRank
});
}
if (num2 == 0)
{
GuildLog.AddGuildLedger(new LogData((long)guild.GuildSN, targetMember.Key.CID, OperationType.HeroesCore_LeaveGuild, GuildLedgerEventType.Success, string.Format("GuildSn: {0}, GuildToString: {1}", guild.GuildSN, guild.ToString(), targetMember.Key.ToString())));
}
}
else
{
GuildLog.AddGuildLedger(new LogData((long)guild.GuildSN, targetMember.Key.CID, OperationType.HeroesCore_LeaveGuild, GuildLedgerEventType.DatabaseFail, string.Format("GuildSn: {0}, GuildToString: {1}", guild.GuildSN, guild.ToString(), targetMember.Key.ToString())));
}
}
}
else if (operatorRank.HasRankChangePermission(targetMember.Rank, toRank))
{
Log <GuildAPI> .Logger.InfoFormat("UserTypeModify: ServiceCode[{0}], GuildSN[{1}], MemberNexonSN[{2}]", GuildAPI.ServerCode, guild.GuildSN, targetMember.Key.NexonSN);
try
{
num = heroesGuildDBDataContext.GuildUserTypeModify(new int?(GuildAPI.ServerCode), new int?(guild.GuildSN), new int?(targetMember.Key.NexonSN), new int?(targetMember.Key.CharacterSN), targetMember.Key.CharacterName, new int?((int)toRank.ToGroupUserType()));
}
catch (Exception ex)
{
Log <HeroesGuildAPI> .Logger.Error("Error in ChangeRank(GuildEntity guild, GuildMemberRank operatorRank, GuildMember targetMember, GuildMemberRank toRank)", ex);
}
if (num == 0)
{
GuildLog.AddGuildLedger(new LogData((long)guild.GuildSN, targetMember.Key.CID, OperationType.HeroesCore_ChangeRank, GuildLedgerEventType.Success, string.Format("GuildSn: {0}, GuildToString: {1}", guild.GuildSN, guild.ToString(), targetMember.Key.ToString())));
}
else
{
GuildLog.AddGuildLedger(new LogData((long)guild.GuildSN, targetMember.Key.CID, OperationType.HeroesCore_ChangeRank, GuildLedgerEventType.DatabaseFail, string.Format("GuildSn: {0}, GuildToString: {1}", guild.GuildSN, guild.ToString(), targetMember.Key.ToString())));
}
}
return(num == 0);
}
public static bool HasNewbieRecommendPermission(this GuildMemberRank operatorRank)
{
return(operatorRank == GuildMemberRank.Master || operatorRank == GuildMemberRank.Operator);
}
public static bool HasAcceptJoinPermission(this GuildMemberRank operatorRank, GuildMemberRank targetRank)
{
return((operatorRank == GuildMemberRank.Master || operatorRank == GuildMemberRank.Operator) && targetRank == GuildMemberRank.Wait);
}
public override IEnumerable <object> Run()
{
GuildMember operatorMember = base.Entity.GetGuildMember(base.Operation.GuildMemberKey.CharacterName);
if (operatorMember == null)
{
Log <DoGuildOperationProcessor> .Logger.ErrorFormat("DoOperationFailed : invalid operatorMember [{0}]", base.Operation.GuildMemberKey.CharacterName);
base.Finished = true;
yield return(new FailMessage("[DoGuildOperationProcessor] operatorMember"));
}
GuildMemberRank operatorRank = operatorMember.Rank;
bool funcResult = false;
List <GuildOperationResult> opResultList = new List <GuildOperationResult>();
if (FeatureMatrix.IsEnable("GuildProcessorNotUseAsync"))
{
try
{
opResultList = base.Entity.DoGuildOperation(base.Operation.Operations, operatorRank);
}
catch (Exception ex)
{
Log <DoGuildOperationProcessor> .Logger.Error(string.Format("Exception on DoGuildOperation. [ Entity : {0}, OperationCount : {1}, FirstOperation : {2} ]", base.Entity.ToString(), base.Operation.Operations.Count, base.Operation.Operations[0].ToString()), ex);
}
funcResult = true;
}
else
{
AsyncFuncSync <List <GuildOperationResult> > sync = new AsyncFuncSync <List <GuildOperationResult> >(delegate
{
try
{
return(this.Entity.DoGuildOperation(this.Operation.Operations, operatorRank));
}
catch (Exception ex2)
{
Log <DoGuildOperationProcessor> .Logger.Error(string.Format("Exception on DoGuildOperation. [ Entity : {0}, OperationCount : {1}, FirstOperation : {2} ]", this.Entity.ToString(), this.Operation.Operations.Count, this.Operation.Operations[0].ToString()), ex2);
}
return(new List <GuildOperationResult>
{
new GuildOperationResult(false, null, null)
});
});
yield return(sync);
funcResult = sync.Result;
opResultList = sync.FuncResult;
}
bool operationResult = true;
if (funcResult)
{
List <GuildOperationInfo> successInfo = new List <GuildOperationInfo>();
foreach (GuildOperationResult guildOperationResult in base.Entity.SyncOperationResult(opResultList))
{
if (guildOperationResult != null)
{
using (List <GuildOperationInfo> .Enumerator enumerator2 = base.Operation.Operations.GetEnumerator())
{
while (enumerator2.MoveNext())
{
GuildOperationInfo guildOperationInfo = enumerator2.Current;
if (guildOperationInfo.Target.Equals(guildOperationResult.Key.CharacterName))
{
successInfo.Add(guildOperationInfo);
break;
}
}
continue;
}
}
operationResult = false;
}
if (FeatureMatrix.IsEnable("RankTitle"))
{
base.Entity.RequestUpdateBriefGuildInfo(successInfo);
}
if (FeatureMatrix.IsEnable("GuildLevel"))
{
base.Entity.GiveGuildLevelUpRewardAP(successInfo);
}
base.Finished = true;
if (operationResult)
{
yield return(new OkMessage());
}
else
{
yield return(new FailMessage("[DoGuildOperationProcessor] operationResult"));
}
}
else
{
base.Finished = true;
yield return(new FailMessage("[DoGuildOperationProcessor] funcResult"));
}
yield break;
}
public MabiGuildMember(ulong characterId, ulong guildId, GuildMemberRank rank)
: this()
{
this.CharacterId = characterId;
this.GuildId = guildId;
this.MemberRank = rank;
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
//Version 0
if (version >= 0)
{
m_Guildmaster = (PlayerMobile)reader.ReadMobile();
m_Abbreviation = reader.ReadString();
m_CreationTime = reader.ReadDateTime();
m_Icon = reader.ReadInt();
m_IconHue = reader.ReadInt();
m_Website = reader.ReadString();
m_Guildhouse = reader.ReadItem() as BaseHouse;
m_Faction = reader.ReadItem() as Faction;
//Rank Names
int rankNamesCount = reader.ReadInt();
for (int a = 0; a < rankNamesCount; a++)
{
m_RankNames[a] = reader.ReadString();
}
//Members
int membersCount = reader.ReadInt();
for (int a = 0; a < membersCount; a++)
{
PlayerMobile player = reader.ReadMobile() as PlayerMobile;
GuildMemberRank rank = (GuildMemberRank)reader.ReadInt();
DateTime joinDate = reader.ReadDateTime();
PlayerMobile fealtyPlayer = reader.ReadMobile() as PlayerMobile;
if (player != null)
{
if (!player.Deleted)
{
GuildMemberEntry guildMemberEntry = new GuildMemberEntry(player, rank, joinDate, fealtyPlayer);
m_Members.Add(guildMemberEntry);
}
}
}
//Lists
int alliesCount = reader.ReadInt();
for (int a = 0; a < alliesCount; a++)
{
Guild entry = reader.ReadItem() as Guild;
if (entry != null)
{
if (!entry.Deleted)
{
m_Allies.Add(entry);
}
}
}
int alliesRequestsSentCount = reader.ReadInt();
for (int a = 0; a < alliesRequestsSentCount; a++)
{
Guild entry = reader.ReadItem() as Guild;
if (entry != null)
{
if (!entry.Deleted)
{
m_AlliesRequestsSent.Add(entry);
}
}
}
int alliesRequestsReceivedCount = reader.ReadInt();
for (int a = 0; a < alliesRequestsReceivedCount; a++)
{
Guild entry = reader.ReadItem() as Guild;
if (entry != null)
{
if (!entry.Deleted)
{
m_AlliesRequestsReceived.Add(entry);
}
}
}
int enemiesCount = reader.ReadInt();
for (int a = 0; a < enemiesCount; a++)
{
Guild entry = reader.ReadItem() as Guild;
if (entry != null)
{
if (!entry.Deleted)
{
m_Enemies.Add(entry);
}
}
}
int enemiesRequestsSentCount = reader.ReadInt();
for (int a = 0; a < enemiesRequestsSentCount; a++)
{
Guild entry = reader.ReadItem() as Guild;
if (entry != null)
{
if (!entry.Deleted)
{
m_EnemiesRequestsSent.Add(entry);
}
}
}
int enemiesRequestsReceivedCount = reader.ReadInt();
for (int a = 0; a < enemiesRequestsReceivedCount; a++)
{
Guild entry = reader.ReadItem() as Guild;
if (entry != null)
{
if (!entry.Deleted)
{
m_EnemiesRequestsReceived.Add(entry);
}
}
}
int candidatesCount = reader.ReadInt();
for (int a = 0; a < candidatesCount; a++)
{
PlayerMobile candidate = reader.ReadMobile() as PlayerMobile;
if (candidate != null)
{
if (!candidate.Deleted)
{
m_Candidates.Add(candidate);
}
}
}
}
//-----
Guilds.m_Guilds.Add(this);
ReapplyMemberships();
AuditGuild();
}
public static bool IsMaster(this GuildMemberRank rank)
{
return(rank == GuildMemberRank.Master);
}
public static bool IsInvalid(this GuildMemberRank rank)
{
return(rank == GuildMemberRank.Ignorable || rank == GuildMemberRank.Unknown);
}
public static bool IsMember(this GuildMemberRank rank)
{
return(rank == GuildMemberRank.Master || rank == GuildMemberRank.Operator || rank == GuildMemberRank.Member || rank == GuildMemberRank.Wait);
}
public void GuildAnnouncement(string message, List <PlayerMobile> ignoredPlayers, GuildMemberRank minimumGuildRank)
{
List <GuildMemberEntry> memberEntries = GetGuildMemberEntries();
foreach (GuildMemberEntry entry in memberEntries)
{
if (entry == null)
{
continue;
}
if (entry.m_Player == null)
{
continue;
}
if (ignoredPlayers.Contains(entry.m_Player))
{
continue;
}
if (((int)entry.m_Rank < (int)minimumGuildRank))
{
continue;
}
entry.m_Player.SendMessage(Guilds.GuildTextHue, message);
}
}
