简化配置表读取

2026-02-04 14:22:26 +08:00 · 2023-03-16 16:26:14 +08:00
parent 2a3ce25898
commit 5e5492943d
51 changed files with 418 additions and 2560 deletions
--- a/gdconf/avatar_costume_data.go
+++ b/gdconf/avatar_costume_data.go
@@ -1,28 +1,19 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // AvatarCostumeData 角色时装配置表
 type AvatarCostumeData struct {
-	CostumeID int32 `csv:"CostumeID"`        // 时装ID
-	ItemID    int32 `csv:"ItemID,omitempty"` // 道具ID
+	CostumeID int32 `csv:"时装ID"`
+	ItemID    int32 `csv:"道具ID,omitempty"`
 }

 func (g *GameDataConfig) loadAvatarCostumeData() {
 	g.AvatarCostumeDataMap = make(map[int32]*AvatarCostumeData)
-	data := g.readCsvFileData("AvatarCostumeData.csv")
-	var avatarCostumeDataList []*AvatarCostumeData
-	err := csvutil.Unmarshal(data, &avatarCostumeDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	avatarCostumeDataList := make([]*AvatarCostumeData, 0)
+	readTable[AvatarCostumeData](g.tablePrefix+"AvatarCostumeData.txt", &avatarCostumeDataList)
 	for _, avatarCostumeData := range avatarCostumeDataList {
 		// 屏蔽默认时装
 		if avatarCostumeData.ItemID == 0 {
--- a/gdconf/avatar_data.go
+++ b/gdconf/avatar_data.go
@@ -3,32 +3,29 @@ package gdconf
 import (
 	"fmt"
 	"os"
-	"strconv"
-	"strings"

 	"hk4e/pkg/endec"
 	"hk4e/pkg/logger"

 	"github.com/hjson/hjson-go/v4"
-	"github.com/jszwec/csvutil"
 )

 // AvatarData 角色配置表
 type AvatarData struct {
-	AvatarId              int32   `csv:"AvatarId"`                        // ID
-	HpBase                float32 `csv:"HpBase,omitempty"`                // 基础生命值
-	AttackBase            float32 `csv:"AttackBase,omitempty"`            // 基础攻击力
-	DefenseBase           float32 `csv:"DefenseBase,omitempty"`           // 基础防御力
-	Critical              float32 `csv:"Critical,omitempty"`              // 暴击率
-	CriticalHurt          float32 `csv:"CriticalHurt,omitempty"`          // 暴击伤害
-	QualityType           int32   `csv:"QualityType,omitempty"`           // 角色品质
-	ConfigJson            string  `csv:"ConfigJson,omitempty"`            // 战斗config
-	InitialWeapon         int32   `csv:"InitialWeapon,omitempty"`         // 初始武器
-	WeaponType            int32   `csv:"WeaponType,omitempty"`            // 武器种类
-	SkillDepotId          int32   `csv:"SkillDepotId,omitempty"`          // 技能库ID
-	PromoteId             int32   `csv:"PromoteId,omitempty"`             // 角色突破ID
-	PromoteRewardLevelStr string  `csv:"PromoteRewardLevelStr,omitempty"` // 角色突破奖励获取等阶
-	PromoteRewardStr      string  `csv:"PromoteRewardStr,omitempty"`      // 角色突破奖励
+	AvatarId           int32    `csv:"ID"`
+	HpBase             float32  `csv:"基础生命值,omitempty"`
+	AttackBase         float32  `csv:"基础攻击力,omitempty"`
+	DefenseBase        float32  `csv:"基础防御力,omitempty"`
+	Critical           float32  `csv:"暴击率,omitempty"`
+	CriticalHurt       float32  `csv:"暴击伤害,omitempty"`
+	QualityType        int32    `csv:"角色品质,omitempty"`
+	ConfigJson         string   `csv:"战斗config,omitempty"`
+	InitialWeapon      int32    `csv:"初始武器,omitempty"`
+	WeaponType         int32    `csv:"武器种类,omitempty"`
+	SkillDepotId       int32    `csv:"技能库ID,omitempty"`
+	PromoteId          int32    `csv:"角色突破ID,omitempty"`
+	PromoteRewardLevel IntArray `csv:"角色突破奖励获取等阶,omitempty"`
+	PromoteReward      IntArray `csv:"角色突破奖励,omitempty"`

 	AbilityHashCodeList []int32
 	PromoteRewardMap    map[uint32]uint32
@@ -45,13 +42,8 @@ type ConfigAvatarAbility struct {

 func (g *GameDataConfig) loadAvatarData() {
 	g.AvatarDataMap = make(map[int32]*AvatarData)
-	data := g.readCsvFileData("AvatarData.csv")
-	var avatarDataList []*AvatarData
-	err := csvutil.Unmarshal(data, &avatarDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	avatarDataList := make([]*AvatarData, 0)
+	readTable[AvatarData](g.tablePrefix+"AvatarData.txt", &avatarDataList)
 	for _, avatarData := range avatarDataList {
 		// 读取战斗config解析技能并转化为哈希码
 		fileData, err := os.ReadFile(g.jsonPrefix + "avatar/" + avatarData.ConfigJson + ".json")
@@ -73,21 +65,10 @@ func (g *GameDataConfig) loadAvatarData() {
 			avatarData.AbilityHashCodeList = append(avatarData.AbilityHashCodeList, abilityHashCode)
 		}
 		// 突破奖励转换列表
-		if avatarData.PromoteRewardLevelStr != "" && avatarData.PromoteRewardStr != "" {
-			tempRewardLevelList := strings.Split(strings.ReplaceAll(avatarData.PromoteRewardLevelStr, " ", ""), "#")
-			tempRewardList := strings.Split(strings.ReplaceAll(avatarData.PromoteRewardStr, " ", ""), "#")
-			avatarData.PromoteRewardMap = make(map[uint32]uint32, len(tempRewardList))
-			for i, s := range tempRewardList {
-				promoteLevel, err := strconv.Atoi(tempRewardLevelList[i])
-				if err != nil {
-					logger.Error("level to i err, %v", err)
-					return
-				}
-				rewardId, err := strconv.Atoi(s)
-				if err != nil {
-					logger.Error("reward id to i err, %v", err)
-					return
-				}
+		if len(avatarData.PromoteRewardLevel) != 0 && len(avatarData.PromoteReward) != 0 {
+			avatarData.PromoteRewardMap = make(map[uint32]uint32, len(avatarData.PromoteReward))
+			for index, rewardId := range avatarData.PromoteReward {
+				promoteLevel := avatarData.PromoteRewardLevel[index]
 				avatarData.PromoteRewardMap[uint32(promoteLevel)] = uint32(rewardId)
 			}
 		}
--- a/gdconf/avatar_flycloak_data.go
+++ b/gdconf/avatar_flycloak_data.go
@@ -1,28 +1,19 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // AvatarFlycloakData 角色风之翼配置表
 type AvatarFlycloakData struct {
-	FlycloakID int32 `csv:"FlycloakID"`       // 风之翼ID
-	ItemID     int32 `csv:"ItemID,omitempty"` // 道具ID
+	FlycloakID int32 `csv:"风之翼ID"`
+	ItemID     int32 `csv:"道具ID,omitempty"`
 }

 func (g *GameDataConfig) loadAvatarFlycloakData() {
 	g.AvatarFlycloakDataMap = make(map[int32]*AvatarFlycloakData)
-	data := g.readCsvFileData("AvatarFlycloakData.csv")
-	var avatarFlycloakDataList []*AvatarFlycloakData
-	err := csvutil.Unmarshal(data, &avatarFlycloakDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	avatarFlycloakDataList := make([]*AvatarFlycloakData, 0)
+	readTable[AvatarFlycloakData](g.tablePrefix+"AvatarFlycloakData.txt", &avatarFlycloakDataList)
 	for _, avatarFlycloakData := range avatarFlycloakDataList {
 		// list -> map
 		g.AvatarFlycloakDataMap[avatarFlycloakData.FlycloakID] = avatarFlycloakData
--- a/gdconf/avatar_level_data.go
+++ b/gdconf/avatar_level_data.go
@@ -1,28 +1,19 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // AvatarLevelData 角色等级配置表
 type AvatarLevelData struct {
-	Level int32 `csv:"Level"`         // 等级
-	Exp   int32 `csv:"Exp,omitempty"` // 升到下一级所需经验
+	Level int32 `csv:"等级"`
+	Exp   int32 `csv:"升到下一级所需经验,omitempty"`
 }

 func (g *GameDataConfig) loadAvatarLevelData() {
 	g.AvatarLevelDataMap = make(map[int32]*AvatarLevelData)
-	data := g.readCsvFileData("AvatarLevelData.csv")
-	var avatarLevelDataList []*AvatarLevelData
-	err := csvutil.Unmarshal(data, &avatarLevelDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	avatarLevelDataList := make([]*AvatarLevelData, 0)
+	readTable[AvatarLevelData](g.tablePrefix+"AvatarLevelData.txt", &avatarLevelDataList)
 	for _, avatarLevelData := range avatarLevelDataList {
 		// list -> map
 		g.AvatarLevelDataMap[avatarLevelData.Level] = avatarLevelData
--- a/gdconf/avatar_promote_data.go
+++ b/gdconf/avatar_promote_data.go
@@ -1,41 +1,32 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // AvatarPromoteData 角色突破配置表
 type AvatarPromoteData struct {
-	PromoteId      int32 `csv:"PromoteId"`                // 角色突破ID
-	PromoteLevel   int32 `csv:"PromoteLevel,omitempty"`   // 突破等级
-	CostCoin       int32 `csv:"CostCoin,omitempty"`       // 消耗金币
-	CostItemId1    int32 `csv:"CostItemId1,omitempty"`    // [消耗物品]1ID
-	CostItemCount1 int32 `csv:"CostItemCount1,omitempty"` // [消耗物品]1数量
-	CostItemId2    int32 `csv:"CostItemId2,omitempty"`    // [消耗物品]2ID
-	CostItemCount2 int32 `csv:"CostItemCount2,omitempty"` // [消耗物品]2数量
-	CostItemId3    int32 `csv:"CostItemId3,omitempty"`    // [消耗物品]3ID
-	CostItemCount3 int32 `csv:"CostItemCount3,omitempty"` // [消耗物品]3数量
-	CostItemId4    int32 `csv:"CostItemId4,omitempty"`    // [消耗物品]4ID
-	CostItemCount4 int32 `csv:"CostItemCount4,omitempty"` // [消耗物品]4数量
-	LevelLimit     int32 `csv:"LevelLimit,omitempty"`     // 解锁等级上限
-	MinPlayerLevel int32 `csv:"MinPlayerLevel,omitempty"` // 冒险等级要求
+	PromoteId      int32 `csv:"角色突破ID"`
+	PromoteLevel   int32 `csv:"突破等级,omitempty"`
+	CostCoin       int32 `csv:"消耗金币,omitempty"`
+	CostItemId1    int32 `csv:"[消耗物品]1ID,omitempty"`
+	CostItemCount1 int32 `csv:"[消耗物品]1数量,omitempty"`
+	CostItemId2    int32 `csv:"[消耗物品]2ID,omitempty"`
+	CostItemCount2 int32 `csv:"[消耗物品]2数量,omitempty"`
+	CostItemId3    int32 `csv:"[消耗物品]3ID,omitempty"`
+	CostItemCount3 int32 `csv:"[消耗物品]3数量,omitempty"`
+	CostItemId4    int32 `csv:"[消耗物品]4ID,omitempty"`
+	CostItemCount4 int32 `csv:"[消耗物品]4数量,omitempty"`
+	LevelLimit     int32 `csv:"解锁等级上限,omitempty"`
+	MinPlayerLevel int32 `csv:"冒险等级要求,omitempty"`

 	CostItemMap map[uint32]uint32 // 消耗物品列表
 }

 func (g *GameDataConfig) loadAvatarPromoteData() {
 	g.AvatarPromoteDataMap = make(map[int32]map[int32]*AvatarPromoteData)
-	data := g.readCsvFileData("AvatarPromoteData.csv")
-	var avatarPromoteDataList []*AvatarPromoteData
-	err := csvutil.Unmarshal(data, &avatarPromoteDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	avatarPromoteDataList := make([]*AvatarPromoteData, 0)
+	readTable[AvatarPromoteData](g.tablePrefix+"AvatarPromoteData.txt", &avatarPromoteDataList)
 	for _, avatarPromoteData := range avatarPromoteDataList {
 		// list -> map
 		_, ok := g.AvatarPromoteDataMap[avatarPromoteData.PromoteId]
--- a/gdconf/avatar_skill_data.go
+++ b/gdconf/avatar_skill_data.go
@@ -1,32 +1,23 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // AvatarSkillData 角色技能配置表
 type AvatarSkillData struct {
-	AvatarSkillId int32  `csv:"AvatarSkillId"`         // ID
-	AbilityName   string `csv:"AbilityName,omitempty"` // Ability名称
+	AvatarSkillId int32  `csv:"ID"`
+	AbilityName   string `csv:"Ability名称,omitempty"`
 	// TODO 这个字段实际上并不是拿来直接扣体力的 体力应该由ability来做 但是现在我捋不清所以摆烂了 改了一下表暂时先这么用着
-	CostStamina  int32 `csv:"CostStamina,omitempty"`  // 消耗体力
-	CostElemType int32 `csv:"CostElemType,omitempty"` // 消耗能量类型
-	CostElemVal  int32 `csv:"CostElemVal,omitempty"`  // 消耗能量值
+	CostStamina  int32 `csv:"消耗体力,omitempty"`
+	CostElemType int32 `csv:"消耗能量类型,omitempty"`
+	CostElemVal  int32 `csv:"消耗能量值,omitempty"`
 }

 func (g *GameDataConfig) loadAvatarSkillData() {
 	g.AvatarSkillDataMap = make(map[int32]*AvatarSkillData)
-	data := g.readCsvFileData("AvatarSkillData.csv")
-	var avatarSkillDataList []*AvatarSkillData
-	err := csvutil.Unmarshal(data, &avatarSkillDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	avatarSkillDataList := make([]*AvatarSkillData, 0)
+	readTable[AvatarSkillData](g.tablePrefix+"AvatarSkillData.txt", &avatarSkillDataList)
 	for _, avatarSkillData := range avatarSkillDataList {
 		// list -> map
 		g.AvatarSkillDataMap[avatarSkillData.AvatarSkillId] = avatarSkillData
--- a/gdconf/avatar_skill_depot_data.go
+++ b/gdconf/avatar_skill_depot_data.go
@@ -8,28 +8,27 @@ import (
 	"hk4e/pkg/logger"

 	"github.com/hjson/hjson-go/v4"
-	"github.com/jszwec/csvutil"
 )

 // AvatarSkillDepotData 角色技能库配置表
 type AvatarSkillDepotData struct {
-	AvatarSkillDepotId                int32  `csv:"AvatarSkillDepotId"`                          // ID
-	EnergySkill                       int32  `csv:"EnergySkill,omitempty"`                       // 充能技能
-	Skill1                            int32  `csv:"Skill1,omitempty"`                            // 技能1
-	Skill2                            int32  `csv:"Skill2,omitempty"`                            // 技能2
-	Skill3                            int32  `csv:"Skill3,omitempty"`                            // 技能3
-	Skill4                            int32  `csv:"Skill4,omitempty"`                            // 技能4
-	ProudSkill1GroupId                int32  `csv:"ProudSkill1GroupId,omitempty"`                // 固有得意技组1ID
-	ProudSkill1NeedAvatarPromoteLevel int32  `csv:"ProudSkill1NeedAvatarPromoteLevel,omitempty"` // 固有得意技组1激活所需角色突破等级
-	ProudSkill2GroupId                int32  `csv:"ProudSkill2GroupId,omitempty"`                // 固有得意技组2ID
-	ProudSkill2NeedAvatarPromoteLevel int32  `csv:"ProudSkill2NeedAvatarPromoteLevel,omitempty"` // 固有得意技组2激活所需角色突破等级
-	ProudSkill3GroupId                int32  `csv:"ProudSkill3GroupId,omitempty"`                // 固有得意技组3ID
-	ProudSkill3NeedAvatarPromoteLevel int32  `csv:"ProudSkill3NeedAvatarPromoteLevel,omitempty"` // 固有得意技组3激活所需角色突破等级
-	ProudSkill4GroupId                int32  `csv:"ProudSkill4GroupId,omitempty"`                // 固有得意技组4ID
-	ProudSkill4NeedAvatarPromoteLevel int32  `csv:"ProudSkill4NeedAvatarPromoteLevel,omitempty"` // 固有得意技组4激活所需角色突破等级
-	ProudSkill5GroupId                int32  `csv:"ProudSkill5GroupId,omitempty"`                // 固有得意技组5ID
-	ProudSkill5NeedAvatarPromoteLevel int32  `csv:"ProudSkill5NeedAvatarPromoteLevel,omitempty"` // 固有得意技组5激活所需角色突破等级
-	SkillDepotAbilityGroup            string `csv:"SkillDepotAbilityGroup,omitempty"`            // AbilityGroup
+	AvatarSkillDepotId                int32  `csv:"ID"`
+	EnergySkill                       int32  `csv:"充能技能,omitempty"`
+	Skill1                            int32  `csv:"技能1,omitempty"`
+	Skill2                            int32  `csv:"技能2,omitempty"`
+	Skill3                            int32  `csv:"技能3,omitempty"`
+	Skill4                            int32  `csv:"技能4,omitempty"`
+	ProudSkill1GroupId                int32  `csv:"固有得意技组1ID,omitempty"`
+	ProudSkill1NeedAvatarPromoteLevel int32  `csv:"固有得意技组1激活所需角色突破等级,omitempty"`
+	ProudSkill2GroupId                int32  `csv:"固有得意技组2ID,omitempty"`
+	ProudSkill2NeedAvatarPromoteLevel int32  `csv:"固有得意技组2激活所需角色突破等级,omitempty"`
+	ProudSkill3GroupId                int32  `csv:"固有得意技组3ID,omitempty"`
+	ProudSkill3NeedAvatarPromoteLevel int32  `csv:"固有得意技组3激活所需角色突破等级,omitempty"`
+	ProudSkill4GroupId                int32  `csv:"固有得意技组4ID,omitempty"`
+	ProudSkill4NeedAvatarPromoteLevel int32  `csv:"固有得意技组4激活所需角色突破等级,omitempty"`
+	ProudSkill5GroupId                int32  `csv:"固有得意技组5ID,omitempty"`
+	ProudSkill5NeedAvatarPromoteLevel int32  `csv:"固有得意技组5激活所需角色突破等级,omitempty"`
+	SkillDepotAbilityGroup            string `csv:"AbilityGroup,omitempty"`

 	Skills                  []int32
 	InherentProudSkillOpens []*InherentProudSkillOpens
@@ -43,14 +42,8 @@ type InherentProudSkillOpens struct {

 func (g *GameDataConfig) loadAvatarSkillDepotData() {
 	g.AvatarSkillDepotDataMap = make(map[int32]*AvatarSkillDepotData)
-	data := g.readCsvFileData("AvatarSkillDepotData.csv")
-	var avatarSkillDepotDataList []*AvatarSkillDepotData
-	err := csvutil.Unmarshal(data, &avatarSkillDepotDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
-
+	avatarSkillDepotDataList := make([]*AvatarSkillDepotData, 0)
+	readTable[AvatarSkillDepotData](g.tablePrefix+"AvatarSkillDepotData.txt", &avatarSkillDepotDataList)
 	playerElementsFilePath := g.jsonPrefix + "ability_group/AbilityGroup_Other_PlayerElementAbility.json"
 	playerElementsFile, err := os.ReadFile(playerElementsFilePath)
 	if err != nil {
--- a/gdconf/drop_group_data.go
+++ b/gdconf/drop_group_data.go
@@ -2,8 +2,6 @@ package gdconf

 import (
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // 当初写卡池算法的时候临时建立的表 以后再做迁移吧
@@ -25,13 +23,8 @@ func (g *GameDataConfig) loadDropGroupData() {
 	g.DropGroupDataMap = make(map[int32]*DropGroupData)
 	fileNameList := []string{"DropGachaAvatarUp.csv", "DropGachaWeaponUp.csv", "DropGachaNormal.csv"}
 	for _, fileName := range fileNameList {
-		data := g.readCsvFileData("../ext/" + fileName)
-		var dropList []*Drop
-		err := csvutil.Unmarshal(data, &dropList)
-		if err != nil {
-			logger.Error("parse file error: %v", err)
-			return
-		}
+		dropList := make([]*Drop, 0)
+		readExtCsv[Drop](g.extPrefix+fileName, &dropList)
 		for _, drop := range dropList {
 			dropGroupData, exist := g.DropGroupDataMap[drop.DropId]
 			if !exist {
--- a/gdconf/fetter_data.go
+++ b/gdconf/fetter_data.go
@@ -1,31 +1,22 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // FetterData 角色资料解锁配置表
 type FetterData struct {
-	FetterId int32 `csv:"FetterId"` // ID
-	AvatarId int32 `csv:"AvatarId"` // 角色ID
+	FetterId int32 `csv:"ID"`
+	AvatarId int32 `csv:"角色ID"`
 }

 func (g *GameDataConfig) loadFetterData() {
 	g.FetterDataMap = make(map[int32]*FetterData)
 	g.FetterDataAvatarIdMap = make(map[int32][]int32)
-	fileNameList := []string{"FettersData.csv", "FetterDataStory.csv", "FetterDataIformation.csv", "PhotographExpressionName.csv", "PhotographPoseName.csv"}
+	fileNameList := []string{"FettersData.txt", "FetterDataStory.txt", "FetterDataIformation.txt", "PhotographExpressionName.txt", "PhotographPoseName.txt"}
 	for _, fileName := range fileNameList {
-		data := g.readCsvFileData(fileName)
-		var fetterDataList []*FetterData
-		err := csvutil.Unmarshal(data, &fetterDataList)
-		if err != nil {
-			info := fmt.Sprintf("parse file error: %v", err)
-			panic(info)
-		}
+		fetterDataList := make([]*FetterData, 0)
+		readTable[FetterData](g.tablePrefix+fileName, &fetterDataList)
 		for _, fetterData := range fetterDataList {
 			// list -> map
 			g.FetterDataMap[fetterData.FetterId] = fetterData
--- a/gdconf/game_data_config.go
+++ b/gdconf/game_data_config.go
@@ -1,10 +1,14 @@
 package gdconf

 import (
+	"bytes"
+	"encoding/csv"
 	"encoding/json"
 	"fmt"
+	"io"
 	"os"
 	"runtime"
+	"strconv"
 	"strings"
 	"time"

@@ -12,6 +16,7 @@ import (
 	"hk4e/common/constant"
 	"hk4e/pkg/logger"

+	"github.com/jszwec/csvutil"
 	lua "github.com/yuin/gopher-lua"
 )

@@ -22,9 +27,10 @@ var CONF_RELOAD *GameDataConfig = nil

 type GameDataConfig struct {
 	// 配置表路径前缀
-	csvPrefix  string
-	jsonPrefix string
-	luaPrefix  string
+	tablePrefix string
+	jsonPrefix  string
+	luaPrefix   string
+	extPrefix   string
 	// 配置表数据
 	AvatarDataMap           map[int32]*AvatarData                   // 角色
 	AvatarSkillDataMap      map[int32]*AvatarSkillData              // 角色技能
@@ -89,13 +95,13 @@ func (g *GameDataConfig) loadAll() {
 		panic(info)
 	}

-	g.csvPrefix = pathPrefix + "/csv"
-	dirInfo, err = os.Stat(g.csvPrefix)
+	g.tablePrefix = pathPrefix + "/txt"
+	dirInfo, err = os.Stat(g.tablePrefix)
 	if err != nil || !dirInfo.IsDir() {
-		info := fmt.Sprintf("open game data config csv dir error: %v", err)
+		info := fmt.Sprintf("open game data config txt dir error: %v", err)
 		panic(info)
 	}
-	g.csvPrefix += "/"
+	g.tablePrefix += "/"

 	g.jsonPrefix = pathPrefix + "/json"
 	dirInfo, err = os.Stat(g.jsonPrefix)
@@ -113,6 +119,14 @@ func (g *GameDataConfig) loadAll() {
 	}
 	g.luaPrefix += "/"

+	g.extPrefix = pathPrefix + "/ext"
+	dirInfo, err = os.Stat(g.extPrefix)
+	if err != nil || !dirInfo.IsDir() {
+		info := fmt.Sprintf("open game data config ext dir error: %v", err)
+		panic(info)
+	}
+	g.extPrefix += "/"
+
 	g.load()
 }

@@ -147,8 +161,38 @@ func (g *GameDataConfig) load() {
 	g.loadTriggerData()        // 场景LUA触发器
 }

-func (g *GameDataConfig) readCsvFileData(fileName string) []byte {
-	fileData, err := os.ReadFile(g.csvPrefix + fileName)
+// CSV相关
+
+func splitStringArray(str string) []string {
+	if str == "" {
+		return make([]string, 0)
+	} else if strings.Contains(str, ";") {
+		return strings.Split(str, ";")
+	} else if strings.Contains(str, ",") {
+		return strings.Split(str, ",")
+	} else {
+		return []string{str}
+	}
+}
+
+type IntArray []int32
+
+func (a *IntArray) UnmarshalCSV(data []byte) error {
+	str := string(data)
+	str = strings.ReplaceAll(str, " ", "")
+	intStrList := splitStringArray(str)
+	for _, intStr := range intStrList {
+		v, err := strconv.ParseInt(intStr, 10, 32)
+		if err != nil {
+			panic(err)
+		}
+		*a = append(*a, int32(v))
+	}
+	return nil
+}
+
+func readExtCsv[T any](tablePath string, table *[]*T) {
+	fileData, err := os.ReadFile(tablePath)
 	if err != nil {
 		info := fmt.Sprintf("open file error: %v", err)
 		panic(info)
@@ -160,9 +204,42 @@ func (g *GameDataConfig) readCsvFileData(fileName string) []byte {
 	standardCsvData := make([]byte, 0)
 	standardCsvData = append(standardCsvData, fileData[:index1]...)
 	standardCsvData = append(standardCsvData, fileData[index3+(index2+1)+(index1+1):]...)
-	return standardCsvData
+	err = csvutil.Unmarshal(standardCsvData, table)
+	if err != nil {
+		info := fmt.Sprintf("parse file error: %v", err)
+		panic(info)
+	}
 }

+func readTable[T any](tablePath string, table *[]*T) {
+	fileData, err := os.ReadFile(tablePath)
+	if err != nil {
+		info := fmt.Sprintf("open file error: %v", err)
+		panic(info)
+	}
+	reader := csv.NewReader(bytes.NewBuffer(fileData))
+	reader.Comma = '\t'
+	dec, err := csvutil.NewDecoder(reader)
+	if err != nil {
+		info := fmt.Sprintf("create decoder error: %v", err)
+		panic(info)
+	}
+	for {
+		t := new(T)
+		err := dec.Decode(t)
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			info := fmt.Sprintf("decode file error: %v", err)
+			panic(info)
+		}
+		*table = append(*table, t)
+	}
+}
+
+// LUA相关
+
 type ScriptLibFunc struct {
 	fnName string
 	fn     lua.LGFunction
--- a/gdconf/game_data_config_test.go
+++ b/gdconf/game_data_config_test.go
@@ -1,11 +1,9 @@
 package gdconf

 import (
-	"encoding/json"
 	"image"
 	"image/color"
 	"image/jpeg"
-	"log"
 	"os"
 	"strings"
 	"testing"
@@ -17,79 +15,6 @@ import (
 	"github.com/hjson/hjson-go/v4"
 )

-type TableField struct {
-	FieldName  string `json:"field_name"`
-	FieldType  string `json:"field_type"`
-	OriginName string `json:"origin_name"`
-}
-
-type TableStructMapping struct {
-	TableName string        `json:"table_name"`
-	FieldList []*TableField `json:"field_list"`
-}
-
-// 生成最终服务器读取的配置表
-func TestGenGdCsv(t *testing.T) {
-	tableStructMappingList := make([]*TableStructMapping, 0)
-	configFileData, err := os.ReadFile("./table_struct_mapping.json")
-	if err != nil {
-		log.Printf("open config file error: %v", err)
-		return
-	}
-	err = json.Unmarshal(configFileData, &tableStructMappingList)
-	if err != nil {
-		log.Printf("parse config file error: %v", err)
-		return
-	}
-	for _, tableStructMapping := range tableStructMappingList {
-		txtFileData, err := os.ReadFile("./game_data_config/txt/" + tableStructMapping.TableName + ".txt")
-		if err != nil {
-			log.Printf("read txt file error: %v", err)
-			continue
-		}
-		// 转换txt配置表格式为csv
-		originCsv := string(txtFileData)
-		originCsv = strings.ReplaceAll(originCsv, "\r\n", "\n")
-		originCsv = strings.ReplaceAll(originCsv, "\r", "\n")
-		originCsv = strings.ReplaceAll(originCsv, ",", "#")
-		originCsv = strings.ReplaceAll(originCsv, ";", "#")
-		originCsv = strings.ReplaceAll(originCsv, "\t", ",")
-		originCsvLineList := strings.Split(originCsv, "\n")
-		if len(originCsvLineList) == 0 {
-			log.Printf("origin csv file is empty")
-			continue
-		}
-		originCsvHeadList := strings.Split(originCsvLineList[0], ",")
-		if len(originCsvHeadList) == 0 {
-			log.Printf("origin csv file head is empty")
-			continue
-		}
-		fieldNameHead := ""
-		fieldTypeHead := ""
-		for index, originCsvHead := range originCsvHeadList {
-			for _, tableField := range tableStructMapping.FieldList {
-				if originCsvHead == tableField.OriginName {
-					// 字段名匹配成功
-					fieldNameHead += tableField.FieldName
-					fieldTypeHead += tableField.FieldType
-				}
-			}
-			if index < len(originCsvHeadList)-1 {
-				fieldNameHead += ","
-				fieldTypeHead += ","
-			}
-		}
-		fieldNameHead += "\n"
-		fieldTypeHead += "\n"
-		gdCsvFile := fieldNameHead + fieldTypeHead + originCsv
-		err = os.WriteFile("./game_data_config/csv/"+tableStructMapping.TableName+".csv", []byte(gdCsvFile), 0644)
-		if err != nil {
-			log.Printf("write gd csv file error: %v", err)
-			continue
-		}
-	}
-}
-
 // 测试初始化加载配置表
 func TestInitGameDataConfig(t *testing.T) {
 	config.InitConfig("./bin/application.toml")
@@ -99,7 +24,7 @@ func TestInitGameDataConfig(t *testing.T) {
 	}()
 	logger.Info("start load conf")
 	InitGameDataConfig()
-	logger.Info("load conf finish, conf: %v", CONF)
+	logger.Info("load conf finish")
 	time.Sleep(time.Second)
 }

--- a/gdconf/gather_data.go
+++ b/gdconf/gather_data.go
@@ -1,30 +1,21 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // GatherData 采集物配置表
 type GatherData struct {
-	PointType int32 `csv:"PointType"` // 挂节点类型
-	GatherId  int32 `csv:"GatherId"`  // ID
-	GadgetId  int32 `csv:"GadgetId"`  // 采集物ID
-	ItemId    int32 `csv:"ItemId"`    // 获得物品ID
+	PointType int32 `csv:"挂节点类型"`
+	GatherId  int32 `csv:"ID"`
+	GadgetId  int32 `csv:"采集物ID"`
+	ItemId    int32 `csv:"获得物品ID"`
 }

 func (g *GameDataConfig) loadGatherData() {
 	g.GatherDataMap = make(map[int32]*GatherData)
-	data := g.readCsvFileData("GatherData.csv")
-	var gatherDataList []*GatherData
-	err := csvutil.Unmarshal(data, &gatherDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	gatherDataList := make([]*GatherData, 0)
+	readTable[GatherData](g.tablePrefix+"GatherData.txt", &gatherDataList)
 	g.GatherDataPointTypeMap = make(map[int32]*GatherData)
 	for _, gatherData := range gatherDataList {
 		// list -> map
--- a/gdconf/gcg_char_data.go
+++ b/gdconf/gcg_char_data.go
@@ -1,40 +1,28 @@
 package gdconf

 import (
-	"fmt"
-	"strconv"
-	"strings"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // GCGCharData 角色卡牌配置表
 type GCGCharData struct {
-	CharId       int32  `csv:"CharId"`                 // ID
-	TagId1       int32  `csv:"TagId1,omitempty"`       // 卡牌标签列表1
-	TagId2       int32  `csv:"TagId2,omitempty"`       // 卡牌标签列表2
-	TagId3       int32  `csv:"TagId3,omitempty"`       // 卡牌标签列表3
-	TagId4       int32  `csv:"TagId4,omitempty"`       // 卡牌标签列表4
-	TagId5       int32  `csv:"TagId5,omitempty"`       // 卡牌标签列表5
-	SkillListStr string `csv:"SkillListStr,omitempty"` // 卡牌技能列表文本
-	HPBase       int32  `csv:"HPBase,omitempty"`       // 角色生命值
-	MaxElemVal   int32  `csv:"MaxElemVal,omitempty"`   // 角色充能上限
+	CharId     int32    `csv:"ID"`
+	TagId1     int32    `csv:"[卡牌标签列表]1,omitempty"`
+	TagId2     int32    `csv:"[卡牌标签列表]2,omitempty"`
+	TagId3     int32    `csv:"[卡牌标签列表]3,omitempty"`
+	TagId4     int32    `csv:"[卡牌标签列表]4,omitempty"`
+	TagId5     int32    `csv:"[卡牌标签列表]5,omitempty"`
+	SkillList  IntArray `csv:"卡牌技能列表,omitempty"`
+	HPBase     int32    `csv:"角色生命值,omitempty"`
+	MaxElemVal int32    `csv:"角色充能上限,omitempty"`

-	TagList   []uint32 // 卡牌标签列表
-	SkillList []uint32 // 卡牌技能列表
+	TagList []uint32 // 卡牌标签列表
 }

 func (g *GameDataConfig) loadGCGCharData() {
 	g.GCGCharDataMap = make(map[int32]*GCGCharData)
-	data := g.readCsvFileData("GCGCharData.csv")
-	var gcgCharDataList []*GCGCharData
-	err := csvutil.Unmarshal(data, &gcgCharDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	gcgCharDataList := make([]*GCGCharData, 0)
+	readTable[GCGCharData](g.tablePrefix+"GCGCharData.txt", &gcgCharDataList)
 	for _, gcgCharData := range gcgCharDataList {
 		// 将TagId整合进TagList
 		gcgCharData.TagList = make([]uint32, 0, 5)
@@ -47,17 +35,6 @@ func (g *GameDataConfig) loadGCGCharData() {
 			}
 			gcgCharData.TagList = append(gcgCharData.TagList, uint32(tagId))
 		}
-		// 技能列表读取转换
-		tempSkillList := strings.Split(strings.ReplaceAll(gcgCharData.SkillListStr, " ", ""), "#")
-		gcgCharData.SkillList = make([]uint32, 0, len(tempSkillList))
-		for _, s := range tempSkillList {
-			skillId, err := strconv.Atoi(s)
-			if err != nil {
-				logger.Error("skill id to i err, %v", err)
-				return
-			}
-			gcgCharData.SkillList = append(gcgCharData.SkillList, uint32(skillId))
-		}
 		// list -> map
 		g.GCGCharDataMap[gcgCharData.CharId] = gcgCharData
 	}
--- a/gdconf/gcg_skill_data.go
+++ b/gdconf/gcg_skill_data.go
@@ -7,18 +7,16 @@ import (
 	"hk4e/pkg/logger"

 	"github.com/hjson/hjson-go/v4"
-
-	"github.com/jszwec/csvutil"
 )

 // GCGSkillData 卡牌技能配置表
 type GCGSkillData struct {
-	SkillId    int32  `csv:"SkillId"`              // ID
-	ConfigJson string `csv:"ConfigJson,omitempty"` // 效果config
-	CostType1  int32  `csv:"CostType1,omitempty"`  // 消耗的元素骰子类型1
-	CostValue1 int32  `csv:"CostValue1,omitempty"` // 消耗的元素骰子数量1
-	CostType2  int32  `csv:"CostType2,omitempty"`  // 消耗的元素骰子类型2
-	CostValue2 int32  `csv:"CostValue2,omitempty"` // 消耗的元素骰子数量2
+	SkillId    int32  `csv:"ID"`
+	ConfigJson string `csv:"效果JSON文件,omitempty"`
+	CostType1  int32  `csv:"[技能费用]1类型,omitempty"`
+	CostValue1 int32  `csv:"[技能费用]1值,omitempty"`
+	CostType2  int32  `csv:"[技能费用]2类型,omitempty"`
+	CostValue2 int32  `csv:"[技能费用]2值,omitempty"`

 	CostMap     map[uint32]uint32 // 技能骰子消耗列表
 	Damage      uint32            // 技能伤害
@@ -36,13 +34,8 @@ type ConfigSkillEffectValue struct {

 func (g *GameDataConfig) loadGCGSkillData() {
 	g.GCGSkillDataMap = make(map[int32]*GCGSkillData)
-	data := g.readCsvFileData("GCGSkillData.csv")
-	var gcgSkillDataList []*GCGSkillData
-	err := csvutil.Unmarshal(data, &gcgSkillDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	gcgSkillDataList := make([]*GCGSkillData, 0)
+	readTable[GCGSkillData](g.tablePrefix+"GCGSkillData.txt", &gcgSkillDataList)
 	for _, gcgSkillData := range gcgSkillDataList {
 		// 技能消耗整合进CostMap
 		gcgSkillData.CostMap = map[uint32]uint32{
--- a/gdconf/item_data.go
+++ b/gdconf/item_data.go
@@ -1,57 +1,44 @@
 package gdconf

 import (
-	"fmt"
-	"strconv"
-	"strings"
-
-	"hk4e/common/constant"
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // ItemData 道具分类分表整合配置表
 type ItemData struct {
 	// 公共表头字段
-	ItemId    int32  `csv:"ItemId"`              // ID
-	Type      int32  `csv:"Type,omitempty"`      // 类型
-	Weight    int32  `csv:"Weight,omitempty"`    // 重量
-	RankLevel int32  `csv:"RankLevel,omitempty"` // 排序权重
-	GadgetId  int32  `csv:"GadgetId,omitempty"`  // 物件ID
-	Name      string `csv:"Name,omitempty"`      // 数值用类型
+	ItemId    int32  `csv:"ID"`
+	Type      int32  `csv:"类型,omitempty"`
+	Weight    int32  `csv:"重量,omitempty"`
+	RankLevel int32  `csv:"排序权重,omitempty"`
+	GadgetId  int32  `csv:"物件ID,omitempty"`
+	Name      string `csv:"数值用类型,omitempty"`
 	// 材料
-	MaterialType int32  `csv:"MaterialType,omitempty"` // 材料类型
-	Use1Param1   string `csv:"Use1Param1,omitempty"`   // [使用]1参数1
+	MaterialType int32  `csv:"材料类型,omitempty"`
+	Use1Param1   string `csv:"[使用]1参数1,omitempty"`
 	// 武器
-	EquipType          int32  `csv:"EquipType,omitempty"`         // 武器种类
-	EquipLevel         int32  `csv:"EquipLevel,omitempty"`        // 武器阶数
-	SkillAffix1        int32  `csv:"SkillAffix1,omitempty"`       // 初始技能词缀1
-	SkillAffix2        int32  `csv:"SkillAffix2,omitempty"`       // 初始技能词缀2
-	PromoteId          int32  `csv:"PromoteId,omitempty"`         // 武器突破ID
-	EquipBaseExp       int32  `csv:"EquipBaseExp,omitempty"`      // 武器初始经验
-	AwakenMaterial     int32  `csv:"AwakenMaterial,omitempty"`    // 武器精炼道具
-	AwakenCoinCostStr  string `csv:"AwakenCoinCostStr,omitempty"` // 精炼摩拉消耗
-	SkillAffix         []int32
-	AwakenCoinCostList []uint32
+	EquipType      int32    `csv:"武器种类,omitempty"`
+	EquipLevel     int32    `csv:"武器阶数,omitempty"`
+	SkillAffix1    int32    `csv:"初始技能词缀1,omitempty"`
+	SkillAffix2    int32    `csv:"初始技能词缀2,omitempty"`
+	PromoteId      int32    `csv:"武器突破ID,omitempty"`
+	EquipBaseExp   int32    `csv:"武器初始经验,omitempty"`
+	AwakenMaterial int32    `csv:"精炼道具,omitempty"`
+	AwakenCoinCost IntArray `csv:"精炼摩拉消耗,omitempty"`
+	SkillAffix     []int32
 	// 圣遗物
-	ReliquaryType     int32 `csv:"ReliquaryType,omitempty"`     // 圣遗物类别
-	MainPropDepotId   int32 `csv:"MainPropDepotId,omitempty"`   // 主属性库ID
-	AppendPropDepotId int32 `csv:"AppendPropDepotId,omitempty"` // 追加属性库ID
-	AppendPropCount   int32 `csv:"AppendPropCount,omitempty"`   // 追加属性初始条数
+	ReliquaryType     int32 `csv:"圣遗物类别,omitempty"`
+	MainPropDepotId   int32 `csv:"主属性库ID,omitempty"`
+	AppendPropDepotId int32 `csv:"追加属性库ID,omitempty"`
+	AppendPropCount   int32 `csv:"追加属性初始条数,omitempty"`
 }

 func (g *GameDataConfig) loadItemData() {
 	g.ItemDataMap = make(map[int32]*ItemData)
-	fileNameList := []string{"MaterialData.csv", "WeaponData.csv", "ReliquaryData.csv", "FurnitureExcelData.csv"}
+	fileNameList := []string{"MaterialData.txt", "WeaponData.txt", "ReliquaryData.txt", "FurnitureExcelData.txt"}
 	for _, fileName := range fileNameList {
-		data := g.readCsvFileData(fileName)
-		var itemDataList []*ItemData
-		err := csvutil.Unmarshal(data, &itemDataList)
-		if err != nil {
-			info := fmt.Sprintf("parse file error: %v", err)
-			panic(info)
-		}
+		itemDataList := make([]*ItemData, 0)
+		readTable[ItemData](g.tablePrefix+fileName, &itemDataList)
 		for _, itemData := range itemDataList {
 			// list -> map
 			itemData.SkillAffix = make([]int32, 0)
@@ -61,19 +48,6 @@ func (g *GameDataConfig) loadItemData() {
 			if itemData.SkillAffix2 != 0 {
 				itemData.SkillAffix = append(itemData.SkillAffix, itemData.SkillAffix2)
 			}
-			// 武器精炼摩拉消耗列表读取转换
-			if itemData.Type == constant.ITEM_TYPE_WEAPON && itemData.AwakenCoinCostStr != "" {
-				tempCostList := strings.Split(strings.ReplaceAll(itemData.AwakenCoinCostStr, " ", ""), "#")
-				itemData.AwakenCoinCostList = make([]uint32, 0, len(tempCostList))
-				for _, s := range tempCostList {
-					costCount, err := strconv.Atoi(s)
-					if err != nil {
-						logger.Error("cost count to i err, %v", err)
-						return
-					}
-					itemData.AwakenCoinCostList = append(itemData.AwakenCoinCostList, uint32(costCount))
-				}
-			}
 			g.ItemDataMap[itemData.ItemId] = itemData
 		}
 	}
--- a/gdconf/player_level_data.go
+++ b/gdconf/player_level_data.go
@@ -1,28 +1,19 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // PlayerLevelData 玩家等级配置表
 type PlayerLevelData struct {
-	Level int32 `csv:"Level"`         // 等级
-	Exp   int32 `csv:"Exp,omitempty"` // 升到下一级所需经验
+	Level int32 `csv:"等级"`
+	Exp   int32 `csv:"升到下一级所需经验,omitempty"`
 }

 func (g *GameDataConfig) loadPlayerLevelData() {
 	g.PlayerLevelDataMap = make(map[int32]*PlayerLevelData)
-	data := g.readCsvFileData("PlayerLevelData.csv")
-	var playerLevelDataList []*PlayerLevelData
-	err := csvutil.Unmarshal(data, &playerLevelDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	playerLevelDataList := make([]*PlayerLevelData, 0)
+	readTable[PlayerLevelData](g.tablePrefix+"PlayerLevelData.txt", &playerLevelDataList)
 	for _, playerLevelData := range playerLevelDataList {
 		// list -> map
 		g.PlayerLevelDataMap[playerLevelData.Level] = playerLevelData
--- a/gdconf/quest_data.go
+++ b/gdconf/quest_data.go
@@ -1,11 +1,7 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 type QuestCond struct {
@@ -17,57 +13,57 @@ type QuestCond struct {

 // QuestData 任务配置表
 type QuestData struct {
-	QuestId       int32 `csv:"QuestId"`                 // ID
-	ParentQuestId int32 `csv:"ParentQuestId,omitempty"` // 父任务ID
-	Sequence      int32 `csv:"Sequence,omitempty"`      // 序列
+	QuestId       int32 `csv:"子任务ID"`
+	ParentQuestId int32 `csv:"父任务ID,omitempty"`
+	Sequence      int32 `csv:"序列,omitempty"`
 	// 领取条件
-	AcceptCondCompose     int32 `csv:"AcceptCondCompose,omitempty"`     // [领取条件]组合
-	AcceptCondType1       int32 `csv:"AcceptCondType1,omitempty"`       // [领取条件]1类型
-	AcceptCondType1Param1 int32 `csv:"AcceptCondType1Param1,omitempty"` // [领取条件]1参数1
-	AcceptCondType1Param2 int32 `csv:"AcceptCondType1Param2,omitempty"` // [领取条件]1参数2
-	AcceptCondType1Param3 int32 `csv:"AcceptCondType1Param3,omitempty"` // [领取条件]1参数3
-	AcceptCondType2       int32 `csv:"AcceptCondType2,omitempty"`       // [领取条件]2类型
-	AcceptCondType2Param1 int32 `csv:"AcceptCondType2Param1,omitempty"` // [领取条件]2参数1
-	AcceptCondType2Param2 int32 `csv:"AcceptCondType2Param2,omitempty"` // [领取条件]2参数2
-	AcceptCondType2Param3 int32 `csv:"AcceptCondType2Param3,omitempty"` // [领取条件]2参数3
-	AcceptCondType3       int32 `csv:"AcceptCondType3,omitempty"`       // [领取条件]3类型
-	AcceptCondType3Param1 int32 `csv:"AcceptCondType3Param1,omitempty"` // [领取条件]3参数1
-	AcceptCondType3Param2 int32 `csv:"AcceptCondType3Param2,omitempty"` // [领取条件]3参数2
-	AcceptCondType3Param3 int32 `csv:"AcceptCondType3Param3,omitempty"` // [领取条件]3参数3
+	AcceptCondCompose     int32 `csv:"[领取条件]组合,omitempty"`
+	AcceptCondType1       int32 `csv:"[领取条件]1类型,omitempty"`
+	AcceptCondType1Param1 int32 `csv:"[领取条件]1参数1,omitempty"`
+	AcceptCondType1Param2 int32 `csv:"[领取条件]1参数2,omitempty"`
+	AcceptCondType1Param3 int32 `csv:"[领取条件]1参数3,omitempty"`
+	AcceptCondType2       int32 `csv:"[领取条件]2类型,omitempty"`
+	AcceptCondType2Param1 int32 `csv:"[领取条件]2参数1,omitempty"`
+	AcceptCondType2Param2 int32 `csv:"[领取条件]2参数2,omitempty"`
+	AcceptCondType2Param3 int32 `csv:"[领取条件]2参数3,omitempty"`
+	AcceptCondType3       int32 `csv:"[领取条件]3类型,omitempty"`
+	AcceptCondType3Param1 int32 `csv:"[领取条件]3参数1,omitempty"`
+	AcceptCondType3Param2 int32 `csv:"[领取条件]3参数2,omitempty"`
+	AcceptCondType3Param3 int32 `csv:"[领取条件]3参数3,omitempty"`
 	// 完成条件
-	FinishCondCompose           int32  `csv:"FinishCondCompose,omitempty"`           // [完成条件]组合
-	FinishCondType1             int32  `csv:"FinishCondType1,omitempty"`             // [完成条件]1类型
-	FinishCondType1Param1       int32  `csv:"FinishCondType1Param1,omitempty"`       // [完成条件]1参数1
-	FinishCondType1Param2       int32  `csv:"FinishCondType1Param2,omitempty"`       // [完成条件]1参数2
-	FinishCondType1ComplexParam string `csv:"FinishCondType1ComplexParam,omitempty"` // [完成条件]1复杂参数
-	FinishCondType1Count        int32  `csv:"FinishCondType1Count,omitempty"`        // [完成条件]1次数
-	FinishCondType2             int32  `csv:"FinishCondType2,omitempty"`             // [完成条件]2类型
-	FinishCondType2Param1       int32  `csv:"FinishCondType2Param1,omitempty"`       // [完成条件]2参数1
-	FinishCondType2Param2       int32  `csv:"FinishCondType2Param2,omitempty"`       // [完成条件]2参数2
-	FinishCondType2ComplexParam string `csv:"FinishCondType2ComplexParam,omitempty"` // [完成条件]2复杂参数
-	FinishCondType2Count        int32  `csv:"FinishCondType2Count,omitempty"`        // [完成条件]2次数
-	FinishCondType3             int32  `csv:"FinishCondType3,omitempty"`             // [完成条件]3类型
-	FinishCondType3Param1       int32  `csv:"FinishCondType3Param1,omitempty"`       // [完成条件]3参数1
-	FinishCondType3Param2       int32  `csv:"FinishCondType3Param2,omitempty"`       // [完成条件]3参数2
-	FinishCondType3ComplexParam string `csv:"FinishCondType3ComplexParam,omitempty"` // [完成条件]3复杂参数
-	FinishCondType3Count        int32  `csv:"FinishCondType3Count,omitempty"`        // [完成条件]3次数
+	FinishCondCompose           int32  `csv:"[完成条件]组合,omitempty"`
+	FinishCondType1             int32  `csv:"[完成条件]1类型,omitempty"`
+	FinishCondType1Param1       int32  `csv:"[完成条件]1参数1,omitempty"`
+	FinishCondType1Param2       int32  `csv:"[完成条件]1参数2,omitempty"`
+	FinishCondType1ComplexParam string `csv:"[完成条件]1复杂参数,omitempty"`
+	FinishCondType1Count        int32  `csv:"[完成条件]1次数,omitempty"`
+	FinishCondType2             int32  `csv:"[完成条件]2类型,omitempty"`
+	FinishCondType2Param1       int32  `csv:"[完成条件]2参数1,omitempty"`
+	FinishCondType2Param2       int32  `csv:"[完成条件]2参数2,omitempty"`
+	FinishCondType2ComplexParam string `csv:"[完成条件]2复杂参数,omitempty"`
+	FinishCondType2Count        int32  `csv:"[完成条件]2次数,omitempty"`
+	FinishCondType3             int32  `csv:"[完成条件]3类型,omitempty"`
+	FinishCondType3Param1       int32  `csv:"[完成条件]3参数1,omitempty"`
+	FinishCondType3Param2       int32  `csv:"[完成条件]3参数2,omitempty"`
+	FinishCondType3ComplexParam string `csv:"[完成条件]3复杂参数,omitempty"`
+	FinishCondType3Count        int32  `csv:"[完成条件]3次数,omitempty"`
 	// 失败条件
-	FailCondCompose           int32  `csv:"FailCondCompose,omitempty"`           // [失败条件]组合
-	FailCondType1             int32  `csv:"FailCondType1,omitempty"`             // [失败条件]1类型
-	FailCondType1Param1       int32  `csv:"FailCondType1Param1,omitempty"`       // [失败条件]1参数1
-	FailCondType1Param2       int32  `csv:"FailCondType1Param2,omitempty"`       // [失败条件]1参数2
-	FailCondType1ComplexParam string `csv:"FailCondType1ComplexParam,omitempty"` // [失败条件]1复杂参数
-	FailCondType1Count        int32  `csv:"FailCondType1Count,omitempty"`        // [失败条件]1次数
-	FailCondType2             int32  `csv:"FailCondType2,omitempty"`             // [失败条件]2类型
-	FailCondType2Param1       int32  `csv:"FailCondType2Param1,omitempty"`       // [失败条件]2参数1
-	FailCondType2Param2       int32  `csv:"FailCondType2Param2,omitempty"`       // [失败条件]2参数2
-	FailCondType2ComplexParam string `csv:"FailCondType2ComplexParam,omitempty"` // [失败条件]2复杂参数
-	FailCondType2Count        int32  `csv:"FailCondType2Count,omitempty"`        // [失败条件]2次数
-	FailCondType3             int32  `csv:"FailCondType3,omitempty"`             // [失败条件]3类型
-	FailCondType3Param1       int32  `csv:"FailCondType3Param1,omitempty"`       // [失败条件]3参数1
-	FailCondType3Param2       int32  `csv:"FailCondType3Param2,omitempty"`       // [失败条件]3参数2
-	FailCondType3ComplexParam string `csv:"FailCondType3ComplexParam,omitempty"` // [失败条件]3复杂参数
-	FailCondType3Count        int32  `csv:"FailCondType3Count,omitempty"`        // [失败条件]3次数
+	FailCondCompose           int32  `csv:"[失败条件]组合,omitempty"`
+	FailCondType1             int32  `csv:"[失败条件]1类型,omitempty"`
+	FailCondType1Param1       int32  `csv:"[失败条件]1参数1,omitempty"`
+	FailCondType1Param2       int32  `csv:"[失败条件]1参数2,omitempty"`
+	FailCondType1ComplexParam string `csv:"[失败条件]1复杂参数,omitempty"`
+	FailCondType1Count        int32  `csv:"[失败条件]1次数,omitempty"`
+	FailCondType2             int32  `csv:"[失败条件]2类型,omitempty"`
+	FailCondType2Param1       int32  `csv:"[失败条件]2参数1,omitempty"`
+	FailCondType2Param2       int32  `csv:"[失败条件]2参数2,omitempty"`
+	FailCondType2ComplexParam string `csv:"[失败条件]2复杂参数,omitempty"`
+	FailCondType2Count        int32  `csv:"[失败条件]2次数,omitempty"`
+	FailCondType3             int32  `csv:"[失败条件]3类型,omitempty"`
+	FailCondType3Param1       int32  `csv:"[失败条件]3参数1,omitempty"`
+	FailCondType3Param2       int32  `csv:"[失败条件]3参数2,omitempty"`
+	FailCondType3ComplexParam string `csv:"[失败条件]3复杂参数,omitempty"`
+	FailCondType3Count        int32  `csv:"[失败条件]3次数,omitempty"`

 	AcceptCondList []*QuestCond // 领取条件
 	FinishCondList []*QuestCond // 完成条件
@@ -76,15 +72,10 @@ type QuestData struct {

 func (g *GameDataConfig) loadQuestData() {
 	g.QuestDataMap = make(map[int32]*QuestData)
-	fileNameList := []string{"QuestData.csv", "QuestData_Exported.csv"}
+	fileNameList := []string{"QuestData.txt", "QuestData_Exported.txt"}
 	for _, fileName := range fileNameList {
-		data := g.readCsvFileData(fileName)
-		var questDataList []*QuestData
-		err := csvutil.Unmarshal(data, &questDataList)
-		if err != nil {
-			info := fmt.Sprintf("parse file error: %v", err)
-			panic(info)
-		}
+		questDataList := make([]*QuestData, 0)
+		readTable[QuestData](g.tablePrefix+fileName, &questDataList)
 		for _, questData := range questDataList {
 			// list -> map
 			// 领取条件
--- a/gdconf/reliquary_affix_data.go
+++ b/gdconf/reliquary_affix_data.go
@@ -1,30 +1,21 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // ReliquaryAffixData 圣遗物追加属性配置表
 type ReliquaryAffixData struct {
-	AppendPropId      int32 `csv:"AppendPropId"`                // 追加属性ID
-	AppendPropDepotId int32 `csv:"AppendPropDepotId,omitempty"` // 追加属性库ID
-	PropType          int32 `csv:"PropType,omitempty"`          // 属性类别
-	RandomWeight      int32 `csv:"RandomWeight,omitempty"`      // 随机权重
+	AppendPropId      int32 `csv:"追加属性ID"`
+	AppendPropDepotId int32 `csv:"追加属性库ID,omitempty"`
+	PropType          int32 `csv:"属性类别,omitempty"`
+	RandomWeight      int32 `csv:"随机权重,omitempty"`
 }

 func (g *GameDataConfig) loadReliquaryAffixData() {
 	g.ReliquaryAffixDataMap = make(map[int32]map[int32]*ReliquaryAffixData)
-	data := g.readCsvFileData("ReliquaryAffixData.csv")
-	var reliquaryAffixDataList []*ReliquaryAffixData
-	err := csvutil.Unmarshal(data, &reliquaryAffixDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	reliquaryAffixDataList := make([]*ReliquaryAffixData, 0)
+	readTable[ReliquaryAffixData](g.tablePrefix+"ReliquaryAffixData.txt", &reliquaryAffixDataList)
 	for _, reliquaryAffixData := range reliquaryAffixDataList {
 		// 通过主属性库ID找到
 		_, ok := g.ReliquaryAffixDataMap[reliquaryAffixData.AppendPropDepotId]
--- a/gdconf/reliquary_main_data.go
+++ b/gdconf/reliquary_main_data.go
@@ -1,30 +1,21 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // ReliquaryMainData 圣遗物主属性配置表
 type ReliquaryMainData struct {
-	MainPropId      int32 `csv:"MainPropId"`                // 主属性ID
-	MainPropDepotId int32 `csv:"MainPropDepotId,omitempty"` // 主属性库ID
-	PropType        int32 `csv:"PropType,omitempty"`        // 属性类别
-	RandomWeight    int32 `csv:"RandomWeight,omitempty"`    // 随机权重
+	MainPropId      int32 `csv:"主属性ID"`
+	MainPropDepotId int32 `csv:"主属性库ID,omitempty"`
+	PropType        int32 `csv:"属性类别,omitempty"`
+	RandomWeight    int32 `csv:"随机权重,omitempty"`
 }

 func (g *GameDataConfig) loadReliquaryMainData() {
 	g.ReliquaryMainDataMap = make(map[int32]map[int32]*ReliquaryMainData)
-	data := g.readCsvFileData("ReliquaryMainData.csv")
-	var reliquaryMainDataList []*ReliquaryMainData
-	err := csvutil.Unmarshal(data, &reliquaryMainDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	reliquaryMainDataList := make([]*ReliquaryMainData, 0)
+	readTable[ReliquaryMainData](g.tablePrefix+"ReliquaryMainData.txt", &reliquaryMainDataList)
 	for _, reliquaryMainData := range reliquaryMainDataList {
 		// 通过主属性库ID找到
 		_, ok := g.ReliquaryMainDataMap[reliquaryMainData.MainPropDepotId]
--- a/gdconf/reward_data.go
+++ b/gdconf/reward_data.go
@@ -1,47 +1,38 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // RewardData 奖励配置表
 type RewardData struct {
-	RewardID         int32 `csv:"RewardID"`                   // 奖励ID
-	RewardItem1ID    int32 `csv:"RewardItem1ID,omitempty"`    // Reward道具1ID
-	RewardItem1Count int32 `csv:"RewardItem1Count,omitempty"` // Reward道具1数量
-	RewardItem2ID    int32 `csv:"RewardItem2ID,omitempty"`    // Reward道具2ID
-	RewardItem2Count int32 `csv:"RewardItem2Count,omitempty"` // Reward道具2数量
-	RewardItem3ID    int32 `csv:"RewardItem3ID,omitempty"`    // Reward道具3ID
-	RewardItem3Count int32 `csv:"RewardItem3Count,omitempty"` // Reward道具3数量
-	RewardItem4ID    int32 `csv:"RewardItem4ID,omitempty"`    // Reward道具4ID
-	RewardItem4Count int32 `csv:"RewardItem4Count,omitempty"` // Reward道具4数量
-	RewardItem5ID    int32 `csv:"RewardItem5ID,omitempty"`    // Reward道具5ID
-	RewardItem5Count int32 `csv:"RewardItem5Count,omitempty"` // Reward道具5数量
-	RewardItem6ID    int32 `csv:"RewardItem6ID,omitempty"`    // Reward道具6ID
-	RewardItem6Count int32 `csv:"RewardItem6Count,omitempty"` // Reward道具6数量
-	RewardItem7ID    int32 `csv:"RewardItem7ID,omitempty"`    // Reward道具7ID
-	RewardItem7Count int32 `csv:"RewardItem7Count,omitempty"` // Reward道具7数量
-	RewardItem8ID    int32 `csv:"RewardItem8ID,omitempty"`    // Reward道具8ID
-	RewardItem8Count int32 `csv:"RewardItem8Count,omitempty"` // Reward道具8数量
-	RewardItem9ID    int32 `csv:"RewardItem9ID,omitempty"`    // Reward道具9ID
-	RewardItem9Count int32 `csv:"RewardItem9Count,omitempty"` // Reward道具9数量
+	RewardID         int32 `csv:"RewardID"`
+	RewardItem1ID    int32 `csv:"Reward道具1ID,omitempty"`
+	RewardItem1Count int32 `csv:"Reward道具1数量,omitempty"`
+	RewardItem2ID    int32 `csv:"Reward道具2ID,omitempty"`
+	RewardItem2Count int32 `csv:"Reward道具2数量,omitempty"`
+	RewardItem3ID    int32 `csv:"Reward道具3ID,omitempty"`
+	RewardItem3Count int32 `csv:"Reward道具3数量,omitempty"`
+	RewardItem4ID    int32 `csv:"Reward道具4ID,omitempty"`
+	RewardItem4Count int32 `csv:"Reward道具4数量,omitempty"`
+	RewardItem5ID    int32 `csv:"Reward道具5ID,omitempty"`
+	RewardItem5Count int32 `csv:"Reward道具5数量,omitempty"`
+	RewardItem6ID    int32 `csv:"Reward道具6ID,omitempty"`
+	RewardItem6Count int32 `csv:"Reward道具6数量,omitempty"`
+	RewardItem7ID    int32 `csv:"Reward道具7ID,omitempty"`
+	RewardItem7Count int32 `csv:"Reward道具7数量,omitempty"`
+	RewardItem8ID    int32 `csv:"Reward道具8ID,omitempty"`
+	RewardItem8Count int32 `csv:"Reward道具8数量,omitempty"`
+	RewardItem9ID    int32 `csv:"Reward道具9ID,omitempty"`
+	RewardItem9Count int32 `csv:"Reward道具9数量,omitempty"`

 	RewardItemMap map[uint32]uint32
 }

 func (g *GameDataConfig) loadRewardData() {
 	g.RewardDataMap = make(map[int32]*RewardData)
-	data := g.readCsvFileData("RewardData.csv")
-	var rewardDataList []*RewardData
-	err := csvutil.Unmarshal(data, &rewardDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	rewardDataList := make([]*RewardData, 0)
+	readTable[RewardData](g.tablePrefix+"RewardData.txt", &rewardDataList)
 	for _, rewardData := range rewardDataList {
 		// list -> map
 		// 奖励物品整合
--- a/gdconf/scene_data.go
+++ b/gdconf/scene_data.go
@@ -1,28 +1,19 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // SceneData 场景配置表
 type SceneData struct {
-	SceneId   int32 `csv:"SceneId"`             // ID
-	SceneType int32 `csv:"SceneType,omitempty"` // 类型
+	SceneId   int32 `csv:"ID"`
+	SceneType int32 `csv:"类型,omitempty"`
 }

 func (g *GameDataConfig) loadSceneData() {
 	g.SceneDataMap = make(map[int32]*SceneData)
-	data := g.readCsvFileData("SceneData.csv")
-	var sceneDataList []*SceneData
-	err := csvutil.Unmarshal(data, &sceneDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	sceneDataList := make([]*SceneData, 0)
+	readTable[SceneData](g.tablePrefix+"SceneData.txt", &sceneDataList)
 	for _, sceneData := range sceneDataList {
 		// list -> map
 		g.SceneDataMap[sceneData.SceneId] = sceneData
--- a/gdconf/scene_tag_data.go
+++ b/gdconf/scene_tag_data.go
@@ -1,28 +1,19 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // SceneTagData 场景标签配置表
 type SceneTagData struct {
-	SceneTagId int32 `csv:"SceneTagId"`        // ID
-	SceneId    int32 `csv:"SceneId,omitempty"` // 场景ID
+	SceneTagId int32 `csv:"ID"`
+	SceneId    int32 `csv:"场景ID,omitempty"`
 }

 func (g *GameDataConfig) loadSceneTagData() {
 	g.SceneTagDataMap = make(map[int32]*SceneTagData)
-	data := g.readCsvFileData("SceneTagData.csv")
-	var sceneTagDataList []*SceneTagData
-	err := csvutil.Unmarshal(data, &sceneTagDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	sceneTagDataList := make([]*SceneTagData, 0)
+	readTable[SceneTagData](g.tablePrefix+"SceneTagData.txt", &sceneTagDataList)
 	for _, sceneTagData := range sceneTagDataList {
 		// list -> map
 		g.SceneTagDataMap[sceneTagData.SceneTagId] = sceneTagData
--- a/gdconf/table_struct_mapping.json
+++ b/gdconf/table_struct_mapping.json
--- a/gdconf/trigger_data.go
+++ b/gdconf/trigger_data.go
@@ -1,30 +1,21 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // TriggerData 场景LUA触发器配置表
 type TriggerData struct {
-	TriggerId   int32  `csv:"TriggerId"`             // ID
-	SceneId     int32  `csv:"SceneId,omitempty"`     // 场景ID
-	GroupId     int32  `csv:"GroupId,omitempty"`     // 组ID
-	TriggerName string `csv:"TriggerName,omitempty"` // 触发器
+	TriggerId   int32  `csv:"ID"`
+	SceneId     int32  `csv:"场景ID,omitempty"`
+	GroupId     int32  `csv:"组ID,omitempty"`
+	TriggerName string `csv:"触发器,omitempty"`
 }

 func (g *GameDataConfig) loadTriggerData() {
 	g.TriggerDataMap = make(map[int32]*TriggerData)
-	data := g.readCsvFileData("TriggerData.csv")
-	var triggerDataList []*TriggerData
-	err := csvutil.Unmarshal(data, &triggerDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	triggerDataList := make([]*TriggerData, 0)
+	readTable[TriggerData](g.tablePrefix+"TriggerData.txt", &triggerDataList)
 	for _, triggerData := range triggerDataList {
 		g.TriggerDataMap[triggerData.TriggerId] = triggerData
 	}
--- a/gdconf/weapon_level_data.go
+++ b/gdconf/weapon_level_data.go
@@ -1,34 +1,25 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // WeaponLevelData 武器等级配置表
 type WeaponLevelData struct {
-	Level      int32 `csv:"Level"`                // 等级
-	ExpByStar1 int32 `csv:"ExpByStar1,omitempty"` // 武器升级经验1
-	ExpByStar2 int32 `csv:"ExpByStar2,omitempty"` // 武器升级经验2
-	ExpByStar3 int32 `csv:"ExpByStar3,omitempty"` // 武器升级经验3
-	ExpByStar4 int32 `csv:"ExpByStar4,omitempty"` // 武器升级经验4
-	ExpByStar5 int32 `csv:"ExpByStar5,omitempty"` // 武器升级经验5
+	Level      int32 `csv:"等级"`
+	ExpByStar1 int32 `csv:"武器升级经验1,omitempty"`
+	ExpByStar2 int32 `csv:"武器升级经验2,omitempty"`
+	ExpByStar3 int32 `csv:"武器升级经验3,omitempty"`
+	ExpByStar4 int32 `csv:"武器升级经验4,omitempty"`
+	ExpByStar5 int32 `csv:"武器升级经验5,omitempty"`

 	ExpByStarMap map[uint32]uint32 // 星级对应武器升级经验
 }

 func (g *GameDataConfig) loadWeaponLevelData() {
 	g.WeaponLevelDataMap = make(map[int32]*WeaponLevelData)
-	data := g.readCsvFileData("WeaponLevelData.csv")
-	var weaponLevelDataList []*WeaponLevelData
-	err := csvutil.Unmarshal(data, &weaponLevelDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	weaponLevelDataList := make([]*WeaponLevelData, 0)
+	readTable[WeaponLevelData](g.tablePrefix+"WeaponLevelData.txt", &weaponLevelDataList)
 	for _, weaponLevelData := range weaponLevelDataList {
 		// list -> map
 		weaponLevelData.ExpByStarMap = map[uint32]uint32{
--- a/gdconf/weapon_promote_data.go
+++ b/gdconf/weapon_promote_data.go
@@ -1,39 +1,30 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // WeaponPromoteData 武器突破配置表
 type WeaponPromoteData struct {
-	PromoteId      int32 `csv:"PromoteId"`                // 武器突破ID
-	PromoteLevel   int32 `csv:"PromoteLevel,omitempty"`   // 突破等级
-	CostItemId1    int32 `csv:"CostItemId1,omitempty"`    // [消耗物品]1ID
-	CostItemCount1 int32 `csv:"CostItemCount1,omitempty"` // [消耗物品]1数量
-	CostItemId2    int32 `csv:"CostItemId2,omitempty"`    // [消耗物品]2ID
-	CostItemCount2 int32 `csv:"CostItemCount2,omitempty"` // [消耗物品]2数量
-	CostItemId3    int32 `csv:"CostItemId3,omitempty"`    // [消耗物品]3ID
-	CostItemCount3 int32 `csv:"CostItemCount3,omitempty"` // [消耗物品]3数量
-	CostCoin       int32 `csv:"CostCoin,omitempty"`       // 突破消耗金币
-	LevelLimit     int32 `csv:"LevelLimit,omitempty"`     // 突破后解锁等级上限
-	MinPlayerLevel int32 `csv:"MinPlayerLevel,omitempty"` // 冒险等级要求
+	PromoteId      int32 `csv:"武器突破ID"`
+	PromoteLevel   int32 `csv:"突破等级,omitempty"`
+	CostItemId1    int32 `csv:"[消耗物品]1ID,omitempty"`
+	CostItemCount1 int32 `csv:"[消耗物品]1数量,omitempty"`
+	CostItemId2    int32 `csv:"[消耗物品]2ID,omitempty"`
+	CostItemCount2 int32 `csv:"[消耗物品]2数量,omitempty"`
+	CostItemId3    int32 `csv:"[消耗物品]3ID,omitempty"`
+	CostItemCount3 int32 `csv:"[消耗物品]3数量,omitempty"`
+	CostCoin       int32 `csv:"突破消耗金币,omitempty"`
+	LevelLimit     int32 `csv:"突破后解锁等级上限,omitempty"`
+	MinPlayerLevel int32 `csv:"冒险等级要求,omitempty"`

 	CostItemMap map[uint32]uint32 // 消耗物品列表
 }

 func (g *GameDataConfig) loadWeaponPromoteData() {
 	g.WeaponPromoteDataMap = make(map[int32]map[int32]*WeaponPromoteData)
-	data := g.readCsvFileData("WeaponPromoteData.csv")
-	var weaponPromoteDataList []*WeaponPromoteData
-	err := csvutil.Unmarshal(data, &weaponPromoteDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	weaponPromoteDataList := make([]*WeaponPromoteData, 0)
+	readTable[WeaponPromoteData](g.tablePrefix+"WeaponPromoteData.txt", &weaponPromoteDataList)
 	for _, weaponPromoteData := range weaponPromoteDataList {
 		// list -> map
 		_, ok := g.WeaponPromoteDataMap[weaponPromoteData.PromoteId]
--- a/gdconf/world_area_data.go
+++ b/gdconf/world_area_data.go
@@ -1,30 +1,21 @@
 package gdconf

 import (
-	"fmt"
-
 	"hk4e/pkg/logger"
-
-	"github.com/jszwec/csvutil"
 )

 // WorldAreaData 世界区域配置表
 type WorldAreaData struct {
-	WorldAreaId int32 `csv:"WorldAreaId"`       // 条目ID
-	SceneId     int32 `csv:"SceneId,omitempty"` // 场景ID
-	AreaId1     int32 `csv:"AreaId1,omitempty"` // 一级区域ID
-	AreaId2     int32 `csv:"AreaId2,omitempty"` // 二级区域ID
+	WorldAreaId int32 `csv:"条目ID"`
+	SceneId     int32 `csv:"场景ID,omitempty"`
+	AreaId1     int32 `csv:"一级区域ID,omitempty"`
+	AreaId2     int32 `csv:"二级区域ID,omitempty"`
 }

 func (g *GameDataConfig) loadWorldAreaData() {
 	g.WorldAreaDataMap = make(map[int32]*WorldAreaData)
-	data := g.readCsvFileData("WorldAreaData.csv")
-	var worldAreaDataList []*WorldAreaData
-	err := csvutil.Unmarshal(data, &worldAreaDataList)
-	if err != nil {
-		info := fmt.Sprintf("parse file error: %v", err)
-		panic(info)
-	}
+	worldAreaDataList := make([]*WorldAreaData, 0)
+	readTable[WorldAreaData](g.tablePrefix+"WorldAreaData.txt", &worldAreaDataList)
 	for _, worldAreaData := range worldAreaDataList {
 		// list -> map
 		g.WorldAreaDataMap[worldAreaData.WorldAreaId] = worldAreaData