CCharInfo.bt

#ifndef _CCHARINFO
#define _CCHARINFO

#include <CEvalSystem.bt>
#include <CTransform4f.bt>
#include <CPASDatabase.bt>

local int charinfoi <hidden=true> = 0;

struct SNodeSet {
    ushort nodeCount;
    ushort nameSet;
    if (nodeCount) {
        uint nodeId[nodeCount] <format = hex>;
    }
};

/* Equivelant of SAnimContext::ReadIntoMemory */
struct SAnimContext(byte unkA, byte unkB, uint16 unkC, uint16 unkD, uint16 unkE) {
    uchar unkData1[unkA * 6];
    uchar unkData2[unkC];
    ushort unkData3[unkB];
    uchar unkData4[unkD - (unkB * 8)];
    ushort unkData5[unkA];
    uchar unkData6[unkE - (unkA * 8)];
    SNodeSet nodeSet;
};

/* Equivelant of SAnimContext::Load */
struct SAnimContextLoad {
    uchar unk1;
    uchar unk2;
    ushort unk3;
    ushort unk4;
    ushort unk5;
    SAnimContext animCtx(unk1, unk2, unk3, unk4, unk5);
};

/* Equivelant of SAbsContext::ReadIntoMemory */
struct SAbsContext(byte unkA, uint16 unkB, uint16 unkC, uint16 unkD, uint16 unkE) {
    char unk1[unkA * 6];
    char unk2[unkC];
    if (unkD) {
        char unk3[unkD];        
    }

    if (unkE) {
        char unk4[unkE];
    }

    SNodeSet nodeSet;
    char unk5[unkB * 4];
    uchar unk6;
};

/* Equivelant of SAbsContextLoad::Load */
struct SAbsContextLoad {
    uchar unk1;
    ushort unk2;
    ushort unk3;
    ushort unk4;
    ushort unk5;
    SAbsContext absContext(unk1, unk2, unk3, unk4, unk5);
};

struct CAssetHeader
{
    ushort typeID;
    ushort version;
};

struct NameHashList
{
    uint count;
    if (count > 0) {
        uint hash[count] <format = hex>;
        uint stringIDs[count];
    }
};

struct StringList
{
    uint stringTableSize;
    local uint pos <format=hex> = FTell();

    while (true)
    {
        if (FTell() > pos + stringTableSize - 5)
            break;

        CString text;
    }
    FSeek(pos + stringTableSize);
};

struct CPooledNameData
{
    StringList stringList;
    ushort unkCount1;
    ushort hashListCount;
    uint counters1[unkCount1];
    uint nameHashCounts[hashListCount];
    uint unk;
    //List of string hashes + indices
    NameHashList hashList[hashListCount]<optimize=false>;
};

struct Transform {
    ushort v;
    CTransform4f x;
};
struct SRenderContext {
    uint16 unk1;
    uint16 unk2;
    uint16 unk3;
    uint16 unk4;
    int32 unk5;
    union {
        struct {
            ushort unk[unk1];
            if (unk2 > 0) {
                ushort unk2[unk2];
            }
            if (unk3 > 0) {
                ushort unk3[unk3];
            }
            ushort segIDs[unk4];
            CTransform4f xfs[unk1 + 1];
            CTransform4f xfs2[unk4];
            char unkp[unk5];
        } data;
        char raw[(unk5 + (unk4 + unk1) * (sizeof(CTransform4f) + 2) + unk2 * 2 + unk3 * 2) + sizeof(CTransform4f)];
    } data;
};

struct CPooledName {
    ubyte hasName;
    if (hasName) {
        uint nameRef;
    }
};

struct SChannel {
    CPooledName pooledName;
    uint16 unk2;
    ubyte unk3;
    ubyte unk4;
    CGuid guid;
};

/* Equivelant of SChannelLoad::Load */
struct SChannelLoad {
    ubyte channelCount;
    if (channelCount) {
        SChannel channels[channelCount] <optimize = false>;
    }
};


struct SFragDecode {
    uint16 unk1;
    uint16 unk2;
    char data[unk2 * 2];
};

struct SStreamFragDecodeData {
    uint fragDecodeCount;
    if (fragDecodeCount) {
        SFragDecode fragDecodes[fragDecodeCount];
    }
};

