Esempio n. 1
0
        /// <summary>
        /// Gets all files in <paramref name="directory"/> matching any extension in <see cref="Extensions"/>.
        /// </summary>
        /// <param name="directory">Directory to search in.</param>
        /// <param name="recursive">Search in subdirectories.</param>
        private void ScanDirectory(DirectoryInfo baseDirectory, DirectoryInfo directory, bool recursive)
        {
            FileInfo[] files = directory.GetFiles("*.*");

            IEnumerable <FileInfo> filteredFiles =
                Extensions != null && Extensions.Count > 0
                ? files.Where(f => Extensions.Contains(f.Extension.Replace(".", "").ToLowerInvariant()))
                : files.AsEnumerable();

            foreach (FileInfo file in filteredFiles)
            {
                string s    = File.ReadAllText(file.FullName);
                string path = AssetPath(baseDirectory.FullName, file.FullName);

                OnItemFound?.Invoke(path, s);
            }

            if (recursive)
            {
                foreach (DirectoryInfo dir in directory.GetDirectories())
                {
                    ScanDirectory(baseDirectory, dir, true);
                }
            }
        }
        /// <summary>
        /// Fetches all files in the archive matching any extension in <see cref="Extensions"/>.
        /// </summary>
        /// <param name="archive">Zip archive.</param>
        public void Fetch(ZipArchive archive)
        {
            // Get metadata to determine asset root
            ZipArchiveEntry metadata = archive.Entries.Where(e =>
            {
                var name = e.Name.ToLowerInvariant();
                return(name == "_metadata" || name == ".metadata");
            }).FirstOrDefault();
            string root = metadata != null?Path.GetDirectoryName(metadata.FullName) : "/";

            if (string.IsNullOrWhiteSpace(root))
            {
                root = "/";
            }

            foreach (ZipArchiveEntry entry in archive.Entries)
            {
                if (Extensions == null || Extensions.Count == 0 ||
                    Extensions.Contains(Path.GetExtension(entry.FullName).Replace(".", "").ToLowerInvariant()))
                {
                    string s    = ReadEntry(entry);
                    string path = AssetPath(root, entry.FullName);

                    OnItemFound?.Invoke(path, s);
                }
            }
        }
Esempio n. 3
0
    private IEnumerator Detect()
    {
        Collider[] hitColliders = Physics.OverlapSphere(droneTransform.position, range);

        int found = 0;

        yield return(new WaitForSeconds(duration));

        foreach (Collider c in hitColliders)
        {
            if (c.CompareTag(rayTag))
            {
                Item item = c.gameObject.GetComponentInChildren <Item>();

                if (item != null)
                {
                    found++;

                    Coordinate coordinate = CoordinateUtil.GetCoordinate(droneTransform.position, item.transform.position);

                    Debug.Log("found: " + item.name + " at " + coordinate.ToString());

                    OnItemFound?.Invoke(this, item, coordinate);

                    yield return(new WaitForSeconds(durationPerFind));
                }
            }
        }
    }
Esempio n. 4
0
        /// <summary>
        /// Fetches all items in the given pak.
        /// </summary>
        /// <param name="pakPath">File path to pak.</param>
        public void Fetch(string pakPath)
        {
            using (FileStream fs = File.Open(pakPath, FileMode.Open))
                using (BinaryReader binaryReader = new BinaryReader(fs))
                {
                    PakReader reader = new PakReader();
                    PakData   pak    = reader.Read(binaryReader);

                    foreach (PakItem item in pak.Items)
                    {
                        string ext = Path.GetExtension(item.Path);
                        if (Extensions == null || Extensions.Count == 0 ||
                            ext.Length > 0 && Extensions.Contains(ext.Substring(1).ToLowerInvariant()))
                        {
                            byte[] data = PakReader.ReadItem(binaryReader, item);
                            string s    = Encoding.UTF8.GetString(data);

                            OnItemFound?.Invoke(item.Path, s);
                        }
                    }
                }
        }