引擎源码分析

根据代码分析，hum.db的主要数据结构如下: 记录头部结构(TRecordHeader): TRecordHeader = packed record boDeleted: Boolean; // 是否删除 nSelectID: Byte; // 选择ID boIsHe...

meinvwudi · 2024-12-16T03:34:40+00:00

根据代码分析，hum.db的主要数据结构如下: 记录头部结构(TRecordHeader): TRecordHeader = packed record boDeleted: Boolean; // 是否删除 nSelectID: Byte; // 选择ID boIsHe...

引擎源码分析

meinvwudi

根据代码分析，hum.db的主要数据结构如下:

记录头部结构(TRecordHeader):
```
TRecordHeader = packed record 
  boDeleted: Boolean;      // 是否删除
  nSelectID: Byte;         // 选择ID
  boIsHero: Boolean;       // 是否是英雄
  bt2: Byte;
  dCreateDate: TDateTime;  // 创建时间
  sName: string[15];       // 角色名称
end;
```
主要数据结构(THumData):
```
THumData = packed record
  // 基本信息
  sChrName: string[ACTORNAMELEN];  // 角色名
  sCurMap: string[MAPNAMELEN];     // 当前地图
  wCurX: Word;                     // 当前X坐标
  wCurY: Word;                     // 当前Y坐标
  btDir: Byte;                     // 方向
  btHair: Byte;                    // 发型
  btSex: Byte;                     // 性别
  btJob: Byte;                     // 职业
  nGold: Integer;                  // 金币
  
  // 能力值
  Abil: TOAbility;                 // 基础属性
  BonusAbil: TNakedAbility;        // 奖励属性
  nBonusPoint: Integer;            // 奖励点数
  
  // 装备和物品
  HumItems: THumItems;             // 装备栏(9格)
  BagItems: TBagItems;             // 背包(46格)
  StorageItems: TStorageItems;     // 仓库(46格)
  HumAddItems: THumAddItems;       // 附加装备(4格)
  
  // 其他属性
  nGameGold: Integer;              // 元宝
  nGamePoint: Integer;             // 游戏点数
  nGameDiamond: Integer;           // 金刚石
  nGameGird: Integer;              // 灵符
  nGameGlory: Integer;             // 荣誉
  
  // 状态标记
  QuestFlag: TQuestFlag;           // 任务标记
  NewStatus: TNewStatus;           // 状态(失明、混乱等)
  wStatusDelayTime: Word;          // 状态持续时间
end;
```
1. 完整记录结构(THumDataInfo):
```
THumDataInfo = packed record
  Header: TRecordHeader;    // 记录头
  Data: THumData;          // 角色数据
end;
```
主要特点:
- 使用packed record紧凑存储
- 包含角色的所有基本信息、属性、装备、状态等
- 支持英雄系统(HEROVERSION = 1时)
- 包含多种货币系统(金币、元宝、点数等)
- 有完整的装备和物品存储系统
这个数据结构设计用于存储游戏中角色的所有相关数据。

meinvwudi