struct SConstPool {
    uint16 unk1;
    uint16 unk2;
    float data[unk2];
};


struct SBaseInfo {
    ubyte type;
    ubyte unk1;
    uint16 unk2;
    ubyte unk3;
    ubyte unk4;
    if (unk4) {
        ubyte unk5;
    }
    ubyte unk6;
    if (unk6) {
        ubyte unk7;
    }
    CPooledName pooledName;
};

struct CAnimCompStream {
    uint32 unk1;
    uint16 unk2;
    uint16 unk3;
    uint32 unk4;
    float unk5;
    uint16 unk6;
    uint32 unk7;
    uint16 unk8;
    char data[unk1 - unk2];
};

struct CAnimSequence {
    uint32 unk1;
    uint32 unk2;
    ubyte unk3;
    ubyte unk4;
    struct {
        ubyte unk1;
        ubyte unk2;
        ubyte unk3;
        ushort unk4;
        uint unk5;
    } unk5[unk1];
    if (unk2) {
        char unk6[unk2];
    }
    float unk7;
};

struct CGridPointData(ubyte size) {
    ubyte unk1;
    ubyte unk2;
    ubyte unk3;
    char unk4[size];
    char unk5[unk2 ? size * 4 : 4];
};

struct CGridGeo2d {
    ubyte unk1;
    ubyte unk2;
    CGridPointData pointData(unk1);
    ubyte unk3;
    ubyte unk4;
    ubyte unk5;
    char unk6[8];
    char unk7[8];
    char unk8[unk3 * 4];
    char unk9[unk4 * 8];
    char unk10[unk5 * 4];
};

struct CGridGeo1d {
    ubyte unk1;
    ubyte unk2;
    CGridPointData pointData(unk1);
    float unk3;
    float unk4;
    char unk8[unk1 * 4];
};

struct CAnimGrid {
    uint32 unk1; // Read in CAnimGrid::Load
    ubyte gridType;
    switch (gridType) {
        case 0:
            break;
        case 1:
            CGridGeo1d grid;
            break;
        case 2:
            CGridGeo2d grid;
            break;
    }

    uint unk2;
    if (unk2 != 0) {
        uint unk3[unk2];
    }

    if (unk1 != 0) {
        uint unk4[unk1];
    }
};

struct CAnim {
    SBaseInfo baseInfo;
    switch(baseInfo.type) {
    case 0:
        CAnimCompStream anim;
        break;
    case 1:
        CAnimSequence anim;
        break;
    case 2:
        CAnimGrid anim;
        break;
    }
};

struct SModelNode {
    CPooledName name;
    uint32 unk1;
    uint32 unk2;
    CGuid unk4;
    CGuid modelId;
};

struct SSubChar(uint32 size) {
    CPooledName name;
    CGuid guid;
    uchar unk1;
    char unk2[unk1 * -12 + size];
    char unk3[unk1 * 12];
};

struct SSubCharData {
    uint16 unk1;
    if (unk1 != 0) {
        uint32 unk2[unk1];
    }
    uint16 unk3;
    local int i;
    if (unk1 != 0) {
        for (i = 0; i < unk1; ++i) {
            SSubChar subChar(unk2[i]);
        }
    }
};

struct SAnimParamNode {
    CGuid guid;
    uint unk1;
    CPASDatabase pasDatabase;
};

struct CAnimCollisionPrimSet {
    CStringFixed something; // CStringHashedCase
    uint unk1;
    CStringFixed strings[unk1] <optimize = false>; // CStringHashedCase
};
struct CAnimCollisionPrim {
    uint unk1;
    CStringFixed name;
    uint evalDataLen;
    CEvalId evalId;
    CGuid guid;
    char evalData[unk1];
};

struct SObjectTag {
    int type;
    CGuid guid;
};

struct CAnimCollisionPrimData {
    uint primCount;
    if (primCount) {
        CAnimCollisionPrim prims[primCount] <optimize = false>;
    }
    uint setCount;
    if (setCount) {
        CAnimCollisionPrimSet collisionPrimSet[setCount] <optimize = false>;
    }

    uint unk1;
    if (unk1) {
        CGuid guids2[unk1];
    }
};

struct CParamSet32 {
    uint unk1;
    uint unk2;
    uint unk3;

