internal ArchiveFile ReadFile(GameProcessorContext context)
        {
            ArchiveFile archive = new ArchiveFile(this);

            archive.AddFile(context, WebScheme);
            return(archive);
        }
Example #2
0
        public ArchiveFile ReadFile(IFileCollection collection, IAssemblyManager manager)
        {
            ArchiveFile archive = new ArchiveFile(collection, this);

            archive.AddFile(WebScheme, collection, manager);
            return(archive);
        }
Example #3
0
        internal void AddArchiveFile(ArchiveFile archive)
        {
            if (archive.Metadata.Entries.Count > 1)
            {
                throw new NotSupportedException("More than one file for archive isn't supported");
            }

            foreach (ArchiveFileEntry entry in archive.Metadata.Entries)
            {
                // for now archive is a top level entity and contains only one file so we shouldn't concern about dependencies
                switch (entry.EntryType)
                {
                case FileEntryType.Serialized:
                {
                    entry.ReadSerializedFile(this, OnRequestDependency);
                }
                break;

                case FileEntryType.Bundle:
                {
                    entry.ReadBundleFile(this);
                }
                break;

                case FileEntryType.Web:
                {
                    entry.ReadWebFile(this);
                }
                break;

                default:
                    throw new Exception($"Unsupported file '{entry.Name}' inside archive '{entry.FilePath}'");
                }
            }
        }
Example #4
0
 public void ReadArchiveFile(SmartStream stream, string archivePath)
 {
     using (ArchiveFile archive = ArchiveFile.Read(stream, archivePath))
     {
         AddArchiveFile(archive);
     }
 }
Example #5
0
 public void LoadArchiveFile(string filePath)
 {
     using (ArchiveFile archive = ArchiveFile.Load(filePath))
     {
         AddArchiveFile(archive);
     }
 }
Example #6
0
        internal void AddFile(FileScheme scheme, IFileCollection collection, IAssemblyManager manager)
        {
            switch (scheme.SchemeType)
            {
            case FileEntryType.Serialized:
            {
                SerializedFileScheme serializedScheme = (SerializedFileScheme)scheme;
                SerializedFile       file             = serializedScheme.ReadFile(collection, manager);
                m_serializedFiles.Add(file);
                OnSerializedFileAdded(file);
            }
            break;

            case FileEntryType.Bundle:
            {
                BundleFileScheme bundleScheme = (BundleFileScheme)scheme;
                BundleFile       bundle       = bundleScheme.ReadFile(collection, manager);
                m_fileLists.Add(bundle);
                OnFileListAdded(bundle);
            }
            break;

            case FileEntryType.Archive:
            {
                ArchiveFileScheme archiveScheme = (ArchiveFileScheme)scheme;
                ArchiveFile       archive       = archiveScheme.ReadFile(collection, manager);
                m_fileLists.Add(archive);
                OnFileListAdded(archive);
            }
            break;

            case FileEntryType.Web:
            {
                WebFileScheme webScheme = (WebFileScheme)scheme;
                WebFile       webFile   = webScheme.ReadFile(collection, manager);
                m_fileLists.Add(webFile);
                OnFileListAdded(webFile);
            }
            break;

            case FileEntryType.Resource:
            {
                ResourceFileScheme resourceScheme = (ResourceFileScheme)scheme;
                ResourceFile       resource       = resourceScheme.ReadFile();
                m_resourceFiles.Add(resource);
                OnResourceFileAdded(resource);
            }
            break;

            default:
                throw new NotSupportedException(scheme.SchemeType.ToString());
            }
        }
Example #7
0
        internal void AddFile(GameProcessorContext context, FileScheme scheme)
        {
            switch (scheme.SchemeType)
            {
            case FileEntryType.Serialized:
            {
                SerializedFileScheme serializedScheme = (SerializedFileScheme)scheme;
                SerializedFile       file             = serializedScheme.ReadFile(context);
                AddSerializedFile(file);
            }
            break;

            case FileEntryType.Bundle:
            {
                BundleFileScheme bundleScheme = (BundleFileScheme)scheme;
                BundleFile       bundle       = bundleScheme.ReadFile(context);
                AddFileList(bundle);
            }
            break;

            case FileEntryType.Archive:
            {
                ArchiveFileScheme archiveScheme = (ArchiveFileScheme)scheme;
                ArchiveFile       archive       = archiveScheme.ReadFile(context);
                AddFileList(archive);
            }
            break;

            case FileEntryType.Web:
            {
                WebFileScheme webScheme = (WebFileScheme)scheme;
                WebFile       webFile   = webScheme.ReadFile(context);
                AddFileList(webFile);
            }
            break;

            case FileEntryType.Resource:
            {
                ResourceFileScheme resourceScheme = (ResourceFileScheme)scheme;
                ResourceFile       resource       = resourceScheme.ReadFile();
                AddResourceFile(resource);
            }
            break;

            default:
                throw new NotSupportedException(scheme.SchemeType.ToString());
            }
        }
