ESD.bt

//------------------------------------------------
//--- 010 Editor v7.0.2 Binary Template
//
//      File: ESD.bt
//   Authors: TKGP
//   Version: 1.03
//   Purpose: EzState
//  Category: Dark Souls
// File Mask: *.esd
//  ID Bytes: 66 [+1] 53 4C 01 00 00 00 [+8] 54 00 00 00
//   History: 
//------------------------------------------------

local int VARINT_LONG = 0;
#include "Util.bt"

LittleEndian();

struct Header {
    char magic[4]; Assert(magic == "fSSL" || magic == "fsSL");
    VARINT_LONG = magic == "fsSL";

    int unk04; Assert(unk04 == 1);
    int numberOfDarkSoulses1;
        Assert(numberOfDarkSoulses1 == 1 || numberOfDarkSoulses1 == 2 || numberOfDarkSoulses1 == 3);
    int numberOfDarkSoulses2;
        Assert(numberOfDarkSoulses2 == numberOfDarkSoulses1);
    int unk10 <format=hex>; Assert(unk10 == 0x54);
    int dataSize;
    int blockCount; Assert(blockCount == 6);

    int dataHeaderSize <format=hex>; Assert(dataHeaderSize == (VARINT_LONG ? 0x48 : 0x2C));
    int dataHeaderCount; Assert(dataHeaderCount == 1);
    int stateGroupSize <format=hex>; Assert(stateGroupSize == (VARINT_LONG ? 0x20 : 0x10));
    int stateGroupCount;
    int stateSize <format=hex>; Assert(stateSize == (VARINT_LONG ? 0x48 : 0x24));
    int stateCount;
    int conditionSize <format=hex>; Assert(conditionSize == (VARINT_LONG ? 0x38 : 0x1C));
    int conditionCount;
    int commandCallSize <format=hex>; Assert(commandCallSize == (VARINT_LONG ? 0x18 : 0x10));
    int commandCallCount;
    int commandArgSize <format=hex>; Assert(commandArgSize == (VARINT_LONG ? 0x10 : 0x8));
    int commandArgCount;

    int conditionOffsetsOffset <format=hex>;
    int conditionOffsetCount;
    // Please note that this is not actually the name offset, it's the end of the
    // bytecode block, which may be off by a byte due to padding for UTF-16
    int nameBlockOffset <format=hex>;
    int nameLength;
    // These are never used
    int unkDataOffset2 <format=hex>;
    int unkDataCount2; Assert(unkDataCount2 == 0);
    int unkDataOffset3 <format=hex>;
    int unkDataCount3; Assert(unkDataCount3 == 0);
} header <bgcolor=cRed>;

// 0x6C
local quad dataStart = FTell();

struct DataHeader {
    int unk6C; Assert(unk6C == 1);
    int unk70[4] <format=hex, bgcolor=cBlack, fgcolor=cWhite>;
    if (VARINT_LONG) {
        int unk80; Assert(unk80 == 0);
    }
        
    Varint dataHeaderSize; Assert(dataHeaderSize.val == (VARINT_LONG ? 0x48 : 0x2C));
    Varint stateGroupCount; Assert(stateGroupCount.val == header.stateGroupCount);
    Varint nameOffset;
    Varint nameLength;
    Varint unkNull1; Assert(unkNull1.val == 0 || unkNull1.val == -1);
    Varint unkNull2; Assert(unkNull2.val == unkNull1.val);

    if (nameLength.val > 0) {
        local quad pos = FTell();
        FSeek(0x6C + nameOffset.val);
        wchar_t name[nameLength.val];
        FSeek(pos);
    }
} dataHeader <bgcolor=cLtRed>;

struct CommandArg {
    // Bytecode expression returning a value
    Varint dataOffset;
    Varint dataSize;
    
    if (dataSize.val > 0) {
        local quad pos = FTell();
        FSeek(dataStart + dataOffset.val);
        byte data[dataSize.val] <format=hex, bgcolor=cBlack, fgcolor=cWhite>;
        FSeek(pos);
    }
};