THumData = packed record //Size = 3164
    sChrName: string[ACTORNAMELEN];
    sCurMap: string[MAPNAMELEN];
    wCurX: Word;
    wCurY: Word;
    btDir: Byte;
    btHair: Byte;
    btSex: Byte;
    btJob: Byte;
    nGold: Integer;
    Abil: TOAbility; //+40
    wStatusTimeArr: TStatusTime; //+24
    sHomeMap: string[MAPNAMELEN];
    //btUnKnow1: Byte;
    wHomeX: Word;
    wHomeY: Word;
    sDearName: string[ACTORNAMELEN];
    sMasterName: string[ACTORNAMELEN];
    boMaster: Boolean;
    btCreditPoint: Byte;
    btDivorce: Byte; //是否结婚
    btMarryCount: Byte; //结婚次数
    sStoragePwd: string[7];
    btReLevel: Byte;
    boOnHorse: Boolean;
    //btUnKnow2: array[0..1] of Byte;
    BonusAbil: TNakedAbility; //+20
    nBonusPoint: Integer;
    nGameGold: Integer;
    nGamePoint: Integer;
    nPayMentPoint: Integer; //充值点
    n: Integer;
    nPKPOINT: Integer;
    btAllowGroup: Byte;
    btF9: Byte;
    btAttatckMode: Byte;
    btIncHealth: Byte;
    btIncSpell: Byte;
    btIncHealing: Byte;
    btFightZoneDieCount: Byte;
    sAccount: string[10];
    btEE: Byte;
    btEF: Byte;
    boLockLogon: Boolean;
    wContribution: Word;
    nHungerStatus: Integer;
    boAllowGuildReCall: Boolean; //  是否允许行会合一
    wGroupRcallTime: Word; //队传送时间
    dBodyLuck: Double; //幸运度  8
    boAllowGroupReCall: Boolean; // 是否允许天地合一
    nEXPRATE: Integer; //经验倍数
    nExpTime: Integer; //经验倍数时间
    btLastOutStatus: Byte; //2006-01-12增加 退出状态 1为死亡退出
    wMasterCount: Word; //出师徒弟数
    boHasHero: Boolean; //是否有英雄
    boIsHero: Boolean; //是否是英雄
    btStatus: Byte; //状态
    sHeroChrName: string[ACTORNAMELEN];
    nGrudge: Integer;
    //UnKnow: TUnKnow;
    QuestFlag: TQuestFlag; //脚本变量

    HumItems: THumItems; //9格装备 衣服  武器  蜡烛 头盔 项链 手镯 手镯 戒指 戒指
    BagItems: TBagItems; //包裹装备
    HumMagics: THumMagics; //魔法
    StorageItems: TStorageItems; //仓库物品
    HumAddItems: THumAddItems; //新增4格 护身符 腰带 鞋子 宝石
  end;
  pTHumData = ^THumData;

源码中的 \GameOfMir(支持WZL格式_新旧土城地图)\GameOfMir(支持新旧土城地图)\Common\Grobal2.pas

meinvwudi

玩家详情 mir.db 中保存的数据库结构

TOAbility = packed record
  Level: Word;          // 等级
  AC: Word;            // 防御
  MAC: Word;           // 魔法防御
  DC: Word;            // 攻击力
  MC: Word;            // 魔法力
  SC: Word;            // 道术力
  HP: Word;            // 生命值
  MP: Word;            // 魔法值
  MaxHP: Word;         // 最大生命值
  MaxMP: Word;         // 最大魔法值
  Exp: LongWord;       // 经验值
  MaxExp: LongWord;    // 最大经验值
  Weight: Word;        // 负重
  MaxWeight: Word;     // 最大负重
  WearWeight: Word;    // 穿戴负重
  MaxWearWeight: Word; // 最大穿戴负重
  HandWeight: Word;    // 腕力负重
  MaxHandWeight: Word; // 最大腕力负重
end;

装备信息

THumItems = array[0..U_CHARM] of TUserItem;  // 总共13个装备位置(0-12)

TUserItem = packed record
  wIndex: Word;             // 物品索引
  MakeIndex: Integer;       // 制造索引(物品唯一ID)
  Dura: Word;              // 当前持久
  DuraMax: Word;           // 最大持久
  btValue: array[0..13] of Byte;  // 附加属性值
end;

// 装备位置常量定义:
const
  U_DRESS = 0;      // 衣服
  U_WEAPON = 1;     // 武器
  U_RIGHTHAND = 2;  // 右手
  U_NECKLACE = 3;   // 项链
  U_HELMET = 4;     // 头盔
  U_ARMRINGL = 5;   // 左手镯
  U_ARMRINGR = 6;   // 右手镯
  U_RINGL = 7;      // 左戒指
  U_RINGR = 8;      // 右戒指
  U_BUJUK = 9;      // 符
  U_BELT = 10;      // 腰带
  U_BOOTS = 11;     // 鞋子
  U_CHARM = 12;     // 宝石

