public static MapEditor GetOrCreateEditor(Map map)
 {
     MapEditor editor;
     if (!EditorsByMap.TryGetValue(map, out editor))
     {
         EditorsByMap.Add(map, editor = new MapEditor(map));
     }
     return editor;
 }

 public static MapEditor StartEditing(Map map, Character chr = null)
 {
     var editor = GetOrCreateEditor(map);
     if (chr != null)
     {
         editor.Join(chr);
     }
     return editor;
 }

		public static ObjectReference GetOrCreate(Map rgn, EntityId id)
		{
			var caster = rgn.GetObject(id);
			if (caster != null)
			{
				return caster.SharedReference;
			}
			return new ObjectReference(id, 1);
		}

		/// <summary>
		/// Creates a new GameObject with the given parameters
		/// </summary>
		public static GameObject Create(GOEntryId id, Map map, GOSpawnEntry spawnEntry = null, GOSpawnPoint spawnPoint = null)
		{
			var entry = GOMgr.GetEntry(id);
			if (entry != null)
			{
				return Create(entry, map, spawnEntry, spawnPoint);
			}
			return null;
		}

		public Zone(Map rgn, ZoneTemplate template)
		{
			Map = rgn;
			Template = template;
			if (template.WorldStates != null)
			{
				WorldStates = new WorldStateCollection(this, template.WorldStates);
			}

			CreateChatChannels();
		}

        public Ticket(Character chr, string message, TicketType type)
        {
            m_owner = chr;
            m_ownerName = chr.Name;
            m_charId = chr.EntityId.Low;
            m_Message = message;

            m_Map = chr.Map;
            Position = chr.Position;
            Phase = chr.Phase;

            m_Timestamp = DateTime.Now;
            m_Type = type;
        }

		public static IMessage GetRemoveObjectTask(WorldObject obj, Map rgn)
		{
		    var moveTask = new Message2<WorldObject, Map>();

			moveTask.Parameter1 = obj;
			moveTask.Parameter2 = rgn;

            moveTask.Callback = ((worldObj, objRgn) =>
            {
                objRgn.RemoveObjectNow(worldObj);
            });

			return moveTask;
		}

		public static IMessage GetInitializeCharacterTask(Character chr, Map rgn)
		{
			var initTask = new Message2<Character, Map>();

			initTask.Parameter1 = chr;
			initTask.Parameter2 = rgn;

			initTask.Callback = ((initChr, initRgn) =>
			{
				initRgn.AddObjectNow(chr);
				//Map.s_log.Debug("Owner added to the map");

				//Map.s_log.Debug("Owner initialized");
			});

			return initTask;
		}

        public DynamicObject(Unit creator, SpellId spellId, float radius, Map map, Vector3 pos)
        {
            if (creator == null)
                throw new ArgumentNullException("creator", "creator must not be null");

            Master = creator;
            EntityId = EntityId.GetDynamicObjectId(++lastId);
            Type |= ObjectTypes.DynamicObject;
            SetEntityId(DynamicObjectFields.CASTER, creator.EntityId);
            SpellId = spellId;
            Radius = radius;
            Bytes = 0x01EEEEEE;
            ScaleX = 1;

            m_position = pos;
            map.AddObjectLater(this);
        }

		public TeleportNode(string defaultName, Map rgn, Vector3 pos)
		{
			DefaultName = defaultName;
			Map = rgn;
			Position = pos;
		}

		public void TeleportTo(Map map, bool wait)
		{
			TeleportTo(map, ref m_position, 3f, wait);
		}

		/// <summary>
		/// Sets the entry position of the character.
		/// </summary>
		public void SetCharacterEntry(Map map, ref Vector3 pos, float orientation)
		{
			m_EntryMap = map;
			_entryPosition = pos;
			_entryOrientation = orientation;
		}

		public NPC SpawnAt(Map map, Vector3 pos, bool hugGround = false)
		{
			var npc = Create(map.DifficultyIndex);
			if (hugGround && InhabitType == InhabitType.Ground)
			{
				pos.Z = map.Terrain.GetGroundHeightUnderneath(pos);
			}
			map.AddObject(npc, pos);
			return npc;
		}

        internal void OnOwnerLogout()
        {
            TicketMgr.Instance.lck.EnterWriteLock();
            try
            {
                Position = m_owner.Position;
                m_Map = m_owner.Map;
                Phase = m_owner.Phase;

                m_owner = null;
                var handler = m_handler;
                if (handler != null)
                {
                    handler.SendMessage("Owner of the Ticket you are handling went -{0}-.", ChatUtility.Colorize("offline", Color.Red));
                }
            }
            finally
            {
                TicketMgr.Instance.lck.ExitWriteLock();
            }
        }

		/// <summary>
		/// Returns the character to their original location prior to entering the Battleground.
		/// </summary>
		public void TeleportBack()
		{
			if (m_EntryMap == null || m_EntryMap.IsDisposed || _entryPosition.X == 0)
			{
				_chr.TeleportToBindLocation();
			}
			else
			{
				_chr.TeleportTo(m_EntryMap, ref _entryPosition, _entryOrientation);
			}

			m_EntryMap = null;
		}

		/// <summary>
		/// Creates a new duel between the 2 parties.
		/// </summary>
		/// <param name="challenger"></param>
		/// <param name="rival"></param>
		/// <param name="startDelay"></param>
		/// <param name="cancelDelay"></param>
		internal Duel(Character challenger, Character rival, int startDelay, int cancelDelay)
		{
			m_challenger = challenger;
			m_rival = rival;
			m_Map = challenger.Map;
			m_startDelay = startDelay;
			m_cancelDelay = cancelDelay;

			m_challenger.Duel = this;
			m_challenger.DuelOpponent = rival;

			m_rival.Duel = this;
			m_rival.DuelOpponent = challenger;

			Initialize();
		}

		private void SetCaster(ObjectReference caster, Map map, uint phase, Vector3 sourceLoc)
		{
			CasterReference = caster;
			if (caster == null)
			{
				throw new ArgumentNullException("caster");
			}
			CasterObject = caster.Object;
			CasterUnit = caster.UnitMaster;
			Map = map;
			Phase = phase;
			SourceLoc = sourceLoc;
		}

        public static void LoadDefaultMaps()
        {
            foreach (var rgnInfo in s_MapTemplates)
            {
                if (rgnInfo != null && rgnInfo.Type == MapType.Normal)
                {
                    var map = new Map(rgnInfo);

                    if (map.Id == MapId.Outland)
                    {
                        map.XpCalculator = XpGenerator.CalcOutlandXp;
                    }
                    else if (map.Id == MapId.Northrend)
                    {
                        map.XpCalculator = XpGenerator.CalcNorthrendXp;
                    }
                    else
                    {
                        map.XpCalculator = XpGenerator.CalcDefaultXp;
                    }

                    map.InitMap();
                    AddMap(map);
                }
            }
        }

		public static SpellCast ObtainPooledCast(ObjectReference caster, Map map, uint phase, ref Vector3 sourceLoc)
		{
			var cast = SpellCastPool.Obtain();
			cast.SetCaster(caster, map, phase, sourceLoc);
			return cast;
		}

		/// <summary>
		/// Returns the GOTemplate of this entry that is closest to the given location
		/// </summary>
		public GOSpawnEntry GetClosestTemplate(Map rgn, Vector3 pos)
		{
			return SpawnEntries.GetClosestEntry(new WorldLocationStruct(rgn, pos));
		}