Example #8
0
 public void Load(string filePath)
 {
     if (BundleFile.IsBundleFile(filePath))
     {
         LoadBundleFile(filePath);
     }
     else if (ArchiveFile.IsArchiveFile(filePath))
     {
         LoadArchiveFile(filePath);
     }
     else if (WebFile.IsWebFile(filePath))
     {
         LoadWebFile(filePath);
     }
     else
     {
         LoadSerializedFile(filePath);
     }
 }
 public static FileScheme ReadScheme(SmartStream stream, string filePath, string fileName)
 {
     if (BundleFile.IsBundleFile(stream))
     {
         return(BundleFile.ReadScheme(stream, filePath, fileName));
     }
     if (ArchiveFile.IsArchiveFile(stream))
     {
         return(ArchiveFile.ReadScheme(stream, filePath, fileName));
     }
     if (WebFile.IsWebFile(stream))
     {
         return(WebFile.ReadScheme(stream, filePath));
     }
     if (SerializedFile.IsSerializedFile(stream))
     {
         return(SerializedFile.ReadScheme(stream, filePath, fileName));
     }
     return(ResourceFile.ReadScheme(stream, filePath, fileName));
 }
Example #10
0
 public void Read(SmartStream stream, string filePath)
 {
     if (BundleFile.IsBundleFile(stream))
     {
         ReadBundleFile(stream, filePath);
     }
     else if (ArchiveFile.IsArchiveFile(stream))
     {
         ReadArchiveFile(stream, filePath);
     }
     else if (WebFile.IsWebFile(stream))
     {
         ReadWebFile(stream, filePath);
     }
     else
     {
         string fileName = Path.GetFileName(filePath);
         ReadSerializedFile(stream, filePath, fileName, OnRequestDependency);
     }
 }
 public static FileScheme ReadScheme(byte[] buffer, string filePath, string fileName)
 {
     using (MemoryStream stream = new MemoryStream(buffer, 0, buffer.Length, false))
     {
         if (BundleFile.IsBundleFile(stream))
         {
             return(BundleFile.ReadScheme(buffer, filePath, fileName));
         }
         if (ArchiveFile.IsArchiveFile(stream))
         {
             return(ArchiveFile.ReadScheme(buffer, filePath, fileName));
         }
         if (WebFile.IsWebFile(stream))
         {
             return(WebFile.ReadScheme(buffer, filePath));
         }
         if (SerializedFile.IsSerializedFile(stream))
         {
             return(SerializedFile.ReadScheme(buffer, filePath, fileName));
         }
         return(ResourceFile.ReadScheme(buffer, filePath, fileName));
     }
 }
Example #12
0
 public static FileScheme ReadScheme(SmartStream stream, long offset, long size, string filePath, string fileName)
 {
     if (BundleFile.IsBundleFile(stream, offset, size))
     {
         return(BundleFile.ReadScheme(stream, offset, size, filePath, fileName));
     }
     if (ArchiveFile.IsArchiveFile(stream, offset, size))
     {
         return(ArchiveFile.ReadScheme(stream, offset, size, filePath, fileName));
     }
     if (WebFile.IsWebFile(stream, offset, size))
     {
         return(WebFile.ReadScheme(stream, offset, size, filePath, fileName));
     }
     if (ResourceFile.IsDefaultResourceFile(fileName))
     {
         return(ResourceFile.ReadScheme(stream, offset, size, filePath, fileName));
     }
     if (SerializedFile.IsSerializedFile(stream, offset, size))
     {
         return(SerializedFile.ReadScheme(stream, offset, size, filePath, fileName));
     }
     return(ResourceFile.ReadScheme(stream, offset, size, filePath, fileName));
 }