THumItems = array[0..12] of TUserItem;  // 装备栏
// 装备位置定义:
U_DRESS = 0;     // 衣服
U_WEAPON = 1;    // 武器
U_RIGHTHAND = 2; // 右手
U_NECKLACE = 3;  // 项链  
U_HELMET = 4;    // 头盔
U_ARMRINGL = 5;  // 左手镯
U_ARMRINGR = 6;  // 右手镯
U_RINGL = 7;     // 左戒指
U_RINGR = 8;     // 右戒指
U_BUJUK = 9;     // 符
U_BELT = 10;     // 腰带
U_BOOTS = 11;    // 鞋子
U_CHARM = 12;    // 宝石

meinvwudi

根据代码中的定义，包裹(背包)的数据结构如下：

const
  MAXBAGITEM = 46;      //普通角色最大包裹物品数量
  MAXHEROBAGITEM = 40;  //英雄包裹最大物品数量

type
  TOBagItems = array[0..MAXBAGITEM-1] of TUserItem;  //普通角色包裹
  TOHeroBagItems = array[0..MAXHEROBAGITEM-1] of TUserItem;  //英雄包裹

  TUserItem = packed record
    wIndex: Word;             //物品索引(对应标准物品库)
    MakeIndex: Integer;       //制造索引(物品唯一ID)
    Dura: Word;              //当前持久
    DuraMax: Word;           //最大持久
    btValue: array[0..13] of Byte;  //附加属性值
  end;

  //背包中的物品结构(客户端使用)
  TClientItem = packed record
    s: TUserItem;            //物品基本信息
    Item: TStdItem;         //标准物品信息
    bo01: Boolean;
  end;

  //背包物品数组(客户端使用)
  TItemArr = array[0..46-1] of TClientItem;
  THeroItemArr = array[0..40-1] of TClientItem;

主要特点：

包裹容量：
- 普通角色：46格
- 英雄角色：40格
每个物品包含：
- wIndex: 物品类型索引
- MakeIndex: 物品唯一ID
- Dura: 当前持久度
- DuraMax: 最大持久度
- btValue: 14个字节的附加属性数组
客户端额外信息：
- TClientItem包含完整的标准物品信息(TStdItem)
- 用于显示物品详细属性
相关操作命令：
```
const
  CM_DROPITEM = 1000;    //扔物品
  CM_PICKUP = 1001;      //捡物品
  CM_TAKEONITEM = 1003;  //装备物品
  CM_TAKEOFFITEM = 1004; //卸下装备
  CM_EAT = 1006;         //使用物品
```
物品操作消息：
```
const
  SM_ADDITEM = 200;        //添加物品
  SM_BAGITEMS = 201;       //背包物品列表
  SM_DELITEM = 202;        //删除物品
  SM_UPDATEITEM = 203;     //更新物品
  SM_UPDATEITEM2 = 204;    //更新物品2
```

这种设计支持：

物品的基本属性管理
物品的唯一性识别
物品的耐久度系统
物品的附加属性系统
背包容量限制
物品的增删改查操作
英雄系统的独立背包

在游戏中用于：

物品存储
物品管理
物品交易
物品使用
装备穿戴
数据同步

meinvwudi

根据代码分析，仓库的数据结构如下：

type
  TOStorageItems = array[0..MAXSTORAGEITEMS-1] of TUserItem;  //仓库物品数组

  TUserItem = packed record
    wIndex: Word;             //物品索引
    MakeIndex: Integer;       //制造索引(唯一ID)
    Dura: Word;              //当前持久
    DuraMax: Word;           //最大持久
    btValue: array[0..13] of Byte;  //附加属性值
  end;

//仓库相关命令常量
const
  CM_USERSTORAGEITEM = 1031;           //存入物品
  CM_USERTAKEBACKSTORAGEITEM = 1032;   //取回物品

  SM_SENDUSERSTORAGEITEM = 700;        //发送仓库物品列表
  SM_STORAGE_OK = 701;                 //存储成功
  SM_STORAGE_FULL = 702;               //仓库已满
  SM_STORAGE_FAIL = 703;               //存储失败
  SM_SAVEITEMLIST = 704;               //保存物品列表
  SM_TAKEBACKSTORAGEITEM_OK = 705;     //取回成功
  SM_TAKEBACKSTORAGEITEM_FAIL = 706;   //取回失败
  SM_TAKEBACKSTORAGEITEM_FULLBAG = 707;//背包已满

