public List<IBlob> Attack(List<IBlob> blobs, string attacker, string defender)
        {
            int attackerIndex = 0;
            int defenderIndex = 0;
            for (int i = 0; i < blobs.Count; i++)
            {
                if (blobs[i].Name == attacker)
                {
                    attackerIndex = i;
                }
                if (blobs[i].Name == defender)
                {
                    defenderIndex = i;
                }
            }

            if (blobs[attackerIndex].Attack == "PutridFart")
            {
                blobs[defenderIndex] = attaks.PutridFart(blobs[attackerIndex], blobs[defenderIndex]);
            }
            else if (blobs[attackerIndex].Attack == "Blobplode")
            {
                IBlob[] blobArray = new IBlob[2];
                blobArray = attaks.Blobplode(blobs[attackerIndex], blobs[defenderIndex]);
                blobs[attackerIndex] = blobArray[0];
                blobs[defenderIndex] = blobArray[1];
            }

            return blobs;
        }

 public override void ToggledEffect(IBlob blob)
 {
     if (this.HasTriggered)
     {
         blob.Health -= 10;
     }
 }

 public void Behave(IBlob blob)
 {
     if (blob.Damage - 5 >= this.initialDamage)
     {
         blob.Damage -= 5;
     }
 }

        internal Blob(IBlob blob)
        {
            if(blob.Id != Guid.Empty)
                Id = blob.Id;

            OwnerUserId = blob.OwnerUserId;
        }

 protected void FireEvent(IBlob parent)
 {
     if (this.HasTriggered != null)
     {
         this.HasTriggered(parent);
     }
 }

 public static void ValidateHelth(IBlob blob)
 {
     if (blob.Health < 0)
     {
         blob.Health = 0;
     }
 }

 /// <summary>
 /// Testing constructor Only
 /// </summary>
 /// <param name="parent"></param>
 /// <param name="inPipe"></param>
 /// <param name="dataObj"></param>
 /// <param name="isValid"></param>
 public DummyOutputNeutralPort(IElement parent, INeutralPipe inPipe, IBlob dataObj, bool isValid)
 {
     _parent = parent;
     _inPipe = inPipe;
     _dataObj = dataObj;
     _IsValid = isValid;
 }

 public override void ApplyBehaviorTurn(IBlob blob)
 {
     if (blob.InitialDamage <= blob.Damage - DefaultAggressiveBehaviorDamageTurnSubtraction)
     {
         blob.Damage -= DefaultAggressiveBehaviorDamageTurnSubtraction;
     }
 }

		public Blob(IBlob blob)
			: this(blob.Md5, Guid.NewGuid().ToString())
		{
			Metdata = new List<KeyValuePair<string, string>>(blob.Metdata);
			Content = blob.Content;
			ContentType = blob.ContentType;
		}

 protected override void ApplyHealthEffect(IBlob blob)
 {
     if (blob.Health/2 >= 1)
     {
         blob.Health /= 2;
     }
     else blob.Health = 1;
 }

        public async Task InsertAsync(IBlob t)
        {
            var blobReference = _container.GetBlockBlobReference(t.Id);
            if(await blobReference.ExistsAsync())
                throw new InvalidOperationException("Key already exists: " + t.Id);

            await UpsertAsync(t);
        }

 public void AddBlob(IBlob blob)
 {
     if (blob==null)
     {
         throw new NullReferenceException(Messeges.NullBlobReference);
     }
     this.blobs.Add(blob);
 }

 public override void Trigger(IBlob blob)
 {
     if (!this.HasTriggered)
     {
         this.HasTriggered = true;
         blob.Damage *= 2;
     }
 }

 public Engine(IBlob blob, Data data, IInputReader reader, IBlobFactory blobFactory, IOutputWriter writer)
 {
     this.blob = blob;
     this.data = data;
     this.reader = reader;
     this.blobFactory = blobFactory;
     this.writer = writer;
 }

 /// <summary>
 /// Adding a Blob to the data.
 /// </summary>
 /// <param name="blob"></param>
 public void AddBlob(IBlob blob)
 {
     if (blob == null)
     {
         throw new ArgumentException("Blob cannot be created without the foll");
     }
     this.blops.Add(blob);
 }

 public override void Trigger(IBlob blob)
 {
     if (!this.HasTriggered)
     {
         this.HasTriggered = true;
         blob.Health += 50;
     }
 }

 public void AddAggresiveBlobs(IBlob aggressiveBlob)
 {
     if (aggressiveBlob == null)
     {
         throw new ArgumentNullException(nameof(aggressiveBlob));
     }
     this.aggresiveBlobs.Add(aggressiveBlob);
 }

 public void AddInflatedBlobs(IBlob inflatedBlob)
 {
     if (inflatedBlob == null)
     {
         throw new ArgumentNullException(nameof(inflatedBlob));
     }
     this.inflatedBlobs.Add(inflatedBlob);
 }

 /// <summary>
 /// Initializes the base for the merged blob.
 /// </summary>
 /// <param name="baseBlob">The blob object to inherit properties from.</param>
 public MergedBlob(IBlob baseBlob)
 {
     Dimension = baseBlob.Dimension;
     Position = baseBlob.Position;
     Size = baseBlob.Size;
     Center = baseBlob.Center;
     Color = baseBlob.Color;
 }

 public void AddBlobs(IBlob blob)
 {
     if (blob == null)
     {
         throw new ArgumentException(nameof(blob));
     }
     this.blobs.Add(blob);
 }