/// <summary>
 ///   Appends the comment.
 /// </summary>
 /// <param name = "entity">The entity.</param>
 /// <param name = "node">The node.</param>
 /// <param name = "comments">The comments.</param>
 protected static void AppendComment(BaseEntity entity, IEnumerable<Comment> comments)
 {
     foreach (Comment comment in comments) {
         String c = comment.CommentText.Trim ();
         if (CommentHelper.IsSummary (c)) {
             continue;
         }
         if (CommentHelper.IsAvailability (c)) {
             String str = c;
             foreach (String s in new[] {"<para>", "</para>", "&lt;para&gt;", "&lt;/para&gt;"}) {
                 str = str.Replace (s, String.Empty);
             }
             entity.MinAvailability = CommentHelper.ExtractAvailability (str.Trim ());
         } else if (CommentHelper.IsParameter (c) || CommentHelper.IsReturn (c) || CommentHelper.IsSignature (c)) {
             // Do nothing
         } else if (CommentHelper.IsParagraph (c)) {
             String str = c;
             foreach (String s in new[] {"<para>", "</para>", "&lt;para&gt;", "&lt;/para&gt;"}) {
                 str = str.Replace (s, String.Empty);
             }
             entity.Summary.Add (str.Trim ());
         } else if (CommentHelper.IsRemarks (c)) {
             String str = c;
             foreach (String s in new[] {"<remarks>", "</remarks>", "&lt;remarks&gt;", "&lt;/remarks&gt;"}) {
                 str = str.Replace (s, String.Empty);
             }
             entity.Summary.Add (str.Trim ());
         } else {
             entity.Summary.Add (c);
         }
     }
 }

        public static IEntity createShip(EntitiesManager manager)
        {
            IEntity ship = new BaseEntity(manager);
            Vector2 Pos = new Vector2();
            Pos.X = manager.game.GraphicsDevice.Adapter.CurrentDisplayMode.Height / 8;
            Pos.Y = manager.game.GraphicsDevice.Adapter.CurrentDisplayMode.Width / 8;

            // for controlling behaviour
            ship.addAttribute("position", Pos);
            ship.addAttribute("velocity", new Vector2());
            ship.addAttribute("weight", 0.0076f);
            ship.addAttribute("direction", 0.0f);
            ship.addAttribute("scale", 1f);

            //for drawing
            Texture2D texture = manager.game.Content.Load<Texture2D>("ship");
            ship.addAttribute("texture", texture);

            //behaviours
            ship.addBehaviour(GameLoopPhase.Update, new GameControllingBehavior());
            ship.addBehaviour(GameLoopPhase.Update, new TemporaryGravityBehaviour());
            ship.addBehaviour(GameLoopPhase.Draw, new DrawTexture2DBehaviour());

            return ship;
        }

 public static int getAmmo(BaseEntity pro)
 {
     var pro1 = pro as BaseProjectile;
     if (pro1 == null)
         return 0;
     return pro1.primaryMagazine.contents;
 }

 public override void CommitLinks(BaseEntity entity)
 {
     if (EnableCommitLinks)
         base.CommitLinks (entity);
     else
         Console.WriteLine ("Bypassed DataLinker.CommitLinks for unit testing purposes.");
 }

 public ItemRepairEvent(RepairBench repairBench, BaseEntity.RPCMessage msg)
 {
     _repairBench = repairBench;
     _player = Server.GetPlayer(msg.player);
     _item = new InvItem(repairBench.inventory.GetSlot(0));
     _msg = msg;
 }

        public static IEntity createGameExit(EntitiesManager manager)
        {
            IEntity exit = new BaseEntity(manager);
            exit.addBehaviour(GameLoopPhase.Update, new ExitGameBehaviour());

            return exit;
        }

 public ItemPickupEvent(CollectibleEntity ce, BaseEntity.RPCMessage msg, Item i)
 {
     _entity = ce;
     _msg = msg;
     _player = Server.GetPlayer(msg.player);
     _item = new InvItem(i);
 }

 public override void SaveLinkedEntities(BaseEntity entity)
 {
     if (EnableSaveLinkedEntities)
         base.SaveLinkedEntities (entity);
     else
         Console.WriteLine ("Bypassed DataLinker.SaveLinkedEntities for unit testing purposes.");
 }

        private void JumpToNextEnemy(BaseEntity enemy)
        {
            List<BaseEntity> enemies = OGE.CurrentWorld.GetCollisionEntitiesType(Collision.CollisionType.Enemy);
            List<BaseEntity> bosses = OGE.CurrentWorld.GetCollisionEntitiesType(Collision.CollisionType.Boss);
            enemies.AddRange(bosses);
            BaseEntity nextEnemy = null;

            foreach (BaseEntity temp in enemies)
            {
                float enemyAngle = OGE.GetAngle(Position, temp.Position);
                float diffAngle = Math.Abs(direction - enemyAngle) % 360;

                if (temp == enemy)
                {
                    continue;
                }

                if (nextEnemy == null)
                {
                    nextEnemy = temp;
                }
                else if (OGE.GetDistance(Position, temp.Position) < OGE.GetDistance(Position, nextEnemy.Position))
                {
                    nextEnemy = temp;
                }
            }

            if (nextEnemy != null)
            {
                direction = OGE.GetAngle(Position, nextEnemy.Position);
            }
        }

        public virtual void FindAndFixDifferences(BaseEntity previousEntity, BaseEntity updatedEntity, PropertyInfo property)
        {
            if (Settings.IsVerbose)
                Console.WriteLine ("      Finding and fixing all differences between previous and updated '" + updatedEntity.GetType().Name + "' entity on '" + property.Name + "' property.");

            var previousLinks = new BaseEntity[]{ };

            if (previousEntity != null)
                previousLinks = Linker.GetLinkedEntities (previousEntity, property);

            var updatedLinks = Linker.GetLinkedEntities (updatedEntity, property);

            var linksToAdd = IdentifyEntityLinksToAdd (previousLinks, updatedLinks);

            var linksToRemove = IdentifyEntityLinksToRemove (previousLinks, updatedLinks);

            if (Settings.IsVerbose) {
                Console.WriteLine ("      Links to add: " + linksToAdd.Length);
                Console.WriteLine ("      Links to remove: " + linksToRemove.Length);
            }

            if (linksToAdd.Length > 0)
                CommitNewReverseLinks (updatedEntity, property, linksToAdd);

            if (linksToRemove.Length > 0)
                RemoveOldReverseLinks (updatedEntity, property, linksToRemove);
        }

 public RocketShootEvent(BaseLauncher baseLauncher, BaseEntity.RPCMessage msg, BaseEntity baseEntity)
 {
     _entity = new Entity(baseEntity);
     _player = Server.GetPlayer(msg.player);
     _msg = msg;
     _launch = baseLauncher;
 }

 public void TestEntityToXml(BaseEntity e)
 {
     XmlDocument xml = e.ToXmlDocument();
     Assert.IsNotNull(xml);
     Assert.IsNotNullOrEmpty(xml.InnerXml);
     Trace.WriteLine(xml.InnerXml);
 }

 public static DataRow AddFeedback(BaseEntity feedback)
 {
     using (DbCommand cmd = DB.Gt.GetStoredProcCommand(ProcNames.AddFeedback))
       {
     DB.Gt.AddInParameter(cmd, "@Feedback", DbType.Xml, feedback.ToXmlString());
     return DB.Gt.ExecuteDataRow(cmd);
       }
 }

 public static DataRow AddImage(BaseEntity sellingImage)
 {
     using (DbCommand cmd = DB.Gt.GetStoredProcCommand(ProcNames.AddImage))
       {
     DB.Gt.AddInParameter(cmd, "@SellingImage", DbType.Xml, sellingImage.ToXmlString());
     return DB.Gt.ExecuteDataRow(cmd);
       }
 }

 public static ItemDefinition getAmmoType(BaseEntity pro)
 {
     var pro1 = pro as BaseProjectile;
     if (pro1 == null)
         return null;
     //ConsoleSystem.Broadcast("chat.add", new object[] { 0, pro1.primaryMagazine.ammoType.ToString() });
     return pro1.primaryMagazine.ammoType;
 }

 public static DataRow Add(BaseEntity news)
 {
     using (DbCommand cmd = DB.Gt.GetStoredProcCommand(AddProcName))
     {
         DB.Gt.AddInParameter(cmd, "@News", DbType.Xml, news.ToXmlString());
         return DB.Gt.ExecuteDataRow(cmd);
     }
 }

        public BaseEntity PrepareForStorage(BaseEntity entity)
        {
            var validatedEntity = entity.Clone ();

            // TODO: Add validation

            return validatedEntity;
        }

        public virtual void CommitLinks(BaseEntity entity)
        {
            if (Settings.IsVerbose)
                Console.WriteLine ("  Committing all links for '"  + entity.GetType().Name + "'.");

            var previousEntity = Reader.Read(entity.GetType(), entity.Id);

            FindAndFixDifferences (previousEntity, entity);
        }

        public override void DestroyBulletCollision(BaseEntity entity)
        {
            base.DestroyBulletCollision(entity);

            if (followingEnemy != null && followingEnemy is BaseEnemy)
            {
                (followingEnemy as BaseEnemy).IsFollowed = false;
            }
        }

 public static DataRow Add(BaseEntity wm)
 {
     using (DbCommand cmd = DB.Gt.GetStoredProcCommand(AddProcName))
     {
         DB.Gt.AddInParameter(cmd, "@wm", DbType.Xml, wm.ToXmlString());
         DataRow dr = DB.Gt.ExecuteDataRow(cmd);
         return dr;
     }
 }