    char data[-(unk1 >> 3 & 1) & 0xffffffc0 | (unk1 & 0xf) << 2];
    char data2[(unk1 & 0xf | unk2 << 4) / 8];
};

struct CEffectState {
    ushort unk1;
    ushort unk2;
    if (unk1) {
        SObjectTag tags[unk1];
    }
    if (unk2) {
        CParamSet32 paramSets[unk2];
    }
};

struct CActionStream {
    short unk1;
    uchar actionFunc;
    if (unk1) {
        char data[unk1];
    }
};

struct CActionInfo {
    short unk1;
    short unk2;
};

struct CActionData {
    int unk1;
    short unk2;
    int unk3;
    int unk4;
    int unk5;
    uchar unk6;
    uchar unk7;
    uchar unk8;
    uchar unk9;
    if (unk1 > 0) {
        CActionStream streams[unk1] <optimize = false>;
        CActionInfo info[unk1] <optimize = false>;
    }

    if (unk3 > 0) {
        int unkInts[unk3];
    }

    if (unk2 > 0) {
        uchar eventIds[unk2 * 8];
    }

    if (unk4) {
        uint unk10[unk4];
        CString strings[unk4] <optimize = false>;
    }
};

struct CAnimTrans {
    uchar type;
    switch(type) {
    case 0:
        break;
    case 1:
        uint unk1;
        float unk2;
        break;
    case 2:
        float unk1;
        break;
    case 3:
        uint unk1;
        break;
    case 4:
        uint unk1;
        char data1[unk1 * 4];
        char data1[(unk1 + 12) * 4];
        break;
    }
};

struct CAnimTransFade {
    float unk1;
    float unk2;
    int unk3;
};
struct CTransAnimLink {
    short unk1;
    short unk2;
    short unk3;
    short unk4;
    uchar unk5;
};

struct CAnimTransTarget {
    uint unk1;
    ushort unk2;
    uchar unk3;
    uchar unk4;
    if (unk2) {
        CTransAnimLink links[unk2];
    }
};

struct CAnimTransFadeTarget {
    short unk1;
    short unk2;
    short unk3;
};

struct STransData {
    ushort unk1;
    ushort unk2;
    ushort unk3;
    ushort unk4;
    short unk5;
    short unk6;
    short unk7;
    short unk8;
    if (unk1 > 0) {
        CAnimTrans trans[unk1] <optimize = false>;
    }
    if (unk2 > 0) {
        CAnimTransFade transFades[unk2] <optimize = false>;
    }

    if (unk3 > 0) {
        CAnimTransTarget transTargets[unk3] <optimize = false>;
    }

    if (unk4 > 0) {
        CAnimTransFadeTarget transFadesTargets[unk4] <optimize = false>;
    }

    if (unk7 > 0) {
        float unk9[unk7];
    }

    if (unk8 > 0) {
        CGuid guids[unk8];
    }
};

struct SNode {
    short unk1;
    short unk2;
    char data[unk2];
};

struct CEventStreamDataSet {
    uint unk1;
    if (unk1 > 0)
        SNode nodes[unk1] <optimize = false>;
};

struct CCharInfo
{
    if (!isDKCTF)
    {
        CPooledNameData namePool;
    }
    byte unk1;
    byte unk2; //boolean
    char data[unk1 * 2];

