public void FinalizeDataHolder()
		{
			RegionId = BattlegroundMgr.BattlemasterListReader.Entries[(int)Id].MapId;

			RegionTemplate = World.GetRegionTemplate(RegionId);
			if (RegionTemplate == null)
			{
				ContentMgr.OnInvalidDBData("BattlegroundTemplate had invalid RegionId: {0} (#{1})",
					RegionId, (int)RegionId);
				return;
			}

			if (BattlegroundMgr.Templates.Length <= (int)Id)
			{
				ContentMgr.OnInvalidDBData("BattlegroundTemplate had invalid BG-Id: {0} (#{1})",
					Id, (int)Id);
				return;
			}

            Difficulties = new PvPDifficultyEntry[BattlegroundMgr.PVPDifficultyReader.Entries.Values.Count(entry => (entry.mapId == RegionId))];

            foreach (var entry in BattlegroundMgr.PVPDifficultyReader.Entries.Values)
            {
                if (entry.mapId == RegionId)
                    Difficulties[entry.bracketId] = entry;
            }

            RegionTemplate.MinLevel = Math.Max(1, MinLevel);
            RegionTemplate.MaxLevel = Math.Max(MinLevel, MaxLevel);

			BattlegroundMgr.Templates[(int)Id] = this;

			CreateQueues();
            SetStartPos();
		}

 public ExtractedWMOManager(string _baseDirectory, MapId _mapId)
 {
     this._baseDirectory = _baseDirectory;
     this._mapId = _mapId;
     _WMOs = new List<ExtractedWMO>();
     _WMOM2s = new List<ExtractedM2>();
 }

        /// <summary>
        /// Get the height of the floor underneath the given position on the map with the given MapId.
        /// </summary>
        /// <param name="mapId">The <see cref="WCell.Constants.World.MapId"/> that corresponds to the desired map.</param>
        /// <param name="pos">The position on the map to get the height at.</param>
        /// <param name="height">The height of the floor at the given position on the map.</param>
        /// <returns>True if the height retrieval was successful.</returns>
        public bool GetHeightAtPosition(MapId mapId, Vector3 pos, out float height)
        {
            height = float.MinValue;

            Map map;
            return ((!TryGetMap(mapId, out map)) || (map.GetHeightAtPosition(pos, out height)));
        }

        /// <summary>
        /// Gets the nearest walkable (i.e., not water, model, air, etc) position to the given position.
        /// </summary>
        /// <param name="mapId">The <see cref="WCell.Constants.World.MapId"/> that corresponds to the desired map.</param>
        /// <param name="pos">The position to check against.</param>
        /// <param name="walkablePos">The nearest walkable position to the given position.</param>
        /// <returns>True if the check was successful.</returns>
        public bool GetNearestWalkablePositon(MapId mapId, Vector3 pos, out Vector3 walkablePos)
        {
            walkablePos = Vector3.Zero;

            Map map;
            return ((!TryGetMap(mapId, out map)) || (map.GetNearestWalkablePosition(pos, out walkablePos)));
        }

        /// <summary>
        /// Gets the nearest valid (i.e., not over a hole, outside map boundaries, etc) position to the given position.
        /// </summary>
        /// <param name="mapId">The <see cref="WCell.Constants.World.MapId"/> that corresponds to the desired map.</param>
        /// <param name="pos">The position to check against.</param>
        /// <param name="validPos">The nearest valid position to the given position.</param>
        /// <returns>True if the check was successful.</returns>
        public bool GetNearestValidPosition(MapId mapId, Vector3 pos, out Vector3 validPos)
        {
            validPos = Vector3.Zero;

            Map map;
            return ((!TryGetMap(mapId, out map)) || (map.GetNearestValidPosition(pos, out validPos)));
        }

		public static bool HasLOS(MapId mapId, Vector3 startPos, Vector3 endPos)
		{
			float tMax;
			var ray = CollisionHelper.CreateRay(startPos, endPos, out tMax);
			var intTMax = (int)(tMax + 0.5f);

			for (var t = 0; t < intTMax; t++)
			{
				var currentPos = ray.Position + ray.Direction * t;

				TileCoord currentTileCoord;
				ChunkCoord currentChunkCoord;
				PointX2D currentPointX2D;
				var currentHeightMapFraction = LocationHelper.GetFullInfoForPos(currentPos,
																				out currentTileCoord,
																				out currentChunkCoord,
																				out currentPointX2D);

				var currentTile = GetTile(mapId, currentTileCoord);
				if (currentTile == null)
				{
					// Can't check non-existant tiles.
					return false;
				}

				var terrainHeight = currentTile.GetInterpolatedHeight(currentChunkCoord, currentPointX2D, currentHeightMapFraction);

				if (terrainHeight < currentPos.Z) continue;
				return false;
			}

			return true;
		}

        public static ExtractedM2 Process(string basePath, MapId mapId, string path)
        {
            basePath = Path.Combine(basePath, mapId.ToString());
            var filePath = Path.Combine(basePath, path);
            filePath = Path.ChangeExtension(filePath, ".m2x");

            if (!File.Exists(filePath))
            {
                throw new FileNotFoundException("Extracted M2 file not found: {0}", filePath);
            }

            var m2 = new ExtractedM2();

            using(var file = File.OpenRead(filePath))
            using(var br = new BinaryReader(file))
            {
                var type = br.ReadString();
                if (type != fileType)
                {
                    br.Close();
                    throw new InvalidDataException(string.Format("M2x file in invalid format: {0}", filePath));
                }

                m2.Extents = br.ReadBoundingBox();
                m2.BoundingVertices = br.ReadVector3List();
                m2.BoundingTriangles = br.ReadIndex3List();

                br.Close();
            }

            return m2;
        }

		public void FinalizeDataHolder()
		{
			MapId = BattlegroundMgr.BattlemasterListReader.Entries[(int)Id].MapId;

			MapTemplate = World.GetMapTemplate(MapId);
			if (MapTemplate == null)
			{
				ContentMgr.OnInvalidDBData("BattlegroundTemplate had invalid MapId: {0} (#{1})",
					MapId, (int)MapId);
				return;
			}

			if (BattlegroundMgr.Templates.Length <= (int)Id)
			{
				ContentMgr.OnInvalidDBData("BattlegroundTemplate had invalid BG-Id: {0} (#{1})",
					Id, (int)Id);
				return;
			}
			MapTemplate.BattlegroundTemplate = this;

			Difficulties = new PvPDifficultyEntry[BattlegroundMgr.PVPDifficultyReader.Entries.Values.Count(entry => (entry.mapId == MapId))];

			foreach (var entry in BattlegroundMgr.PVPDifficultyReader.Entries.Values.Where(entry => (entry.mapId == MapId)))
			{
				Difficulties[entry.bracketId] = entry;
			}

			MinLevel = MapTemplate.MinLevel = Difficulties.First().minLevel;
			MaxLevel = MapTemplate.MaxLevel = Difficulties.Last().maxLevel;
			BattlegroundMgr.Templates[(int)Id] = this;

			CreateQueues();
			SetStartPos();
		}

		public void FinalizeDataHolder()
		{
			RegionId = BattlegroundMgr.BattlemasterListReader.Entries[(int)Id].MapId;

			RegionInfo = World.GetRegionInfo(RegionId);
			if (RegionInfo == null)
			{
				ContentHandler.OnInvalidDBData("BattlegroundTemplate had invalid RegionId: {0} (#{1})",
					RegionId, (int)RegionId);
				return;
			}

			if (BattlegroundMgr.Templates.Length <= (int)Id)
			{
				ContentHandler.OnInvalidDBData("BattlegroundTemplate had invalid BG-Id: {0} (#{1})",
					Id, (int)Id);
				return;
			}

			RegionInfo.MinLevel = Math.Max(1, MinLevel);
			RegionInfo.MaxLevel = Math.Max(MinLevel, MaxLevel);

			BattlegroundMgr.Templates[(int)Id] = this;

			CreateQueues();
            SetStartPos();
		}

		public WorldState(MapId mapId, ZoneId zoneId, uint key, int value)
		{
			MapId = mapId;
			ZoneId = zoneId;
			Key = (WorldStateId)key;
			DefaultValue = value;
		}

		public InstanceBinding(uint id, MapId mapId, uint difficultyIndex)
		{
			BindTime = DateTime.Now;
			DifficultyIndex = difficultyIndex;
			InstanceId = id;
			MapId = mapId;
		}

        internal static bool TryLoad(MapId mapId, out Map map)
        {
            map = null;
            var basePath = TerrainDisplayConfig.MapDir;
            var mapPath = Path.Combine(basePath, mapId.ToString());
            var fileName = string.Format("{0}{1}", mapId, Extension);
            var filePath = Path.Combine(mapPath, fileName);

            if (!Directory.Exists(mapPath))
            {
                log.Warn("Unable to find requested .map dir: {0}", mapPath);
                return false;
            }
            if (!File.Exists(filePath))
            {
                log.Warn("Unable to find requested .map file: {0}", filePath);
                return false;
            }

            using(var file = File.OpenRead(filePath))
            {
                map = ReadWDTInfo(file);
                file.Close();

                if (map == null)
                {
                    log.Warn("Unable to load the requested .map file: {0}", filePath);
                    return false;
                }
            }

            map.MapId = mapId;
            return true;
        }

 public ExtractedADTManager(ExtractedTerrainManager terrainManager, string basePath, MapId mapId)
 {
     _mapId = mapId;
     _terrainManager = terrainManager;
     _basePath = basePath;
     MapTiles = new List<ADTBase>();
 }

        public static ExtractedWMO Process(string basePath, MapId mapId, string path)
        {
            basePath = Path.Combine(basePath, mapId.ToString());
            var filePath = Path.Combine(basePath, path);
            filePath = Path.ChangeExtension(filePath, ".wmo");

            if (!File.Exists(filePath))
            {
                throw new FileNotFoundException("Extracted M2 file not found: {0}", filePath);
            }

            var wmo = new ExtractedWMO();

            using (var file = File.OpenRead(filePath))
            using (var br = new BinaryReader(file))
            {
                var type = br.ReadString();
                if (type != fileType)
                {
                    br.Close();
                    throw new InvalidDataException(string.Format("WMO file in invalid format: {0}", filePath));
                }

                wmo.Extents = br.ReadBoundingBox();
                wmo.WMOId = br.ReadUInt32();

                ReadWMODoodadDefs(br, wmo);

                ReadWMOGroups(br, wmo);
            }
            return wmo;
        }

 /// <summary>
 /// An instance has been reset
 /// </summary>
 public static void SendInstanceReset(IPacketReceiver client, MapId mapId)
 {
     using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_UPDATE_LAST_INSTANCE, 4))
     {
         packet.Write((int)mapId);
         client.Send(packet);
     }
 }

 /// <summary>
 /// Creates a dummy Terrain and loads the given tile into it
 /// </summary>
 public static TerrainTile LoadTile(MapId map, int x, int y)
 {
     var terrain = new SimpleTerrain(map);
     terrain.TileProfile[x, y] = true;
     var tile = terrain.LoadTile(x, y);
     terrain.Tiles[x, y] = tile;
     return tile;
 }

		public WorldLocation(MapId region, Vector3 pos)
		{
			Position = pos;
			Region = World.GetRegion(region);
			if (Region == null)
			{
				throw new Exception("Invalid Region in WorldLocation: " + region);
			}
		}

        public ITerrain CreateTerrain(MapId id)
        {
            if (!WorldMap.TerrainDataExists(id))
            {
                return new EmptyTerrain();
            }

            return new FullTerrain(id);
        }

		public WorldLocationStruct(MapId map, Vector3 pos, uint phase = WorldObject.DefaultPhase)
		{
			m_Position = pos;
			m_Map = World.GetNonInstancedMap(map);
			if (m_Map == null)
			{
				throw new Exception("Invalid Map in WorldLocationStruct: " + map);
			}
			m_Phase = phase;
		}

		public TeleportNode(string defaultName, MapId id, Vector3 pos)
		{
			DefaultName = defaultName;
			Map = World.GetNonInstancedMap(id);
			if (Map == null)
			{
				throw new ArgumentException("Map is not a continent: " + id);
			}
			Position = pos;
		}