struct CommandCall {
    // Only 1 in DS1
    int unk00; Assert(unk00 == 1 || unk00 == 5 || unk00 == 6 || unk00 == 7);
    // ID of the function to call
    int commandID;
    Varint commandArgsOffset;
    Varint commandArgCount;

    if (commandArgCount.val > 0) {
        local quad pos = FTell();
        FSeek(dataStart + commandArgsOffset.val);
        CommandArg args[commandArgCount.val] <bgcolor=cAqua, optimize=false>;
        FSeek(pos);
    }
};

struct State {
    Varint id;
    // Conditions are checked each frame, state switches to
    // the first one that passes (if any)
    Varint conditionOffsetsOffset;
    Varint conditionOffsetCount;
    // On commands run when the state is entered
    Varint onCommandsOffset;
    Varint onCommandCount;
    // Off commands run when the state is exited
    Varint offCommandsOffset;
    Varint offCommandCount;
    // Not used in DS1; perhaps run every frame?
    Varint unkCommandsOffset;
    Varint unkCommandCount;
    
    local quad pos = FTell();
    if (conditionOffsetCount.val > 0) {
        FSeek(dataStart + conditionOffsetsOffset.val);
        Varint conditionOffsets[conditionOffsetCount.val] <format=hex, bgcolor=cDkGreen, optimize=true>;
    }
    if (onCommandCount.val > 0) {
        FSeek(dataStart + onCommandsOffset.val);
        CommandCall onCommands[onCommandCount.val] <bgcolor=cLtBlue, optimize=false>;
    }
    if (offCommandCount.val > 0) {
        FSeek(dataStart + offCommandsOffset.val);
        CommandCall offCommands[offCommandCount.val] <bgcolor=cLtBlue, optimize=false>;
    }
    if (unkCommandCount.val > 0) {
        FSeek(dataStart + unkCommandsOffset.val);
        CommandCall unkCommands[unkCommandCount.val] <bgcolor=cLtBlue, optimize=false>;
    }
    FSeek(pos);
};

struct StateGroup {
    Varint id;
    Varint unkOffset1;
    Varint stateCount;
    // One of these is probably "entry state" or something.
    Varint unkOffset2; Assert(unkOffset2.val == unkOffset1.val);
    
    local quad pos = FTell();
    FSeek(dataStart + unkOffset1.val);
    struct StatesGroup {
        State states[stateCount.val] <bgcolor=cGreen, optimize=false>;
    } statesGroup;
    State transitionState <bgcolor=cDkGreen>;
    FSeek(pos);
};

struct StateGroupsGroup {
    StateGroup stateGroups[dataHeader.stateGroupCount.val] <bgcolor=cSilver, optimize=false>;
} stateGroupsGroup;

struct Condition {
    // State to enter if the condition passes
    Varint stateOffset;
    // Commands run when the condition passes
    Varint commandsOffset;
    Varint commandCount;
    // If the condition passes, evaluation will continue to these conditions
    Varint conditionOffsetsOffset;
    Varint conditionOffsetCount;
    // Bytecode that evaluates the condition
    Varint dataOffset;
    Varint dataSize;
    
    local quad pos = FTell();
    if (commandCount.val > 0) {
        FSeek(dataStart + commandsOffset.val);
        CommandCall commands[commandCount.val] <bgcolor=cLtBlue, optimize=false>;
    }
    if (conditionOffsetCount.val > 0) {
        FSeek(dataStart + conditionOffsetsOffset.val);
        Varint conditionOffsets[conditionOffsetCount.val] <format=hex, bgcolor=cDkGreen, optimize=true>;
    }
    if (dataSize.val > 0) {
        FSeek(dataStart + dataOffset.val);
        byte data[dataSize.val] <format=hex, bgcolor=cBlack, fgcolor=cWhite>;
    }
    FSeek(pos);
};

// Skip past all the states because we read them from their groups before
FSeek(FTell() + header.stateCount * header.stateSize);
struct ConditionsGroup {
    Condition conditions[header.conditionCount] <bgcolor=cLtGreen, optimize=false>;
} conditionsGroup;

// In DS2, the file is padded with garbage to 0x10