DOF/sqr/User/Asset/AssetManager.nut

/*
文件名:AssetManager.nut
路径:User/Asset/AssetManager.nut
创建日期:2024-11-24	08:44
文件用途: 资源管理器
*/
class _AssetManager_ {

    //角色列表
    CharacterList = null;
    //角色信息表
    CharacterInfoList = null;
    //角色经验表
    CharacterExptable = null;
    //技能信息表
    SkillList = null;
    //技能树信息表
    SkillTreeList = null;
    //地图列表
    MapList = null;
    //城镇列表
    TownList = null;
    //装备列表
    EquipmentList = null;
    //消耗品列表
    StackableList = null;
    //NPC列表
    NpcList = null;
    //NPC商店列表
    NpcShopList = null;


    //杂项配置信息
    EtcConfig = null;
    //属性脚本
    AttributeScript = null;

    function InitTownList() {
        TownList = ScriptData.GetFileData("town/town.lst", function(DataTable, Data) {
            while (!Data.Eof()) {
                local Key = Data.Get();
                //注册城镇列表 路径写入 数据未读取
                DataTable.rawset(Key, {
                    Path = Data.Get(),
                    Data = null
                });
            }
            if (_DEBUG_) print("加载城镇List完成, 共" + DataTable.len() + "个");
        });
    }

    function InitMapList() {
        MapList = ScriptData.GetFileData("map/map.lst", function(DataTable, Data) {
            while (!Data.Eof()) {
                local Key = Data.Get();
                DataTable.rawset(Key, Data.Get());
            }
            if (_DEBUG_) print("加载地图List完成, 共" + DataTable.len() + "个");
        });
    }