仓库系统的主要特点：

存储结构：
- 使用固定大小的数组存储物品
- 每个物品包含完整的TUserItem信息
- 与背包使用相同的物品数据结构
物品属性：
- 物品类型索引(wIndex)
- 唯一ID(MakeIndex)
- 当前持久度(Dura)
- 最大持久度(DuraMax)
- 附加属性数组(btValue)
操作功能：
- 存入物品
- 取回物品
- 查看仓库
- 保存物品列表
状态检查：
- 仓库容量检查
- 背包空间检查
- 操作结果反馈
安全机制：
```
  sStoragePwd: string[7];  //仓库密码
```
相关消息处理：
```
  RM_USERSTORAGEITEM = 10146;    //仓库物品操作
  RM_USERGETBACKITEM = 10147;     //取回物品操作
  
  //大仓库相关
  RM_USERBIGSTORAGEITEM = 20146;  //大仓库物品操作
  RM_USERBIGGETBACKITEM = 20147;  //大仓库取回操作
```
仓库系统的用途：
1. 物品存储：
  - 长期存储不常用物品
  - 存储贵重物品
  - 角色间物品交换
2. 安全保护：
  - 密码保护机制
  - 操作验证
  - 数据同步保护
3. 数据管理：
  - 物品列表管理
  - 存取操作记录
  - 容量控制
4. 交互功能：
  - 与NPC交互
  - 与背包系统交互
  - 与物品系统交互
这种设计实现了：
1. 安全的物品存储系统
2. 灵活的物品管理
3. 完整的操作机制
4. 可靠的数据保护
5. 良好的扩展性(支持大仓库)

meinvwudi

数据的增加

// 更新角色记录数据
// 参数:
//   nIndex: 记录索引号
//   HumRecord: 角色数据指针
//   boNew: 是否新建记录
// 返回值: 
//   Boolean - 更新是否成功
function TFileHumDB.UpdateRecord(nIndex: Integer; HumRecord: pTHumInfo; boNew: Boolean): Boolean;
var
  HumRcd: THumInfo;      // 临时角色数据
  nPosion: Integer;      // 文件位置偏移
  n10: Integer;          // 当前文件指针位置
begin
  // 计算记录在文件中的位置
  // 位置 = 记录索引 * 记录大小 + 文件头大小
  nPosion := nIndex * SizeOf(THumInfo) + SizeOf(TDBHeader);
  
  // 定位到记录位置
  if FileSeek(m_nFileHandle, nPosion, 0) = nPosion then begin
    // 保存当前文件指针位置
    n10 := FileSeek(m_nFileHandle, 0, 1);
    
    // 如果是新建记录,需要检查该位置是否已有有效记录
    if boNew and
      (FileRead(m_nFileHandle, HumRcd, SizeOf(THumInfo)) = SizeOf(THumInfo)) and // 读取记录
      (not HumRcd.Header.boDeleted) and  // 记录未删除
      (HumRcd.Header.sName <> '') then   // 记录名不为空
      Result := True  // 已存在有效记录,返回失败
    else begin
      // 设置记录头信息
      HumRecord.Header.boDeleted := False;  // 设置未删除标记
      HumRecord.Header.dCreateDate := Now(); // 设置创建时间
      
      // 更新数据库头更新时间
      m_Header.dUpdateDate := Now();
      
      // 写入数据库头
      FileSeek(m_nFileHandle, 0, 0);
      FileWrite(m_nFileHandle, m_Header, SizeOf(TDBHeader));
      
      // 写入角色数据
      FileSeek(m_nFileHandle, n10, 0);
      FileWrite(m_nFileHandle, HumRecord^, SizeOf(THumInfo));
      
      // 文件指针回退一条记录
      FileSeek(m_nFileHandle, -SizeOf(THumInfo), 1);
      
      // 更新当前记录索引
      n4 := nIndex;
      
      // 设置数据已修改标记
      m_boChanged := True;
      Result := True;
    end;
  end else 
    Result := False; // 定位失败返回错误
