فهرست منبع

困难模式相关代码

leitao666 1 سال پیش
والد
کامیت
ddb0a99960

+ 336 - 334
RO_Server_Trunk-branch_0.1.39/roserver/baseserver/router/route_table.go

@@ -5,7 +5,8 @@ type ReqAckKVInfo struct {
 	AckMsgId   int32
 	AckMsgId   int32
 	ReqMsgName string
 	ReqMsgName string
 }
 }
-var(
+
+var (
 	RouteTable = new(MsgRouteList)
 	RouteTable = new(MsgRouteList)
 	//req和ack回复确认匹配协议号
 	//req和ack回复确认匹配协议号
 	ReqAckKVList = map[int]ReqAckKVInfo{}
 	ReqAckKVList = map[int]ReqAckKVInfo{}
@@ -13,345 +14,346 @@ var(
 
 
 func addRule(name string, service string, mod string, id int) {
 func addRule(name string, service string, mod string, id int) {
 	rule := &MsgRouteRule{
 	rule := &MsgRouteRule{
-		MsgName: name,
+		MsgName:     name,
 		ServiceName: service,
 		ServiceName: service,
-		Mod: mod,
-		MsgID: id,
+		Mod:         mod,
+		MsgID:       id,
 	}
 	}
 	RouteTable.Rules = append(RouteTable.Rules, rule)
 	RouteTable.Rules = append(RouteTable.Rules, rule)
 	AddRouteRule(rule)
 	AddRouteRule(rule)
 }
 }
 
 
-//初始化路由信息,或者从服务器发现etcd中获取
-func init(){
-	addRule("CSLoginReq","game,auth","game",1002)
-	addRule("CSReconnectReq","game","game",1004)
-	addRule("CSCreateRoleReq","game","game",1007)
-	addRule("CSNameReq","game","game",1009)
-	addRule("CSGetServerTimeReq","game","game",1016)
-	addRule("CSAddAttrPointReq","game","game",1020)
-	addRule("CSResetAttrPointReq","game","game",1022)
-	addRule("CSActiveHeadReq","game","game",1025)
-	addRule("CSHeadInfoReq","game","game",1027)
-	addRule("CSSetHeadIdReq","game","game",1029)
-	addRule("CSRenameReq","game","game",1031)
-	addRule("CSChangeHeadFrameReq","game","game",1033)
-	addRule("CSHeadFrameInfoReq","game","game",1035)
-	addRule("CSUseHeadFrameItemReq","game","game",1038)
-	addRule("CSHeroLevelUpReq","game","game",1040)
-	addRule("CSHeroAdvanceReq","game","game",1042)
-	addRule("CSHeroBattleReq","game","game",1044)
-	addRule("CSHeroChipDecomposeReq","game","game",1050)
-	addRule("CSHeroStrengthReq","game","game",1052)
-	addRule("CSHeroChangeJobReq","game","game",1054)
-	addRule("CSHeroFighPowerReq","game","game",1057)
-	addRule("CSHeroResetSkillPointReq","game","game",1059)
-	addRule("CSHeroActiveReq","game","game",1061)
-	addRule("CSEquipForgeReq","game","game",1063)
-	addRule("CSEquipUpReq","game","game",1066)
-	addRule("CSEquipDownReq","game","game",1069)
-	addRule("CSEquipLevelUpAllReq","game","game",1070)
-	addRule("CSEquipSlotLevelUpReq","game","game",1072)
-	addRule("CSCardMountReq","game","game",1074)
-	addRule("CSCardDownReq","game","game",1076)
-	addRule("CSCardComposeReq","game","game",1078)
-	addRule("CSCardDecomposeReq","game","game",1080)
-	addRule("CSUseItemReq","game","game",1085)
-	addRule("CSDelItemReq","game","game",1087)
-	addRule("CSChipComposeReq","game","game",1089)
-	addRule("CSCardUpGradeReq","game","game",1092)
-	addRule("CSCardEquipAllReq","game","game",1094)
-	addRule("CSCardEquipDownReq","game","game",1096)
-	addRule("CSCardUpGradeAllReq","game","game",1098)
-	addRule("CSCardCollectInfoReq","game","game",1100)
-	addRule("CSCardCollectRewardReq","game","game",1102)
-	addRule("CSCardCollectionRankReq","game,rank","game",1105)
-	addRule("CSSkillSlotLevelUpReq","game","game",1109)
-	addRule("CSReplaceSkillReq","game","game",1111)
-	addRule("CSActiveSkillReq","game","game",1113)
-	addRule("CSSwapSkillReq","game","game",1115)
-	addRule("CSSetSkillListReq","game","game",1117)
-	addRule("CSSkillLevelUpReq","game","game",1119)
-	addRule("CSResetSkillLevelReq","game","game",1121)
-	addRule("CSFashionUpReq","game","game",1125)
-	addRule("CSFashionDownReq","game","game",1127)
-	addRule("CSFashionComposeReq","game","game",1129)
-	addRule("CSFashionPaperDecomposeReq","game","game",1131)
-	addRule("CSGetOtherPlayerDetailInfoReq","game,social","game",1143)
-	addRule("CSGetOtherPlayerBriefInfoReq","game","game",1145)
-	addRule("CSPlayerChallengeSummonReq","game,battleboss","game",1150)
-	addRule("CSPlayerChallengeHpReq","game,battleboss","game",1153)
-	addRule("CSPlayerLeaveChallengeReq","game,battleboss","game",1155)
-	addRule("CSPlayerWorldBossListReq","game,battleboss","game",1158)
-	addRule("CSChatMessageReq","game,social,guild","game",1162)
-	addRule("CSChatPlayerStateReq","game,social","game",1165)
-	addRule("CSChatOfflineMsgReq","game,db","game",1167)
-	addRule("CSPlayerIncomeReq","game","game",1171)
-	addRule("CSPlayerBossRewardReq","game","game",1173)
-	addRule("CSPlayerBattleRecordDetailSaveReq","battlerecord","battlerecord",1176)
-	addRule("CSPlayerBattleRecordDetailReq","battlerecord","battlerecord",1178)
-	addRule("CSPlayerBattleRecordReq","game,rank","game",1180)
-	addRule("CSGetMapRankReq","game","game",1183)
-	addRule("CSQuickBattleIncomeReq","game","game",1187)
-	addRule("CSBattleBossFightReq","game","game",1189)
-	addRule("CSEvilRefreshReq","game","game",1191)
-	addRule("CSEvilChallengeReq","game","game",1194)
-	addRule("CSGetTaskRewardReq","game","game",1196)
-	addRule("CSGetTaskScoreRewardReq","game","game",1199)
-	addRule("CSArenaReq","game","game",1203)
-	addRule("CSArenaMatchReq","game","game",1204)
-	addRule("CSArenaResultReq","game","game",1206)
-	addRule("CSArenaBuyCountReq","game","game",1208)
-	addRule("CSArenaRankListReq","game","game",1210)
-	addRule("CSArenaActivityReq","game","game",1212)
-	addRule("CSMailListReq","game","game",1216)
-	addRule("CSMailReadReq","game","game",1218)
-	addRule("CSMailRewardReq","game","game",1220)
-	addRule("CSMailDelReadReq","game","game",1222)
-	addRule("CSCompetitionReq","game","game",1225)
-	addRule("CSCompetitionScoreReq","game","game",1228)
-	addRule("CSShopBuyItemReq","game","game",1230)
-	addRule("CSShopInfoReq","game","game",1232)
-	addRule("CSShopRefreshReq","game","game",1234)
-	addRule("CSFriendReq","game","game",1236)
-	addRule("CSFriendAddReq","game","game",1238)
-	addRule("CSFriendDelReq","game","game",1241)
-	addRule("CSFriendBlackReq","game","game",1244)
-	addRule("CSFriendRecommendReq","game","game",1246)
-	addRule("CSFriendSearchReq","game","game",1249)
-	addRule("CSRoleGuideNtf","game","game",1252)
-	addRule("CSRoleStoryReq","game","game",1254)
-	addRule("CSNewMapCartoonReq","game","game",1256)
-	addRule("CSCompulsoryGuidanceReq","game","game",1258)
-	addRule("CSSignUpInfoReq","game","game",1260)
-	addRule("CSSignUpReq","game","game",1262)
-	addRule("CSClimbingTowerInfoReq","game","game",1264)
-	addRule("CSFriendPassTowerInfoReq","game","game",1266)
-	addRule("CSClimbingTowerBeginReq","game","game",1269)
-	addRule("CSClimbingTowerEndReq","game","game",1271)
-	addRule("CSClimbingTowerRankReq","game","game",1273)
-	addRule("CSOnlineRushInfoReq","game","game",1275)
-	addRule("CSTowerActivityReq","game","game",1277)
-	addRule("CSBuildGuildReq","game,guild","game",1281)
-	addRule("CSDisbandGuildReq","game,guild","game",1283)
-	addRule("CSApplyGuildReq","game,guild","game",1285)
-	addRule("CSQuitGuildReq","game,guild","game",1287)
-	addRule("CSKickGuildMemberReq","game,guild","game",1289)
-	addRule("CSChangeMemberTitleReq","game,guild","game",1292)
-	addRule("CSGuildRenameReq","game,guild","game",1295)
-	addRule("CSGuildReNoticeReq","game,guild","game",1297)
-	addRule("CSSetGuildInfoReq","game,guild","game",1299)
-	addRule("CSGuildLogInfoReq","game,guild","game",1301)
-	addRule("CSGuildApplyDataReq","game,guild","game",1303)
-	addRule("CSApplyInfoHandleReq","game,guild","game",1305)
-	addRule("CSGuildInfoReq","game,guild","game",1308)
-	addRule("CSGetSelfGuildInfoReq","game,guild","game",1310)
-	addRule("CSGuildMemberInfoReq","game,guild","game",1312)
-	addRule("CSRecommendGuildInfoReq","game,guild","game",1314)
-	addRule("CSOnlinePlayerGuildReq","game,guild","game",1316)
-	addRule("CSSearchGuildReq","game,guild","game",1318)
-	addRule("CSGuildBossInfoReq","game,guild","game",1321)
-	addRule("CSGuildBossLogReq","game,guild","game",1323)
-	addRule("CSGuildBossChallengeReq","game,guild","game",1325)
-	addRule("CSGuildBossSummonReq","game,guild","game",1327)
-	addRule("CSGuildBossExtraRewardReq","game,guild","game",1329)
-	addRule("CSPetLevelUpReq","game","game",1334)
-	addRule("CSPetAdvanceReq","game","game",1336)
-	addRule("CSPetSkillLevelUpReq","game","game",1338)
-	addRule("CSPetDecomposeReq","game","game",1340)
-	addRule("CSPetBondListReq","game","game",1342)
-	addRule("CSPetBondAssistListReq","game","game",1345)
-	addRule("CSPetBondActiveReq","game","game",1347)
-	addRule("CSPetAssistReq","game","game",1349)
-	addRule("CSPetBattleReq","game","game",1351)
-	addRule("CSPetManualRewardReq","game","game",1353)
-	addRule("CSPetAdvAchievementReq","game","game",1355)
-	addRule("CSExpeditionChallengePreReq","game","game",1358)
-	addRule("CSExpeditionChallengeReq","game","game",1360)
-	addRule("CSExpeditionSelectBuffReq","game","game",1362)
-	addRule("CSExpeditionRewardReq","game","game",1364)
-	addRule("CSExpeditionBattleHeroReq","game","game",1366)
-	addRule("CSExpeditionCallForHelpReq","game","game",1368)
-	addRule("CSExpeditionHelpReq","game","game",1371)
-	addRule("CSActivitiesRewardReq","game","game",1376)
-	addRule("CSActivitiesScoreRewardReq","game","game",1378)
-	addRule("CSActivitiesFirstChargeRewardReq","game","game",1381)
-	addRule("CSInvitationNumberReq","game","game",1386)
-	addRule("CSInvitationNumberUserInfoReq","game","game",1388)
-	addRule("CSInvitationBeToMemberReq","game","game",1390)
-	addRule("CSInvitationClickReq","game","game",1392)
-	addRule("CSInvitationClickReplayReq","game","game",1394)
-	addRule("CSInvitationDelMemberReq","game","game",1396)
-	addRule("CSInvitationTaskRewardReq","game","game",1398)
-	addRule("CSPayInfoGetReq","game","game",1400)
-	addRule("CSPayInfoOrderOKListGetReq","game","game",1403)
-	addRule("CSDaoChang100PlayerInfoReq","game,rank","game",1406)
-	addRule("CSDaoChang100Req","game","game",1408)
-	addRule("CSDaoChang100LogReq","game","game",1410)
-	addRule("CSDaoChang100ChallengeReq","game","game",1412)
-	addRule("CSDaoChang100ChallengeResultReq","game","game",1414)
-	addRule("CSDaoChang100TimeRewardReq","game","game",1415)
-	addRule("CSDaoChang100BuyChallengeCountReq","game","game",1417)
-	addRule("CSGiftRewardReq","game,social,gmweb","game",1419)
-	addRule("CSGMCommandReq","game","game",1421)
-	addRule("CSDrawCardReq","game","game",1424)
-	addRule("CSRuneShopInfoReq","game","game",1426)
-	addRule("CSAntiCheatReq","game","game",1433)
-	addRule("CSQuestionRewardReq","game","game",1435)
-	addRule("CSClientParamNtf","game","game",1437)
-	addRule("CSMapActivityReq","game","game",1438)
-	addRule("CSHeroReplaceJobReq","game","game",1442)
-	addRule("CSDaoChang100SetTipsReq","game","game",1444)
-	addRule("CSOnlineGetKeepSakeReq","game","game",1446)
-	addRule("CSKeepSakeRankReq","game,rank","game",1448)
-	addRule("CSKeepSakeLevelUpReq","game","game",1450)
-	addRule("CSTowerLevelMinFightPowerReq","game","game",1453)
-	addRule("CSActivitiesCollectionServerDataReq","game","game",1455)
-	addRule("CSGuildBattleInfoReq","game,guild","game",1457)
-	addRule("CSGuildBattleSettingReq","game,guild","game",1460)
-	addRule("CSGuildBattleBuyChallengeReq","game,guild","game",1462)
-	addRule("CSGuildBattleRebornReq","game,guild","game",1464)
-	addRule("CSGuildBattleRankListReq","game,guild","game",1466)
-	addRule("CSGuildBattlePosIdxListReq","game,guild","game",1468)
-	addRule("CSGuildBattleLogReq","game,guild","game",1470)
-	addRule("CSGuildBattleChallengeReq","game","game",1472)
-	addRule("CSGuildBattleChallengeResultReq","game,guild","game",1474)
-	addRule("CSGuildBattleChallengePingReq","game,guild","game",1475)
-	addRule("CSGuildBattlePKDataReq","game,guild","game",1477)
-	addRule("CSGuildBattleBuyBuffReq","game,guild","game",1483)
-	addRule("CSGuildBattleCPRankReq","game","game",1487)
-	addRule("CSGuildBattleCountPartReq","game","game",1489)
-	addRule("CSGuildBattleMvpInfoReq","game","game",1491)
-	addRule("CSGuildBattleMvpDetailReq","game","game",1492)
-	addRule("CSExpeditionScoreRankListReq","game","game",1495)
-	addRule("CSDaoChang100WheelReq","game","game",1497)
-	addRule("CSDaoChang100WheelRefreshReq","game","game",1499)
-	addRule("CSDaoChang100WheelOpenRewardReq","game","game",1501)
-	addRule("CSDaoChang100WheelRewardReq","game","game",1503)
-	addRule("CSDaoChang100WheelCloseRewardReq","game","game",1505)
-	addRule("CSFashionUpLvlReq","game","game",1507)
-	addRule("CSFashionResetAttrReq","game","game",1510)
-	addRule("CSExploreInfoReq","game","game",1513)
-	addRule("CSExploreExtraRewardReq","game","game",1515)
-	addRule("CSExploreRewardReq","game","game",1517)
-	addRule("CSDaoChang100WheelLogReq","game,db","game",1519)
-	addRule("CSAccOnlineRewardReq","game,db","game",1523)
-	addRule("CSOnlineTimeRewardReq","game","game",1525)
-	addRule("CSRedBagExchangeReq","game","game",1528)
-	addRule("CSPetActivityReq","game","game",1530)
-	addRule("CSPetActivityRankReq","game,rank","game",1532)
-	addRule("CSAddQualityPointReq","game","game",1536)
-	addRule("CSExpeditionPassRewardReq","game","game",1538)
-	addRule("CSActivitiesLikabilityRewardReq","game","game",1540)
-	addRule("CSActorAttrGetReq","game","game",1542)
-	addRule("CSPetEquipLevelUpReq","game","game",1546)
-	addRule("CSPetEquipUpReq","game","game",1548)
-	addRule("CSPetEquipDownReq","game","game",1550)
-	addRule("CSCompetitionStarInfoReq","game","game",1552)
-	addRule("CSCompetitionStarCloseRewardReq","game","game",1556)
-	addRule("CSCompetitionStarDivineReq","game","game",1559)
-	addRule("CSConverSkillExpReq","game","game",1561)
-	addRule("CSCrossYuanHangTrialRefreshTrialTypeReq","game","game",1564)
-	addRule("CSCrossYuanHangTrialReq","game","game",1566)
-	addRule("CSCrossYuanHangTrialRewardReq","game","game",1568)
-	addRule("CSCrossYuanHangTrialChallengeReq","game","game",1570)
-	addRule("CSCrossYuanHangTrialChallengeResultReq","game","game",1572)
-	addRule("CSCrossYuanHangTrialRankListReq","game","game",1574)
-	addRule("CSCrossYuanHangTrialViewListReq","game","game",1576)
-	addRule("CSCrossYuanHangTrialViewListOutReq","game","game",1578)
-	addRule("CSActivitiesExchangeReq","game","game",1580)
-	addRule("SCActivitiesExchangeAck","game","game",1581)
-	addRule("CSCrossYuanHangTrialInfoReq","game","game",1589)
-	addRule("CSCrossYuanHangTrialLogReq","game","game",1591)
-	addRule("CSRushActivityReq","game","game",1593)
-	addRule("CSRushActivityRewardReq","game","game",1595)
-	addRule("CSRushSkillActivityRankReq","game,rank","game",1597)
-	addRule("CSActivityWheelRefreshReq","game","game",1599)
-	addRule("CSActivityWheelOpenRewardReq","game","game",1601)
-	addRule("CSActivityWheelRewardReq","game","game",1603)
-	addRule("CSActivityWheelCloseRewardReq","game","game",1605)
-	addRule("CSSkillEquipUpReq","game","game",1608)
-	addRule("CSSkillEquipDownReq","game","game",1611)
-	addRule("CSSkillEquipLevelUpReq","game","game",1613)
-	addRule("CSSkillEquipSlotLevelUpReq","game","game",1615)
-	addRule("CSSkillEquipDecomposeReq","game","game",1617)
-	addRule("CSCrossTopTowerFightListReq","game","game",1620)
-	addRule("CSCrossTopTowerChallengeResultReq","game","game",1622)
-	addRule("CSCrossTopTowerForceWinReq","game","game",1624)
-	addRule("CSCrossTopTowerForceWinRankListReq","game","game",1626)
-	addRule("CSCrossTopTowerChallengeReq","game","game",1628)
-	addRule("CSHeadOperateReq","game","game",1631)
-	addRule("CSHeadDataReq","game","game",1633)
-	addRule("CSGCrossGetServerStateReq","game","game",1635)
-	addRule("CSGCrossPlayerEnterMapReq","game","game",1637)
-	addRule("CSGCrossPlayerLeaveMapReq","game","game",1639)
-	addRule("CSGCrossPlayerMapSyncPosReq","game","game",1640)
-	addRule("CSGCrossPlayerShowInfoReq","game","game",1648)
-	addRule("CSSkillEquipRemadeReq","game","game",1650)
-	addRule("CSSkillEquipPoolReq","game","game",1652)
-	addRule("CSGuildDemonInfoReq","game,guild","game",1654)
-	addRule("CSGuildDemonFightReq","game,guild","game",1656)
-	addRule("CSGuildDemonGuildRankReq","game,guild","game",1658)
-	addRule("CSGuildDemonMVPRankReq","game,guild","game",1660)
-	addRule("CSGuildDemonBuyFightCountReq","game","game",1662)
-	addRule("CSActivitySummonReq","game","game",1664)
-	addRule("CSActivitySignInReq","game","game",1666)
-	addRule("CSSkillEquipShiftReq","game","game",1668)
-	addRule("CSCrossTopTowerChallengeViewInfoReq","game","game",1670)
-	addRule("CSGCrossPlayerMapSyncParamReq","game","game",1672)
-	addRule("CSCompetitionOnVoteReq","game","game",1674)
-	addRule("CSCompetitionSelfFansInfoReq","game","game",1676)
-	addRule("CSCompetitionVoteRankReq","game","game",1678)
-	addRule("CSCompetitionFansRewardRankReq","game","game",1680)
-	addRule("CSCompetitionFansGetRewardReq","game","game",1682)
-	addRule("CSCompetitionFansDayRewardReq","game","game",1684)
-	addRule("CSCompetitionGetPlayerVoteRankReq","game","game",1686)
-	addRule("CSPetDetailInfoReq","game","game",1688)
-	addRule("CSWishBoxUseReq","game","game",1690)
-	addRule("CSWishUnlockSlotReq","game","game",1692)
-	addRule("CSWishSlotReq","game","game",1696)
-	addRule("CSActivitiesWordNoticeSetReq","game","game",1698)
-	addRule("CSPetQiyueSlotUnlockReq","game","game",1701)
-	addRule("CSPetQiyueSlotInReq","game","game",1703)
-	addRule("CSPetQiyueSlotOutReq","game","game",1705)
-	addRule("CSPetQiyueBattlePetAttrReq","game","game",1707)
-	addRule("CSCardLevelExchangeReq","game","game",1709)
-	addRule("CSCombineServerInfoReq","game","game",1712)
-	addRule("CSCreditRechargeShopItemBuyReq","game","game",1714)
-	addRule("CSRuneSpecialPrivilegeRewardReq","game","game",1717)
-	addRule("CSClimbingTowerDayRewardReq","game","game",1723)
-	addRule("CSBoliShopLevelUpReq","game","game",1725)
-	addRule("CSBoliShopRewardReq","game","game",1727)
-	addRule("CSBoliShopBuyReq","game","game",1729)
-	addRule("CSBTShopInfoReq","game","game",1736)
-	addRule("CSBoliShopInfoReq","game","game",1738)
-	addRule("CSBTRoCoinShopItemBuyReq","game","game",1740)
-	addRule("CSActivitySmashEggsReq","game","game",1742)
-	addRule("CSActivitySmashEggsMsgReq","game","game",1744)
-	addRule("CSBTFirstRechargeRewardReq","game","game",1747)
-	addRule("CSBTRecharge100RewardReq","game","game",1750)
-	addRule("SSCrossYuanHangTrialViewListReq","crossserver","crossserver",6002)
-	addRule("SSCrossYuanHangTrialReq","crossserver","crossserver",6004)
-	addRule("SSCrossYuanHangTrialChallengeReq","crossserver","crossserver",6006)
-	addRule("SSCrossYuanHangTrialChallengeResultReq","crossserver","crossserver",6008)
-	addRule("SSCrossYuanHangTrialUpdateRankScoreNtf","crossserver","crossserver",6011)
-	addRule("SSCrossYuanHangTrialRankListReq","crossserver","crossserver",6012)
-	addRule("SSCrossYuanHangTrialInfoReq","crossserver","crossserver",6016)
-	addRule("SSCrossYuanHangTrialSelfReq","crossserver","crossserver",6026)
-	addRule("SSCrossRankUpdateNtf","crossrank","crossrank",6028)
-	addRule("SSCrossRankFightInfoUpdateNtf","crossrank","crossrank",6029)
-	addRule("SSCrossTopTowerMatchFightReq","crossrank","crossrank",6030)
-	addRule("SSCrossTopTowerForceWinRankUpdateNtf","crossrank","crossrank",6032)
-	addRule("SSCrossTopTowerForceWinRankListReq","crossrank","crossrank",6033)
-	addRule("SSGCrossMapEnterReq","gcrossmap","gcrossmap",6035)
-	addRule("SSGCrossMapLeaveReq","gcrossmap","gcrossmap",6037)
-	addRule("SSGCrossMapSyncPosReq","gcrossmap","gcrossmap",6040)
-	addRule("SSGCrossMapOtherUnitShowInfoReq","gcrossmap","gcrossmap",6045)
-	addRule("SSGCrossMapUnitShowUpdateNtf","gcrossmap","gcrossmap",6047)
-	addRule("SSGCrossChatMessageReq","gcrossmap","gcrossmap",6048)
-	addRule("SSGCrossMapSyncParamReq","gcrossmap","gcrossmap",6051)
+// 初始化路由信息,或者从服务器发现etcd中获取
+func init() {
+	addRule("CSLoginReq", "game,auth", "game", 1002)
+	addRule("CSReconnectReq", "game", "game", 1004)
+	addRule("CSCreateRoleReq", "game", "game", 1007)
+	addRule("CSNameReq", "game", "game", 1009)
+	addRule("CSGetServerTimeReq", "game", "game", 1016)
+	addRule("CSAddAttrPointReq", "game", "game", 1020)
+	addRule("CSResetAttrPointReq", "game", "game", 1022)
+	addRule("CSActiveHeadReq", "game", "game", 1025)
+	addRule("CSHeadInfoReq", "game", "game", 1027)
+	addRule("CSSetHeadIdReq", "game", "game", 1029)
+	addRule("CSRenameReq", "game", "game", 1031)
+	addRule("CSChangeHeadFrameReq", "game", "game", 1033)
+	addRule("CSHeadFrameInfoReq", "game", "game", 1035)
+	addRule("CSUseHeadFrameItemReq", "game", "game", 1038)
+	addRule("CSHeroLevelUpReq", "game", "game", 1040)
+	addRule("CSHeroAdvanceReq", "game", "game", 1042)
+	addRule("CSHeroBattleReq", "game", "game", 1044)
+	addRule("CSHeroChipDecomposeReq", "game", "game", 1050)
+	addRule("CSHeroStrengthReq", "game", "game", 1052)
+	addRule("CSHeroChangeJobReq", "game", "game", 1054)
+	addRule("CSHeroFighPowerReq", "game", "game", 1057)
+	addRule("CSHeroResetSkillPointReq", "game", "game", 1059)
+	addRule("CSHeroActiveReq", "game", "game", 1061)
+	addRule("CSEquipForgeReq", "game", "game", 1063)
+	addRule("CSEquipUpReq", "game", "game", 1066)
+	addRule("CSEquipDownReq", "game", "game", 1069)
+	addRule("CSEquipLevelUpAllReq", "game", "game", 1070)
+	addRule("CSEquipSlotLevelUpReq", "game", "game", 1072)
+	addRule("CSCardMountReq", "game", "game", 1074)
+	addRule("CSCardDownReq", "game", "game", 1076)
+	addRule("CSCardComposeReq", "game", "game", 1078)
+	addRule("CSCardDecomposeReq", "game", "game", 1080)
+	addRule("CSUseItemReq", "game", "game", 1085)
+	addRule("CSDelItemReq", "game", "game", 1087)
+	addRule("CSChipComposeReq", "game", "game", 1089)
+	addRule("CSCardUpGradeReq", "game", "game", 1092)
+	addRule("CSCardEquipAllReq", "game", "game", 1094)
+	addRule("CSCardEquipDownReq", "game", "game", 1096)
+	addRule("CSCardUpGradeAllReq", "game", "game", 1098)
+	addRule("CSCardCollectInfoReq", "game", "game", 1100)
+	addRule("CSCardCollectRewardReq", "game", "game", 1102)
+	addRule("CSCardCollectionRankReq", "game,rank", "game", 1105)
+	addRule("CSSkillSlotLevelUpReq", "game", "game", 1109)
+	addRule("CSReplaceSkillReq", "game", "game", 1111)
+	addRule("CSActiveSkillReq", "game", "game", 1113)
+	addRule("CSSwapSkillReq", "game", "game", 1115)
+	addRule("CSSetSkillListReq", "game", "game", 1117)
+	addRule("CSSkillLevelUpReq", "game", "game", 1119)
+	addRule("CSResetSkillLevelReq", "game", "game", 1121)
+	addRule("CSFashionUpReq", "game", "game", 1125)
+	addRule("CSFashionDownReq", "game", "game", 1127)
+	addRule("CSFashionComposeReq", "game", "game", 1129)
+	addRule("CSFashionPaperDecomposeReq", "game", "game", 1131)
+	addRule("CSGetOtherPlayerDetailInfoReq", "game,social", "game", 1143)
+	addRule("CSGetOtherPlayerBriefInfoReq", "game", "game", 1145)
+	addRule("CSPlayerChallengeSummonReq", "game,battleboss", "game", 1150)
+	addRule("CSPlayerChallengeHpReq", "game,battleboss", "game", 1153)
+	addRule("CSPlayerLeaveChallengeReq", "game,battleboss", "game", 1155)
+	addRule("CSPlayerWorldBossListReq", "game,battleboss", "game", 1158)
+	addRule("CSChatMessageReq", "game,social,guild", "game", 1162)
+	addRule("CSChatPlayerStateReq", "game,social", "game", 1165)
+	addRule("CSChatOfflineMsgReq", "game,db", "game", 1167)
+	addRule("CSPlayerIncomeReq", "game", "game", 1171)
+	addRule("CSPlayerBossRewardReq", "game", "game", 1173)
+	addRule("CSPlayerBattleRecordDetailSaveReq", "battlerecord", "battlerecord", 1176)
+	addRule("CSPlayerBattleRecordDetailReq", "battlerecord", "battlerecord", 1178)
+	addRule("CSPlayerBattleRecordReq", "game,rank", "game", 1180)
+	addRule("CSGetMapRankReq", "game", "game", 1183)
+	addRule("CSQuickBattleIncomeReq", "game", "game", 1187)
+	addRule("CSBattleBossFightReq", "game", "game", 1189)
+	addRule("CSEvilRefreshReq", "game", "game", 1191)
+	addRule("CSEvilChallengeReq", "game", "game", 1194)
+	addRule("CSGetTaskRewardReq", "game", "game", 1196)
+	addRule("CSGetTaskScoreRewardReq", "game", "game", 1199)
+	addRule("CSArenaReq", "game", "game", 1203)
+	addRule("CSArenaMatchReq", "game", "game", 1204)
+	addRule("CSArenaResultReq", "game", "game", 1206)
+	addRule("CSArenaBuyCountReq", "game", "game", 1208)
+	addRule("CSArenaRankListReq", "game", "game", 1210)
+	addRule("CSArenaActivityReq", "game", "game", 1212)
+	addRule("CSMailListReq", "game", "game", 1216)
+	addRule("CSMailReadReq", "game", "game", 1218)
+	addRule("CSMailRewardReq", "game", "game", 1220)
+	addRule("CSMailDelReadReq", "game", "game", 1222)
+	addRule("CSCompetitionReq", "game", "game", 1225)
+	addRule("CSCompetitionScoreReq", "game", "game", 1228)
+	addRule("CSShopBuyItemReq", "game", "game", 1230)
+	addRule("CSShopInfoReq", "game", "game", 1232)
+	addRule("CSShopRefreshReq", "game", "game", 1234)
+	addRule("CSFriendReq", "game", "game", 1236)
+	addRule("CSFriendAddReq", "game", "game", 1238)
+	addRule("CSFriendDelReq", "game", "game", 1241)
+	addRule("CSFriendBlackReq", "game", "game", 1244)
+	addRule("CSFriendRecommendReq", "game", "game", 1246)
+	addRule("CSFriendSearchReq", "game", "game", 1249)
+	addRule("CSRoleGuideNtf", "game", "game", 1252)
+	addRule("CSRoleStoryReq", "game", "game", 1254)
+	addRule("CSNewMapCartoonReq", "game", "game", 1256)
+	addRule("CSCompulsoryGuidanceReq", "game", "game", 1258)
+	addRule("CSSignUpInfoReq", "game", "game", 1260)
+	addRule("CSSignUpReq", "game", "game", 1262)
+	addRule("CSClimbingTowerInfoReq", "game", "game", 1264)
+	addRule("CSFriendPassTowerInfoReq", "game", "game", 1266)
+	addRule("CSClimbingTowerBeginReq", "game", "game", 1269)
+	addRule("CSClimbingTowerEndReq", "game", "game", 1271)
+	addRule("CSClimbingTowerRankReq", "game", "game", 1273)
+	addRule("CSOnlineRushInfoReq", "game", "game", 1275)
+	addRule("CSTowerActivityReq", "game", "game", 1277)
+	addRule("CSBuildGuildReq", "game,guild", "game", 1281)
+	addRule("CSDisbandGuildReq", "game,guild", "game", 1283)
+	addRule("CSApplyGuildReq", "game,guild", "game", 1285)
+	addRule("CSQuitGuildReq", "game,guild", "game", 1287)
+	addRule("CSKickGuildMemberReq", "game,guild", "game", 1289)
+	addRule("CSChangeMemberTitleReq", "game,guild", "game", 1292)
+	addRule("CSGuildRenameReq", "game,guild", "game", 1295)
+	addRule("CSGuildReNoticeReq", "game,guild", "game", 1297)
+	addRule("CSSetGuildInfoReq", "game,guild", "game", 1299)
+	addRule("CSGuildLogInfoReq", "game,guild", "game", 1301)
+	addRule("CSGuildApplyDataReq", "game,guild", "game", 1303)
+	addRule("CSApplyInfoHandleReq", "game,guild", "game", 1305)
+	addRule("CSGuildInfoReq", "game,guild", "game", 1308)
+	addRule("CSGetSelfGuildInfoReq", "game,guild", "game", 1310)
+	addRule("CSGuildMemberInfoReq", "game,guild", "game", 1312)
+	addRule("CSRecommendGuildInfoReq", "game,guild", "game", 1314)
+	addRule("CSOnlinePlayerGuildReq", "game,guild", "game", 1316)
+	addRule("CSSearchGuildReq", "game,guild", "game", 1318)
+	addRule("CSGuildBossInfoReq", "game,guild", "game", 1321)
+	addRule("CSGuildBossLogReq", "game,guild", "game", 1323)
+	addRule("CSGuildBossChallengeReq", "game,guild", "game", 1325)
+	addRule("CSGuildBossSummonReq", "game,guild", "game", 1327)
+	addRule("CSGuildBossExtraRewardReq", "game,guild", "game", 1329)
+	addRule("CSPetLevelUpReq", "game", "game", 1334)
+	addRule("CSPetAdvanceReq", "game", "game", 1336)
+	addRule("CSPetSkillLevelUpReq", "game", "game", 1338)
+	addRule("CSPetDecomposeReq", "game", "game", 1340)
+	addRule("CSPetBondListReq", "game", "game", 1342)
+	addRule("CSPetBondAssistListReq", "game", "game", 1345)
+	addRule("CSPetBondActiveReq", "game", "game", 1347)
+	addRule("CSPetAssistReq", "game", "game", 1349)
+	addRule("CSPetBattleReq", "game", "game", 1351)
+	addRule("CSPetManualRewardReq", "game", "game", 1353)
+	addRule("CSPetAdvAchievementReq", "game", "game", 1355)
+	addRule("CSExpeditionChallengePreReq", "game", "game", 1358)
+	addRule("CSExpeditionChallengeReq", "game", "game", 1360)
+	addRule("CSExpeditionSelectBuffReq", "game", "game", 1362)
+	addRule("CSExpeditionRewardReq", "game", "game", 1364)
+	addRule("CSExpeditionBattleHeroReq", "game", "game", 1366)
+	addRule("CSExpeditionCallForHelpReq", "game", "game", 1368)
+	addRule("CSExpeditionHelpReq", "game", "game", 1371)
+	addRule("CSActivitiesRewardReq", "game", "game", 1376)
+	addRule("CSActivitiesScoreRewardReq", "game", "game", 1378)
+	addRule("CSActivitiesFirstChargeRewardReq", "game", "game", 1381)
+	addRule("CSInvitationNumberReq", "game", "game", 1386)
+	addRule("CSInvitationNumberUserInfoReq", "game", "game", 1388)
+	addRule("CSInvitationBeToMemberReq", "game", "game", 1390)
+	addRule("CSInvitationClickReq", "game", "game", 1392)
+	addRule("CSInvitationClickReplayReq", "game", "game", 1394)
+	addRule("CSInvitationDelMemberReq", "game", "game", 1396)
+	addRule("CSInvitationTaskRewardReq", "game", "game", 1398)
+	addRule("CSPayInfoGetReq", "game", "game", 1400)
+	addRule("CSPayInfoOrderOKListGetReq", "game", "game", 1403)
+	addRule("CSDaoChang100PlayerInfoReq", "game,rank", "game", 1406)
+	addRule("CSDaoChang100Req", "game", "game", 1408)
+	addRule("CSDaoChang100LogReq", "game", "game", 1410)
+	addRule("CSDaoChang100ChallengeReq", "game", "game", 1412)
+	addRule("CSDaoChang100ChallengeResultReq", "game", "game", 1414)
+	addRule("CSDaoChang100TimeRewardReq", "game", "game", 1415)
+	addRule("CSDaoChang100BuyChallengeCountReq", "game", "game", 1417)
+	addRule("CSGiftRewardReq", "game,social,gmweb", "game", 1419)
+	addRule("CSGMCommandReq", "game", "game", 1421)
+	addRule("CSDrawCardReq", "game", "game", 1424)
+	addRule("CSRuneShopInfoReq", "game", "game", 1426)
+	addRule("CSAntiCheatReq", "game", "game", 1433)
+	addRule("CSQuestionRewardReq", "game", "game", 1435)
+	addRule("CSClientParamNtf", "game", "game", 1437)
+	addRule("CSMapActivityReq", "game", "game", 1438)
+	addRule("CSHeroReplaceJobReq", "game", "game", 1442)
+	addRule("CSDaoChang100SetTipsReq", "game", "game", 1444)
+	addRule("CSOnlineGetKeepSakeReq", "game", "game", 1446)
+	addRule("CSKeepSakeRankReq", "game,rank", "game", 1448)
+	addRule("CSKeepSakeLevelUpReq", "game", "game", 1450)
+	addRule("CSTowerLevelMinFightPowerReq", "game", "game", 1453)
+	addRule("CSActivitiesCollectionServerDataReq", "game", "game", 1455)
+	addRule("CSGuildBattleInfoReq", "game,guild", "game", 1457)
+	addRule("CSGuildBattleSettingReq", "game,guild", "game", 1460)
+	addRule("CSGuildBattleBuyChallengeReq", "game,guild", "game", 1462)
+	addRule("CSGuildBattleRebornReq", "game,guild", "game", 1464)
+	addRule("CSGuildBattleRankListReq", "game,guild", "game", 1466)
+	addRule("CSGuildBattlePosIdxListReq", "game,guild", "game", 1468)
+	addRule("CSGuildBattleLogReq", "game,guild", "game", 1470)
+	addRule("CSGuildBattleChallengeReq", "game", "game", 1472)
+	addRule("CSGuildBattleChallengeResultReq", "game,guild", "game", 1474)
+	addRule("CSGuildBattleChallengePingReq", "game,guild", "game", 1475)
+	addRule("CSGuildBattlePKDataReq", "game,guild", "game", 1477)
+	addRule("CSGuildBattleBuyBuffReq", "game,guild", "game", 1483)
+	addRule("CSGuildBattleCPRankReq", "game", "game", 1487)
+	addRule("CSGuildBattleCountPartReq", "game", "game", 1489)
+	addRule("CSGuildBattleMvpInfoReq", "game", "game", 1491)
+	addRule("CSGuildBattleMvpDetailReq", "game", "game", 1492)
+	addRule("CSExpeditionScoreRankListReq", "game", "game", 1495)
+	addRule("CSDaoChang100WheelReq", "game", "game", 1497)
+	addRule("CSDaoChang100WheelRefreshReq", "game", "game", 1499)
+	addRule("CSDaoChang100WheelOpenRewardReq", "game", "game", 1501)
+	addRule("CSDaoChang100WheelRewardReq", "game", "game", 1503)
+	addRule("CSDaoChang100WheelCloseRewardReq", "game", "game", 1505)
+	addRule("CSFashionUpLvlReq", "game", "game", 1507)
+	addRule("CSFashionResetAttrReq", "game", "game", 1510)
+	addRule("CSExploreInfoReq", "game", "game", 1513)
+	addRule("CSExploreExtraRewardReq", "game", "game", 1515)
+	addRule("CSExploreRewardReq", "game", "game", 1517)
+	addRule("CSDaoChang100WheelLogReq", "game,db", "game", 1519)
+	addRule("CSAccOnlineRewardReq", "game,db", "game", 1523)
+	addRule("CSOnlineTimeRewardReq", "game", "game", 1525)
+	addRule("CSRedBagExchangeReq", "game", "game", 1528)
+	addRule("CSPetActivityReq", "game", "game", 1530)
+	addRule("CSPetActivityRankReq", "game,rank", "game", 1532)
+	addRule("CSAddQualityPointReq", "game", "game", 1536)
+	addRule("CSExpeditionPassRewardReq", "game", "game", 1538)
+	addRule("CSActivitiesLikabilityRewardReq", "game", "game", 1540)
+	addRule("CSActorAttrGetReq", "game", "game", 1542)
+	addRule("CSPetEquipLevelUpReq", "game", "game", 1546)
+	addRule("CSPetEquipUpReq", "game", "game", 1548)
+	addRule("CSPetEquipDownReq", "game", "game", 1550)
+	addRule("CSCompetitionStarInfoReq", "game", "game", 1552)
+	addRule("CSCompetitionStarCloseRewardReq", "game", "game", 1556)
+	addRule("CSCompetitionStarDivineReq", "game", "game", 1559)
+	addRule("CSConverSkillExpReq", "game", "game", 1561)
+	addRule("CSCrossYuanHangTrialRefreshTrialTypeReq", "game", "game", 1564)
+	addRule("CSCrossYuanHangTrialReq", "game", "game", 1566)
+	addRule("CSCrossYuanHangTrialRewardReq", "game", "game", 1568)
+	addRule("CSCrossYuanHangTrialChallengeReq", "game", "game", 1570)
+	addRule("CSCrossYuanHangTrialChallengeResultReq", "game", "game", 1572)
+	addRule("CSCrossYuanHangTrialRankListReq", "game", "game", 1574)
+	addRule("CSCrossYuanHangTrialViewListReq", "game", "game", 1576)
+	addRule("CSCrossYuanHangTrialViewListOutReq", "game", "game", 1578)
+	addRule("CSActivitiesExchangeReq", "game", "game", 1580)
+	addRule("SCActivitiesExchangeAck", "game", "game", 1581)
+	addRule("CSCrossYuanHangTrialInfoReq", "game", "game", 1589)
+	addRule("CSCrossYuanHangTrialLogReq", "game", "game", 1591)
+	addRule("CSRushActivityReq", "game", "game", 1593)
+	addRule("CSRushActivityRewardReq", "game", "game", 1595)
+	addRule("CSRushSkillActivityRankReq", "game,rank", "game", 1597)
+	addRule("CSActivityWheelRefreshReq", "game", "game", 1599)
+	addRule("CSActivityWheelOpenRewardReq", "game", "game", 1601)
+	addRule("CSActivityWheelRewardReq", "game", "game", 1603)
+	addRule("CSActivityWheelCloseRewardReq", "game", "game", 1605)
+	addRule("CSSkillEquipUpReq", "game", "game", 1608)
+	addRule("CSSkillEquipDownReq", "game", "game", 1611)
+	addRule("CSSkillEquipLevelUpReq", "game", "game", 1613)
+	addRule("CSSkillEquipSlotLevelUpReq", "game", "game", 1615)
+	addRule("CSSkillEquipDecomposeReq", "game", "game", 1617)
+	addRule("CSCrossTopTowerFightListReq", "game", "game", 1620)
+	addRule("CSCrossTopTowerChallengeResultReq", "game", "game", 1622)
+	addRule("CSCrossTopTowerForceWinReq", "game", "game", 1624)
+	addRule("CSCrossTopTowerForceWinRankListReq", "game", "game", 1626)
+	addRule("CSCrossTopTowerChallengeReq", "game", "game", 1628)
+	addRule("CSHeadOperateReq", "game", "game", 1631)
+	addRule("CSHeadDataReq", "game", "game", 1633)
+	addRule("CSGCrossGetServerStateReq", "game", "game", 1635)
+	addRule("CSGCrossPlayerEnterMapReq", "game", "game", 1637)
+	addRule("CSGCrossPlayerLeaveMapReq", "game", "game", 1639)
+	addRule("CSGCrossPlayerMapSyncPosReq", "game", "game", 1640)
+	addRule("CSGCrossPlayerShowInfoReq", "game", "game", 1648)
+	addRule("CSSkillEquipRemadeReq", "game", "game", 1650)
+	addRule("CSSkillEquipPoolReq", "game", "game", 1652)
+	addRule("CSGuildDemonInfoReq", "game,guild", "game", 1654)
+	addRule("CSGuildDemonFightReq", "game,guild", "game", 1656)
+	addRule("CSGuildDemonGuildRankReq", "game,guild", "game", 1658)
+	addRule("CSGuildDemonMVPRankReq", "game,guild", "game", 1660)
+	addRule("CSGuildDemonBuyFightCountReq", "game", "game", 1662)
+	addRule("CSActivitySummonReq", "game", "game", 1664)
+	addRule("CSActivitySignInReq", "game", "game", 1666)
+	addRule("CSSkillEquipShiftReq", "game", "game", 1668)
+	addRule("CSCrossTopTowerChallengeViewInfoReq", "game", "game", 1670)
+	addRule("CSGCrossPlayerMapSyncParamReq", "game", "game", 1672)
+	addRule("CSCompetitionOnVoteReq", "game", "game", 1674)
+	addRule("CSCompetitionSelfFansInfoReq", "game", "game", 1676)
+	addRule("CSCompetitionVoteRankReq", "game", "game", 1678)
+	addRule("CSCompetitionFansRewardRankReq", "game", "game", 1680)
+	addRule("CSCompetitionFansGetRewardReq", "game", "game", 1682)
+	addRule("CSCompetitionFansDayRewardReq", "game", "game", 1684)
+	addRule("CSCompetitionGetPlayerVoteRankReq", "game", "game", 1686)
+	addRule("CSPetDetailInfoReq", "game", "game", 1688)
+	addRule("CSWishBoxUseReq", "game", "game", 1690)
+	addRule("CSWishUnlockSlotReq", "game", "game", 1692)
+	addRule("CSWishSlotReq", "game", "game", 1696)
+	addRule("CSActivitiesWordNoticeSetReq", "game", "game", 1698)
+	addRule("CSPetQiyueSlotUnlockReq", "game", "game", 1701)
+	addRule("CSPetQiyueSlotInReq", "game", "game", 1703)
+	addRule("CSPetQiyueSlotOutReq", "game", "game", 1705)
+	addRule("CSPetQiyueBattlePetAttrReq", "game", "game", 1707)
+	addRule("CSCardLevelExchangeReq", "game", "game", 1709)
+	addRule("CSCombineServerInfoReq", "game", "game", 1712)
+	addRule("CSCreditRechargeShopItemBuyReq", "game", "game", 1714)
+	addRule("CSRuneSpecialPrivilegeRewardReq", "game", "game", 1717)
+	addRule("CSClimbingTowerDayRewardReq", "game", "game", 1723)
+	addRule("CSBoliShopLevelUpReq", "game", "game", 1725)
+	addRule("CSBoliShopRewardReq", "game", "game", 1727)
+	addRule("CSBoliShopBuyReq", "game", "game", 1729)
+	addRule("CSBTShopInfoReq", "game", "game", 1736)
+	addRule("CSBoliShopInfoReq", "game", "game", 1738)
+	addRule("CSBTRoCoinShopItemBuyReq", "game", "game", 1740)
+	addRule("CSActivitySmashEggsReq", "game", "game", 1742)
+	addRule("CSActivitySmashEggsMsgReq", "game", "game", 1744)
+	addRule("CSBTFirstRechargeRewardReq", "game", "game", 1747)
+	addRule("CSBTRecharge100RewardReq", "game", "game", 1750)
+	addRule("CSMapLevelTypeChangeReq", "game", "game", 1752)
+	addRule("SSCrossYuanHangTrialViewListReq", "crossserver", "crossserver", 6002)
+	addRule("SSCrossYuanHangTrialReq", "crossserver", "crossserver", 6004)
+	addRule("SSCrossYuanHangTrialChallengeReq", "crossserver", "crossserver", 6006)
+	addRule("SSCrossYuanHangTrialChallengeResultReq", "crossserver", "crossserver", 6008)
+	addRule("SSCrossYuanHangTrialUpdateRankScoreNtf", "crossserver", "crossserver", 6011)
+	addRule("SSCrossYuanHangTrialRankListReq", "crossserver", "crossserver", 6012)
+	addRule("SSCrossYuanHangTrialInfoReq", "crossserver", "crossserver", 6016)
+	addRule("SSCrossYuanHangTrialSelfReq", "crossserver", "crossserver", 6026)
+	addRule("SSCrossRankUpdateNtf", "crossrank", "crossrank", 6028)
+	addRule("SSCrossRankFightInfoUpdateNtf", "crossrank", "crossrank", 6029)
+	addRule("SSCrossTopTowerMatchFightReq", "crossrank", "crossrank", 6030)
+	addRule("SSCrossTopTowerForceWinRankUpdateNtf", "crossrank", "crossrank", 6032)
+	addRule("SSCrossTopTowerForceWinRankListReq", "crossrank", "crossrank", 6033)
+	addRule("SSGCrossMapEnterReq", "gcrossmap", "gcrossmap", 6035)
+	addRule("SSGCrossMapLeaveReq", "gcrossmap", "gcrossmap", 6037)
+	addRule("SSGCrossMapSyncPosReq", "gcrossmap", "gcrossmap", 6040)
+	addRule("SSGCrossMapOtherUnitShowInfoReq", "gcrossmap", "gcrossmap", 6045)
+	addRule("SSGCrossMapUnitShowUpdateNtf", "gcrossmap", "gcrossmap", 6047)
+	addRule("SSGCrossChatMessageReq", "gcrossmap", "gcrossmap", 6048)
+	addRule("SSGCrossMapSyncParamReq", "gcrossmap", "gcrossmap", 6051)
 
 
- 	//req和ack消息映射处理
+	//req和ack消息映射处理
 	ReqAckKVList[1000] = ReqAckKVInfo{1000, 1001, "CSPingReq|SCPingAck"}
 	ReqAckKVList[1000] = ReqAckKVInfo{1000, 1001, "CSPingReq|SCPingAck"}
 	ReqAckKVList[1002] = ReqAckKVInfo{1002, 1003, "CSLoginReq|SCLoginAck"}
 	ReqAckKVList[1002] = ReqAckKVInfo{1002, 1003, "CSLoginReq|SCLoginAck"}
 	ReqAckKVList[1004] = ReqAckKVInfo{1004, 1005, "CSReconnectReq|SCReconnectAck"}
 	ReqAckKVList[1004] = ReqAckKVInfo{1004, 1005, "CSReconnectReq|SCReconnectAck"}
@@ -636,4 +638,4 @@ func init(){
 	ReqAckKVList[1747] = ReqAckKVInfo{1747, 1748, "CSBTFirstRechargeRewardReq|SCBTFirstRechargeRewardAck"}
 	ReqAckKVList[1747] = ReqAckKVInfo{1747, 1748, "CSBTFirstRechargeRewardReq|SCBTFirstRechargeRewardAck"}
 	ReqAckKVList[1750] = ReqAckKVInfo{1750, 1751, "CSBTRecharge100RewardReq|SCBTRecharge100RewardAck"}
 	ReqAckKVList[1750] = ReqAckKVInfo{1750, 1751, "CSBTRecharge100RewardReq|SCBTRecharge100RewardAck"}
 	ReqAckKVList[1752] = ReqAckKVInfo{1752, 1753, "CSMapLevelTypeChangeReq|SCMapLevelTypeChangeAck"}
 	ReqAckKVList[1752] = ReqAckKVInfo{1752, 1753, "CSMapLevelTypeChangeReq|SCMapLevelTypeChangeAck"}
-}
+}

+ 1 - 1
RO_Server_Trunk-branch_0.1.39/roserver/battleboss/model/boss_manager.go

@@ -524,7 +524,7 @@ func (this *WorldBossManager) PlayerChallengeSummonBoss(uid, challengeBossUid ui
 		if bossInfo.finish {
 		if bossInfo.finish {
 			delete(this.challengePlayerList, uid)
 			delete(this.challengePlayerList, uid)
 		} else {
 		} else {
-			bossInfo.leaveNotify(uid, false)
+			bossInfo.leaveNotify(uid, true)
 			//util.InfoF("PlayerChallengeSummonBoss already in other boss=%v uid=%v", bossInfo, uid)
 			//util.InfoF("PlayerChallengeSummonBoss already in other boss=%v uid=%v", bossInfo, uid)
 			//return serverproto.ErrorCode_ERROR_AOI_BOSS_CHALLENGING
 			//return serverproto.ErrorCode_ERROR_AOI_BOSS_CHALLENGING
 		}
 		}

+ 2 - 0
RO_Server_Trunk-branch_0.1.39/roserver/game/model/role_activity.go

@@ -3119,6 +3119,7 @@ func (this *RoleActivity) OtherExchangeCheck(useItemList []*serverproto.Exchange
 // 扣除宠物兑换道具
 // 扣除宠物兑换道具
 func (this *RoleActivity) DelPetExchangeItem(useItemList []*serverproto.ExchangeInfo) serverproto.ErrorCode {
 func (this *RoleActivity) DelPetExchangeItem(useItemList []*serverproto.ExchangeInfo) serverproto.ErrorCode {
 	if len(useItemList) <= 0 {
 	if len(useItemList) <= 0 {
+		util.ErrorF("uid=%v del pet error useItemList is nil:", this.role.GetUUid())
 		return serverproto.ErrorCode_ERROR_FAIL
 		return serverproto.ErrorCode_ERROR_FAIL
 	}
 	}
 	//删除消耗的宠物
 	//删除消耗的宠物
@@ -3128,6 +3129,7 @@ func (this *RoleActivity) DelPetExchangeItem(useItemList []*serverproto.Exchange
 			costPet := this.role.GetRolePet().getPet(uint32(data.Key))
 			costPet := this.role.GetRolePet().getPet(uint32(data.Key))
 			//上阵宠物和契约宠物无法作为兑换材料
 			//上阵宠物和契约宠物无法作为兑换材料
 			if costPet == nil || costPet.HeroId > 0 || costPet.QiyueHeroId > 0 {
 			if costPet == nil || costPet.HeroId > 0 || costPet.QiyueHeroId > 0 {
+				util.ErrorF("uid=%v del pet error costPet:%v :", this.role.GetUUid(), costPet)
 				return serverproto.ErrorCode_ERROR_FAIL
 				return serverproto.ErrorCode_ERROR_FAIL
 			}
 			}
 			delPetList = append(delPetList, uint32(data.Key))
 			delPetList = append(delPetList, uint32(data.Key))

+ 67 - 30
RO_Server_Trunk-branch_0.1.39/roserver/game/model/role_battle.go

@@ -906,23 +906,28 @@ func (this *RoleBattle) GMIncome(incomeTime int32) {
 	util.DebugF("uid=%v GMIncome incomenum=%v dropList=%v", this.role.GetUUid(), incomeNum, ackMsg)
 	util.DebugF("uid=%v GMIncome incomenum=%v dropList=%v", this.role.GetUUid(), incomeNum, ackMsg)
 }
 }
 
 
-func (this *RoleBattle) GMSetMapLevel(mapId, mapLevel uint32) {
+func (this *RoleBattle) GMSetMapLevel(mapId, mapLevel uint32, b bool) {
 	//关卡数据不存在
 	//关卡数据不存在
 	levelId := this.getLevelId(mapId, mapLevel)
 	levelId := this.getLevelId(mapId, mapLevel)
 	_, ok := serverproto.LevelCfgLoader[levelId]
 	_, ok := serverproto.LevelCfgLoader[levelId]
 	if !ok {
 	if !ok {
 		return
 		return
 	}
 	}
+	if b {
+		this.mapIdHard = mapId
+		this.mapLevelHard = mapLevel
+		this.SetDirty(true)
+	} else {
+		rewardCount := this.getDeltaMapCount(this.mapId, this.mapLevel, mapId, mapLevel)
 
 
-	rewardCount := this.getDeltaMapCount(this.mapId, this.mapLevel, mapId, mapLevel)
-
-	oldMapId := this.mapId
-	oldMapLevel := this.mapLevel
-	this.mapId = mapId
-	this.mapLevel = mapLevel
-	this.SetDirty(true)
-	//修改地图通关排名(需要通关该关卡)
-	this.addMapRank(rewardCount, oldMapId, oldMapLevel, 0, 0)
+		oldMapId := this.mapId
+		oldMapLevel := this.mapLevel
+		this.mapId = mapId
+		this.mapLevel = mapLevel
+		this.SetDirty(true)
+		//修改地图通关排名(需要通关该关卡)
+		this.addMapRank(rewardCount, oldMapId, oldMapLevel, 0, 0)
+	}
 
 
 	this.changeBattleDataNtf()
 	this.changeBattleDataNtf()
 }
 }
@@ -1077,27 +1082,56 @@ func (this *RoleBattle) BossReward(challengeTime uint32, mapId, mapLevel uint32,
 	oldMapId := this.mapId
 	oldMapId := this.mapId
 	oldMapLevel := this.mapLevel
 	oldMapLevel := this.mapLevel
 	var addItemList = map[int32]int32{}
 	var addItemList = map[int32]int32{}
-	//baseExp
-	addItemList[int32(serverproto.ResType_Res_RoleBaseExp)] = levelCfgData.BaseExp
-	//伙伴经验
-	addItemList[int32(serverproto.ResType_Res_HeroBaseExp)] = levelCfgData.Parter
-	//jobExp
-	addItemList[int32(serverproto.ResType_Res_RoleJobExp)] = levelCfgData.JobExp
-	//rmb
-	addItemList[int32(serverproto.ResType_Res_Rmb)] = levelCfgData.Gold
-	//通关免费充值额度
-	addItemList[int32(serverproto.ResType_Res_CreditRecharge)] = levelCfgData.FreeInvest
-	//cash//做活动时间判定,活动时间内才给
-	if !this.role.FuncDisable() {
-		if ok := CheckHDItemAdd(int32(serverproto.ResType_Res_CashTicket), this.role); ok && (levelCfgData.Cash != 0) {
-			addItemList[int32(serverproto.ResType_Res_CashTicket)] = levelCfgData.Cash
+	if isHard {
+		hardLevelCfgData, ok2 := serverproto.HardLevelCfgLoader[levelId]
+		if !ok2 {
+			return serverproto.ErrorCode_ERROR_BATTLE_LEVEL_DATA_NOT_FOUND
+		}
+		//baseExp
+		addItemList[int32(serverproto.ResType_Res_RoleBaseExp)] = hardLevelCfgData.BaseExp
+		//伙伴经验
+		addItemList[int32(serverproto.ResType_Res_HeroBaseExp)] = hardLevelCfgData.Parter
+		//jobExp
+		addItemList[int32(serverproto.ResType_Res_RoleJobExp)] = hardLevelCfgData.JobExp
+		//rmb
+		addItemList[int32(serverproto.ResType_Res_Rmb)] = hardLevelCfgData.Gold
+		//通关免费充值额度
+		addItemList[int32(serverproto.ResType_Res_CreditRecharge)] = hardLevelCfgData.FreeInvest
+		//cash//做活动时间判定,活动时间内才给
+		if !this.role.FuncDisable() {
+			if ok := CheckHDItemAdd(int32(serverproto.ResType_Res_CashTicket), this.role); ok && (hardLevelCfgData.Cash != 0) {
+				addItemList[int32(serverproto.ResType_Res_CashTicket)] = hardLevelCfgData.Cash
+			}
+		}
+		//coin
+		addItemList[int32(serverproto.ResType_Res_Coin)] = hardLevelCfgData.Zeny
+		dropId := this.genDropId(model.LevelDropBossDataList, levelId) //放到income中领取
+		for idx := 0; idx < len(dropId); idx++ {
+			this.DropProcess(addItemList, dropId[idx])
+		}
+	} else {
+		//baseExp
+		addItemList[int32(serverproto.ResType_Res_RoleBaseExp)] = levelCfgData.BaseExp
+		//伙伴经验
+		addItemList[int32(serverproto.ResType_Res_HeroBaseExp)] = levelCfgData.Parter
+		//jobExp
+		addItemList[int32(serverproto.ResType_Res_RoleJobExp)] = levelCfgData.JobExp
+		//rmb
+		addItemList[int32(serverproto.ResType_Res_Rmb)] = levelCfgData.Gold
+		//通关免费充值额度
+		addItemList[int32(serverproto.ResType_Res_CreditRecharge)] = levelCfgData.FreeInvest
+		//cash//做活动时间判定,活动时间内才给
+		if !this.role.FuncDisable() {
+			if ok := CheckHDItemAdd(int32(serverproto.ResType_Res_CashTicket), this.role); ok && (levelCfgData.Cash != 0) {
+				addItemList[int32(serverproto.ResType_Res_CashTicket)] = levelCfgData.Cash
+			}
+		}
+		//coin
+		addItemList[int32(serverproto.ResType_Res_Coin)] = levelCfgData.Zeny
+		dropId := this.genDropId(model.LevelDropBossDataList, levelId) //放到income中领取
+		for idx := 0; idx < len(dropId); idx++ {
+			this.DropProcess(addItemList, dropId[idx])
 		}
 		}
-	}
-	//coin
-	addItemList[int32(serverproto.ResType_Res_Coin)] = levelCfgData.Zeny
-	dropId := this.genDropId(model.LevelDropBossDataList, levelId) //放到income中领取
-	for idx := 0; idx < len(dropId); idx++ {
-		this.DropProcess(addItemList, dropId[idx])
 	}
 	}
 	this.role.AddItemList(addItemList, AddFrom_Battle, true)
 	this.role.AddItemList(addItemList, AddFrom_Battle, true)
 
 
@@ -1216,6 +1250,9 @@ func (this *RoleBattle) bossRewardCheck(challengeTime uint32, mapId, mapLevel ui
 func (this *RoleBattle) mapFightCheck() serverproto.ErrorCode {
 func (this *RoleBattle) mapFightCheck() serverproto.ErrorCode {
 	//战斗力校验
 	//战斗力校验
 	levelId := this.getLevelId(this.mapId, this.mapLevel)
 	levelId := this.getLevelId(this.mapId, this.mapLevel)
+	if this.role.GetHardFight() {
+		levelId = this.getLevelId(this.mapIdHard, this.mapLevelHard)
+	}
 	levelCfgData, ok := serverproto.LevelCfgLoader[levelId]
 	levelCfgData, ok := serverproto.LevelCfgLoader[levelId]
 	if !ok {
 	if !ok {
 		return serverproto.ErrorCode_ERROR_BATTLE_LEVEL_DATA_NOT_FOUND
 		return serverproto.ErrorCode_ERROR_BATTLE_LEVEL_DATA_NOT_FOUND

+ 52 - 49
RO_Server_Trunk-branch_0.1.39/roserver/game/model/role_battle_attr.go

@@ -21,7 +21,7 @@ func (this *Role) GetActorAttr(reqMsg *serverproto.CSActorAttrGetReq) {
 	}
 	}
 }
 }
 
 
-//属性变更类型
+// 属性变更类型
 const (
 const (
 	Attr_Change_None             = 0
 	Attr_Change_None             = 0
 	Attr_Change_Fashion          = 1  //时装数据变更
 	Attr_Change_Fashion          = 1  //时装数据变更
@@ -331,7 +331,7 @@ func (this *ActorAttr) isFront() bool {
 	return this.positionValue <= 3
 	return this.positionValue <= 3
 }
 }
 
 
-//first
+// first
 func (this *ActorAttr) STR() int32 {
 func (this *ActorAttr) STR() int32 {
 	return this.baseStr + int32(this.GetAdditionalAttr(serverproto.Attr_Str))
 	return this.baseStr + int32(this.GetAdditionalAttr(serverproto.Attr_Str))
 }
 }
@@ -351,7 +351,7 @@ func (this *ActorAttr) LUK() int32 {
 	return this.baseLuk + int32(this.GetAdditionalAttr(serverproto.Attr_Luk))
 	return this.baseLuk + int32(this.GetAdditionalAttr(serverproto.Attr_Luk))
 }
 }
 
 
-//second
+// second
 func (this *ActorAttr) Life() float64 {
 func (this *ActorAttr) Life() float64 {
 	return this.calcSecondAttrForLife(serverproto.Attr_Life)
 	return this.calcSecondAttrForLife(serverproto.Attr_Life)
 }
 }
@@ -403,27 +403,27 @@ func (this *ActorAttr) CastAcce() float32 {
 	//return this.calcSecondAttr(serverproto.Attr_CastAcce)
 	//return this.calcSecondAttr(serverproto.Attr_CastAcce)
 }
 }
 
 
-//暴击伤害百分比
+// 暴击伤害百分比
 func (this *ActorAttr) CritDamagePercent() float32 {
 func (this *ActorAttr) CritDamagePercent() float32 {
 	return this.GetAdditionalAttrPercent(serverproto.Attr_CritDamage_Percent)
 	return this.GetAdditionalAttrPercent(serverproto.Attr_CritDamage_Percent)
 }
 }
 
 
-//忽视物防
+// 忽视物防
 func (this *ActorAttr) Penetration() float32 {
 func (this *ActorAttr) Penetration() float32 {
 	return this.GetAdditionalAttrPercent(serverproto.Attr_Penetration_Percent)
 	return this.GetAdditionalAttrPercent(serverproto.Attr_Penetration_Percent)
 }
 }
 
 
-//忽视魔防
+// 忽视魔防
 func (this *ActorAttr) MagicPenetration() float32 {
 func (this *ActorAttr) MagicPenetration() float32 {
 	return this.GetAdditionalAttrPercent(serverproto.Attr_Magic_Penetration_Percent)
 	return this.GetAdditionalAttrPercent(serverproto.Attr_Magic_Penetration_Percent)
 }
 }
 
 
-//防御百分比
+// 防御百分比
 func (this *ActorAttr) DefPercent() float32 {
 func (this *ActorAttr) DefPercent() float32 {
 	return this.GetAdditionalAttrPercent(serverproto.Attr_Defense_Percent)
 	return this.GetAdditionalAttrPercent(serverproto.Attr_Defense_Percent)
 }
 }
 
 
-//魔防百分比
+// 魔防百分比
 func (this *ActorAttr) MagicDefPercent() float32 {
 func (this *ActorAttr) MagicDefPercent() float32 {
 	return this.GetAdditionalAttrPercent(serverproto.Attr_MagicDefense_Percent)
 	return this.GetAdditionalAttrPercent(serverproto.Attr_MagicDefense_Percent)
 }
 }
@@ -562,7 +562,7 @@ func (this *ActorAttr) baseCastAcce() float32 {
 	return p1 * float32(this.DEX())
 	return p1 * float32(this.DEX())
 }
 }
 
 
-//获得二级基础属性
+// 获得二级基础属性
 func (this *ActorAttr) getAttr(attrId serverproto.Attr) float32 {
 func (this *ActorAttr) getAttr(attrId serverproto.Attr) float32 {
 	if attrId < serverproto.Attr_Life {
 	if attrId < serverproto.Attr_Life {
 		return 0
 		return 0
@@ -632,7 +632,7 @@ func (this *ActorAttr) getBaseSecondAttr(attrId serverproto.Attr) float32 {
 	return 0
 	return 0
 }
 }
 
 
-//life需要处理成64位
+// life需要处理成64位
 func (this *ActorAttr) calcSecondAttrForLife(attrId serverproto.Attr) float64 {
 func (this *ActorAttr) calcSecondAttrForLife(attrId serverproto.Attr) float64 {
 	if attrId < serverproto.Attr_Life || attrId > serverproto.Attr_CastAcce {
 	if attrId < serverproto.Attr_Life || attrId > serverproto.Attr_CastAcce {
 		return 0
 		return 0
@@ -815,10 +815,13 @@ func (this *ActorAttr) calActorAttr(heroData *serverproto.HeroData, attrList []*
 			IsHeroPet: true,
 			IsHeroPet: true,
 			ActorId:   uint32(heroData.Id),
 			ActorId:   uint32(heroData.Id),
 		}
 		}
+		//util.InfoF("aaaaa3", this.attrPercent)
 		//代码优化,避免频繁出现扩容操作
 		//代码优化,避免频繁出现扩容操作
 		ntfAttrType.AttrList = make([]*serverproto.KeyValueFloat32, 0, 16)
 		ntfAttrType.AttrList = make([]*serverproto.KeyValueFloat32, 0, 16)
 		this.attrMag.copyAttrToMsg(this, ntfAttrType)
 		this.attrMag.copyAttrToMsg(this, ntfAttrType)
 		//计算战力
 		//计算战力
+		//util.InfoF("aaaaaaa", ntfAttrType)
+		//util.InfoF("aaaaaaa22", heroData)
 		heroFightPower := this.calcActorFightPower(ntfAttrType.AttrList)
 		heroFightPower := this.calcActorFightPower(ntfAttrType.AttrList)
 		this.getRole().GetRoleHero().BattleAttrChange(heroData, ntfAttrType, heroFightPower)
 		this.getRole().GetRoleHero().BattleAttrChange(heroData, ntfAttrType, heroFightPower)
 
 
@@ -832,8 +835,8 @@ func (this *ActorAttr) calActorAttr(heroData *serverproto.HeroData, attrList []*
 	return bChange
 	return bChange
 }
 }
 
 
-//计算属性
-//属性点加成
+// 计算属性
+// 属性点加成
 func (this *ActorAttr) calcAddPointAttrs(heroData *serverproto.HeroData, attrList []*serverproto.KeyValueType) bool {
 func (this *ActorAttr) calcAddPointAttrs(heroData *serverproto.HeroData, attrList []*serverproto.KeyValueType) bool {
 	if heroData == nil {
 	if heroData == nil {
 		return false
 		return false
@@ -859,7 +862,7 @@ func (this *ActorAttr) calcAddPointAttrs(heroData *serverproto.HeroData, attrLis
 	return true
 	return true
 }
 }
 
 
-//技能升级添加属性
+// 技能升级添加属性
 func (this *ActorAttr) calcSkillAttrs(heroData *serverproto.HeroData, attrChangeSt AttrChangeST) bool {
 func (this *ActorAttr) calcSkillAttrs(heroData *serverproto.HeroData, attrChangeSt AttrChangeST) bool {
 	if !this.changeSetList.Has(Attr_Change_Skill) {
 	if !this.changeSetList.Has(Attr_Change_Skill) {
 		return false
 		return false
@@ -928,7 +931,7 @@ func (this *ActorAttr) calcHeadFrameAttrs(heroData *serverproto.HeroData, attrCh
 	return true
 	return true
 }
 }
 
 
-//equip
+// equip
 func (this *ActorAttr) calcEquipAttrs(heroData *serverproto.HeroData) bool {
 func (this *ActorAttr) calcEquipAttrs(heroData *serverproto.HeroData) bool {
 	if !this.changeSetList.Has(Attr_Change_Equip) {
 	if !this.changeSetList.Has(Attr_Change_Equip) {
 		return false
 		return false
@@ -961,7 +964,7 @@ func (this *ActorAttr) calcPrivilegeAttrs(heroData *serverproto.HeroData) bool {
 	return true
 	return true
 }
 }
 
 
-//card
+// card
 func (this *ActorAttr) calcCardAttrs(heroData *serverproto.HeroData) bool {
 func (this *ActorAttr) calcCardAttrs(heroData *serverproto.HeroData) bool {
 	if !this.changeSetList.Has(Attr_Change_Card) {
 	if !this.changeSetList.Has(Attr_Change_Card) {
 		return false
 		return false
@@ -983,7 +986,7 @@ func (this *ActorAttr) calcCardAttrs(heroData *serverproto.HeroData) bool {
 	return true
 	return true
 }
 }
 
 
-//skill equip
+// skill equip
 func (this *ActorAttr) calcSkillEquipSlotAttrs(heroData *serverproto.HeroData) bool {
 func (this *ActorAttr) calcSkillEquipSlotAttrs(heroData *serverproto.HeroData) bool {
 	if !this.changeSetList.Has(Attr_Change_Skill_Equip_Slot) {
 	if !this.changeSetList.Has(Attr_Change_Skill_Equip_Slot) {
 		return false
 		return false
@@ -1010,7 +1013,7 @@ func (this *ActorAttr) calcSkillEquipSlotAttrs(heroData *serverproto.HeroData) b
 	return true
 	return true
 }
 }
 
 
-//fashion
+// fashion
 func (this *ActorAttr) calcFashionAttr(fashionData *serverproto.FashionData, heroData *serverproto.HeroData) bool {
 func (this *ActorAttr) calcFashionAttr(fashionData *serverproto.FashionData, heroData *serverproto.HeroData) bool {
 	if !this.changeSetList.Has(Attr_Change_Fashion) {
 	if !this.changeSetList.Has(Attr_Change_Fashion) {
 		return false
 		return false
@@ -1044,7 +1047,7 @@ func (this *ActorAttr) calcFashionAttr(fashionData *serverproto.FashionData, her
 	return true
 	return true
 }
 }
 
 
-//sake
+// sake
 func (this *ActorAttr) calcSakeAttr(heroData *serverproto.HeroData) bool {
 func (this *ActorAttr) calcSakeAttr(heroData *serverproto.HeroData) bool {
 	if !this.changeSetList.Has(Attr_Change_Sake) {
 	if !this.changeSetList.Has(Attr_Change_Sake) {
 		return false
 		return false
@@ -1072,7 +1075,7 @@ func (this *ActorAttr) calcSakeAttr(heroData *serverproto.HeroData) bool {
 	return true
 	return true
 }
 }
 
 
-//sake
+// sake
 func (this *ActorAttr) calcHeadAttr(heroData *serverproto.HeroData) bool {
 func (this *ActorAttr) calcHeadAttr(heroData *serverproto.HeroData) bool {
 	if !this.changeSetList.Has(Attr_Change_Head) {
 	if !this.changeSetList.Has(Attr_Change_Head) {
 		return false
 		return false
@@ -1106,7 +1109,7 @@ func (this *ActorAttr) calcHeadAttr(heroData *serverproto.HeroData) bool {
 	return true
 	return true
 }
 }
 
 
-//hero advance
+// hero advance
 func (this *ActorAttr) calcAdvanceAttrs(heroData *serverproto.HeroData) bool {
 func (this *ActorAttr) calcAdvanceAttrs(heroData *serverproto.HeroData) bool {
 	if !this.changeSetList.Has(Attr_Change_Advance) {
 	if !this.changeSetList.Has(Attr_Change_Advance) {
 		return false
 		return false
@@ -1123,7 +1126,7 @@ func (this *ActorAttr) calcAdvanceAttrs(heroData *serverproto.HeroData) bool {
 	return true
 	return true
 }
 }
 
 
-//hero strength
+// hero strength
 func (this *ActorAttr) calcStrengthAttr(heroData *serverproto.HeroData) bool {
 func (this *ActorAttr) calcStrengthAttr(heroData *serverproto.HeroData) bool {
 	if !this.changeSetList.Has(Attr_Change_Strength) {
 	if !this.changeSetList.Has(Attr_Change_Strength) {
 		return false
 		return false
@@ -1140,7 +1143,7 @@ func (this *ActorAttr) calcStrengthAttr(heroData *serverproto.HeroData) bool {
 	return true
 	return true
 }
 }
 
 
-//pet
+// pet
 func (this *ActorAttr) calcPetAttr(heroData *serverproto.HeroData, attrChangeSt AttrChangeST) bool {
 func (this *ActorAttr) calcPetAttr(heroData *serverproto.HeroData, attrChangeSt AttrChangeST) bool {
 	if !this.changeSetList.Has(Attr_Change_Pet) {
 	if !this.changeSetList.Has(Attr_Change_Pet) {
 		return false
 		return false
@@ -1187,7 +1190,7 @@ func (this *ActorAttr) calAttr(curAttr map[serverproto.Attr]float32, attrList ma
 	}
 	}
 }
 }
 
 
-//直接添加到总属性上
+// 直接添加到总属性上
 func (this *ActorAttr) calAttrAdd(curAttr map[serverproto.Attr]float32, attrList map[serverproto.Attr]float32) {
 func (this *ActorAttr) calAttrAdd(curAttr map[serverproto.Attr]float32, attrList map[serverproto.Attr]float32) {
 	for key, val := range attrList {
 	for key, val := range attrList {
 		deltaValue := val
 		deltaValue := val
@@ -1200,7 +1203,7 @@ func (this *ActorAttr) calAttrAdd(curAttr map[serverproto.Attr]float32, attrList
 	}
 	}
 }
 }
 
 
-//直接减到总属性上
+// 直接减到总属性上
 func (this *ActorAttr) calAttrDel(curAttr map[serverproto.Attr]float32, attrList map[serverproto.Attr]float32) {
 func (this *ActorAttr) calAttrDel(curAttr map[serverproto.Attr]float32, attrList map[serverproto.Attr]float32) {
 	for key, val := range attrList {
 	for key, val := range attrList {
 		deltaValue := -val
 		deltaValue := -val
@@ -1213,7 +1216,7 @@ func (this *ActorAttr) calAttrDel(curAttr map[serverproto.Attr]float32, attrList
 	}
 	}
 }
 }
 
 
-//attr copy
+// attr copy
 func (this *ActorAttr) calAttrCopy(curAttr map[serverproto.Attr]float32, attrList map[serverproto.Attr]float32) {
 func (this *ActorAttr) calAttrCopy(curAttr map[serverproto.Attr]float32, attrList map[serverproto.Attr]float32) {
 	for key, val := range curAttr {
 	for key, val := range curAttr {
 		attrList[key] += val
 		attrList[key] += val
@@ -1362,7 +1365,7 @@ func (this *ActorAttr) GetHeadFrameAttr(baseAttrList map[serverproto.Attr]float3
 	}
 	}
 }
 }
 
 
-//获取属性
+// 获取属性
 func (this *ActorAttr) GetEquipAttr(slotData *serverproto.SlotData, baseAttrList map[serverproto.Attr]float32) {
 func (this *ActorAttr) GetEquipAttr(slotData *serverproto.SlotData, baseAttrList map[serverproto.Attr]float32) {
 	var suitList = map[int32]int32{}
 	var suitList = map[int32]int32{}
 	//最小精炼等级
 	//最小精炼等级
@@ -1588,7 +1591,7 @@ func (this *ActorAttr) GetFashionAttr(fashionData *serverproto.FashionData, hero
 	}
 	}
 }
 }
 
 
-//进阶(突破等级上限,角色通过专职来处理)
+// 进阶(突破等级上限,角色通过专职来处理)
 func (this *ActorAttr) GetAdvanceAttrs(heroData *serverproto.HeroData, baseAttrList map[serverproto.Attr]float32) {
 func (this *ActorAttr) GetAdvanceAttrs(heroData *serverproto.HeroData, baseAttrList map[serverproto.Attr]float32) {
 	if heroData.AdvanceLevel <= 0 {
 	if heroData.AdvanceLevel <= 0 {
 		return
 		return
@@ -1613,7 +1616,7 @@ func (this *ActorAttr) GetAdvanceAttrs(heroData *serverproto.HeroData, baseAttrL
 	}
 	}
 }
 }
 
 
-//突破
+// 突破
 func (this *ActorAttr) GetStrengthAttrs(heroData *serverproto.HeroData, baseAttrList map[serverproto.Attr]float32) {
 func (this *ActorAttr) GetStrengthAttrs(heroData *serverproto.HeroData, baseAttrList map[serverproto.Attr]float32) {
 	if heroData.StrengthLevel <= 0 {
 	if heroData.StrengthLevel <= 0 {
 		return
 		return
@@ -1638,7 +1641,7 @@ func (this *ActorAttr) GetStrengthAttrs(heroData *serverproto.HeroData, baseAttr
 	}
 	}
 }
 }
 
 
-//可能是上阵,也可能是下阵
+// 可能是上阵,也可能是下阵
 func (this *ActorAttr) GetPetAttrs(heroData *serverproto.HeroData, baseAttrList map[serverproto.Attr]float32, attrChangeSt AttrChangeST) {
 func (this *ActorAttr) GetPetAttrs(heroData *serverproto.HeroData, baseAttrList map[serverproto.Attr]float32, attrChangeSt AttrChangeST) {
 	if heroData.BattlePetId <= 0 {
 	if heroData.BattlePetId <= 0 {
 		return
 		return
@@ -1850,7 +1853,7 @@ func (this *ActorAttr) getPetQiyueAttrs(petData *serverproto.PetData, baseAttrLi
 	}
 	}
 }
 }
 
 
-//for pet(宠物自身属性计算)
+// for pet(宠物自身属性计算)
 func (this *ActorAttr) calPetAttrForPetBase() bool {
 func (this *ActorAttr) calPetAttrForPetBase() bool {
 	//check is'nt a pet
 	//check is'nt a pet
 	if !this.isPet {
 	if !this.isPet {
@@ -2064,7 +2067,7 @@ func (this *ActorAttr) calcActorFightPower(attrList []*serverproto.KeyValueFloat
 	return fightPower
 	return fightPower
 }
 }
 
 
-//战斗属性计算
+// 战斗属性计算
 type RoleBattleAttr struct {
 type RoleBattleAttr struct {
 	role               *Role
 	role               *Role
 	bInitAttrCalc      bool   //玩家登陆时第一战斗时计算上阵单位属性
 	bInitAttrCalc      bool   //玩家登陆时第一战斗时计算上阵单位属性
@@ -2102,7 +2105,7 @@ func newRoleBattleAttr(r *Role) *RoleBattleAttr {
 	return mag
 	return mag
 }
 }
 
 
-//hero
+// hero
 func (this *RoleBattleAttr) getActorAttr(heroData *serverproto.HeroData) *ActorAttr {
 func (this *RoleBattleAttr) getActorAttr(heroData *serverproto.HeroData) *ActorAttr {
 	actorAttr, ok := this.roleActorAttrList[heroData.Id]
 	actorAttr, ok := this.roleActorAttrList[heroData.Id]
 	if !ok {
 	if !ok {
@@ -2130,7 +2133,7 @@ func (this *RoleBattleAttr) getActorAttr(heroData *serverproto.HeroData) *ActorA
 	return actorAttr
 	return actorAttr
 }
 }
 
 
-//pet
+// pet
 func (this *RoleBattleAttr) getPetActorAttr(petData *serverproto.PetData) *ActorAttr {
 func (this *RoleBattleAttr) getPetActorAttr(petData *serverproto.PetData) *ActorAttr {
 	actorAttr, ok := this.rolePetAttrList[int32(petData.Id)]
 	actorAttr, ok := this.rolePetAttrList[int32(petData.Id)]
 	if !ok {
 	if !ok {
@@ -2147,7 +2150,7 @@ func (this *RoleBattleAttr) getPetActorAttr(petData *serverproto.PetData) *Actor
 	return actorAttr
 	return actorAttr
 }
 }
 
 
-//属性变更
+// 属性变更
 type AttrChangeST struct {
 type AttrChangeST struct {
 	IgnoreNotify         bool //是否通知客户端属性变更(true不通知)
 	IgnoreNotify         bool //是否通知客户端属性变更(true不通知)
 	FightChangeNotNotify bool
 	FightChangeNotNotify bool
@@ -2172,7 +2175,7 @@ type AttrChangeST struct {
 	HeadFrameId      int32
 	HeadFrameId      int32
 }
 }
 
 
-//压制值计算
+// 压制值计算
 type RepressChangeST struct {
 type RepressChangeST struct {
 	HeroData      *serverproto.HeroData
 	HeroData      *serverproto.HeroData
 	BReset        bool
 	BReset        bool
@@ -2181,7 +2184,7 @@ type RepressChangeST struct {
 	NewSKillLevel int32
 	NewSKillLevel int32
 }
 }
 
 
-//技能变化
+// 技能变化
 func (this *RoleBattleAttr) HeroSkillChange(heroData *serverproto.HeroData) {
 func (this *RoleBattleAttr) HeroSkillChange(heroData *serverproto.HeroData) {
 	if heroData == nil {
 	if heroData == nil {
 		return
 		return
@@ -2213,7 +2216,7 @@ func (this *RoleBattleAttr) HeroSkillChange(heroData *serverproto.HeroData) {
 	}
 	}
 }
 }
 
 
-//等级属性变更
+// 等级属性变更
 func (this *RoleBattleAttr) ResetLevelAttrList(heroData *serverproto.HeroData) {
 func (this *RoleBattleAttr) ResetLevelAttrList(heroData *serverproto.HeroData) {
 	if heroData == nil {
 	if heroData == nil {
 		return
 		return
@@ -2228,7 +2231,7 @@ func (this *RoleBattleAttr) ResetLevelAttrList(heroData *serverproto.HeroData) {
 	})
 	})
 }
 }
 
 
-//更换职业属性变更
+// 更换职业属性变更
 func (this *RoleBattleAttr) ResetJobAttrList(heroData *serverproto.HeroData) {
 func (this *RoleBattleAttr) ResetJobAttrList(heroData *serverproto.HeroData) {
 	if heroData == nil {
 	if heroData == nil {
 		return
 		return
@@ -2264,7 +2267,7 @@ func (this *RoleBattleAttr) PartnerAdvanceAttrList(heroData *serverproto.HeroDat
 	})
 	})
 }
 }
 
 
-//属性变更唯一对外接口
+// 属性变更唯一对外接口
 func (this *RoleBattleAttr) AttrChange(attrChangeSt AttrChangeST) {
 func (this *RoleBattleAttr) AttrChange(attrChangeSt AttrChangeST) {
 
 
 	if attrChangeSt.IsPet {
 	if attrChangeSt.IsPet {
@@ -2436,7 +2439,7 @@ func (this *RoleBattleAttr) getPetFightPower(petData *serverproto.PetData) int64
 	return fightPower
 	return fightPower
 }
 }
 
 
-//获取当前所有技能对应的战力加成
+// 获取当前所有技能对应的战力加成
 func (this *RoleBattleAttr) getHeroTotalSkillFightPower(actorId int32) int32 {
 func (this *RoleBattleAttr) getHeroTotalSkillFightPower(actorId int32) int32 {
 	var fightPower int32 = 0
 	var fightPower int32 = 0
 	heroData := this.role.GetRoleHero().GetHero(actorId)
 	heroData := this.role.GetRoleHero().GetHero(actorId)
@@ -2661,7 +2664,7 @@ func (this *RoleBattleAttr) syncActorData(out *serverproto.ActorBattleAttr, acto
 	}
 	}
 }
 }
 
 
-//时装属性
+// 时装属性
 func (this *RoleBattleAttr) getFashionAttr(heroData *serverproto.HeroData) {
 func (this *RoleBattleAttr) getFashionAttr(heroData *serverproto.HeroData) {
 	if heroData == nil {
 	if heroData == nil {
 		//玩家自身角色
 		//玩家自身角色
@@ -2708,7 +2711,7 @@ func (this *RoleBattleAttr) getFashionAttr(heroData *serverproto.HeroData) {
 	}
 	}
 }
 }
 
 
-//收集屋藏品属性
+// 收集屋藏品属性
 func (this *RoleBattleAttr) getSakeAttr(heroData *serverproto.HeroData) {
 func (this *RoleBattleAttr) getSakeAttr(heroData *serverproto.HeroData) {
 	if heroData == nil {
 	if heroData == nil {
 		//玩家自身角色
 		//玩家自身角色
@@ -2754,7 +2757,7 @@ func (this *RoleBattleAttr) getSakeAttr(heroData *serverproto.HeroData) {
 	}
 	}
 }
 }
 
 
-//宠物羁绊属性
+// 宠物羁绊属性
 func (this *RoleBattleAttr) getPetBondAttr() {
 func (this *RoleBattleAttr) getPetBondAttr() {
 	if this.role.GetRolePet() == nil {
 	if this.role.GetRolePet() == nil {
 		return
 		return
@@ -2899,7 +2902,7 @@ func (this *RoleBattleAttr) calcAttrPet(petList []*serverproto.PetData, attrChan
 	return
 	return
 }
 }
 
 
-//计算其他玩家战斗属性
+// 计算其他玩家战斗属性
 func (this *RoleBattleAttr) CalcFightRoleInfoAttr(FightInfo *serverproto.FightRoleInfo) map[uint32]*serverproto.ActorData {
 func (this *RoleBattleAttr) CalcFightRoleInfoAttr(FightInfo *serverproto.FightRoleInfo) map[uint32]*serverproto.ActorData {
 	tempBattleHeroList := map[uint32]*serverproto.ActorData{}
 	tempBattleHeroList := map[uint32]*serverproto.ActorData{}
 
 
@@ -2926,8 +2929,8 @@ func (this *RoleBattleAttr) CalcFightRoleInfoAttr(FightInfo *serverproto.FightRo
 	return tempBattleHeroList
 	return tempBattleHeroList
 }
 }
 
 
-//Role
-//获取英雄属性,宠物属性
+// Role
+// 获取英雄属性,宠物属性
 func (this *RoleBattleAttr) GetActorAttr(actorList []*serverproto.ActorAttrType,
 func (this *RoleBattleAttr) GetActorAttr(actorList []*serverproto.ActorAttrType,
 	isAllBattle bool, bNotify bool) serverproto.ErrorCode {
 	isAllBattle bool, bNotify bool) serverproto.ErrorCode {
 
 
@@ -3028,9 +3031,9 @@ func (this *RoleBattleAttr) GetActorAttr(actorList []*serverproto.ActorAttrType,
 	return serverproto.ErrorCode_ERROR_OK
 	return serverproto.ErrorCode_ERROR_OK
 }
 }
 
 
-//获取actor契约属性
-//如果是宠物,则获取契约材料宠物给到契约宠物生成的属性
-//如果是英雄,则获取契约宠物继承到英雄的属性
+// 获取actor契约属性
+// 如果是宠物,则获取契约材料宠物给到契约宠物生成的属性
+// 如果是英雄,则获取契约宠物继承到英雄的属性
 func (this *RoleBattleAttr) GetActorQiyueAttr(actorList []*serverproto.ActorAttrType) {
 func (this *RoleBattleAttr) GetActorQiyueAttr(actorList []*serverproto.ActorAttrType) {
 	for idx := 0; idx < len(actorList); idx++ {
 	for idx := 0; idx < len(actorList); idx++ {
 		if actorList[idx].IsHeroPet {
 		if actorList[idx].IsHeroPet {

+ 8 - 1
RO_Server_Trunk-branch_0.1.39/roserver/game/msg/gm_msg.go

@@ -128,7 +128,14 @@ func init() {
 				mapId, _ := model.Str2Num(cmdList[1])
 				mapId, _ := model.Str2Num(cmdList[1])
 				levelId, _ := model.Str2Num(cmdList[2])
 				levelId, _ := model.Str2Num(cmdList[2])
 
 
-				roleOuter.(*model2.Role).GetRoleBattle().GMSetMapLevel(uint32(mapId), uint32(levelId))
+				roleOuter.(*model2.Role).GetRoleBattle().GMSetMapLevel(uint32(mapId), uint32(levelId), false)
+			}
+		case "sethardmap": //设置挑战到的关卡,关卡相关的其他数据不做处理
+			if len(cmdList) >= 3 {
+				mapId, _ := model.Str2Num(cmdList[1])
+				levelId, _ := model.Str2Num(cmdList[2])
+
+				roleOuter.(*model2.Role).GetRoleBattle().GMSetMapLevel(uint32(mapId), uint32(levelId), true)
 			}
 			}
 		case "signup":
 		case "signup":
 			if len(cmdList) >= 2 {
 			if len(cmdList) >= 2 {

+ 26 - 29
RO_Server_Trunk-branch_0.1.39/roserver/gate/model/proc_rpc.go

@@ -1,20 +1,17 @@
 package model
 package model
 
 
 import (
 import (
+	"github.com/gorilla/websocket"
 	"io"
 	"io"
 	"net"
 	"net"
 	"rocommon"
 	"rocommon"
 	"rocommon/rpc"
 	"rocommon/rpc"
-	"rocommon/service"
 	"rocommon/socket"
 	"rocommon/socket"
 	_ "rocommon/socket/tcp"
 	_ "rocommon/socket/tcp"
 	"rocommon/util"
 	"rocommon/util"
 	"roserver/baseserver/model"
 	"roserver/baseserver/model"
 	"roserver/baseserver/router"
 	"roserver/baseserver/router"
 	"roserver/serverproto"
 	"roserver/serverproto"
-	"strings"
-
-	"github.com/gorilla/websocket"
 )
 )
 
 
 // 消息解析操作
 // 消息解析操作
@@ -216,31 +213,31 @@ func FrontendPackageProc(msgId int, seqId uint32, flagId uint16, msgData []byte,
 		}
 		}
 	default:
 	default:
 		//gm白名单处理
 		//gm白名单处理
-		if msgId == CSPlayerGMReqMsgId && len(service.GetServiceConfig().Node.WhiteListGM) >= 0 {
-			bFind := false
-			gmIPStr := ""
-			switch t := s.Raw().(type) {
-			case net.Conn:
-				gmIPStr = t.RemoteAddr().String()
-			case *websocket.Conn:
-				gmIPStr = t.RemoteAddr().String()
-			}
-			//gmIPStr := s.Raw().(net.Conn).RemoteAddr().String()
-			for idx := 0; idx < len(service.GetServiceConfig().Node.WhiteListGM); idx++ {
-				if strings.Contains(gmIPStr, service.GetServiceConfig().Node.WhiteListGM[idx]) {
-					bFind = true
-					break
-				}
-				if strings.Contains("0.0.0.0", service.GetServiceConfig().Node.WhiteListGM[idx]) {
-					bFind = true
-					break
-				}
-			}
-			if !bFind {
-				s.Close()
-				return
-			}
-		}
+		//if msgId == CSPlayerGMReqMsgId && len(service.GetServiceConfig().Node.WhiteListGM) >= 0 {
+		//	bFind := false
+		//	gmIPStr := ""
+		//	switch t := s.Raw().(type) {
+		//	case net.Conn:
+		//		gmIPStr = t.RemoteAddr().String()
+		//	case *websocket.Conn:
+		//		gmIPStr = t.RemoteAddr().String()
+		//	}
+		//	//gmIPStr := s.Raw().(net.Conn).RemoteAddr().String()
+		//	for idx := 0; idx < len(service.GetServiceConfig().Node.WhiteListGM); idx++ {
+		//		if strings.Contains(gmIPStr, service.GetServiceConfig().Node.WhiteListGM[idx]) {
+		//			bFind = true
+		//			break
+		//		}
+		//		if strings.Contains("0.0.0.0", service.GetServiceConfig().Node.WhiteListGM[idx]) {
+		//			bFind = true
+		//			break
+		//		}
+		//	}
+		//	if !bFind {
+		//		s.Close()
+		//		return
+		//	}
+		//}
 
 
 		//todo...目前暂时只针对gate做了透传,后期需要对所有服务器节点都可以执行透传
 		//todo...目前暂时只针对gate做了透传,后期需要对所有服务器节点都可以执行透传
 		routeRule := router.GetRuleByMsgID(msgId)
 		routeRule := router.GetRuleByMsgID(msgId)

+ 26 - 0
RO_Server_Trunk-branch_0.1.39/roserver/serverproto/config_csv.go

@@ -219,6 +219,7 @@ func configNameListInit() {
 	CFGNameList["JobExpCfg"] = JobExpCfgLoad
 	CFGNameList["JobExpCfg"] = JobExpCfgLoad
 	CFGNameList["KeepSakeCfg"] = KeepSakeCfgLoad
 	CFGNameList["KeepSakeCfg"] = KeepSakeCfgLoad
 	CFGNameList["LevelCfg"] = LevelCfgLoad
 	CFGNameList["LevelCfg"] = LevelCfgLoad
+	CFGNameList["HardLevelCfg"] = HardLevelCfgLoad
 	CFGNameList["LineMissionCfg"] = LineMissionCfgLoad
 	CFGNameList["LineMissionCfg"] = LineMissionCfgLoad
 	CFGNameList["MailCfg"] = MailCfgLoad
 	CFGNameList["MailCfg"] = MailCfgLoad
 	CFGNameList["MissionCfg"] = MissionCfgLoad
 	CFGNameList["MissionCfg"] = MissionCfgLoad
@@ -438,6 +439,7 @@ func ConfigInit(path string) {
 	ServiceRecordCfgLoad(path)
 	ServiceRecordCfgLoad(path)
 	ShieldedWordCfgLoad(path)
 	ShieldedWordCfgLoad(path)
 	ShopCfgLoad(path)
 	ShopCfgLoad(path)
+	HardLevelCfgLoad(path)
 	ShopTypeCfgLoad(path)
 	ShopTypeCfgLoad(path)
 	SignInCfgLoad(path)
 	SignInCfgLoad(path)
 	SkillCfgLoad(path)
 	SkillCfgLoad(path)
@@ -3767,3 +3769,27 @@ func WorldBossChangePlayCfgLoad(path string) {
 		WorldBossChangePlayCfgLoader[row.Id] = row
 		WorldBossChangePlayCfgLoader[row.Id] = row
 	}
 	}
 }
 }
+
+var HardLevelCfgLoader map[int32]*HardLevelCfg
+
+type HardLevelCfg struct {
+	Id         int32 `csv:"Id"`         //唯一id
+	LevelId    int32 `csv:"LevelId"`    //场景id
+	MapId      int32 `csv:"MapId"`      //地图id
+	BaseExp    int32 `csv:"BaseExp"`    //通关base经验
+	JobExp     int32 `csv:"JobExp"`     //通关job经验
+	Zeny       int32 `csv:"Zeny"`       //通关银币
+	Gold       int32 `csv:"Gold"`       //通关金币
+	Parter     int32 `csv:"Parter"`     //通关伙伴经验
+	Cash       int32 `csv:"Cash"`       //活动通关现金
+	FreeInvest int32 `csv:"FreeInvest"` //通关免费充值额度
+}
+
+func HardLevelCfgLoad(path string) {
+	cfg := []*HardLevelCfg{}
+	HardLevelCfgLoader = map[int32]*HardLevelCfg{}
+	loadCsvCfg(path+"HardLevelCfg.csv", &cfg)
+	for _, row := range cfg {
+		HardLevelCfgLoader[row.Id] = row
+	}
+}

+ 2357 - 2053
RO_Server_Trunk-branch_bt/roserver/serverproto/config_csv.go

@@ -1,149 +1,150 @@
 package serverproto
 package serverproto
 
 
 const (
 const (
-	CFG_ActiveCodeCfg = "ActiveCodeCfg.csv"
-	CFG_ActivitiesBtChargeTaskGoldCfg = "ActivitiesBtChargeTaskGoldCfg.csv"
+	CFG_ActiveCodeCfg                    = "ActiveCodeCfg.csv"
+	CFG_ActivitiesBtChargeTaskGoldCfg    = "ActivitiesBtChargeTaskGoldCfg.csv"
 	CFG_ActivitiesBtChargeTaskRoMoneyCfg = "ActivitiesBtChargeTaskRoMoneyCfg.csv"
 	CFG_ActivitiesBtChargeTaskRoMoneyCfg = "ActivitiesBtChargeTaskRoMoneyCfg.csv"
-	CFG_ActivitiesBtFirstChargeCfg = "ActivitiesBtFirstChargeCfg.csv"
-	CFG_ActivitiesCfg = "ActivitiesCfg.csv"
-	CFG_ActivitiesCollectionCfg = "ActivitiesCollectionCfg.csv"
-	CFG_ActivitiesDiscountsCfg = "ActivitiesDiscountsCfg.csv"
-	CFG_ActivitiesFirstChargeCfg = "ActivitiesFirstChargeCfg.csv"
-	CFG_ActivitiesFortnightDaysCfg = "ActivitiesFortnightDaysCfg.csv"
-	CFG_ActivitiesFortnightOnlineCfg = "ActivitiesFortnightOnlineCfg.csv"
-	CFG_ActivitiesGiftCfg = "ActivitiesGiftCfg.csv"
-	CFG_ActivitiesKingTaskCfg = "ActivitiesKingTaskCfg.csv"
-	CFG_ActivitieslikabilityCfg = "ActivitieslikabilityCfg.csv"
-	CFG_ActivitiesPetExchangeCfg = "ActivitiesPetExchangeCfg.csv"
-	CFG_ActivitiesRewardCfg = "ActivitiesRewardCfg.csv"
-	CFG_ActivitiesSignInCfg = "ActivitiesSignInCfg.csv"
-	CFG_ActivitiesTaskCfg = "ActivitiesTaskCfg.csv"
-	CFG_ActivitiesTiredChargeCfg = "ActivitiesTiredChargeCfg.csv"
-	CFG_ActivityRoulettelCfg = "ActivityRoulettelCfg.csv"
-	CFG_ActRewardCfg = "ActRewardCfg.csv"
-	CFG_AdvertisingScreen = "AdvertisingScreen.csv"
-	CFG_ArenaLevelCfg = "ArenaLevelCfg.csv"
-	CFG_ArenaRewardCfg = "ArenaRewardCfg.csv"
-	CFG_ArtifactCfg = "ArtifactCfg.csv"
-	CFG_ArtifactExpCfg = "ArtifactExpCfg.csv"
-	CFG_BoliShopCfg = "BoliShopCfg.csv"
-	CFG_BoliVipCfg = "BoliVipCfg.csv"
-	CFG_BTSmashEggsCfg = "BTSmashEggsCfg.csv"
-	CFG_CardCfg = "CardCfg.csv"
-	CFG_CardIdentification = "CardIdentification.csv"
-	CFG_CardReset = "CardReset.csv"
-	CFG_CardSuitNewCfg = "CardSuitNewCfg.csv"
-	CFG_CardUnlockCfg = "CardUnlockCfg.csv"
-	CFG_ClimbingTowerCfg = "ClimbingTowerCfg.csv"
-	CFG_CombinedServiceCfg = "CombinedServiceCfg.csv"
-	CFG_CompetitionAidouluCfg = "CompetitionAidouluCfg.csv"
-	CFG_CompetitionCfg = "CompetitionCfg.csv"
-	CFG_CompetitionDevineCfg = "CompetitionDevineCfg.csv"
-	CFG_CompetitionPrizeWheelCfg = "CompetitionPrizeWheelCfg.csv"
-	CFG_ConditionCfg = "ConditionCfg.csv"
-	CFG_DesignationCfg = "DesignationCfg.csv"
-	CFG_DropCfg = "DropCfg.csv"
-	CFG_EquipCfg = "EquipCfg.csv"
-	CFG_EquipRefineCfg = "EquipRefineCfg.csv"
-	CFG_EquipSuitNewCfg = "EquipSuitNewCfg.csv"
-	CFG_EvilCfg = "EvilCfg.csv"
-	CFG_ExpeditionBuffCfg = "ExpeditionBuffCfg.csv"
-	CFG_ExpeditionBuffDropCfg = "ExpeditionBuffDropCfg.csv"
-	CFG_ExpeditionCfg = "ExpeditionCfg.csv"
-	CFG_FashionCfg = "FashionCfg.csv"
-	CFG_FashionLevelUp = "FashionLevelUp.csv"
-	CFG_FashionPaperCfg = "FashionPaperCfg.csv"
-	CFG_FashionRandom = "FashionRandom.csv"
-	CFG_FashionSuitCfg = "FashionSuitCfg.csv"
-	CFG_FightCfg = "FightCfg.csv"
-	CFG_FunctionCfg = "FunctionCfg.csv"
-	CFG_GlobalCfg = "GlobalCfg.csv"
-	CFG_GuildBadgeCfg = "GuildBadgeCfg.csv"
-	CFG_GuildBossCfg = "GuildBossCfg.csv"
-	CFG_GuildBossRewardCfg = "GuildBossRewardCfg.csv"
-	CFG_GuildDemonCfg = "GuildDemonCfg.csv"
-	CFG_GuildLvCfg = "GuildLvCfg.csv"
-	CFG_GuildWarAgainstCfg = "GuildWarAgainstCfg.csv"
-	CFG_GuildWarBuffCfg = "GuildWarBuffCfg.csv"
-	CFG_GuildWarDojoCfg = "GuildWarDojoCfg.csv"
-	CFG_HeadFrameCfg = "HeadFrameCfg.csv"
-	CFG_HeadPortraitCfg = "HeadPortraitCfg.csv"
-	CFG_HundredDojoCfg = "HundredDojoCfg.csv"
-	CFG_InvitationTaskCfg = "InvitationTaskCfg.csv"
-	CFG_ItemCfg = "ItemCfg.csv"
-	CFG_JobCfg = "JobCfg.csv"
-	CFG_JobExpCfg = "JobExpCfg.csv"
-	CFG_KeepSakeCfg = "KeepSakeCfg.csv"
-	CFG_LevelCfg = "LevelCfg.csv"
-	CFG_LineMissionCfg = "LineMissionCfg.csv"
-	CFG_MailCfg = "MailCfg.csv"
-	CFG_MissionCfg = "MissionCfg.csv"
-	CFG_NatureCfg = "NatureCfg.csv"
-	CFG_NpcCfg = "NpcCfg.csv"
-	CFG_OnlineRewardsCfg = "OnlineRewardsCfg.csv"
-	CFG_ParterAttributeCfg = "ParterAttributeCfg.csv"
-	CFG_ParterCfg = "ParterCfg.csv"
-	CFG_ParterProgressCfg = "ParterProgressCfg.csv"
-	CFG_ParterSkillTreeCfg = "ParterSkillTreeCfg.csv"
-	CFG_PassCheckCfg = "PassCheckCfg.csv"
-	CFG_PassiveSkillCfg = "PassiveSkillCfg.csv"
-	CFG_PetBattleCfg = "PetBattleCfg.csv"
-	CFG_PetCfg = "PetCfg.csv"
-	CFG_PetEquipCfg = "PetEquipCfg.csv"
-	CFG_PetEquipExpCfg = "PetEquipExpCfg.csv"
-	CFG_PetEquipSuitCfg = "PetEquipSuitCfg.csv"
-	CFG_PetExpCfg = "PetExpCfg.csv"
-	CFG_PetpartnerCfg = "PetpartnerCfg.csv"
-	CFG_PetProgressCfg = "PetProgressCfg.csv"
-	CFG_PresspointPvPCfg = "PresspointPvPCfg.csv"
-	CFG_PrivilegeCardCfg = "PrivilegeCardCfg.csv"
-	CFG_PurseShopCfg = "PurseShopCfg.csv"
-	CFG_QualityPointCfg = "QualityPointCfg.csv"
-	CFG_QuickBattleCostCfg = "QuickBattleCostCfg.csv"
-	CFG_RobotCfg = "RobotCfg.csv"
-	CFG_RoleAttributeCfg = "RoleAttributeCfg.csv"
-	CFG_RuneShopExploreCfg = "RuneShopExploreCfg.csv"
-	CFG_RuneShopExploreRewardCfg = "RuneShopExploreRewardCfg.csv"
-	CFG_RuneShopGiftsCfg = "RuneShopGiftsCfg.csv"
-	CFG_RuneShopGuildBattleCfg = "RuneShopGuildBattleCfg.csv"
-	CFG_RuneShopLimitCfg = "RuneShopLimitCfg.csv"
-	CFG_RuneShopMonthCardCfg = "RuneShopMonthCardCfg.csv"
-	CFG_RuneShopRankAidouluCfg = "RuneShopRankAidouluCfg.csv"
-	CFG_RuneShopRankArenaCfg = "RuneShopRankArenaCfg.csv"
-	CFG_RuneShopRankMapCfg = "RuneShopRankMapCfg.csv"
-	CFG_RuneShopRankPetCfg = "RuneShopRankPetCfg.csv"
-	CFG_RuneShopRankSkillCfg = "RuneShopRankSkillCfg.csv"
-	CFG_RuneShopRankTowerCfg = "RuneShopRankTowerCfg.csv"
-	CFG_RushListCfg = "RushListCfg.csv"
-	CFG_RushListTargetCfg = "RushListTargetCfg.csv"
-	CFG_ServiceRecordCfg = "ServiceRecordCfg.csv"
-	CFG_ShieldedWordCfg = "ShieldedWordCfg.csv"
-	CFG_ShopCfg = "ShopCfg.csv"
-	CFG_ShopTypeCfg = "ShopTypeCfg.csv"
-	CFG_SignInCfg = "SignInCfg.csv"
-	CFG_SkillCfg = "SkillCfg.csv"
-	CFG_SkillDemandCfg = "SkillDemandCfg.csv"
-	CFG_SkillLvCfg = "SkillLvCfg.csv"
-	CFG_SkillSlotCfg = "SkillSlotCfg.csv"
-	CFG_SkillSuitNewCfg = "SkillSuitNewCfg.csv"
-	CFG_SkillTreeCfg = "SkillTreeCfg.csv"
-	CFG_SkillUpEffectCfg = "SkillUpEffectCfg.csv"
-	CFG_SummonServerCfg = "SummonServerCfg.csv"
-	CFG_SummonTemplateCfg = "SummonTemplateCfg.csv"
-	CFG_SysReward = "SysReward.csv"
-	CFG_TargetTaskCfg = "TargetTaskCfg.csv"
-	CFG_TopTowerCfgLevel = "TopTowerCfgLevel.csv"
-	CFG_TopTowerCfgReward = "TopTowerCfgReward.csv"
-	CFG_TransportCfg = "TransportCfg.csv"
-	CFG_UIFuncUnLockCfg = "UIFuncUnLockCfg.csv"
-	CFG_VipCfg = "VipCfg.csv"
-	CFG_WishCfg = "WishCfg.csv"
-	CFG_WorldBossCfg = "WorldBossCfg.csv"
-	CFG_WorldBossChangePlayCfg = "WorldBossChangePlayCfg.csv"
+	CFG_ActivitiesBtFirstChargeCfg       = "ActivitiesBtFirstChargeCfg.csv"
+	CFG_ActivitiesCfg                    = "ActivitiesCfg.csv"
+	CFG_ActivitiesCollectionCfg          = "ActivitiesCollectionCfg.csv"
+	CFG_ActivitiesDiscountsCfg           = "ActivitiesDiscountsCfg.csv"
+	CFG_ActivitiesFirstChargeCfg         = "ActivitiesFirstChargeCfg.csv"
+	CFG_ActivitiesFortnightDaysCfg       = "ActivitiesFortnightDaysCfg.csv"
+	CFG_ActivitiesFortnightOnlineCfg     = "ActivitiesFortnightOnlineCfg.csv"
+	CFG_ActivitiesGiftCfg                = "ActivitiesGiftCfg.csv"
+	CFG_ActivitiesKingTaskCfg            = "ActivitiesKingTaskCfg.csv"
+	CFG_ActivitieslikabilityCfg          = "ActivitieslikabilityCfg.csv"
+	CFG_ActivitiesPetExchangeCfg         = "ActivitiesPetExchangeCfg.csv"
+	CFG_ActivitiesRewardCfg              = "ActivitiesRewardCfg.csv"
+	CFG_ActivitiesSignInCfg              = "ActivitiesSignInCfg.csv"
+	CFG_ActivitiesTaskCfg                = "ActivitiesTaskCfg.csv"
+	CFG_ActivitiesTiredChargeCfg         = "ActivitiesTiredChargeCfg.csv"
+	CFG_ActivityRoulettelCfg             = "ActivityRoulettelCfg.csv"
+	CFG_ActRewardCfg                     = "ActRewardCfg.csv"
+	CFG_AdvertisingScreen                = "AdvertisingScreen.csv"
+	CFG_ArenaLevelCfg                    = "ArenaLevelCfg.csv"
+	CFG_ArenaRewardCfg                   = "ArenaRewardCfg.csv"
+	CFG_ArtifactCfg                      = "ArtifactCfg.csv"
+	CFG_ArtifactExpCfg                   = "ArtifactExpCfg.csv"
+	CFG_BoliShopCfg                      = "BoliShopCfg.csv"
+	CFG_BoliVipCfg                       = "BoliVipCfg.csv"
+	CFG_BTSmashEggsCfg                   = "BTSmashEggsCfg.csv"
+	CFG_CardCfg                          = "CardCfg.csv"
+	CFG_CardIdentification               = "CardIdentification.csv"
+	CFG_CardReset                        = "CardReset.csv"
+	CFG_CardSuitNewCfg                   = "CardSuitNewCfg.csv"
+	CFG_CardUnlockCfg                    = "CardUnlockCfg.csv"
+	CFG_ClimbingTowerCfg                 = "ClimbingTowerCfg.csv"
+	CFG_CombinedServiceCfg               = "CombinedServiceCfg.csv"
+	CFG_CompetitionAidouluCfg            = "CompetitionAidouluCfg.csv"
+	CFG_CompetitionCfg                   = "CompetitionCfg.csv"
+	CFG_CompetitionDevineCfg             = "CompetitionDevineCfg.csv"
+	CFG_CompetitionPrizeWheelCfg         = "CompetitionPrizeWheelCfg.csv"
+	CFG_ConditionCfg                     = "ConditionCfg.csv"
+	CFG_DesignationCfg                   = "DesignationCfg.csv"
+	CFG_DropCfg                          = "DropCfg.csv"
+	CFG_EquipCfg                         = "EquipCfg.csv"
+	CFG_EquipRefineCfg                   = "EquipRefineCfg.csv"
+	CFG_EquipSuitNewCfg                  = "EquipSuitNewCfg.csv"
+	CFG_EvilCfg                          = "EvilCfg.csv"
+	CFG_ExpeditionBuffCfg                = "ExpeditionBuffCfg.csv"
+	CFG_ExpeditionBuffDropCfg            = "ExpeditionBuffDropCfg.csv"
+	CFG_ExpeditionCfg                    = "ExpeditionCfg.csv"
+	CFG_FashionCfg                       = "FashionCfg.csv"
+	CFG_FashionLevelUp                   = "FashionLevelUp.csv"
+	CFG_FashionPaperCfg                  = "FashionPaperCfg.csv"
+	CFG_FashionRandom                    = "FashionRandom.csv"
+	CFG_FashionSuitCfg                   = "FashionSuitCfg.csv"
+	CFG_FightCfg                         = "FightCfg.csv"
+	CFG_FunctionCfg                      = "FunctionCfg.csv"
+	CFG_GlobalCfg                        = "GlobalCfg.csv"
+	CFG_GuildBadgeCfg                    = "GuildBadgeCfg.csv"
+	CFG_GuildBossCfg                     = "GuildBossCfg.csv"
+	CFG_GuildBossRewardCfg               = "GuildBossRewardCfg.csv"
+	CFG_GuildDemonCfg                    = "GuildDemonCfg.csv"
+	CFG_GuildLvCfg                       = "GuildLvCfg.csv"
+	CFG_GuildWarAgainstCfg               = "GuildWarAgainstCfg.csv"
+	CFG_GuildWarBuffCfg                  = "GuildWarBuffCfg.csv"
+	CFG_GuildWarDojoCfg                  = "GuildWarDojoCfg.csv"
+	CFG_HeadFrameCfg                     = "HeadFrameCfg.csv"
+	CFG_HeadPortraitCfg                  = "HeadPortraitCfg.csv"
+	CFG_HundredDojoCfg                   = "HundredDojoCfg.csv"
+	CFG_InvitationTaskCfg                = "InvitationTaskCfg.csv"
+	CFG_ItemCfg                          = "ItemCfg.csv"
+	CFG_JobCfg                           = "JobCfg.csv"
+	CFG_JobExpCfg                        = "JobExpCfg.csv"
+	CFG_KeepSakeCfg                      = "KeepSakeCfg.csv"
+	CFG_LevelCfg                         = "LevelCfg.csv"
+	CFG_LineMissionCfg                   = "LineMissionCfg.csv"
+	CFG_MailCfg                          = "MailCfg.csv"
+	CFG_MissionCfg                       = "MissionCfg.csv"
+	CFG_NatureCfg                        = "NatureCfg.csv"
+	CFG_NpcCfg                           = "NpcCfg.csv"
+	CFG_OnlineRewardsCfg                 = "OnlineRewardsCfg.csv"
+	CFG_ParterAttributeCfg               = "ParterAttributeCfg.csv"
+	CFG_ParterCfg                        = "ParterCfg.csv"
+	CFG_ParterProgressCfg                = "ParterProgressCfg.csv"
+	CFG_ParterSkillTreeCfg               = "ParterSkillTreeCfg.csv"
+	CFG_PassCheckCfg                     = "PassCheckCfg.csv"
+	CFG_PassiveSkillCfg                  = "PassiveSkillCfg.csv"
+	CFG_PetBattleCfg                     = "PetBattleCfg.csv"
+	CFG_PetCfg                           = "PetCfg.csv"
+	CFG_PetEquipCfg                      = "PetEquipCfg.csv"
+	CFG_PetEquipExpCfg                   = "PetEquipExpCfg.csv"
+	CFG_PetEquipSuitCfg                  = "PetEquipSuitCfg.csv"
+	CFG_PetExpCfg                        = "PetExpCfg.csv"
+	CFG_PetpartnerCfg                    = "PetpartnerCfg.csv"
+	CFG_PetProgressCfg                   = "PetProgressCfg.csv"
+	CFG_PresspointPvPCfg                 = "PresspointPvPCfg.csv"
+	CFG_PrivilegeCardCfg                 = "PrivilegeCardCfg.csv"
+	CFG_PurseShopCfg                     = "PurseShopCfg.csv"
+	CFG_QualityPointCfg                  = "QualityPointCfg.csv"
+	CFG_QuickBattleCostCfg               = "QuickBattleCostCfg.csv"
+	CFG_RobotCfg                         = "RobotCfg.csv"
+	CFG_RoleAttributeCfg                 = "RoleAttributeCfg.csv"
+	CFG_RuneShopExploreCfg               = "RuneShopExploreCfg.csv"
+	CFG_RuneShopExploreRewardCfg         = "RuneShopExploreRewardCfg.csv"
+	CFG_RuneShopGiftsCfg                 = "RuneShopGiftsCfg.csv"
+	CFG_RuneShopGuildBattleCfg           = "RuneShopGuildBattleCfg.csv"
+	CFG_RuneShopLimitCfg                 = "RuneShopLimitCfg.csv"
+	CFG_RuneShopMonthCardCfg             = "RuneShopMonthCardCfg.csv"
+	CFG_RuneShopRankAidouluCfg           = "RuneShopRankAidouluCfg.csv"
+	CFG_RuneShopRankArenaCfg             = "RuneShopRankArenaCfg.csv"
+	CFG_RuneShopRankMapCfg               = "RuneShopRankMapCfg.csv"
+	CFG_RuneShopRankPetCfg               = "RuneShopRankPetCfg.csv"
+	CFG_RuneShopRankSkillCfg             = "RuneShopRankSkillCfg.csv"
+	CFG_RuneShopRankTowerCfg             = "RuneShopRankTowerCfg.csv"
+	CFG_RushListCfg                      = "RushListCfg.csv"
+	CFG_RushListTargetCfg                = "RushListTargetCfg.csv"
+	CFG_ServiceRecordCfg                 = "ServiceRecordCfg.csv"
+	CFG_ShieldedWordCfg                  = "ShieldedWordCfg.csv"
+	CFG_ShopCfg                          = "ShopCfg.csv"
+	CFG_ShopTypeCfg                      = "ShopTypeCfg.csv"
+	CFG_SignInCfg                        = "SignInCfg.csv"
+	CFG_SkillCfg                         = "SkillCfg.csv"
+	CFG_SkillDemandCfg                   = "SkillDemandCfg.csv"
+	CFG_SkillLvCfg                       = "SkillLvCfg.csv"
+	CFG_SkillSlotCfg                     = "SkillSlotCfg.csv"
+	CFG_SkillSuitNewCfg                  = "SkillSuitNewCfg.csv"
+	CFG_SkillTreeCfg                     = "SkillTreeCfg.csv"
+	CFG_SkillUpEffectCfg                 = "SkillUpEffectCfg.csv"
+	CFG_SummonServerCfg                  = "SummonServerCfg.csv"
+	CFG_SummonTemplateCfg                = "SummonTemplateCfg.csv"
+	CFG_SysReward                        = "SysReward.csv"
+	CFG_TargetTaskCfg                    = "TargetTaskCfg.csv"
+	CFG_TopTowerCfgLevel                 = "TopTowerCfgLevel.csv"
+	CFG_TopTowerCfgReward                = "TopTowerCfgReward.csv"
+	CFG_TransportCfg                     = "TransportCfg.csv"
+	CFG_UIFuncUnLockCfg                  = "UIFuncUnLockCfg.csv"
+	CFG_VipCfg                           = "VipCfg.csv"
+	CFG_WishCfg                          = "WishCfg.csv"
+	CFG_WorldBossCfg                     = "WorldBossCfg.csv"
+	CFG_WorldBossChangePlayCfg           = "WorldBossChangePlayCfg.csv"
 )
 )
+
 var CFGNameList = map[string]func(path string){}
 var CFGNameList = map[string]func(path string){}
 
 
-func configNameListInit(){
+func configNameListInit() {
 	CFGNameList["ActiveCodeCfg"] = ActiveCodeCfgLoad
 	CFGNameList["ActiveCodeCfg"] = ActiveCodeCfgLoad
 	CFGNameList["ActivitiesBtChargeTaskGoldCfg"] = ActivitiesBtChargeTaskGoldCfgLoad
 	CFGNameList["ActivitiesBtChargeTaskGoldCfg"] = ActivitiesBtChargeTaskGoldCfgLoad
 	CFGNameList["ActivitiesBtChargeTaskRoMoneyCfg"] = ActivitiesBtChargeTaskRoMoneyCfgLoad
 	CFGNameList["ActivitiesBtChargeTaskRoMoneyCfg"] = ActivitiesBtChargeTaskRoMoneyCfgLoad
@@ -218,6 +219,7 @@ func configNameListInit(){
 	CFGNameList["JobExpCfg"] = JobExpCfgLoad
 	CFGNameList["JobExpCfg"] = JobExpCfgLoad
 	CFGNameList["KeepSakeCfg"] = KeepSakeCfgLoad
 	CFGNameList["KeepSakeCfg"] = KeepSakeCfgLoad
 	CFGNameList["LevelCfg"] = LevelCfgLoad
 	CFGNameList["LevelCfg"] = LevelCfgLoad
+	CFGNameList["HardLevelCfg"] = HardLevelCfgLoad
 	CFGNameList["LineMissionCfg"] = LineMissionCfgLoad
 	CFGNameList["LineMissionCfg"] = LineMissionCfgLoad
 	CFGNameList["MailCfg"] = MailCfgLoad
 	CFGNameList["MailCfg"] = MailCfgLoad
 	CFGNameList["MissionCfg"] = MissionCfgLoad
 	CFGNameList["MissionCfg"] = MissionCfgLoad
@@ -285,7 +287,6 @@ func configNameListInit(){
 	CFGNameList["WorldBossChangePlayCfg"] = WorldBossChangePlayCfgLoad
 	CFGNameList["WorldBossChangePlayCfg"] = WorldBossChangePlayCfgLoad
 }
 }
 
 
-
 var XmlFileList = []string{
 var XmlFileList = []string{
 	"BattleFormulaParamCfg",
 	"BattleFormulaParamCfg",
 	"Born_Scene_prontera_sd",
 	"Born_Scene_prontera_sd",
@@ -317,7 +318,7 @@ var XmlFileList = []string{
 	"FrameEvent_Xiehailangren",
 	"FrameEvent_Xiehailangren",
 }
 }
 
 
-//load config data
+// load config data
 func ConfigInit(path string) {
 func ConfigInit(path string) {
 	configNameListInit()
 	configNameListInit()
 	ActiveCodeCfgLoad(path)
 	ActiveCodeCfgLoad(path)
@@ -394,6 +395,7 @@ func ConfigInit(path string) {
 	JobExpCfgLoad(path)
 	JobExpCfgLoad(path)
 	KeepSakeCfgLoad(path)
 	KeepSakeCfgLoad(path)
 	LevelCfgLoad(path)
 	LevelCfgLoad(path)
+	HardLevelCfgLoad(path)
 	LineMissionCfgLoad(path)
 	LineMissionCfgLoad(path)
 	MailCfgLoad(path)
 	MailCfgLoad(path)
 	MissionCfgLoad(path)
 	MissionCfgLoad(path)
@@ -461,3025 +463,3327 @@ func ConfigInit(path string) {
 	WorldBossChangePlayCfgLoad(path)
 	WorldBossChangePlayCfgLoad(path)
 }
 }
 
 
-var ActiveCodeCfgLoader  map[int32]*ActiveCodeCfg
-type ActiveCodeCfg struct{
-	Id	int32	`csv:"Id"`		//ID
-	Code	string	`csv:"Code"`		//类型
+var ActiveCodeCfgLoader map[int32]*ActiveCodeCfg
+
+type ActiveCodeCfg struct {
+	Id   int32  `csv:"Id"`   //ID
+	Code string `csv:"Code"` //类型
 }
 }
+
 func ActiveCodeCfgLoad(path string) {
 func ActiveCodeCfgLoad(path string) {
 	cfg := []*ActiveCodeCfg{}
 	cfg := []*ActiveCodeCfg{}
 	ActiveCodeCfgLoader = map[int32]*ActiveCodeCfg{}
 	ActiveCodeCfgLoader = map[int32]*ActiveCodeCfg{}
-	loadCsvCfg(path + "ActiveCodeCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActiveCodeCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActiveCodeCfgLoader[row.Id] = row
 		ActiveCodeCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesBtChargeTaskGoldCfgLoader  map[int32]*ActivitiesBtChargeTaskGoldCfg
-type ActivitiesBtChargeTaskGoldCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	TaskIds	[]string	`csv:"TaskIds"`		//7日累充
-	DailyTaskIds	[]string	`csv:"DailyTaskIds"`		//每日累充
-	ActivitiesId	int32	`csv:"ActivitiesId"`		//活动Id
-	Day	int32	`csv:"Day"`		//天数
+var ActivitiesBtChargeTaskGoldCfgLoader map[int32]*ActivitiesBtChargeTaskGoldCfg
+
+type ActivitiesBtChargeTaskGoldCfg struct {
+	Id           int32    `csv:"Id"`           //唯一id
+	TaskIds      []string `csv:"TaskIds"`      //7日累充
+	DailyTaskIds []string `csv:"DailyTaskIds"` //每日累充
+	ActivitiesId int32    `csv:"ActivitiesId"` //活动Id
+	Day          int32    `csv:"Day"`          //天数
 }
 }
+
 func ActivitiesBtChargeTaskGoldCfgLoad(path string) {
 func ActivitiesBtChargeTaskGoldCfgLoad(path string) {
 	cfg := []*ActivitiesBtChargeTaskGoldCfg{}
 	cfg := []*ActivitiesBtChargeTaskGoldCfg{}
 	ActivitiesBtChargeTaskGoldCfgLoader = map[int32]*ActivitiesBtChargeTaskGoldCfg{}
 	ActivitiesBtChargeTaskGoldCfgLoader = map[int32]*ActivitiesBtChargeTaskGoldCfg{}
-	loadCsvCfg(path + "ActivitiesBtChargeTaskGoldCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesBtChargeTaskGoldCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesBtChargeTaskGoldCfgLoader[row.Id] = row
 		ActivitiesBtChargeTaskGoldCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesBtChargeTaskRoMoneyCfgLoader  map[int32]*ActivitiesBtChargeTaskRoMoneyCfg
-type ActivitiesBtChargeTaskRoMoneyCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	TaskIds	[]string	`csv:"TaskIds"`		//7日累充
-	DailyTaskIds	[]string	`csv:"DailyTaskIds"`		//每日累充
-	ActivitiesId	int32	`csv:"ActivitiesId"`		//活动Id
-	Day	int32	`csv:"Day"`		//天数
+var ActivitiesBtChargeTaskRoMoneyCfgLoader map[int32]*ActivitiesBtChargeTaskRoMoneyCfg
+
+type ActivitiesBtChargeTaskRoMoneyCfg struct {
+	Id           int32    `csv:"Id"`           //唯一id
+	TaskIds      []string `csv:"TaskIds"`      //7日累充
+	DailyTaskIds []string `csv:"DailyTaskIds"` //每日累充
+	ActivitiesId int32    `csv:"ActivitiesId"` //活动Id
+	Day          int32    `csv:"Day"`          //天数
 }
 }
+
 func ActivitiesBtChargeTaskRoMoneyCfgLoad(path string) {
 func ActivitiesBtChargeTaskRoMoneyCfgLoad(path string) {
 	cfg := []*ActivitiesBtChargeTaskRoMoneyCfg{}
 	cfg := []*ActivitiesBtChargeTaskRoMoneyCfg{}
 	ActivitiesBtChargeTaskRoMoneyCfgLoader = map[int32]*ActivitiesBtChargeTaskRoMoneyCfg{}
 	ActivitiesBtChargeTaskRoMoneyCfgLoader = map[int32]*ActivitiesBtChargeTaskRoMoneyCfg{}
-	loadCsvCfg(path + "ActivitiesBtChargeTaskRoMoneyCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesBtChargeTaskRoMoneyCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesBtChargeTaskRoMoneyCfgLoader[row.Id] = row
 		ActivitiesBtChargeTaskRoMoneyCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesBtFirstChargeCfgLoader  map[int32]*ActivitiesBtFirstChargeCfg
-type ActivitiesBtFirstChargeCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	Name	string	`csv:"Name"`		//名称
-	OpenCondition	[]string	`csv:"OpenCondition"`		//解锁条件
-	RechargeAmount	[]string	`csv:"RechargeAmount"`		//充值金额
-	Reward1	[]string	`csv:"Reward1"`		//奖励1
-	Value1	int32	`csv:"Value1"`		//价值
-	Reward2	[]string	`csv:"Reward2"`		//奖励2
-	Value2	int32	`csv:"Value2"`		//价值
-	Reward3	[]string	`csv:"Reward3"`		//奖励3
-	Value3	int32	`csv:"Value3"`		//价值
+var ActivitiesBtFirstChargeCfgLoader map[int32]*ActivitiesBtFirstChargeCfg
+
+type ActivitiesBtFirstChargeCfg struct {
+	Id             int32    `csv:"Id"`             //唯一id
+	Name           string   `csv:"Name"`           //名称
+	OpenCondition  []string `csv:"OpenCondition"`  //解锁条件
+	RechargeAmount []string `csv:"RechargeAmount"` //充值金额
+	Reward1        []string `csv:"Reward1"`        //奖励1
+	Value1         int32    `csv:"Value1"`         //价值
+	Reward2        []string `csv:"Reward2"`        //奖励2
+	Value2         int32    `csv:"Value2"`         //价值
+	Reward3        []string `csv:"Reward3"`        //奖励3
+	Value3         int32    `csv:"Value3"`         //价值
 }
 }
+
 func ActivitiesBtFirstChargeCfgLoad(path string) {
 func ActivitiesBtFirstChargeCfgLoad(path string) {
 	cfg := []*ActivitiesBtFirstChargeCfg{}
 	cfg := []*ActivitiesBtFirstChargeCfg{}
 	ActivitiesBtFirstChargeCfgLoader = map[int32]*ActivitiesBtFirstChargeCfg{}
 	ActivitiesBtFirstChargeCfgLoader = map[int32]*ActivitiesBtFirstChargeCfg{}
-	loadCsvCfg(path + "ActivitiesBtFirstChargeCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesBtFirstChargeCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesBtFirstChargeCfgLoader[row.Id] = row
 		ActivitiesBtFirstChargeCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesCfgLoader  map[int32]*ActivitiesCfg
-type ActivitiesCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	Type	int32	`csv:"Type"`		//活动类型
-	Order	int32	`csv:"Order"`		//活动排序
-	StartTime	string	`csv:"StartTime"`		//活动开始时间
-	EndTime	string	`csv:"EndTime"`		//活动结束时间
-	OpenCondition	[]string	`csv:"OpenCondition"`		//活动解锁条件
-	BG	string	`csv:"BG"`		//活动图片
-	HdDrop	[]string	`csv:"HdDrop"`		//活动掉落
-	ActShopID	[]string	`csv:"ActShopID"`		//活动商店ID
-	NeedShow	bool	`csv:"NeedShow"`		//是否显示活动Banner
-	ExpiredActivities	int32	`csv:"ExpiredActivities"`		//过期活动
-	ServiceMark	int32	`csv:"ServiceMark"`		//合服活动
+var ActivitiesCfgLoader map[int32]*ActivitiesCfg
+
+type ActivitiesCfg struct {
+	Id                int32    `csv:"Id"`                //唯一id
+	Type              int32    `csv:"Type"`              //活动类型
+	Order             int32    `csv:"Order"`             //活动排序
+	StartTime         string   `csv:"StartTime"`         //活动开始时间
+	EndTime           string   `csv:"EndTime"`           //活动结束时间
+	OpenCondition     []string `csv:"OpenCondition"`     //活动解锁条件
+	BG                string   `csv:"BG"`                //活动图片
+	HdDrop            []string `csv:"HdDrop"`            //活动掉落
+	ActShopID         []string `csv:"ActShopID"`         //活动商店ID
+	NeedShow          bool     `csv:"NeedShow"`          //是否显示活动Banner
+	ExpiredActivities int32    `csv:"ExpiredActivities"` //过期活动
+	ServiceMark       int32    `csv:"ServiceMark"`       //合服活动
 }
 }
+
 func ActivitiesCfgLoad(path string) {
 func ActivitiesCfgLoad(path string) {
 	cfg := []*ActivitiesCfg{}
 	cfg := []*ActivitiesCfg{}
 	ActivitiesCfgLoader = map[int32]*ActivitiesCfg{}
 	ActivitiesCfgLoader = map[int32]*ActivitiesCfg{}
-	loadCsvCfg(path + "ActivitiesCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesCfgLoader[row.Id] = row
 		ActivitiesCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesCollectionCfgLoader  map[int32]*ActivitiesCollectionCfg
-type ActivitiesCollectionCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	Order	int32	`csv:"Order"`		//显示排序
-	ExchangeCondition	[]string	`csv:"ExchangeCondition"`		//兑换条件
-	ServersReward	int32	`csv:"ServersReward"`		//全服奖励数量
-	Number	int32	`csv:"Number"`		//兑换数量
-	Reward	[]string	`csv:"Reward"`		//兑换奖励
-	ActivitiesId	int32	`csv:"ActivitiesId"`		//活动Id
+var ActivitiesCollectionCfgLoader map[int32]*ActivitiesCollectionCfg
+
+type ActivitiesCollectionCfg struct {
+	Id                int32    `csv:"Id"`                //唯一id
+	Order             int32    `csv:"Order"`             //显示排序
+	ExchangeCondition []string `csv:"ExchangeCondition"` //兑换条件
+	ServersReward     int32    `csv:"ServersReward"`     //全服奖励数量
+	Number            int32    `csv:"Number"`            //兑换数量
+	Reward            []string `csv:"Reward"`            //兑换奖励
+	ActivitiesId      int32    `csv:"ActivitiesId"`      //活动Id
 }
 }
+
 func ActivitiesCollectionCfgLoad(path string) {
 func ActivitiesCollectionCfgLoad(path string) {
 	cfg := []*ActivitiesCollectionCfg{}
 	cfg := []*ActivitiesCollectionCfg{}
 	ActivitiesCollectionCfgLoader = map[int32]*ActivitiesCollectionCfg{}
 	ActivitiesCollectionCfgLoader = map[int32]*ActivitiesCollectionCfg{}
-	loadCsvCfg(path + "ActivitiesCollectionCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesCollectionCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesCollectionCfgLoader[row.Id] = row
 		ActivitiesCollectionCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesDiscountsCfgLoader  map[int32]*ActivitiesDiscountsCfg
-type ActivitiesDiscountsCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	ProductID	int32	`csv:"ProductID"`		//商品标识
-	Name	string	`csv:"Name"`		//名称
-	TriggeringCondition	[]string	`csv:"TriggeringCondition"`		//解锁条件
-	Money	float32	`csv:"Money"`		//金额
-	Reward	[]string	`csv:"Reward"`		//奖励1
-	Time	int32	`csv:"Time"`		//倒计时
-	Value	int32	`csv:"Value"`		//价值
-	Popup	int32	`csv:"Popup"`		//弹出次数
-	PopupWindow	int32	`csv:"PopupWindow"`		//是否弹出
-	Recharge	int32	`csv:"Recharge"`		//累计充值
+var ActivitiesDiscountsCfgLoader map[int32]*ActivitiesDiscountsCfg
+
+type ActivitiesDiscountsCfg struct {
+	Id                  int32    `csv:"Id"`                  //唯一id
+	ProductID           int32    `csv:"ProductID"`           //商品标识
+	Name                string   `csv:"Name"`                //名称
+	TriggeringCondition []string `csv:"TriggeringCondition"` //解锁条件
+	Money               float32  `csv:"Money"`               //金额
+	Reward              []string `csv:"Reward"`              //奖励1
+	Time                int32    `csv:"Time"`                //倒计时
+	Value               int32    `csv:"Value"`               //价值
+	Popup               int32    `csv:"Popup"`               //弹出次数
+	PopupWindow         int32    `csv:"PopupWindow"`         //是否弹出
+	Recharge            int32    `csv:"Recharge"`            //累计充值
 }
 }
+
 func ActivitiesDiscountsCfgLoad(path string) {
 func ActivitiesDiscountsCfgLoad(path string) {
 	cfg := []*ActivitiesDiscountsCfg{}
 	cfg := []*ActivitiesDiscountsCfg{}
 	ActivitiesDiscountsCfgLoader = map[int32]*ActivitiesDiscountsCfg{}
 	ActivitiesDiscountsCfgLoader = map[int32]*ActivitiesDiscountsCfg{}
-	loadCsvCfg(path + "ActivitiesDiscountsCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesDiscountsCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesDiscountsCfgLoader[row.Id] = row
 		ActivitiesDiscountsCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesFirstChargeCfgLoader  map[int32]*ActivitiesFirstChargeCfg
-type ActivitiesFirstChargeCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	Name	string	`csv:"Name"`		//名称
-	OpenCondition	[]string	`csv:"OpenCondition"`		//解锁条件
-	RechargeAmount	float32	`csv:"RechargeAmount"`		//充值金额
-	Reward1	[]string	`csv:"Reward1"`		//奖励1
-	Value1	int32	`csv:"Value1"`		//价值
-	Reward2	[]string	`csv:"Reward2"`		//奖励2
-	Value2	int32	`csv:"Value2"`		//价值
-	Reward3	[]string	`csv:"Reward3"`		//奖励3
-	Value3	int32	`csv:"Value3"`		//价值
+var ActivitiesFirstChargeCfgLoader map[int32]*ActivitiesFirstChargeCfg
+
+type ActivitiesFirstChargeCfg struct {
+	Id             int32    `csv:"Id"`             //唯一id
+	Name           string   `csv:"Name"`           //名称
+	OpenCondition  []string `csv:"OpenCondition"`  //解锁条件
+	RechargeAmount float32  `csv:"RechargeAmount"` //充值金额
+	Reward1        []string `csv:"Reward1"`        //奖励1
+	Value1         int32    `csv:"Value1"`         //价值
+	Reward2        []string `csv:"Reward2"`        //奖励2
+	Value2         int32    `csv:"Value2"`         //价值
+	Reward3        []string `csv:"Reward3"`        //奖励3
+	Value3         int32    `csv:"Value3"`         //价值
 }
 }
+
 func ActivitiesFirstChargeCfgLoad(path string) {
 func ActivitiesFirstChargeCfgLoad(path string) {
 	cfg := []*ActivitiesFirstChargeCfg{}
 	cfg := []*ActivitiesFirstChargeCfg{}
 	ActivitiesFirstChargeCfgLoader = map[int32]*ActivitiesFirstChargeCfg{}
 	ActivitiesFirstChargeCfgLoader = map[int32]*ActivitiesFirstChargeCfg{}
-	loadCsvCfg(path + "ActivitiesFirstChargeCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesFirstChargeCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesFirstChargeCfgLoader[row.Id] = row
 		ActivitiesFirstChargeCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesFortnightDaysCfgLoader  map[int32]*ActivitiesFortnightDaysCfg
-type ActivitiesFortnightDaysCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	TaskIds	[]string	`csv:"TaskIds"`		//成长任务
-	DailyTaskIds	[]string	`csv:"DailyTaskIds"`		//今日挑战
+var ActivitiesFortnightDaysCfgLoader map[int32]*ActivitiesFortnightDaysCfg
+
+type ActivitiesFortnightDaysCfg struct {
+	Id           int32    `csv:"Id"`           //唯一id
+	TaskIds      []string `csv:"TaskIds"`      //成长任务
+	DailyTaskIds []string `csv:"DailyTaskIds"` //今日挑战
 }
 }
+
 func ActivitiesFortnightDaysCfgLoad(path string) {
 func ActivitiesFortnightDaysCfgLoad(path string) {
 	cfg := []*ActivitiesFortnightDaysCfg{}
 	cfg := []*ActivitiesFortnightDaysCfg{}
 	ActivitiesFortnightDaysCfgLoader = map[int32]*ActivitiesFortnightDaysCfg{}
 	ActivitiesFortnightDaysCfgLoader = map[int32]*ActivitiesFortnightDaysCfg{}
-	loadCsvCfg(path + "ActivitiesFortnightDaysCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesFortnightDaysCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesFortnightDaysCfgLoader[row.Id] = row
 		ActivitiesFortnightDaysCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesFortnightOnlineCfgLoader  map[int32]*ActivitiesFortnightOnlineCfg
-type ActivitiesFortnightOnlineCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	Rewards	[]string	`csv:"Rewards"`		//登录奖励
-	ActivitiesId	int32	`csv:"ActivitiesId"`		//活动Id
-	Day	int32	`csv:"Day"`		//登录天数
+var ActivitiesFortnightOnlineCfgLoader map[int32]*ActivitiesFortnightOnlineCfg
+
+type ActivitiesFortnightOnlineCfg struct {
+	Id           int32    `csv:"Id"`           //唯一id
+	Rewards      []string `csv:"Rewards"`      //登录奖励
+	ActivitiesId int32    `csv:"ActivitiesId"` //活动Id
+	Day          int32    `csv:"Day"`          //登录天数
 }
 }
+
 func ActivitiesFortnightOnlineCfgLoad(path string) {
 func ActivitiesFortnightOnlineCfgLoad(path string) {
 	cfg := []*ActivitiesFortnightOnlineCfg{}
 	cfg := []*ActivitiesFortnightOnlineCfg{}
 	ActivitiesFortnightOnlineCfgLoader = map[int32]*ActivitiesFortnightOnlineCfg{}
 	ActivitiesFortnightOnlineCfgLoader = map[int32]*ActivitiesFortnightOnlineCfg{}
-	loadCsvCfg(path + "ActivitiesFortnightOnlineCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesFortnightOnlineCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesFortnightOnlineCfgLoader[row.Id] = row
 		ActivitiesFortnightOnlineCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesGiftCfgLoader  map[int32]*ActivitiesGiftCfg
-type ActivitiesGiftCfg struct{
-	Id	int32	`csv:"Id"`		//ID
-	Classitemid	int32	`csv:"Classitemid"`		//档位类型
-	Classcostaddlike	[]string	`csv:"Classcostaddlike"`		//消耗的道具数量:增加的好感度
-	Activityid	int32	`csv:"Activityid"`		//活动ID
+var ActivitiesGiftCfgLoader map[int32]*ActivitiesGiftCfg
+
+type ActivitiesGiftCfg struct {
+	Id               int32    `csv:"Id"`               //ID
+	Classitemid      int32    `csv:"Classitemid"`      //档位类型
+	Classcostaddlike []string `csv:"Classcostaddlike"` //消耗的道具数量:增加的好感度
+	Activityid       int32    `csv:"Activityid"`       //活动ID
 }
 }
+
 func ActivitiesGiftCfgLoad(path string) {
 func ActivitiesGiftCfgLoad(path string) {
 	cfg := []*ActivitiesGiftCfg{}
 	cfg := []*ActivitiesGiftCfg{}
 	ActivitiesGiftCfgLoader = map[int32]*ActivitiesGiftCfg{}
 	ActivitiesGiftCfgLoader = map[int32]*ActivitiesGiftCfg{}
-	loadCsvCfg(path + "ActivitiesGiftCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesGiftCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesGiftCfgLoader[row.Id] = row
 		ActivitiesGiftCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesKingTaskCfgLoader  map[int32]*ActivitiesKingTaskCfg
-type ActivitiesKingTaskCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	TaskIds	[]string	`csv:"TaskIds"`		//成长任务
-	DailyTaskIds	[]string	`csv:"DailyTaskIds"`		//今日挑战
-	ActivitiesId	int32	`csv:"ActivitiesId"`		//活动Id
-	Day	int32	`csv:"Day"`		//天数
+var ActivitiesKingTaskCfgLoader map[int32]*ActivitiesKingTaskCfg
+
+type ActivitiesKingTaskCfg struct {
+	Id           int32    `csv:"Id"`           //唯一id
+	TaskIds      []string `csv:"TaskIds"`      //成长任务
+	DailyTaskIds []string `csv:"DailyTaskIds"` //今日挑战
+	ActivitiesId int32    `csv:"ActivitiesId"` //活动Id
+	Day          int32    `csv:"Day"`          //天数
 }
 }
+
 func ActivitiesKingTaskCfgLoad(path string) {
 func ActivitiesKingTaskCfgLoad(path string) {
 	cfg := []*ActivitiesKingTaskCfg{}
 	cfg := []*ActivitiesKingTaskCfg{}
 	ActivitiesKingTaskCfgLoader = map[int32]*ActivitiesKingTaskCfg{}
 	ActivitiesKingTaskCfgLoader = map[int32]*ActivitiesKingTaskCfg{}
-	loadCsvCfg(path + "ActivitiesKingTaskCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesKingTaskCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesKingTaskCfgLoader[row.Id] = row
 		ActivitiesKingTaskCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivitieslikabilityCfgLoader  map[int32]*ActivitieslikabilityCfg
-type ActivitieslikabilityCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	Likelevel	int32	`csv:"Likelevel"`		//好感度等级
-	LikeMax	int32	`csv:"LikeMax"`		//好感度上限
-	Conditionrewards	[]string	`csv:"Conditionrewards"`		//好感度固定值对应奖励
-	Activityid	int32	`csv:"Activityid"`		//活动ID
+var ActivitieslikabilityCfgLoader map[int32]*ActivitieslikabilityCfg
+
+type ActivitieslikabilityCfg struct {
+	Id               int32    `csv:"Id"`               //唯一id
+	Likelevel        int32    `csv:"Likelevel"`        //好感度等级
+	LikeMax          int32    `csv:"LikeMax"`          //好感度上限
+	Conditionrewards []string `csv:"Conditionrewards"` //好感度固定值对应奖励
+	Activityid       int32    `csv:"Activityid"`       //活动ID
 }
 }
+
 func ActivitieslikabilityCfgLoad(path string) {
 func ActivitieslikabilityCfgLoad(path string) {
 	cfg := []*ActivitieslikabilityCfg{}
 	cfg := []*ActivitieslikabilityCfg{}
 	ActivitieslikabilityCfgLoader = map[int32]*ActivitieslikabilityCfg{}
 	ActivitieslikabilityCfgLoader = map[int32]*ActivitieslikabilityCfg{}
-	loadCsvCfg(path + "ActivitieslikabilityCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitieslikabilityCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitieslikabilityCfgLoader[row.Id] = row
 		ActivitieslikabilityCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesPetExchangeCfgLoader  map[int32]*ActivitiesPetExchangeCfg
-type ActivitiesPetExchangeCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	Order	int32	`csv:"Order"`		//显示排序
-	ExchangeCondition1	[]string	`csv:"ExchangeCondition1"`		//兑换条件1
-	ExchangeCondition2	[]string	`csv:"ExchangeCondition2"`		//兑换条件2
-	ServersReward	int32	`csv:"ServersReward"`		//全服奖励数量
-	Number	int32	`csv:"Number"`		//兑换数量
-	Reward	[]string	`csv:"Reward"`		//兑换奖励
-	ActivitiesId	int32	`csv:"ActivitiesId"`		//活动Id
-	Type	int32	`csv:"Type"`		//类型
-	Broadcast	int32	`csv:"Broadcast"`		//是否系统公告
-	Scope	[]string	`csv:"Scope"`		//筛选范围
-	ResetDay	int32	`csv:"ResetDay"`		//刷新天数
+var ActivitiesPetExchangeCfgLoader map[int32]*ActivitiesPetExchangeCfg
+
+type ActivitiesPetExchangeCfg struct {
+	Id                 int32    `csv:"Id"`                 //唯一id
+	Order              int32    `csv:"Order"`              //显示排序
+	ExchangeCondition1 []string `csv:"ExchangeCondition1"` //兑换条件1
+	ExchangeCondition2 []string `csv:"ExchangeCondition2"` //兑换条件2
+	ServersReward      int32    `csv:"ServersReward"`      //全服奖励数量
+	Number             int32    `csv:"Number"`             //兑换数量
+	Reward             []string `csv:"Reward"`             //兑换奖励
+	ActivitiesId       int32    `csv:"ActivitiesId"`       //活动Id
+	Type               int32    `csv:"Type"`               //类型
+	Broadcast          int32    `csv:"Broadcast"`          //是否系统公告
+	Scope              []string `csv:"Scope"`              //筛选范围
+	ResetDay           int32    `csv:"ResetDay"`           //刷新天数
 }
 }
+
 func ActivitiesPetExchangeCfgLoad(path string) {
 func ActivitiesPetExchangeCfgLoad(path string) {
 	cfg := []*ActivitiesPetExchangeCfg{}
 	cfg := []*ActivitiesPetExchangeCfg{}
 	ActivitiesPetExchangeCfgLoader = map[int32]*ActivitiesPetExchangeCfg{}
 	ActivitiesPetExchangeCfgLoader = map[int32]*ActivitiesPetExchangeCfg{}
-	loadCsvCfg(path + "ActivitiesPetExchangeCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesPetExchangeCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesPetExchangeCfgLoader[row.Id] = row
 		ActivitiesPetExchangeCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesRewardCfgLoader  map[int32]*ActivitiesRewardCfg
-type ActivitiesRewardCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	Type	int32	`csv:"Type"`		//类型
-	Integral	int32	`csv:"Integral"`		//所需积分
-	Rewards	[]string	`csv:"Rewards"`		//宝箱奖励
+var ActivitiesRewardCfgLoader map[int32]*ActivitiesRewardCfg
+
+type ActivitiesRewardCfg struct {
+	Id       int32    `csv:"Id"`       //唯一id
+	Type     int32    `csv:"Type"`     //类型
+	Integral int32    `csv:"Integral"` //所需积分
+	Rewards  []string `csv:"Rewards"`  //宝箱奖励
 }
 }
+
 func ActivitiesRewardCfgLoad(path string) {
 func ActivitiesRewardCfgLoad(path string) {
 	cfg := []*ActivitiesRewardCfg{}
 	cfg := []*ActivitiesRewardCfg{}
 	ActivitiesRewardCfgLoader = map[int32]*ActivitiesRewardCfg{}
 	ActivitiesRewardCfgLoader = map[int32]*ActivitiesRewardCfg{}
-	loadCsvCfg(path + "ActivitiesRewardCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesRewardCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesRewardCfgLoader[row.Id] = row
 		ActivitiesRewardCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesSignInCfgLoader  map[int32]*ActivitiesSignInCfg
-type ActivitiesSignInCfg struct{
-	ID	int32	`csv:"ID"`		//序列id
-	SignInType	int32	`csv:"SignInType"`		//签到类型
-	SignInReward	[]string	`csv:"SignInReward"`		//签到奖励
-	VipLevel	int32	`csv:"VipLevel"`		//Vip等级
-	ActivitiesId	int32	`csv:"ActivitiesId"`		//活动Id
-	Day	int32	`csv:"Day"`		//签到天数
+var ActivitiesSignInCfgLoader map[int32]*ActivitiesSignInCfg
+
+type ActivitiesSignInCfg struct {
+	ID           int32    `csv:"ID"`           //序列id
+	SignInType   int32    `csv:"SignInType"`   //签到类型
+	SignInReward []string `csv:"SignInReward"` //签到奖励
+	VipLevel     int32    `csv:"VipLevel"`     //Vip等级
+	ActivitiesId int32    `csv:"ActivitiesId"` //活动Id
+	Day          int32    `csv:"Day"`          //签到天数
 }
 }
+
 func ActivitiesSignInCfgLoad(path string) {
 func ActivitiesSignInCfgLoad(path string) {
 	cfg := []*ActivitiesSignInCfg{}
 	cfg := []*ActivitiesSignInCfg{}
 	ActivitiesSignInCfgLoader = map[int32]*ActivitiesSignInCfg{}
 	ActivitiesSignInCfgLoader = map[int32]*ActivitiesSignInCfg{}
-	loadCsvCfg(path + "ActivitiesSignInCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesSignInCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesSignInCfgLoader[row.ID] = row
 		ActivitiesSignInCfgLoader[row.ID] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesTaskCfgLoader  map[int32]*ActivitiesTaskCfg
-type ActivitiesTaskCfg struct{
-	TaskId	int32	`csv:"TaskId"`		//任务ID
-	TaskCondition	[]string	`csv:"TaskCondition"`		//任务枚举
-	Reward	[]string	`csv:"Reward"`		//任务奖励
-	ShowState	int32	`csv:"ShowState"`		//是否显示进度
-	Integral	int32	`csv:"Integral"`		//积分
+var ActivitiesTaskCfgLoader map[int32]*ActivitiesTaskCfg
+
+type ActivitiesTaskCfg struct {
+	TaskId        int32    `csv:"TaskId"`        //任务ID
+	TaskCondition []string `csv:"TaskCondition"` //任务枚举
+	Reward        []string `csv:"Reward"`        //任务奖励
+	ShowState     int32    `csv:"ShowState"`     //是否显示进度
+	Integral      int32    `csv:"Integral"`      //积分
 }
 }
+
 func ActivitiesTaskCfgLoad(path string) {
 func ActivitiesTaskCfgLoad(path string) {
 	cfg := []*ActivitiesTaskCfg{}
 	cfg := []*ActivitiesTaskCfg{}
 	ActivitiesTaskCfgLoader = map[int32]*ActivitiesTaskCfg{}
 	ActivitiesTaskCfgLoader = map[int32]*ActivitiesTaskCfg{}
-	loadCsvCfg(path + "ActivitiesTaskCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesTaskCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesTaskCfgLoader[row.TaskId] = row
 		ActivitiesTaskCfgLoader[row.TaskId] = row
 	}
 	}
 }
 }
 
 
-var ActivitiesTiredChargeCfgLoader  map[int32]*ActivitiesTiredChargeCfg
-type ActivitiesTiredChargeCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	RechargeAmount	float32	`csv:"RechargeAmount"`		//充值金额
-	Reward	[]string	`csv:"Reward"`		//奖励1
-	Day	int32	`csv:"Day"`		//奖励天数
-	Index	int32	`csv:"Index"`		//奖励档次
+var ActivitiesTiredChargeCfgLoader map[int32]*ActivitiesTiredChargeCfg
+
+type ActivitiesTiredChargeCfg struct {
+	Id             int32    `csv:"Id"`             //唯一id
+	RechargeAmount float32  `csv:"RechargeAmount"` //充值金额
+	Reward         []string `csv:"Reward"`         //奖励1
+	Day            int32    `csv:"Day"`            //奖励天数
+	Index          int32    `csv:"Index"`          //奖励档次
 }
 }
+
 func ActivitiesTiredChargeCfgLoad(path string) {
 func ActivitiesTiredChargeCfgLoad(path string) {
 	cfg := []*ActivitiesTiredChargeCfg{}
 	cfg := []*ActivitiesTiredChargeCfg{}
 	ActivitiesTiredChargeCfgLoader = map[int32]*ActivitiesTiredChargeCfg{}
 	ActivitiesTiredChargeCfgLoader = map[int32]*ActivitiesTiredChargeCfg{}
-	loadCsvCfg(path + "ActivitiesTiredChargeCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivitiesTiredChargeCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivitiesTiredChargeCfgLoader[row.Id] = row
 		ActivitiesTiredChargeCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActivityRoulettelCfgLoader  map[int32]*ActivityRoulettelCfg
-type ActivityRoulettelCfg struct{
-	Id	int32	`csv:"Id"`		//ID
-	LowNormalNum	[]string	`csv:"LowNormalNum"`		//低级奖
-	NormalNum	[]string	`csv:"NormalNum"`		//Normal奖
-	MiniNum	[]string	`csv:"MiniNum"`		//Mini奖
-	MvpNum	[]string	`csv:"MvpNum"`		//Mvp奖
-	ModProbability	int32	`csv:"ModProbability"`		//模板权重
-	Probability	[]string	`csv:"Probability"`		//非MVP抽奖概率
-	MvpProbability	[]string	`csv:"MvpProbability"`		//MVP抽奖概率
-	ItemPrice	int32	`csv:"ItemPrice"`		//一个道具的价格
-	RewardOneItem	[]string	`csv:"RewardOneItem"`		//抽一次价格(道具)
-	RewardOneGold	[]string	`csv:"RewardOneGold"`		//抽一次价格(金币)
-	RewardAllItem	[]string	`csv:"RewardAllItem"`		//抽全部价格(道具)
-	RewardAdllGold	int32	`csv:"RewardAdllGold"`		//抽全部价格(金币)
-	RefreshPrice	[]string	`csv:"RefreshPrice"`		//刷新价格(金币)
-	NoRewardNum	int32	`csv:"NoRewardNum"`		//结束本轮次数
-	ActivitiesId	int32	`csv:"ActivitiesId"`		//活动Id
+var ActivityRoulettelCfgLoader map[int32]*ActivityRoulettelCfg
+
+type ActivityRoulettelCfg struct {
+	Id             int32    `csv:"Id"`             //ID
+	LowNormalNum   []string `csv:"LowNormalNum"`   //低级奖
+	NormalNum      []string `csv:"NormalNum"`      //Normal奖
+	MiniNum        []string `csv:"MiniNum"`        //Mini奖
+	MvpNum         []string `csv:"MvpNum"`         //Mvp奖
+	ModProbability int32    `csv:"ModProbability"` //模板权重
+	Probability    []string `csv:"Probability"`    //非MVP抽奖概率
+	MvpProbability []string `csv:"MvpProbability"` //MVP抽奖概率
+	ItemPrice      int32    `csv:"ItemPrice"`      //一个道具的价格
+	RewardOneItem  []string `csv:"RewardOneItem"`  //抽一次价格(道具)
+	RewardOneGold  []string `csv:"RewardOneGold"`  //抽一次价格(金币)
+	RewardAllItem  []string `csv:"RewardAllItem"`  //抽全部价格(道具)
+	RewardAdllGold int32    `csv:"RewardAdllGold"` //抽全部价格(金币)
+	RefreshPrice   []string `csv:"RefreshPrice"`   //刷新价格(金币)
+	NoRewardNum    int32    `csv:"NoRewardNum"`    //结束本轮次数
+	ActivitiesId   int32    `csv:"ActivitiesId"`   //活动Id
 }
 }
+
 func ActivityRoulettelCfgLoad(path string) {
 func ActivityRoulettelCfgLoad(path string) {
 	cfg := []*ActivityRoulettelCfg{}
 	cfg := []*ActivityRoulettelCfg{}
 	ActivityRoulettelCfgLoader = map[int32]*ActivityRoulettelCfg{}
 	ActivityRoulettelCfgLoader = map[int32]*ActivityRoulettelCfg{}
-	loadCsvCfg(path + "ActivityRoulettelCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActivityRoulettelCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActivityRoulettelCfgLoader[row.Id] = row
 		ActivityRoulettelCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ActRewardCfgLoader  map[int32]*ActRewardCfg
-type ActRewardCfg struct{
-	ID	int32	`csv:"ID"`		//ID
-	ActiveType	int32	`csv:"ActiveType"`		//活跃度类型
-	Active	int32	`csv:"Active"`		//活跃值
-	Reward	[]string	`csv:"Reward"`		//奖励
-	HdDrop	[]string	`csv:"HdDrop"`		//活动掉落
+var ActRewardCfgLoader map[int32]*ActRewardCfg
+
+type ActRewardCfg struct {
+	ID         int32    `csv:"ID"`         //ID
+	ActiveType int32    `csv:"ActiveType"` //活跃度类型
+	Active     int32    `csv:"Active"`     //活跃值
+	Reward     []string `csv:"Reward"`     //奖励
+	HdDrop     []string `csv:"HdDrop"`     //活动掉落
 }
 }
+
 func ActRewardCfgLoad(path string) {
 func ActRewardCfgLoad(path string) {
 	cfg := []*ActRewardCfg{}
 	cfg := []*ActRewardCfg{}
 	ActRewardCfgLoader = map[int32]*ActRewardCfg{}
 	ActRewardCfgLoader = map[int32]*ActRewardCfg{}
-	loadCsvCfg(path + "ActRewardCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ActRewardCfg.csv", &cfg)
+	for _, row := range cfg {
 		ActRewardCfgLoader[row.ID] = row
 		ActRewardCfgLoader[row.ID] = row
 	}
 	}
 }
 }
 
 
-var AdvertisingScreenLoader  map[int32]*AdvertisingScreen
-type AdvertisingScreen struct{
-	ID	int32	`csv:"ID"`		//ID
-	Type	string	`csv:"Type"`		//Type
+var AdvertisingScreenLoader map[int32]*AdvertisingScreen
+
+type AdvertisingScreen struct {
+	ID   int32  `csv:"ID"`   //ID
+	Type string `csv:"Type"` //Type
 }
 }
+
 func AdvertisingScreenLoad(path string) {
 func AdvertisingScreenLoad(path string) {
 	cfg := []*AdvertisingScreen{}
 	cfg := []*AdvertisingScreen{}
 	AdvertisingScreenLoader = map[int32]*AdvertisingScreen{}
 	AdvertisingScreenLoader = map[int32]*AdvertisingScreen{}
-	loadCsvCfg(path + "AdvertisingScreen.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"AdvertisingScreen.csv", &cfg)
+	for _, row := range cfg {
 		AdvertisingScreenLoader[row.ID] = row
 		AdvertisingScreenLoader[row.ID] = row
 	}
 	}
 }
 }
 
 
-var ArenaLevelCfgLoader  map[int32]*ArenaLevelCfg
-type ArenaLevelCfg struct{
-	ArenaLevelId	int32	`csv:"ArenaLevelId"`		//段位ID
-	ArenaLevelName	string	`csv:"ArenaLevelName"`		//段位名称
-	ArenaLevelScore	int32	`csv:"ArenaLevelScore"`		//段位积分
-	ArenaLevelReward	[]string	`csv:"ArenaLevelReward"`		//段位奖励
-	WinReward	[]string	`csv:"WinReward"`		//胜利资源奖励
-	FailReward	[]string	`csv:"FailReward"`		//失败资源奖励
-	WinScore	int32	`csv:"WinScore"`		//胜利积分
-	WinScore1	int32	`csv:"WinScore1"`		//遇强敌胜利积分
-	WinScore2	int32	`csv:"WinScore2"`		//遇弱胜利积分
-	LostScore	int32	`csv:"LostScore"`		//失败积分
-	LostScore1	int32	`csv:"LostScore1"`		//遇强敌失败积分
-	LostScore2	int32	`csv:"LostScore2"`		//遇弱失败积分
-	Section	[]string	`csv:"Section"`		//强弱区间
-	WinStreak	[]string	`csv:"WinStreak"`		//连胜积分
-	Win	[]string	`csv:"Win"`		//胜利匹配区间
-	Fail	[]string	`csv:"Fail"`		//失败匹配区间
-	LevelReduce	int32	`csv:"LevelReduce"`		//赛季降段
+var ArenaLevelCfgLoader map[int32]*ArenaLevelCfg
+
+type ArenaLevelCfg struct {
+	ArenaLevelId     int32    `csv:"ArenaLevelId"`     //段位ID
+	ArenaLevelName   string   `csv:"ArenaLevelName"`   //段位名称
+	ArenaLevelScore  int32    `csv:"ArenaLevelScore"`  //段位积分
+	ArenaLevelReward []string `csv:"ArenaLevelReward"` //段位奖励
+	WinReward        []string `csv:"WinReward"`        //胜利资源奖励
+	FailReward       []string `csv:"FailReward"`       //失败资源奖励
+	WinScore         int32    `csv:"WinScore"`         //胜利积分
+	WinScore1        int32    `csv:"WinScore1"`        //遇强敌胜利积分
+	WinScore2        int32    `csv:"WinScore2"`        //遇弱胜利积分
+	LostScore        int32    `csv:"LostScore"`        //失败积分
+	LostScore1       int32    `csv:"LostScore1"`       //遇强敌失败积分
+	LostScore2       int32    `csv:"LostScore2"`       //遇弱失败积分
+	Section          []string `csv:"Section"`          //强弱区间
+	WinStreak        []string `csv:"WinStreak"`        //连胜积分
+	Win              []string `csv:"Win"`              //胜利匹配区间
+	Fail             []string `csv:"Fail"`             //失败匹配区间
+	LevelReduce      int32    `csv:"LevelReduce"`      //赛季降段
 }
 }
+
 func ArenaLevelCfgLoad(path string) {
 func ArenaLevelCfgLoad(path string) {
 	cfg := []*ArenaLevelCfg{}
 	cfg := []*ArenaLevelCfg{}
 	ArenaLevelCfgLoader = map[int32]*ArenaLevelCfg{}
 	ArenaLevelCfgLoader = map[int32]*ArenaLevelCfg{}
-	loadCsvCfg(path + "ArenaLevelCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ArenaLevelCfg.csv", &cfg)
+	for _, row := range cfg {
 		ArenaLevelCfgLoader[row.ArenaLevelId] = row
 		ArenaLevelCfgLoader[row.ArenaLevelId] = row
 	}
 	}
 }
 }
 
 
-var ArenaRewardCfgLoader  map[int32]*ArenaRewardCfg
-type ArenaRewardCfg struct{
-	RankId	int32	`csv:"RankId"`		//排名ID
-	Zone	int32	`csv:"Zone"`		//区号
-	StartTime	string	`csv:"StartTime"`		//开始时间
-	CloseTime	string	`csv:"CloseTime"`		//结束时间
-	Rest	int32	`csv:"Rest"`		//休息时间
-	ArenaRank	[]string	`csv:"ArenaRank"`		//竞技场排名
-	ArenaReward	[]string	`csv:"ArenaReward"`		//排名奖励
+var ArenaRewardCfgLoader map[int32]*ArenaRewardCfg
+
+type ArenaRewardCfg struct {
+	RankId      int32    `csv:"RankId"`      //排名ID
+	Zone        int32    `csv:"Zone"`        //区号
+	StartTime   string   `csv:"StartTime"`   //开始时间
+	CloseTime   string   `csv:"CloseTime"`   //结束时间
+	Rest        int32    `csv:"Rest"`        //休息时间
+	ArenaRank   []string `csv:"ArenaRank"`   //竞技场排名
+	ArenaReward []string `csv:"ArenaReward"` //排名奖励
 }
 }
+
 func ArenaRewardCfgLoad(path string) {
 func ArenaRewardCfgLoad(path string) {
 	cfg := []*ArenaRewardCfg{}
 	cfg := []*ArenaRewardCfg{}
 	ArenaRewardCfgLoader = map[int32]*ArenaRewardCfg{}
 	ArenaRewardCfgLoader = map[int32]*ArenaRewardCfg{}
-	loadCsvCfg(path + "ArenaRewardCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ArenaRewardCfg.csv", &cfg)
+	for _, row := range cfg {
 		ArenaRewardCfgLoader[row.RankId] = row
 		ArenaRewardCfgLoader[row.RankId] = row
 	}
 	}
 }
 }
 
 
-var ArtifactCfgLoader  map[int32]*ArtifactCfg
-type ArtifactCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	Quality	int32	`csv:"Quality"`		//品质
-	ArtifactMaxLevel	int32	`csv:"ArtifactMaxLevel"`		//最大星级
-	ArtifacFuncId	[]string	`csv:"ArtifacFuncId"`		//效果ID
-	JobType	int32	`csv:"JobType"`		//职业类型
-	JobBranch	int32	`csv:"JobBranch"`		//职业分支
-	JobStage	int32	`csv:"JobStage"`		//职业阶段
-	Condition	[]string	`csv:"Condition"`		//升星条件
-	AddFight	[]string	`csv:"AddFight"`		//增加战力
-	SmeltReturn	[]string	`csv:"SmeltReturn"`		//熔炼返还材料
-	ReforgeCost	[]string	`csv:"ReforgeCost"`		//神器重铸消耗
-	Times	int32	`csv:"Times"`		//批次id
-	ArtifactDuration	[]string	`csv:"ArtifactDuration"`		//开服天数区间
+var ArtifactCfgLoader map[int32]*ArtifactCfg
+
+type ArtifactCfg struct {
+	Id               int32    `csv:"Id"`               //唯一id
+	Quality          int32    `csv:"Quality"`          //品质
+	ArtifactMaxLevel int32    `csv:"ArtifactMaxLevel"` //最大星级
+	ArtifacFuncId    []string `csv:"ArtifacFuncId"`    //效果ID
+	JobType          int32    `csv:"JobType"`          //职业类型
+	JobBranch        int32    `csv:"JobBranch"`        //职业分支
+	JobStage         int32    `csv:"JobStage"`         //职业阶段
+	Condition        []string `csv:"Condition"`        //升星条件
+	AddFight         []string `csv:"AddFight"`         //增加战力
+	SmeltReturn      []string `csv:"SmeltReturn"`      //熔炼返还材料
+	ReforgeCost      []string `csv:"ReforgeCost"`      //神器重铸消耗
+	Times            int32    `csv:"Times"`            //批次id
+	ArtifactDuration []string `csv:"ArtifactDuration"` //开服天数区间
 }
 }
+
 func ArtifactCfgLoad(path string) {
 func ArtifactCfgLoad(path string) {
 	cfg := []*ArtifactCfg{}
 	cfg := []*ArtifactCfg{}
 	ArtifactCfgLoader = map[int32]*ArtifactCfg{}
 	ArtifactCfgLoader = map[int32]*ArtifactCfg{}
-	loadCsvCfg(path + "ArtifactCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ArtifactCfg.csv", &cfg)
+	for _, row := range cfg {
 		ArtifactCfgLoader[row.Id] = row
 		ArtifactCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ArtifactExpCfgLoader  map[int32]*ArtifactExpCfg
-type ArtifactExpCfg struct{
-	ArtifactLevel	int32	`csv:"ArtifactLevel"`		//神器位等级
-	UpgradeCost	[]string	`csv:"UpgradeCost"`		//升级消耗
-	Nature	[]string	`csv:"Nature"`		//增加属性
+var ArtifactExpCfgLoader map[int32]*ArtifactExpCfg
+
+type ArtifactExpCfg struct {
+	ArtifactLevel int32    `csv:"ArtifactLevel"` //神器位等级
+	UpgradeCost   []string `csv:"UpgradeCost"`   //升级消耗
+	Nature        []string `csv:"Nature"`        //增加属性
 }
 }
+
 func ArtifactExpCfgLoad(path string) {
 func ArtifactExpCfgLoad(path string) {
 	cfg := []*ArtifactExpCfg{}
 	cfg := []*ArtifactExpCfg{}
 	ArtifactExpCfgLoader = map[int32]*ArtifactExpCfg{}
 	ArtifactExpCfgLoader = map[int32]*ArtifactExpCfg{}
-	loadCsvCfg(path + "ArtifactExpCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ArtifactExpCfg.csv", &cfg)
+	for _, row := range cfg {
 		ArtifactExpCfgLoader[row.ArtifactLevel] = row
 		ArtifactExpCfgLoader[row.ArtifactLevel] = row
 	}
 	}
 }
 }
 
 
-var BoliShopCfgLoader  map[int32]*BoliShopCfg
-type BoliShopCfg struct{
-	GoodsId	int32	`csv:"GoodsId"`		//商品Id
-	GoodsName	string	`csv:"GoodsName"`		//商品名称
-	GoodsType	int32	`csv:"GoodsType"`		//商品所属tab
-	GoodsTypename	string	`csv:"GoodsTypename"`		//商品页签
-	GoodsItem	int32	`csv:"GoodsItem"`		//商品内容
-	PayForType	int32	`csv:"PayForType"`		//消耗资源类型
-	PayForNum	int32	`csv:"PayForNum"`		//消耗资源数量
-	HdDrop	int32	`csv:"HdDrop"`		//活动商品
-	SellWell	int32	`csv:"SellWell"`		//是否热销
-	Proportion	int32	`csv:"Proportion"`		//折扣比例
-	DiscountPayForNum	int32	`csv:"DiscountPayForNum"`		//折扣后价格
-	RestrictedType	string	`csv:"RestrictedType"`		//限购类型次数
-	BeginTime	string	`csv:"BeginTime"`		//开始时间
-	EndTime	string	`csv:"EndTime"`		//结束时间
-	SortId	int32	`csv:"SortId"`		//排序Id
-	Weight	int32	`csv:"Weight"`		//权重概率
-	Weight1	int32	`csv:"Weight1"`		//VIP权重概率1
-	Weight2	int32	`csv:"Weight2"`		//VIP权重概率2
-	Weight3	int32	`csv:"Weight3"`		//VIP权重概率3
-	Weight4	int32	`csv:"Weight4"`		//VIP权重概率4
-	NtfClient	int32	`csv:"NtfClient"`		//是否通知客户端
-	GoodsPic	string	`csv:"GoodsPic"`		//图片
-	Reward	[]string	`csv:"Reward"`		//购买后获得道具
-	Condition	[]string	`csv:"Condition"`		//上架解锁条件枚举
-	BoliVipLevel	int32	`csv:"BoliVipLevel"`		//波利特权等级显示
+var BoliShopCfgLoader map[int32]*BoliShopCfg
+
+type BoliShopCfg struct {
+	GoodsId           int32    `csv:"GoodsId"`           //商品Id
+	GoodsName         string   `csv:"GoodsName"`         //商品名称
+	GoodsType         int32    `csv:"GoodsType"`         //商品所属tab
+	GoodsTypename     string   `csv:"GoodsTypename"`     //商品页签
+	GoodsItem         int32    `csv:"GoodsItem"`         //商品内容
+	PayForType        int32    `csv:"PayForType"`        //消耗资源类型
+	PayForNum         int32    `csv:"PayForNum"`         //消耗资源数量
+	HdDrop            int32    `csv:"HdDrop"`            //活动商品
+	SellWell          int32    `csv:"SellWell"`          //是否热销
+	Proportion        int32    `csv:"Proportion"`        //折扣比例
+	DiscountPayForNum int32    `csv:"DiscountPayForNum"` //折扣后价格
+	RestrictedType    string   `csv:"RestrictedType"`    //限购类型次数
+	BeginTime         string   `csv:"BeginTime"`         //开始时间
+	EndTime           string   `csv:"EndTime"`           //结束时间
+	SortId            int32    `csv:"SortId"`            //排序Id
+	Weight            int32    `csv:"Weight"`            //权重概率
+	Weight1           int32    `csv:"Weight1"`           //VIP权重概率1
+	Weight2           int32    `csv:"Weight2"`           //VIP权重概率2
+	Weight3           int32    `csv:"Weight3"`           //VIP权重概率3
+	Weight4           int32    `csv:"Weight4"`           //VIP权重概率4
+	NtfClient         int32    `csv:"NtfClient"`         //是否通知客户端
+	GoodsPic          string   `csv:"GoodsPic"`          //图片
+	Reward            []string `csv:"Reward"`            //购买后获得道具
+	Condition         []string `csv:"Condition"`         //上架解锁条件枚举
+	BoliVipLevel      int32    `csv:"BoliVipLevel"`      //波利特权等级显示
 }
 }
+
 func BoliShopCfgLoad(path string) {
 func BoliShopCfgLoad(path string) {
 	cfg := []*BoliShopCfg{}
 	cfg := []*BoliShopCfg{}
 	BoliShopCfgLoader = map[int32]*BoliShopCfg{}
 	BoliShopCfgLoader = map[int32]*BoliShopCfg{}
-	loadCsvCfg(path + "BoliShopCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"BoliShopCfg.csv", &cfg)
+	for _, row := range cfg {
 		BoliShopCfgLoader[row.GoodsId] = row
 		BoliShopCfgLoader[row.GoodsId] = row
 	}
 	}
 }
 }
 
 
-var BoliVipCfgLoader  map[int32]*BoliVipCfg
-type BoliVipCfg struct{
-	Lv	int32	`csv:"Lv"`		//波利特权等级
-	QuickBattle	int32	`csv:"QuickBattle"`		//战斗X2加速
-	Reward	[]string	`csv:"Reward"`		//Vip道具奖励
-	VipExp	int32	`csv:"VipExp"`		//Vip升级所需经验
-	EvilFreeTimes	int32	`csv:"EvilFreeTimes"`		//恶魔免费刷新次数
-	VipLogin	int32	`csv:"VipLogin"`		//VIP上线提示
-	PetAdvance	int32	`csv:"PetAdvance"`		//宠物进阶消耗免费
-	CardReset	int32	`csv:"CardReset"`		//卡片重铸免费
-	PetBreak	int32	`csv:"PetBreak"`		//宠物分解全额返还
-	SkillReset	int32	`csv:"SkillReset"`		//角色技能重置免费
-	GuildBossChallenge	int32	`csv:"GuildBossChallenge"`		//公会狩猎额外次数
-	CardInsertion	int32	`csv:"CardInsertion"`		//一键插卡功能
-	ShopWeight	int32	`csv:"ShopWeight"`		//黑市VIP权重
-	WorldBoss	int32	`csv:"WorldBoss"`		//世界BOSS刮奖次数
-	PvpReward	int32	`csv:"PvpReward"`		//额外荣誉之证
-	HangupTimes	int32	`csv:"HangupTimes"`		//时光之力购买次数
-	SilverUp	int32	`csv:"SilverUp"`		//银币加成
-	BaseExpUp	int32	`csv:"BaseExpUp"`		//基础经验加成
-	PartnerExpUp	int32	`csv:"PartnerExpUp"`		//伙伴经验加成
-	SkillExpUp	int32	`csv:"SkillExpUp"`		//技能经验加成
-	GiftBuyTimes	[]string	`csv:"GiftBuyTimes"`		//每日礼包购买次数+1
-	HangupDuration	int32	`csv:"HangupDuration"`		//离线挂机时长上限(秒)
-	SignInRewardUp	int32	`csv:"SignInRewardUp"`		//签到翻倍
-	WorldBossCount	int32	`csv:"WorldBossCount"`		//世界BOSS购买次数
-	DevilsUp	int32	`csv:"DevilsUp"`		//挂机魔魂值加成
-	TransportRobbery	int32	`csv:"TransportRobbery"`		//飞艇被抢劫掉落减少至
-	LuxuryPrizeWheelTimes	int32	`csv:"LuxuryPrizeWheelTimes"`		//豪华转盘可使用次数
-	GiftRewards	[]string	`csv:"GiftRewards"`		//每日礼包
+var BoliVipCfgLoader map[int32]*BoliVipCfg
+
+type BoliVipCfg struct {
+	Lv                    int32    `csv:"Lv"`                    //波利特权等级
+	QuickBattle           int32    `csv:"QuickBattle"`           //战斗X2加速
+	Reward                []string `csv:"Reward"`                //Vip道具奖励
+	VipExp                int32    `csv:"VipExp"`                //Vip升级所需经验
+	EvilFreeTimes         int32    `csv:"EvilFreeTimes"`         //恶魔免费刷新次数
+	VipLogin              int32    `csv:"VipLogin"`              //VIP上线提示
+	PetAdvance            int32    `csv:"PetAdvance"`            //宠物进阶消耗免费
+	CardReset             int32    `csv:"CardReset"`             //卡片重铸免费
+	PetBreak              int32    `csv:"PetBreak"`              //宠物分解全额返还
+	SkillReset            int32    `csv:"SkillReset"`            //角色技能重置免费
+	GuildBossChallenge    int32    `csv:"GuildBossChallenge"`    //公会狩猎额外次数
+	CardInsertion         int32    `csv:"CardInsertion"`         //一键插卡功能
+	ShopWeight            int32    `csv:"ShopWeight"`            //黑市VIP权重
+	WorldBoss             int32    `csv:"WorldBoss"`             //世界BOSS刮奖次数
+	PvpReward             int32    `csv:"PvpReward"`             //额外荣誉之证
+	HangupTimes           int32    `csv:"HangupTimes"`           //时光之力购买次数
+	SilverUp              int32    `csv:"SilverUp"`              //银币加成
+	BaseExpUp             int32    `csv:"BaseExpUp"`             //基础经验加成
+	PartnerExpUp          int32    `csv:"PartnerExpUp"`          //伙伴经验加成
+	SkillExpUp            int32    `csv:"SkillExpUp"`            //技能经验加成
+	GiftBuyTimes          []string `csv:"GiftBuyTimes"`          //每日礼包购买次数+1
+	HangupDuration        int32    `csv:"HangupDuration"`        //离线挂机时长上限(秒)
+	SignInRewardUp        int32    `csv:"SignInRewardUp"`        //签到翻倍
+	WorldBossCount        int32    `csv:"WorldBossCount"`        //世界BOSS购买次数
+	DevilsUp              int32    `csv:"DevilsUp"`              //挂机魔魂值加成
+	TransportRobbery      int32    `csv:"TransportRobbery"`      //飞艇被抢劫掉落减少至
+	LuxuryPrizeWheelTimes int32    `csv:"LuxuryPrizeWheelTimes"` //豪华转盘可使用次数
+	GiftRewards           []string `csv:"GiftRewards"`           //每日礼包
 }
 }
+
 func BoliVipCfgLoad(path string) {
 func BoliVipCfgLoad(path string) {
 	cfg := []*BoliVipCfg{}
 	cfg := []*BoliVipCfg{}
 	BoliVipCfgLoader = map[int32]*BoliVipCfg{}
 	BoliVipCfgLoader = map[int32]*BoliVipCfg{}
-	loadCsvCfg(path + "BoliVipCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"BoliVipCfg.csv", &cfg)
+	for _, row := range cfg {
 		BoliVipCfgLoader[row.Lv] = row
 		BoliVipCfgLoader[row.Lv] = row
 	}
 	}
 }
 }
 
 
-var BTSmashEggsCfgLoader  map[int32]*BTSmashEggsCfg
-type BTSmashEggsCfg struct{
-	Id	int32	`csv:"Id"`		//砸蛋Id
-	Name	string	`csv:"Name"`		//砸蛋名字
-	Cost	[]string	`csv:"Cost"`		//消耗道具顺序
-	Method	[]string	`csv:"Method"`		//砸蛋方式
-	DropId	int32	`csv:"DropId"`		//消耗道具1掉落包
-	DropId2	int32	`csv:"DropId2"`		//消耗道具1掉落包
-	Total	int32	`csv:"Total"`		//保底奖励的累计次数
-	ExtDropId	int32	`csv:"ExtDropId"`		//保底奖励的掉落包
-	SortId	int32	`csv:"SortId"`		//界面排序
-	ShowItemType	[]string	`csv:"ShowItemType"`		//可用于表现的道具类型
-	UnLock	int32	`csv:"UnLock"`		//解锁ID
-	ActivitiesId	int32	`csv:"ActivitiesId"`		//活动Id
-	Type	int32	`csv:"Type"`		//召唤类型
-	StartDay	int32	`csv:"StartDay"`		//开服时间
-	SummoType	int32	`csv:"SummoType"`		//召唤组
-	Show	[]string	`csv:"Show"`		//大奖预览
-	ClientShow	[]string	`csv:"ClientShow"`		//客户端大奖预览
+var BTSmashEggsCfgLoader map[int32]*BTSmashEggsCfg
+
+type BTSmashEggsCfg struct {
+	Id           int32    `csv:"Id"`           //砸蛋Id
+	Name         string   `csv:"Name"`         //砸蛋名字
+	Cost         []string `csv:"Cost"`         //消耗道具顺序
+	Method       []string `csv:"Method"`       //砸蛋方式
+	DropId       int32    `csv:"DropId"`       //消耗道具1掉落包
+	DropId2      int32    `csv:"DropId2"`      //消耗道具1掉落包
+	Total        int32    `csv:"Total"`        //保底奖励的累计次数
+	ExtDropId    int32    `csv:"ExtDropId"`    //保底奖励的掉落包
+	SortId       int32    `csv:"SortId"`       //界面排序
+	ShowItemType []string `csv:"ShowItemType"` //可用于表现的道具类型
+	UnLock       int32    `csv:"UnLock"`       //解锁ID
+	ActivitiesId int32    `csv:"ActivitiesId"` //活动Id
+	Type         int32    `csv:"Type"`         //召唤类型
+	StartDay     int32    `csv:"StartDay"`     //开服时间
+	SummoType    int32    `csv:"SummoType"`    //召唤组
+	Show         []string `csv:"Show"`         //大奖预览
+	ClientShow   []string `csv:"ClientShow"`   //客户端大奖预览
 }
 }
+
 func BTSmashEggsCfgLoad(path string) {
 func BTSmashEggsCfgLoad(path string) {
 	cfg := []*BTSmashEggsCfg{}
 	cfg := []*BTSmashEggsCfg{}
 	BTSmashEggsCfgLoader = map[int32]*BTSmashEggsCfg{}
 	BTSmashEggsCfgLoader = map[int32]*BTSmashEggsCfg{}
-	loadCsvCfg(path + "BTSmashEggsCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"BTSmashEggsCfg.csv", &cfg)
+	for _, row := range cfg {
 		BTSmashEggsCfgLoader[row.Id] = row
 		BTSmashEggsCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var CardCfgLoader  map[int32]*CardCfg
-type CardCfg struct{
-	CardId	int32	`csv:"CardId"`		//卡片ID
-	CardName	string	`csv:"CardName"`		//卡片名称
-	FromCardId	int32	`csv:"FromCardId"`		//来源目标
-	ToCardId	int32	`csv:"ToCardId"`		//升级目标
-	CardType	int32	`csv:"CardType"`		//卡片类型
-	CardLocation	int32	`csv:"CardLocation"`		//卡片部位
-	CardLevel	int32	`csv:"CardLevel"`		//卡片等级
-	Attribute1	[]string	`csv:"Attribute1"`		//卡片属性
-	CardPicId	int32	`csv:"CardPicId"`		//卡片图鉴ID
-	BUFF	[]string	`csv:"BUFF"`		//卡片BUFF
-	Pro	int32	`csv:"Pro"`		//卡组权重
-	FightPower	int32	`csv:"FightPower"`		//卡片附加战斗力
-	Profession	[]string	`csv:"Profession"`		//推荐职业
-	Attribute2	[]string	`csv:"Attribute2"`		//筛选用基础属性
-	Attribute3	int32	`csv:"Attribute3"`		//卡片相克属性
-	UpCost	int32	`csv:"UpCost"`		//卡片升级费用
+var CardCfgLoader map[int32]*CardCfg
+
+type CardCfg struct {
+	CardId       int32    `csv:"CardId"`       //卡片ID
+	CardName     string   `csv:"CardName"`     //卡片名称
+	FromCardId   int32    `csv:"FromCardId"`   //来源目标
+	ToCardId     int32    `csv:"ToCardId"`     //升级目标
+	CardType     int32    `csv:"CardType"`     //卡片类型
+	CardLocation int32    `csv:"CardLocation"` //卡片部位
+	CardLevel    int32    `csv:"CardLevel"`    //卡片等级
+	Attribute1   []string `csv:"Attribute1"`   //卡片属性
+	CardPicId    int32    `csv:"CardPicId"`    //卡片图鉴ID
+	BUFF         []string `csv:"BUFF"`         //卡片BUFF
+	Pro          int32    `csv:"Pro"`          //卡组权重
+	FightPower   int32    `csv:"FightPower"`   //卡片附加战斗力
+	Profession   []string `csv:"Profession"`   //推荐职业
+	Attribute2   []string `csv:"Attribute2"`   //筛选用基础属性
+	Attribute3   int32    `csv:"Attribute3"`   //卡片相克属性
+	UpCost       int32    `csv:"UpCost"`       //卡片升级费用
 }
 }
+
 func CardCfgLoad(path string) {
 func CardCfgLoad(path string) {
 	cfg := []*CardCfg{}
 	cfg := []*CardCfg{}
 	CardCfgLoader = map[int32]*CardCfg{}
 	CardCfgLoader = map[int32]*CardCfg{}
-	loadCsvCfg(path + "CardCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"CardCfg.csv", &cfg)
+	for _, row := range cfg {
 		CardCfgLoader[row.CardId] = row
 		CardCfgLoader[row.CardId] = row
 	}
 	}
 }
 }
 
 
-var CardIdentificationLoader  map[int32]*CardIdentification
-type CardIdentification struct{
-	Cardid	int32	`csv:"Cardid"`		//卡片ID
-	CardQuality	int32	`csv:"CardQuality"`		//卡片品质
-	MaxLv	int32	`csv:"MaxLv"`		//最大等级
-	CardReward1	[]string	`csv:"CardReward1"`		//收集奖励1
-	CardReward2	[]string	`csv:"CardReward2"`		//收集奖励2
-	CardReward3	[]string	`csv:"CardReward3"`		//收集奖励3
-	CardReward4	[]string	`csv:"CardReward4"`		//收集奖励4
-	CardReward5	[]string	`csv:"CardReward5"`		//收集奖励5
+var CardIdentificationLoader map[int32]*CardIdentification
+
+type CardIdentification struct {
+	Cardid      int32    `csv:"Cardid"`      //卡片ID
+	CardQuality int32    `csv:"CardQuality"` //卡片品质
+	MaxLv       int32    `csv:"MaxLv"`       //最大等级
+	CardReward1 []string `csv:"CardReward1"` //收集奖励1
+	CardReward2 []string `csv:"CardReward2"` //收集奖励2
+	CardReward3 []string `csv:"CardReward3"` //收集奖励3
+	CardReward4 []string `csv:"CardReward4"` //收集奖励4
+	CardReward5 []string `csv:"CardReward5"` //收集奖励5
 }
 }
+
 func CardIdentificationLoad(path string) {
 func CardIdentificationLoad(path string) {
 	cfg := []*CardIdentification{}
 	cfg := []*CardIdentification{}
 	CardIdentificationLoader = map[int32]*CardIdentification{}
 	CardIdentificationLoader = map[int32]*CardIdentification{}
-	loadCsvCfg(path + "CardIdentification.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"CardIdentification.csv", &cfg)
+	for _, row := range cfg {
 		CardIdentificationLoader[row.Cardid] = row
 		CardIdentificationLoader[row.Cardid] = row
 	}
 	}
 }
 }
 
 
-var CardResetLoader  map[int32]*CardReset
-type CardReset struct{
-	Id	int32	`csv:"Id"`		//ID
-	CardType	int32	`csv:"CardType"`		//卡片类型
-	CardLv	int32	`csv:"CardLv"`		//卡片等级
-	Normal	int32	`csv:"Normal"`		//获得普通概率
-	Mini	int32	`csv:"Mini"`		//获得迷你概率
-	Boss	int32	`csv:"Boss"`		//获得BOSS概率
+var CardResetLoader map[int32]*CardReset
+
+type CardReset struct {
+	Id       int32 `csv:"Id"`       //ID
+	CardType int32 `csv:"CardType"` //卡片类型
+	CardLv   int32 `csv:"CardLv"`   //卡片等级
+	Normal   int32 `csv:"Normal"`   //获得普通概率
+	Mini     int32 `csv:"Mini"`     //获得迷你概率
+	Boss     int32 `csv:"Boss"`     //获得BOSS概率
 }
 }
+
 func CardResetLoad(path string) {
 func CardResetLoad(path string) {
 	cfg := []*CardReset{}
 	cfg := []*CardReset{}
 	CardResetLoader = map[int32]*CardReset{}
 	CardResetLoader = map[int32]*CardReset{}
-	loadCsvCfg(path + "CardReset.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"CardReset.csv", &cfg)
+	for _, row := range cfg {
 		CardResetLoader[row.Id] = row
 		CardResetLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var CardSuitNewCfgLoader  map[int32]*CardSuitNewCfg
-type CardSuitNewCfg struct{
-	Id	int32	`csv:"Id"`		//id
-	Suit1	[]string	`csv:"Suit1"`		//祝福效果
-	TriggerConditions	[]string	`csv:"TriggerConditions"`		//激活条件
+var CardSuitNewCfgLoader map[int32]*CardSuitNewCfg
+
+type CardSuitNewCfg struct {
+	Id                int32    `csv:"Id"`                //id
+	Suit1             []string `csv:"Suit1"`             //祝福效果
+	TriggerConditions []string `csv:"TriggerConditions"` //激活条件
 }
 }
+
 func CardSuitNewCfgLoad(path string) {
 func CardSuitNewCfgLoad(path string) {
 	cfg := []*CardSuitNewCfg{}
 	cfg := []*CardSuitNewCfg{}
 	CardSuitNewCfgLoader = map[int32]*CardSuitNewCfg{}
 	CardSuitNewCfgLoader = map[int32]*CardSuitNewCfg{}
-	loadCsvCfg(path + "CardSuitNewCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"CardSuitNewCfg.csv", &cfg)
+	for _, row := range cfg {
 		CardSuitNewCfgLoader[row.Id] = row
 		CardSuitNewCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var CardUnlockCfgLoader  map[int32]*CardUnlockCfg
-type CardUnlockCfg struct{
-	CardSlotID	int32	`csv:"CardSlotID"`		//卡槽ID
-	UnlockingCondition	[]string	`csv:"UnlockingCondition"`		//解锁条件
+var CardUnlockCfgLoader map[int32]*CardUnlockCfg
+
+type CardUnlockCfg struct {
+	CardSlotID         int32    `csv:"CardSlotID"`         //卡槽ID
+	UnlockingCondition []string `csv:"UnlockingCondition"` //解锁条件
 }
 }
+
 func CardUnlockCfgLoad(path string) {
 func CardUnlockCfgLoad(path string) {
 	cfg := []*CardUnlockCfg{}
 	cfg := []*CardUnlockCfg{}
 	CardUnlockCfgLoader = map[int32]*CardUnlockCfg{}
 	CardUnlockCfgLoader = map[int32]*CardUnlockCfg{}
-	loadCsvCfg(path + "CardUnlockCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"CardUnlockCfg.csv", &cfg)
+	for _, row := range cfg {
 		CardUnlockCfgLoader[row.CardSlotID] = row
 		CardUnlockCfgLoader[row.CardSlotID] = row
 	}
 	}
 }
 }
 
 
-var ClimbingTowerCfgLoader  map[int32]*ClimbingTowerCfg
-type ClimbingTowerCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	MaxFightingTime	int32	`csv:"MaxFightingTime"`		//最长战斗时间
-	RewardItems	[]string	`csv:"RewardItems"`		//关卡奖励
-	MonsterLevel	int32	`csv:"MonsterLevel"`		//怪物等级
-	SpecialReward	[]string	`csv:"SpecialReward"`		//特殊奖励
-	FightCheck	int32	`csv:"FightCheck"`		//战力校验
-	SpAddition	string	`csv:"SpAddition"`		//蓝量加成
-	PowerWeaken	string	`csv:"PowerWeaken"`		//战力削弱
-	StayTimeWeaken	string	`csv:"StayTimeWeaken"`		//停留时间削弱
-	Version	int32	`csv:"version"`		//版本
-	CardUnlock	string	`csv:"CardUnlock"`		//卡槽解锁
-	CloseDown	string	`csv:"CloseDown"`		//查封配置
+var ClimbingTowerCfgLoader map[int32]*ClimbingTowerCfg
+
+type ClimbingTowerCfg struct {
+	Id              int32    `csv:"Id"`              //唯一id
+	MaxFightingTime int32    `csv:"MaxFightingTime"` //最长战斗时间
+	RewardItems     []string `csv:"RewardItems"`     //关卡奖励
+	MonsterLevel    int32    `csv:"MonsterLevel"`    //怪物等级
+	SpecialReward   []string `csv:"SpecialReward"`   //特殊奖励
+	FightCheck      int32    `csv:"FightCheck"`      //战力校验
+	SpAddition      string   `csv:"SpAddition"`      //蓝量加成
+	PowerWeaken     string   `csv:"PowerWeaken"`     //战力削弱
+	StayTimeWeaken  string   `csv:"StayTimeWeaken"`  //停留时间削弱
+	Version         int32    `csv:"version"`         //版本
+	CardUnlock      string   `csv:"CardUnlock"`      //卡槽解锁
+	CloseDown       string   `csv:"CloseDown"`       //查封配置
 }
 }
+
 func ClimbingTowerCfgLoad(path string) {
 func ClimbingTowerCfgLoad(path string) {
 	cfg := []*ClimbingTowerCfg{}
 	cfg := []*ClimbingTowerCfg{}
 	ClimbingTowerCfgLoader = map[int32]*ClimbingTowerCfg{}
 	ClimbingTowerCfgLoader = map[int32]*ClimbingTowerCfg{}
-	loadCsvCfg(path + "ClimbingTowerCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ClimbingTowerCfg.csv", &cfg)
+	for _, row := range cfg {
 		ClimbingTowerCfgLoader[row.Id] = row
 		ClimbingTowerCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var CombinedServiceCfgLoader  map[int32]*CombinedServiceCfg
-type CombinedServiceCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	Number	[]string	`csv:"Number"`		//合服编号
-	Time	string	`csv:"Time"`		//合服时间
-	Tips	string	`csv:"Tips"`		//合服预告
+var CombinedServiceCfgLoader map[int32]*CombinedServiceCfg
+
+type CombinedServiceCfg struct {
+	Id     int32    `csv:"Id"`     //唯一id
+	Number []string `csv:"Number"` //合服编号
+	Time   string   `csv:"Time"`   //合服时间
+	Tips   string   `csv:"Tips"`   //合服预告
 }
 }
+
 func CombinedServiceCfgLoad(path string) {
 func CombinedServiceCfgLoad(path string) {
 	cfg := []*CombinedServiceCfg{}
 	cfg := []*CombinedServiceCfg{}
 	CombinedServiceCfgLoader = map[int32]*CombinedServiceCfg{}
 	CombinedServiceCfgLoader = map[int32]*CombinedServiceCfg{}
-	loadCsvCfg(path + "CombinedServiceCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"CombinedServiceCfg.csv", &cfg)
+	for _, row := range cfg {
 		CombinedServiceCfgLoader[row.Id] = row
 		CombinedServiceCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var CompetitionAidouluCfgLoader  map[int32]*CompetitionAidouluCfg
-type CompetitionAidouluCfg struct{
-	BoxId	int32	`csv:"BoxId"`		//宝箱
-	GoodNum	int32	`csv:"GoodNum"`		//需要礼包数
-	ConditionHot	int32	`csv:"ConditionHot"`		//需要热度
-	Rewards	[]string	`csv:"Rewards"`		//宝箱奖励
+var CompetitionAidouluCfgLoader map[int32]*CompetitionAidouluCfg
+
+type CompetitionAidouluCfg struct {
+	BoxId        int32    `csv:"BoxId"`        //宝箱
+	GoodNum      int32    `csv:"GoodNum"`      //需要礼包数
+	ConditionHot int32    `csv:"ConditionHot"` //需要热度
+	Rewards      []string `csv:"Rewards"`      //宝箱奖励
 }
 }
+
 func CompetitionAidouluCfgLoad(path string) {
 func CompetitionAidouluCfgLoad(path string) {
 	cfg := []*CompetitionAidouluCfg{}
 	cfg := []*CompetitionAidouluCfg{}
 	CompetitionAidouluCfgLoader = map[int32]*CompetitionAidouluCfg{}
 	CompetitionAidouluCfgLoader = map[int32]*CompetitionAidouluCfg{}
-	loadCsvCfg(path + "CompetitionAidouluCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"CompetitionAidouluCfg.csv", &cfg)
+	for _, row := range cfg {
 		CompetitionAidouluCfgLoader[row.BoxId] = row
 		CompetitionAidouluCfgLoader[row.BoxId] = row
 	}
 	}
 }
 }
 
 
-var CompetitionCfgLoader  map[int32]*CompetitionCfg
-type CompetitionCfg struct{
-	Id	int32	`csv:"Id"`		//序列ID
-	CompetitionId	int32	`csv:"CompetitionId"`		//赛季ID
-	CompetitionType	int32	`csv:"CompetitionType"`		//赛季类型
-	CompetitionCondition	[]string	`csv:"CompetitionCondition"`		//赛季条件
-	CompetitionReward1	[]string	`csv:"CompetitionReward1"`		//奖励1
-	CompetitionReward2	[]string	`csv:"CompetitionReward2"`		//奖励2
-	CompetitionReward3	[]string	`csv:"CompetitionReward3"`		//奖励3
-	CompetitionPeriod	[]string	`csv:"CompetitionPeriod"`		//赛季周期(天)
-	BeginTime	string	`csv:"BeginTime"`		//开始时间
-	EndTime	string	`csv:"EndTime"`		//结束时间
-	RestTime	int32	`csv:"RestTime"`		//赛季休赛期(天)
-	HuodongItem	[]string	`csv:"HuodongItem"`		//活动道具
-	Level	int32	`csv:"Level"`		//档位
+var CompetitionCfgLoader map[int32]*CompetitionCfg
+
+type CompetitionCfg struct {
+	Id                   int32    `csv:"Id"`                   //序列ID
+	CompetitionId        int32    `csv:"CompetitionId"`        //赛季ID
+	CompetitionType      int32    `csv:"CompetitionType"`      //赛季类型
+	CompetitionCondition []string `csv:"CompetitionCondition"` //赛季条件
+	CompetitionReward1   []string `csv:"CompetitionReward1"`   //奖励1
+	CompetitionReward2   []string `csv:"CompetitionReward2"`   //奖励2
+	CompetitionReward3   []string `csv:"CompetitionReward3"`   //奖励3
+	CompetitionPeriod    []string `csv:"CompetitionPeriod"`    //赛季周期(天)
+	BeginTime            string   `csv:"BeginTime"`            //开始时间
+	EndTime              string   `csv:"EndTime"`              //结束时间
+	RestTime             int32    `csv:"RestTime"`             //赛季休赛期(天)
+	HuodongItem          []string `csv:"HuodongItem"`          //活动道具
+	Level                int32    `csv:"Level"`                //档位
 }
 }
+
 func CompetitionCfgLoad(path string) {
 func CompetitionCfgLoad(path string) {
 	cfg := []*CompetitionCfg{}
 	cfg := []*CompetitionCfg{}
 	CompetitionCfgLoader = map[int32]*CompetitionCfg{}
 	CompetitionCfgLoader = map[int32]*CompetitionCfg{}
-	loadCsvCfg(path + "CompetitionCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"CompetitionCfg.csv", &cfg)
+	for _, row := range cfg {
 		CompetitionCfgLoader[row.Id] = row
 		CompetitionCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var CompetitionDevineCfgLoader  map[int32]*CompetitionDevineCfg
-type CompetitionDevineCfg struct{
-	ID	int32	`csv:"ID"`		//ID
-	NowLightNum	int32	`csv:"NowLightNum"`		//当前点亮数
-	Probability	int32	`csv:"Probability"`		//下次点亮概率(万分比)
-	PledgeProbability	int32	`csv:"PledgeProbability"`		//连续点暗保底概率(万分比)
-	ItemPrice	[]string	`csv:"ItemPrice"`		//下次占道具花费
-	GoldPrice	[]string	`csv:"GoldPrice"`		//下次占金币花费
-	LuckyPrice	[]string	`csv:"LuckyPrice"`		//下次幸运符花费
-	Rewards	[]string	`csv:"Rewards"`		//奖励
-	Point	[]string	`csv:"Point"`		//下次【占星】得到的积分
-	IfBroadcast	int32	`csv:"IfBroadcast"`		//领奖是否需要播报
-	BroadcastKey	string	`csv:"BroadcastKey"`		//播报key
+var CompetitionDevineCfgLoader map[int32]*CompetitionDevineCfg
+
+type CompetitionDevineCfg struct {
+	ID                int32    `csv:"ID"`                //ID
+	NowLightNum       int32    `csv:"NowLightNum"`       //当前点亮数
+	Probability       int32    `csv:"Probability"`       //下次点亮概率(万分比)
+	PledgeProbability int32    `csv:"PledgeProbability"` //连续点暗保底概率(万分比)
+	ItemPrice         []string `csv:"ItemPrice"`         //下次占道具花费
+	GoldPrice         []string `csv:"GoldPrice"`         //下次占金币花费
+	LuckyPrice        []string `csv:"LuckyPrice"`        //下次幸运符花费
+	Rewards           []string `csv:"Rewards"`           //奖励
+	Point             []string `csv:"Point"`             //下次【占星】得到的积分
+	IfBroadcast       int32    `csv:"IfBroadcast"`       //领奖是否需要播报
+	BroadcastKey      string   `csv:"BroadcastKey"`      //播报key
 }
 }
+
 func CompetitionDevineCfgLoad(path string) {
 func CompetitionDevineCfgLoad(path string) {
 	cfg := []*CompetitionDevineCfg{}
 	cfg := []*CompetitionDevineCfg{}
 	CompetitionDevineCfgLoader = map[int32]*CompetitionDevineCfg{}
 	CompetitionDevineCfgLoader = map[int32]*CompetitionDevineCfg{}
-	loadCsvCfg(path + "CompetitionDevineCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"CompetitionDevineCfg.csv", &cfg)
+	for _, row := range cfg {
 		CompetitionDevineCfgLoader[row.ID] = row
 		CompetitionDevineCfgLoader[row.ID] = row
 	}
 	}
 }
 }
 
 
-var CompetitionPrizeWheelCfgLoader  map[int32]*CompetitionPrizeWheelCfg
-type CompetitionPrizeWheelCfg struct{
-	Id	int32	`csv:"Id"`		//ID
-	LowNormalNum	[]string	`csv:"LowNormalNum"`		//低级奖
-	NormalNum	[]string	`csv:"NormalNum"`		//Normal奖
-	MiniNum	[]string	`csv:"MiniNum"`		//Mini奖
-	MvpNum	[]string	`csv:"MvpNum"`		//Mvp奖
-	ModProbability	int32	`csv:"ModProbability"`		//模板权重
-	Probability	[]string	`csv:"Probability"`		//非MVP抽奖概率
-	MvpProbability	[]string	`csv:"MvpProbability"`		//MVP抽奖概率
-	ItemPrice	int32	`csv:"ItemPrice"`		//一个道具的价格
-	RewardOneItem	[]string	`csv:"RewardOneItem"`		//抽一次价格(道具)
-	RewardOneGold	[]string	`csv:"RewardOneGold"`		//抽一次价格(金币)
-	RewardAllItem	[]string	`csv:"RewardAllItem"`		//抽全部价格(道具)
-	RewardAdllGold	int32	`csv:"RewardAdllGold"`		//抽全部价格(金币)
-	RefreshPrice	[]string	`csv:"RefreshPrice"`		//刷新价格(金币)
-	NoRewardNum	int32	`csv:"NoRewardNum"`		//结束本轮次数
-	RewardOnePoint	[]string	`csv:"RewardOnePoint"`		//抽一次送赛季积分
-	RewardAllPoint	int32	`csv:"RewardAllPoint"`		//抽全部送赛季积分
+var CompetitionPrizeWheelCfgLoader map[int32]*CompetitionPrizeWheelCfg
+
+type CompetitionPrizeWheelCfg struct {
+	Id             int32    `csv:"Id"`             //ID
+	LowNormalNum   []string `csv:"LowNormalNum"`   //低级奖
+	NormalNum      []string `csv:"NormalNum"`      //Normal奖
+	MiniNum        []string `csv:"MiniNum"`        //Mini奖
+	MvpNum         []string `csv:"MvpNum"`         //Mvp奖
+	ModProbability int32    `csv:"ModProbability"` //模板权重
+	Probability    []string `csv:"Probability"`    //非MVP抽奖概率
+	MvpProbability []string `csv:"MvpProbability"` //MVP抽奖概率
+	ItemPrice      int32    `csv:"ItemPrice"`      //一个道具的价格
+	RewardOneItem  []string `csv:"RewardOneItem"`  //抽一次价格(道具)
+	RewardOneGold  []string `csv:"RewardOneGold"`  //抽一次价格(金币)
+	RewardAllItem  []string `csv:"RewardAllItem"`  //抽全部价格(道具)
+	RewardAdllGold int32    `csv:"RewardAdllGold"` //抽全部价格(金币)
+	RefreshPrice   []string `csv:"RefreshPrice"`   //刷新价格(金币)
+	NoRewardNum    int32    `csv:"NoRewardNum"`    //结束本轮次数
+	RewardOnePoint []string `csv:"RewardOnePoint"` //抽一次送赛季积分
+	RewardAllPoint int32    `csv:"RewardAllPoint"` //抽全部送赛季积分
 }
 }
+
 func CompetitionPrizeWheelCfgLoad(path string) {
 func CompetitionPrizeWheelCfgLoad(path string) {
 	cfg := []*CompetitionPrizeWheelCfg{}
 	cfg := []*CompetitionPrizeWheelCfg{}
 	CompetitionPrizeWheelCfgLoader = map[int32]*CompetitionPrizeWheelCfg{}
 	CompetitionPrizeWheelCfgLoader = map[int32]*CompetitionPrizeWheelCfg{}
-	loadCsvCfg(path + "CompetitionPrizeWheelCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"CompetitionPrizeWheelCfg.csv", &cfg)
+	for _, row := range cfg {
 		CompetitionPrizeWheelCfgLoader[row.Id] = row
 		CompetitionPrizeWheelCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ConditionCfgLoader  map[int32]*ConditionCfg
-type ConditionCfg struct{
-	ConditionId	int32	`csv:"ConditionId"`		//条件ID
-	Condition	[]string	`csv:"Condition"`		//条件枚举
+var ConditionCfgLoader map[int32]*ConditionCfg
+
+type ConditionCfg struct {
+	ConditionId int32    `csv:"ConditionId"` //条件ID
+	Condition   []string `csv:"Condition"`   //条件枚举
 }
 }
+
 func ConditionCfgLoad(path string) {
 func ConditionCfgLoad(path string) {
 	cfg := []*ConditionCfg{}
 	cfg := []*ConditionCfg{}
 	ConditionCfgLoader = map[int32]*ConditionCfg{}
 	ConditionCfgLoader = map[int32]*ConditionCfg{}
-	loadCsvCfg(path + "ConditionCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ConditionCfg.csv", &cfg)
+	for _, row := range cfg {
 		ConditionCfgLoader[row.ConditionId] = row
 		ConditionCfgLoader[row.ConditionId] = row
 	}
 	}
 }
 }
 
 
-var DesignationCfgLoader  map[int32]*DesignationCfg
-type DesignationCfg struct{
-	ID	int32	`csv:"ID"`		//ID
-	Name	string	`csv:"Name"`		//称号名字
-	Type	int32	`csv:"Type"`		//称号类别
-	Attribute	[]string	`csv:"Attribute"`		//称号属性
-	TaskCondition	[]string	`csv:"TaskCondition"`		//任务条件枚举
-	TaskConditionItem	[]string	`csv:"TaskConditionItem"`		//消耗道具
-	Time	int32	`csv:"Time"`		//称号时限
-	DecomposeReward	int32	`csv:"DecomposeReward"`		//分解
-	RefreshDaily	int32	`csv:"RefreshDaily"`		//条件计数是否每日刷新
+var DesignationCfgLoader map[int32]*DesignationCfg
+
+type DesignationCfg struct {
+	ID                int32    `csv:"ID"`                //ID
+	Name              string   `csv:"Name"`              //称号名字
+	Type              int32    `csv:"Type"`              //称号类别
+	Attribute         []string `csv:"Attribute"`         //称号属性
+	TaskCondition     []string `csv:"TaskCondition"`     //任务条件枚举
+	TaskConditionItem []string `csv:"TaskConditionItem"` //消耗道具
+	Time              int32    `csv:"Time"`              //称号时限
+	DecomposeReward   int32    `csv:"DecomposeReward"`   //分解
+	RefreshDaily      int32    `csv:"RefreshDaily"`      //条件计数是否每日刷新
 }
 }
+
 func DesignationCfgLoad(path string) {
 func DesignationCfgLoad(path string) {
 	cfg := []*DesignationCfg{}
 	cfg := []*DesignationCfg{}
 	DesignationCfgLoader = map[int32]*DesignationCfg{}
 	DesignationCfgLoader = map[int32]*DesignationCfg{}
-	loadCsvCfg(path + "DesignationCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"DesignationCfg.csv", &cfg)
+	for _, row := range cfg {
 		DesignationCfgLoader[row.ID] = row
 		DesignationCfgLoader[row.ID] = row
 	}
 	}
 }
 }
 
 
-var DropCfgLoader  map[int32]*DropCfg
-type DropCfg struct{
-	Id	int32	`csv:"Id"`		//ID
-	Rate	int32	`csv:"Rate"`		//出现概率
-	DropType	int32	`csv:"DropType"`		//类型
-	Times	int32	`csv:"Times"`		//随机次数
-	Drop1	[]string	`csv:"Drop1"`		//掉落组1
+var DropCfgLoader map[int32]*DropCfg
+
+type DropCfg struct {
+	Id       int32    `csv:"Id"`       //ID
+	Rate     int32    `csv:"Rate"`     //出现概率
+	DropType int32    `csv:"DropType"` //类型
+	Times    int32    `csv:"Times"`    //随机次数
+	Drop1    []string `csv:"Drop1"`    //掉落组1
 }
 }
+
 func DropCfgLoad(path string) {
 func DropCfgLoad(path string) {
 	cfg := []*DropCfg{}
 	cfg := []*DropCfg{}
 	DropCfgLoader = map[int32]*DropCfg{}
 	DropCfgLoader = map[int32]*DropCfg{}
-	loadCsvCfg(path + "DropCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"DropCfg.csv", &cfg)
+	for _, row := range cfg {
 		DropCfgLoader[row.Id] = row
 		DropCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var EquipCfgLoader  map[int32]*EquipCfg
-type EquipCfg struct{
-	Id	int32	`csv:"Id"`		//id
-	Type	int32	`csv:"Type"`		//装备类型
-	EquipLevel	int32	`csv:"EquipLevel"`		//装备等级
-	JobType	[]string	`csv:"JobType"`		//职业类型
-	Forge	int32	`csv:"Forge"`		//锻造目标
-	ForgeOld	int32	`csv:"ForgeOld"`		//装备前置
-	CostMoney	int32	`csv:"CostMoney"`		//合成消耗
-	Suit	int32	`csv:"Suit"`		//套装ID
-	Attack	int32	`csv:"Attack"`		//物攻
-	MagicAttack	int32	`csv:"MagicAttack"`		//魔攻
-	Defense	int32	`csv:"Defense"`		//物防
-	MagicDefense	int32	`csv:"MagicDefense"`		//魔防
-	Life	int32	`csv:"Life"`		//生命
-	Sp	int32	`csv:"Sp"`		//蓝量
-	Crit	int32	`csv:"Crit"`		//暴击
-	Ten	int32	`csv:"Ten"`		//韧性
-	Hit	int32	`csv:"Hit"`		//命中
-	Dodge	int32	`csv:"Dodge"`		//闪避
-	PhysicalDamageBonus	int32	`csv:"PhysicalDamageBonus"`		//物伤加成
-	MagicDamageBonus	int32	`csv:"MagicDamageBonus"`		//魔伤加成
-	AtkPercent	int32	`csv:"AtkPercent"`		//ATK%
-	MatkPercent	int32	`csv:"MatkPercent"`		//MATK%
-	Str	int32	`csv:"Str"`		//力量
-	Agi	int32	`csv:"Agi"`		//敏捷
-	Int	int32	`csv:"Int"`		//智力
-	Vit	int32	`csv:"Vit"`		//体质
-	Dex	int32	`csv:"Dex"`		//灵巧
-	Luk	int32	`csv:"Luk"`		//幸运
+var EquipCfgLoader map[int32]*EquipCfg
+
+type EquipCfg struct {
+	Id                  int32    `csv:"Id"`                  //id
+	Type                int32    `csv:"Type"`                //装备类型
+	EquipLevel          int32    `csv:"EquipLevel"`          //装备等级
+	JobType             []string `csv:"JobType"`             //职业类型
+	Forge               int32    `csv:"Forge"`               //锻造目标
+	ForgeOld            int32    `csv:"ForgeOld"`            //装备前置
+	CostMoney           int32    `csv:"CostMoney"`           //合成消耗
+	Suit                int32    `csv:"Suit"`                //套装ID
+	Attack              int32    `csv:"Attack"`              //物攻
+	MagicAttack         int32    `csv:"MagicAttack"`         //魔攻
+	Defense             int32    `csv:"Defense"`             //物防
+	MagicDefense        int32    `csv:"MagicDefense"`        //魔防
+	Life                int32    `csv:"Life"`                //生命
+	Sp                  int32    `csv:"Sp"`                  //蓝量
+	Crit                int32    `csv:"Crit"`                //暴击
+	Ten                 int32    `csv:"Ten"`                 //韧性
+	Hit                 int32    `csv:"Hit"`                 //命中
+	Dodge               int32    `csv:"Dodge"`               //闪避
+	PhysicalDamageBonus int32    `csv:"PhysicalDamageBonus"` //物伤加成
+	MagicDamageBonus    int32    `csv:"MagicDamageBonus"`    //魔伤加成
+	AtkPercent          int32    `csv:"AtkPercent"`          //ATK%
+	MatkPercent         int32    `csv:"MatkPercent"`         //MATK%
+	Str                 int32    `csv:"Str"`                 //力量
+	Agi                 int32    `csv:"Agi"`                 //敏捷
+	Int                 int32    `csv:"Int"`                 //智力
+	Vit                 int32    `csv:"Vit"`                 //体质
+	Dex                 int32    `csv:"Dex"`                 //灵巧
+	Luk                 int32    `csv:"Luk"`                 //幸运
 }
 }
+
 func EquipCfgLoad(path string) {
 func EquipCfgLoad(path string) {
 	cfg := []*EquipCfg{}
 	cfg := []*EquipCfg{}
 	EquipCfgLoader = map[int32]*EquipCfg{}
 	EquipCfgLoader = map[int32]*EquipCfg{}
-	loadCsvCfg(path + "EquipCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"EquipCfg.csv", &cfg)
+	for _, row := range cfg {
 		EquipCfgLoader[row.Id] = row
 		EquipCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var EquipRefineCfgLoader  map[int32]*EquipRefineCfg
-type EquipRefineCfg struct{
-	Id	int32	`csv:"Id"`		//id
-	Place1	[]string	`csv:"Place1"`		//部位1
-	Costzeny1	int32	`csv:"Costzeny1"`		//消耗银币1
-	Costitem1	[]string	`csv:"Costitem1"`		//消耗道具1
-	Place2	[]string	`csv:"Place2"`		//部位2
-	Costzeny2	int32	`csv:"Costzeny2"`		//消耗银币2
-	Costitem2	[]string	`csv:"Costitem2"`		//消耗道具2
-	Rate	int32	`csv:"rate"`		//成功概率
-	Result	int32	`csv:"Result"`		//精炼效果
-	Suit	[]string	`csv:"Suit"`		//全身加
-	SuitServer	[]string	`csv:"SuitServer"`		//全身加
+var EquipRefineCfgLoader map[int32]*EquipRefineCfg
+
+type EquipRefineCfg struct {
+	Id         int32    `csv:"Id"`         //id
+	Place1     []string `csv:"Place1"`     //部位1
+	Costzeny1  int32    `csv:"Costzeny1"`  //消耗银币1
+	Costitem1  []string `csv:"Costitem1"`  //消耗道具1
+	Place2     []string `csv:"Place2"`     //部位2
+	Costzeny2  int32    `csv:"Costzeny2"`  //消耗银币2
+	Costitem2  []string `csv:"Costitem2"`  //消耗道具2
+	Rate       int32    `csv:"rate"`       //成功概率
+	Result     int32    `csv:"Result"`     //精炼效果
+	Suit       []string `csv:"Suit"`       //全身加
+	SuitServer []string `csv:"SuitServer"` //全身加
 }
 }
+
 func EquipRefineCfgLoad(path string) {
 func EquipRefineCfgLoad(path string) {
 	cfg := []*EquipRefineCfg{}
 	cfg := []*EquipRefineCfg{}
 	EquipRefineCfgLoader = map[int32]*EquipRefineCfg{}
 	EquipRefineCfgLoader = map[int32]*EquipRefineCfg{}
-	loadCsvCfg(path + "EquipRefineCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"EquipRefineCfg.csv", &cfg)
+	for _, row := range cfg {
 		EquipRefineCfgLoader[row.Id] = row
 		EquipRefineCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var EquipSuitNewCfgLoader  map[int32]*EquipSuitNewCfg
-type EquipSuitNewCfg struct{
-	Id	int32	`csv:"Id"`		//id
-	Name	string	`csv:"Name"`		//名称
-	Suit1	[]string	`csv:"Suit1"`		//2件属性
-	Suit2	[]string	`csv:"Suit2"`		//4件属性
-	Suit3	[]string	`csv:"Suit3"`		//6件属性
+var EquipSuitNewCfgLoader map[int32]*EquipSuitNewCfg
+
+type EquipSuitNewCfg struct {
+	Id    int32    `csv:"Id"`    //id
+	Name  string   `csv:"Name"`  //名称
+	Suit1 []string `csv:"Suit1"` //2件属性
+	Suit2 []string `csv:"Suit2"` //4件属性
+	Suit3 []string `csv:"Suit3"` //6件属性
 }
 }
+
 func EquipSuitNewCfgLoad(path string) {
 func EquipSuitNewCfgLoad(path string) {
 	cfg := []*EquipSuitNewCfg{}
 	cfg := []*EquipSuitNewCfg{}
 	EquipSuitNewCfgLoader = map[int32]*EquipSuitNewCfg{}
 	EquipSuitNewCfgLoader = map[int32]*EquipSuitNewCfg{}
-	loadCsvCfg(path + "EquipSuitNewCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"EquipSuitNewCfg.csv", &cfg)
+	for _, row := range cfg {
 		EquipSuitNewCfgLoader[row.Id] = row
 		EquipSuitNewCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var EvilCfgLoader  map[int32]*EvilCfg
-type EvilCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	MonsterList	[]string	`csv:"MonsterList"`		//召唤怪物
-	LevelReward	[]string	`csv:"LevelReward"`		//升级奖励
-	LevelTimes	int32	`csv:"LevelTimes"`		//升级次数
-	MaxFightingTime	int32	`csv:"MaxFightingTime"`		//最长战斗时间
+var EvilCfgLoader map[int32]*EvilCfg
+
+type EvilCfg struct {
+	Id              int32    `csv:"Id"`              //唯一id
+	MonsterList     []string `csv:"MonsterList"`     //召唤怪物
+	LevelReward     []string `csv:"LevelReward"`     //升级奖励
+	LevelTimes      int32    `csv:"LevelTimes"`      //升级次数
+	MaxFightingTime int32    `csv:"MaxFightingTime"` //最长战斗时间
 }
 }
+
 func EvilCfgLoad(path string) {
 func EvilCfgLoad(path string) {
 	cfg := []*EvilCfg{}
 	cfg := []*EvilCfg{}
 	EvilCfgLoader = map[int32]*EvilCfg{}
 	EvilCfgLoader = map[int32]*EvilCfg{}
-	loadCsvCfg(path + "EvilCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"EvilCfg.csv", &cfg)
+	for _, row := range cfg {
 		EvilCfgLoader[row.Id] = row
 		EvilCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ExpeditionBuffCfgLoader  map[int32]*ExpeditionBuffCfg
-type ExpeditionBuffCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	BuffId	int32	`csv:"BuffId"`		//buffid
-	WarriorScore	int32	`csv:"WarriorScore"`		//勇士积分
+var ExpeditionBuffCfgLoader map[int32]*ExpeditionBuffCfg
+
+type ExpeditionBuffCfg struct {
+	Id           int32 `csv:"Id"`           //唯一id
+	BuffId       int32 `csv:"BuffId"`       //buffid
+	WarriorScore int32 `csv:"WarriorScore"` //勇士积分
 }
 }
+
 func ExpeditionBuffCfgLoad(path string) {
 func ExpeditionBuffCfgLoad(path string) {
 	cfg := []*ExpeditionBuffCfg{}
 	cfg := []*ExpeditionBuffCfg{}
 	ExpeditionBuffCfgLoader = map[int32]*ExpeditionBuffCfg{}
 	ExpeditionBuffCfgLoader = map[int32]*ExpeditionBuffCfg{}
-	loadCsvCfg(path + "ExpeditionBuffCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ExpeditionBuffCfg.csv", &cfg)
+	for _, row := range cfg {
 		ExpeditionBuffCfgLoader[row.Id] = row
 		ExpeditionBuffCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ExpeditionBuffDropCfgLoader  map[int32]*ExpeditionBuffDropCfg
-type ExpeditionBuffDropCfg struct{
-	Id	int32	`csv:"Id"`		//索引
-	BossID	int32	`csv:"BossID"`		//BossID
-	Buffs	[]string	`csv:"Buffs"`		//掉落Buff列表
-	LevelId	int32	`csv:"LevelId"`		//关卡Id
-	WarriorScore	int32	`csv:"WarriorScore"`		//勇士积分
+var ExpeditionBuffDropCfgLoader map[int32]*ExpeditionBuffDropCfg
+
+type ExpeditionBuffDropCfg struct {
+	Id           int32    `csv:"Id"`           //索引
+	BossID       int32    `csv:"BossID"`       //BossID
+	Buffs        []string `csv:"Buffs"`        //掉落Buff列表
+	LevelId      int32    `csv:"LevelId"`      //关卡Id
+	WarriorScore int32    `csv:"WarriorScore"` //勇士积分
 }
 }
+
 func ExpeditionBuffDropCfgLoad(path string) {
 func ExpeditionBuffDropCfgLoad(path string) {
 	cfg := []*ExpeditionBuffDropCfg{}
 	cfg := []*ExpeditionBuffDropCfg{}
 	ExpeditionBuffDropCfgLoader = map[int32]*ExpeditionBuffDropCfg{}
 	ExpeditionBuffDropCfgLoader = map[int32]*ExpeditionBuffDropCfg{}
-	loadCsvCfg(path + "ExpeditionBuffDropCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ExpeditionBuffDropCfg.csv", &cfg)
+	for _, row := range cfg {
 		ExpeditionBuffDropCfgLoader[row.Id] = row
 		ExpeditionBuffDropCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ExpeditionCfgLoader  map[int32]*ExpeditionCfg
-type ExpeditionCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	Type	int32	`csv:"Type"`		//副本难度
-	LevelId	int32	`csv:"LevelId"`		//副本关
-	LevelNum	int32	`csv:"LevelNum"`		//关卡数量
-	BossList	[]string	`csv:"BossList"`		//召唤boss
-	Reward	[]string	`csv:"Reward"`		//奖励
-	MaxFightingTime	int32	`csv:"MaxFightingTime"`		//最长战斗时间
-	HighReward	int32	`csv:"HighReward"`		//是否为高级奖励
-	ChallengeNum	int32	`csv:"ChallengeNum"`		//赠送挑战次数
-	UnlockDesc	string	`csv:"UnlockDesc"`		//开启条件
-	WarriorScore	int32	`csv:"WarriorScore"`		//勇士积分
-	LevelCoefficient	int32	`csv:"LevelCoefficient"`		//加成积分系数
-	DayReward	[]string	`csv:"DayReward"`		//每日通关奖励
+var ExpeditionCfgLoader map[int32]*ExpeditionCfg
+
+type ExpeditionCfg struct {
+	Id               int32    `csv:"Id"`               //唯一id
+	Type             int32    `csv:"Type"`             //副本难度
+	LevelId          int32    `csv:"LevelId"`          //副本关
+	LevelNum         int32    `csv:"LevelNum"`         //关卡数量
+	BossList         []string `csv:"BossList"`         //召唤boss
+	Reward           []string `csv:"Reward"`           //奖励
+	MaxFightingTime  int32    `csv:"MaxFightingTime"`  //最长战斗时间
+	HighReward       int32    `csv:"HighReward"`       //是否为高级奖励
+	ChallengeNum     int32    `csv:"ChallengeNum"`     //赠送挑战次数
+	UnlockDesc       string   `csv:"UnlockDesc"`       //开启条件
+	WarriorScore     int32    `csv:"WarriorScore"`     //勇士积分
+	LevelCoefficient int32    `csv:"LevelCoefficient"` //加成积分系数
+	DayReward        []string `csv:"DayReward"`        //每日通关奖励
 }
 }
+
 func ExpeditionCfgLoad(path string) {
 func ExpeditionCfgLoad(path string) {
 	cfg := []*ExpeditionCfg{}
 	cfg := []*ExpeditionCfg{}
 	ExpeditionCfgLoader = map[int32]*ExpeditionCfg{}
 	ExpeditionCfgLoader = map[int32]*ExpeditionCfg{}
-	loadCsvCfg(path + "ExpeditionCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ExpeditionCfg.csv", &cfg)
+	for _, row := range cfg {
 		ExpeditionCfgLoader[row.Id] = row
 		ExpeditionCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var FashionCfgLoader  map[int32]*FashionCfg
-type FashionCfg struct{
-	FashionId	int32	`csv:"FashionId"`		//时装id
-	FashionLocation	int32	`csv:"FashionLocation"`		//时装部位类型
-	FashionHideHair	bool	`csv:"FashionHideHair"`		//是否隐藏发型
-	FashionSex	int32	`csv:"FashionSex"`		//时装性别限制
-	FashionUseJob	[]string	`csv:"FashionUseJob"`		//时装职业限制
-	FashionOpen	bool	`csv:"FashionOpen"`		//是否开放使用
-	FashionQuality	int32	`csv:"FashionQuality"`		//时装品质
-	AttrNum	int32	`csv:"AttrNum"`		//属性数量
-	SuitId	[]string	`csv:"SuitId"`		//时装套装
+var FashionCfgLoader map[int32]*FashionCfg
+
+type FashionCfg struct {
+	FashionId       int32    `csv:"FashionId"`       //时装id
+	FashionLocation int32    `csv:"FashionLocation"` //时装部位类型
+	FashionHideHair bool     `csv:"FashionHideHair"` //是否隐藏发型
+	FashionSex      int32    `csv:"FashionSex"`      //时装性别限制
+	FashionUseJob   []string `csv:"FashionUseJob"`   //时装职业限制
+	FashionOpen     bool     `csv:"FashionOpen"`     //是否开放使用
+	FashionQuality  int32    `csv:"FashionQuality"`  //时装品质
+	AttrNum         int32    `csv:"AttrNum"`         //属性数量
+	SuitId          []string `csv:"SuitId"`          //时装套装
 }
 }
+
 func FashionCfgLoad(path string) {
 func FashionCfgLoad(path string) {
 	cfg := []*FashionCfg{}
 	cfg := []*FashionCfg{}
 	FashionCfgLoader = map[int32]*FashionCfg{}
 	FashionCfgLoader = map[int32]*FashionCfg{}
-	loadCsvCfg(path + "FashionCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"FashionCfg.csv", &cfg)
+	for _, row := range cfg {
 		FashionCfgLoader[row.FashionId] = row
 		FashionCfgLoader[row.FashionId] = row
 	}
 	}
 }
 }
 
 
-var FashionLevelUpLoader  map[int32]*FashionLevelUp
-type FashionLevelUp struct{
-	Level	int32	`csv:"Level"`		//等级
-	UpMaterial1	[]string	`csv:"UpMaterial1"`		//绿色升级消耗
-	UpMaterial2	[]string	`csv:"UpMaterial2"`		//蓝色升级消耗
-	UpMaterial3	[]string	`csv:"UpMaterial3"`		//紫色升级消耗
-	UpMaterial4	[]string	`csv:"UpMaterial4"`		//金色升级消耗
-	UpMaterial5	[]string	`csv:"UpMaterial5"`		//红色升级消耗
-	UpAttribute	int32	`csv:"UpAttribute"`		//每级属性
+var FashionLevelUpLoader map[int32]*FashionLevelUp
+
+type FashionLevelUp struct {
+	Level       int32    `csv:"Level"`       //等级
+	UpMaterial1 []string `csv:"UpMaterial1"` //绿色升级消耗
+	UpMaterial2 []string `csv:"UpMaterial2"` //蓝色升级消耗
+	UpMaterial3 []string `csv:"UpMaterial3"` //紫色升级消耗
+	UpMaterial4 []string `csv:"UpMaterial4"` //金色升级消耗
+	UpMaterial5 []string `csv:"UpMaterial5"` //红色升级消耗
+	UpAttribute int32    `csv:"UpAttribute"` //每级属性
 }
 }
+
 func FashionLevelUpLoad(path string) {
 func FashionLevelUpLoad(path string) {
 	cfg := []*FashionLevelUp{}
 	cfg := []*FashionLevelUp{}
 	FashionLevelUpLoader = map[int32]*FashionLevelUp{}
 	FashionLevelUpLoader = map[int32]*FashionLevelUp{}
-	loadCsvCfg(path + "FashionLevelUp.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"FashionLevelUp.csv", &cfg)
+	for _, row := range cfg {
 		FashionLevelUpLoader[row.Level] = row
 		FashionLevelUpLoader[row.Level] = row
 	}
 	}
 }
 }
 
 
-var FashionPaperCfgLoader  map[int32]*FashionPaperCfg
-type FashionPaperCfg struct{
-	PaperId	int32	`csv:"PaperId"`		//图纸ID
-	MakeMaterial	[]string	`csv:"MakeMaterial"`		//图纸制作材料
-	FashionId	int32	`csv:"FashionId"`		//时装ID
-	ResolveItem	[]string	`csv:"ResolveItem"`		//分解获得
+var FashionPaperCfgLoader map[int32]*FashionPaperCfg
+
+type FashionPaperCfg struct {
+	PaperId      int32    `csv:"PaperId"`      //图纸ID
+	MakeMaterial []string `csv:"MakeMaterial"` //图纸制作材料
+	FashionId    int32    `csv:"FashionId"`    //时装ID
+	ResolveItem  []string `csv:"ResolveItem"`  //分解获得
 }
 }
+
 func FashionPaperCfgLoad(path string) {
 func FashionPaperCfgLoad(path string) {
 	cfg := []*FashionPaperCfg{}
 	cfg := []*FashionPaperCfg{}
 	FashionPaperCfgLoader = map[int32]*FashionPaperCfg{}
 	FashionPaperCfgLoader = map[int32]*FashionPaperCfg{}
-	loadCsvCfg(path + "FashionPaperCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"FashionPaperCfg.csv", &cfg)
+	for _, row := range cfg {
 		FashionPaperCfgLoader[row.PaperId] = row
 		FashionPaperCfgLoader[row.PaperId] = row
 	}
 	}
 }
 }
 
 
-var FashionRandomLoader  map[int32]*FashionRandom
-type FashionRandom struct{
-	ID	int32	`csv:"ID"`		//ID
-	RoleId	int32	`csv:"RoleId"`		//目标角色类型
-	AtrId	[]string	`csv:"AtrId"`		//属性类型
+var FashionRandomLoader map[int32]*FashionRandom
+
+type FashionRandom struct {
+	ID     int32    `csv:"ID"`     //ID
+	RoleId int32    `csv:"RoleId"` //目标角色类型
+	AtrId  []string `csv:"AtrId"`  //属性类型
 }
 }
+
 func FashionRandomLoad(path string) {
 func FashionRandomLoad(path string) {
 	cfg := []*FashionRandom{}
 	cfg := []*FashionRandom{}
 	FashionRandomLoader = map[int32]*FashionRandom{}
 	FashionRandomLoader = map[int32]*FashionRandom{}
-	loadCsvCfg(path + "FashionRandom.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"FashionRandom.csv", &cfg)
+	for _, row := range cfg {
 		FashionRandomLoader[row.ID] = row
 		FashionRandomLoader[row.ID] = row
 	}
 	}
 }
 }
 
 
-var FashionSuitCfgLoader  map[int32]*FashionSuitCfg
-type FashionSuitCfg struct{
-	SuitId	int32	`csv:"SuitId"`		//套装id
-	SuitName	string	`csv:"SuitName"`		//套装标签名字
-	SuitSex	int32	`csv:"SuitSex"`		//套装性别
-	FashionId	[]string	`csv:"FashionId"`		//套装内时装
-	LevelCondition	[]string	`csv:"LevelCondition"`		//套装等级条件
-	Attribute	[]string	`csv:"Attribute"`		//每级属性
+var FashionSuitCfgLoader map[int32]*FashionSuitCfg
+
+type FashionSuitCfg struct {
+	SuitId         int32    `csv:"SuitId"`         //套装id
+	SuitName       string   `csv:"SuitName"`       //套装标签名字
+	SuitSex        int32    `csv:"SuitSex"`        //套装性别
+	FashionId      []string `csv:"FashionId"`      //套装内时装
+	LevelCondition []string `csv:"LevelCondition"` //套装等级条件
+	Attribute      []string `csv:"Attribute"`      //每级属性
 }
 }
+
 func FashionSuitCfgLoad(path string) {
 func FashionSuitCfgLoad(path string) {
 	cfg := []*FashionSuitCfg{}
 	cfg := []*FashionSuitCfg{}
 	FashionSuitCfgLoader = map[int32]*FashionSuitCfg{}
 	FashionSuitCfgLoader = map[int32]*FashionSuitCfg{}
-	loadCsvCfg(path + "FashionSuitCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"FashionSuitCfg.csv", &cfg)
+	for _, row := range cfg {
 		FashionSuitCfgLoader[row.SuitId] = row
 		FashionSuitCfgLoader[row.SuitId] = row
 	}
 	}
 }
 }
 
 
-var FightCfgLoader  map[int32]*FightCfg
-type FightCfg struct{
-	Id	int32	`csv:"Id"`		//属性ID
-	Coefficient	[]string	`csv:"Coefficient"`		//系数
-	Mapping	int32	`csv:"Mapping"`		//映射关系
+var FightCfgLoader map[int32]*FightCfg
+
+type FightCfg struct {
+	Id          int32    `csv:"Id"`          //属性ID
+	Coefficient []string `csv:"Coefficient"` //系数
+	Mapping     int32    `csv:"Mapping"`     //映射关系
 }
 }
+
 func FightCfgLoad(path string) {
 func FightCfgLoad(path string) {
 	cfg := []*FightCfg{}
 	cfg := []*FightCfg{}
 	FightCfgLoader = map[int32]*FightCfg{}
 	FightCfgLoader = map[int32]*FightCfg{}
-	loadCsvCfg(path + "FightCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"FightCfg.csv", &cfg)
+	for _, row := range cfg {
 		FightCfgLoader[row.Id] = row
 		FightCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var FunctionCfgLoader  map[int32]*FunctionCfg
-type FunctionCfg struct{
-	Id	int32	`csv:"Id"`		//状态id
-	FunctionType	int32	`csv:"FunctionType"`		//状态类型
-	Group	int32	`csv:"Group"`		//状态组
-	BuffType	int32	`csv:"BuffType"`		//buff类型
-	HurtStop	int32	`csv:"HurtStop"`		//伤害打断
-	ForbidMove	int32	`csv:"ForbidMove"`		//禁止移动
-	ForbidAttack	int32	`csv:"ForbidAttack"`		//禁止普攻
-	ForbidSkill	int32	`csv:"ForbidSkill"`		//禁止技能
-	Dodge	int32	`csv:"Dodge"`		//闪避
-	Effect	int32	`csv:"Effect"`		//状态特效
-	EndEffect	int32	`csv:"EndEffect"`		//状态特效
+var FunctionCfgLoader map[int32]*FunctionCfg
+
+type FunctionCfg struct {
+	Id           int32 `csv:"Id"`           //状态id
+	FunctionType int32 `csv:"FunctionType"` //状态类型
+	Group        int32 `csv:"Group"`        //状态组
+	BuffType     int32 `csv:"BuffType"`     //buff类型
+	HurtStop     int32 `csv:"HurtStop"`     //伤害打断
+	ForbidMove   int32 `csv:"ForbidMove"`   //禁止移动
+	ForbidAttack int32 `csv:"ForbidAttack"` //禁止普攻
+	ForbidSkill  int32 `csv:"ForbidSkill"`  //禁止技能
+	Dodge        int32 `csv:"Dodge"`        //闪避
+	Effect       int32 `csv:"Effect"`       //状态特效
+	EndEffect    int32 `csv:"EndEffect"`    //状态特效
 }
 }
+
 func FunctionCfgLoad(path string) {
 func FunctionCfgLoad(path string) {
 	cfg := []*FunctionCfg{}
 	cfg := []*FunctionCfg{}
 	FunctionCfgLoader = map[int32]*FunctionCfg{}
 	FunctionCfgLoader = map[int32]*FunctionCfg{}
-	loadCsvCfg(path + "FunctionCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"FunctionCfg.csv", &cfg)
+	for _, row := range cfg {
 		FunctionCfgLoader[row.Id] = row
 		FunctionCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var GlobalCfgLoader  map[int32]*GlobalCfg
-type GlobalCfg struct{
-	Id	int32	`csv:"Id"`		//全局配置id
-	IVal	int32	`csv:"IVal"`		//int类型数据
-	SVal	string	`csv:"SVal"`		//字符串类型数据
-	FVal	float32	`csv:"FVal"`		//浮点数据类型
+var GlobalCfgLoader map[int32]*GlobalCfg
+
+type GlobalCfg struct {
+	Id   int32   `csv:"Id"`   //全局配置id
+	IVal int32   `csv:"IVal"` //int类型数据
+	SVal string  `csv:"SVal"` //字符串类型数据
+	FVal float32 `csv:"FVal"` //浮点数据类型
 }
 }
+
 func GlobalCfgLoad(path string) {
 func GlobalCfgLoad(path string) {
 	cfg := []*GlobalCfg{}
 	cfg := []*GlobalCfg{}
 	GlobalCfgLoader = map[int32]*GlobalCfg{}
 	GlobalCfgLoader = map[int32]*GlobalCfg{}
-	loadCsvCfg(path + "GlobalCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"GlobalCfg.csv", &cfg)
+	for _, row := range cfg {
 		GlobalCfgLoader[row.Id] = row
 		GlobalCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var GuildBadgeCfgLoader  map[int32]*GuildBadgeCfg
-type GuildBadgeCfg struct{
-	Id	int32	`csv:"Id"`		//ID
+var GuildBadgeCfgLoader map[int32]*GuildBadgeCfg
+
+type GuildBadgeCfg struct {
+	Id int32 `csv:"Id"` //ID
 }
 }
+
 func GuildBadgeCfgLoad(path string) {
 func GuildBadgeCfgLoad(path string) {
 	cfg := []*GuildBadgeCfg{}
 	cfg := []*GuildBadgeCfg{}
 	GuildBadgeCfgLoader = map[int32]*GuildBadgeCfg{}
 	GuildBadgeCfgLoader = map[int32]*GuildBadgeCfg{}
-	loadCsvCfg(path + "GuildBadgeCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"GuildBadgeCfg.csv", &cfg)
+	for _, row := range cfg {
 		GuildBadgeCfgLoader[row.Id] = row
 		GuildBadgeCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var GuildBossCfgLoader  map[int32]*GuildBossCfg
-type GuildBossCfg struct{
-	Id	int32	`csv:"Id"`		//全局配置id
-	BossType	int32	`csv:"BossType"`		//BOSS类型
-	Challenge	int32	`csv:"Challenge"`		//挑战次数
-	SummonId	int32	`csv:"SummonId"`		//召唤物id
-	SummonLimit	[]string	`csv:"SummonLimit"`		//开启权限
-	SummonTime	int32	`csv:"SummonTime"`		//BOSS开启时间
-	LifeTime	int32	`csv:"LifeTime"`		//boss存活时间
-	SettlementCd	int32	`csv:"SettlementCd"`		//BOSS结算CD
-	UnlockCond	int32	`csv:"UnlockCond"`		//解锁条件
-	Consume	int32	`csv:"Consume"`		//开启消耗
-	BattleTime	int32	`csv:"BattleTime"`		//挑战时间
-	DamageSegment	int32	`csv:"DamageSegment"`		//伤害档位
-	RewardRange	[]string	`csv:"RewardRange"`		//奖励区间
-	ReviewAwards	[]string	`csv:"ReviewAwards"`		//挑战后的可获得奖励预览
-	Reward	[]string	`csv:"Reward"`		//单局档位结算奖励
-	MasterReward	[]string	`csv:"MasterReward"`		//大师馈赠奖励
-	EndBattleDamage	int32	`csv:"EndBattleDamage"`		//战斗终止伤害量
+var GuildBossCfgLoader map[int32]*GuildBossCfg
+
+type GuildBossCfg struct {
+	Id              int32    `csv:"Id"`              //全局配置id
+	BossType        int32    `csv:"BossType"`        //BOSS类型
+	Challenge       int32    `csv:"Challenge"`       //挑战次数
+	SummonId        int32    `csv:"SummonId"`        //召唤物id
+	SummonLimit     []string `csv:"SummonLimit"`     //开启权限
+	SummonTime      int32    `csv:"SummonTime"`      //BOSS开启时间
+	LifeTime        int32    `csv:"LifeTime"`        //boss存活时间
+	SettlementCd    int32    `csv:"SettlementCd"`    //BOSS结算CD
+	UnlockCond      int32    `csv:"UnlockCond"`      //解锁条件
+	Consume         int32    `csv:"Consume"`         //开启消耗
+	BattleTime      int32    `csv:"BattleTime"`      //挑战时间
+	DamageSegment   int32    `csv:"DamageSegment"`   //伤害档位
+	RewardRange     []string `csv:"RewardRange"`     //奖励区间
+	ReviewAwards    []string `csv:"ReviewAwards"`    //挑战后的可获得奖励预览
+	Reward          []string `csv:"Reward"`          //单局档位结算奖励
+	MasterReward    []string `csv:"MasterReward"`    //大师馈赠奖励
+	EndBattleDamage int32    `csv:"EndBattleDamage"` //战斗终止伤害量
 }
 }
+
 func GuildBossCfgLoad(path string) {
 func GuildBossCfgLoad(path string) {
 	cfg := []*GuildBossCfg{}
 	cfg := []*GuildBossCfg{}
 	GuildBossCfgLoader = map[int32]*GuildBossCfg{}
 	GuildBossCfgLoader = map[int32]*GuildBossCfg{}
-	loadCsvCfg(path + "GuildBossCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"GuildBossCfg.csv", &cfg)
+	for _, row := range cfg {
 		GuildBossCfgLoader[row.Id] = row
 		GuildBossCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var GuildBossRewardCfgLoader  map[int32]*GuildBossRewardCfg
-type GuildBossRewardCfg struct{
-	Id	int32	`csv:"Id"`		//ID
-	Reward	[]string	`csv:"Reward"`		//结算奖励
-	Note	string	`csv:"Note"`		//备注
+var GuildBossRewardCfgLoader map[int32]*GuildBossRewardCfg
+
+type GuildBossRewardCfg struct {
+	Id     int32    `csv:"Id"`     //ID
+	Reward []string `csv:"Reward"` //结算奖励
+	Note   string   `csv:"Note"`   //备注
 }
 }
+
 func GuildBossRewardCfgLoad(path string) {
 func GuildBossRewardCfgLoad(path string) {
 	cfg := []*GuildBossRewardCfg{}
 	cfg := []*GuildBossRewardCfg{}
 	GuildBossRewardCfgLoader = map[int32]*GuildBossRewardCfg{}
 	GuildBossRewardCfgLoader = map[int32]*GuildBossRewardCfg{}
-	loadCsvCfg(path + "GuildBossRewardCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"GuildBossRewardCfg.csv", &cfg)
+	for _, row := range cfg {
 		GuildBossRewardCfgLoader[row.Id] = row
 		GuildBossRewardCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var GuildDemonCfgLoader  map[int32]*GuildDemonCfg
-type GuildDemonCfg struct{
-	Id	int32	`csv:"Id"`		//全局配置id
-	BossLvCycle	[]string	`csv:"BossLvCycle"`		//开服天数
-	WeekDay	int32	`csv:"WeekDay"`		//星期几的BOSS
-	BossLevel	int32	`csv:"BossLevel"`		//Boss等级
-	BossLvMax	int32	`csv:"BossLvMax"`		//BOSS等级达到上限
-	FreeChallenge	int32	`csv:"FreeChallenge"`		//免费挑战次数
-	ChallengeTimes	int32	`csv:"ChallengeTimes"`		//挑战次数购买上限
-	ChallengeReward	[]string	`csv:"ChallengeReward"`		//单局结算奖励
-	ChallengePrice	[]string	`csv:"ChallengePrice"`		//挑战次数购买价格
-	SummonId	int32	`csv:"SummonId"`		//召唤物id
-	SummonTime	string	`csv:"SummonTime"`		//BOSS开启时间
-	LifeTime	int32	`csv:"LifeTime"`		//boss存活时间
-	SettlementCd	int32	`csv:"SettlementCd"`		//BOSS结算CD
-	BattleTime	int32	`csv:"BattleTime"`		//挑战时间
-	DamageSegment	string	`csv:"DamageSegment"`		//评分档位所需伤害量
-	DamageReward	[]string	`csv:"DamageReward"`		//宝箱奖励
-	DamageCheck	string	`csv:"DamageCheck"`		//整场伤害上限校验
+var GuildDemonCfgLoader map[int32]*GuildDemonCfg
+
+type GuildDemonCfg struct {
+	Id              int32    `csv:"Id"`              //全局配置id
+	BossLvCycle     []string `csv:"BossLvCycle"`     //开服天数
+	WeekDay         int32    `csv:"WeekDay"`         //星期几的BOSS
+	BossLevel       int32    `csv:"BossLevel"`       //Boss等级
+	BossLvMax       int32    `csv:"BossLvMax"`       //BOSS等级达到上限
+	FreeChallenge   int32    `csv:"FreeChallenge"`   //免费挑战次数
+	ChallengeTimes  int32    `csv:"ChallengeTimes"`  //挑战次数购买上限
+	ChallengeReward []string `csv:"ChallengeReward"` //单局结算奖励
+	ChallengePrice  []string `csv:"ChallengePrice"`  //挑战次数购买价格
+	SummonId        int32    `csv:"SummonId"`        //召唤物id
+	SummonTime      string   `csv:"SummonTime"`      //BOSS开启时间
+	LifeTime        int32    `csv:"LifeTime"`        //boss存活时间
+	SettlementCd    int32    `csv:"SettlementCd"`    //BOSS结算CD
+	BattleTime      int32    `csv:"BattleTime"`      //挑战时间
+	DamageSegment   string   `csv:"DamageSegment"`   //评分档位所需伤害量
+	DamageReward    []string `csv:"DamageReward"`    //宝箱奖励
+	DamageCheck     string   `csv:"DamageCheck"`     //整场伤害上限校验
 }
 }
+
 func GuildDemonCfgLoad(path string) {
 func GuildDemonCfgLoad(path string) {
 	cfg := []*GuildDemonCfg{}
 	cfg := []*GuildDemonCfg{}
 	GuildDemonCfgLoader = map[int32]*GuildDemonCfg{}
 	GuildDemonCfgLoader = map[int32]*GuildDemonCfg{}
-	loadCsvCfg(path + "GuildDemonCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"GuildDemonCfg.csv", &cfg)
+	for _, row := range cfg {
 		GuildDemonCfgLoader[row.Id] = row
 		GuildDemonCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var GuildLvCfgLoader  map[int32]*GuildLvCfg
-type GuildLvCfg struct{
-	Id	int32	`csv:"Id"`		//ID
-	ExpRequire	int32	`csv:"ExpRequire"`		//需求经验
-	PeopleLimit	int32	`csv:"PeopleLimit"`		//人数上限
-	ActiveLimit	int32	`csv:"ActiveLimit"`		//公会活跃值上限
-	PeopleAdd	int32	`csv:"PeopleAdd"`		//公会升级成员上限增量
-	ActiveAdd	int32	`csv:"ActiveAdd"`		//公会升级活跃上限增量
+var GuildLvCfgLoader map[int32]*GuildLvCfg
+
+type GuildLvCfg struct {
+	Id          int32 `csv:"Id"`          //ID
+	ExpRequire  int32 `csv:"ExpRequire"`  //需求经验
+	PeopleLimit int32 `csv:"PeopleLimit"` //人数上限
+	ActiveLimit int32 `csv:"ActiveLimit"` //公会活跃值上限
+	PeopleAdd   int32 `csv:"PeopleAdd"`   //公会升级成员上限增量
+	ActiveAdd   int32 `csv:"ActiveAdd"`   //公会升级活跃上限增量
 }
 }
+
 func GuildLvCfgLoad(path string) {
 func GuildLvCfgLoad(path string) {
 	cfg := []*GuildLvCfg{}
 	cfg := []*GuildLvCfg{}
 	GuildLvCfgLoader = map[int32]*GuildLvCfg{}
 	GuildLvCfgLoader = map[int32]*GuildLvCfg{}
-	loadCsvCfg(path + "GuildLvCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"GuildLvCfg.csv", &cfg)
+	for _, row := range cfg {
 		GuildLvCfgLoader[row.Id] = row
 		GuildLvCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var GuildWarAgainstCfgLoader  map[int32]*GuildWarAgainstCfg
-type GuildWarAgainstCfg struct{
-	Id	int32	`csv:"Id"`		//ID
-	Ranking	int32	`csv:"Ranking"`		//公会战排名
-	DeaconName	string	`csv:"DeaconName"`		//会长奖励文本
-	DeaconReword	[]string	`csv:"DeaconReword"`		//会长奖励
-	GuildsmenName	string	`csv:"GuildsmenName"`		//公会成员奖励文本
-	GuildsmenReword	[]string	`csv:"GuildsmenReword"`		//公会战成员奖励
-	PointMvpName	string	`csv:"PointMvpName"`		//积分MVP奖励文本
-	PointMvp	int32	`csv:"PointMvp"`		//积分MVP
-	PointMvpReword	[]string	`csv:"PointMvpReword"`		//积分MVP奖励
-	KillerMvpName	string	`csv:"KillerMvpName"`		//击杀MVP奖励文本
-	KillerMvp	int32	`csv:"KillerMvp"`		//击杀MVP
-	KillerMvpReword	[]string	`csv:"KillerMvpReword"`		//击杀MVP奖励
+var GuildWarAgainstCfgLoader map[int32]*GuildWarAgainstCfg
+
+type GuildWarAgainstCfg struct {
+	Id              int32    `csv:"Id"`              //ID
+	Ranking         int32    `csv:"Ranking"`         //公会战排名
+	DeaconName      string   `csv:"DeaconName"`      //会长奖励文本
+	DeaconReword    []string `csv:"DeaconReword"`    //会长奖励
+	GuildsmenName   string   `csv:"GuildsmenName"`   //公会成员奖励文本
+	GuildsmenReword []string `csv:"GuildsmenReword"` //公会战成员奖励
+	PointMvpName    string   `csv:"PointMvpName"`    //积分MVP奖励文本
+	PointMvp        int32    `csv:"PointMvp"`        //积分MVP
+	PointMvpReword  []string `csv:"PointMvpReword"`  //积分MVP奖励
+	KillerMvpName   string   `csv:"KillerMvpName"`   //击杀MVP奖励文本
+	KillerMvp       int32    `csv:"KillerMvp"`       //击杀MVP
+	KillerMvpReword []string `csv:"KillerMvpReword"` //击杀MVP奖励
 }
 }
+
 func GuildWarAgainstCfgLoad(path string) {
 func GuildWarAgainstCfgLoad(path string) {
 	cfg := []*GuildWarAgainstCfg{}
 	cfg := []*GuildWarAgainstCfg{}
 	GuildWarAgainstCfgLoader = map[int32]*GuildWarAgainstCfg{}
 	GuildWarAgainstCfgLoader = map[int32]*GuildWarAgainstCfg{}
-	loadCsvCfg(path + "GuildWarAgainstCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"GuildWarAgainstCfg.csv", &cfg)
+	for _, row := range cfg {
 		GuildWarAgainstCfgLoader[row.Id] = row
 		GuildWarAgainstCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var GuildWarBuffCfgLoader  map[int32]*GuildWarBuffCfg
-type GuildWarBuffCfg struct{
-	Id	int32	`csv:"Id"`		//公会战buffID
-	SortId	int32	`csv:"SortId"`		//buff排序ID
-	Price	[]string	`csv:"Price"`		//购买价格
-	Mark	int32	`csv:"Mark"`		//对应mark
+var GuildWarBuffCfgLoader map[int32]*GuildWarBuffCfg
+
+type GuildWarBuffCfg struct {
+	Id     int32    `csv:"Id"`     //公会战buffID
+	SortId int32    `csv:"SortId"` //buff排序ID
+	Price  []string `csv:"Price"`  //购买价格
+	Mark   int32    `csv:"Mark"`   //对应mark
 }
 }
+
 func GuildWarBuffCfgLoad(path string) {
 func GuildWarBuffCfgLoad(path string) {
 	cfg := []*GuildWarBuffCfg{}
 	cfg := []*GuildWarBuffCfg{}
 	GuildWarBuffCfgLoader = map[int32]*GuildWarBuffCfg{}
 	GuildWarBuffCfgLoader = map[int32]*GuildWarBuffCfg{}
-	loadCsvCfg(path + "GuildWarBuffCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"GuildWarBuffCfg.csv", &cfg)
+	for _, row := range cfg {
 		GuildWarBuffCfgLoader[row.Id] = row
 		GuildWarBuffCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var GuildWarDojoCfgLoader  map[int32]*GuildWarDojoCfg
-type GuildWarDojoCfg struct{
-	Id	int32	`csv:"Id"`		//地块编号
-	AreaType	int32	`csv:"AreaType"`		//地块类别
-	GuildWarPoint	int32	`csv:"GuildWarPoint"`		//获得积分
+var GuildWarDojoCfgLoader map[int32]*GuildWarDojoCfg
+
+type GuildWarDojoCfg struct {
+	Id            int32 `csv:"Id"`            //地块编号
+	AreaType      int32 `csv:"AreaType"`      //地块类别
+	GuildWarPoint int32 `csv:"GuildWarPoint"` //获得积分
 }
 }
+
 func GuildWarDojoCfgLoad(path string) {
 func GuildWarDojoCfgLoad(path string) {
 	cfg := []*GuildWarDojoCfg{}
 	cfg := []*GuildWarDojoCfg{}
 	GuildWarDojoCfgLoader = map[int32]*GuildWarDojoCfg{}
 	GuildWarDojoCfgLoader = map[int32]*GuildWarDojoCfg{}
-	loadCsvCfg(path + "GuildWarDojoCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"GuildWarDojoCfg.csv", &cfg)
+	for _, row := range cfg {
 		GuildWarDojoCfgLoader[row.Id] = row
 		GuildWarDojoCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var HeadFrameCfgLoader  map[int32]*HeadFrameCfg
-type HeadFrameCfg struct{
-	HeadFrameId	int32	`csv:"HeadFrameId"`		//头像框id
-	HeadFrameQuality	[]string	`csv:"HeadFrameQuality"`		//头像框属性
-	HeadFrameSource	[]string	`csv:"HeadFrameSource"`		//头像框来源
-	HeadFrameType	int32	`csv:"HeadFrameType"`		//头像框类型
-	ResolveItem	[]string	`csv:"ResolveItem"`		//分解获得
-	Dec	string	`csv:"Dec"`		//备注
+var HeadFrameCfgLoader map[int32]*HeadFrameCfg
+
+type HeadFrameCfg struct {
+	HeadFrameId      int32    `csv:"HeadFrameId"`      //头像框id
+	HeadFrameQuality []string `csv:"HeadFrameQuality"` //头像框属性
+	HeadFrameSource  []string `csv:"HeadFrameSource"`  //头像框来源
+	HeadFrameType    int32    `csv:"HeadFrameType"`    //头像框类型
+	ResolveItem      []string `csv:"ResolveItem"`      //分解获得
+	Dec              string   `csv:"Dec"`              //备注
 }
 }
+
 func HeadFrameCfgLoad(path string) {
 func HeadFrameCfgLoad(path string) {
 	cfg := []*HeadFrameCfg{}
 	cfg := []*HeadFrameCfg{}
 	HeadFrameCfgLoader = map[int32]*HeadFrameCfg{}
 	HeadFrameCfgLoader = map[int32]*HeadFrameCfg{}
-	loadCsvCfg(path + "HeadFrameCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"HeadFrameCfg.csv", &cfg)
+	for _, row := range cfg {
 		HeadFrameCfgLoader[row.HeadFrameId] = row
 		HeadFrameCfgLoader[row.HeadFrameId] = row
 	}
 	}
 }
 }
 
 
-var HeadPortraitCfgLoader  map[int32]*HeadPortraitCfg
-type HeadPortraitCfg struct{
-	HeadPortraitId	int32	`csv:"HeadPortraitId"`		//头像ID
-	UnlockCondition	int32	`csv:"UnlockCondition"`		//解锁条件
-	HeadLoadId	int32	`csv:"HeadLoadId"`		//头像加载ID
-	HeadPortraitSex	int32	`csv:"HeadPortraitSex"`		//头像性别
+var HeadPortraitCfgLoader map[int32]*HeadPortraitCfg
+
+type HeadPortraitCfg struct {
+	HeadPortraitId  int32 `csv:"HeadPortraitId"`  //头像ID
+	UnlockCondition int32 `csv:"UnlockCondition"` //解锁条件
+	HeadLoadId      int32 `csv:"HeadLoadId"`      //头像加载ID
+	HeadPortraitSex int32 `csv:"HeadPortraitSex"` //头像性别
 }
 }
+
 func HeadPortraitCfgLoad(path string) {
 func HeadPortraitCfgLoad(path string) {
 	cfg := []*HeadPortraitCfg{}
 	cfg := []*HeadPortraitCfg{}
 	HeadPortraitCfgLoader = map[int32]*HeadPortraitCfg{}
 	HeadPortraitCfgLoader = map[int32]*HeadPortraitCfg{}
-	loadCsvCfg(path + "HeadPortraitCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"HeadPortraitCfg.csv", &cfg)
+	for _, row := range cfg {
 		HeadPortraitCfgLoader[row.HeadPortraitId] = row
 		HeadPortraitCfgLoader[row.HeadPortraitId] = row
 	}
 	}
 }
 }
 
 
-var HundredDojoCfgLoader  map[int32]*HundredDojoCfg
-type HundredDojoCfg struct{
-	Id	int32	`csv:"Id"`		//地块编号
-	AreaType	int32	`csv:"AreaType"`		//地块类别
-	FunType	int32	`csv:"FunType"`		//功能类型
-	RewardList	[]string	`csv:"RewardList"`		//固定时间间隔资源产出
-	Robot	int32	`csv:"Robot"`		//初始机器人Id
-	TimeProtect	int32	`csv:"TimeProtect"`		//保护时间(分钟)
-	TimeReward	int32	`csv:"TimeReward"`		//占领时间(分钟)
-	ShowRewardList	[]string	`csv:"ShowRewardList"`		//固定时间间隔资源产出
+var HundredDojoCfgLoader map[int32]*HundredDojoCfg
+
+type HundredDojoCfg struct {
+	Id             int32    `csv:"Id"`             //地块编号
+	AreaType       int32    `csv:"AreaType"`       //地块类别
+	FunType        int32    `csv:"FunType"`        //功能类型
+	RewardList     []string `csv:"RewardList"`     //固定时间间隔资源产出
+	Robot          int32    `csv:"Robot"`          //初始机器人Id
+	TimeProtect    int32    `csv:"TimeProtect"`    //保护时间(分钟)
+	TimeReward     int32    `csv:"TimeReward"`     //占领时间(分钟)
+	ShowRewardList []string `csv:"ShowRewardList"` //固定时间间隔资源产出
 }
 }
+
 func HundredDojoCfgLoad(path string) {
 func HundredDojoCfgLoad(path string) {
 	cfg := []*HundredDojoCfg{}
 	cfg := []*HundredDojoCfg{}
 	HundredDojoCfgLoader = map[int32]*HundredDojoCfg{}
 	HundredDojoCfgLoader = map[int32]*HundredDojoCfg{}
-	loadCsvCfg(path + "HundredDojoCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"HundredDojoCfg.csv", &cfg)
+	for _, row := range cfg {
 		HundredDojoCfgLoader[row.Id] = row
 		HundredDojoCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var InvitationTaskCfgLoader  map[int32]*InvitationTaskCfg
-type InvitationTaskCfg struct{
-	TaskId	int32	`csv:"TaskId"`		//任务ID
-	TaskCondition	[]string	`csv:"TaskCondition"`		//任务枚举
-	Reward	[]string	`csv:"Reward"`		//任务奖励
-	Desc	string	`csv:"Desc"`		//任务描述
-	CompleteNum	int32	`csv:"CompleteNum"`		//可完成的最大次数
+var InvitationTaskCfgLoader map[int32]*InvitationTaskCfg
+
+type InvitationTaskCfg struct {
+	TaskId        int32    `csv:"TaskId"`        //任务ID
+	TaskCondition []string `csv:"TaskCondition"` //任务枚举
+	Reward        []string `csv:"Reward"`        //任务奖励
+	Desc          string   `csv:"Desc"`          //任务描述
+	CompleteNum   int32    `csv:"CompleteNum"`   //可完成的最大次数
 }
 }
+
 func InvitationTaskCfgLoad(path string) {
 func InvitationTaskCfgLoad(path string) {
 	cfg := []*InvitationTaskCfg{}
 	cfg := []*InvitationTaskCfg{}
 	InvitationTaskCfgLoader = map[int32]*InvitationTaskCfg{}
 	InvitationTaskCfgLoader = map[int32]*InvitationTaskCfg{}
-	loadCsvCfg(path + "InvitationTaskCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"InvitationTaskCfg.csv", &cfg)
+	for _, row := range cfg {
 		InvitationTaskCfgLoader[row.TaskId] = row
 		InvitationTaskCfgLoader[row.TaskId] = row
 	}
 	}
 }
 }
 
 
-var ItemCfgLoader  map[int32]*ItemCfg
-type ItemCfg struct{
-	Id	int32	`csv:"Id"`		//id
-	ResType	int32	`csv:"ResType"`		//道具类型
-	Quality	int32	`csv:"Quality"`		//道具品质
-	Composition	int32	`csv:"Composition"`		//叠加数量
-	AutoUse	int32	`csv:"AutoUse"`		//是否自动使用
-	Costitem	[]string	`csv:"Costitem"`		//是否消耗道具
-	NeedLevel	int32	`csv:"NeedLevel"`		//需要等级
-	Bang	int32	`csv:"Bang"`		//是否绑定
-	Job	int32	`csv:"Job"`		//是否分职业
-	ComposeItem	[]string	`csv:"ComposeItem"`		//合成目标
-	Resolve	[]string	`csv:"Resolve"`		//分解目标
-	ItemTime	int32	`csv:"ItemTime"`		//道具时效
-	DebrisShow	int32	`csv:"DebrisShow"`		//碎片展示
-	SourceFun	[]string	`csv:"SourceFun"`		//获取途径
-	NatureType	int32	`csv:"NatureType"`		//属性
-	ActivationItem	int32	`csv:"ActivationItem"`		//对应藏品
-	ItemTimeCd	int32	`csv:"ItemTimeCd"`		//道具使用所需时间
+var ItemCfgLoader map[int32]*ItemCfg
+
+type ItemCfg struct {
+	Id             int32    `csv:"Id"`             //id
+	ResType        int32    `csv:"ResType"`        //道具类型
+	Quality        int32    `csv:"Quality"`        //道具品质
+	Composition    int32    `csv:"Composition"`    //叠加数量
+	AutoUse        int32    `csv:"AutoUse"`        //是否自动使用
+	Costitem       []string `csv:"Costitem"`       //是否消耗道具
+	NeedLevel      int32    `csv:"NeedLevel"`      //需要等级
+	Bang           int32    `csv:"Bang"`           //是否绑定
+	Job            int32    `csv:"Job"`            //是否分职业
+	ComposeItem    []string `csv:"ComposeItem"`    //合成目标
+	Resolve        []string `csv:"Resolve"`        //分解目标
+	ItemTime       int32    `csv:"ItemTime"`       //道具时效
+	DebrisShow     int32    `csv:"DebrisShow"`     //碎片展示
+	SourceFun      []string `csv:"SourceFun"`      //获取途径
+	NatureType     int32    `csv:"NatureType"`     //属性
+	ActivationItem int32    `csv:"ActivationItem"` //对应藏品
+	ItemTimeCd     int32    `csv:"ItemTimeCd"`     //道具使用所需时间
 }
 }
+
 func ItemCfgLoad(path string) {
 func ItemCfgLoad(path string) {
 	cfg := []*ItemCfg{}
 	cfg := []*ItemCfg{}
 	ItemCfgLoader = map[int32]*ItemCfg{}
 	ItemCfgLoader = map[int32]*ItemCfg{}
-	loadCsvCfg(path + "ItemCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ItemCfg.csv", &cfg)
+	for _, row := range cfg {
 		ItemCfgLoader[row.Id] = row
 		ItemCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var JobCfgLoader  map[int32]*JobCfg
-type JobCfg struct{
-	Id	int32	`csv:"Id"`		//职业ID
-	JobName	string	`csv:"JobName"`		//职业名字
-	Position	int32	`csv:"Position"`		//站位
-	JobType	int32	`csv:"JobType"`		//职业类型
-	JobBranch	int32	`csv:"JobBranch"`		//职业分支
-	JobStage	int32	`csv:"JobStage"`		//职业阶段
-	MaxJobLv	int32	`csv:"MaxJobLv"`		//职业等级上限
-	BeforeJobId	int32	`csv:"BeforeJobId"`		//上阶职业
-	AfterJobId	[]string	`csv:"AfterJobId"`		//下阶职业
-	ChangeCond	[]string	`csv:"ChangeCond"`		//转职条件
-	ItemCost	[]string	`csv:"ItemCost"`		//消耗道具
-	Again	int32	`csv:"Again"`		//转生
-	UpBaseLV	int32	`csv:"UpBaseLV"`		//转职人物等级
-	UpJobLv	int32	`csv:"UpJobLv"`		//转职职业等级
-	Bag	int32	`csv:"Bag"`		//装备背包格子
-	HpRate	int32	`csv:"HpRate"`		//生命系数
-	SpRate	int32	`csv:"SpRate"`		//蓝量系数
-	AtkRate	int32	`csv:"AtkRate"`		//物攻系数
-	MatkRate	int32	`csv:"MatkRate"`		//魔攻系数
-	DefRate	int32	`csv:"DefRate"`		//物防系数
-	MdefRate	int32	`csv:"MdefRate"`		//魔防系数
-	HitRate	int32	`csv:"HitRate"`		//命中系数
-	DodgeRate	int32	`csv:"DodgeRate"`		//闪避系数
-	CritRate	int32	`csv:"CritRate"`		//暴击系数
-	TenRate	int32	`csv:"TenRate"`		//韧性系数
-	Aspd	int32	`csv:"Aspd"`		//攻速
-	ArmsType	int32	`csv:"ArmsType"`		//职业武器类型
-	NormalSkillIds	[]string	`csv:"NormalSkillIds"`		//普攻技能id
-	SkillIds	[]string	`csv:"SkillIds"`		//默认技能id
-	NatureId	int32	`csv:"NatureId"`		//属性id
-	RaceId	int32	`csv:"RaceId"`		//种族id
-	AutoAddPoint	[]string	`csv:"AutoAddPoint"`		//自动加点
-	AlternativeSkills	[]string	`csv:"AlternativeSkills"`		//备用技能id
+var JobCfgLoader map[int32]*JobCfg
+
+type JobCfg struct {
+	Id                int32    `csv:"Id"`                //职业ID
+	JobName           string   `csv:"JobName"`           //职业名字
+	Position          int32    `csv:"Position"`          //站位
+	JobType           int32    `csv:"JobType"`           //职业类型
+	JobBranch         int32    `csv:"JobBranch"`         //职业分支
+	JobStage          int32    `csv:"JobStage"`          //职业阶段
+	MaxJobLv          int32    `csv:"MaxJobLv"`          //职业等级上限
+	BeforeJobId       int32    `csv:"BeforeJobId"`       //上阶职业
+	AfterJobId        []string `csv:"AfterJobId"`        //下阶职业
+	ChangeCond        []string `csv:"ChangeCond"`        //转职条件
+	ItemCost          []string `csv:"ItemCost"`          //消耗道具
+	Again             int32    `csv:"Again"`             //转生
+	UpBaseLV          int32    `csv:"UpBaseLV"`          //转职人物等级
+	UpJobLv           int32    `csv:"UpJobLv"`           //转职职业等级
+	Bag               int32    `csv:"Bag"`               //装备背包格子
+	HpRate            int32    `csv:"HpRate"`            //生命系数
+	SpRate            int32    `csv:"SpRate"`            //蓝量系数
+	AtkRate           int32    `csv:"AtkRate"`           //物攻系数
+	MatkRate          int32    `csv:"MatkRate"`          //魔攻系数
+	DefRate           int32    `csv:"DefRate"`           //物防系数
+	MdefRate          int32    `csv:"MdefRate"`          //魔防系数
+	HitRate           int32    `csv:"HitRate"`           //命中系数
+	DodgeRate         int32    `csv:"DodgeRate"`         //闪避系数
+	CritRate          int32    `csv:"CritRate"`          //暴击系数
+	TenRate           int32    `csv:"TenRate"`           //韧性系数
+	Aspd              int32    `csv:"Aspd"`              //攻速
+	ArmsType          int32    `csv:"ArmsType"`          //职业武器类型
+	NormalSkillIds    []string `csv:"NormalSkillIds"`    //普攻技能id
+	SkillIds          []string `csv:"SkillIds"`          //默认技能id
+	NatureId          int32    `csv:"NatureId"`          //属性id
+	RaceId            int32    `csv:"RaceId"`            //种族id
+	AutoAddPoint      []string `csv:"AutoAddPoint"`      //自动加点
+	AlternativeSkills []string `csv:"AlternativeSkills"` //备用技能id
 }
 }
+
 func JobCfgLoad(path string) {
 func JobCfgLoad(path string) {
 	cfg := []*JobCfg{}
 	cfg := []*JobCfg{}
 	JobCfgLoader = map[int32]*JobCfg{}
 	JobCfgLoader = map[int32]*JobCfg{}
-	loadCsvCfg(path + "JobCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"JobCfg.csv", &cfg)
+	for _, row := range cfg {
 		JobCfgLoader[row.Id] = row
 		JobCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var JobExpCfgLoader  map[int32]*JobExpCfg
-type JobExpCfg struct{
-	JobLevel	int32	`csv:"jobLevel"`		//job等级
-	ExpRequire1	int32	`csv:"expRequire1"`		//未转身所需经验
-	Point1	int32	`csv:"point1"`		//1转升级点
-	ExpRequire2	int32	`csv:"expRequire2"`		//1转所需经验
-	Point2	int32	`csv:"point2"`		//2转升级点
-	ExpRequire3	int32	`csv:"expRequire3"`		//3转所需经验
-	Point3	int32	`csv:"point3"`		//3转升级点
+var JobExpCfgLoader map[int32]*JobExpCfg
+
+type JobExpCfg struct {
+	JobLevel    int32 `csv:"jobLevel"`    //job等级
+	ExpRequire1 int32 `csv:"expRequire1"` //未转身所需经验
+	Point1      int32 `csv:"point1"`      //1转升级点
+	ExpRequire2 int32 `csv:"expRequire2"` //1转所需经验
+	Point2      int32 `csv:"point2"`      //2转升级点
+	ExpRequire3 int32 `csv:"expRequire3"` //3转所需经验
+	Point3      int32 `csv:"point3"`      //3转升级点
 }
 }
+
 func JobExpCfgLoad(path string) {
 func JobExpCfgLoad(path string) {
 	cfg := []*JobExpCfg{}
 	cfg := []*JobExpCfg{}
 	JobExpCfgLoader = map[int32]*JobExpCfg{}
 	JobExpCfgLoader = map[int32]*JobExpCfg{}
-	loadCsvCfg(path + "JobExpCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"JobExpCfg.csv", &cfg)
+	for _, row := range cfg {
 		JobExpCfgLoader[row.JobLevel] = row
 		JobExpCfgLoader[row.JobLevel] = row
 	}
 	}
 }
 }
 
 
-var KeepSakeCfgLoader  map[int32]*KeepSakeCfg
-type KeepSakeCfg struct{
-	Id	int32	`csv:"Id"`		//藏品Id
-	CollectionLevel	int32	`csv:"CollectionLevel"`		//藏品等级
-	MaterialMaxLevel	int32	`csv:"MaterialMaxLevel"`		//最大合成等级
-	MaterialLevel1	[]string	`csv:"MaterialLevel1"`		//合成阶段1
-	MaterialLevel2	[]string	`csv:"MaterialLevel2"`		//合成阶段2
-	MaterialLevel3	[]string	`csv:"MaterialLevel3"`		//合成阶段3
-	MaterialLevel4	[]string	`csv:"MaterialLevel4"`		//合成阶段4
-	MaterialLevel5	[]string	`csv:"MaterialLevel5"`		//合成阶段5
-	AddAttrLevel1	[]string	`csv:"AddAttrLevel1"`		//增加属性1
-	AddAttrLevel2	[]string	`csv:"AddAttrLevel2"`		//增加属性2
-	AddAttrLevel3	[]string	`csv:"AddAttrLevel3"`		//增加属性3
-	AddAttrLevel4	[]string	`csv:"AddAttrLevel4"`		//增加属性4
-	AddAttrLevel5	[]string	`csv:"AddAttrLevel5"`		//增加属性5
-	Job	[]string	`csv:"Job"`		//加成职业
+var KeepSakeCfgLoader map[int32]*KeepSakeCfg
+
+type KeepSakeCfg struct {
+	Id               int32    `csv:"Id"`               //藏品Id
+	CollectionLevel  int32    `csv:"CollectionLevel"`  //藏品等级
+	MaterialMaxLevel int32    `csv:"MaterialMaxLevel"` //最大合成等级
+	MaterialLevel1   []string `csv:"MaterialLevel1"`   //合成阶段1
+	MaterialLevel2   []string `csv:"MaterialLevel2"`   //合成阶段2
+	MaterialLevel3   []string `csv:"MaterialLevel3"`   //合成阶段3
+	MaterialLevel4   []string `csv:"MaterialLevel4"`   //合成阶段4
+	MaterialLevel5   []string `csv:"MaterialLevel5"`   //合成阶段5
+	AddAttrLevel1    []string `csv:"AddAttrLevel1"`    //增加属性1
+	AddAttrLevel2    []string `csv:"AddAttrLevel2"`    //增加属性2
+	AddAttrLevel3    []string `csv:"AddAttrLevel3"`    //增加属性3
+	AddAttrLevel4    []string `csv:"AddAttrLevel4"`    //增加属性4
+	AddAttrLevel5    []string `csv:"AddAttrLevel5"`    //增加属性5
+	Job              []string `csv:"Job"`              //加成职业
 }
 }
+
 func KeepSakeCfgLoad(path string) {
 func KeepSakeCfgLoad(path string) {
 	cfg := []*KeepSakeCfg{}
 	cfg := []*KeepSakeCfg{}
 	KeepSakeCfgLoader = map[int32]*KeepSakeCfg{}
 	KeepSakeCfgLoader = map[int32]*KeepSakeCfg{}
-	loadCsvCfg(path + "KeepSakeCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"KeepSakeCfg.csv", &cfg)
+	for _, row := range cfg {
 		KeepSakeCfgLoader[row.Id] = row
 		KeepSakeCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var LevelCfgLoader  map[int32]*LevelCfg
-type LevelCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	LevelId	int32	`csv:"LevelId"`		//场景id
-	MapId	int32	`csv:"MapId"`		//地图id
-	LevelType	int32	`csv:"LevelType"`		//场景类型
-	FightCD	int32	`csv:"FightCD"`		//挑战CD
-	BaseExpOl	int32	`csv:"BaseExpOl"`		//在线base经验
-	ParterOl	int32	`csv:"ParterOl"`		//在线伙伴经验
-	ZenyOl	int32	`csv:"ZenyOl"`		//在线银币
-	CruiseOl	int32	`csv:"CruiseOl"`		//技能经验
-	GoldOl	int32	`csv:"GoldOl"`		//在线金币
-	EvilOl	int32	`csv:"EvilOl"`		//在线魔魂值
-	DropOl	[]string	`csv:"DropOl"`		//在线掉落包ID
-	HdDrop	[]string	`csv:"HdDrop"`		//活动掉落ID
-	BaseExp	int32	`csv:"BaseExp"`		//通关base经验
-	JobExp	int32	`csv:"JobExp"`		//通关job经验
-	Zeny	int32	`csv:"Zeny"`		//通关银币
-	Gold	int32	`csv:"Gold"`		//通关金币
-	Parter	int32	`csv:"Parter"`		//通关伙伴经验
-	Cash	int32	`csv:"Cash"`		//活动通关现金
-	PassNum	int32	`csv:"PassNum"`		//通关超过人数
-	GuildActive	int32	`csv:"GuildActive"`		//通关公会活跃
-	Drop	[]string	`csv:"Drop"`		//通关掉落包ID
-	BossId	int32	`csv:"BossId"`		//bossId
-	DropTimes	int32	`csv:"DropTimes"`		//挑战后掉落次数
-	FightLv	int32	`csv:"FightLv"`		//BOSS挑战等级
-	DlgId	int32	`csv:"DlgId"`		//巡游前剧情ID
-	DlgContentId	int32	`csv:"DlgContentId"`		//剧情索引ID
-	FightCheck	int32	`csv:"FightCheck"`		//战力校验
-	SpAddition	string	`csv:"SpAddition"`		//蓝量加成
-	PowerWeaken	string	`csv:"PowerWeaken"`		//战力削弱
-	StayTimeWeaken	string	`csv:"StayTimeWeaken"`		//停留时间削弱
-	Version	int32	`csv:"version"`		//版本
-	MapScore	int32	`csv:"MapScore"`		//里程积分
-	CloseDown	string	`csv:"CloseDown"`		//查封配置
-	FreeInvest	int32	`csv:"FreeInvest"`		//通关免费充值额度
+var LevelCfgLoader map[int32]*LevelCfg
+
+type LevelCfg struct {
+	Id             int32    `csv:"Id"`             //唯一id
+	LevelId        int32    `csv:"LevelId"`        //场景id
+	MapId          int32    `csv:"MapId"`          //地图id
+	LevelType      int32    `csv:"LevelType"`      //场景类型
+	FightCD        int32    `csv:"FightCD"`        //挑战CD
+	BaseExpOl      int32    `csv:"BaseExpOl"`      //在线base经验
+	ParterOl       int32    `csv:"ParterOl"`       //在线伙伴经验
+	ZenyOl         int32    `csv:"ZenyOl"`         //在线银币
+	CruiseOl       int32    `csv:"CruiseOl"`       //技能经验
+	GoldOl         int32    `csv:"GoldOl"`         //在线金币
+	EvilOl         int32    `csv:"EvilOl"`         //在线魔魂值
+	DropOl         []string `csv:"DropOl"`         //在线掉落包ID
+	HdDrop         []string `csv:"HdDrop"`         //活动掉落ID
+	BaseExp        int32    `csv:"BaseExp"`        //通关base经验
+	JobExp         int32    `csv:"JobExp"`         //通关job经验
+	Zeny           int32    `csv:"Zeny"`           //通关银币
+	Gold           int32    `csv:"Gold"`           //通关金币
+	Parter         int32    `csv:"Parter"`         //通关伙伴经验
+	Cash           int32    `csv:"Cash"`           //活动通关现金
+	PassNum        int32    `csv:"PassNum"`        //通关超过人数
+	GuildActive    int32    `csv:"GuildActive"`    //通关公会活跃
+	Drop           []string `csv:"Drop"`           //通关掉落包ID
+	BossId         int32    `csv:"BossId"`         //bossId
+	DropTimes      int32    `csv:"DropTimes"`      //挑战后掉落次数
+	FightLv        int32    `csv:"FightLv"`        //BOSS挑战等级
+	DlgId          int32    `csv:"DlgId"`          //巡游前剧情ID
+	DlgContentId   int32    `csv:"DlgContentId"`   //剧情索引ID
+	FightCheck     int32    `csv:"FightCheck"`     //战力校验
+	SpAddition     string   `csv:"SpAddition"`     //蓝量加成
+	PowerWeaken    string   `csv:"PowerWeaken"`    //战力削弱
+	StayTimeWeaken string   `csv:"StayTimeWeaken"` //停留时间削弱
+	Version        int32    `csv:"version"`        //版本
+	MapScore       int32    `csv:"MapScore"`       //里程积分
+	CloseDown      string   `csv:"CloseDown"`      //查封配置
+	FreeInvest     int32    `csv:"FreeInvest"`     //通关免费充值额度
 }
 }
+
 func LevelCfgLoad(path string) {
 func LevelCfgLoad(path string) {
 	cfg := []*LevelCfg{}
 	cfg := []*LevelCfg{}
 	LevelCfgLoader = map[int32]*LevelCfg{}
 	LevelCfgLoader = map[int32]*LevelCfg{}
-	loadCsvCfg(path + "LevelCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"LevelCfg.csv", &cfg)
+	for _, row := range cfg {
 		LevelCfgLoader[row.Id] = row
 		LevelCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var LineMissionCfgLoader  map[int32]*LineMissionCfg
-type LineMissionCfg struct{
-	MissionID	int32	`csv:"MissionID"`		//任务ID
-	MissionCondition	[]string	`csv:"MissionCondition"`		//任务枚举
-	Reward	[]string	`csv:"Reward"`		//奖励
-	BeginMission	int32	`csv:"BeginMission"`		//是否为开始任务
-	FollowMissionld	int32	`csv:"FollowMissionld"`		//后续ID
+var LineMissionCfgLoader map[int32]*LineMissionCfg
+
+type LineMissionCfg struct {
+	MissionID        int32    `csv:"MissionID"`        //任务ID
+	MissionCondition []string `csv:"MissionCondition"` //任务枚举
+	Reward           []string `csv:"Reward"`           //奖励
+	BeginMission     int32    `csv:"BeginMission"`     //是否为开始任务
+	FollowMissionld  int32    `csv:"FollowMissionld"`  //后续ID
 }
 }
+
 func LineMissionCfgLoad(path string) {
 func LineMissionCfgLoad(path string) {
 	cfg := []*LineMissionCfg{}
 	cfg := []*LineMissionCfg{}
 	LineMissionCfgLoader = map[int32]*LineMissionCfg{}
 	LineMissionCfgLoader = map[int32]*LineMissionCfg{}
-	loadCsvCfg(path + "LineMissionCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"LineMissionCfg.csv", &cfg)
+	for _, row := range cfg {
 		LineMissionCfgLoader[row.MissionID] = row
 		LineMissionCfgLoader[row.MissionID] = row
 	}
 	}
 }
 }
 
 
-var MailCfgLoader  map[int32]*MailCfg
-type MailCfg struct{
-	Id	int32	`csv:"Id"`		//id
-	Title	string	`csv:"Title"`		//主题
-	Text	string	`csv:"Text"`		//正文
-	Time	int32	`csv:"Time"`		//有效期
+var MailCfgLoader map[int32]*MailCfg
+
+type MailCfg struct {
+	Id    int32  `csv:"Id"`    //id
+	Title string `csv:"Title"` //主题
+	Text  string `csv:"Text"`  //正文
+	Time  int32  `csv:"Time"`  //有效期
 }
 }
+
 func MailCfgLoad(path string) {
 func MailCfgLoad(path string) {
 	cfg := []*MailCfg{}
 	cfg := []*MailCfg{}
 	MailCfgLoader = map[int32]*MailCfg{}
 	MailCfgLoader = map[int32]*MailCfg{}
-	loadCsvCfg(path + "MailCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"MailCfg.csv", &cfg)
+	for _, row := range cfg {
 		MailCfgLoader[row.Id] = row
 		MailCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var MissionCfgLoader  map[int32]*MissionCfg
-type MissionCfg struct{
-	MissionID	int32	`csv:"MissionID"`		//任务ID
-	MissionCondition	[]string	`csv:"MissionCondition"`		//任务枚举
-	MissionType	int32	`csv:"MissionType"`		//任务类型
-	Active	int32	`csv:"Active"`		//活跃度
-	GuildActive	int32	`csv:"GuildActive"`		//公会个人活跃值
-	RenovateTime	int32	`csv:"RenovateTime"`		//刷新时间
+var MissionCfgLoader map[int32]*MissionCfg
+
+type MissionCfg struct {
+	MissionID        int32    `csv:"MissionID"`        //任务ID
+	MissionCondition []string `csv:"MissionCondition"` //任务枚举
+	MissionType      int32    `csv:"MissionType"`      //任务类型
+	Active           int32    `csv:"Active"`           //活跃度
+	GuildActive      int32    `csv:"GuildActive"`      //公会个人活跃值
+	RenovateTime     int32    `csv:"RenovateTime"`     //刷新时间
 }
 }
+
 func MissionCfgLoad(path string) {
 func MissionCfgLoad(path string) {
 	cfg := []*MissionCfg{}
 	cfg := []*MissionCfg{}
 	MissionCfgLoader = map[int32]*MissionCfg{}
 	MissionCfgLoader = map[int32]*MissionCfg{}
-	loadCsvCfg(path + "MissionCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"MissionCfg.csv", &cfg)
+	for _, row := range cfg {
 		MissionCfgLoader[row.MissionID] = row
 		MissionCfgLoader[row.MissionID] = row
 	}
 	}
 }
 }
 
 
-var NatureCfgLoader  map[int32]*NatureCfg
-type NatureCfg struct{
-	Id	int32	`csv:"Id"`		//属性id
-	Name	string	`csv:"Name"`		//属性名字
-	NatureAttribute	string	`csv:"NatureAttribute"`		//附加元素属性
-	AntiNature	string	`csv:"AntiNature"`		//承受属性伤害系数
+var NatureCfgLoader map[int32]*NatureCfg
+
+type NatureCfg struct {
+	Id              int32  `csv:"Id"`              //属性id
+	Name            string `csv:"Name"`            //属性名字
+	NatureAttribute string `csv:"NatureAttribute"` //附加元素属性
+	AntiNature      string `csv:"AntiNature"`      //承受属性伤害系数
 }
 }
+
 func NatureCfgLoad(path string) {
 func NatureCfgLoad(path string) {
 	cfg := []*NatureCfg{}
 	cfg := []*NatureCfg{}
 	NatureCfgLoader = map[int32]*NatureCfg{}
 	NatureCfgLoader = map[int32]*NatureCfg{}
-	loadCsvCfg(path + "NatureCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"NatureCfg.csv", &cfg)
+	for _, row := range cfg {
 		NatureCfgLoader[row.Id] = row
 		NatureCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var NpcCfgLoader  map[int32]*NpcCfg
-type NpcCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	MonsterId	int32	`csv:"MonsterId"`		//怪物id
-	BaseLv	int32	`csv:"BaseLv"`		//角色等级
-	JobType	int32	`csv:"JobType"`		//怪物职业
-	NpcType	int32	`csv:"NpcType"`		//职业类型
-	Hp	float32	`csv:"Hp"`		//生命
-	Sp	float32	`csv:"Sp"`		//蓝量
-	SkillIds	[]string	`csv:"SkillIds"`		//技能id
-	NatureId	int32	`csv:"NatureId"`		//属性id
-	PassiveSkills	[]string	`csv:"PassiveSkills"`		//被动技能
-	EngName	string	`csv:"EngName"`		//英语唯一名
+var NpcCfgLoader map[int32]*NpcCfg
+
+type NpcCfg struct {
+	Id            int32    `csv:"Id"`            //唯一id
+	MonsterId     int32    `csv:"MonsterId"`     //怪物id
+	BaseLv        int32    `csv:"BaseLv"`        //角色等级
+	JobType       int32    `csv:"JobType"`       //怪物职业
+	NpcType       int32    `csv:"NpcType"`       //职业类型
+	Hp            float32  `csv:"Hp"`            //生命
+	Sp            float32  `csv:"Sp"`            //蓝量
+	SkillIds      []string `csv:"SkillIds"`      //技能id
+	NatureId      int32    `csv:"NatureId"`      //属性id
+	PassiveSkills []string `csv:"PassiveSkills"` //被动技能
+	EngName       string   `csv:"EngName"`       //英语唯一名
 }
 }
+
 func NpcCfgLoad(path string) {
 func NpcCfgLoad(path string) {
 	cfg := []*NpcCfg{}
 	cfg := []*NpcCfg{}
 	NpcCfgLoader = map[int32]*NpcCfg{}
 	NpcCfgLoader = map[int32]*NpcCfg{}
-	loadCsvCfg(path + "NpcCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"NpcCfg.csv", &cfg)
+	for _, row := range cfg {
 		NpcCfgLoader[row.Id] = row
 		NpcCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var OnlineRewardsCfgLoader  map[int32]*OnlineRewardsCfg
-type OnlineRewardsCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	Day	int32	`csv:"Day"`		//天数
-	Time	int32	`csv:"Time"`		//在线时长
-	Rewards	[]string	`csv:"Rewards"`		//奖励
-	SpeedUp	int32	`csv:"SpeedUp"`		//金币加速
+var OnlineRewardsCfgLoader map[int32]*OnlineRewardsCfg
+
+type OnlineRewardsCfg struct {
+	Id      int32    `csv:"Id"`      //唯一id
+	Day     int32    `csv:"Day"`     //天数
+	Time    int32    `csv:"Time"`    //在线时长
+	Rewards []string `csv:"Rewards"` //奖励
+	SpeedUp int32    `csv:"SpeedUp"` //金币加速
 }
 }
+
 func OnlineRewardsCfgLoad(path string) {
 func OnlineRewardsCfgLoad(path string) {
 	cfg := []*OnlineRewardsCfg{}
 	cfg := []*OnlineRewardsCfg{}
 	OnlineRewardsCfgLoader = map[int32]*OnlineRewardsCfg{}
 	OnlineRewardsCfgLoader = map[int32]*OnlineRewardsCfg{}
-	loadCsvCfg(path + "OnlineRewardsCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"OnlineRewardsCfg.csv", &cfg)
+	for _, row := range cfg {
 		OnlineRewardsCfgLoader[row.Id] = row
 		OnlineRewardsCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ParterAttributeCfgLoader  map[int32]*ParterAttributeCfg
-type ParterAttributeCfg struct{
-	BaseLv	int32	`csv:"BaseLv"`		//伙伴等级
-	Exp	int32	`csv:"Exp"`		//需求经验
-	Money	int32	`csv:"Money"`		//伙伴升级费用
-	GetPoint	int32	`csv:"GetPoint"`		//获得点数
+var ParterAttributeCfgLoader map[int32]*ParterAttributeCfg
+
+type ParterAttributeCfg struct {
+	BaseLv   int32 `csv:"BaseLv"`   //伙伴等级
+	Exp      int32 `csv:"Exp"`      //需求经验
+	Money    int32 `csv:"Money"`    //伙伴升级费用
+	GetPoint int32 `csv:"GetPoint"` //获得点数
 }
 }
+
 func ParterAttributeCfgLoad(path string) {
 func ParterAttributeCfgLoad(path string) {
 	cfg := []*ParterAttributeCfg{}
 	cfg := []*ParterAttributeCfg{}
 	ParterAttributeCfgLoader = map[int32]*ParterAttributeCfg{}
 	ParterAttributeCfgLoader = map[int32]*ParterAttributeCfg{}
-	loadCsvCfg(path + "ParterAttributeCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ParterAttributeCfg.csv", &cfg)
+	for _, row := range cfg {
 		ParterAttributeCfgLoader[row.BaseLv] = row
 		ParterAttributeCfgLoader[row.BaseLv] = row
 	}
 	}
 }
 }
 
 
-var ParterCfgLoader  map[int32]*ParterCfg
-type ParterCfg struct{
-	ParterId	int32	`csv:"ParterId"`		//佣兵ID
-	Desc	string	`csv:"Desc"`		//描述
-	JobName	string	`csv:"JobName"`		//职业名字
-	JobIcon	string	`csv:"JobIcon"`		//职业图标
-	JobType	int32	`csv:"JobType"`		//职业类型
-	JobStage	int32	`csv:"JobStage"`		//职业阶段
-	JobBranch	int32	`csv:"JobBranch"`		//职业分支
-	AvatarId	int32	`csv:"AvatarId"`		//模型id
-	NatureId	int32	`csv:"NatureId"`		//属性id
-	RaceId	int32	`csv:"RaceId"`		//种族id
-	HeadId	string	`csv:"HeadId"`		//头像id
-	Avatar	string	`csv:"Avatar"`		//纸娃娃
-	AvatarGray	string	`csv:"AvatarGray"`		//纸娃娃简影
-	JobIcon2	string	`csv:"JobIcon2"`		//职业图标2
-	PostId	int32	`csv:"PostId"`		//显示顺位
-	Position	int32	`csv:"Position"`		//站位
-	Hp	int32	`csv:"Hp"`		//初始生命
-	Sp	int32	`csv:"Sp"`		//初始蓝量
-	Atk	int32	`csv:"Atk"`		//初始物攻
-	Matk	int32	`csv:"Matk"`		//初始魔攻
-	Def	int32	`csv:"Def"`		//初始物防
-	Mdef	int32	`csv:"Mdef"`		//初始魔防
-	Hit	int32	`csv:"Hit"`		//初始命中
-	Dodge	int32	`csv:"Dodge"`		//初始闪避
-	Crit	int32	`csv:"Crit"`		//初始暴击
-	Ten	int32	`csv:"Ten"`		//初始韧性
-	StrRate	int32	`csv:"StrRate"`		//STR成长率
-	IntRate	int32	`csv:"IntRate"`		//INT成长率
-	AgiRate	int32	`csv:"AgiRate"`		//AGI成长率
-	DexRate	int32	`csv:"DexRate"`		//DEX成长率
-	LucRate	int32	`csv:"LucRate"`		//LUC成长率
-	ViteRate	int32	`csv:"ViteRate"`		//VIT成长率
-	Aspd	int32	`csv:"Aspd"`		//攻速
-	NormalSkillIds	[]string	`csv:"NormalSkillIds"`		//普攻技能id
-	SkillIds	[]string	`csv:"SkillIds"`		//默认技能id
-	Chip	string	`csv:"Chip"`		//重复分解
-	InitialSkill	int32	`csv:"InitialSkill"`		//初始技能id
-	BeforeJobId	int32	`csv:"BeforeJobId"`		//上阶职业
-	AfterJobId	[]string	`csv:"AfterJobId"`		//下阶职业
-	ChangeCond	[]string	`csv:"ChangeCond"`		//转职条件
-	ItemCost	[]string	`csv:"ItemCost"`		//消耗道具
-	InitFightPower	int32	`csv:"InitFightPower"`		//初始战力
-	AlternativeSkills	[]string	`csv:"AlternativeSkills"`		//备用技能id
-	ParterJob	int32	`csv:"ParterJob"`		//伙伴转职索引
-	AddPoint	[]string	`csv:"AddPoint"`		//推荐加点比例
+var ParterCfgLoader map[int32]*ParterCfg
+
+type ParterCfg struct {
+	ParterId          int32    `csv:"ParterId"`          //佣兵ID
+	Desc              string   `csv:"Desc"`              //描述
+	JobName           string   `csv:"JobName"`           //职业名字
+	JobIcon           string   `csv:"JobIcon"`           //职业图标
+	JobType           int32    `csv:"JobType"`           //职业类型
+	JobStage          int32    `csv:"JobStage"`          //职业阶段
+	JobBranch         int32    `csv:"JobBranch"`         //职业分支
+	AvatarId          int32    `csv:"AvatarId"`          //模型id
+	NatureId          int32    `csv:"NatureId"`          //属性id
+	RaceId            int32    `csv:"RaceId"`            //种族id
+	HeadId            string   `csv:"HeadId"`            //头像id
+	Avatar            string   `csv:"Avatar"`            //纸娃娃
+	AvatarGray        string   `csv:"AvatarGray"`        //纸娃娃简影
+	JobIcon2          string   `csv:"JobIcon2"`          //职业图标2
+	PostId            int32    `csv:"PostId"`            //显示顺位
+	Position          int32    `csv:"Position"`          //站位
+	Hp                int32    `csv:"Hp"`                //初始生命
+	Sp                int32    `csv:"Sp"`                //初始蓝量
+	Atk               int32    `csv:"Atk"`               //初始物攻
+	Matk              int32    `csv:"Matk"`              //初始魔攻
+	Def               int32    `csv:"Def"`               //初始物防
+	Mdef              int32    `csv:"Mdef"`              //初始魔防
+	Hit               int32    `csv:"Hit"`               //初始命中
+	Dodge             int32    `csv:"Dodge"`             //初始闪避
+	Crit              int32    `csv:"Crit"`              //初始暴击
+	Ten               int32    `csv:"Ten"`               //初始韧性
+	StrRate           int32    `csv:"StrRate"`           //STR成长率
+	IntRate           int32    `csv:"IntRate"`           //INT成长率
+	AgiRate           int32    `csv:"AgiRate"`           //AGI成长率
+	DexRate           int32    `csv:"DexRate"`           //DEX成长率
+	LucRate           int32    `csv:"LucRate"`           //LUC成长率
+	ViteRate          int32    `csv:"ViteRate"`          //VIT成长率
+	Aspd              int32    `csv:"Aspd"`              //攻速
+	NormalSkillIds    []string `csv:"NormalSkillIds"`    //普攻技能id
+	SkillIds          []string `csv:"SkillIds"`          //默认技能id
+	Chip              string   `csv:"Chip"`              //重复分解
+	InitialSkill      int32    `csv:"InitialSkill"`      //初始技能id
+	BeforeJobId       int32    `csv:"BeforeJobId"`       //上阶职业
+	AfterJobId        []string `csv:"AfterJobId"`        //下阶职业
+	ChangeCond        []string `csv:"ChangeCond"`        //转职条件
+	ItemCost          []string `csv:"ItemCost"`          //消耗道具
+	InitFightPower    int32    `csv:"InitFightPower"`    //初始战力
+	AlternativeSkills []string `csv:"AlternativeSkills"` //备用技能id
+	ParterJob         int32    `csv:"ParterJob"`         //伙伴转职索引
+	AddPoint          []string `csv:"AddPoint"`          //推荐加点比例
 }
 }
+
 func ParterCfgLoad(path string) {
 func ParterCfgLoad(path string) {
 	cfg := []*ParterCfg{}
 	cfg := []*ParterCfg{}
 	ParterCfgLoader = map[int32]*ParterCfg{}
 	ParterCfgLoader = map[int32]*ParterCfg{}
-	loadCsvCfg(path + "ParterCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ParterCfg.csv", &cfg)
+	for _, row := range cfg {
 		ParterCfgLoader[row.ParterId] = row
 		ParterCfgLoader[row.ParterId] = row
 	}
 	}
 }
 }
 
 
-var ParterProgressCfgLoader  map[int32]*ParterProgressCfg
-type ParterProgressCfg struct{
-	Id	int32	`csv:"Id"`		//佣兵ID
-	Times	int32	`csv:"Times"`		//进阶上限(次)
-	CostMoney	[]string	`csv:"CostMoney"`		//消耗银币
-	CostStone	[]string	`csv:"CostStone"`		//消耗天使之泪
-	AddLv	[]string	`csv:"AddLv"`		//提高等级上限
-	Attribute1	[]string	`csv:"Attribute1"`		//进阶1增加属性
-	Attribute2	[]string	`csv:"Attribute2"`		//进阶2增加属性
-	Attribute3	[]string	`csv:"Attribute3"`		//进阶3增加属性
-	Attribute4	[]string	`csv:"Attribute4"`		//进阶4增加属性
-	Attribute5	[]string	`csv:"Attribute5"`		//进阶5增加属性
-	Attribute6	[]string	`csv:"Attribute6"`		//进阶6增加属性
-	Attribute7	[]string	`csv:"Attribute7"`		//进阶7增加属性
-	Attribute8	[]string	`csv:"Attribute8"`		//进阶8增加属性
-	Attribute9	[]string	`csv:"Attribute9"`		//进阶9增加属性
-	Attribute10	[]string	`csv:"Attribute10"`		//进阶10增加属性
-	Attribute11	[]string	`csv:"Attribute11"`		//进阶11增加属性
-	Attribute12	[]string	`csv:"Attribute12"`		//进阶12增加属性
-	Attribute13	[]string	`csv:"Attribute13"`		//进阶13增加属性
-	Attribute14	[]string	`csv:"Attribute14"`		//进阶14增加属性
-	Attribute15	[]string	`csv:"Attribute15"`		//进阶15增加属性
-	BreachTimes	int32	`csv:"BreachTimes"`		//伙伴突破次数
-	BreachAddLv	[]string	`csv:"BreachAddLv"`		//突破获得等级
-	BreachMoney	[]string	`csv:"BreachMoney"`		//突破银币
-	BreachCost	[]string	`csv:"BreachCost"`		//突破材料
-	BreachAttribute1	[]string	`csv:"BreachAttribute1"`		//突破1增加属性
-	BreachAttribute2	[]string	`csv:"BreachAttribute2"`		//突破2增加属性
-	BreachAttribute3	[]string	`csv:"BreachAttribute3"`		//突破3增加属性
-	BreachAttribute4	[]string	`csv:"BreachAttribute4"`		//突破4增加属性
-	BreachAttribute5	[]string	`csv:"BreachAttribute5"`		//突破5增加属性
-	BreachAttribute6	[]string	`csv:"BreachAttribute6"`		//突破6增加属性
-	BreachAttribute7	[]string	`csv:"BreachAttribute7"`		//突破7增加属性
-	BreachAttribute8	[]string	`csv:"BreachAttribute8"`		//突破8增加属性
-	BreachAttribute9	[]string	`csv:"BreachAttribute9"`		//突破9增加属性
-	BreachAttribute10	[]string	`csv:"BreachAttribute10"`		//突破10增加属性
-	BreachAttribute11	[]string	`csv:"BreachAttribute11"`		//突破11增加属性
-	BreachAttribute12	[]string	`csv:"BreachAttribute12"`		//突破12增加属性
-	BreachAttribute13	[]string	`csv:"BreachAttribute13"`		//突破13增加属性
-	BreachAttribute14	[]string	`csv:"BreachAttribute14"`		//突破14增加属性
-	BreachAttribute15	[]string	`csv:"BreachAttribute15"`		//突破15增加属性
+var ParterProgressCfgLoader map[int32]*ParterProgressCfg
+
+type ParterProgressCfg struct {
+	Id                int32    `csv:"Id"`                //佣兵ID
+	Times             int32    `csv:"Times"`             //进阶上限(次)
+	CostMoney         []string `csv:"CostMoney"`         //消耗银币
+	CostStone         []string `csv:"CostStone"`         //消耗天使之泪
+	AddLv             []string `csv:"AddLv"`             //提高等级上限
+	Attribute1        []string `csv:"Attribute1"`        //进阶1增加属性
+	Attribute2        []string `csv:"Attribute2"`        //进阶2增加属性
+	Attribute3        []string `csv:"Attribute3"`        //进阶3增加属性
+	Attribute4        []string `csv:"Attribute4"`        //进阶4增加属性
+	Attribute5        []string `csv:"Attribute5"`        //进阶5增加属性
+	Attribute6        []string `csv:"Attribute6"`        //进阶6增加属性
+	Attribute7        []string `csv:"Attribute7"`        //进阶7增加属性
+	Attribute8        []string `csv:"Attribute8"`        //进阶8增加属性
+	Attribute9        []string `csv:"Attribute9"`        //进阶9增加属性
+	Attribute10       []string `csv:"Attribute10"`       //进阶10增加属性
+	Attribute11       []string `csv:"Attribute11"`       //进阶11增加属性
+	Attribute12       []string `csv:"Attribute12"`       //进阶12增加属性
+	Attribute13       []string `csv:"Attribute13"`       //进阶13增加属性
+	Attribute14       []string `csv:"Attribute14"`       //进阶14增加属性
+	Attribute15       []string `csv:"Attribute15"`       //进阶15增加属性
+	BreachTimes       int32    `csv:"BreachTimes"`       //伙伴突破次数
+	BreachAddLv       []string `csv:"BreachAddLv"`       //突破获得等级
+	BreachMoney       []string `csv:"BreachMoney"`       //突破银币
+	BreachCost        []string `csv:"BreachCost"`        //突破材料
+	BreachAttribute1  []string `csv:"BreachAttribute1"`  //突破1增加属性
+	BreachAttribute2  []string `csv:"BreachAttribute2"`  //突破2增加属性
+	BreachAttribute3  []string `csv:"BreachAttribute3"`  //突破3增加属性
+	BreachAttribute4  []string `csv:"BreachAttribute4"`  //突破4增加属性
+	BreachAttribute5  []string `csv:"BreachAttribute5"`  //突破5增加属性
+	BreachAttribute6  []string `csv:"BreachAttribute6"`  //突破6增加属性
+	BreachAttribute7  []string `csv:"BreachAttribute7"`  //突破7增加属性
+	BreachAttribute8  []string `csv:"BreachAttribute8"`  //突破8增加属性
+	BreachAttribute9  []string `csv:"BreachAttribute9"`  //突破9增加属性
+	BreachAttribute10 []string `csv:"BreachAttribute10"` //突破10增加属性
+	BreachAttribute11 []string `csv:"BreachAttribute11"` //突破11增加属性
+	BreachAttribute12 []string `csv:"BreachAttribute12"` //突破12增加属性
+	BreachAttribute13 []string `csv:"BreachAttribute13"` //突破13增加属性
+	BreachAttribute14 []string `csv:"BreachAttribute14"` //突破14增加属性
+	BreachAttribute15 []string `csv:"BreachAttribute15"` //突破15增加属性
 }
 }
+
 func ParterProgressCfgLoad(path string) {
 func ParterProgressCfgLoad(path string) {
 	cfg := []*ParterProgressCfg{}
 	cfg := []*ParterProgressCfg{}
 	ParterProgressCfgLoader = map[int32]*ParterProgressCfg{}
 	ParterProgressCfgLoader = map[int32]*ParterProgressCfg{}
-	loadCsvCfg(path + "ParterProgressCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ParterProgressCfg.csv", &cfg)
+	for _, row := range cfg {
 		ParterProgressCfgLoader[row.Id] = row
 		ParterProgressCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ParterSkillTreeCfgLoader  map[int32]*ParterSkillTreeCfg
-type ParterSkillTreeCfg struct{
-	SkillId	int32	`csv:"SkillId"`		//技能ID
-	SkillType	int32	`csv:"SkillType"`		//技能类型
-	MaxLv	int32	`csv:"MaxLv"`		//技能等级上限
-	SkillQuality	int32	`csv:"SkillQuality"`		//技能品质
-	JobType	int32	`csv:"JobType"`		//职业类型
-	JobBranch	int32	`csv:"JobBranch"`		//职业分支
-	JobStage	int32	`csv:"JobStage"`		//职业阶段
-	ParterID	int32	`csv:"ParterID"`		//对应伙伴
-	OpenLevel	int32	`csv:"OpenLevel"`		//解锁伙伴等级要求
-	OpenNeedCost	[]string	`csv:"OpenNeedCost"`		//解锁需求
-	Pos	int32	`csv:"Pos"`		//技能树位置件
-	Order	int32	`csv:"order"`		//技能排序
-	SuperSkill	[]string	`csv:"SuperSkill"`		//进阶技能
-	BeforeSkill	int32	`csv:"beforeSkill"`		//下阶技能
-	SkillBranch	int32	`csv:"SkillBranch"`		//进阶职业阶段
-	PressPoint	int32	`csv:"PressPoint"`		//技能压制值
-	StartPressPoint	int32	`csv:"StartPressPoint"`		//技能原压制值
+var ParterSkillTreeCfgLoader map[int32]*ParterSkillTreeCfg
+
+type ParterSkillTreeCfg struct {
+	SkillId         int32    `csv:"SkillId"`         //技能ID
+	SkillType       int32    `csv:"SkillType"`       //技能类型
+	MaxLv           int32    `csv:"MaxLv"`           //技能等级上限
+	SkillQuality    int32    `csv:"SkillQuality"`    //技能品质
+	JobType         int32    `csv:"JobType"`         //职业类型
+	JobBranch       int32    `csv:"JobBranch"`       //职业分支
+	JobStage        int32    `csv:"JobStage"`        //职业阶段
+	ParterID        int32    `csv:"ParterID"`        //对应伙伴
+	OpenLevel       int32    `csv:"OpenLevel"`       //解锁伙伴等级要求
+	OpenNeedCost    []string `csv:"OpenNeedCost"`    //解锁需求
+	Pos             int32    `csv:"Pos"`             //技能树位置件
+	Order           int32    `csv:"order"`           //技能排序
+	SuperSkill      []string `csv:"SuperSkill"`      //进阶技能
+	BeforeSkill     int32    `csv:"beforeSkill"`     //下阶技能
+	SkillBranch     int32    `csv:"SkillBranch"`     //进阶职业阶段
+	PressPoint      int32    `csv:"PressPoint"`      //技能压制值
+	StartPressPoint int32    `csv:"StartPressPoint"` //技能原压制值
 }
 }
+
 func ParterSkillTreeCfgLoad(path string) {
 func ParterSkillTreeCfgLoad(path string) {
 	cfg := []*ParterSkillTreeCfg{}
 	cfg := []*ParterSkillTreeCfg{}
 	ParterSkillTreeCfgLoader = map[int32]*ParterSkillTreeCfg{}
 	ParterSkillTreeCfgLoader = map[int32]*ParterSkillTreeCfg{}
-	loadCsvCfg(path + "ParterSkillTreeCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ParterSkillTreeCfg.csv", &cfg)
+	for _, row := range cfg {
 		ParterSkillTreeCfgLoader[row.SkillId] = row
 		ParterSkillTreeCfgLoader[row.SkillId] = row
 	}
 	}
 }
 }
 
 
-var PassCheckCfgLoader  map[int32]*PassCheckCfg
-type PassCheckCfg struct{
-	Lv	int32	`csv:"Lv"`		//等级
-	RMB	float32	`csv:"RMB"`		//价格
-	Automatic	int32	`csv:"Automatic"`		//自动挑战
-	AddLeadExp	int32	`csv:"AddLeadExp"`		//时光助力主角经验提升万分比
-	AddAttrLevel	[]string	`csv:"AddAttrLevel"`		//增加主角属性
+var PassCheckCfgLoader map[int32]*PassCheckCfg
+
+type PassCheckCfg struct {
+	Lv           int32    `csv:"Lv"`           //等级
+	RMB          float32  `csv:"RMB"`          //价格
+	Automatic    int32    `csv:"Automatic"`    //自动挑战
+	AddLeadExp   int32    `csv:"AddLeadExp"`   //时光助力主角经验提升万分比
+	AddAttrLevel []string `csv:"AddAttrLevel"` //增加主角属性
 }
 }
+
 func PassCheckCfgLoad(path string) {
 func PassCheckCfgLoad(path string) {
 	cfg := []*PassCheckCfg{}
 	cfg := []*PassCheckCfg{}
 	PassCheckCfgLoader = map[int32]*PassCheckCfg{}
 	PassCheckCfgLoader = map[int32]*PassCheckCfg{}
-	loadCsvCfg(path + "PassCheckCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"PassCheckCfg.csv", &cfg)
+	for _, row := range cfg {
 		PassCheckCfgLoader[row.Lv] = row
 		PassCheckCfgLoader[row.Lv] = row
 	}
 	}
 }
 }
 
 
-var PassiveSkillCfgLoader  map[int32]*PassiveSkillCfg
-type PassiveSkillCfg struct{
-	SkillId	int32	`csv:"SkillId"`		//技能ID
-	AddAttributes	[]string	`csv:"AddAttributes"`		//增加属性
+var PassiveSkillCfgLoader map[int32]*PassiveSkillCfg
+
+type PassiveSkillCfg struct {
+	SkillId       int32    `csv:"SkillId"`       //技能ID
+	AddAttributes []string `csv:"AddAttributes"` //增加属性
 }
 }
+
 func PassiveSkillCfgLoad(path string) {
 func PassiveSkillCfgLoad(path string) {
 	cfg := []*PassiveSkillCfg{}
 	cfg := []*PassiveSkillCfg{}
 	PassiveSkillCfgLoader = map[int32]*PassiveSkillCfg{}
 	PassiveSkillCfgLoader = map[int32]*PassiveSkillCfg{}
-	loadCsvCfg(path + "PassiveSkillCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"PassiveSkillCfg.csv", &cfg)
+	for _, row := range cfg {
 		PassiveSkillCfgLoader[row.SkillId] = row
 		PassiveSkillCfgLoader[row.SkillId] = row
 	}
 	}
 }
 }
 
 
-var PetBattleCfgLoader  map[int32]*PetBattleCfg
-type PetBattleCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	AvatarId	int32	`csv:"AvatarId"`		//模型id
-	JobType	int32	`csv:"JobType"`		//宠物职业
-	Fame	int32	`csv:"Fame"`		//头像框
-	NatureType	int32	`csv:"NatureType"`		//属性
-	Hp	float32	`csv:"Hp"`		//生命
-	Sp	float32	`csv:"Sp"`		//蓝量
-	Atk	float32	`csv:"Atk"`		//物攻
-	Matk	float32	`csv:"Matk"`		//魔攻
-	Skill1	int32	`csv:"Skill1"`		//技能1
-	Skill1Rate	[]string	`csv:"Skill1Rate"`		//技能1发动概率
-	Skill2	int32	`csv:"Skill2"`		//技能2
-	Skill2Rate	[]string	`csv:"Skill2Rate"`		//技能2发动概率
-	Skill3	int32	`csv:"Skill3"`		//技能3
-	Skill3Rate	[]string	`csv:"Skill3Rate"`		//技能3发动概率
-	Skill4	int32	`csv:"Skill4"`		//技能4
+var PetBattleCfgLoader map[int32]*PetBattleCfg
+
+type PetBattleCfg struct {
+	Id         int32    `csv:"Id"`         //唯一id
+	AvatarId   int32    `csv:"AvatarId"`   //模型id
+	JobType    int32    `csv:"JobType"`    //宠物职业
+	Fame       int32    `csv:"Fame"`       //头像框
+	NatureType int32    `csv:"NatureType"` //属性
+	Hp         float32  `csv:"Hp"`         //生命
+	Sp         float32  `csv:"Sp"`         //蓝量
+	Atk        float32  `csv:"Atk"`        //物攻
+	Matk       float32  `csv:"Matk"`       //魔攻
+	Skill1     int32    `csv:"Skill1"`     //技能1
+	Skill1Rate []string `csv:"Skill1Rate"` //技能1发动概率
+	Skill2     int32    `csv:"Skill2"`     //技能2
+	Skill2Rate []string `csv:"Skill2Rate"` //技能2发动概率
+	Skill3     int32    `csv:"Skill3"`     //技能3
+	Skill3Rate []string `csv:"Skill3Rate"` //技能3发动概率
+	Skill4     int32    `csv:"Skill4"`     //技能4
 }
 }
+
 func PetBattleCfgLoad(path string) {
 func PetBattleCfgLoad(path string) {
 	cfg := []*PetBattleCfg{}
 	cfg := []*PetBattleCfg{}
 	PetBattleCfgLoader = map[int32]*PetBattleCfg{}
 	PetBattleCfgLoader = map[int32]*PetBattleCfg{}
-	loadCsvCfg(path + "PetBattleCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"PetBattleCfg.csv", &cfg)
+	for _, row := range cfg {
 		PetBattleCfgLoader[row.Id] = row
 		PetBattleCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var PetCfgLoader  map[int32]*PetCfg
-type PetCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	AvatarId	int32	`csv:"AvatarId"`		//模型id
-	JobType	int32	`csv:"JobType"`		//宠物职业
-	Quality	int32	`csv:"Quality"`		//品质
-	Fame	int32	`csv:"Fame"`		//头像框
-	NatureType	int32	`csv:"NatureType"`		//属性
-	ConversionRate	int32	`csv:"ConversionRate"`		//属性转化率
-	Pos	int32	`csv:"Pos"`		//虚拟站位
-	Hp	float32	`csv:"Hp"`		//生命
-	Sp	float32	`csv:"Sp"`		//蓝量
-	Atk	float32	`csv:"Atk"`		//物攻
-	Matk	float32	`csv:"Matk"`		//魔攻
-	Def	float32	`csv:"Def"`		//物防
-	Mdef	float32	`csv:"Mdef"`		//魔防
-	Hit	float32	`csv:"Hit"`		//命中
-	Dodge	float32	`csv:"Dodge"`		//闪避
-	Crit	float32	`csv:"Crit"`		//暴击
-	Ten	float32	`csv:"Ten"`		//韧性
-	AttackSpeed	float32	`csv:"AttackSpeed"`		//攻击速度
-	HpRate	int32	`csv:"HpRate"`		//生命系数
-	SpRate	int32	`csv:"SpRate"`		//蓝量系数
-	AtkRate	int32	`csv:"AtkRate"`		//物攻系数
-	MatkRate	int32	`csv:"MatkRate"`		//魔攻系数
-	DefRate	int32	`csv:"DefRate"`		//物防系数
-	MdefRate	int32	`csv:"MdefRate"`		//魔防系数
-	HitRate	int32	`csv:"HitRate"`		//命中系数
-	DodgeRate	int32	`csv:"DodgeRate"`		//闪避系数
-	CritRate	int32	`csv:"CritRate"`		//暴击系数
-	TenRate	int32	`csv:"TenRate"`		//韧性系数
-	NormalSkillIds	[]string	`csv:"NormalSkillIds"`		//普攻技能id
-	Skill1	int32	`csv:"Skill1"`		//技能1
-	Skill1Rate	[]string	`csv:"Skill1Rate"`		//技能1发动概率
-	Skill2	int32	`csv:"Skill2"`		//技能2
-	Skill2Rate	[]string	`csv:"Skill2Rate"`		//技能2发动概率
-	Skill3	int32	`csv:"Skill3"`		//技能3
-	Skill3Rate	[]string	`csv:"Skill3Rate"`		//技能3发动概率
-	Skill4	int32	`csv:"Skill4"`		//技能4
-	Skill4Rate	[]string	`csv:"Skill4Rate"`		//技能4发动概率
-	EmptySkill	int32	`csv:"EmptySkill"`		//备用技能
-	PetReward	[]string	`csv:"PetReward"`		//收集奖励
-	Contract	int32	`csv:"contract"`		//宠物契约继承属性
-	Understand	int32	`csv:"understand"`		//领悟额外增加继承属性
+var PetCfgLoader map[int32]*PetCfg
+
+type PetCfg struct {
+	Id             int32    `csv:"Id"`             //唯一id
+	AvatarId       int32    `csv:"AvatarId"`       //模型id
+	JobType        int32    `csv:"JobType"`        //宠物职业
+	Quality        int32    `csv:"Quality"`        //品质
+	Fame           int32    `csv:"Fame"`           //头像框
+	NatureType     int32    `csv:"NatureType"`     //属性
+	ConversionRate int32    `csv:"ConversionRate"` //属性转化率
+	Pos            int32    `csv:"Pos"`            //虚拟站位
+	Hp             float32  `csv:"Hp"`             //生命
+	Sp             float32  `csv:"Sp"`             //蓝量
+	Atk            float32  `csv:"Atk"`            //物攻
+	Matk           float32  `csv:"Matk"`           //魔攻
+	Def            float32  `csv:"Def"`            //物防
+	Mdef           float32  `csv:"Mdef"`           //魔防
+	Hit            float32  `csv:"Hit"`            //命中
+	Dodge          float32  `csv:"Dodge"`          //闪避
+	Crit           float32  `csv:"Crit"`           //暴击
+	Ten            float32  `csv:"Ten"`            //韧性
+	AttackSpeed    float32  `csv:"AttackSpeed"`    //攻击速度
+	HpRate         int32    `csv:"HpRate"`         //生命系数
+	SpRate         int32    `csv:"SpRate"`         //蓝量系数
+	AtkRate        int32    `csv:"AtkRate"`        //物攻系数
+	MatkRate       int32    `csv:"MatkRate"`       //魔攻系数
+	DefRate        int32    `csv:"DefRate"`        //物防系数
+	MdefRate       int32    `csv:"MdefRate"`       //魔防系数
+	HitRate        int32    `csv:"HitRate"`        //命中系数
+	DodgeRate      int32    `csv:"DodgeRate"`      //闪避系数
+	CritRate       int32    `csv:"CritRate"`       //暴击系数
+	TenRate        int32    `csv:"TenRate"`        //韧性系数
+	NormalSkillIds []string `csv:"NormalSkillIds"` //普攻技能id
+	Skill1         int32    `csv:"Skill1"`         //技能1
+	Skill1Rate     []string `csv:"Skill1Rate"`     //技能1发动概率
+	Skill2         int32    `csv:"Skill2"`         //技能2
+	Skill2Rate     []string `csv:"Skill2Rate"`     //技能2发动概率
+	Skill3         int32    `csv:"Skill3"`         //技能3
+	Skill3Rate     []string `csv:"Skill3Rate"`     //技能3发动概率
+	Skill4         int32    `csv:"Skill4"`         //技能4
+	Skill4Rate     []string `csv:"Skill4Rate"`     //技能4发动概率
+	EmptySkill     int32    `csv:"EmptySkill"`     //备用技能
+	PetReward      []string `csv:"PetReward"`      //收集奖励
+	Contract       int32    `csv:"contract"`       //宠物契约继承属性
+	Understand     int32    `csv:"understand"`     //领悟额外增加继承属性
 }
 }
+
 func PetCfgLoad(path string) {
 func PetCfgLoad(path string) {
 	cfg := []*PetCfg{}
 	cfg := []*PetCfg{}
 	PetCfgLoader = map[int32]*PetCfg{}
 	PetCfgLoader = map[int32]*PetCfg{}
-	loadCsvCfg(path + "PetCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"PetCfg.csv", &cfg)
+	for _, row := range cfg {
 		PetCfgLoader[row.Id] = row
 		PetCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var PetEquipCfgLoader  map[int32]*PetEquipCfg
-type PetEquipCfg struct{
-	Id	int32	`csv:"Id"`		//id
-	Type	int32	`csv:"Type"`		//格子编号
-	Quality	int32	`csv:"Quality"`		//品质
-	MaxLevel	int32	`csv:"MaxLevel"`		//最大等级
-	Advance	int32	`csv:"Advance"`		//进阶目标
-	AdvanceCost	[]string	`csv:"AdvanceCost"`		//进阶消耗
+var PetEquipCfgLoader map[int32]*PetEquipCfg
+
+type PetEquipCfg struct {
+	Id          int32    `csv:"Id"`          //id
+	Type        int32    `csv:"Type"`        //格子编号
+	Quality     int32    `csv:"Quality"`     //品质
+	MaxLevel    int32    `csv:"MaxLevel"`    //最大等级
+	Advance     int32    `csv:"Advance"`     //进阶目标
+	AdvanceCost []string `csv:"AdvanceCost"` //进阶消耗
 }
 }
+
 func PetEquipCfgLoad(path string) {
 func PetEquipCfgLoad(path string) {
 	cfg := []*PetEquipCfg{}
 	cfg := []*PetEquipCfg{}
 	PetEquipCfgLoader = map[int32]*PetEquipCfg{}
 	PetEquipCfgLoader = map[int32]*PetEquipCfg{}
-	loadCsvCfg(path + "PetEquipCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"PetEquipCfg.csv", &cfg)
+	for _, row := range cfg {
 		PetEquipCfgLoader[row.Id] = row
 		PetEquipCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var PetEquipExpCfgLoader  map[int32]*PetEquipExpCfg
-type PetEquipExpCfg struct{
-	Id	int32	`csv:"Id"`		//唯一ID
-	PetEquipLevel	int32	`csv:"PetEquipLevel"`		//印记等级
-	PetEquipID	int32	`csv:"PetEquipID"`		//印记ID
-	Cost	[]string	`csv:"Cost"`		//升级所需材料
-	Nature	[]string	`csv:"Nature"`		//属性
-	FightPower	int32	`csv:"FightPower"`		//战斗力
+var PetEquipExpCfgLoader map[int32]*PetEquipExpCfg
+
+type PetEquipExpCfg struct {
+	Id            int32    `csv:"Id"`            //唯一ID
+	PetEquipLevel int32    `csv:"PetEquipLevel"` //印记等级
+	PetEquipID    int32    `csv:"PetEquipID"`    //印记ID
+	Cost          []string `csv:"Cost"`          //升级所需材料
+	Nature        []string `csv:"Nature"`        //属性
+	FightPower    int32    `csv:"FightPower"`    //战斗力
 }
 }
+
 func PetEquipExpCfgLoad(path string) {
 func PetEquipExpCfgLoad(path string) {
 	cfg := []*PetEquipExpCfg{}
 	cfg := []*PetEquipExpCfg{}
 	PetEquipExpCfgLoader = map[int32]*PetEquipExpCfg{}
 	PetEquipExpCfgLoader = map[int32]*PetEquipExpCfg{}
-	loadCsvCfg(path + "PetEquipExpCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"PetEquipExpCfg.csv", &cfg)
+	for _, row := range cfg {
 		PetEquipExpCfgLoader[row.Id] = row
 		PetEquipExpCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var PetEquipSuitCfgLoader  map[int32]*PetEquipSuitCfg
-type PetEquipSuitCfg struct{
-	Id	int32	`csv:"Id"`		//id
-	Amount	[]string	`csv:"Amount"`		//激活数量
-	Suit	[]string	`csv:"Suit"`		//6件属性
+var PetEquipSuitCfgLoader map[int32]*PetEquipSuitCfg
+
+type PetEquipSuitCfg struct {
+	Id     int32    `csv:"Id"`     //id
+	Amount []string `csv:"Amount"` //激活数量
+	Suit   []string `csv:"Suit"`   //6件属性
 }
 }
+
 func PetEquipSuitCfgLoad(path string) {
 func PetEquipSuitCfgLoad(path string) {
 	cfg := []*PetEquipSuitCfg{}
 	cfg := []*PetEquipSuitCfg{}
 	PetEquipSuitCfgLoader = map[int32]*PetEquipSuitCfg{}
 	PetEquipSuitCfgLoader = map[int32]*PetEquipSuitCfg{}
-	loadCsvCfg(path + "PetEquipSuitCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"PetEquipSuitCfg.csv", &cfg)
+	for _, row := range cfg {
 		PetEquipSuitCfgLoader[row.Id] = row
 		PetEquipSuitCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var PetExpCfgLoader  map[int32]*PetExpCfg
-type PetExpCfg struct{
-	PetLevel	int32	`csv:"petLevel"`		//宠物等级
-	Experience1	int32	`csv:"experience1"`		//Normal升级所需经验
-	Experience2	int32	`csv:"experience2"`		//Mini升级所需经验
-	Experience3	int32	`csv:"experience3"`		//Mvp升级所需经验
-	CostMoney1	int32	`csv:"CostMoney1"`		//Normal升级所需银币
-	CostMoney2	int32	`csv:"CostMoney2"`		//Mini升级所需银币
-	CostMoney3	int32	`csv:"CostMoney3"`		//Mvp升级所需银币
-	Capacity1	int32	`csv:"Capacity1"`		//Normal战力
-	Capacity2	int32	`csv:"Capacity2"`		//Mini战力
-	Capacity3	int32	`csv:"Capacity3"`		//Mvp战力
+var PetExpCfgLoader map[int32]*PetExpCfg
+
+type PetExpCfg struct {
+	PetLevel    int32 `csv:"petLevel"`    //宠物等级
+	Experience1 int32 `csv:"experience1"` //Normal升级所需经验
+	Experience2 int32 `csv:"experience2"` //Mini升级所需经验
+	Experience3 int32 `csv:"experience3"` //Mvp升级所需经验
+	CostMoney1  int32 `csv:"CostMoney1"`  //Normal升级所需银币
+	CostMoney2  int32 `csv:"CostMoney2"`  //Mini升级所需银币
+	CostMoney3  int32 `csv:"CostMoney3"`  //Mvp升级所需银币
+	Capacity1   int32 `csv:"Capacity1"`   //Normal战力
+	Capacity2   int32 `csv:"Capacity2"`   //Mini战力
+	Capacity3   int32 `csv:"Capacity3"`   //Mvp战力
 }
 }
+
 func PetExpCfgLoad(path string) {
 func PetExpCfgLoad(path string) {
 	cfg := []*PetExpCfg{}
 	cfg := []*PetExpCfg{}
 	PetExpCfgLoader = map[int32]*PetExpCfg{}
 	PetExpCfgLoader = map[int32]*PetExpCfg{}
-	loadCsvCfg(path + "PetExpCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"PetExpCfg.csv", &cfg)
+	for _, row := range cfg {
 		PetExpCfgLoader[row.PetLevel] = row
 		PetExpCfgLoader[row.PetLevel] = row
 	}
 	}
 }
 }
 
 
-var PetpartnerCfgLoader  map[int32]*PetpartnerCfg
-type PetpartnerCfg struct{
-	Id	int32	`csv:"Id"`		//唯一id
-	Condition1	[]string	`csv:"Condition1"`		//激活条件1
-	Attribute1	[]string	`csv:"attribute1"`		//属性1
-	Capacity1	int32	`csv:"Capacity1"`		//战力1
-	AddHeroCap1	[]string	`csv:"AddHeroCap1"`		//战力1
-	Condition2	[]string	`csv:"Condition2"`		//激活条件2
-	Attribute2	[]string	`csv:"attribute2"`		//属性2
-	Capacity2	int32	`csv:"Capacity2"`		//战力2
-	AddHeroCap2	[]string	`csv:"AddHeroCap2"`		//战力2
-	Condition3	[]string	`csv:"Condition3"`		//激活条件3
-	Attribute3	[]string	`csv:"attribute3"`		//属性3
-	Capacity3	int32	`csv:"Capacity3"`		//战力3
-	AddHeroCap3	[]string	`csv:"AddHeroCap3"`		//战力3
+var PetpartnerCfgLoader map[int32]*PetpartnerCfg
+
+type PetpartnerCfg struct {
+	Id          int32    `csv:"Id"`          //唯一id
+	Condition1  []string `csv:"Condition1"`  //激活条件1
+	Attribute1  []string `csv:"attribute1"`  //属性1
+	Capacity1   int32    `csv:"Capacity1"`   //战力1
+	AddHeroCap1 []string `csv:"AddHeroCap1"` //战力1
+	Condition2  []string `csv:"Condition2"`  //激活条件2
+	Attribute2  []string `csv:"attribute2"`  //属性2
+	Capacity2   int32    `csv:"Capacity2"`   //战力2
+	AddHeroCap2 []string `csv:"AddHeroCap2"` //战力2
+	Condition3  []string `csv:"Condition3"`  //激活条件3
+	Attribute3  []string `csv:"attribute3"`  //属性3
+	Capacity3   int32    `csv:"Capacity3"`   //战力3
+	AddHeroCap3 []string `csv:"AddHeroCap3"` //战力3
 }
 }
+
 func PetpartnerCfgLoad(path string) {
 func PetpartnerCfgLoad(path string) {
 	cfg := []*PetpartnerCfg{}
 	cfg := []*PetpartnerCfg{}
 	PetpartnerCfgLoader = map[int32]*PetpartnerCfg{}
 	PetpartnerCfgLoader = map[int32]*PetpartnerCfg{}
-	loadCsvCfg(path + "PetpartnerCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"PetpartnerCfg.csv", &cfg)
+	for _, row := range cfg {
 		PetpartnerCfgLoader[row.Id] = row
 		PetpartnerCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var PetProgressCfgLoader  map[int32]*PetProgressCfg
-type PetProgressCfg struct{
-	Id	int32	`csv:"Id"`		//宠物ID
-	CostMoney	[]string	`csv:"CostMoney"`		//消耗银币
-	AddFight	[]string	`csv:"AddFight"`		//进阶增加战力
-	Attribute1	[]string	`csv:"Attribute1"`		//1阶增加属性
-	AttributeRateAdd1	[]string	`csv:"AttributeRateAdd1"`		//1阶成长率
-	Condition11	[]string	`csv:"Condition11"`		//1阶条件1
-	Condition12	[]string	`csv:"Condition12"`		//1阶条件2
-	Attribute2	[]string	`csv:"Attribute2"`		//进阶2增加属性
-	AttributeRateAdd2	[]string	`csv:"AttributeRateAdd2"`		//进阶2成长率
-	Condition21	[]string	`csv:"Condition21"`		//2阶条件1
-	Condition22	[]string	`csv:"Condition22"`		//2阶条件2
-	Attribute3	[]string	`csv:"Attribute3"`		//进阶3增加属性
-	AttributeRateAdd3	[]string	`csv:"AttributeRateAdd3"`		//进阶3成长率
-	Condition31	[]string	`csv:"Condition31"`		//3阶条件1
-	Condition32	[]string	`csv:"Condition32"`		//3阶条件2
-	Attribute4	[]string	`csv:"Attribute4"`		//进阶4增加属性
-	AttributeRateAdd4	[]string	`csv:"AttributeRateAdd4"`		//进阶4成长率
-	Condition41	[]string	`csv:"Condition41"`		//4阶条件1
-	Condition42	[]string	`csv:"Condition42"`		//4阶条件2
-	Attribute5	[]string	`csv:"Attribute5"`		//进阶5增加属性
-	AttributeRateAdd5	[]string	`csv:"AttributeRateAdd5"`		//进阶5成长率
-	Condition51	[]string	`csv:"Condition51"`		//5阶条件1
-	Condition52	[]string	`csv:"Condition52"`		//5阶条件2
-	Attribute6	[]string	`csv:"Attribute6"`		//进阶6增加属性
-	AttributeRateAdd6	[]string	`csv:"AttributeRateAdd6"`		//进阶6成长率
-	Condition61	[]string	`csv:"Condition61"`		//6阶条件1
-	Condition62	[]string	`csv:"Condition62"`		//6阶条件2
-	Attribute7	[]string	`csv:"Attribute7"`		//进阶7增加属性
-	AttributeRateAdd7	[]string	`csv:"AttributeRateAdd7"`		//进阶7成长率
-	Condition71	[]string	`csv:"Condition71"`		//7阶条件1
-	Condition72	[]string	`csv:"Condition72"`		//7阶条件2
-	Attribute8	[]string	`csv:"Attribute8"`		//进阶8增加属性
-	AttributeRateAdd8	[]string	`csv:"AttributeRateAdd8"`		//进阶8成长率
-	Condition81	[]string	`csv:"Condition81"`		//8阶条件1
-	Condition82	[]string	`csv:"Condition82"`		//8阶条件2
-	Attribute9	[]string	`csv:"Attribute9"`		//进阶9增加属性
-	AttributeRateAdd9	[]string	`csv:"AttributeRateAdd9"`		//进阶9成长率
-	Condition91	[]string	`csv:"Condition91"`		//9阶条件1
-	Condition92	[]string	`csv:"Condition92"`		//9阶条件2
-	Attribute10	[]string	`csv:"Attribute10"`		//进阶10增加属性
-	AttributeRateAdd10	[]string	`csv:"AttributeRateAdd10"`		//进阶10成长率
-	Condition101	[]string	`csv:"Condition101"`		//10阶条件1
-	Condition102	[]string	`csv:"Condition102"`		//10阶条件2
+var PetProgressCfgLoader map[int32]*PetProgressCfg
+
+type PetProgressCfg struct {
+	Id                 int32    `csv:"Id"`                 //宠物ID
+	CostMoney          []string `csv:"CostMoney"`          //消耗银币
+	AddFight           []string `csv:"AddFight"`           //进阶增加战力
+	Attribute1         []string `csv:"Attribute1"`         //1阶增加属性
+	AttributeRateAdd1  []string `csv:"AttributeRateAdd1"`  //1阶成长率
+	Condition11        []string `csv:"Condition11"`        //1阶条件1
+	Condition12        []string `csv:"Condition12"`        //1阶条件2
+	Attribute2         []string `csv:"Attribute2"`         //进阶2增加属性
+	AttributeRateAdd2  []string `csv:"AttributeRateAdd2"`  //进阶2成长率
+	Condition21        []string `csv:"Condition21"`        //2阶条件1
+	Condition22        []string `csv:"Condition22"`        //2阶条件2
+	Attribute3         []string `csv:"Attribute3"`         //进阶3增加属性
+	AttributeRateAdd3  []string `csv:"AttributeRateAdd3"`  //进阶3成长率
+	Condition31        []string `csv:"Condition31"`        //3阶条件1
+	Condition32        []string `csv:"Condition32"`        //3阶条件2
+	Attribute4         []string `csv:"Attribute4"`         //进阶4增加属性
+	AttributeRateAdd4  []string `csv:"AttributeRateAdd4"`  //进阶4成长率
+	Condition41        []string `csv:"Condition41"`        //4阶条件1
+	Condition42        []string `csv:"Condition42"`        //4阶条件2
+	Attribute5         []string `csv:"Attribute5"`         //进阶5增加属性
+	AttributeRateAdd5  []string `csv:"AttributeRateAdd5"`  //进阶5成长率
+	Condition51        []string `csv:"Condition51"`        //5阶条件1
+	Condition52        []string `csv:"Condition52"`        //5阶条件2
+	Attribute6         []string `csv:"Attribute6"`         //进阶6增加属性
+	AttributeRateAdd6  []string `csv:"AttributeRateAdd6"`  //进阶6成长率
+	Condition61        []string `csv:"Condition61"`        //6阶条件1
+	Condition62        []string `csv:"Condition62"`        //6阶条件2
+	Attribute7         []string `csv:"Attribute7"`         //进阶7增加属性
+	AttributeRateAdd7  []string `csv:"AttributeRateAdd7"`  //进阶7成长率
+	Condition71        []string `csv:"Condition71"`        //7阶条件1
+	Condition72        []string `csv:"Condition72"`        //7阶条件2
+	Attribute8         []string `csv:"Attribute8"`         //进阶8增加属性
+	AttributeRateAdd8  []string `csv:"AttributeRateAdd8"`  //进阶8成长率
+	Condition81        []string `csv:"Condition81"`        //8阶条件1
+	Condition82        []string `csv:"Condition82"`        //8阶条件2
+	Attribute9         []string `csv:"Attribute9"`         //进阶9增加属性
+	AttributeRateAdd9  []string `csv:"AttributeRateAdd9"`  //进阶9成长率
+	Condition91        []string `csv:"Condition91"`        //9阶条件1
+	Condition92        []string `csv:"Condition92"`        //9阶条件2
+	Attribute10        []string `csv:"Attribute10"`        //进阶10增加属性
+	AttributeRateAdd10 []string `csv:"AttributeRateAdd10"` //进阶10成长率
+	Condition101       []string `csv:"Condition101"`       //10阶条件1
+	Condition102       []string `csv:"Condition102"`       //10阶条件2
 }
 }
+
 func PetProgressCfgLoad(path string) {
 func PetProgressCfgLoad(path string) {
 	cfg := []*PetProgressCfg{}
 	cfg := []*PetProgressCfg{}
 	PetProgressCfgLoader = map[int32]*PetProgressCfg{}
 	PetProgressCfgLoader = map[int32]*PetProgressCfg{}
-	loadCsvCfg(path + "PetProgressCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"PetProgressCfg.csv", &cfg)
+	for _, row := range cfg {
 		PetProgressCfgLoader[row.Id] = row
 		PetProgressCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var PresspointPvPCfgLoader  map[int32]*PresspointPvPCfg
-type PresspointPvPCfg struct{
-	Id	int32	`csv:"Id"`		//ID挡位
-	TriggerConditions	int32	`csv:"TriggerConditions"`		//差值
-	Buffid	[]string	`csv:"buffid"`		//触发buff
+var PresspointPvPCfgLoader map[int32]*PresspointPvPCfg
+
+type PresspointPvPCfg struct {
+	Id                int32    `csv:"Id"`                //ID挡位
+	TriggerConditions int32    `csv:"TriggerConditions"` //差值
+	Buffid            []string `csv:"buffid"`            //触发buff
 }
 }
+
 func PresspointPvPCfgLoad(path string) {
 func PresspointPvPCfgLoad(path string) {
 	cfg := []*PresspointPvPCfg{}
 	cfg := []*PresspointPvPCfg{}
 	PresspointPvPCfgLoader = map[int32]*PresspointPvPCfg{}
 	PresspointPvPCfgLoader = map[int32]*PresspointPvPCfg{}
-	loadCsvCfg(path + "PresspointPvPCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"PresspointPvPCfg.csv", &cfg)
+	for _, row := range cfg {
 		PresspointPvPCfgLoader[row.Id] = row
 		PresspointPvPCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var PrivilegeCardCfgLoader  map[int32]*PrivilegeCardCfg
-type PrivilegeCardCfg struct{
-	Lv	int32	`csv:"Lv"`		//等级
-	RMB	float32	`csv:"RMB"`		//价格
-	UnlockCond	[]string	`csv:"UnlockCond"`		//解锁条件
-	QuickBattle	int32	`csv:"QuickBattle"`		//战斗X2加速
-	Reward	[]string	`csv:"Reward"`		//特权每日礼包
-	PurseQuota	int32	`csv:"PurseQuota"`		//充值钱包额度
-	BuyReward	[]string	`csv:"BuyReward"`		//购买奖励显示
+var PrivilegeCardCfgLoader map[int32]*PrivilegeCardCfg
+
+type PrivilegeCardCfg struct {
+	Lv          int32    `csv:"Lv"`          //等级
+	RMB         float32  `csv:"RMB"`         //价格
+	UnlockCond  []string `csv:"UnlockCond"`  //解锁条件
+	QuickBattle int32    `csv:"QuickBattle"` //战斗X2加速
+	Reward      []string `csv:"Reward"`      //特权每日礼包
+	PurseQuota  int32    `csv:"PurseQuota"`  //充值钱包额度
+	BuyReward   []string `csv:"BuyReward"`   //购买奖励显示
 }
 }
+
 func PrivilegeCardCfgLoad(path string) {
 func PrivilegeCardCfgLoad(path string) {
 	cfg := []*PrivilegeCardCfg{}
 	cfg := []*PrivilegeCardCfg{}
 	PrivilegeCardCfgLoader = map[int32]*PrivilegeCardCfg{}
 	PrivilegeCardCfgLoader = map[int32]*PrivilegeCardCfg{}
-	loadCsvCfg(path + "PrivilegeCardCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"PrivilegeCardCfg.csv", &cfg)
+	for _, row := range cfg {
 		PrivilegeCardCfgLoader[row.Lv] = row
 		PrivilegeCardCfgLoader[row.Lv] = row
 	}
 	}
 }
 }
 
 
-var PurseShopCfgLoader  map[int32]*PurseShopCfg
-type PurseShopCfg struct{
-	Id	int32	`csv:"Id"`		//礼包Id
-	Name	string	`csv:"Name"`		//礼包名字
-	Type	int32	`csv:"Type"`		//类型
-	RMB	float32	`csv:"RMB"`		//价格
-	Reward	[]string	`csv:"Reward"`		//购买后获得道具
-	FirstBuyReward	[]string	`csv:"FirstBuyReward"`		//首次购买奖励
-	ExtraBuyReward	[]string	`csv:"ExtraBuyReward"`		//购买额外获得
-	RestrictedType	int32	`csv:"RestrictedType"`		//限购类型次数
-	SortId	int32	`csv:"SortId"`		//排序Id
-	RmbTotalPay	int32	`csv:"RmbTotalPay"`		//累计充值金额
+var PurseShopCfgLoader map[int32]*PurseShopCfg
+
+type PurseShopCfg struct {
+	Id             int32    `csv:"Id"`             //礼包Id
+	Name           string   `csv:"Name"`           //礼包名字
+	Type           int32    `csv:"Type"`           //类型
+	RMB            float32  `csv:"RMB"`            //价格
+	Reward         []string `csv:"Reward"`         //购买后获得道具
+	FirstBuyReward []string `csv:"FirstBuyReward"` //首次购买奖励
+	ExtraBuyReward []string `csv:"ExtraBuyReward"` //购买额外获得
+	RestrictedType int32    `csv:"RestrictedType"` //限购类型次数
+	SortId         int32    `csv:"SortId"`         //排序Id
+	RmbTotalPay    int32    `csv:"RmbTotalPay"`    //累计充值金额
 }
 }
+
 func PurseShopCfgLoad(path string) {
 func PurseShopCfgLoad(path string) {
 	cfg := []*PurseShopCfg{}
 	cfg := []*PurseShopCfg{}
 	PurseShopCfgLoader = map[int32]*PurseShopCfg{}
 	PurseShopCfgLoader = map[int32]*PurseShopCfg{}
-	loadCsvCfg(path + "PurseShopCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"PurseShopCfg.csv", &cfg)
+	for _, row := range cfg {
 		PurseShopCfgLoader[row.Id] = row
 		PurseShopCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var QualityPointCfgLoader  map[int32]*QualityPointCfg
-type QualityPointCfg struct{
-	Count	int32	`csv:"count"`		//点数
-	Cost	int32	`csv:"cost"`		//消耗
+var QualityPointCfgLoader map[int32]*QualityPointCfg
+
+type QualityPointCfg struct {
+	Count int32 `csv:"count"` //点数
+	Cost  int32 `csv:"cost"`  //消耗
 }
 }
+
 func QualityPointCfgLoad(path string) {
 func QualityPointCfgLoad(path string) {
 	cfg := []*QualityPointCfg{}
 	cfg := []*QualityPointCfg{}
 	QualityPointCfgLoader = map[int32]*QualityPointCfg{}
 	QualityPointCfgLoader = map[int32]*QualityPointCfg{}
-	loadCsvCfg(path + "QualityPointCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"QualityPointCfg.csv", &cfg)
+	for _, row := range cfg {
 		QualityPointCfgLoader[row.Count] = row
 		QualityPointCfgLoader[row.Count] = row
 	}
 	}
 }
 }
 
 
-var QuickBattleCostCfgLoader  map[int32]*QuickBattleCostCfg
-type QuickBattleCostCfg struct{
-	ID	int32	`csv:"ID"`		//次数
-	Cost	int32	`csv:"Cost"`		//消耗
-	CostType	int32	`csv:"CostType"`		//消耗类型
+var QuickBattleCostCfgLoader map[int32]*QuickBattleCostCfg
+
+type QuickBattleCostCfg struct {
+	ID       int32 `csv:"ID"`       //次数
+	Cost     int32 `csv:"Cost"`     //消耗
+	CostType int32 `csv:"CostType"` //消耗类型
 }
 }
+
 func QuickBattleCostCfgLoad(path string) {
 func QuickBattleCostCfgLoad(path string) {
 	cfg := []*QuickBattleCostCfg{}
 	cfg := []*QuickBattleCostCfg{}
 	QuickBattleCostCfgLoader = map[int32]*QuickBattleCostCfg{}
 	QuickBattleCostCfgLoader = map[int32]*QuickBattleCostCfg{}
-	loadCsvCfg(path + "QuickBattleCostCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"QuickBattleCostCfg.csv", &cfg)
+	for _, row := range cfg {
 		QuickBattleCostCfgLoader[row.ID] = row
 		QuickBattleCostCfgLoader[row.ID] = row
 	}
 	}
 }
 }
 
 
-var RobotCfgLoader  map[int32]*RobotCfg
-type RobotCfg struct{
-	RobotId	int32	`csv:"RobotId"`		//机器人ID
-	RobotName	string	`csv:"RobotName"`		//名字
-	ArenaLevelId	int32	`csv:"ArenaLevelId"`		//段位ID
-	RobotLevel	int32	`csv:"RobotLevel"`		//等级
-	RobotAvatar	int32	`csv:"RobotAvatar"`		//机器人模型
-	RobotEquip	[]string	`csv:"RobotEquip"`		//装备
-	RobotSkill	[]string	`csv:"RobotSkill"`		//技能
-	RobotHeadPortrait	int32	`csv:"RobotHeadPortrait"`		//头像
-	PartnerId	[]string	`csv:"PartnerId"`		//伙伴
-	PartnerEquip	[]string	`csv:"PartnerEquip"`		//伙伴装备
-	PartnerLevel	[]string	`csv:"PartnerLevel"`		//伙伴等级
-	FightPower	[]string	`csv:"FightPower"`		//战斗力
-	SystemType	int32	`csv:"SystemType"`		//机器人系统类别
+var RobotCfgLoader map[int32]*RobotCfg
+
+type RobotCfg struct {
+	RobotId           int32    `csv:"RobotId"`           //机器人ID
+	RobotName         string   `csv:"RobotName"`         //名字
+	ArenaLevelId      int32    `csv:"ArenaLevelId"`      //段位ID
+	RobotLevel        int32    `csv:"RobotLevel"`        //等级
+	RobotAvatar       int32    `csv:"RobotAvatar"`       //机器人模型
+	RobotEquip        []string `csv:"RobotEquip"`        //装备
+	RobotSkill        []string `csv:"RobotSkill"`        //技能
+	RobotHeadPortrait int32    `csv:"RobotHeadPortrait"` //头像
+	PartnerId         []string `csv:"PartnerId"`         //伙伴
+	PartnerEquip      []string `csv:"PartnerEquip"`      //伙伴装备
+	PartnerLevel      []string `csv:"PartnerLevel"`      //伙伴等级
+	FightPower        []string `csv:"FightPower"`        //战斗力
+	SystemType        int32    `csv:"SystemType"`        //机器人系统类别
 }
 }
+
 func RobotCfgLoad(path string) {
 func RobotCfgLoad(path string) {
 	cfg := []*RobotCfg{}
 	cfg := []*RobotCfg{}
 	RobotCfgLoader = map[int32]*RobotCfg{}
 	RobotCfgLoader = map[int32]*RobotCfg{}
-	loadCsvCfg(path + "RobotCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RobotCfg.csv", &cfg)
+	for _, row := range cfg {
 		RobotCfgLoader[row.RobotId] = row
 		RobotCfgLoader[row.RobotId] = row
 	}
 	}
 }
 }
 
 
-var RoleAttributeCfgLoader  map[int32]*RoleAttributeCfg
-type RoleAttributeCfg struct{
-	BaseLv	int32	`csv:"BaseLv"`		//角色等级
-	Name	int32	`csv:"Name"`		//需求经验
-	GetPoint	int32	`csv:"GetPoint"`		//获得点数
-	Hp	int32	`csv:"Hp"`		//生命
-	Sp	int32	`csv:"Sp"`		//蓝量
-	Atk	int32	`csv:"Atk"`		//物攻
-	Matk	int32	`csv:"Matk"`		//魔攻
-	Def	int32	`csv:"Def"`		//物防
-	Mdef	int32	`csv:"Mdef"`		//魔防
-	Hit	int32	`csv:"Hit"`		//命中
-	Dodge	int32	`csv:"Dodge"`		//闪避
-	Crit	int32	`csv:"Crit"`		//暴击
-	Ten	int32	`csv:"Ten"`		//韧性
+var RoleAttributeCfgLoader map[int32]*RoleAttributeCfg
+
+type RoleAttributeCfg struct {
+	BaseLv   int32 `csv:"BaseLv"`   //角色等级
+	Name     int32 `csv:"Name"`     //需求经验
+	GetPoint int32 `csv:"GetPoint"` //获得点数
+	Hp       int32 `csv:"Hp"`       //生命
+	Sp       int32 `csv:"Sp"`       //蓝量
+	Atk      int32 `csv:"Atk"`      //物攻
+	Matk     int32 `csv:"Matk"`     //魔攻
+	Def      int32 `csv:"Def"`      //物防
+	Mdef     int32 `csv:"Mdef"`     //魔防
+	Hit      int32 `csv:"Hit"`      //命中
+	Dodge    int32 `csv:"Dodge"`    //闪避
+	Crit     int32 `csv:"Crit"`     //暴击
+	Ten      int32 `csv:"Ten"`      //韧性
 }
 }
+
 func RoleAttributeCfgLoad(path string) {
 func RoleAttributeCfgLoad(path string) {
 	cfg := []*RoleAttributeCfg{}
 	cfg := []*RoleAttributeCfg{}
 	RoleAttributeCfgLoader = map[int32]*RoleAttributeCfg{}
 	RoleAttributeCfgLoader = map[int32]*RoleAttributeCfg{}
-	loadCsvCfg(path + "RoleAttributeCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RoleAttributeCfg.csv", &cfg)
+	for _, row := range cfg {
 		RoleAttributeCfgLoader[row.BaseLv] = row
 		RoleAttributeCfgLoader[row.BaseLv] = row
 	}
 	}
 }
 }
 
 
-var RuneShopExploreCfgLoader  map[int32]*RuneShopExploreCfg
-type RuneShopExploreCfg struct{
-	ID	int32	`csv:"ID"`		//高级解锁商品ID
-	Round	int32	`csv:"Round"`		//活动轮次
-	GoldExp	string	`csv:"GoldExp"`		//消耗金币获取经验比例
-	MissionExp	string	`csv:"MissionExp"`		//任务活跃度转化经验比例
-	MissonExpUp	string	`csv:"MissonExpUp"`		//解锁后任务获得经验提高
-	RMB	float32	`csv:"RMB"`		//解锁价格
-	SellingBegin	int32	`csv:"SellingBegin"`		//间隔时间
-	StartTime	string	`csv:"StartTime"`		//活动开启时间
-	SellingDuration	int32	`csv:"SellingDuration"`		//活动结束时长
-	CloseTime	string	`csv:"CloseTime"`		//结束时间
-	MaxLvRewad	[]string	`csv:"MaxLvRewad"`		//满级奖励
-	ExpCost	int32	`csv:"ExpCost"`		//领取消耗经验
+var RuneShopExploreCfgLoader map[int32]*RuneShopExploreCfg
+
+type RuneShopExploreCfg struct {
+	ID              int32    `csv:"ID"`              //高级解锁商品ID
+	Round           int32    `csv:"Round"`           //活动轮次
+	GoldExp         string   `csv:"GoldExp"`         //消耗金币获取经验比例
+	MissionExp      string   `csv:"MissionExp"`      //任务活跃度转化经验比例
+	MissonExpUp     string   `csv:"MissonExpUp"`     //解锁后任务获得经验提高
+	RMB             float32  `csv:"RMB"`             //解锁价格
+	SellingBegin    int32    `csv:"SellingBegin"`    //间隔时间
+	StartTime       string   `csv:"StartTime"`       //活动开启时间
+	SellingDuration int32    `csv:"SellingDuration"` //活动结束时长
+	CloseTime       string   `csv:"CloseTime"`       //结束时间
+	MaxLvRewad      []string `csv:"MaxLvRewad"`      //满级奖励
+	ExpCost         int32    `csv:"ExpCost"`         //领取消耗经验
 }
 }
+
 func RuneShopExploreCfgLoad(path string) {
 func RuneShopExploreCfgLoad(path string) {
 	cfg := []*RuneShopExploreCfg{}
 	cfg := []*RuneShopExploreCfg{}
 	RuneShopExploreCfgLoader = map[int32]*RuneShopExploreCfg{}
 	RuneShopExploreCfgLoader = map[int32]*RuneShopExploreCfg{}
-	loadCsvCfg(path + "RuneShopExploreCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RuneShopExploreCfg.csv", &cfg)
+	for _, row := range cfg {
 		RuneShopExploreCfgLoader[row.ID] = row
 		RuneShopExploreCfgLoader[row.ID] = row
 	}
 	}
 }
 }
 
 
-var RuneShopExploreRewardCfgLoader  map[int32]*RuneShopExploreRewardCfg
-type RuneShopExploreRewardCfg struct{
-	ID	int32	`csv:"ID"`		//奖励ID
-	Lv	int32	`csv:"Lv"`		//探索等级
-	Exp	int32	`csv:"Exp"`		//升级所需经验
-	Reward	[]string	`csv:"Reward"`		//普通奖励
-	CashReward	[]string	`csv:"CashReward"`		//高级奖励
-	MaxRewardConsumen	int32	`csv:"MaxRewardConsumen"`		//满级奖励消耗所需经验
-	RewardSign	int32	`csv:"RewardSign"`		//是否为大奖
-	ActiveRound	int32	`csv:"ActiveRound"`		//活动轮次
+var RuneShopExploreRewardCfgLoader map[int32]*RuneShopExploreRewardCfg
+
+type RuneShopExploreRewardCfg struct {
+	ID                int32    `csv:"ID"`                //奖励ID
+	Lv                int32    `csv:"Lv"`                //探索等级
+	Exp               int32    `csv:"Exp"`               //升级所需经验
+	Reward            []string `csv:"Reward"`            //普通奖励
+	CashReward        []string `csv:"CashReward"`        //高级奖励
+	MaxRewardConsumen int32    `csv:"MaxRewardConsumen"` //满级奖励消耗所需经验
+	RewardSign        int32    `csv:"RewardSign"`        //是否为大奖
+	ActiveRound       int32    `csv:"ActiveRound"`       //活动轮次
 }
 }
+
 func RuneShopExploreRewardCfgLoad(path string) {
 func RuneShopExploreRewardCfgLoad(path string) {
 	cfg := []*RuneShopExploreRewardCfg{}
 	cfg := []*RuneShopExploreRewardCfg{}
 	RuneShopExploreRewardCfgLoader = map[int32]*RuneShopExploreRewardCfg{}
 	RuneShopExploreRewardCfgLoader = map[int32]*RuneShopExploreRewardCfg{}
-	loadCsvCfg(path + "RuneShopExploreRewardCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RuneShopExploreRewardCfg.csv", &cfg)
+	for _, row := range cfg {
 		RuneShopExploreRewardCfgLoader[row.ID] = row
 		RuneShopExploreRewardCfgLoader[row.ID] = row
 	}
 	}
 }
 }
 
 
-var RuneShopGiftsCfgLoader  map[int32]*RuneShopGiftsCfg
-type RuneShopGiftsCfg struct{
-	Id	int32	`csv:"Id"`		//礼包Id
-	Name	string	`csv:"Name"`		//礼包名字
-	Type	int32	`csv:"Type"`		//类型
-	RMB	float32	`csv:"RMB"`		//价格
-	Reward	[]string	`csv:"Reward"`		//购买后获得道具
-	FirstBuyReward	[]string	`csv:"FirstBuyReward"`		//首次购买奖励
-	ExtraBuyReward	[]string	`csv:"ExtraBuyReward"`		//购买额外获得
-	RestrictedType	int32	`csv:"RestrictedType"`		//限购类型次数
-	SortId	int32	`csv:"SortId"`		//排序Id
-	RmbTotalPay	int32	`csv:"RmbTotalPay"`		//累计充值金额
+var RuneShopGiftsCfgLoader map[int32]*RuneShopGiftsCfg
+
+type RuneShopGiftsCfg struct {
+	Id             int32    `csv:"Id"`             //礼包Id
+	Name           string   `csv:"Name"`           //礼包名字
+	Type           int32    `csv:"Type"`           //类型
+	RMB            float32  `csv:"RMB"`            //价格
+	Reward         []string `csv:"Reward"`         //购买后获得道具
+	FirstBuyReward []string `csv:"FirstBuyReward"` //首次购买奖励
+	ExtraBuyReward []string `csv:"ExtraBuyReward"` //购买额外获得
+	RestrictedType int32    `csv:"RestrictedType"` //限购类型次数
+	SortId         int32    `csv:"SortId"`         //排序Id
+	RmbTotalPay    int32    `csv:"RmbTotalPay"`    //累计充值金额
 }
 }
+
 func RuneShopGiftsCfgLoad(path string) {
 func RuneShopGiftsCfgLoad(path string) {
 	cfg := []*RuneShopGiftsCfg{}
 	cfg := []*RuneShopGiftsCfg{}
 	RuneShopGiftsCfgLoader = map[int32]*RuneShopGiftsCfg{}
 	RuneShopGiftsCfgLoader = map[int32]*RuneShopGiftsCfg{}
-	loadCsvCfg(path + "RuneShopGiftsCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RuneShopGiftsCfg.csv", &cfg)
+	for _, row := range cfg {
 		RuneShopGiftsCfgLoader[row.Id] = row
 		RuneShopGiftsCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var RuneShopGuildBattleCfgLoader  map[int32]*RuneShopGuildBattleCfg
-type RuneShopGuildBattleCfg struct{
-	Id	int32	`csv:"Id"`		//礼包Id
-	Name	string	`csv:"Name"`		//礼包名字
-	RMB	float32	`csv:"RMB"`		//价格
-	Reward	[]string	`csv:"Reward"`		//购买后获得道具
-	RestrictedType	int32	`csv:"RestrictedType"`		//限购类型次数
-	SortId	int32	`csv:"SortId"`		//排序Id
+var RuneShopGuildBattleCfgLoader map[int32]*RuneShopGuildBattleCfg
+
+type RuneShopGuildBattleCfg struct {
+	Id             int32    `csv:"Id"`             //礼包Id
+	Name           string   `csv:"Name"`           //礼包名字
+	RMB            float32  `csv:"RMB"`            //价格
+	Reward         []string `csv:"Reward"`         //购买后获得道具
+	RestrictedType int32    `csv:"RestrictedType"` //限购类型次数
+	SortId         int32    `csv:"SortId"`         //排序Id
 }
 }
+
 func RuneShopGuildBattleCfgLoad(path string) {
 func RuneShopGuildBattleCfgLoad(path string) {
 	cfg := []*RuneShopGuildBattleCfg{}
 	cfg := []*RuneShopGuildBattleCfg{}
 	RuneShopGuildBattleCfgLoader = map[int32]*RuneShopGuildBattleCfg{}
 	RuneShopGuildBattleCfgLoader = map[int32]*RuneShopGuildBattleCfg{}
-	loadCsvCfg(path + "RuneShopGuildBattleCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RuneShopGuildBattleCfg.csv", &cfg)
+	for _, row := range cfg {
 		RuneShopGuildBattleCfgLoader[row.Id] = row
 		RuneShopGuildBattleCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var RuneShopLimitCfgLoader  map[int32]*RuneShopLimitCfg
-type RuneShopLimitCfg struct{
-	Id	int32	`csv:"Id"`		//限时商品Id
-	Name	string	`csv:"Name"`		//商品名字
-	BuyReward	[]string	`csv:"BuyReward"`		//购买奖励
-	RMB	float32	`csv:"RMB"`		//价格
-	SellingType	int32	`csv:"SellingType"`		//商品上架类型
-	SellingBegin	int32	`csv:"SellingBegin"`		//开服后起始时间
-	SellingDuration	int32	`csv:"SellingDuration"`		//开服上架持续时长
-	BeginTime	string	`csv:"BeginTime"`		//商品上架时间
-	EndTime	string	`csv:"EndTime"`		//商品下架时间
-	RestrictedType	int32	`csv:"RestrictedType"`		//限购次数
-	SeasonId	int32	`csv:"SeasonId"`		//赛季ID
-	ActiveId	int32	`csv:"ActiveId"`		//活动ID
-	RedPoint	int32	`csv:"RedPoint"`		//红点显示
-	SortId	int32	`csv:"SortId"`		//排序Id
+var RuneShopLimitCfgLoader map[int32]*RuneShopLimitCfg
+
+type RuneShopLimitCfg struct {
+	Id              int32    `csv:"Id"`              //限时商品Id
+	Name            string   `csv:"Name"`            //商品名字
+	BuyReward       []string `csv:"BuyReward"`       //购买奖励
+	RMB             float32  `csv:"RMB"`             //价格
+	SellingType     int32    `csv:"SellingType"`     //商品上架类型
+	SellingBegin    int32    `csv:"SellingBegin"`    //开服后起始时间
+	SellingDuration int32    `csv:"SellingDuration"` //开服上架持续时长
+	BeginTime       string   `csv:"BeginTime"`       //商品上架时间
+	EndTime         string   `csv:"EndTime"`         //商品下架时间
+	RestrictedType  int32    `csv:"RestrictedType"`  //限购次数
+	SeasonId        int32    `csv:"SeasonId"`        //赛季ID
+	ActiveId        int32    `csv:"ActiveId"`        //活动ID
+	RedPoint        int32    `csv:"RedPoint"`        //红点显示
+	SortId          int32    `csv:"SortId"`          //排序Id
 }
 }
+
 func RuneShopLimitCfgLoad(path string) {
 func RuneShopLimitCfgLoad(path string) {
 	cfg := []*RuneShopLimitCfg{}
 	cfg := []*RuneShopLimitCfg{}
 	RuneShopLimitCfgLoader = map[int32]*RuneShopLimitCfg{}
 	RuneShopLimitCfgLoader = map[int32]*RuneShopLimitCfg{}
-	loadCsvCfg(path + "RuneShopLimitCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RuneShopLimitCfg.csv", &cfg)
+	for _, row := range cfg {
 		RuneShopLimitCfgLoader[row.Id] = row
 		RuneShopLimitCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var RuneShopMonthCardCfgLoader  map[int32]*RuneShopMonthCardCfg
-type RuneShopMonthCardCfg struct{
-	Id	int32	`csv:"Id"`		//周卡类型
-	Name	string	`csv:"Name"`		//周卡名字
-	AddTime	int32	`csv:"AddTime"`		//增加时长
-	BuyReward	[]string	`csv:"BuyReward"`		//购买奖励显示
-	DayReward	[]string	`csv:"DayReward"`		//每日奖励
-	TotalReward	[]string	`csv:"TotalReward"`		//总计奖励
-	RMB	float32	`csv:"RMB"`		//价格
-	BuyRewardServer	[]string	`csv:"BuyRewardServer"`		//获得购买奖励
-	RewardMail	int32	`csv:"RewardMail"`		//奖励邮件
-	Monthdec	string	`csv:"Monthdec"`		//周卡描述
+var RuneShopMonthCardCfgLoader map[int32]*RuneShopMonthCardCfg
+
+type RuneShopMonthCardCfg struct {
+	Id              int32    `csv:"Id"`              //周卡类型
+	Name            string   `csv:"Name"`            //周卡名字
+	AddTime         int32    `csv:"AddTime"`         //增加时长
+	BuyReward       []string `csv:"BuyReward"`       //购买奖励显示
+	DayReward       []string `csv:"DayReward"`       //每日奖励
+	TotalReward     []string `csv:"TotalReward"`     //总计奖励
+	RMB             float32  `csv:"RMB"`             //价格
+	BuyRewardServer []string `csv:"BuyRewardServer"` //获得购买奖励
+	RewardMail      int32    `csv:"RewardMail"`      //奖励邮件
+	Monthdec        string   `csv:"Monthdec"`        //周卡描述
 }
 }
+
 func RuneShopMonthCardCfgLoad(path string) {
 func RuneShopMonthCardCfgLoad(path string) {
 	cfg := []*RuneShopMonthCardCfg{}
 	cfg := []*RuneShopMonthCardCfg{}
 	RuneShopMonthCardCfgLoader = map[int32]*RuneShopMonthCardCfg{}
 	RuneShopMonthCardCfgLoader = map[int32]*RuneShopMonthCardCfg{}
-	loadCsvCfg(path + "RuneShopMonthCardCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RuneShopMonthCardCfg.csv", &cfg)
+	for _, row := range cfg {
 		RuneShopMonthCardCfgLoader[row.Id] = row
 		RuneShopMonthCardCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var RuneShopRankAidouluCfgLoader  map[int32]*RuneShopRankAidouluCfg
-type RuneShopRankAidouluCfg struct{
-	Id	int32	`csv:"Id"`		//礼包Id
-	RankId	int32	`csv:"RankId"`		//活序号
-	Name	string	`csv:"Name"`		//礼包名字
-	RMB	float32	`csv:"RMB"`		//价格
-	Reward	[]string	`csv:"Reward"`		//前端显示获得道具
-	RestrictedType	int32	`csv:"RestrictedType"`		//限购类型次数
-	SortId	int32	`csv:"SortId"`		//排序Id
-	SeverReward	[]string	`csv:"SeverReward"`		//购买后获得道具
-	RewardScore	int32	`csv:"RewardScore"`		//购买后获得积分
-	IfRequite	int32	`csv:"IfRequite"`		//是否解锁馈赠
+var RuneShopRankAidouluCfgLoader map[int32]*RuneShopRankAidouluCfg
+
+type RuneShopRankAidouluCfg struct {
+	Id             int32    `csv:"Id"`             //礼包Id
+	RankId         int32    `csv:"RankId"`         //活序号
+	Name           string   `csv:"Name"`           //礼包名字
+	RMB            float32  `csv:"RMB"`            //价格
+	Reward         []string `csv:"Reward"`         //前端显示获得道具
+	RestrictedType int32    `csv:"RestrictedType"` //限购类型次数
+	SortId         int32    `csv:"SortId"`         //排序Id
+	SeverReward    []string `csv:"SeverReward"`    //购买后获得道具
+	RewardScore    int32    `csv:"RewardScore"`    //购买后获得积分
+	IfRequite      int32    `csv:"IfRequite"`      //是否解锁馈赠
 }
 }
+
 func RuneShopRankAidouluCfgLoad(path string) {
 func RuneShopRankAidouluCfgLoad(path string) {
 	cfg := []*RuneShopRankAidouluCfg{}
 	cfg := []*RuneShopRankAidouluCfg{}
 	RuneShopRankAidouluCfgLoader = map[int32]*RuneShopRankAidouluCfg{}
 	RuneShopRankAidouluCfgLoader = map[int32]*RuneShopRankAidouluCfg{}
-	loadCsvCfg(path + "RuneShopRankAidouluCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RuneShopRankAidouluCfg.csv", &cfg)
+	for _, row := range cfg {
 		RuneShopRankAidouluCfgLoader[row.Id] = row
 		RuneShopRankAidouluCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var RuneShopRankArenaCfgLoader  map[int32]*RuneShopRankArenaCfg
-type RuneShopRankArenaCfg struct{
-	Id	int32	`csv:"Id"`		//礼包Id
-	RankId	int32	`csv:"RankId"`		//活序号
-	Name	string	`csv:"Name"`		//礼包名字
-	RMB	float32	`csv:"RMB"`		//价格
-	Reward	[]string	`csv:"Reward"`		//购买后获得道具
-	RestrictedType	int32	`csv:"RestrictedType"`		//限购类型次数
-	SortId	int32	`csv:"SortId"`		//排序Id
+var RuneShopRankArenaCfgLoader map[int32]*RuneShopRankArenaCfg
+
+type RuneShopRankArenaCfg struct {
+	Id             int32    `csv:"Id"`             //礼包Id
+	RankId         int32    `csv:"RankId"`         //活序号
+	Name           string   `csv:"Name"`           //礼包名字
+	RMB            float32  `csv:"RMB"`            //价格
+	Reward         []string `csv:"Reward"`         //购买后获得道具
+	RestrictedType int32    `csv:"RestrictedType"` //限购类型次数
+	SortId         int32    `csv:"SortId"`         //排序Id
 }
 }
+
 func RuneShopRankArenaCfgLoad(path string) {
 func RuneShopRankArenaCfgLoad(path string) {
 	cfg := []*RuneShopRankArenaCfg{}
 	cfg := []*RuneShopRankArenaCfg{}
 	RuneShopRankArenaCfgLoader = map[int32]*RuneShopRankArenaCfg{}
 	RuneShopRankArenaCfgLoader = map[int32]*RuneShopRankArenaCfg{}
-	loadCsvCfg(path + "RuneShopRankArenaCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RuneShopRankArenaCfg.csv", &cfg)
+	for _, row := range cfg {
 		RuneShopRankArenaCfgLoader[row.Id] = row
 		RuneShopRankArenaCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var RuneShopRankMapCfgLoader  map[int32]*RuneShopRankMapCfg
-type RuneShopRankMapCfg struct{
-	Id	int32	`csv:"Id"`		//礼包Id
-	RankId	int32	`csv:"RankId"`		//活序号
-	Name	string	`csv:"Name"`		//礼包名字
-	RMB	float32	`csv:"RMB"`		//价格
-	Reward	[]string	`csv:"Reward"`		//购买后获得道具
-	RewardScore	int32	`csv:"RewardScore"`		//购买后获得积分
-	RestrictedType	int32	`csv:"RestrictedType"`		//限购类型次数
-	SortId	int32	`csv:"SortId"`		//排序Id
-	SeverReward	[]string	`csv:"SeverReward"`		//购买后获得道具
+var RuneShopRankMapCfgLoader map[int32]*RuneShopRankMapCfg
+
+type RuneShopRankMapCfg struct {
+	Id             int32    `csv:"Id"`             //礼包Id
+	RankId         int32    `csv:"RankId"`         //活序号
+	Name           string   `csv:"Name"`           //礼包名字
+	RMB            float32  `csv:"RMB"`            //价格
+	Reward         []string `csv:"Reward"`         //购买后获得道具
+	RewardScore    int32    `csv:"RewardScore"`    //购买后获得积分
+	RestrictedType int32    `csv:"RestrictedType"` //限购类型次数
+	SortId         int32    `csv:"SortId"`         //排序Id
+	SeverReward    []string `csv:"SeverReward"`    //购买后获得道具
 }
 }
+
 func RuneShopRankMapCfgLoad(path string) {
 func RuneShopRankMapCfgLoad(path string) {
 	cfg := []*RuneShopRankMapCfg{}
 	cfg := []*RuneShopRankMapCfg{}
 	RuneShopRankMapCfgLoader = map[int32]*RuneShopRankMapCfg{}
 	RuneShopRankMapCfgLoader = map[int32]*RuneShopRankMapCfg{}
-	loadCsvCfg(path + "RuneShopRankMapCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RuneShopRankMapCfg.csv", &cfg)
+	for _, row := range cfg {
 		RuneShopRankMapCfgLoader[row.Id] = row
 		RuneShopRankMapCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var RuneShopRankPetCfgLoader  map[int32]*RuneShopRankPetCfg
-type RuneShopRankPetCfg struct{
-	Id	int32	`csv:"Id"`		//礼包Id
-	RankId	int32	`csv:"RankId"`		//活序号
-	Name	string	`csv:"Name"`		//礼包名字
-	RMB	float32	`csv:"RMB"`		//价格
-	Reward	[]string	`csv:"Reward"`		//购买后获得道具
-	RestrictedType	int32	`csv:"RestrictedType"`		//限购类型次数
-	SortId	int32	`csv:"SortId"`		//排序Id
+var RuneShopRankPetCfgLoader map[int32]*RuneShopRankPetCfg
+
+type RuneShopRankPetCfg struct {
+	Id             int32    `csv:"Id"`             //礼包Id
+	RankId         int32    `csv:"RankId"`         //活序号
+	Name           string   `csv:"Name"`           //礼包名字
+	RMB            float32  `csv:"RMB"`            //价格
+	Reward         []string `csv:"Reward"`         //购买后获得道具
+	RestrictedType int32    `csv:"RestrictedType"` //限购类型次数
+	SortId         int32    `csv:"SortId"`         //排序Id
 }
 }
+
 func RuneShopRankPetCfgLoad(path string) {
 func RuneShopRankPetCfgLoad(path string) {
 	cfg := []*RuneShopRankPetCfg{}
 	cfg := []*RuneShopRankPetCfg{}
 	RuneShopRankPetCfgLoader = map[int32]*RuneShopRankPetCfg{}
 	RuneShopRankPetCfgLoader = map[int32]*RuneShopRankPetCfg{}
-	loadCsvCfg(path + "RuneShopRankPetCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RuneShopRankPetCfg.csv", &cfg)
+	for _, row := range cfg {
 		RuneShopRankPetCfgLoader[row.Id] = row
 		RuneShopRankPetCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var RuneShopRankSkillCfgLoader  map[int32]*RuneShopRankSkillCfg
-type RuneShopRankSkillCfg struct{
-	Id	int32	`csv:"Id"`		//礼包Id
-	RankId	int32	`csv:"RankId"`		//活序号
-	Name	string	`csv:"Name"`		//礼包名字
-	RMB	float32	`csv:"RMB"`		//价格
-	Reward	[]string	`csv:"Reward"`		//购买后获得道具
-	RestrictedType	int32	`csv:"RestrictedType"`		//限购类型次数
-	SortId	int32	`csv:"SortId"`		//排序Id
+var RuneShopRankSkillCfgLoader map[int32]*RuneShopRankSkillCfg
+
+type RuneShopRankSkillCfg struct {
+	Id             int32    `csv:"Id"`             //礼包Id
+	RankId         int32    `csv:"RankId"`         //活序号
+	Name           string   `csv:"Name"`           //礼包名字
+	RMB            float32  `csv:"RMB"`            //价格
+	Reward         []string `csv:"Reward"`         //购买后获得道具
+	RestrictedType int32    `csv:"RestrictedType"` //限购类型次数
+	SortId         int32    `csv:"SortId"`         //排序Id
 }
 }
+
 func RuneShopRankSkillCfgLoad(path string) {
 func RuneShopRankSkillCfgLoad(path string) {
 	cfg := []*RuneShopRankSkillCfg{}
 	cfg := []*RuneShopRankSkillCfg{}
 	RuneShopRankSkillCfgLoader = map[int32]*RuneShopRankSkillCfg{}
 	RuneShopRankSkillCfgLoader = map[int32]*RuneShopRankSkillCfg{}
-	loadCsvCfg(path + "RuneShopRankSkillCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RuneShopRankSkillCfg.csv", &cfg)
+	for _, row := range cfg {
 		RuneShopRankSkillCfgLoader[row.Id] = row
 		RuneShopRankSkillCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var RuneShopRankTowerCfgLoader  map[int32]*RuneShopRankTowerCfg
-type RuneShopRankTowerCfg struct{
-	Id	int32	`csv:"Id"`		//礼包Id
-	RankId	int32	`csv:"RankId"`		//活序号
-	Name	string	`csv:"Name"`		//礼包名字
-	RMB	float32	`csv:"RMB"`		//价格
-	Reward	[]string	`csv:"Reward"`		//购买后获得道具
-	RestrictedType	int32	`csv:"RestrictedType"`		//限购类型次数
-	SortId	int32	`csv:"SortId"`		//排序Id
+var RuneShopRankTowerCfgLoader map[int32]*RuneShopRankTowerCfg
+
+type RuneShopRankTowerCfg struct {
+	Id             int32    `csv:"Id"`             //礼包Id
+	RankId         int32    `csv:"RankId"`         //活序号
+	Name           string   `csv:"Name"`           //礼包名字
+	RMB            float32  `csv:"RMB"`            //价格
+	Reward         []string `csv:"Reward"`         //购买后获得道具
+	RestrictedType int32    `csv:"RestrictedType"` //限购类型次数
+	SortId         int32    `csv:"SortId"`         //排序Id
 }
 }
+
 func RuneShopRankTowerCfgLoad(path string) {
 func RuneShopRankTowerCfgLoad(path string) {
 	cfg := []*RuneShopRankTowerCfg{}
 	cfg := []*RuneShopRankTowerCfg{}
 	RuneShopRankTowerCfgLoader = map[int32]*RuneShopRankTowerCfg{}
 	RuneShopRankTowerCfgLoader = map[int32]*RuneShopRankTowerCfg{}
-	loadCsvCfg(path + "RuneShopRankTowerCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RuneShopRankTowerCfg.csv", &cfg)
+	for _, row := range cfg {
 		RuneShopRankTowerCfgLoader[row.Id] = row
 		RuneShopRankTowerCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var RushListCfgLoader  map[int32]*RushListCfg
-type RushListCfg struct{
-	Id	int32	`csv:"Id"`		//RankId
-	RankType	int32	`csv:"RankType"`		//活动种类
-	RankId	int32	`csv:"RankId"`		//活动序号
-	StartDay	int32	`csv:"StartDay"`		//活动开始日期
-	StartTime	string	`csv:"StartTime"`		//活动开始时间
-	CloseDay	int32	`csv:"CloseDay"`		//活动结束日期
-	CloseTime	string	`csv:"CloseTime"`		//活动结束时间
-	RestDay	int32	`csv:"RestDay"`		//功能结束日期
-	RestTime	string	`csv:"RestTime"`		//功能结束时间
-	RankGrade	int32	`csv:"RankGrade"`		//排名档次
-	Rank	[]string	`csv:"Rank"`		//排名区间
-	Reward	[]string	`csv:"Reward"`		//排名奖励
+var RushListCfgLoader map[int32]*RushListCfg
+
+type RushListCfg struct {
+	Id        int32    `csv:"Id"`        //RankId
+	RankType  int32    `csv:"RankType"`  //活动种类
+	RankId    int32    `csv:"RankId"`    //活动序号
+	StartDay  int32    `csv:"StartDay"`  //活动开始日期
+	StartTime string   `csv:"StartTime"` //活动开始时间
+	CloseDay  int32    `csv:"CloseDay"`  //活动结束日期
+	CloseTime string   `csv:"CloseTime"` //活动结束时间
+	RestDay   int32    `csv:"RestDay"`   //功能结束日期
+	RestTime  string   `csv:"RestTime"`  //功能结束时间
+	RankGrade int32    `csv:"RankGrade"` //排名档次
+	Rank      []string `csv:"Rank"`      //排名区间
+	Reward    []string `csv:"Reward"`    //排名奖励
 }
 }
+
 func RushListCfgLoad(path string) {
 func RushListCfgLoad(path string) {
 	cfg := []*RushListCfg{}
 	cfg := []*RushListCfg{}
 	RushListCfgLoader = map[int32]*RushListCfg{}
 	RushListCfgLoader = map[int32]*RushListCfg{}
-	loadCsvCfg(path + "RushListCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RushListCfg.csv", &cfg)
+	for _, row := range cfg {
 		RushListCfgLoader[row.Id] = row
 		RushListCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var RushListTargetCfgLoader  map[int32]*RushListTargetCfg
-type RushListTargetCfg struct{
-	Id	int32	`csv:"Id"`		//Id
-	RankType	int32	`csv:"RankType"`		//活动种类
-	RankId	int32	`csv:"RankId"`		//活序号
-	Rank	[]string	`csv:"Rank"`		//条件区间
-	TargetGrade	int32	`csv:"TargetGrade"`		//目标档次
-	Reward	[]string	`csv:"Reward"`		//奖励
+var RushListTargetCfgLoader map[int32]*RushListTargetCfg
+
+type RushListTargetCfg struct {
+	Id          int32    `csv:"Id"`          //Id
+	RankType    int32    `csv:"RankType"`    //活动种类
+	RankId      int32    `csv:"RankId"`      //活序号
+	Rank        []string `csv:"Rank"`        //条件区间
+	TargetGrade int32    `csv:"TargetGrade"` //目标档次
+	Reward      []string `csv:"Reward"`      //奖励
 }
 }
+
 func RushListTargetCfgLoad(path string) {
 func RushListTargetCfgLoad(path string) {
 	cfg := []*RushListTargetCfg{}
 	cfg := []*RushListTargetCfg{}
 	RushListTargetCfgLoader = map[int32]*RushListTargetCfg{}
 	RushListTargetCfgLoader = map[int32]*RushListTargetCfg{}
-	loadCsvCfg(path + "RushListTargetCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"RushListTargetCfg.csv", &cfg)
+	for _, row := range cfg {
 		RushListTargetCfgLoader[row.Id] = row
 		RushListTargetCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ServiceRecordCfgLoader  map[int32]*ServiceRecordCfg
-type ServiceRecordCfg struct{
-	Id	int32	`csv:"Id"`		//合服记录编号
-	ActivitiesId	[]string	`csv:"ActivitiesId"`		//活动Id
+var ServiceRecordCfgLoader map[int32]*ServiceRecordCfg
+
+type ServiceRecordCfg struct {
+	Id           int32    `csv:"Id"`           //合服记录编号
+	ActivitiesId []string `csv:"ActivitiesId"` //活动Id
 }
 }
+
 func ServiceRecordCfgLoad(path string) {
 func ServiceRecordCfgLoad(path string) {
 	cfg := []*ServiceRecordCfg{}
 	cfg := []*ServiceRecordCfg{}
 	ServiceRecordCfgLoader = map[int32]*ServiceRecordCfg{}
 	ServiceRecordCfgLoader = map[int32]*ServiceRecordCfg{}
-	loadCsvCfg(path + "ServiceRecordCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ServiceRecordCfg.csv", &cfg)
+	for _, row := range cfg {
 		ServiceRecordCfgLoader[row.Id] = row
 		ServiceRecordCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var ShieldedWordCfgLoader  map[int32]*ShieldedWordCfg
-type ShieldedWordCfg struct{
-	ID	int32	`csv:"ID"`		//ID
-	Type	string	`csv:"Type"`		//Type
+var ShieldedWordCfgLoader map[int32]*ShieldedWordCfg
+
+type ShieldedWordCfg struct {
+	ID   int32  `csv:"ID"`   //ID
+	Type string `csv:"Type"` //Type
 }
 }
+
 func ShieldedWordCfgLoad(path string) {
 func ShieldedWordCfgLoad(path string) {
 	cfg := []*ShieldedWordCfg{}
 	cfg := []*ShieldedWordCfg{}
 	ShieldedWordCfgLoader = map[int32]*ShieldedWordCfg{}
 	ShieldedWordCfgLoader = map[int32]*ShieldedWordCfg{}
-	loadCsvCfg(path + "ShieldedWordCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ShieldedWordCfg.csv", &cfg)
+	for _, row := range cfg {
 		ShieldedWordCfgLoader[row.ID] = row
 		ShieldedWordCfgLoader[row.ID] = row
 	}
 	}
 }
 }
 
 
-var ShopCfgLoader  map[int32]*ShopCfg
-type ShopCfg struct{
-	GoodsId	int32	`csv:"GoodsId"`		//商品Id
-	GoodsName	string	`csv:"GoodsName"`		//商品名称
-	GoodsType	int32	`csv:"GoodsType"`		//商品所属tab
-	GoodsTypename	string	`csv:"GoodsTypename"`		//商品页签
-	GoodsItem	int32	`csv:"GoodsItem"`		//商品内容
-	PayForType	int32	`csv:"PayForType"`		//消耗资源类型
-	PayForNum	int32	`csv:"PayForNum"`		//消耗资源数量
-	HdDrop	int32	`csv:"HdDrop"`		//活动商品
-	SellWell	int32	`csv:"SellWell"`		//是否热销
-	Proportion	int32	`csv:"Proportion"`		//折扣比例
-	DiscountPayForNum	int32	`csv:"DiscountPayForNum"`		//折扣后价格
-	RestrictedType	string	`csv:"RestrictedType"`		//限购类型次数
-	BeginTime	string	`csv:"BeginTime"`		//开始时间
-	EndTime	string	`csv:"EndTime"`		//结束时间
-	SortId	int32	`csv:"SortId"`		//排序Id
-	Weight	int32	`csv:"Weight"`		//权重概率
-	Weight1	int32	`csv:"Weight1"`		//VIP权重概率1
-	Weight2	int32	`csv:"Weight2"`		//VIP权重概率2
-	Weight3	int32	`csv:"Weight3"`		//VIP权重概率3
-	Weight4	int32	`csv:"Weight4"`		//VIP权重概率4
-	NtfClient	int32	`csv:"NtfClient"`		//是否通知客户端
-	GoodsPic	string	`csv:"GoodsPic"`		//图片
-	Reward	[]string	`csv:"Reward"`		//购买后获得道具
-	Condition	[]string	`csv:"Condition"`		//上架解锁条件枚举
+var ShopCfgLoader map[int32]*ShopCfg
+
+type ShopCfg struct {
+	GoodsId           int32    `csv:"GoodsId"`           //商品Id
+	GoodsName         string   `csv:"GoodsName"`         //商品名称
+	GoodsType         int32    `csv:"GoodsType"`         //商品所属tab
+	GoodsTypename     string   `csv:"GoodsTypename"`     //商品页签
+	GoodsItem         int32    `csv:"GoodsItem"`         //商品内容
+	PayForType        int32    `csv:"PayForType"`        //消耗资源类型
+	PayForNum         int32    `csv:"PayForNum"`         //消耗资源数量
+	HdDrop            int32    `csv:"HdDrop"`            //活动商品
+	SellWell          int32    `csv:"SellWell"`          //是否热销
+	Proportion        int32    `csv:"Proportion"`        //折扣比例
+	DiscountPayForNum int32    `csv:"DiscountPayForNum"` //折扣后价格
+	RestrictedType    string   `csv:"RestrictedType"`    //限购类型次数
+	BeginTime         string   `csv:"BeginTime"`         //开始时间
+	EndTime           string   `csv:"EndTime"`           //结束时间
+	SortId            int32    `csv:"SortId"`            //排序Id
+	Weight            int32    `csv:"Weight"`            //权重概率
+	Weight1           int32    `csv:"Weight1"`           //VIP权重概率1
+	Weight2           int32    `csv:"Weight2"`           //VIP权重概率2
+	Weight3           int32    `csv:"Weight3"`           //VIP权重概率3
+	Weight4           int32    `csv:"Weight4"`           //VIP权重概率4
+	NtfClient         int32    `csv:"NtfClient"`         //是否通知客户端
+	GoodsPic          string   `csv:"GoodsPic"`          //图片
+	Reward            []string `csv:"Reward"`            //购买后获得道具
+	Condition         []string `csv:"Condition"`         //上架解锁条件枚举
 }
 }
+
 func ShopCfgLoad(path string) {
 func ShopCfgLoad(path string) {
 	cfg := []*ShopCfg{}
 	cfg := []*ShopCfg{}
 	ShopCfgLoader = map[int32]*ShopCfg{}
 	ShopCfgLoader = map[int32]*ShopCfg{}
-	loadCsvCfg(path + "ShopCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ShopCfg.csv", &cfg)
+	for _, row := range cfg {
 		ShopCfgLoader[row.GoodsId] = row
 		ShopCfgLoader[row.GoodsId] = row
 	}
 	}
 }
 }
 
 
-var ShopTypeCfgLoader  map[int32]*ShopTypeCfg
-type ShopTypeCfg struct{
-	Id	int32	`csv:"Id"`		//商店唯一ID
-	ShopType	int32	`csv:"ShopType"`		//商店类型
-	Currency	[]string	`csv:"Currency"`		//交易货币
-	RefreshTime	[]string	`csv:"RefreshTime"`		//自动刷新时间点
-	PayForRefresh	[]string	`csv:"PayForRefresh"`		//手动刷新消耗
-	RefreshNum	int32	`csv:"RefreshNum"`		//手动刷新最大次数
-	GoodsRefreshNum	int32	`csv:"GoodsRefreshNum"`		//刷新商店道具上架数量
-	SortId	int32	`csv:"SortId"`		//商店页签排序
-	ActShop	int32	`csv:"ActShop"`		//活动商店类型
+var ShopTypeCfgLoader map[int32]*ShopTypeCfg
+
+type ShopTypeCfg struct {
+	Id              int32    `csv:"Id"`              //商店唯一ID
+	ShopType        int32    `csv:"ShopType"`        //商店类型
+	Currency        []string `csv:"Currency"`        //交易货币
+	RefreshTime     []string `csv:"RefreshTime"`     //自动刷新时间点
+	PayForRefresh   []string `csv:"PayForRefresh"`   //手动刷新消耗
+	RefreshNum      int32    `csv:"RefreshNum"`      //手动刷新最大次数
+	GoodsRefreshNum int32    `csv:"GoodsRefreshNum"` //刷新商店道具上架数量
+	SortId          int32    `csv:"SortId"`          //商店页签排序
+	ActShop         int32    `csv:"ActShop"`         //活动商店类型
 }
 }
+
 func ShopTypeCfgLoad(path string) {
 func ShopTypeCfgLoad(path string) {
 	cfg := []*ShopTypeCfg{}
 	cfg := []*ShopTypeCfg{}
 	ShopTypeCfgLoader = map[int32]*ShopTypeCfg{}
 	ShopTypeCfgLoader = map[int32]*ShopTypeCfg{}
-	loadCsvCfg(path + "ShopTypeCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"ShopTypeCfg.csv", &cfg)
+	for _, row := range cfg {
 		ShopTypeCfgLoader[row.Id] = row
 		ShopTypeCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var SignInCfgLoader  map[int32]*SignInCfg
-type SignInCfg struct{
-	ID	int32	`csv:"ID"`		//序列id
-	SignInType	int32	`csv:"SignInType"`		//签到类型
-	SignInReward	[]string	`csv:"SignInReward"`		//签到奖励
-	VipLevel	int32	`csv:"VipLevel"`		//Vip等级
-	SignInAddReward	[]string	`csv:"SignInAddReward"`		//累计奖励
-	Balloon	int32	`csv:"balloon"`		//气球方向
+var SignInCfgLoader map[int32]*SignInCfg
+
+type SignInCfg struct {
+	ID              int32    `csv:"ID"`              //序列id
+	SignInType      int32    `csv:"SignInType"`      //签到类型
+	SignInReward    []string `csv:"SignInReward"`    //签到奖励
+	VipLevel        int32    `csv:"VipLevel"`        //Vip等级
+	SignInAddReward []string `csv:"SignInAddReward"` //累计奖励
+	Balloon         int32    `csv:"balloon"`         //气球方向
 }
 }
+
 func SignInCfgLoad(path string) {
 func SignInCfgLoad(path string) {
 	cfg := []*SignInCfg{}
 	cfg := []*SignInCfg{}
 	SignInCfgLoader = map[int32]*SignInCfg{}
 	SignInCfgLoader = map[int32]*SignInCfg{}
-	loadCsvCfg(path + "SignInCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"SignInCfg.csv", &cfg)
+	for _, row := range cfg {
 		SignInCfgLoader[row.ID] = row
 		SignInCfgLoader[row.ID] = row
 	}
 	}
 }
 }
 
 
-var SkillCfgLoader  map[int32]*SkillCfg
-type SkillCfg struct{
-	SkillId	int32	`csv:"SkillId"`		//技能ID
-	SkillType	int32	`csv:"SkillType"`		//技能类型
-	JobType	int32	`csv:"JobType"`		//职业类型
-	JobBranch	int32	`csv:"JobBranch"`		//职业分支
-	JobStage	int32	`csv:"JobStage"`		//职业阶段
-	Hide	int32	`csv:"Hide"`		//隐藏
-	BuffPoint	[]string	`csv:"BuffPoint"`		//技能点数
-	AddFight	int32	`csv:"AddFight"`		//技能升级提升战力
-	SpcSkillDec	[]string	`csv:"SpcSkillDec"`		//特殊技能
+var SkillCfgLoader map[int32]*SkillCfg
+
+type SkillCfg struct {
+	SkillId     int32    `csv:"SkillId"`     //技能ID
+	SkillType   int32    `csv:"SkillType"`   //技能类型
+	JobType     int32    `csv:"JobType"`     //职业类型
+	JobBranch   int32    `csv:"JobBranch"`   //职业分支
+	JobStage    int32    `csv:"JobStage"`    //职业阶段
+	Hide        int32    `csv:"Hide"`        //隐藏
+	BuffPoint   []string `csv:"BuffPoint"`   //技能点数
+	AddFight    int32    `csv:"AddFight"`    //技能升级提升战力
+	SpcSkillDec []string `csv:"SpcSkillDec"` //特殊技能
 }
 }
+
 func SkillCfgLoad(path string) {
 func SkillCfgLoad(path string) {
 	cfg := []*SkillCfg{}
 	cfg := []*SkillCfg{}
 	SkillCfgLoader = map[int32]*SkillCfg{}
 	SkillCfgLoader = map[int32]*SkillCfg{}
-	loadCsvCfg(path + "SkillCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"SkillCfg.csv", &cfg)
+	for _, row := range cfg {
 		SkillCfgLoader[row.SkillId] = row
 		SkillCfgLoader[row.SkillId] = row
 	}
 	}
 }
 }
 
 
-var SkillDemandCfgLoader  map[int32]*SkillDemandCfg
-type SkillDemandCfg struct{
-	LearnLv	int32	`csv:"LearnLv"`		//技能学习等级
-	LvupDemand	[]string	`csv:"LvupDemand"`		//技能升级需求等级
-	LvupCost	[]string	`csv:"LvupCost"`		//技能升级所需消耗
+var SkillDemandCfgLoader map[int32]*SkillDemandCfg
+
+type SkillDemandCfg struct {
+	LearnLv    int32    `csv:"LearnLv"`    //技能学习等级
+	LvupDemand []string `csv:"LvupDemand"` //技能升级需求等级
+	LvupCost   []string `csv:"LvupCost"`   //技能升级所需消耗
 }
 }
+
 func SkillDemandCfgLoad(path string) {
 func SkillDemandCfgLoad(path string) {
 	cfg := []*SkillDemandCfg{}
 	cfg := []*SkillDemandCfg{}
 	SkillDemandCfgLoader = map[int32]*SkillDemandCfg{}
 	SkillDemandCfgLoader = map[int32]*SkillDemandCfg{}
-	loadCsvCfg(path + "SkillDemandCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"SkillDemandCfg.csv", &cfg)
+	for _, row := range cfg {
 		SkillDemandCfgLoader[row.LearnLv] = row
 		SkillDemandCfgLoader[row.LearnLv] = row
 	}
 	}
 }
 }
 
 
-var SkillLvCfgLoader  map[int32]*SkillLvCfg
-type SkillLvCfg struct{
-	Id	int32	`csv:"Id"`		//固定ID
-	Cost	int32	`csv:"Cost"`		//SP消耗
-	SkillId	int32	`csv:"SkillId"`		//技能ID
-	SkillLV	int32	`csv:"SkillLV"`		//技能等级
+var SkillLvCfgLoader map[int32]*SkillLvCfg
+
+type SkillLvCfg struct {
+	Id      int32 `csv:"Id"`      //固定ID
+	Cost    int32 `csv:"Cost"`    //SP消耗
+	SkillId int32 `csv:"SkillId"` //技能ID
+	SkillLV int32 `csv:"SkillLV"` //技能等级
 }
 }
+
 func SkillLvCfgLoad(path string) {
 func SkillLvCfgLoad(path string) {
 	cfg := []*SkillLvCfg{}
 	cfg := []*SkillLvCfg{}
 	SkillLvCfgLoader = map[int32]*SkillLvCfg{}
 	SkillLvCfgLoader = map[int32]*SkillLvCfg{}
-	loadCsvCfg(path + "SkillLvCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"SkillLvCfg.csv", &cfg)
+	for _, row := range cfg {
 		SkillLvCfgLoader[row.Id] = row
 		SkillLvCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var SkillSlotCfgLoader  map[int32]*SkillSlotCfg
-type SkillSlotCfg struct{
-	ID	int32	`csv:"ID"`		//编号
-	Condition	int32	`csv:"Condition"`		//升级解锁条件
-	SCondition	[]string	`csv:"S_Condition"`		//升级解锁条件
-	FightPower	int32	`csv:"FightPower"`		//技能槽附加战斗力
-	ParterCondition	int32	`csv:"ParterCondition"`		//伙伴技能升级条件
-	SParterCondition	[]string	`csv:"S_ParterCondition"`		//伙伴技能升级条件
+var SkillSlotCfgLoader map[int32]*SkillSlotCfg
+
+type SkillSlotCfg struct {
+	ID               int32    `csv:"ID"`                //编号
+	Condition        int32    `csv:"Condition"`         //升级解锁条件
+	SCondition       []string `csv:"S_Condition"`       //升级解锁条件
+	FightPower       int32    `csv:"FightPower"`        //技能槽附加战斗力
+	ParterCondition  int32    `csv:"ParterCondition"`   //伙伴技能升级条件
+	SParterCondition []string `csv:"S_ParterCondition"` //伙伴技能升级条件
 }
 }
+
 func SkillSlotCfgLoad(path string) {
 func SkillSlotCfgLoad(path string) {
 	cfg := []*SkillSlotCfg{}
 	cfg := []*SkillSlotCfg{}
 	SkillSlotCfgLoader = map[int32]*SkillSlotCfg{}
 	SkillSlotCfgLoader = map[int32]*SkillSlotCfg{}
-	loadCsvCfg(path + "SkillSlotCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"SkillSlotCfg.csv", &cfg)
+	for _, row := range cfg {
 		SkillSlotCfgLoader[row.ID] = row
 		SkillSlotCfgLoader[row.ID] = row
 	}
 	}
 }
 }
 
 
-var SkillSuitNewCfgLoader  map[int32]*SkillSuitNewCfg
-type SkillSuitNewCfg struct{
-	Id	int32	`csv:"Id"`		//id
-	Name	string	`csv:"Name"`		//名称
-	Suit1	[]string	`csv:"Suit1"`		//效果
-	TriggerConditions	[]string	`csv:"TriggerConditions"`		//激活条件
-	Buffid	int32	`csv:"buffid"`		//触发buff
+var SkillSuitNewCfgLoader map[int32]*SkillSuitNewCfg
+
+type SkillSuitNewCfg struct {
+	Id                int32    `csv:"Id"`                //id
+	Name              string   `csv:"Name"`              //名称
+	Suit1             []string `csv:"Suit1"`             //效果
+	TriggerConditions []string `csv:"TriggerConditions"` //激活条件
+	Buffid            int32    `csv:"buffid"`            //触发buff
 }
 }
+
 func SkillSuitNewCfgLoad(path string) {
 func SkillSuitNewCfgLoad(path string) {
 	cfg := []*SkillSuitNewCfg{}
 	cfg := []*SkillSuitNewCfg{}
 	SkillSuitNewCfgLoader = map[int32]*SkillSuitNewCfg{}
 	SkillSuitNewCfgLoader = map[int32]*SkillSuitNewCfg{}
-	loadCsvCfg(path + "SkillSuitNewCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"SkillSuitNewCfg.csv", &cfg)
+	for _, row := range cfg {
 		SkillSuitNewCfgLoader[row.Id] = row
 		SkillSuitNewCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var SkillTreeCfgLoader  map[int32]*SkillTreeCfg
-type SkillTreeCfg struct{
-	SkillId	int32	`csv:"SkillId"`		//技能ID
-	Name	string	`csv:"Name"`		//技能名字
-	SkillType	int32	`csv:"SkillType"`		//技能类型
-	MaxLv	int32	`csv:"MaxLv"`		//技能等级上限
-	SkillQuality	int32	`csv:"SkillQuality"`		//技能品质
-	JobType	int32	`csv:"JobType"`		//职业类型
-	JobBranch	int32	`csv:"JobBranch"`		//职业分支
-	JobStage	int32	`csv:"JobStage"`		//职业阶段
-	OpenLevel	int32	`csv:"OpenLevel"`		//解锁主角等级要求
-	OpenNeedCost	[]string	`csv:"OpenNeedCost"`		//解锁需求
-	Pos	int32	`csv:"Pos"`		//技能树位置件
-	Order	int32	`csv:"order"`		//技能排序
-	SuperSkill	[]string	`csv:"SuperSkill"`		//进阶技能
-	BeforeSkill	int32	`csv:"beforeSkill"`		//下阶技能
-	SkillBranch	int32	`csv:"SkillBranch"`		//进阶职业阶段
-	PressPoint	int32	`csv:"PressPoint"`		//技能压制值
-	StartPressPoint	int32	`csv:"StartPressPoint"`		//技能原压制值
+var SkillTreeCfgLoader map[int32]*SkillTreeCfg
+
+type SkillTreeCfg struct {
+	SkillId         int32    `csv:"SkillId"`         //技能ID
+	Name            string   `csv:"Name"`            //技能名字
+	SkillType       int32    `csv:"SkillType"`       //技能类型
+	MaxLv           int32    `csv:"MaxLv"`           //技能等级上限
+	SkillQuality    int32    `csv:"SkillQuality"`    //技能品质
+	JobType         int32    `csv:"JobType"`         //职业类型
+	JobBranch       int32    `csv:"JobBranch"`       //职业分支
+	JobStage        int32    `csv:"JobStage"`        //职业阶段
+	OpenLevel       int32    `csv:"OpenLevel"`       //解锁主角等级要求
+	OpenNeedCost    []string `csv:"OpenNeedCost"`    //解锁需求
+	Pos             int32    `csv:"Pos"`             //技能树位置件
+	Order           int32    `csv:"order"`           //技能排序
+	SuperSkill      []string `csv:"SuperSkill"`      //进阶技能
+	BeforeSkill     int32    `csv:"beforeSkill"`     //下阶技能
+	SkillBranch     int32    `csv:"SkillBranch"`     //进阶职业阶段
+	PressPoint      int32    `csv:"PressPoint"`      //技能压制值
+	StartPressPoint int32    `csv:"StartPressPoint"` //技能原压制值
 }
 }
+
 func SkillTreeCfgLoad(path string) {
 func SkillTreeCfgLoad(path string) {
 	cfg := []*SkillTreeCfg{}
 	cfg := []*SkillTreeCfg{}
 	SkillTreeCfgLoader = map[int32]*SkillTreeCfg{}
 	SkillTreeCfgLoader = map[int32]*SkillTreeCfg{}
-	loadCsvCfg(path + "SkillTreeCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"SkillTreeCfg.csv", &cfg)
+	for _, row := range cfg {
 		SkillTreeCfgLoader[row.SkillId] = row
 		SkillTreeCfgLoader[row.SkillId] = row
 	}
 	}
 }
 }
 
 
-var SkillUpEffectCfgLoader  map[int32]*SkillUpEffectCfg
-type SkillUpEffectCfg struct{
-	Id	int32	`csv:"Id"`		//技能ID
-	SkillId	int32	`csv:"SkillId"`		//技能ID
-	SkillLv	int32	`csv:"SkillLv"`		//技能等级
-	SkillType	int32	`csv:"SkillType"`		//技能类型
-	AddAttributes	[]string	`csv:"AddAttributes"`		//增加属性
+var SkillUpEffectCfgLoader map[int32]*SkillUpEffectCfg
+
+type SkillUpEffectCfg struct {
+	Id            int32    `csv:"Id"`            //技能ID
+	SkillId       int32    `csv:"SkillId"`       //技能ID
+	SkillLv       int32    `csv:"SkillLv"`       //技能等级
+	SkillType     int32    `csv:"SkillType"`     //技能类型
+	AddAttributes []string `csv:"AddAttributes"` //增加属性
 }
 }
+
 func SkillUpEffectCfgLoad(path string) {
 func SkillUpEffectCfgLoad(path string) {
 	cfg := []*SkillUpEffectCfg{}
 	cfg := []*SkillUpEffectCfg{}
 	SkillUpEffectCfgLoader = map[int32]*SkillUpEffectCfg{}
 	SkillUpEffectCfgLoader = map[int32]*SkillUpEffectCfg{}
-	loadCsvCfg(path + "SkillUpEffectCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"SkillUpEffectCfg.csv", &cfg)
+	for _, row := range cfg {
 		SkillUpEffectCfgLoader[row.Id] = row
 		SkillUpEffectCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var SummonServerCfgLoader  map[int32]*SummonServerCfg
-type SummonServerCfg struct{
-	Id	int32	`csv:"Id"`		//召唤Id
-	Name	string	`csv:"Name"`		//召唤名字
-	Cost	[]string	`csv:"Cost"`		//消耗道具顺序
-	Method	[]string	`csv:"Method"`		//召唤方式
-	DropId	int32	`csv:"DropId"`		//钥匙掉落包
-	DropId2	int32	`csv:"DropId2"`		//金币掉落包
-	Total	int32	`csv:"Total"`		//额外奖励的累计次数
-	ExtDropId	int32	`csv:"ExtDropId"`		//额外奖励的掉落包
-	SortId	int32	`csv:"SortId"`		//界面排序
-	ShowItemType	[]string	`csv:"ShowItemType"`		//可用于表现的道具类型
-	UnLock	int32	`csv:"UnLock"`		//解锁ID
-	ActivitiesId	int32	`csv:"ActivitiesId"`		//活动Id
-	Type	int32	`csv:"Type"`		//召唤类型
-	StartDay	int32	`csv:"StartDay"`		//开服时间
-	SummoType	int32	`csv:"SummoType"`		//召唤组
+var SummonServerCfgLoader map[int32]*SummonServerCfg
+
+type SummonServerCfg struct {
+	Id           int32    `csv:"Id"`           //召唤Id
+	Name         string   `csv:"Name"`         //召唤名字
+	Cost         []string `csv:"Cost"`         //消耗道具顺序
+	Method       []string `csv:"Method"`       //召唤方式
+	DropId       int32    `csv:"DropId"`       //钥匙掉落包
+	DropId2      int32    `csv:"DropId2"`      //金币掉落包
+	Total        int32    `csv:"Total"`        //额外奖励的累计次数
+	ExtDropId    int32    `csv:"ExtDropId"`    //额外奖励的掉落包
+	SortId       int32    `csv:"SortId"`       //界面排序
+	ShowItemType []string `csv:"ShowItemType"` //可用于表现的道具类型
+	UnLock       int32    `csv:"UnLock"`       //解锁ID
+	ActivitiesId int32    `csv:"ActivitiesId"` //活动Id
+	Type         int32    `csv:"Type"`         //召唤类型
+	StartDay     int32    `csv:"StartDay"`     //开服时间
+	SummoType    int32    `csv:"SummoType"`    //召唤组
 }
 }
+
 func SummonServerCfgLoad(path string) {
 func SummonServerCfgLoad(path string) {
 	cfg := []*SummonServerCfg{}
 	cfg := []*SummonServerCfg{}
 	SummonServerCfgLoader = map[int32]*SummonServerCfg{}
 	SummonServerCfgLoader = map[int32]*SummonServerCfg{}
-	loadCsvCfg(path + "SummonServerCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"SummonServerCfg.csv", &cfg)
+	for _, row := range cfg {
 		SummonServerCfgLoader[row.Id] = row
 		SummonServerCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var SummonTemplateCfgLoader  map[int32]*SummonTemplateCfg
-type SummonTemplateCfg struct{
-	Id	int32	`csv:"Id"`		//ID
-	BlueNum	[]string	`csv:"BlueNum"`		//蓝色
-	PurpleNum	[]string	`csv:"PurpleNum"`		//紫色
-	GoldNum	[]string	`csv:"GoldNum"`		//金色
-	SecurityNum	int32	`csv:"SecurityNum"`		//保底增加百分比
-	Probability1	int32	`csv:"Probability1"`		//用道具抽取权重
-	Probability2	int32	`csv:"Probability2"`		//用金币抽取权重
-	CardType	int32	`csv:"CardType"`		//类型
+var SummonTemplateCfgLoader map[int32]*SummonTemplateCfg
+
+type SummonTemplateCfg struct {
+	Id           int32    `csv:"Id"`           //ID
+	BlueNum      []string `csv:"BlueNum"`      //蓝色
+	PurpleNum    []string `csv:"PurpleNum"`    //紫色
+	GoldNum      []string `csv:"GoldNum"`      //金色
+	SecurityNum  int32    `csv:"SecurityNum"`  //保底增加百分比
+	Probability1 int32    `csv:"Probability1"` //用道具抽取权重
+	Probability2 int32    `csv:"Probability2"` //用金币抽取权重
+	CardType     int32    `csv:"CardType"`     //类型
 }
 }
+
 func SummonTemplateCfgLoad(path string) {
 func SummonTemplateCfgLoad(path string) {
 	cfg := []*SummonTemplateCfg{}
 	cfg := []*SummonTemplateCfg{}
 	SummonTemplateCfgLoader = map[int32]*SummonTemplateCfg{}
 	SummonTemplateCfgLoader = map[int32]*SummonTemplateCfg{}
-	loadCsvCfg(path + "SummonTemplateCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"SummonTemplateCfg.csv", &cfg)
+	for _, row := range cfg {
 		SummonTemplateCfgLoader[row.Id] = row
 		SummonTemplateCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var SysRewardLoader  map[int32]*SysReward
-type SysReward struct{
-	Id	int32	`csv:"Id"`		//爬塔层数
-	Reward	[]string	`csv:"Reward"`		//对应奖励
+var SysRewardLoader map[int32]*SysReward
+
+type SysReward struct {
+	Id     int32    `csv:"Id"`     //爬塔层数
+	Reward []string `csv:"Reward"` //对应奖励
 }
 }
+
 func SysRewardLoad(path string) {
 func SysRewardLoad(path string) {
 	cfg := []*SysReward{}
 	cfg := []*SysReward{}
 	SysRewardLoader = map[int32]*SysReward{}
 	SysRewardLoader = map[int32]*SysReward{}
-	loadCsvCfg(path + "SysReward.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"SysReward.csv", &cfg)
+	for _, row := range cfg {
 		SysRewardLoader[row.Id] = row
 		SysRewardLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var TargetTaskCfgLoader  map[int32]*TargetTaskCfg
-type TargetTaskCfg struct{
-	TargetTaskId	int32	`csv:"TargetTaskId"`		//任务ID
-	TargetTaskCondition	[]string	`csv:"TargetTaskCondition"`		//任务枚举
-	TargetTaskType	int32	`csv:"TargetTaskType"`		//任务类型
-	TargetReward	[]string	`csv:"TargetReward"`		//任务奖励
-	FollowTaskOld	int32	`csv:"FollowTaskOld"`		//后续ID
-	TargetTaskTitle	string	`csv:"TargetTaskTitle"`		//任务标题
-	TargetTaskDescribe	string	`csv:"TargetTaskDescribe"`		//任务描述
-	SkipInterface	int32	`csv:"SkipInterface"`		//跳转界面
-	ShowState	int32	`csv:"ShowState"`		//是否显示进度
+var TargetTaskCfgLoader map[int32]*TargetTaskCfg
+
+type TargetTaskCfg struct {
+	TargetTaskId        int32    `csv:"TargetTaskId"`        //任务ID
+	TargetTaskCondition []string `csv:"TargetTaskCondition"` //任务枚举
+	TargetTaskType      int32    `csv:"TargetTaskType"`      //任务类型
+	TargetReward        []string `csv:"TargetReward"`        //任务奖励
+	FollowTaskOld       int32    `csv:"FollowTaskOld"`       //后续ID
+	TargetTaskTitle     string   `csv:"TargetTaskTitle"`     //任务标题
+	TargetTaskDescribe  string   `csv:"TargetTaskDescribe"`  //任务描述
+	SkipInterface       int32    `csv:"SkipInterface"`       //跳转界面
+	ShowState           int32    `csv:"ShowState"`           //是否显示进度
 }
 }
+
 func TargetTaskCfgLoad(path string) {
 func TargetTaskCfgLoad(path string) {
 	cfg := []*TargetTaskCfg{}
 	cfg := []*TargetTaskCfg{}
 	TargetTaskCfgLoader = map[int32]*TargetTaskCfg{}
 	TargetTaskCfgLoader = map[int32]*TargetTaskCfg{}
-	loadCsvCfg(path + "TargetTaskCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"TargetTaskCfg.csv", &cfg)
+	for _, row := range cfg {
 		TargetTaskCfgLoader[row.TargetTaskId] = row
 		TargetTaskCfgLoader[row.TargetTaskId] = row
 	}
 	}
 }
 }
 
 
-var TopTowerCfgLevelLoader  map[int32]*TopTowerCfgLevel
-type TopTowerCfgLevel struct{
-	LevelId	int32	`csv:"LevelId"`		//区间ID
-	RankId	[]string	`csv:"RankId"`		//排名ID
-	LevelRank1	[]string	`csv:"LevelRank1"`		//第1层
-	LevelRank2	[]string	`csv:"LevelRank2"`		//第2层
-	LevelRank3	[]string	`csv:"LevelRank3"`		//第3层
-	LevelRank4	[]string	`csv:"LevelRank4"`		//第4层
-	LevelRank5	[]string	`csv:"LevelRank5"`		//第5层
-	LevelRank6	[]string	`csv:"LevelRank6"`		//第6层
-	LevelRank7	[]string	`csv:"LevelRank7"`		//第7层
-	LevelRank8	[]string	`csv:"LevelRank8"`		//第8层
-	LevelRank9	[]string	`csv:"LevelRank9"`		//第9层
-	LevelRank10	[]string	`csv:"LevelRank10"`		//第10层
+var TopTowerCfgLevelLoader map[int32]*TopTowerCfgLevel
+
+type TopTowerCfgLevel struct {
+	LevelId     int32    `csv:"LevelId"`     //区间ID
+	RankId      []string `csv:"RankId"`      //排名ID
+	LevelRank1  []string `csv:"LevelRank1"`  //第1层
+	LevelRank2  []string `csv:"LevelRank2"`  //第2层
+	LevelRank3  []string `csv:"LevelRank3"`  //第3层
+	LevelRank4  []string `csv:"LevelRank4"`  //第4层
+	LevelRank5  []string `csv:"LevelRank5"`  //第5层
+	LevelRank6  []string `csv:"LevelRank6"`  //第6层
+	LevelRank7  []string `csv:"LevelRank7"`  //第7层
+	LevelRank8  []string `csv:"LevelRank8"`  //第8层
+	LevelRank9  []string `csv:"LevelRank9"`  //第9层
+	LevelRank10 []string `csv:"LevelRank10"` //第10层
 }
 }
+
 func TopTowerCfgLevelLoad(path string) {
 func TopTowerCfgLevelLoad(path string) {
 	cfg := []*TopTowerCfgLevel{}
 	cfg := []*TopTowerCfgLevel{}
 	TopTowerCfgLevelLoader = map[int32]*TopTowerCfgLevel{}
 	TopTowerCfgLevelLoader = map[int32]*TopTowerCfgLevel{}
-	loadCsvCfg(path + "TopTowerCfgLevel.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"TopTowerCfgLevel.csv", &cfg)
+	for _, row := range cfg {
 		TopTowerCfgLevelLoader[row.LevelId] = row
 		TopTowerCfgLevelLoader[row.LevelId] = row
 	}
 	}
 }
 }
 
 
-var TopTowerCfgRewardLoader  map[int32]*TopTowerCfgReward
-type TopTowerCfgReward struct{
-	LevelId	int32	`csv:"LevelId"`		//层数
-	RewardItems	[]string	`csv:"RewardItems"`		//层数奖励
-	BuyRoadCost	[]string	`csv:"BuyRoadCost"`		//买路花费
+var TopTowerCfgRewardLoader map[int32]*TopTowerCfgReward
+
+type TopTowerCfgReward struct {
+	LevelId     int32    `csv:"LevelId"`     //层数
+	RewardItems []string `csv:"RewardItems"` //层数奖励
+	BuyRoadCost []string `csv:"BuyRoadCost"` //买路花费
 }
 }
+
 func TopTowerCfgRewardLoad(path string) {
 func TopTowerCfgRewardLoad(path string) {
 	cfg := []*TopTowerCfgReward{}
 	cfg := []*TopTowerCfgReward{}
 	TopTowerCfgRewardLoader = map[int32]*TopTowerCfgReward{}
 	TopTowerCfgRewardLoader = map[int32]*TopTowerCfgReward{}
-	loadCsvCfg(path + "TopTowerCfgReward.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"TopTowerCfgReward.csv", &cfg)
+	for _, row := range cfg {
 		TopTowerCfgRewardLoader[row.LevelId] = row
 		TopTowerCfgRewardLoader[row.LevelId] = row
 	}
 	}
 }
 }
 
 
-var TransportCfgLoader  map[int32]*TransportCfg
-type TransportCfg struct{
-	ShipLevel	int32	`csv:"ShipLevel"`		//飞艇等级
-	Duration	int32	`csv:"Duration"`		//远航完成时长
-	Consume	[]string	`csv:"Consume"`		//飞艇升级消耗
-	Probability	int32	`csv:"Probability"`		//飞艇升级成功率
-	TranspoertReward	[]string	`csv:"TranspoertReward"`		//远航完成奖励
-	RobberyTimes	int32	`csv:"RobberyTimes"`		//被打劫次数
-	RobberyLose	[]string	`csv:"RobberyLose"`		//被打劫后损失奖励
-	RobberyReward	[]string	`csv:"RobberyReward"`		//打劫奖励
-	RobberyFraction	int32	`csv:"RobberyFraction"`		//打劫获得积分
-	TopLevel	[]string	`csv:"TopLevel"`		//直接升至顶级
+var TransportCfgLoader map[int32]*TransportCfg
+
+type TransportCfg struct {
+	ShipLevel        int32    `csv:"ShipLevel"`        //飞艇等级
+	Duration         int32    `csv:"Duration"`         //远航完成时长
+	Consume          []string `csv:"Consume"`          //飞艇升级消耗
+	Probability      int32    `csv:"Probability"`      //飞艇升级成功率
+	TranspoertReward []string `csv:"TranspoertReward"` //远航完成奖励
+	RobberyTimes     int32    `csv:"RobberyTimes"`     //被打劫次数
+	RobberyLose      []string `csv:"RobberyLose"`      //被打劫后损失奖励
+	RobberyReward    []string `csv:"RobberyReward"`    //打劫奖励
+	RobberyFraction  int32    `csv:"RobberyFraction"`  //打劫获得积分
+	TopLevel         []string `csv:"TopLevel"`         //直接升至顶级
 }
 }
+
 func TransportCfgLoad(path string) {
 func TransportCfgLoad(path string) {
 	cfg := []*TransportCfg{}
 	cfg := []*TransportCfg{}
 	TransportCfgLoader = map[int32]*TransportCfg{}
 	TransportCfgLoader = map[int32]*TransportCfg{}
-	loadCsvCfg(path + "TransportCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"TransportCfg.csv", &cfg)
+	for _, row := range cfg {
 		TransportCfgLoader[row.ShipLevel] = row
 		TransportCfgLoader[row.ShipLevel] = row
 	}
 	}
 }
 }
 
 
-var UIFuncUnLockCfgLoader  map[int32]*UIFuncUnLockCfg
-type UIFuncUnLockCfg struct{
-	Id	int32	`csv:"Id"`		//ID
-	UIId	int32	`csv:"UIId"`		//界面ID
-	UnlockCond	[]string	`csv:"UnlockCond"`		//解锁条件列表
-	LockNotice	string	`csv:"LockNotice"`		//锁定提示
-	NeedLock	bool	`csv:"NeedLock"`		//需要锁定
-	NeedMask	bool	`csv:"NeedMask"`		//需要按钮遮挡
-	NeedNotify	bool	`csv:"NeedNotify"`		//需要提示界面
-	NeedGuide	bool	`csv:"NeedGuide"`		//需要引导
-	NeedDisplay	bool	`csv:"NeedDisplay"`		//需要显示
-	PrePose	int32	`csv:"PrePose"`		//前置
-	PostPose	int32	`csv:"PostPose"`		//后置
-	ForceGuideGroup	int32	`csv:"ForceGuideGroup"`		//强制引导
+var UIFuncUnLockCfgLoader map[int32]*UIFuncUnLockCfg
+
+type UIFuncUnLockCfg struct {
+	Id              int32    `csv:"Id"`              //ID
+	UIId            int32    `csv:"UIId"`            //界面ID
+	UnlockCond      []string `csv:"UnlockCond"`      //解锁条件列表
+	LockNotice      string   `csv:"LockNotice"`      //锁定提示
+	NeedLock        bool     `csv:"NeedLock"`        //需要锁定
+	NeedMask        bool     `csv:"NeedMask"`        //需要按钮遮挡
+	NeedNotify      bool     `csv:"NeedNotify"`      //需要提示界面
+	NeedGuide       bool     `csv:"NeedGuide"`       //需要引导
+	NeedDisplay     bool     `csv:"NeedDisplay"`     //需要显示
+	PrePose         int32    `csv:"PrePose"`         //前置
+	PostPose        int32    `csv:"PostPose"`        //后置
+	ForceGuideGroup int32    `csv:"ForceGuideGroup"` //强制引导
 }
 }
+
 func UIFuncUnLockCfgLoad(path string) {
 func UIFuncUnLockCfgLoad(path string) {
 	cfg := []*UIFuncUnLockCfg{}
 	cfg := []*UIFuncUnLockCfg{}
 	UIFuncUnLockCfgLoader = map[int32]*UIFuncUnLockCfg{}
 	UIFuncUnLockCfgLoader = map[int32]*UIFuncUnLockCfg{}
-	loadCsvCfg(path + "UIFuncUnLockCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"UIFuncUnLockCfg.csv", &cfg)
+	for _, row := range cfg {
 		UIFuncUnLockCfgLoader[row.Id] = row
 		UIFuncUnLockCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var VipCfgLoader  map[int32]*VipCfg
-type VipCfg struct{
-	Lv	int32	`csv:"Lv"`		//Vip等级
-	QuickBattle	int32	`csv:"QuickBattle"`		//战斗X2加速
-	Reward	[]string	`csv:"Reward"`		//Vip道具奖励
-	VipExp	int32	`csv:"VipExp"`		//Vip升级所需经验
-	EvilFreeTimes	int32	`csv:"EvilFreeTimes"`		//恶魔免费刷新次数
-	VipLogin	int32	`csv:"VipLogin"`		//VIP上线提示
-	PetAdvance	int32	`csv:"PetAdvance"`		//宠物进阶消耗免费
-	CardReset	int32	`csv:"CardReset"`		//卡片重铸免费
-	PetBreak	int32	`csv:"PetBreak"`		//宠物分解全额返还
-	SkillReset	int32	`csv:"SkillReset"`		//角色技能重置免费
-	GuildBossChallenge	int32	`csv:"GuildBossChallenge"`		//公会狩猎额外次数
-	CardInsertion	int32	`csv:"CardInsertion"`		//一键插卡功能
-	ShopWeight	int32	`csv:"ShopWeight"`		//黑市VIP权重
-	WorldBoss	int32	`csv:"WorldBoss"`		//世界BOSS刮奖次数
-	PvpReward	int32	`csv:"PvpReward"`		//额外荣誉之证
-	HangupTimes	int32	`csv:"HangupTimes"`		//时光之力购买次数
-	SilverUp	int32	`csv:"SilverUp"`		//银币加成
-	BaseExpUp	int32	`csv:"BaseExpUp"`		//基础经验加成
-	PartnerExpUp	int32	`csv:"PartnerExpUp"`		//伙伴经验加成
-	SkillExpUp	int32	`csv:"SkillExpUp"`		//技能经验加成
-	GiftBuyTimes	[]string	`csv:"GiftBuyTimes"`		//每日礼包购买次数+1
-	HangupDuration	int32	`csv:"HangupDuration"`		//离线挂机时长上限(秒)
-	SignInRewardUp	int32	`csv:"SignInRewardUp"`		//签到翻倍
-	WorldBossCount	int32	`csv:"WorldBossCount"`		//世界BOSS购买次数
-	DevilsUp	int32	`csv:"DevilsUp"`		//挂机魔魂值加成
-	TransportRobbery	int32	`csv:"TransportRobbery"`		//飞艇被抢劫掉落减少至
+var VipCfgLoader map[int32]*VipCfg
+
+type VipCfg struct {
+	Lv                 int32    `csv:"Lv"`                 //Vip等级
+	QuickBattle        int32    `csv:"QuickBattle"`        //战斗X2加速
+	Reward             []string `csv:"Reward"`             //Vip道具奖励
+	VipExp             int32    `csv:"VipExp"`             //Vip升级所需经验
+	EvilFreeTimes      int32    `csv:"EvilFreeTimes"`      //恶魔免费刷新次数
+	VipLogin           int32    `csv:"VipLogin"`           //VIP上线提示
+	PetAdvance         int32    `csv:"PetAdvance"`         //宠物进阶消耗免费
+	CardReset          int32    `csv:"CardReset"`          //卡片重铸免费
+	PetBreak           int32    `csv:"PetBreak"`           //宠物分解全额返还
+	SkillReset         int32    `csv:"SkillReset"`         //角色技能重置免费
+	GuildBossChallenge int32    `csv:"GuildBossChallenge"` //公会狩猎额外次数
+	CardInsertion      int32    `csv:"CardInsertion"`      //一键插卡功能
+	ShopWeight         int32    `csv:"ShopWeight"`         //黑市VIP权重
+	WorldBoss          int32    `csv:"WorldBoss"`          //世界BOSS刮奖次数
+	PvpReward          int32    `csv:"PvpReward"`          //额外荣誉之证
+	HangupTimes        int32    `csv:"HangupTimes"`        //时光之力购买次数
+	SilverUp           int32    `csv:"SilverUp"`           //银币加成
+	BaseExpUp          int32    `csv:"BaseExpUp"`          //基础经验加成
+	PartnerExpUp       int32    `csv:"PartnerExpUp"`       //伙伴经验加成
+	SkillExpUp         int32    `csv:"SkillExpUp"`         //技能经验加成
+	GiftBuyTimes       []string `csv:"GiftBuyTimes"`       //每日礼包购买次数+1
+	HangupDuration     int32    `csv:"HangupDuration"`     //离线挂机时长上限(秒)
+	SignInRewardUp     int32    `csv:"SignInRewardUp"`     //签到翻倍
+	WorldBossCount     int32    `csv:"WorldBossCount"`     //世界BOSS购买次数
+	DevilsUp           int32    `csv:"DevilsUp"`           //挂机魔魂值加成
+	TransportRobbery   int32    `csv:"TransportRobbery"`   //飞艇被抢劫掉落减少至
 }
 }
+
 func VipCfgLoad(path string) {
 func VipCfgLoad(path string) {
 	cfg := []*VipCfg{}
 	cfg := []*VipCfg{}
 	VipCfgLoader = map[int32]*VipCfg{}
 	VipCfgLoader = map[int32]*VipCfg{}
-	loadCsvCfg(path + "VipCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"VipCfg.csv", &cfg)
+	for _, row := range cfg {
 		VipCfgLoader[row.Lv] = row
 		VipCfgLoader[row.Lv] = row
 	}
 	}
 }
 }
 
 
-var WishCfgLoader  map[int32]*WishCfg
-type WishCfg struct{
-	Id	int32	`csv:"Id"`		//ID
-	Name	string	`csv:"Name"`		//名字
-	BoxType	int32	`csv:"BoxType"`		//宝箱类型
-	WishReward	[]string	`csv:"WishReward"`		//许愿奖励(随机/权重:道具:数量/自选/道具:数量)
-	AccelerateCost	[]string	`csv:"AccelerateCost"`		//加速消耗
-	LuckyProbability	int32	`csv:"LuckyProbability"`		//暴击概率(百分比)
-	LuckyReward	[]string	`csv:"LuckyReward"`		//暴击奖励(概率:道具:数量)
-	WishCountdown	int32	`csv:"WishCountdown"`		//倒计时(秒)
+var WishCfgLoader map[int32]*WishCfg
+
+type WishCfg struct {
+	Id               int32    `csv:"Id"`               //ID
+	Name             string   `csv:"Name"`             //名字
+	BoxType          int32    `csv:"BoxType"`          //宝箱类型
+	WishReward       []string `csv:"WishReward"`       //许愿奖励(随机/权重:道具:数量/自选/道具:数量)
+	AccelerateCost   []string `csv:"AccelerateCost"`   //加速消耗
+	LuckyProbability int32    `csv:"LuckyProbability"` //暴击概率(百分比)
+	LuckyReward      []string `csv:"LuckyReward"`      //暴击奖励(概率:道具:数量)
+	WishCountdown    int32    `csv:"WishCountdown"`    //倒计时(秒)
 }
 }
+
 func WishCfgLoad(path string) {
 func WishCfgLoad(path string) {
 	cfg := []*WishCfg{}
 	cfg := []*WishCfg{}
 	WishCfgLoader = map[int32]*WishCfg{}
 	WishCfgLoader = map[int32]*WishCfg{}
-	loadCsvCfg(path + "WishCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"WishCfg.csv", &cfg)
+	for _, row := range cfg {
 		WishCfgLoader[row.Id] = row
 		WishCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var WorldBossCfgLoader  map[int32]*WorldBossCfg
-type WorldBossCfg struct{
-	Id	int32	`csv:"Id"`		//全局配置id
-	SummonId	int32	`csv:"SummonId"`		//召唤物id
-	StartDay	int32	`csv:"StartDay"`		//开服时间
-	Tiaozhantiaojian	int32	`csv:"Tiaozhantiaojian"`		//解锁条件
-	SummonTime	[]string	`csv:"SummonTime"`		//召唤时间
-	LifeTime	int32	`csv:"LifeTime"`		//存活时间
-	FirstRewardServer	[]string	`csv:"FirstRewardServer"`		//1等奖
-	SecondRewardServer	[]string	`csv:"SecondRewardServer"`		//2等奖
-	ThreeRewardServer	[]string	`csv:"ThreeRewardServer"`		//3等奖奖
-	Roll	[]string	`csv:"Roll"`		//中将概率
-	Roll2	[]string	`csv:"Roll2"`		//衰减概率
-	AutoHp	[]string	`csv:"AutoHp"`		//系统掉血
+var WorldBossCfgLoader map[int32]*WorldBossCfg
+
+type WorldBossCfg struct {
+	Id                 int32    `csv:"Id"`                 //全局配置id
+	SummonId           int32    `csv:"SummonId"`           //召唤物id
+	StartDay           int32    `csv:"StartDay"`           //开服时间
+	Tiaozhantiaojian   int32    `csv:"Tiaozhantiaojian"`   //解锁条件
+	SummonTime         []string `csv:"SummonTime"`         //召唤时间
+	LifeTime           int32    `csv:"LifeTime"`           //存活时间
+	FirstRewardServer  []string `csv:"FirstRewardServer"`  //1等奖
+	SecondRewardServer []string `csv:"SecondRewardServer"` //2等奖
+	ThreeRewardServer  []string `csv:"ThreeRewardServer"`  //3等奖奖
+	Roll               []string `csv:"Roll"`               //中将概率
+	Roll2              []string `csv:"Roll2"`              //衰减概率
+	AutoHp             []string `csv:"AutoHp"`             //系统掉血
 }
 }
+
 func WorldBossCfgLoad(path string) {
 func WorldBossCfgLoad(path string) {
 	cfg := []*WorldBossCfg{}
 	cfg := []*WorldBossCfg{}
 	WorldBossCfgLoader = map[int32]*WorldBossCfg{}
 	WorldBossCfgLoader = map[int32]*WorldBossCfg{}
-	loadCsvCfg(path + "WorldBossCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"WorldBossCfg.csv", &cfg)
+	for _, row := range cfg {
 		WorldBossCfgLoader[row.Id] = row
 		WorldBossCfgLoader[row.Id] = row
 	}
 	}
 }
 }
 
 
-var WorldBossChangePlayCfgLoader  map[int32]*WorldBossChangePlayCfg
-type WorldBossChangePlayCfg struct{
-	Id	int32	`csv:"Id"`		//全局配置id
-	SummonId	int32	`csv:"SummonId"`		//召唤物id
-	Consume	[]string	`csv:"Consume"`		//消耗资源
-	StartTime	string	`csv:"StartTime"`		//活动开始时间
-	EndTime	string	`csv:"EndTime"`		//活动结束时间
-	SummonTime	[]string	`csv:"SummonTime"`		//召唤时间
-	LifeTime	int32	`csv:"LifeTime"`		//存活时间
-	ChangePlayId	[]string	`csv:"ChangePlayId"`		//变身
-	FirstRewardServer	[]string	`csv:"FirstRewardServer"`		//1等奖
-	SecondRewardServer	[]string	`csv:"SecondRewardServer"`		//2等奖
-	ThreeRewardServer	[]string	`csv:"ThreeRewardServer"`		//3等奖奖
-	Roll	[]string	`csv:"Roll"`		//中将概率
-	Roll2	[]string	`csv:"Roll2"`		//衰减概率
-	AutoHp	[]string	`csv:"AutoHp"`		//系统掉血
-	HpSegment	int32	`csv:"HpSegment"`		//血条段数
+var WorldBossChangePlayCfgLoader map[int32]*WorldBossChangePlayCfg
+
+type WorldBossChangePlayCfg struct {
+	Id                 int32    `csv:"Id"`                 //全局配置id
+	SummonId           int32    `csv:"SummonId"`           //召唤物id
+	Consume            []string `csv:"Consume"`            //消耗资源
+	StartTime          string   `csv:"StartTime"`          //活动开始时间
+	EndTime            string   `csv:"EndTime"`            //活动结束时间
+	SummonTime         []string `csv:"SummonTime"`         //召唤时间
+	LifeTime           int32    `csv:"LifeTime"`           //存活时间
+	ChangePlayId       []string `csv:"ChangePlayId"`       //变身
+	FirstRewardServer  []string `csv:"FirstRewardServer"`  //1等奖
+	SecondRewardServer []string `csv:"SecondRewardServer"` //2等奖
+	ThreeRewardServer  []string `csv:"ThreeRewardServer"`  //3等奖奖
+	Roll               []string `csv:"Roll"`               //中将概率
+	Roll2              []string `csv:"Roll2"`              //衰减概率
+	AutoHp             []string `csv:"AutoHp"`             //系统掉血
+	HpSegment          int32    `csv:"HpSegment"`          //血条段数
 }
 }
+
 func WorldBossChangePlayCfgLoad(path string) {
 func WorldBossChangePlayCfgLoad(path string) {
 	cfg := []*WorldBossChangePlayCfg{}
 	cfg := []*WorldBossChangePlayCfg{}
 	WorldBossChangePlayCfgLoader = map[int32]*WorldBossChangePlayCfg{}
 	WorldBossChangePlayCfgLoader = map[int32]*WorldBossChangePlayCfg{}
-	loadCsvCfg(path + "WorldBossChangePlayCfg.csv", &cfg)
-	for _,row := range cfg{
+	loadCsvCfg(path+"WorldBossChangePlayCfg.csv", &cfg)
+	for _, row := range cfg {
 		WorldBossChangePlayCfgLoader[row.Id] = row
 		WorldBossChangePlayCfgLoader[row.Id] = row
 	}
 	}
-}
+}
+
+var HardLevelCfgLoader map[int32]*HardLevelCfg
+
+type HardLevelCfg struct {
+	Id         int32 `csv:"Id"`         //唯一id
+	LevelId    int32 `csv:"LevelId"`    //场景id
+	MapId      int32 `csv:"MapId"`      //地图id
+	BaseExp    int32 `csv:"BaseExp"`    //通关base经验
+	JobExp     int32 `csv:"JobExp"`     //通关job经验
+	Zeny       int32 `csv:"Zeny"`       //通关银币
+	Gold       int32 `csv:"Gold"`       //通关金币
+	Parter     int32 `csv:"Parter"`     //通关伙伴经验
+	Cash       int32 `csv:"Cash"`       //活动通关现金
+	FreeInvest int32 `csv:"FreeInvest"` //通关免费充值额度
+}
+
+func HardLevelCfgLoad(path string) {
+	cfg := []*HardLevelCfg{}
+	HardLevelCfgLoader = map[int32]*HardLevelCfg{}
+	loadCsvCfg(path+"HardLevelCfg.csv", &cfg)
+	for _, row := range cfg {
+		HardLevelCfgLoader[row.Id] = row
+	}
+}