/**
* @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]);
}
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);
}
}
}
}
final void parseData(LShrinkArray in, Mod srcMod) {
int strLength = in.extractInt(4);
name = in.extractString(strLength);
texture.parseData(in, srcMod);
index = in.extractInt(4);
}
void trimName(LShrinkArray out) {
if (is(BSAFlag.NamesInFileData)) {
out.skip(out.extractInt(1));
}
}
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;
}
}