end;

meinvwudi

这是读取玩家数据的过程,我来详细分析:

// 根据快速列表索引获取玩家数据
// 参数:
//   nIndex: 快速列表中的索引号
//   HumanRCD: 接收玩家数据的指针
// 返回值:
//   Integer - 成功返回实际记录索引,失败返回-1
function TFileDB.Get(nIndex: Integer; HumanRCD: pTHumDataInfo): Integer;
var
  nIdx: Integer;  // 实际文件中的记录索引
begin
  // 从快速列表获取实际的文件记录索引
  // m_QuickList存储了角色名和对应的文件记录索引
  nIdx := Integer(m_QuickList.Objects[nIndex]);
  
  // 调用GetRecord读取具体记录
  if GetRecord(nIdx, HumanRCD) then
    Result := nIdx    // 读取成功返回记录索引
  else
    Result := -1;     // 读取失败返回-1
end;

// 从文件读取具体记录
function TFileDB.GetRecord(nIndex: Integer; HumanRCD: pTHumDataInfo): Boolean;
begin
  // 定位到记录位置
  // 位置 = 记录索引 * 记录大小 + 文件头大小
  if FileSeek(m_nFileHandle, nIndex * SizeOf(THumDataInfo) + SizeOf(TDBHeader), 0) <> -1 then
  begin
    // 读取记录数据到HumanRCD指向的内存
    FileRead(m_nFileHandle, HumanRCD^, SizeOf(THumDataInfo));
    
    // 保持文件指针位置,用于后续操作
    FileSeek(m_nFileHandle, -SizeOf(THumDataInfo), 1);
    
    // 记录当前索引
    n4 := nIndex;
    Result := True;
  end else 
    Result := False;
end;

读取流程:

索引转换:
- m_QuickList保存了角色名到文件记录索引的映射
- 通过快速列表索引获取实际文件记录索引
文件定位:
- 计算记录在文件中的具体位置
- 位置 = 记录索引 * 记录大小 + 文件头大小
读取数据:
- 使用FileRead读取整个THumDataInfo结构
- 数据直接读入传入的HumanRCD指针指向的内存
数据结构:
```
THumDataInfo = packed record
  Header: TRecordHeader;   // 记录头(角色基本信息)
  Data: THumData;         // 角色详细数据(属性/装备/状态等)
end;
```

主要特点:

使用快速列表加速查找
直接文件读取,效率高
完整的错误检查
保持文件指针位置
返回实际记录索引

这种设计实现了高效的玩家数据读取。

meinvwudi

从代码中可以看到删除玩家数据有两个实现方法,分析如下:

根据角色名删除:
```
function TFileDB.Delete(const sChrName: string): Boolean;
var
  n10: Integer;
begin
  Result := False;
  
  // 1. 从快速列表中查找角色名对应的索引
  n10 := m_QuickList.GetIndex(sChrName);
  if n10 < 0 then Exit;
  
  // 2. 删除记录
  if DeleteRecord(Integer(m_QuickList.Objects[n10])) then begin
    // 3. 从快速列表中移除
    m_QuickList.Delete(n10);
    Result := True;
  end;
end;
```
1. 根据索引删除:
```
function TFileDB.Delete(nIndex: Integer): Boolean;
var
  I: Integer;
  s14: string;
begin
  Result := False;
  
  // 1. 遍历快速列表找到对应索引的记录
  for I := 0 to m_QuickList.Count - 1 do begin
    if Integer(m_QuickList.Objects[I]) = nIndex then begin
      s14 := m_QuickList.Strings[I];
      // 2. 删除记录
      if DeleteRecord(nIndex) then begin
        // 3. 从快速列表移除
        m_QuickList.Delete(I);
        Result := True;
        Break;
      end;
    end;
  end;
end;
```
  1. 实际的删除操作:
```
function TFileDB.DeleteRecord(nIndex: Integer): Boolean;
var
  ChrRecordHeader: TRecordHeader;
begin
  Result := False;
  
  // 1. 定位到记录位置
  if FileSeek(m_nFileHandle, nIndex * SizeOf(THumDataInfo) + SizeOf(TDBHeader), 0) = -1 then 
    Exit;
    
  // 2. 更新最后操作信息
  m_nLastIndex := nIndex;
  m_dUpdateTime := Now();
  
  // 3. 设置删除标记
  ChrRecordHeader.boDeleted := True;
  ChrRecordHeader.dCreateDate := Now();
  
  // 4. 写入删除标记
  FileWrite(m_nFileHandle, ChrRecordHeader, SizeOf(TRecordHeader));
  
  // 5. 添加到已删除列表
  m_DeletedList.Add(Pointer(nIndex));
  
  // 6. 更新数据库头信息
  m_Header.nLastIndex := m_nLastIndex;
  m_Header.dLastDate := m_dUpdateTime;
  m_Header.dUpdateDate := Now();
  
  // 7. 写入更新后的数据库头
  FileSeek(m_nFileHandle, 0, 0);
  FileWrite(m_nFileHandle, m_Header, SizeOf(TDBHeader));
  
  m_boChanged := True;
  Result := True;
end;
```
    删除的特点:
    1. 逻辑删除而非物理删除:
    2. 只是设置删除标记
    3. 实际数据仍保留在文件中
    4. 记录空间可以重用
    5. 索引维护:
    6. 从快速列表中移除
    7. 添加到删除列表
    8. 更新数据库头信息
    9. 数据一致性:
    10. 更新文件头信息
    11. 记录操作时间
    12. 设置修改标记
    13. 空间重用机制:
```
// 添加新记录时优先使用已删除的空间
if m_DeletedList.Count > 0 then begin
  nIdx := Integer(m_DeletedList.Items[0]);
  m_DeletedList.Delete(0);
end else begin
  nIdx := m_Header.nHumCount;
  Inc(m_Header.nHumCount);
end;
```
    14. 数据库优化:
```
// 重建数据库,清理已删除记录
procedure TFileDB.Rebuild;
begin
  // 创建临时文件
  // 只复制未删除的记录
  // 更新数据库头信息
  // 替换原文件
end;
```
    这种删除机制的优点:
    1. 支持数据恢复
    2. 空间可以重用
    3. 操作快速
    4. 维护数据一致性
    缺点:
    1. 需要定期整理
    2. 文件大小不会减少
    3. 需要额外的删除列表维护

meinvwudi

是的,你说得对!我重新梳理下:

TFileDB - 操作mir.db(角色主数据库):
```
TFileDB = class
private
  m_sDBFileName: string;    // mir.db
  m_sIdxFileName: string;   // mir.idx
  m_Header: TDBHeader;      // 数据库头
  m_QuickList: TQuickList;  // 角色名快速索引
  
public
  // mir.db的操作方法
  function Add(HumanRCD: pTHumDataInfo): Boolean;     // 添加角色
  function Delete(const sChrName: string): Boolean;    // 删除角色
  function Update(nIndex: Integer; HumanRCD: pTHumDataInfo): Boolean;  // 更新角色
  function Get(nIndex: Integer; HumanRCD: pTHumDataInfo): Integer;     // 获取角色
end;
```
1. TFileHumDB - 操作hum.db(角色扩展数据库):
```
TFileHumDB = class
private
  m_sDBFileName: string;     // hum.db 
  m_Header: TDBHeader;       // 数据库头
  m_QuickList: TQuickList;   // 快速索引
  m_QuickIDList: TQuickIDList; // 账号索引
  
public
  // hum.db的操作方法
  function Add(HumRecord: pTHumInfo): Boolean;      // 添加记录
  function Delete(const sName: string): Boolean;     // 删除记录
  function Update(nIndex: Integer; HumRecord: pTHumInfo): Boolean;  // 更新记录
  function Get(n08: Integer; HumRecord: pTHumInfo): Integer;       // 获取记录
end;
```
  主要区别:
  1. 数据结构:
