public float PriceRate(PlayerObject player, bool baseRate = false)
        {
            if (Conq == null || baseRate) return Info.Rate / 100F;

            if (player.MyGuild != null && player.MyGuild.Guildindex == Conq.Owner)
                return Info.Rate / 100F;
            else
                return (((Info.Rate / 100F) * Conq.npcRate) + Info.Rate) / 100F;
        }

        public Reporting(PlayerObject player)
        {
            Player = player;

            string baseDir = Settings.ReportPath + player.Name;

            if (!Directory.Exists(baseDir))
                Directory.CreateDirectory(baseDir);

            _baseDir = baseDir;
        }

 public GuildObject(PlayerObject owner, string name)
 {
     Name = name;
     Rank Owner = new Rank() { Name = "Leader", Options = (RankOptions)255 , Index = 0};
     GuildMember Leader = new GuildMember() { name = owner.Info.Name, Player = owner, Id = owner.Info.Index, LastLogin = Envir.Now, Online = true};
     Owner.Members.Add(Leader);
     Ranks.Add(Owner);
     Membercount++;
     NeedSave = true;
     if (Level < Settings.Guild_ExperienceList.Count)
         MaxExperience = Settings.Guild_ExperienceList[Level];
     if (Level < Settings.Guild_MembercapList.Count)
         MemberCap = Settings.Guild_MembercapList[Level];
 }

 public virtual void Add(PlayerObject player)
 {
     if (Race == ObjectType.Player)
     {
         PlayerObject me = (PlayerObject)this;
         player.Enqueue(me.GetInfoEx(player));
     }
     else
         player.Enqueue(GetInfo());
 }

 public void MemberDeleted(string name, PlayerObject formermember, bool kickself)
 {
     PlayerObject player = null;
     for (int i = 0; i < Ranks.Count; i++)
         for (int j = 0; j < Ranks[i].Members.Count; j++)
         {
             if ((Ranks[i].Members[j].Player != null) && (Ranks[i].Members[j].Player != formermember))
             {
                 player = (PlayerObject)Ranks[i].Members[j].Player;
                 player.Enqueue(new ServerPackets.GuildMemberChange() { Name = name, Status = (byte)(kickself ? 4:3) });
                 player.GuildMembersChanged = true;
             }
         }
     if (formermember != null)
     {
         formermember.Info.GuildIndex = -1;
         formermember.MyGuild = null;
         formermember.MyGuildRank = null;
         formermember.ReceiveChat(kickself ? "You have left your guild." : "You have been removed from your guild.", ChatType.Guild);
         formermember.Enqueue(new ServerPackets.GuildStatus() { GuildName = "", GuildRankName = "", MyOptions = (RankOptions)0 });
         formermember.BroadcastInfo();
     }
 }

        public void Broadcast(Packet p, Point location, PlayerObject Player)
        {
            if (p == null) return;

            if (Functions.InRange(location, Player.CurrentLocation, Globals.DataRange))
            {
                Player.Enqueue(p);
            }
        }

        public override bool IsFriendlyTarget(PlayerObject ally)
        {
            if (Master == null) return false;
            if (Master == ally) return true;

            switch (ally.AMode)
            {
                case AttackMode.Group:
                    return Master.GroupMembers != null && Master.GroupMembers.Contains(ally);
                case AttackMode.Guild:
                    return false;
                case AttackMode.EnemyGuild:
                    return true;
                case AttackMode.RedBrown:
                    return Master.PKPoints < 200 & Envir.Time > Master.BrownTime;
            }
            return true;
        }

 public override void Add(PlayerObject player)
 {
     player.Enqueue(GetInfo());
     SendHealth(player);
 }

 public override bool IsAttackTarget(PlayerObject attacker)
 {
     throw new NotSupportedException();
 }

 public override void SendHealth(PlayerObject player)
 {
     throw new NotSupportedException();
 }

 public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true)
 {
     return 0;
 }

 public override bool IsFriendlyTarget(PlayerObject ally)
 {
     return true;
 }

 public MountInfo(PlayerObject ob)
 {
     Player = ob;
 }

        public void NewMember(PlayerObject newmember)
        {
            if (Ranks.Count < 2)
                Ranks.Add(new Rank() { Name = "Members", Index = 1});
            Rank currentrank = Ranks[Ranks.Count - 1];
            GuildMember Member = new GuildMember() { name = newmember.Info.Name, Player = newmember, Id = newmember.Info.Index, LastLogin = Envir.Now, Online = true };
            currentrank.Members.Add(Member);
            PlayerLogged(newmember, true, true);

            Membercount++;
            NeedSave = true;
        }

 public void SendGuildStatus(PlayerObject member)
 {
     member.Enqueue(new ServerPackets.GuildStatus()
         {
             GuildName = Name,
             GuildRankName = member.MyGuildRank != null? member.MyGuildRank.Name: "",
             Experience = Experience,
             MaxExperience = MaxExperience,
             MemberCount = Membercount,
             MaxMembers = MemberCap,
             Gold = Gold,
             Level = Level,
             Voting = Voting,
             SparePoints = SparePoints,
             ItemCount = (byte)StoredItems.Length,
             BuffCount = (byte)0,//(byte)BuffList.Count,
             MyOptions = member.MyGuildRank != null? member.MyGuildRank.Options: (RankOptions)0,
             MyRankId = member.MyGuildRank != null? member.MyGuildRank.Index: 256
         });
 }

 public void PlayerLogged(PlayerObject member, bool online, bool New = false)
 {
     for (int i = 0; i < Ranks.Count; i++)
         for (int j = 0; j < Ranks[i].Members.Count; j++)
         {
             if (Ranks[i].Members[j].Id == member.Info.Index)
             {
                 if (online)
                 {
                     Ranks[i].Members[j].Player = member;
                     Ranks[i].Members[j].Online = true;
                 }
                 else
                 {
                     Ranks[i].Members[j].LastLogin = Envir.Now;
                     Ranks[i].Members[j].Player = null;
                     Ranks[i].Members[j].Online = false;
                     NeedSave = true;
                 }
             }
         }
     SendServerPacket(new ServerPackets.GuildMemberChange() {Name = member.Name, Status = (byte)(New? 2: online? 1: 0)});
     if (online && !New)
         SendGuildStatus(member);
 }

 public bool NewRank(PlayerObject Self)
 {
     if (Ranks.Count >= byte.MaxValue)
     {
         Self.ReceiveChat("You cannot have anymore ranks.", ChatType.System);
         return false;
     }
     int NewIndex = Ranks.Count > 1? Ranks.Count -1: 1;
     Rank NewRank = new Rank(){Index = NewIndex, Name = String.Format("Rank-{0}",NewIndex), Options = (RankOptions)0};
     Ranks.Insert(NewIndex, NewRank);
     Ranks[Ranks.Count - 1].Index = Ranks.Count - 1;
     List<Rank> NewRankList = new List<Rank>();
     NewRankList.Add(NewRank);
     SendServerPacket(new ServerPackets.GuildMemberChange() { Name = Self.Name, Status = (byte)6, Ranks = NewRankList});
     NeedSave = true;
     return true;
 }

 public override bool IsAttackTarget(PlayerObject attacker)
 {
     return false;
 }

 public abstract int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true);

 public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true)
 {
     throw new NotSupportedException();
 }