Пример #1
0
 /**
  * @param filePath filepath to query for and retrieve.
  * @return ShrinkArray of the raw data from the BSA of the file specified, already decompressed if
  *     applicable; Empty ShrinkArray if the file did not exist.
  * @throws IOException
  * @throws DataFormatException
  */
 public LShrinkArray getFile(String filePath) throws IOException, DataFormatException {
   BSAFileRef ref;
   if ((ref = getFileRef(filePath)) != null) {
     in.pos(getFileLocation(ref));
     LShrinkArray out = new LShrinkArray(in.extract(0, ref.size));
     trimName(out);
     if (isCompressed(ref)) {
       out = out.correctForCompression();
     }
     return out;
   }
   return new LShrinkArray(new byte[0]);
 }
Пример #2
0
  void loadHeader(LShrinkArray in) throws BadParameter {

    // Gamebryo header
    if (SPGlobal.debugNIFimport) {
      SPGlobal.logSync(header, "Loading nif file");
    }
    if (!in.getString(20).equals("Gamebryo File Format")) {
      byte first = in.extract(1)[0];
      if (!in.extractString((int) first, 20).equals("Gamebryo File Format")) {
        throw new BadParameter(fileName + " was not a NIF file.");
      }
    }

    in.extractLine();

    // BlockTypes
    numBlocks = in.extractInt(9, 4);
    if (SPGlobal.debugNIFimport && SPGlobal.logging()) {
      SPGlobal.logSync(header, "Num Blocks: " + numBlocks);
    }
    in.skip(in.extractInt(4, 1)); // Author name
    in.skip(in.extractInt(1)); // Export Info 1
    in.skip(in.extractInt(1)); // Export Info 2
    int numBlockTypes = in.extractInt(2);
    if (SPGlobal.debugNIFimport && SPGlobal.logging()) {
      SPGlobal.logSync(header, "Num Block Types: " + numBlockTypes);
    }
    blockTypes = new ArrayList<>(numBlockTypes);
    for (int i = 0; i < numBlockTypes; i++) {
      String blockType = in.extractString(in.extractInt(4));
      blockTypes.add(blockType);
      if (SPGlobal.debugNIFimport && SPGlobal.logging()) {
        SPGlobal.logSync(header, "  Added block type[" + i + "]: " + blockType);
      }
    }

    // Blocks list
    if (SPGlobal.debugNIFimport && SPGlobal.logging()) {
      SPGlobal.logSync(header, "Block Type list: ");
    }
    nodes = new ArrayList<>(numBlocks);
    for (int i = 0; i < numBlocks; i++) {
      int type = in.extractInt(2);
      Node n = new Node(NodeType.SPvalueOf(blockTypes.get(type)));
      n.number = i;
      nodes.add(n);
      if (SPGlobal.debugNIFimport && SPGlobal.logging()) {
        SPGlobal.logSync(
            header,
            "  Block list[" + i + "] has block type: " + type + ", " + blockTypes.get(type));
      }
    }

    // Block lengths
    for (int i = 0; i < numBlocks; i++) {
      nodes.get(i).size = in.extractInt(4);
    }

    if (SPGlobal.debugNIFimport && SPGlobal.logging()) {
      SPGlobal.logSync(header, "Block headers: ");
      for (int i = 0; i < numBlocks; i++) {
        SPGlobal.logSync(
            header,
            "  ["
                + i
                + "]: "
                + nodes.get(i).type
                + ", length: "
                + Ln.prettyPrintHex(nodes.get(i).size));
      }
    }

    // Strings
    if (SPGlobal.debugNIFimport && SPGlobal.logging()) {
      SPGlobal.logSync(header, "Block Titles: ");
    }
    int numStrings = in.extractInt(4);
    in.skip(4); // max Length string
    ArrayList<String> strings = new ArrayList<>(numStrings);
    for (int i = 0; i < numStrings; i++) {
      strings.add(in.extractString(in.extractInt(4)));
    }
    in.skip(4); // unknown int

    for (int i = 0; i < numBlocks; i++) {
      nodes.get(i).data = new LShrinkArray(in, nodes.get(i).size);
      in.skip(nodes.get(i).size);
    }

    // Set titles
    for (int i = 0; i < numBlocks; i++) {
      NodeType type = nodes.get(i).type;
      if (type == NodeType.NINODE
          || type == NodeType.NITRISHAPE
          || type == NodeType.BSINVMARKER
          || type == NodeType.BSBEHAVIORGRAPHEXTRADATA) {
        Node n = nodes.get(i);
        int stringIndex = n.data.getInts(0, 4)[0];
        n.title = strings.get(stringIndex);
        if (SPGlobal.debugNIFimport && SPGlobal.logging()) {
          SPGlobal.log(
              header, "  [" + i + "]: " + nodes.get(i).type + ", string: " + nodes.get(i).title);
        }
      }
    }
  }
