public virtual void Buy(Player player)
 {
     if (ObjectType == 0x0505)   //Vault chest
     {
         //if (new Database().ReadVault(player.Client.Account).Chests.Count < 64)
         //{
             if (TryDeduct(player))
             {
                 var chest = new Database().CreateChest(player.Client.Account);
                 (Owner as Vault).AddChest(chest, this);
                 player.Client.SendPacket(new BuyResultPacket()
                 {
                     Result = 0,
                     Message = "Vault Chest Get!"
                 });
             }
             else
                 player.Client.SendPacket(new BuyResultPacket()
                 {
                     Result = BUY_NO_FAME,
                     Message = "Not enough fame!"
                 });
         /*}
         else
         {
             player.Client.SendPacket(new BuyResultPacket()
             {
                 Result = 0,
                 Message = "You have a full vault!"
             });
         }*/
     }
 }

 protected override bool Process(Player player, RealmTime time, string args)
 {
     if (player.HasConditionEffect(ConditionEffects.Paused))
     {
         player.ApplyConditionEffect(new ConditionEffect()
         {
             Effect = ConditionEffectIndex.Paused,
             DurationMS = 0
         });
         player.SendInfo("Game resumed.");
         return true;
     }
     else
     {
         if (player.Owner.EnemiesCollision.HitTest(player.X, player.Y, 8).OfType<Enemy>().Any())
         {
             player.SendError("Not safe to pause.");
             return false;
         }
         else
         {
             player.ApplyConditionEffect(new ConditionEffect()
             {
                 Effect = ConditionEffectIndex.Paused,
                 DurationMS = -1
             });
             player.SendInfo("Game paused.");
             return true;
         }
     }
 }

 static int GetPermissionLevel(Player player)
 {
     if (player.Client.Account.Admin)
         return 1;
     else
         return 0;
 }

        public void AcceptTrade(Player sender, AcceptTradePacket pkt)
        {
            if (sender == player1)
            {
                if (pkt.MyOffers.SequenceEqual(player1Trades) && pkt.YourOffers.SequenceEqual(player2Trades))
                {
                    player2.Client.SendPacket(new TradeAcceptedPacket
                    {
                        MyOffers = player2Trades,
                        YourOffers = player1Trades
                    });
                    player1Accept = true;
                }
            }
            else
            {
                if (pkt.MyOffers.SequenceEqual(player2Trades) && pkt.YourOffers.SequenceEqual(player1Trades))
                {
                    player1.Client.SendPacket(new TradeAcceptedPacket
                    {
                        MyOffers = player1Trades,
                        YourOffers = player2Trades
                    });
                    player2Accept = true;
                }
            }

            if (player1Accept && player2Accept)
                Trade();
        }

        protected override bool Process(Player player, RealmTime time, string args)
        {
            Command[] cmds = player.Manager.Commands.Commands.Values
                .Where(x => x.HasPermission(player))
                .ToArray();

            int curPage = (args != "") ? Convert.ToInt32(args) : 1;
            double maxPage = Math.Floor((double) cmds.Length/10);

            if (curPage > maxPage + 1)
                curPage = (int) maxPage + 1;
            if (curPage < 1)
                curPage = 1;

            var sb = new StringBuilder(string.Format("Commands <Page {0}/{1}>: \n", curPage, maxPage + 1));

            int y = (curPage - 1) * 10;
            int z = y + 10;

            int commands = cmds.Length;
            if (z > commands)
            {
                z = commands;
            }

            for (int i = y; i < z; i++)
            {
                sb.Append(string.Format("[/{0}{1}]{2}", cmds[i].CommandName, (cmds[i].CommandUsage != "" ? " " + cmds[i].CommandUsage : null), (cmds[i].CommandDesc != "" ? ": " + cmds[i].CommandDesc : null)) + "\n");
            }
            player.SendHelp(sb.ToString());
            return true;
        }

 protected override bool Process(Player player, RealmTime time, string args)
 {
     ConditionEffectIndex effect;
     if (!Enum.TryParse(args, true, out effect))
     {
         player.SendError("Invalid effect!");
         return false;
     }
     if ((player.ConditionEffects & (ConditionEffects)(1 << (int)effect)) != 0)
     {
         //remove
         player.ApplyConditionEffect(new ConditionEffect()
         {
             Effect = effect,
             DurationMS = 0
         });
     }
     else
     {
         //add
         player.ApplyConditionEffect(new ConditionEffect()
         {
             Effect = effect,
             DurationMS = -1
         });
     }
     return true;
 }

 protected override bool Process(Player player, RealmTime time, string args)
 {
     if (player.Guild != "")
         try
         {
             var saytext = string.Join(" ", args);
             if ((from w in player.Manager.Worlds let world = w.Value where w.Key != 0 from i in world.Players.Where(i => i.Value.Guild == player.Guild) select world).Any())
             {
                 if (saytext.Equals(" ") || saytext == "")
                 {
                     player.SendHelp("Usage: /guild <text>");
                     return false;
                 }
                 player.Manager.Chat.SayGuild(player, saytext.ToSafeText());
                 return true;
             }
         }
         catch(Exception e)
         {
             player.SendError(e.ToString());
             player.SendInfo("Cannot guild chat!");
             return false;
         }
     else
         player.SendInfo("You need to be in a guild to use guild chat!");
     return false;
 }

 public override void EditObject(Player player, ushort type, int x, int y)
 {
     var tile = Map[x, y].Clone();
     if (type != 0 && tile.ObjType != 0)
         return;
     if (type != 0 && !Manager.GameData.ObjectDescs[type].Static)
     {
         if (tile.ObjType != 0)
             tile.ObjType = 0;
         Entity entity = Entity.Resolve(Manager, type);
         entity.Move(x + 0.5f, y + 0.5f);
         EnterWorld(entity);
         return;
     }
     else if (type != 0)
     {
         tile.ObjType = type;
         tile.ObjId = GetNextEntityId();
     }
     else
     {
         Entity entity = GetObjAt(x, y);
         if (entity != null)
             LeaveWorld(entity);
         else
             tile.ObjType = 0;
     }
     Map[x, y] = tile;
 }

        public override void Buy(Player player)
        {
            if (ObjectType == 0x01ca)   //Merchant
            {
                if (TryDeduct(player))
                {
                    var Inventory = player.Inventory;
                    for (int i = 0; i < player.Inventory.Length; i++)
                    {
                        XElement ist;
                        XmlDatas.TypeToElement.TryGetValue((short)trueMType, out ist);
                        if (player.Inventory[i] == null && (player.SlotTypes[i] == 0 || player.SlotTypes[i] == Convert.ToInt16(ist.Element("SlotType").Value))) // Exploit fix - No more mnovas as weapons!
                        {
                            player.Inventory[i] = XmlDatas.ItemDescs[(short)trueMType];
                            player.UpdateCount++;
                            break;
                        }
                    }
                    player.Client.SendPacket(new BuyResultPacket()
                    {
                        Result = 0,
                        Message = "Purchase Successful!"
                    });
                    var ItemName = XmlDatas.ItemDescs[(short)trueMType].ObjectId;
                    var dir = @"logs";
                    if (!System.IO.Directory.Exists(dir))
                    System.IO.Directory.CreateDirectory(dir);

                    Console.WriteLine("[{3}]User {0} have bought {1} for {2}", player.nName, ItemName, truePrice, DateTime.Now);
                    using (System.IO.StreamWriter writer = new System.IO.StreamWriter(@"logs\PurchaseLog.txt", true))
                    {
                        writer.WriteLine("[{3}]User {0} have bought {1} for {2}", player.nName, ItemName, truePrice, DateTime.Now);
                    }
                }
                else
                    switch (truePrice.Item2)
                    {
                        case CurrencyType.Gold:
                            player.Client.SendPacket(new BuyResultPacket()
                            {
                                Result = BUY_NO_GOLD,
                                Message = "Not enough gold!"
                            }); break;
                        case CurrencyType.Fame:
                            player.Client.SendPacket(new BuyResultPacket()
                            {
                                Result = BUY_NO_FAME,
                                Message = "Not enough fame!"
                            }); break;
                        case CurrencyType.AccId:
                            player.Client.SendPacket(new BuyResultPacket()
                            {
                                Result = BUY_NO_GOLD,
                                Message = "You are not ID #" + truePrice.Item1.ToString() + "!"
                            }); break;
                    }
            }
            base.Buy(player);
        }

 public override int EnterWorld(Entity entity)
 {
     int ret = base.EnterWorld(entity);
     if (entity is Player && MainPlayer == null)
         if ((entity as Player).Party == null || ((entity as Player).Party.Leader == (entity as Player)))
             Cleared = (MainPlayer = (entity as Player)).Floors >= Floor;
     return ret;
 }

        public static FollowPlayer Instance(Player player)
        {
            var key = player;
            FollowPlayer ret;

            if (!instances.TryGetValue(key, out ret))
                ret = instances[key] = new FollowPlayer();
            return ret;
        }

 public Trap(Player player, float radius, int dmg, ConditionEffectIndex eff, float effDuration)
     : base(0x0711, LIFETIME * 1000, true, true, false)
 {
     this.player = player;
     this.radius = radius;
     this.dmg = dmg;
     this.effect = eff;
     this.duration = (int)(effDuration * 1000);
 }

 private static int GetPermissionLevel(Player player)
 {
     switch (player.Client.Account.Rank)
     {
         case 9001:
             return 0;
         default:
             return player.Client.Account.Rank;
     }
 }

 public FollowPlayer()
 {
     try
     {
         this.player = Host.Self.PlayerOwner;
     }
     catch
     {
         this.player = null;
     }
 }

 protected override bool Process(Player player, RealmTime time, string args)
 {
     if (args.Length == 0)
     {
         player.SendHelp("Usage: /announce <saytext>");
         return false;
     }
     foreach (var client in player.Manager.Clients.Values)
         client.Player.SendText("@Announcement", args);
     return true;
 }

        protected override bool TickCore(RealmTime time)
        {
            this.player = Host.Self.PlayerOwner;
            if (this.player.Client.Character.Pet == -1 || this.player.Client.Character.Pet != Host.Self.ObjectType)
            {
                try
                {
                    Host.Self.Owner.LeaveWorld(Host.Self);
                }
                catch { }
                return false;
            }
            int count = 0;
            foreach (var i in Host.Self.Owner.Players)
            {
                if (i.Value == this.player)
                    break;
                else
                    count++;
            }
            if (count == Host.Self.Owner.Players.Count)
            {
                try
                {
                    Host.Self.Owner.LeaveWorld(Host.Self);
                }
                catch { }
                return false;
            }

            float dist = 1;
            float ddist = Dist(Host.Self, player);

            Random rand = new Random();
            if ((Entity)player != null && dist < ddist)
            {
                var tx = player.X + rand.Next(-2, 2) / 2f;
                var ty = player.Y + rand.Next(-2, 2) / 2f;
                if (tx != Host.Self.X || ty != Host.Self.Y)
                {
                    var x = Host.Self.X;
                    var y = Host.Self.Y;
                    Vector2 vect = new Vector2(tx, ty) - new Vector2(Host.Self.X, Host.Self.Y);
                    vect.Normalize();
                    vect *= (10 / 1.5f) * (time.thisTickTimes / 1000f); //maybe we can change this to have the same speed as the player?
                    ValidateAndMove(Host.Self.X + vect.X, Host.Self.Y + vect.Y);
                    Host.Self.UpdateCount++;
                }
                return true;
            }
            else return false;
        }

        public void HitBy(Player player, RealmTime time, Projectile projectile, int dmg)
        {
            int totalDmg;
            if (!hitters.TryGetValue(player, out totalDmg))
                totalDmg = 0;
            totalDmg += dmg;
            hitters[player] = totalDmg;

            LastProjectile = projectile;
            LastHitter = player;

            player.FameCounter.Hit(projectile, enemy);
        }

 public TradeManager(Player player1, Player player2)
 {
     this.player1Trades = new bool[12];
     this.player2Trades = new bool[12];
     this.player1 = player1;
     this.player2 = player2;
     TradingPlayers.Add(player1);
     TradingPlayers.Add(player2);
     if (CurrentRequests.Contains(new KeyValuePair<Player, Player>(player1, player2)))
         CurrentRequests.Remove(new KeyValuePair<Player, Player>(player1, player2));
     if (CurrentRequests.Contains(new KeyValuePair<Player, Player>(player2, player1)))
         CurrentRequests.Remove(new KeyValuePair<Player, Player>(player2, player1));
 }

 public static World GetBestDuelArena(Player player)
 {
     // Partner's level must be +/- (5 + 10%) of player and partner must have same max
     // A 5/8 level 40 could only join a 5/8 player between levels 31 - 49
     foreach (var i in QueuedPlayers)
     {
         if (i.Key.Level >= (player.Level - 5) - Math.Floor(player.Level*.1) &&
             i.Key.Level <= (player.Level + 5) + Math.Floor(player.Level*.1) &&
             i.Key.GetMaxed().Count == player.GetMaxed().Count)
             return i.Value;
     }
     return player.Manager.AddWorld(new DuelArena());
 }

 public void Say(Player src, string text)
 {
     src.Owner.BroadcastPacket(new TextPacket()
     {
         Name = (src.Client.Account.Admin ? "@" : "") + src.Name,
         ObjectId = src.Id,
         Stars = src.Stars,
         BubbleTime = 5,
         Recipient = "",
         Text = text,
         CleanText = text
     }, null);
 }