Пример #1
0
        public bool LoadMapTile(uint tileX, uint tileY, VMapManager2 vm)
        {
            if (_treeValues == null)
            {
                Console.WriteLine("StaticMapTree.LoadMapTile() : tree has not been initialized [{tileX}, {tileY}]");
                return(false);
            }

            string tilefile = _basePath + GetTileFileName(_mapId, tileX, tileY);

            if (File.Exists(tilefile))
            {
                using (BinaryReader binaryReader = new BinaryReader(File.Open(tilefile, FileMode.Open, FileAccess.Read, FileShare.Read)))
                {
                    if (binaryReader.ReadStringFromChars(8) != SharedConst.VMAP_MAGIC)
                    {
                        return(false);
                    }

                    uint numSpawns = binaryReader.ReadUInt32();
                    for (uint i = 0; i < numSpawns; ++i)
                    {
                        // read model spawns
                        ModelSpawn spawn;
                        var        result = ModelSpawn.ReadFromFile(binaryReader, out spawn);
                        if (result)
                        {
                            // acquire model instance
                            WorldModel model = vm.AcquireModelInstance(_basePath, spawn.name);
                            if (model == null)
                            {
                                Console.WriteLine($"StaticMapTree.LoadMapTile() : could not acquire WorldModel pointer [{tileX}, {tileY}]");
                            }

                            // update tree
                            if (_spawnIndices.ContainsKey(spawn.ID))
                            {
                                uint referencedVal = _spawnIndices[spawn.ID];
                                if (!_loadedSpawns.ContainsKey(referencedVal))
                                {
                                    if (referencedVal > _nTreeValues)
                                    {
                                        Console.WriteLine($"StaticMapTree.LoadMapTile() : invalid tree element ({referencedVal}/{_nTreeValues}) referenced in tile {tilefile}");
                                        continue;
                                    }

                                    _treeValues[referencedVal]   = new ModelInstance(spawn, model);
                                    _loadedSpawns[referencedVal] = 1;
                                }
                                else
                                {
                                    ++_loadedSpawns[referencedVal];
                                }
                            }
                        }
                    }
                    _loadedTiles[PackTileID(tileX, tileY)] = true;
                }
            }
            else
            {
                _loadedTiles[PackTileID(tileX, tileY)] = false;
            }

            //TC_METRIC_EVENT("map_events", "LoadMapTile", "Map: " + std::to_string(iMapID) + " TileX: " + std::to_string(tileX) + " TileY: " + std::to_string(tileY));
            return(true);
        }
Пример #2
0
        public void UnloadMapTile(uint tileX, uint tileY, VMapManager2 vm)
        {
            uint tileID = PackTileID(tileX, tileY);

            if (!_loadedTiles.ContainsKey(tileID))
            {
                Console.WriteLine("StaticMapTree.UnloadMapTile() : trying to unload non-loaded tile - Map:{iMapID} X:{tileX} Y:{tileY}");
                return;
            }

            var tile = _loadedTiles.LookupByKey(tileID);

            if (tile) // file associated with tile
            {
                string tilefile = _basePath + GetTileFileName(_mapId, tileX, tileY);
                if (File.Exists(tilefile))
                {
                    using (BinaryReader binaryReader = new BinaryReader(File.Open(tilefile, FileMode.Open, FileAccess.Read, FileShare.Read)))
                    {
                        bool result = true;
                        if (binaryReader.ReadStringFromChars(8) != SharedConst.VMAP_MAGIC)
                        {
                            result = false;
                        }

                        uint numSpawns = binaryReader.ReadUInt32();
                        for (uint i = 0; i < numSpawns && result; ++i)
                        {
                            // read model spawns
                            ModelSpawn spawn;
                            result = ModelSpawn.ReadFromFile(binaryReader, out spawn);
                            if (result)
                            {
                                // release model instance
                                vm.ReleaseModelInstance(spawn.name);

                                // update tree
                                if (!_spawnIndices.ContainsKey(spawn.ID))
                                {
                                    result = false;
                                }
                                else
                                {
                                    uint referencedVal = _spawnIndices[spawn.ID];
                                    if (!_loadedSpawns.ContainsKey(referencedVal))
                                    {
                                        Console.WriteLine($"StaticMapTree.UnloadMapTile() : trying to unload non-referenced model '{spawn.name}' (ID:{spawn.ID})");
                                    }
                                    else if (--_loadedSpawns[referencedVal] == 0)
                                    {
                                        _treeValues[referencedVal].SetUnloaded();
                                        _loadedSpawns.Remove(referencedVal);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            _loadedTiles.Remove(tileID);
            //TC_METRIC_EVENT("map_events", "UnloadMapTile", "Map: " + std::to_string(iMapID) + " TileX: " + std::to_string(tileX) + " TileY: " + std::to_string(tileY));
        }