/// <summary>
        /// Stars loading all roomtextures in a background thread.
        /// </summary>
        protected void LoadThreadRoomTextures()
        {
            IEnumerator <KeyValuePair <string, BgfFile> > it = RoomTextures.GetEnumerator();
            BgfFile file;

            while (it.MoveNext())
            {
                // load
                file = new BgfFile(Path.Combine(RoomTexturesFolder, it.Current.Key));
                file.DecompressAll();

                // update
                RoomTextures.TryUpdate(it.Current.Key, file, null);

                queueAsyncFilesLoaded.Enqueue(it.Current.Key);
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Preloads all elements in the RoomTextures dictionary.
        /// </summary>
        public void PreloadRoomTextures()
        {
            IEnumerator <KeyValuePair <string, BgfFile> > it = RoomTextures.GetEnumerator();
            BgfFile file;

            while (it.MoveNext())
            {
                // load
                file = new BgfFile(Path.Combine(Config.RoomTexturesFolder, it.Current.Key));
                file.DecompressAll();

                // update
                RoomTextures.TryUpdate(it.Current.Key, file, null);
            }

            GC.Collect(2);
        }
        /// <summary>
        /// Tries to retrieve a BGF file from the RoomTextures dictionary.
        /// Will load the file from disk, if not yet loaded.
        /// </summary>
        /// <param name="File"></param>
        /// <returns></returns>
        public BgfFile GetRoomTexture(string File)
        {
            BgfFile bgfFile = null;

            // if the file is known
            if (RoomTextures.TryGetValue(File, out bgfFile))
            {
                // haven't loaded it yet?
                if (bgfFile == null)
                {
                    byte[] buffer;

                    // get file byte buffer
                    if (!fileBuffers.TryPop(out buffer))
                    {
                        buffer = new byte[FILEBUFFERSIZE];
                    }

                    string file = RoomTexturesFolder + "/" + File;

                    // load to mem
                    if (Util.LoadFileToBuffer(file, buffer))
                    {
                        // load it
                        bgfFile = new BgfFile(file, buffer);

                        // update the registry
                        if (RoomTextures.TryUpdate(File, bgfFile, null))
                        {
                            numLoadedRoomTextures++;
                        }
                    }
                    else
                    {
                        Logger.Log(MODULENAME, LogType.Error, "Failed to load file (possibly too big?): " + File);
                    }

                    fileBuffers.Push(buffer);
                }
            }

            return(bgfFile);
        }
        /// <summary>
        /// Tries to retrieve a BGF file from the RoomTextures dictionary.
        /// Will load the file from disk, if not yet loaded.
        /// </summary>
        /// <param name="File"></param>
        /// <returns></returns>
        public BgfFile GetRoomTexture(string File)
        {
            BgfFile bgfFile = null;

            // if the file is known
            if (RoomTextures.TryGetValue(File, out bgfFile))
            {
                // haven't loaded it yet?
                if (bgfFile == null)
                {
                    // load it
                    bgfFile = new BgfFile(RoomTexturesFolder + "/" + File);

                    // update the registry
                    RoomTextures.TryUpdate(File, bgfFile, null);
                }
            }

            return(bgfFile);
        }
        /// <summary>
        /// Sets pathes to required resources.
        /// Will also remove any existing resources from the current lists.
        /// </summary>
        /// <param name="PathStrings"></param>
        /// <param name="PathRooms"></param>
        /// <param name="PathObjects"></param>
        /// <param name="PathRoomTextures"></param>
        /// <param name="PathSounds"></param>
        /// <param name="PathMusic"></param>
        /// <param name="PathMails"></param>
        public void Init(
            string PathStrings,
            string PathRooms,
            string PathObjects,
            string PathRoomTextures,
            string PathSounds,
            string PathMusic,
            string PathMails)
        {
            this.StringsFolder      = PathStrings;
            this.RoomsFolder        = PathRooms;
            this.ObjectsFolder      = PathObjects;
            this.RoomTexturesFolder = PathRoomTextures;
            this.WavFolder          = PathSounds;
            this.MusicFolder        = PathMusic;
            this.MailFolder         = PathMails;

            string[] files;

            // already executed once?
            if (Initialized)
            {
                StringResources.Clear();
                StringDictionaries.Clear();
                Objects.Clear();
                RoomTextures.Clear();
                Rooms.Clear();
                Wavs.Clear();
                Music.Clear();

                // detach mail listener so we don't delete them
                Mails.ListChanged -= OnMailsListChanged;

                // clear our objects
                Mails.Clear();
            }

            // register string dictionaries for different servers
            if (Directory.Exists(StringsFolder))
            {
                // get available files
                files = Directory.GetFiles(StringsFolder, '*' + FileExtensions.RSB);

                foreach (string s in files)
                {
                    StringDictionaries.TryAdd(Path.GetFileName(s), null);
                }
            }

            // register objects
            if (Directory.Exists(ObjectsFolder))
            {
                // get available files
                files = Directory.GetFiles(ObjectsFolder, '*' + FileExtensions.BGF);

                foreach (string s in files)
                {
                    string filename = Path.GetFileName(s);

                    if (!filename.StartsWith("grd"))
                    {
                        Objects.TryAdd(filename, null);
                    }
                }
            }

            // register roomtextures
            if (Directory.Exists(RoomTexturesFolder))
            {
                // get available files
                files = Directory.GetFiles(RoomTexturesFolder, "grd*" + FileExtensions.BGF);

                foreach (string s in files)
                {
                    RoomTextures.TryAdd(Path.GetFileName(s), null);
                }
            }

            // register rooms
            if (Directory.Exists(RoomsFolder))
            {
                // get available files
                files = Directory.GetFiles(RoomsFolder, '*' + FileExtensions.ROO);

                foreach (string s in files)
                {
                    Rooms.TryAdd(Path.GetFileName(s), null);
                }
            }

            // register wav sounds
            if (Directory.Exists(WavFolder))
            {
                // get available files
                files = Directory.GetFiles(WavFolder, '*' + FileExtensions.OGG);

                foreach (string s in files)
                {
                    Wavs.TryAdd(Path.GetFileName(s), null);
                }
            }

            // register music
            if (Directory.Exists(MusicFolder))
            {
                // get available files
                files = Directory.GetFiles(MusicFolder, '*' + FileExtensions.OGG);

                foreach (string s in files)
                {
                    Music.TryAdd(Path.GetFileName(s), null);
                }
            }

            // load mails
            if (Directory.Exists(MailFolder))
            {
                // read available mail files
                files = Directory.GetFiles(MailFolder, '*' + FileExtensions.XML);
                foreach (string s in files)
                {
                    // create mail object
                    Mail mail = new Mail();

                    // load values from xml
                    mail.Load(s);

                    // add to list
                    Mails.Add(mail);
                }
            }

            // hookup mails listener to write/delete the files
            Mails.ListChanged += OnMailsListChanged;

            // forced GC collection
            GC.Collect(2);

            // mark initialized
            Initialized = true;
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Initializes the ResourceManager from given config.
        /// </summary>
        /// <param name="Config"></param>
        public void InitConfig(ResourceManagerConfig Config)
        {
            string[] files;

            // save new config
            this.Config = Config;

            // already executed once?
            if (Initialized)
            {
                // clear current string dictionary
                StringResources.Clear();

                // clear current lookup dictionaries
                Objects.Clear();
                RoomTextures.Clear();
                Rooms.Clear();
                Wavs.Clear();
                Music.Clear();

                // detach mail listener so we don't delete them
                Mails.ListChanged -= OnMailsListChanged;

                // clear our objects
                Mails.Clear();
            }

            // register strings
            if (File.Exists(Config.StringResourcesFile))
            {
                // load string resources
                RsbFile rsbFile = new RsbFile(Config.StringResourcesFile);

                // add to dictionary
                foreach (KeyValuePair <uint, string> pair in rsbFile.StringResources)
                {
                    StringResources.TryAdd(pair.Key, pair.Value);
                }
            }

            // register objects
            if (Directory.Exists(Config.ObjectsFolder))
            {
                // get available files
                files = Directory.GetFiles(Config.ObjectsFolder, '*' + FileExtensions.BGF);

                foreach (string s in files)
                {
                    string filename = Path.GetFileName(s);

                    if (!filename.StartsWith("grd"))
                    {
                        Objects.TryAdd(filename, null);
                    }
                }
            }

            // register roomtextures
            if (Directory.Exists(Config.RoomTexturesFolder))
            {
                // get available files
                files = Directory.GetFiles(Config.RoomTexturesFolder, "grd*" + FileExtensions.BGF);

                foreach (string s in files)
                {
                    RoomTextures.TryAdd(Path.GetFileName(s), null);
                }
            }

            // register rooms
            if (Directory.Exists(Config.RoomsFolder))
            {
                // get available files
                files = Directory.GetFiles(Config.RoomsFolder, '*' + FileExtensions.ROO);

                foreach (string s in files)
                {
                    Rooms.TryAdd(Path.GetFileName(s), null);
                }
            }

            // register wav sounds
            if (Directory.Exists(Config.WavFolder))
            {
                // get available files
                files = Directory.GetFiles(Config.WavFolder, '*' + FileExtensions.WAV);

                foreach (string s in files)
                {
                    Wavs.TryAdd(Path.GetFileName(s), null);
                }
            }

            // register music
            if (Directory.Exists(Config.MusicFolder))
            {
                // get available files
                files = Directory.GetFiles(Config.MusicFolder, '*' + FileExtensions.MP3);

                foreach (string s in files)
                {
                    Music.TryAdd(Path.GetFileName(s), null);
                }
            }

            // load mails
            if (Directory.Exists(Config.MailFolder))
            {
                // read available mail files
                files = Directory.GetFiles(Config.MailFolder, '*' + FileExtensions.XML);
                foreach (string s in files)
                {
                    // create mail object
                    Mail mail = new Mail();

                    // load values from xml
                    mail.Load(s);

                    // add to list
                    Mails.Add(mail);
                }
            }

            // hookup mails listener to write/delete the files
            Mails.ListChanged += OnMailsListChanged;

            // forced GC collection
            GC.Collect(2);

            // mark initialized
            Initialized = true;
        }