Пример #3
0
 final void parseData(LShrinkArray in, Mod srcMod) {
   int strLength = in.extractInt(4);
   name = in.extractString(strLength);
   texture.parseData(in, srcMod);
   index = in.extractInt(4);
 }
Пример #4
0
 void trimName(LShrinkArray out) {
   if (is(BSAFlag.NamesInFileData)) {
     out.skip(out.extractInt(1));
   }
 }
Пример #5
0
 final void loadFolders() {
   if (loaded) {
     return;
   }
   loaded = true;
   if (SPGlobal.logging()) {
     SPGlobal.logSpecial(LogTypes.BSA, header, "|============================================");
     SPGlobal.logSpecial(LogTypes.BSA, header, "|============  Loading " + this + " ============");
     SPGlobal.logSpecial(LogTypes.BSA, header, "|============================================");
   }
   try {
     String fileName;
     int fileCounter = 0;
     in.pos(offset);
     LShrinkArray folderData = new LShrinkArray(in.extract(0, folderCount * 16));
     posAtFilenames();
     LShrinkArray fileNames = new LShrinkArray(in.extract(0, fileNameLength));
     for (int i = 0; i < folderCount; i++) {
       BSAFolder folder = new BSAFolder();
       folderData.skip(8); // Skip Hash
       folder.setFileCount(folderData.extractInt(4));
       folder.dataPos = folderData.extractInt(4);
       posAtFolder(folder);
       folder.name = in.extractString(0, in.read() - 1) + "\\";
       folder.name = folder.name.toUpperCase();
       in.skip(1);
       folders.put(folder.name, folder);
       if (SPGlobal.debugBSAimport && SPGlobal.logging()) {
         SPGlobal.logSpecial(LogTypes.BSA, header, "Loaded folder: " + folder.name);
       }
       for (int j = 0; j < folder.fileCount; j++) {
         BSAFileRef f = new BSAFileRef();
         f.size = in.extractInt(8, 3); // Skip Hash
         LFlags sizeFlag = new LFlags(in.extract(1));
         f.flippedCompression = sizeFlag.get(6);
         f.dataOffset = in.extractLong(0, 4);
         fileName = fileNames.extractString();
         folder.files.put(fileName.toUpperCase(), f);
         if (SPGlobal.logging()) {
           SPGlobal.logSpecial(
               LogTypes.BSA,
               header,
               "  "
                   + fileName
                   + ", size: "
                   + Ln.prettyPrintHex(f.size)
                   + ", offset: "
                   + Ln.prettyPrintHex(f.dataOffset));
           fileCounter++;
         }
       }
     }
     if (SPGlobal.logging()) {
       if (SPGlobal.debugBSAimport) {
         SPGlobal.logSpecial(LogTypes.BSA, header, "Loaded " + fileCounter + " files.");
       }
       SPGlobal.logSpecial(LogTypes.BSA, header, "Loaded BSA: " + getFilePath());
     }
   } catch (Exception e) {
     SPGlobal.logException(e);
     SPGlobal.logError("BSA", "Skipped BSA " + this);
     bad = true;
   }
 }