    if (isDKCTF)
    {
        byte unk3;
        byte unk4;
        byte unk2[12];
        byte flags1;
        uint16 flags2;
    } else {
        SAnimContextLoad animCtxLoadDummy;
        // local int i;
        // local int id;
        // Printf("=== ANIM CTX ===\n");
        // for (i = 0; i < animCtxLoadDummy.animCtx.nodeSet.nodeCount; ++i) {
        //     id = animCtxLoadDummy.animCtx.nodeSet.nodeId[i];
        //     Printf("%s -> 0x%08X (0x%04X, 0x%04X)  -> %i\n", namePool.stringList.text[namePool.hashList[animCtxLoadDummy.animCtx.nodeSet.nameSet].stringIDs[i]].text, id, (id >> 16) & 0xFFFF, id & 0xFFFF, i);
        // }
        SAbsContextLoad absCtxLoadDummy;
        // Printf("=== ABS CTX ===\n");
        // for (i = 0; i < absCtxLoadDummy.absContext.nodeSet.nodeCount; ++i) {
        //     id = absCtxLoadDummy.absContext.nodeSet.nodeId[i];
        //     Printf("%s -> 0x%08X (0x%04X, 0x%04X) -> %i\n", namePool.stringList.text[namePool.hashList[absCtxLoadDummy.absContext.nodeSet.nameSet].stringIDs[i]].text, id, (id >> 16) & 0xFFFF, id & 0xFFFF, i);
        // }
        SRenderContext renderCtx;
        SChannelLoad channel;
        ubyte unk3;
        ubyte unk4;
        ubyte unk5;
        uint16 unk6;
        uint16 unk7;
        ubyte unk8;

        if (unk8) {
            SStreamFragDecodeData streamFragDecodeData;
        }

        ubyte unk9;
        if (unk9) {
            uint constPoolCount;
            if (constPoolCount) {
                SConstPool constPools[constPoolCount] <optimize = false>;
            }
        }

        uint16 unk10;

        if (unk6) {
            CAnim anims[unk6] <optimize = false>;
        }

        if (unk5 != 0) {
            struct SAnchorInfo {
                uint16 unk1;
                uint16 unk2;
                uint32 unk3;
                uint32 unk4;
            } anchors[unk5];
        }

        if (unk3 != 0) {
            SModelNode modelNodes[unk3] <optimize = false>;
        }

        SSubCharData subCharData;
        int16 unk12;
        uint16 unk13;

        char unkData[-((unk12 >> 15) & 1) & ~0x3FFFF | (unk12 & 0xFFFF) << 2];
        char unkData2[unk13];
        uint unk14;
        uint unk15;
        uchar unkData3[unk14 * 8];
        uchar unkData4[unk15];
        if (unk7) {
            SAnimParamNode paramNodes[unk7] <optimize = false>;
        }
        if (unk6) {
            CGuid guids[unk6];
            uint unk16[unk6];
        }
        uchar hasCollisionPrimitives;
        if (hasCollisionPrimitives) {
            CAnimCollisionPrimData collisionPrimData;
        }

        uchar hasEffectState;
        if (hasEffectState) {
            CEffectState effectState;
        }
        uchar hasActionData;
        if (hasActionData) {
            CActionData actionData;
        }

        uchar hasTransData;
        if (hasTransData) {
            STransData transData;
        }

        uchar hasEffectStreamDataSet;
        if (hasEffectStreamDataSet) {
            CEventStreamDataSet effectStreamDataSet;
        }
    }

};

struct CAnimationIdMap
{
    uint32 hashnodes;
    uint32 hash[hashnodes];
};

struct CCharacterModelSet
{
    if (ReadByte() == 0)
    {
        CStringFixed name;
    }
    else
    {
        CString name;
    }
    GUID skeletonID;
    CAABox aabox;
};

struct CAnimationInfo
{
    if (ReadByte() == 0)
    {
        CStringFixed name;
    }
    else
    {
        CString name;
    }
    GUID skeletonID;
    FourCC chunkID;
    uint32 unk;
    uint16 unk2[2];
    bool unk3;
    CAABox aabox;
};

struct FCharInfo
{
    CAssetHeader assetHeader;
    if (isDKCTF)
    {
        CCharInfo charInfo<optimize=false>;
        if (ReadByte() == 0)
        {
           CStringFixed name;
        }
        else
        {
          CString name;
        }
        GUID skeletonID;
        uint32 modelSets;
        for (charinfoi = 0; charinfoi < modelSets; charinfoi++)
        {
            CCharacterModelSet cms;
        }
        uint32 animInfos;
        for (charinfoi = 0; charinfoi < animInfos; charinfoi++)
        {
            CAnimationInfo cai;
        }
        if (charInfo.flags1 && charInfo.flags2 && 2000)
        {
            CAnimationIdMap caim;
        }
        if (charInfo.flags1 && charInfo.flags2 && 8000)
        {
            //CTransitionInfo cti;
        }
        if (charInfo.flags1 && charInfo.flags2 && 4000)
        {
            //uint32 ctis;
            //CCharacterTransformBits cti[ctis];
        }
        //CAABox endaabox;
    }
    else
    {
        byte count;
        CCharInfo charInfo[count] <optimize=false>;
    }
};


#endif// _CCHARINFO