case (ushort)Database.SpellTable.SpellId.WrathoftheEmperor:
                        {
                            FloorItem item = new FloorItem(true)
                            {
                                ItemID = 1380,
                                UID = FloorItem.FloorUID.Next,
                                MapID = Attacker.MapID,
                                mColor = 14,
                                ItemColor = Enums.Color.Black,
                                Type = FloorItem.Effect,
                                Owner = Attacker.Owner,
                                OwnerUID = Attacker.UID,
                                FlowerType = 1,
                                OnFloor = Time32.Now
                            };

                            var suse = new SpellUse()
                            {
                                Attacker = Attacker.UID,
                                Attacked = Attacker.UID,
                                SpellID = spell.Id,
                                SpellLevel = spell.Level,
                            };
                            bool CanAttack = false;
                            IMapObject obj;
                            if (Attacker.Owner.Screen.TryGetValue(info.TargetUid, out obj, MapObjectType.Player, MapObjectType.Monster))
                            {
                                if (Kernel.GetDistance(Attacker.X, Attacker.Y, obj.X, obj.Y) <= 2)
                                {
                                    if (CanAttackEntity.Verified(Attacker, (obj as Entity), spell))
                                    {
                                        item.X = obj.X;
                                        item.Y = obj.Y;

                                        uint damage = Calculating.Physical.Player(Attacker, (obj as Entity), spell, ref info.Attack);
                                        suse.Effect1 = info.Attack.Effect;
                                        ReceiveAttack.Player.Execute(Attacker, (obj as Entity), info.Attack, ref damage, spell);
                                        suse.AddTarget(obj.UID, damage, info.Attack);

                                        CanAttack = true;
                                    }
                                }
                            }
                            else if (Attacker.Owner.Screen.TryGetValue(info.TargetUid, out obj, MapObjectType.SobNpc))
                            {
                                if (Kernel.GetDistance(Attacker.X, Attacker.Y, obj.X, obj.Y) <= 2)
                                {
                                    if (CanAttackNpc.Verified(Attacker, (obj as SobNpcSpawn), spell))
                                    {
                                        item.X = obj.X;
                                        item.Y = obj.Y;

                                        uint damage = Physical.OnSob(Attacker, (obj as SobNpcSpawn), spell, ref info.Attack);
                                        suse.Effect1 = info.Attack.Effect;
                                        ReceiveAttack.Npc.Execute(Attacker, (obj as SobNpcSpawn), info.Attack, damage, spell);
                                        suse.AddTarget(obj.UID, damage, info.Attack);
                                        CanAttack = true;
                                    }
                                }
                            }
                            if (CanAttack)
                            {
                                Attacker.Owner.SendScreenSpawn(item, true);
                                suse = new SpellUse()
                                {
                                    Attacker = Attacker.UID,
                                    SpellID = spell.Id,
                                    SpellLevel = spell.Level,
                                    X = info.Attack.X,
                                    Y = info.Attack.Y,
                                    SpellEffect = 1
                                };
                                Program.World.DelayedTask.StartDelayedTask(() =>
                                {
                                    foreach (var target in Attacker.Owner.Screen.TryGetValues(MapObjectType.Player, MapObjectType.Monster))
                                    {
                                        var attacked = target as Entity;

                                        if (Kernel.GetDistance(item.X, item.Y, attacked.X, attacked.Y) <= spell.Range)
                                        {
                                            if (CanAttackEntity.Verified(Attacker, attacked, spell))
                                            {
                                                uint damage = Calculating.Physical.Player(Attacker, attacked, spell, ref info.Attack);
                                                suse.Effect1 = info.Attack.Effect;
                                                ReceiveAttack.Player.Execute(Attacker, attacked, info.Attack, ref damage, spell);
                                                suse.AddTarget(attacked.UID, damage, info.Attack);
                                            }
                                        }
                                    }

                                    foreach (var target in Attacker.Owner.Screen.TryGetValues(MapObjectType.SobNpc))
                                    {
                                        var attacked = target as SobNpcSpawn;

                                        if (Kernel.GetDistance(item.X, item.Y, attacked.X, attacked.Y) <= spell.Range)
                                        {
                                            if (CanAttackNpc.Verified(Attacker, attacked, spell))
                                            {
                                                uint damage = Physical.OnSob(Attacker, attacked, spell, ref info.Attack);
                                                suse.Effect1 = info.Attack.Effect;
                                                ReceiveAttack.Npc.Execute(Attacker, attacked, info.Attack, damage, spell);
                                                suse.AddTarget(attacked.UID, damage, info.Attack);
                                            }
                                        }
                                    }
                                    Attacker.Owner.SendScreen(suse);

                                    foreach (var user in Kernel.GamePool.Values.Where(u => u.Entity.MapID == item.MapID))
                                    {
                                        if (Kernel.GetDistance(user.Entity.X, user.Entity.Y, item.X, item.Y) <= 18)
                                        {
                                            item.Type = FloorItem.RemoveEffect;
                                            user.Screen.Remove(item);
                                            user.Send(item);
                                        }
                                    }
                                }, 1000);
                            }
                            break;
                        }