```
// mir.db使用
THumDataInfo = packed record
  Header: TRecordHeader;   // 记录头
  Data: THumData;         // 角色主数据
end;

// hum.db使用  
THumInfo = packed record
  Header: TRecordHeader;  // 记录头
  Data: THumInfo;        // 角色扩展数据
end;
```
    1. 索引方式:
    2. mir.db: 使用角色名索引
    3. hum.db: 使用角色名和账号双重索引
    4. 使用场景:
    5. mir.db: 存储角色基础数据
    6. hum.db: 存储角色扩展数据
    7. 操作流程:
```
// 删除角色时需要同时操作两个数据库
TFileDB.Delete(charName);      // 删除mir.db中的记录
TFileHumDB.Delete(charName);   // 删除hum.db中的记录
```
    这样设计的目的:
    1. 分离基础数据和扩展数据
    2. 提高数据访问效率
    3. 便于数据维护和备份
    4. 支持数据的独立扩展
    所以之前的分析有误,两个类都是必要的,分别操作不同的数据库文件。

meinvwudi

找到了,在FIDHum.pas中的BtnDeleteChrAllInfoClick方法中:

procedure TFrmIDHum.BtnDeleteChrAllInfoClick(Sender: TObject);
var
  sChrName: string;
begin
  sChrName := EdChrName.Text;
  if sChrName = '' then Exit;
  if MessageDlg('是否确认删除角色 ' + sChrName + ' 的所有数据？', mtConfirmation, [mbYes, mbNo], 0) = mrYes then begin
    try
      // 删除hum.db中的记录
      if g_HumCharDB.Open then begin
        g_HumCharDB.Delete(sChrName);
      end;
    finally
      g_HumCharDB.Close;
    end;
    
    try
      // 删除mir.db中的记录
      if g_HumDataDB.Open then 
        g_HumDataDB.Delete(sChrName);
    finally
      g_HumDataDB.Close;
    end;
  end;
end;

这里确实同时调用了两个数据库的删除操作:

g_HumCharDB.Delete - 删除hum.db中的记录
g_HumDataDB.Delete - 删除mir.db中的记录

这是一个完全删除角色数据的操作。此外还有两个相关的删除方法:

逻辑删除(标记删除):
```
procedure TFrmIDHum.BtnDeleteChrClick(Sender: TObject);
begin
  // 只是设置删除标记,不实际删除数据
  if g_HumCharDB.Open then begin
    nIndex := g_HumCharDB.Index(sChrName);
    g_HumCharDB.Get(nIndex, @HumRecord);
    HumRecord.boDeleted := True;  // 设置删除标记
    HumRecord.dModDate := Now();
    Inc(HumRecord.btCount);
    g_HumCharDB.Update(nIndex, @HumRecord);
  end;
end;
```
恢复删除的角色:
```
procedure TFrmIDHum.BtnRevivalClick(Sender: TObject);
begin
  // 恢复被标记删除的角色
  if g_HumCharDB.Open then begin
    nIndex := g_HumCharDB.Index(sChrName);
    g_HumCharDB.Get(nIndex, @HumRecord);
    HumRecord.boDeleted := False;  // 取消删除标记
    Inc(HumRecord.btCount);
    g_HumCharDB.Update(nIndex, @HumRecord);
  end;
end;
```

所以完整的删除机制包括:

逻辑删除(标记)
物理删除(实际删除数据)
恢复删除

meinvwudi

数据的导出

// 导出数据到文件
procedure TfrmEditRcd.ProcessSaveRcdToFile;
begin
  // 保存THumDataInfo结构到文件
  FileWrite(nFileHandle, m_ChrRcd, SizeOf(THumDataInfo));
end;

// 从文件导入数据
procedure TfrmEditRcd.ProcessLoadRcdformFile;
begin
  // 从文件读取THumDataInfo结构
  FileRead(nFileHandle, ChrRcd, SizeOf(THumDataInfo));
  // 保持原有的角色名和账号
  ChrRcd.Header := m_ChrRcd.Header;
  ChrRcd.Data.sChrName := m_ChrRcd.Data.sChrName;
  ChrRcd.Data.sAccount := m_ChrRcd.Data.sAccount;
end;