示例#1
0
文件: Main.cs 项目: txdv/hltools
        public static void LoadWADFile(string filename)
        {
            Console.WriteLine("Parsing WAD file: {0}\n", filename);
            FileStream fs = File.OpenRead(filename);

            WADParser wadp = new WADParser(fs);
            Console.WriteLine("Files in directory: {0}", wadp.FileCount);

            wadp.OnLoadFile += (file) => { };
            Console.WriteLine("Loading file information");
            wadp.LoadFiles();

            fs.Close();
            fs.Dispose();
        }
示例#2
0
文件: Verifier.cs 项目: txdv/hltools
        public VerifierResult VerifyMap(string map)
        {
            VerifierResult res = new VerifierResult();

            ValveFile[] wadfiles = GetWadFiles();

            var fullmap = Path.Combine(ModMapsDirectory, map);

            if (!File.Exists(fullmap)) {
                throw new Exception(string.Format("Map does not exist: {0}", fullmap));
            }

            BSPParser bp = new BSPParser(File.OpenRead(fullmap));

            if (!bp.LoadDirectoryTables()) {
                throw new Exception("Malformed file");
            }

            List<string> textureList = new List<string>();
            bp.LoadMipTextureOffsets();
            bp.OnLoadMipTexture += (texture) => {
                if ((texture.offset1 == 0) && (texture.offset2 == 0) && (texture.offset3 == 0) && (texture.offset4 == 0)) {
                    textureList.Add(texture.Name);
                }
            };
            bp.LoadMipTextures();

            string entities = bp.ReadEntities();

            bp.Close();

            EntityParser ep = new EntityParser(entities);

            var ent = ep.ReadEntities();

            List<ValveFile> existingWads = new List<ValveFile>();
            List<string> malformedWadFiles = new List<string>();
            List<string> misnamedModDirs = new List<string>();
            List<string> notExistingFiles = new List<string>();

            if (ent.ContainsKey("worldspawn")) {
                string skyname = ent["worldspawn"][0]["skyname"];
                string wadList = ent["worldspawn"][0]["wad"];
                var list = Seperate(wadList);

                foreach (string fullReferencedWadFile in list) {

                    string referencedRelevantWadFile = fullReferencedWadFile.GetRelevantPath();

                    ValveFile referencedFile = new ValveFile(referencedRelevantWadFile);
                    ValveFile existingFile = GetWadFile(wadfiles, referencedFile);

                    if (referencedRelevantWadFile != fullReferencedWadFile) {
                        malformedWadFiles.Add(fullReferencedWadFile);
                    }

                    if (existingFile != null) {
                        if (existingFile.Compare(referencedFile) == ValveFileDifference.EqualFile) {
                            misnamedModDirs.Add(fullReferencedWadFile);
                        }

                        existingWads.Add(existingFile);
                    } else {
                        notExistingFiles.Add(fullReferencedWadFile);
                    }
                }

                res.MalformedWadFiles = malformedWadFiles.ToArray();
                res.MisnamedModDirs   =   misnamedModDirs.ToArray();
                res.NotExistingFiles  =  notExistingFiles.ToArray();

                #region Textures

                List<string> existingFilenames = new List<string>();
                foreach (var wadFile in existingWads) {
                    WADParser wp = new WADParser(File.OpenRead(wadFile.ToString(BaseDirectory)));
                    wp.OnLoadFile += (file) => {
                        existingFilenames.Add(file.Filename.ToLower());
                    };
                    wp.LoadFiles();
                    wp.Close();
                }

                List<string> missingTextures = new List<string>();

                foreach (var item in textureList) {
                    if (!existingFilenames.Contains(item.ToLower())) {
                        missingTextures.Add(item);
                    }
                }

                res.MissingTextures = missingTextures.ToArray();

                #endregion

                #region Sprites

                List<string> sprites = new List<string>();
                if (ent.ContainsKey("env_sprite")) {
                    foreach (var dict in ent["env_sprite"]) {
                        string model = dict["model"];
                        if (!sprites.Contains(model)) {
                            sprites.Add(model);
                        }
                    }
                }

                res.UsedSprites = sprites.ToArray();

                List<string> missingSprites = new List<string>();
                foreach (string sprite in sprites) {
                    ValveFile file = GetFile(sprite);
                    if (file == null) {
                        missingSprites.Add(sprite);
                    }
                }
                res.MissingSprites = missingSprites.ToArray();

                #endregion

                #region Sounds

                List<string> sounds = new List<string>();
                if (ent.ContainsKey("ambient_generic")) {
                    foreach (var ambient in ent["ambient_generic"]) {
                        if (ambient.ContainsKey("message")) {
                            string message = Path.Combine(SoundDir, ambient["message"]);
                            if (!sounds.Contains(message)) {
                                sounds.Add(message);
                            }
                        }
                    }
                }

                res.UsedSounds = sounds.ToArray();

                List<string> missingSounds = new List<string>();

                foreach (string sound in sounds) {
                    ValveFile file = GetFile(sound);
                    if (file == null) {
                        missingSounds.Add(sound);
                    }
                }

                res.MissingSounds = missingSounds.ToArray();

                #endregion

                #region Models

                List<string> models = new List<string>();
                foreach (var entityPair in ent) {
                    foreach (var entity in entityPair.Value) {
                        if (entity.ContainsKey("model")) {
                            string model = entity["model"];
                            if (!model.EndsWith(".mdl")) {
                                continue;
                            }
                            if (!models.Contains(model)) {
                                models.Add(model);
                            }
                        }
                    }
                }

                res.UsedModels = models.ToArray();

                List<string> missingModels = new List<string>();

                foreach (var model in models) {
                    ValveFile file = GetFile(model);
                    if (file == null) {
                        missingModels.Add(model);
                    }
                }

                res.MissingModels = missingModels.ToArray();

                #endregion
            }

            List<string> usedFileList = new List<string>();
            usedFileList.AddRange(res.UsedSprites);
            usedFileList.AddRange(res.UsedSounds);
            usedFileList.AddRange(res.UsedModels);
            usedFileList.Sort();
            res.UsedFileList = usedFileList.ToArray();

            List<string> missingFileList = new List<string>();
            missingFileList.AddRange(res.MissingSprites);
            missingFileList.AddRange(res.MissingSounds);
            missingFileList.AddRange(res.MissingModels);
            missingFileList.Sort();
            res.MissingFileList = missingFileList.ToArray();

            return res;
        }