private void AddRacket(GameObject obj)
 {
     // remove the previous racket from this.allObjects and this.staticObjects
     RemoveRacket();
     this.playerRacket = obj as Racket;
     this.AddStaticObject(obj);
 }

 private void AddRacket(GameObject obj)
 {
     //TODO: we should remove the previous racket from this.allObjects
     //the solution is above, in AddObject()
     this.playerRacket = obj as Racket;
     this.AddStaticObject(obj);
 }

 /* Search for a "TODO" in the Engine class, regarding the AddRacket method. Solve the problem mentioned there.
  * There should always be only one Racket. Note: comment in TODO not completely correct*/
 private void AddRacket(GameObject obj)
 {
     //TODO: we should remove the previous racket from this.allObjects
     RemovePreviousRacket();
     this.playerRacket = obj as Racket;
     this.AddStaticObject(obj);
 }

 private void AddRacket(GameObject obj)
 {
     //all previous Rackets removed
     this.allObjects.RemoveAll(x => x is Racket);
     this.staticObjects.RemoveAll(x => x is Racket);
     this.playerRacket = obj as Racket;
     this.AddStaticObject(obj);
 }

 private void AddRacket(GameObject obj)
 {
     //TODO: we should remove the previous racket from this.allObjects
     this.playerRacket = obj as Racket;
     this.allObjects.RemoveAll(ob => ob is Racket);
     this.staticObjects.RemoveAll(ob => ob is Racket);
     this.AddStaticObject(obj);
 }

 public override void AddObject(GameObject obj)
 {
     var as_racket = obj as ShootingRacket;
     if (as_racket != null) {
         racket = as_racket;
     }
     base.AddObject(obj);
 }

 public void AddTrailingObject(GameObject obj)
 {
     if (obj is TrailObject)
     {
         allObjects.Add(obj as TrailObject);
         staticObjects.Add(obj as TrailObject);
     }
 }

 //overriding of this method is important for task 13 in order to get access to the fields of the current racket
 public override void AddObject(GameObject obj)
 {
     if (obj is ShootingRacket)
     {
         ShootingRacket newRacket = obj as ShootingRacket;
         this.playerRacket = newRacket;
     }
     base.AddObject(obj);
 }

        private void AddRacket(GameObject obj)
        {
            //TODO: we should remove the previous racket from this.allObjects
            // 3. Removing the rackets from allObjects and staticObjects

            this.playerRacket = obj as Racket;
            this.allObjects.RemoveAll(item => item is Racket); // this line should be as comment if we use multiple rackets
            this.staticObjects.RemoveAll(item => item is Racket);
            this.AddStaticObject(obj);
        }

        private void AddRacket(GameObject obj)
        {
            //TODO: we should remove the previous racket from this.allObjects
            //Task 3: Implementing Removing of all elements of Type Racket from allObjects
            var toRemove = this.allObjects.OfType<Racket>().ToList();
            foreach (var item in toRemove)
                this.allObjects.Remove(item);

            this.playerRacket = obj as Racket;
            this.AddStaticObject(obj);
        }

        private void AddRacket(GameObject obj)
        {
            //TODO: we should remove the previous racket from this.allObjects

            // 03. Removing the old Racket using Lambda
            // We can also search the whole list of objects and remove the object that is Racket
            this.allObjects.RemoveAll(item => item is Racket);
            this.staticObjects.RemoveAll(item => item is Racket);

            this.playerRacket = obj as Racket;
            this.AddStaticObject(obj);
        }

 private void AddRacket(GameObject obj)
 {
     for(int i = 0; i < allObjects.Count; i++) {
       if(allObjects[i] is Racket) {
         allObjects.RemoveAt(i);
         break;
       }
     }
     //TODO: we should remove the previous racket from this.allObjects
     this.playerRacket = obj as Racket;
     this.AddStaticObject(obj);
 }

 // Add some object in depending his type
 public virtual void AddObject(GameObject obj)
 {
     if (obj is MovingObject)
     {
         this.AddMovingObject(obj as MovingObject);
     }
     else
     {
         if (obj is Racket) AddRacket(obj);
         else this.AddStaticObject(obj);
     }
 }

        private void AddRacket(GameObject obj)
        {
            //TODO: we should remove the previous racket from this.allObjects
           /* 03. Search for a "TODO" in the Engine class, regarding the AddRacket method. 
            * Solve the problem mentioned there. There should always be only one Racket. 
            * Note: comment in TODO not completely correct
            */

            this.playerRacket = obj as Racket;
            this.allObjects.RemoveAll(x => x is Racket); // should be always one racket
            this.AddStaticObject(obj);
        }

 // Task 3 - I have decided that, since it was mentioned that the comment in the code was not completely correct and
 // that the only condition is to have one racket, to keep the original racket. The method checks whether we have
 // a Racket object in the list of all objects and then, if not, to add the racket.5
 protected virtual void AddRacket(GameObject obj)
 {
     bool check=true;
     foreach (var c in this.allObjects)
     {
         if (c is Racket)
             check = false;
     }
     if (check)
     {
         this.playerRacket = obj as Racket;
         this.AddStaticObject(obj);
     }
 }

 private void AddRacket(GameObject obj)
 {
     //3.Search for TODO and remove racket. There should always be only one racket.
     //TODO: we should remove the previous racket from this.allObjects
     this.playerRacket = obj as Racket;
     for (int i = 0; i < allObjects.Count; i++)
     {
         if (allObjects[i] is Racket)
         {
             allObjects.RemoveAt(i);
             break;
         }
     }
     this.AddStaticObject(obj);
     
 }

 public virtual void AddObject(GameObject obj)
 {
     if (obj is MovingObject)
     {
         this.AddMovingObject(obj as MovingObject);
     }
     else
     {
         if (obj is Racket)
         {
             // TASK 3
             this.allObjects.RemoveAll(gameObject => gameObject is Racket);
             AddRacket(obj);
         }
         else
         {
             this.AddStaticObject(obj);
         }
     }
 }

 public virtual void AddObject(GameObject obj)
 {
     if (obj is MovingObject)
     {
         this.AddMovingObject(obj as MovingObject);
     }
     else
     {
         if (obj is Racket)
         {
             //03.Search for a "TODO" in the Engine class, regarding the AddRacket method. Solve the problem mentioned there. 
             //There should always be only one Racket. Note: comment in TODO not completely correct
             this.allObjects.RemoveAll(allObj => allObj is Racket);
             //END 03
             AddRacket(obj);
         }
         else
         {
             this.AddStaticObject(obj);
         }
     }
 }

 protected override void AddRacket(GameObject obj)
 {
     bool check = true, secondCheck=true;
     ShootingRacket l;
     foreach (var c in this.allObjects)
     {
         if ((c is Racket) && !(c is ShootingRacket))
             check = false;
         else if (c is ShootingRacket)
             secondCheck = false;
     }
     if (check)
     {
         this.playerRacket = obj as Racket;
         this.AddStaticObject(obj);
     }
     else if (!secondCheck)
     {
         this.playerRacket = obj as ShootingRacket;
         this.AddStaticObject(obj);
     }
 }

        private void AddRacket(GameObject obj)
        {
            //03. Search for a "TODO" in the Engine class, regarding the AddRacket method. Solve the problem mentioned
            //    there. There should always be only one Racket. Note: comment in TODO not completely correct
            // TODO: we should remove the previous racket from this.allObjects
            //================================================================================================== Task 03>
            // obj is added to staticObjects AND allObjects (AddStaticObject(obj)), which means it should be removed from both
            this.allObjects.RemoveAll(x => x is Racket);
            this.staticObjects.RemoveAll(x => x is Racket);
            //================================================================================================== >Task 03

            this.playerRacket = obj as Racket;
            this.AddStaticObject(obj);
        }