private static bool Blastenheimer5000Used(GameObject go, Character user)
 {
     var cast = user.SpellCast;
     cast.Start(CannonPrepId);
     user.IncMechanicCount(SpellMechanic.Rooted);
     switch (go.EntryId)
     {
         case (uint)Blastenheimer5000ElwynnId:
             {
                 user.TeleportTo(ElwynnTelePosition, ElwynnTeleOrientation);
             } break;
         case (uint)Blastenheimer5000TerokkarId:
             {
                 user.TeleportTo(TerokkarTelePosition, TerokkarTeleOrientation);
             } break;
         case (uint)Blastenheimer5000MulgoreId:
             {
                 user.TeleportTo(MulgoreTelePosition, MulgoreTeleOrientation);
             } break;
         default:
             {
                 user.DecMechanicCount(SpellMechanic.Rooted);
                 return false;
             }
     }
     go.PlaySound(8476);
     
     user.CallDelayed(2000, obj => FireCannon(user));
     return true;
 }

		public override void Apply()
		{
			var goId = (GOEntryId)Effect.MiscValue;
			var goEntry = GOMgr.GetEntry(goId);
			var caster = m_cast.CasterUnit;
			if (goEntry != null)
			{
				GO = goEntry.Spawn(caster, caster);
				GO.State = GameObjectState.Enabled;
				GO.Orientation = caster.Orientation;
				GO.ScaleX = 1;
				GO.Faction = caster.Faction;
				GO.CreatedBy = caster.EntityId;

				// TODO: Handle SummoningRitualHandler properly
				if (GO.Handler is SummoningRitualHandler)
				{
					((SummoningRitualHandler)GO.Handler).Target = firstTarget;
				}

				if (m_cast.IsChanneling)
				{
					m_cast.CasterUnit.ChannelObject = GO;
				}
				else if (Effect.Spell.Durations.Min > 0)
				{
					// not channelled: Activate decay delay
					GO.RemainingDecayDelayMillis = Effect.Spell.Durations.Random();
				}
			}
			else
			{
				log.Error("Summoning Spell {0} refers to invalid Object: {1} ({2})", Effect.Spell, goId, (uint)goId);
			}
		}

		public void WithdrawMoney(Character withdrawer, GameObject bank, uint withdrawl)
		{
			if (withdrawl == 0) return;
			if (!bank.CanInteractWith(withdrawer)) return;
			if (withdrawer.Guild == null || withdrawer.GuildMember == null) return;
			if (withdrawer.Guild != Guild) return;
			if (Guild.Money < withdrawl) return;

			var member = withdrawer.GuildMember;
			if (!member.HasRight(GuildPrivileges.WITHDRAW_GOLD) ||
				member.HasRight(GuildPrivileges.WITHDRAW_GOLD_LOCK))
			{
				return;
			}
			if (member.BankMoneyWithdrawlAllowance < withdrawl)
			{
				return;
			}

			Guild.Money -= withdrawl;
			withdrawer.Money += withdrawl;
			member.BankMoneyWithdrawlAllowance -= withdrawl;

			BankLog.LogEvent(GuildBankLogEntryType.WithdrawMoney, withdrawer, withdrawl, null, 0, null);

			GuildHandler.SendMemberRemainingDailyWithdrawlAllowance(withdrawer, member.BankMoneyWithdrawlAllowance);
			GuildHandler.SendGuildBankTabNames(withdrawer, bank);
			GuildHandler.SendGuildBankTabContents(withdrawer, bank, 0);
			GuildHandler.SendGuildBankMoneyUpdate(withdrawer, bank);
		}

		protected internal override void Initialize(GameObject go)
		{
		    //var hidden = (go.Entry as GOTrapEntry).Hidden;
			//if (hidden)
			{
				// hide go
			}
		}

		private static void Teleport(GameObject go, Character chr)
		{
			if (go.Handler.CanBeUsedBy(chr))
			{
				// We need to enqueue a message when moving/removing/adding Objects in this method
				var portal = (Portal)go;
				chr.AddMessage(() => chr.TeleportTo(portal.Target));
			}
		}

		public static void SendRequest(GameObject duelFlag, Character challenger, Character rival)
		{
			using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_DUEL_REQUESTED))
			{
				packet.Write(duelFlag.EntityId);
				packet.Write(challenger.EntityId);

				rival.Client.Send(packet);
				challenger.Client.Send(packet);
			}
		}

		public void DepositMoney(Character depositer, GameObject bankObj, uint deposit)
		{
			if (!CheckBankObj(depositer, bankObj)) return;

			if (deposit == 0) return;
			if (depositer.Money < deposit) return;

			Guild.Money += deposit;
			depositer.Money -= deposit;

			BankLog.LogEvent(GuildBankLogEntryType.DepositMoney, depositer, deposit, null, 0, null);
			GuildHandler.SendGuildBankTabNames(depositer, bankObj);
			GuildHandler.SendGuildBankTabContents(depositer, bankObj, 0);
			GuildHandler.SendGuildBankMoneyUpdate(depositer, bankObj);
		}

		public void DepositMoney(Character depositer, GameObject bank, uint deposit)
		{
			if (deposit == 0) return;
			if (!bank.CanInteractWith(depositer)) return;
			if (depositer.Guild == null || depositer.GuildMember == null) return;
			if (depositer.Guild != Guild) return;
			if (depositer.Money < deposit) return;

			Guild.Money += deposit;
			depositer.Money -= deposit;

			BankLog.LogEvent(GuildBankLogEntryType.DepositMoney, depositer, deposit, null, 0, null);
			GuildHandler.SendGuildBankTabNames(depositer, bank);
			GuildHandler.SendGuildBankTabContents(depositer, bank, 0);
			GuildHandler.SendGuildBankMoneyUpdate(depositer, bank);
		}

        private static bool Blastenheimer5000Used(GameObject go, Character user)
        {
            var cast = user.SpellCast;
            var target = go.GetNearbyGO(CannonTarget, 1000);
            if(target != null)
            {
                var dist = go.GetDistance(target);
            }
            
            switch (go.EntryId)
            {
                case (uint)Blastenheimer5000ElwynnId:
                    {
                        cast.Start(CannonPrepId);
                        user.StandState = StandState.Sit;
                        user.IncMechanicCount(SpellMechanic.Rooted);
                        var facing = target != null ? go.GetAngleTowards(target) : ElwynnTeleOrientation;
                        user.TeleportTo(ElwynnTelePosition, facing);

                    } break;
                case (uint)Blastenheimer5000TerokkarId:
                    {
                        cast.Start(CannonPrepId);
                        user.StandState = StandState.Sit;
                        user.IncMechanicCount(SpellMechanic.Rooted);
                        var facing = target != null ? go.GetAngleTowards(target) : TerokkarTeleOrientation;
                        user.TeleportTo(TerokkarTelePosition, facing);
                    } break;
                case (uint)Blastenheimer5000MulgoreId:
                    {
                        cast.Start(CannonPrepMulgore);
                        user.StandState = StandState.Sit;
                        user.IncMechanicCount(SpellMechanic.Rooted);
                        var facing = target != null ? go.GetAngleTowards(target) : MulgoreTeleOrientation;
                        user.TeleportTo(MulgoreTelePosition, facing);
                    } break;
                default:
                    {
                        user.DecMechanicCount(SpellMechanic.Rooted);
                        return false;
                    }
            }
            go.PlaySound(8476);
            
            user.CallDelayed(2000, obj => FireCannon(user));
            return true;
        }

        public override void Apply()
        {
            var goId = (GOEntryId)Effect.MiscValue;
            var goEntry = GOMgr.GetEntry(goId);
            var caster = m_cast.CasterUnit;
            if (goEntry != null)
            {
                if (Cast.TargetLoc.X != 0)
                {
                    var worldLocation = new WorldLocation(caster.Map, Cast.TargetLoc);
                    go = goEntry.Spawn(worldLocation);
                }
                else
                {
                    go = goEntry.Spawn(caster, null);
                }

                go.State = GameObjectState.Enabled;
                go.Orientation = caster.Orientation;
                go.ScaleX = 1;
            }
        }

		/// <summary>
		/// Is called when the given new GameObject has been created.
		/// </summary>
		/// <param name="go"></param>
		internal protected virtual void InitGO(GameObject go)
		{
		}

		private static bool OnUse(GameObject go, Character chr)
		{
			var portal = (Portal)go;
			chr.TeleportTo(portal.Target);
			return true;
		}

 private static void TonkConsoleActivated(GameObject obj)
 {
     obj.State = GameObjectState.Enabled;
 }

		public virtual void OnPlayerClickedOnflag(GameObject go, Character chr)
		{
		}

		private static bool SoulPrisonUsed(GameObject go, Character user)
		{
			var nearest = go.GetNearbyNPC(NPCId.UnworthyInitiateAnchor, 2);
			if (nearest == null) return false;
			var shackled = nearest.ChannelObject as NPC;
			if (shackled == null) return false;

			var transformSpellId = GetTransformSpellIdFor(shackled.DisplayId);
			//just clear all auras! uh oh...not
			shackled.Auras.Clear();
			shackled.IsInvulnerable = false;
			go.Flags = GameObjectFlags.None;
			shackled.StandState = StandState.Stand;
			shackled.Emote(EmoteType.SimpleTalk);
			shackled.Say("They brand me unworthy? I will show them unworthy!");
			shackled.Spells.Clear();
			shackled.Spells.AddSpell(
				SpellId.ClassSkillPlagueStrikeRank1_2,
				SpellId.ClassSkillIcyTouchRank1_2,
				SpellId.ClassSkillBloodStrikeRank1_2,
				SpellId.ClassSkillDeathCoil,
				SpellId.ClassSkillDeathCoilRank1_3);
			shackled.CallDelayed(3000, wObj => ((NPC)wObj).MoveInFrontThenExecute(go, npc =>
			{
				npc.Emote(EmoteType.SimpleLoot);
				npc.CallDelayed(4000, obj =>
				{
					obj.SpellCast.TriggerSelf(SpellId.DeathKnightInitiateVisual);
					obj.SpellCast.TriggerSelf(transformSpellId);
					((NPC) obj).VirtualItem1 = ItemId.RunedSoulblade;
					obj.FactionId = FactionId.ActorEvil;
				});
				
				npc.CallDelayed(7000, obj =>
				{
					((NPC)obj).Emote(EmoteType.SimplePointNosheathe);
					obj.Say("To battle!");
				});

				npc.CallDelayed(9000, obj =>
				{
					((NPC)obj).ThreatCollection[user] += 10000;
					((NPC)obj).UnitFlags &= ~UnitFlags.SelectableNotAttackable;
					((NPC)obj).UnitFlags &= ~UnitFlags.NotAttackable;
					((NPC) obj).Target = user;
					((NPC)obj).Brain.State = BrainState.Combat;
				});
			}));

			return true;
		}

		protected internal override void InitGO(GameObject go)
		{
			go.SetUpdatePriority(UpdatePriority.VeryLowPriority);
			if (m_AreaEffectHandler != null)
			{
				go.CallPeriodicallyTicks(UpdateTicks, ApplyEffectsToArea);
			}
		}

		public GOSelection(GameObject go)
		{
			GO = go;
		}

		/// <summary>
		/// Initializes the duel after a new Duel has been proposed
		/// </summary>
		void Initialize()
		{
			// place flag in between the two
			var pos = ((m_challenger.Position + m_rival.Position) / 2);

			m_flag = GameObject.Create(GOEntryId.DuelFlag, new WorldLocationStruct(m_Map, pos));
			if (m_flag == null)
			{
				ContentMgr.OnInvalidDBData("Cannot start Duel: DuelFlag-GameObject (ID: {0}) does not exist.", (int)GOEntryId.DuelFlag);
				Cancel();
			}
			else
			{
				m_flag.Phase = m_challenger.Phase;

				((DuelFlagHandler)m_flag.Handler).Duel = this;
				m_flag.CreatedBy = m_challenger.EntityId;
				m_flag.Level = m_challenger.Level;
				m_flag.AnimationProgress = 255;
				m_flag.Position = m_challenger.Position;
				m_flag.Faction = m_challenger.Faction;
				m_flag.ScaleX = m_challenger.ScaleX;
				m_flag.ParentRotation4 = 1;
				m_flag.Orientation = m_challenger.Orientation;

				m_Map.AddMessage(new Message(() => DuelHandler.SendRequest(m_flag, m_challenger, m_rival)));
				m_challenger.SetEntityId(PlayerFields.DUEL_ARBITER, m_flag.EntityId);
				m_rival.SetEntityId(PlayerFields.DUEL_ARBITER, m_flag.EntityId);
			}
		}

        private static bool TonkConsoleUsed(GameObject go, Character user)
        {
            go.State = GameObjectState.Disabled;

            var tonkEntry = NPCMgr.GetEntry(SteamTonkNPCId);
            var tonk = tonkEntry.SpawnAt(user);
            tonk.Summoner = user;
            
            //Remove any of the special abilities from the tonk entry
            //and add a random one
            foreach (var tonkSpell in SpecialTonkSpells.Where(tonkSpell => tonkEntry.Spells.ContainsKey(tonkSpell)))
            {
                tonkEntry.Spells.Remove(tonkSpell);
            }
            var rand = new Random();
            tonkEntry.AddSpell(SpecialTonkSpells[rand.Next(0,3)]);

            var cast = user.SpellCast;
            if (cast == null)
            {
                go.State = GameObjectState.Enabled;
                return false;
            }

            if(cast.Start(UseTonkSpellId, false, tonk, user) != SpellFailedReason.Ok)
            {
                go.State = GameObjectState.Enabled;
                return false;
            }
            return true;
        }

		protected internal override void InitGO(GameObject trap)
		{
			// init Trap

			trap.Level = Level;
			trap.IsStealthed = Stealthed;
			if (!trap.HasAreaAuras)
			{
				if (Spell != null)
				{
					new AreaAura(trap, Spell, this);
				}
				trap.m_IsTrap = true;
			}
		}