    function InitCharacter() {
        CharacterList = ScriptData.GetFileData("character/character.lst", function(DataTable, Data) {
            local dirpath = DataTable.filepath.slice(0, DataTable.filepath.lastfind("/") + 1);
            while (!Data.Eof()) {
                local Index = Data.Get();
                local Path = Data.Get();
                DataTable.rawset(Index, dirpath + Path.tolower());
            }
            if (_DEBUG_) print("加载角色List完成, 共" + DataTable.len() + "个");
        });
        CharacterExptable = ScriptData.GetFileData("character/exptable.tbl", function(DataTable, Data) {
            local Level = 1;
            while (!Data.Eof()) {
                local Exp = Data.Get();
                DataTable.rawset(Level, Exp.tointeger());
                Level += 1;
            }
        })
        CharacterInfoList = [];
        foreach(Index, Path in CharacterList) {
            if (Index == "filepath") continue;
            local Info = ScriptData.GetFileData(Path, function(DataTable, Data) {
                local dirpath = DataTable.filepath.slice(0, DataTable.filepath.lastfind("/") + 1);
                while (!Data.Eof()) {
                    local Key = Data.Get();
                    if (Key == "[job]") {
                        DataTable.job <- Data.Get().slice(1, -1);
                    } else if (Key == "[growtype name]") {
                        DataTable.growtype <- array(6, {});
                        for (local i = 0; i< 5; i++) {
                            local name = Data.Get();
                            DataTable.growtype[i].name <- name;
                        }
                    }
                    //默认时装
                    else if (Key == "[default avatar]") {
                        DataTable.default_avatar <- [];
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/default avatar]") break;
                            DataTable.default_avatar.append(Ret);
                        }
                    }
                    //基础Ani
                    else if (Key == "[waiting motion]" || Key == "[move motion]" || Key == "[sit motion]" || Key == "[damage motion 1]" || Key == "[damage motion 2]" || Key == "[down motion]" || Key == "[overturn motion]" || Key == "[jump motion]" || Key == "[jumpattack motion]" || Key == "[rest motion]" || Key == "[throw motion 1-1]" || Key == "[throw motion 1-2]" || Key == "[throw motion 2-1]" || Key == "[throw motion 2-2]" || Key == "[throw motion 3-1]" || Key == "[throw motion 3-2]" || Key == "[throw motion 4-1]" || Key == "[throw motion 4-2]" || Key == "[dash motion]" || Key == "[dashattack motion]" || Key == "[getitem motion]" || Key == "[buff motion]" || Key == "[simple rest motion]" || Key == "[simple move motion]" || Key == "[back motion]") {
                        local RealKey = Key.slice(1, Key.len() - 1);
                        DataTable[RealKey] <- dirpath + Data.Get().tolower();
                    }
                    //普攻Ani
                    else if (Key == "[attack motion]") {
                        DataTable.attack_motion <- [];
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/attack motion]") break;
                            DataTable.attack_motion.append(dirpath + Ret.tolower());
                        }
                    }
                    //进阶Ani
                    else if (Key == "[etc motion]") {
                        DataTable.etc_motion <- [];
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/etc motion]") break;
                            DataTable.etc_motion.append(dirpath + Ret.tolower());
                        }
                    }
                    //基础Atk
                    else if (Key == "[jumpattack info]" || Key == "[dashattack info]") {
                        local RealKey = Key.slice(1, Key.len() - 1);
                        DataTable[RealKey] <- (dirpath + Data.Get().tolower());
                    }
                    //普攻Atk
                    else if (Key == "[attack info]") {
                        DataTable.attack_info <- [];
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/attack info]") break;
                            DataTable.attack_info.append(dirpath + Ret.tolower());
                        }
                    }
                    //进阶Atk
                    else if (Key == "[etc attack info]") {
                        DataTable.etc_attack_info <- [];
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/etc attack info]") break;
                            DataTable.etc_attack_info.append(dirpath + Ret.tolower());
                        }
                    }
                    //属性
                    else if (Key == "[growtype attribute]") {
                        DataTable.Attribute <- [];
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/growtype attribute]") break;
                            local attrtable = ScriptData.GetFileData(Ret, function(DataTable, Data) {
                                while (!Data.Eof()) {
                                    local Key = Data.Get();
                                    //基础属性
                                    if (AttributeScript.rawin(Key)) {
                                        DataTable[AttributeScript[Key]] <- Data.Get();
                                    }
                                    //名称
                                    else if (Key == "[name]") {
                                        DataTable.name <- Data.Get();
                                    }
                                }
                            }.bindenv(this));
                            DataTable.Attribute.push(attrtable);
                        }
                    }
                }
                // print(DataTable);
                if (_DEBUG_) print("初始化角色" + DataTable.job);
            }.bindenv(this));
            CharacterInfoList.push(Info);
        }
    }

    function InitSkill() {
        SkillList = ScriptData.GetFileData("skill/skilllist.lst", function(DataTable, Data) {
            while (!Data.Eof()) {
                local Key = Data.Get();
                //注册装备列表 路径写入 数据未读取
                DataTable.rawset(Key, ScriptData.GetFileData("skill/" + Data.Get().tolower(), function(DataTableA, DataA) {
                    while (!DataA.Eof()) {
                        local SkillIndex = DataA.Get();
                        //注册装备列表 路径写入 数据未读取
                        DataTableA.rawset(SkillIndex, DataA.Get());
                    }
                    if (_DEBUG_) print("加载职业技能" + Key + "List完成, 共" + DataTableA.len() + "个");
                }));
            }
            if (_DEBUG_) print("加载技能List完成, 共" + DataTable.len() + "个");
        })
    }

    function InitJobSkillTree(Path) {
        local ConfigBuffer = ScriptData.GetFileData("clientonly/" + Path, function(DataTable, Data) {
            while (!Data.Eof()) {
                local Key = Data.Get();
                if (Key == "[skill info]") {
                    Data.Get();
                    local SkillIndex = Data.Get();
                    DataTable.rawset(SkillIndex, {});
                    while (true) {
                        local Ret = Data.Get();
                        if (Ret == "[/skill info]") break;
                        //技能图标位置
                        if (Ret == "[icon pos]") {
                            DataTable[SkillIndex].IconPos <- {
                                x = Data.Get(),
                                y = Data.Get()
                            }
                        }
                    }
                }
            }
        });
        ConfigBuffer.rawdelete("filepath");
        return ConfigBuffer;
    }

    function InitSkillTree() {
        //先读职业技能树list  在读转职职业list
        SkillTreeList = ScriptData.GetFileData("clientonly/skilltree.lst", function(DataTable, Data) {
            while (!Data.Eof()) {
                local Key = Data.Get();
                //注册技能树列表 路径写入 数据未读取
                DataTable.rawset(Key, ScriptData.GetFileData("clientonly/" + Data.Get().tolower(), function(DataTableA, DataA) {
                    while (!DataA.Eof()) {
                        local GrowJob = DataA.Get();
                        local GrowJobSkillTreePath = DataA.Get();
                        local Config = InitJobSkillTree(GrowJobSkillTreePath);
                        DataTableA.rawset(GrowJob, Config);
                    }
                }.bindenv(this)));
            }
            if (_DEBUG_) print("加载技能树List完成, 共" + DataTable.len() + "个职业技能树");
        }.bindenv(this))
    }

    function InitEquipmentList() {
        EquipmentList = ScriptData.GetFileData("equipment/equipment.lst", function(DataTable, Data) {
            while (!Data.Eof()) {
                local Key = Data.Get();
                //注册装备列表 路径写入 数据未读取
                DataTable.rawset(Key, {
                    Path = Data.Get(),
                    Data = null
                });
            }
            if (_DEBUG_) print("加载装备List完成, 共" + DataTable.len() + "个");
        });
    }

    function InitStackableList() {
        StackableList = ScriptData.GetFileData("stackable/stackable.lst", function(DataTable, Data) {
            while (!Data.Eof()) {
                local Key = Data.Get();
                //注册装备列表 路径写入 数据未读取
                DataTable.rawset(Key, {
                    Path = Data.Get(),
                    Data = null
                });
            }
            if (_DEBUG_) print("加载消耗品List完成, 共" + DataTable.len() + "个");
        });
    }

    function InitNpcList() {
        NpcList = ScriptData.GetFileData("npc/npc.lst", function(DataTable, Data) {
            while (!Data.Eof()) {
                local Key = Data.Get();
                //注册NPC列表 路径写入 数据未读取
                DataTable.rawset(Key, {
                    Path = Data.Get(),
                    Data = null
                });
            }
            if (_DEBUG_) print("加载NPCList完成, 共" + DataTable.len() + "个");
        });
    }

    function InitNpcShopList() {
        NpcShopList = ScriptData.GetFileData("itemshop/itemshop.lst", function(DataTable, Data) {
            while (!Data.Eof()) {
                local Key = Data.Get();
                //注册NPC商店列表 路径写入 数据未读取
                DataTable.rawset(Key, {
                    Path = Data.Get(),
                    Data = null
                });
            }
            if (_DEBUG_) print("加载NPC商店List完成, 共" + DataTable.len() + "个");
        });
    }


    function InitEtcConfig() {
        //初始化装备信息标签tag配置
        {
            EtcConfig.ItemInfoTag <- ScriptData.GetFileData("etc/iteminfo.etc", function(DataTable, Data) {
                while (!Data.Eof()) {
                    local Pack = Data.Get();
                    //名称 grade 套装Id 稀有度 最低穿戴登记 重量
                    if (Pack == "[item group name table]") {
                        DataTable.item_group_name_table <- {};
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/item group name table]") break;
                            DataTable.item_group_name_table.rawset(Ret, Data.Get());
                        }
                    } else if (Pack == "[elemental property tag]") {
                        DataTable.elemental_property_tag <- {};
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/elemental property tag]") break;
                            DataTable.elemental_property_tag.rawset(Ret, Data.Get());
                        }
                    } else if (Pack == "[rarity frame color idx]") {
                        DataTable.rarityframe_color_idx <- [];
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/rarity frame color idx]") break;
                            DataTable.rarityframe_color_idx.push(Ret);
                        }
                    } else if (Pack == "[rarity name tag]") {
                        DataTable.rarity_name_tag <- [];
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/rarity name tag]") break;
                            DataTable.rarity_name_tag.push(Ret);
                        }
                    } else if (Pack == "[rarity color]") {
                        DataTable.rarity_color <- [];
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/rarity color]") break;
                            local color = HexStringToInt(Ret);
                            DataTable.rarity_color.push(color);
                        }
                    } else if (Pack == "[percentage text]") {
                        DataTable.percentage_text <- [];
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/percentage text]") break;
                            DataTable.percentage_text.push(Ret);
                        }
                    } else if (Pack == "[percentage range boundaries]") {
                        DataTable.percentage_range_boundaries <- [];
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/percentage range boundaries]") break;
                            DataTable.percentage_range_boundaries.push(Ret);
                        }
                    } else if (Pack == "[trade type text]") {
                        DataTable.trade_type_text <- [];
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/trade type text]") break;
                            DataTable.trade_type_text.push(Ret);
                        }
                    } else if (Pack == "[trade type color]") {
                        DataTable.trade_type_color <- [];
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/trade type color]") break;
                            local color = HexStringToInt(Ret);
                            DataTable.trade_type_color.push(color);
                        }
                    }
                }
            });
        }
        //初始化NPC功能对应配置
        {
            EtcConfig.NpcRole <- ScriptData.GetFileData("etc/npcroleconfig.dat", function(DataTable, Data) {
                while (!Data.Eof()) {
                    local Pack = Data.Get();
                    //名称 grade 套装Id 稀有度 最低穿戴登记 重量
                    if (Pack == "[config]") {
                        while (true) {
                            local Ret = Data.Get();
                            if (Ret == "[/config]") break;
                            DataTable[Ret] <- {
                                imgidx = Data.Get(),
                                name = Data.Get(),
                                namecolor = HexStringToInt(Data.Get()),
                                iconpath = Data.Get(),
                                iconidx = Data.Get(),
                            }
                        }
                    }
                }
            });
        }

    }

    constructor() {
        EtcConfig = {};
        AttributeScript = {};
        AttributeScript.rawset("[HP MAX]", "HPMax");
        AttributeScript.rawset("[MP MAX]", "MPMax");
        AttributeScript.rawset("[HP regen speed]", "HPRegenSpeed");
        AttributeScript.rawset("[MP regen speed]", "MPRegenSpeed");
        AttributeScript.rawset("[jump power]", "JumpPower");
        AttributeScript.rawset("[hit recovery]", "HitRecovery");
        AttributeScript.rawset("[stuck]", "Stuck");
        AttributeScript.rawset("[stuck resistance]", "StuckResistance");
        AttributeScript.rawset("[physical attack]", "PhysicalAttack");
        AttributeScript.rawset("[magical attack]", "MagicalAttack");
        AttributeScript.rawset("[physical defense]", "PhysicalDefense");
        AttributeScript.rawset("[magical defense]", "MagicalDefense");
        AttributeScript.rawset("[all elemental attack]", "AllElementalAttack");
        AttributeScript.rawset("[dark attack]", "DarkAttack");
        AttributeScript.rawset("[light attack]", "LightAttack");
        AttributeScript.rawset("[water attack]", "WaterAttack");
        AttributeScript.rawset("[fire attack]", "FireAttack");
        AttributeScript.rawset("[equipment physical attack]", "EquipmentPhysicalAttack");
        AttributeScript.rawset("[equipment magical attack]", "EquipmentMagicalAttack");
        AttributeScript.rawset("[separate attack]", "SeparateAttack");
        AttributeScript.rawset("[equipment physical defense]", "EquipmentPhysicalDefense");
        AttributeScript.rawset("[equipment magical defense]", "EquipmentMagicalDefense");
        AttributeScript.rawset("[attack speed]", "AttackSpeed");
        AttributeScript.rawset("[cast speed]", "CastSpeed");
        AttributeScript.rawset("[move speed]", "MoveSpeed");
        AttributeScript.rawset("[jump speed]", "JumpSpeed");
        AttributeScript.rawset("[physical critical hit]", "PhysicalCriticalHit");
        AttributeScript.rawset("[magical critical hit]", "MagicalCriticalHit");
        AttributeScript.rawset("[dark resistance]", "DarkResistance");
        AttributeScript.rawset("[light resistance]", "LightResistance");
        AttributeScript.rawset("[water resistance]", "WaterResistance");
        AttributeScript.rawset("[fire resistance]", "FireResistance");
        AttributeScript.rawset("[elemental property]", "ElementalProperty");

        //初始化城镇列表
        InitTownList();
        //初始化地图列表
        InitMapList();
        //初始化角色
        InitCharacter();
        //初始化技能
        InitSkill();
        //初始化技能树
        InitSkillTree();
        //初始化装备列表
        InitEquipmentList();
        //初始化消耗品列表
        InitStackableList();
        //初始化NPC列表
        InitNpcList();
        //初始化NPC商店列表
        InitNpcShopList();

        //初始化杂项配置信息
        InitEtcConfig();



        getroottable().AssetManager <- this;
    }


    //Public::

    //获取装备信息
    function GetEquipment(Idx) {
        //如果没有这件装备则返回
        if (!(EquipmentList.rawin(Idx))) return;
        //如果装备数据已经读取过存在了则直接返回
        if (EquipmentList[Idx].Data) return EquipmentList[Idx].Data;
        local Path = EquipmentList[Idx].Path;
        local m_data = ScriptData.GetFileData("equipment/" + Path, function(DataTable, Data) {
            DataTable.DirPath <- DataTable.filepath.slice(0, DataTable.filepath.lastfind("/") + 1);
            while (!Data.Eof()) {
                local Pack = Data.Get();
                //名称 grade 套装Id 稀有度 最低穿戴登记 重量 组名 购买价格 出售价格 耐久 描述
                if (Pack == "[name]" || Pack == "[part set index]" || Pack == "[grade]" || Pack == "[rarity]" || Pack == "[minimum level]" || Pack == "[weight]" || Pack == "[item group name]" || Pack == "[price]" || Pack == "[repair price]" || Pack == "[value]" || Pack == "[durability]" || Pack == "[flavor text]") {
                    local RealKey = Pack.slice(1, -1);
                    DataTable[RealKey] <- Data.Get();
                }
                //属性
                else if (AttributeScript.rawin(Pack)) {
                    //三攻 和 双防 要读取两个值因为是浮动数组
                    if (Pack == "[equipment physical attack]" || Pack == "[equipment magical attack]" || Pack == "[separate attack]" || Pack == "[equipment physical defense]" || Pack == "[equipment magical defense]") {
                        DataTable[AttributeScript[Pack]] <- [Data.Get(), Data.Get()];
                    } else {
                        DataTable[AttributeScript[Pack]] <- Data.Get();
                    }
                }
                //适用角色
                else if (Pack == "[usable job]") {
                    DataTable.usable_job <- [];
                    while (true) {
                        local Ret = Data.Get();
                        if (Ret == "[/usable job]") break;
                        DataTable.usable_job.append(Ret.slice(1, -1).tolower());
                    }
                }
                //隐藏图层
                else if (Pack == "[hide layer]") {
                    DataTable.hide_layer <- [];
                    while (true) {
                        local Ret = Data.Get();
                        if (Ret == "[/hide layer]") break;
                        DataTable.hide_layer.append(Ret);
                    }
                }
                //图标
                else if (Pack == "[icon]") {
                    DataTable.icon <- {};
                    local Ret = Data.Get();
                    DataTable.icon.path <- "sprite/" + Ret.tolower();
                    Ret = Data.Get();
                    DataTable.icon.index <- Ret.tointeger();
                }
                //装备类型
                else if (Pack == "[equipment type]") {
                    DataTable.type <- {};
                    local Ret = Data.Get();
                    DataTable.type.path <- Ret.tolower().slice(1, -1);
                    Ret = Data.Get();
                    DataTable.type.index <- Ret.tointeger();
                }
                //光环效果
                else if (Pack == "[aurora graphic effects]") {
                    DataTable.aurora_effects <- [];
                    local Count = Data.Get();
                    for (local i = 0; i< Count; i++) {
                        local T = {
                            type = Data.Get(),
                            path = Data.Get().tolower()
                        }
                        DataTable.aurora_effects.push(T);
                    }
                }
                //Expand Ani
                else if (Pack == "[expand ani]") {
                    if (!(DataTable.rawin("Ani"))) DataTable["Ani"] <- {};
                    local DataBuffer = {};
                    DataBuffer.layer_variation <- [];

                    while (true) {
                        local Ret = Data.Get();
                        if (Ret == "[/expand ani]") break;
                        if (Ret == "[variation]") {
                            DataBuffer.variation <- [Data.Get(), Data.Get()];
                        } else if (Ret == "[layer variation]") {
                            local InfoBuf = {};
                            InfoBuf.Zorder <- Data.Get();
                            InfoBuf.Path <- Data.Get();
                            DataBuffer.layer_variation.append(InfoBuf);
                        } else if (Ret == "[expand path]") {
                            DataTable["expand_path"] <- Data.Get();
                        }
                    }

                    foreach(Job in DataTable.usable_job) {
                        DataTable["Ani"]["Ani_" + Job] <- {};
                        DataTable["Ani"]["Ani_" + Job].variation <- sq_DeepCopy(DataBuffer.variation);
                        DataTable["Ani"]["Ani_" + Job].layer_variation <- sq_DeepCopy(DataBuffer.layer_variation)
                    }
                }
                //Ani
                else if (Pack == "[animation job]") {
                    local Job = Data.Get().slice(1, -1);
                    if (!(DataTable.rawin("Ani"))) DataTable["Ani"] <- {};
                    DataTable["Ani"]["Ani_" + Job] <- {};
                    Data.Get();

                    local Index1 = Data.Get();
                    local Index2 = Data.Get();
                    DataTable["Ani"]["Ani_" + Job].variation <- [Index1, Index2];
                    DataTable["Ani"]["Ani_" + Job].layer_variation <- [];

                    while (true) {
                        local Ret = Data.Get();
                        if (Ret == "[animation job]" || (endswith(Ret, "]") && Ret != "[equipment ani script]" && Ret != "[layer variation]")) {
                            Data.Pos--;
                            break;
                        } else if (Ret == "[layer variation]") {
                            local InfoBuf = {};
                            InfoBuf.Zorder <- Data.Get();
                            InfoBuf.Path <- Data.Get();
                            DataTable["Ani"]["Ani_" + Job].layer_variation.append(InfoBuf);
                        }
                    }
                }
            }
        }.bindenv(this));
        EquipmentList[Idx].Data = m_data;
        return m_data;
    }

    //获取消耗品信息
    function GetStackable(Idx) {
        //如果没有这件消耗品则返回
        if (!(StackableList.rawin(Idx))) return;
        //如果装备数据已经读取过存在了则直接返回
        if (StackableList[Idx].Data) return StackableList[Idx].Data;
        local Path = StackableList[Idx].Path;
        local m_data = ScriptData.GetFileData("stackable/" + Path, function(DataTable, Data) {
            DataTable.DirPath <- DataTable.filepath.slice(0, DataTable.filepath.lastfind("/") + 1);
            while (!Data.Eof()) {
                local Pack = Data.Get();
                //名称
                if (Pack == "[name]" || Pack == "[item group name]" || Pack == "[explain]") {
                    local RealKey = Pack.slice(1, -1);
                    DataTable[RealKey] <- Data.Get();
                }
                //适用角色
                else if (Pack == "[usable job]") {
                    DataTable.usable_job <- [];
                    while (true) {
                        local Ret = Data.Get();
                        if (Ret == "[/usable job]") break;
                        DataTable.usable_job.append(Ret.slice(1, -1).tolower());
                    }
                }
                //图标
                else if (Pack == "[icon]") {
                    DataTable.icon <- {};
                    local Ret = Data.Get();
                    DataTable.icon.path <- "sprite/" + Ret.tolower();
                    Ret = Data.Get();
                    DataTable.icon.index <- Ret.tointeger();
                }
                //消耗品类型
                else if (Pack == "[stackable type]") {
                    DataTable.type <- {};
                    local Ret = Data.Get();
                    DataTable.type.path <- Ret.tolower().slice(1, -1);
                    Ret = Data.Get();
                    DataTable.type.index <- Ret.tointeger();
                }
                //交易类型
                else if (Pack == "[attach type]") {
                    local Ret = Data.Get();
                    if (Ret == "[free]") DataTable.trade_type <- 0;
                    else if (Ret == "[trade]") DataTable.trade_type <- 1;
                    else if (Ret == "[sealing]") DataTable.trade_type <- 2;
                    else if (Ret == "[account]") DataTable.trade_type <- 3;
                }
            }
        });
        StackableList[Idx].Data = m_data;
        return m_data;
    }

    //获取NPC信息
    function GetNpc(Idx) {
        //如果没有这个NPC则返回
        if (!(NpcList.rawin(Idx))) return;
        //如果NPC数据已经读取过存在了则直接返回
        if (NpcList[Idx].Data) return NpcList[Idx].Data;
        local Path = NpcList[Idx].Path;
        local m_data = ScriptData.GetFileData("npc/" + Path, function(DataTable, Data) {
            DataTable.DirPath <- DataTable.filepath.slice(0, DataTable.filepath.lastfind("/") + 1);
            while (!Data.Eof()) {
                local Pack = Data.Get();
                //各种头像
                if (Pack == "[small face]" || Pack == "[big face]" || Pack == "[popup face]") {
                    local RealKey = Pack.slice(1, Pack.find(" face")) + "_face";
                    DataTable[RealKey] <- {
                        img = "sprite/" + Data.Get().tolower(),
                        idx = Data.Get()
                    }
                } else if (Pack == "[field animation]") {
                    DataTable.field_animation <- DataTable.DirPath + Data.Get().tolower();
                } else if (Pack == "[field wav]") {
                    DataTable.field_wav <- Data.Get();
                } else if (Pack == "[popup wav]") {
                    DataTable.popup_wav <- [Data.Get(), Data.Get()];
                } else if (Pack == "[name]") {
                    DataTable.name <- Data.Get();
                } else if (Pack == "[field name]") {
                    DataTable.field_name <- Data.Get();
                }
                //功能
                else if (Pack == "[role]") {
                    DataTable.role <- {};
                    while (true) {
                        local Ret = Data.Get();
                        if (Ret == "[/role]") break;
                        DataTable.role.rawset(Ret.slice(1, -1).tolower(), Data.Get());
                    }
                }
            }
        });
        NpcList[Idx].Data = m_data;
        return m_data;
    }

    //获取NPC商店信息
    function GetNpcShop(Idx) {
        //如果没有这个商店则返回
        if (!(NpcShopList.rawin(Idx))) return;
        //如果商店数据已经读取过存在了则直接返回
        if (NpcShopList[Idx].Data) return NpcShopList[Idx].Data;
        local Path = NpcShopList[Idx].Path;
        local m_data = ScriptData.GetFileData("itemshop/" + Path, function(DataTable, Data) {
            DataTable.DirPath <- DataTable.filepath.slice(0, DataTable.filepath.lastfind("/") + 1);
            DataTable.PageList <- [];
            DataTable.PageNameList <- [];
            while (!Data.Eof()) {
                local Pack = Data.Get();
                //商店信息
                if (Pack == "[page]") {
                    local ItemList = [];
                    DataTable.PageNameList.push(Data.Get());
                    while (true) {
                        local Buffer = Data.Get();
                        if (Buffer == "[/page]") break;
                        local ItemInfo = {};
                        ItemInfo.Id <- Buffer;
                        ItemInfo.Cera <- Data.Get();
                        ItemInfo.CeraPoint <- Data.Get();
                        ItemInfo.Gold <- Data.Get();
                        ItemInfo.Material <- Data.Get();
                        ItemInfo.MaterialCount <- Data.Get();
                        ItemList.push(ItemInfo);
                    }
                    DataTable.PageList.push(ItemList);
                } else if (Pack == "[name]") {
                    DataTable.name <- Data.Get();
                }
            }
        });
        NpcList[Idx].Data = m_data;
        return m_data;
    }

    //获取技能信息
    function GetSkill(Job, Idx) {
        //如果没有这个技能则返回
        if (!(SkillList.rawin(Job))) return;
        if (!(SkillList[Job].rawin(Idx))) return;
        //如果技能数据已经读取过存在了则直接返回
        if (typeof SkillList[Job][Idx] == "table") return SkillList[Job][Idx];
        local Path = SkillList[Job][Idx];
        local m_data = ScriptData.GetFileData("skill/" + Path, function(DataTable, Data) {
            DataTable.DirPath <- DataTable.filepath.slice(0, DataTable.filepath.lastfind("/") + 1);
            while (!Data.Eof()) {
                local Pack = Data.Get();
                if (Pack == "[command key explain]" || Pack == "[basic explain]" || Pack == "[explain]" || Pack == "[name]" || Pack == "[name2]" || Pack == "[required level]" || Pack == "[required level range]" || Pack == "[skill class]" || Pack == "[maximum level]" || Pack == "[skill fitness second growtype]") {
                    DataTable[Pack.slice(1, -1)] <- Data.Get();
                }
                //技能类型
                else if (Pack == "[type]") {
                    local Type = Data.Get();
                    if (Type == "[active]") {
                        DataTable.type <- 0;
                    } else if (Type == "[passive]") {
                        DataTable.type <- 0;
                    }
                }
                //技能消耗道具
                else if (Pack == "[consume item]") {
                    DataTable.consume_item <- [];
                    while (true) {
                        local Ret = Data.Get();
                        if (Ret == "[/consume item]") break;
                        DataTable.consume_item.push(Ret);
                        DataTable.consume_item.push(Data.Get());
                        DataTable.consume_item.push(Data.Get());
                    }
                }
                //各职业是否可学习
                else if (Pack == "[skill fitness growtype]") {
                    DataTable.skill_fitness_growtype <- {};
                    while (true) {
                        local Ret = Data.Get();
                        if (Ret == "[/skill fitness growtype]") break;
                        DataTable.skill_fitness_growtype.rawset(Ret, true);
                    }
                }
                //图标
                else if (Pack == "[icon]") {
                    DataTable.icon <- {};
                    local Ret = Data.Get();
                    DataTable.icon.path <- "sprite/" + Ret.tolower();
                    Ret = Data.Get();
                    DataTable.icon.index <- Ret.tointeger();
                }
                //技能指令
                else if (Pack == "[command]") {
                    DataTable.command <- [];
                    while (true) {
                        local Ret = Data.Get();
                        if (Ret == "[/command]") break;
                        DataTable.command.push(Ret);
                    }
                }
                //技能属性
                else if (Pack == "[level property]") {
                    DataTable.level_property <- {};
                    DataTable.level_property.data <- [];
                    Data.Get();
                    Data.Get();
                    local ExplainBuffer = Data.Get();
                    ExplainBuffer = String.ReplaceString(ExplainBuffer, "<int>", "%d");
                    ExplainBuffer = String.ReplaceString(ExplainBuffer, "<float1>", "%.1f");
                    ExplainBuffer = String.ReplaceString(ExplainBuffer, "<float2>", "%.2f");
                    DataTable.level_property.explain <- ExplainBuffer;
                    while (true) {
                        local Ret = Data.Get();
                        if (Ret == "[/level property]") break;
                        DataTable.level_property.data.push(Ret);
                    }
                }
                //地下城数据
                else if (Pack == "[dungeon]") {
                    DataTable.dungeon_data <- {};
                    DataTable.dungeon_data.consume_mp <- 0;
                    while (true) {
                        local Ret = Data.Get();
                        if (Ret == "[/dungeon]") break;
                        if (Ret == "[cool time]") {
                            DataTable.dungeon_data.cooltime <- [Data.Get(), Data.Get()];
                        } else if (Ret == "[consume MP]") {
                            DataTable.dungeon_data.consume_mp <- [Data.Get(), Data.Get()];
                        } else if (Ret == "[casting time]") {
                            DataTable.dungeon_data.casting_time <- [Data.Get(), Data.Get()];
                        } else if (Ret == "[static data]") {
                            DataTable.dungeon_data.static_data <- [];
                            while (true) {
                                local Ret2 = Data.Get();
                                if (Ret2 == "[/static data]") break;
                                DataTable.dungeon_data.static_data.push(Ret2);
                            }
                        } else if (Ret == "[level info]") {
                            local ListCount = Data.Get();
                            DataTable.dungeon_data.level_info <- [];

                            while (true) {
                                local Ret2 = Data.Get();
                                if (Ret2 == "[/level info]") break;
                                local ArrBuffer = [Ret2];
                                for (local i = 0; i< ListCount - 1; i++) {
                                    ArrBuffer.push(Data.Get());
                                }
                                DataTable.dungeon_data.level_info.push(ArrBuffer);
                            }
                        }

                    }
                }
            }
        })
        SkillList[Job][Idx] = m_data;
        return m_data;
    }

    //获取指定职业的技能树配置
    function GetSkillTreeByJob(Job, GrowType) {
        if (SkillTreeList.rawin(Job) && SkillTreeList[Job].rawin(GrowType)) {
            return SkillTreeList[Job][GrowType];
        }
        error("没有找到指定职业的技能树配置");
    }
}