我这伤害皮肤的实现和 GMS083 技能 Buff 倒计时的实现有着异曲同工之处，都是投机取巧的方法。当然这是一年前完成的作品，如果现在让我重新写的话我估计会写得更好，但也不会有什么质的提升。我很久没碰083了暂时也不想折腾这个东西，现在只是把去年完成的东西分享出来，至于其他的以后再说。

关于伤害皮肤的演示可以看 GMS083 伤害皮肤可联机这个视频同样录制于去年。

该示例支持联机显示而非本地自慰版，不支持动态皮肤如一些火焰特效的，不支持最新版的“亿”之类的字样显示，只能是纯数字。

我在尝试了很多错误的方法之后最终找到这一条偷鸡方法，正如第一段内容所说，该实现方法和BUFF倒计时一样，也是靠着篡改StringPool实现的。

如果你有认真读过我发的所有文章的话，那你是完全有能力在不看这篇教程的情况下，独自完成所有工作的。

你可以通过原生伤害数字图片顺藤摸瓜，找到显示伤害数值的方法在客户端的 CAnimationDisplayer::Effect_HP

仔细阅读这个方法的伪代码，你就可以发现，伤害数字是一个个加载的，比如你造成的伤害是 9630，客户端绘制伤害数字的时候会把这个值拆成 9 6 3 0 四个数字，然后依次去wz里加载对应的图片出来显示。

那么实际上和BUFF倒计时一样，我们去篡改客户端拆分后的数字，比如 9 我们给他改成 10XXXX9，这里面的 XXXX 就可以作为我们的皮肤 id。

和BUFF倒计时不一样的是，倒计时是直接绕过了SP，这里面还是要借用SP调取返回值的，需要在SP里加入自定义的返回值。这个其实我在介绍SP的时候有提到过，如果你有认真看过北斗插件修改StringPool汉化和新增自定义的字符串组的话，应该就会了

那不就很简单了，只需要在wz中存0-9这10个图片的地方，插入10XXXX0-10XXXX9若N个图片，然后在客户端把原本的0-9改成10XXXX0-10XXXX9，那就实现了不同的皮肤效果了，皮肤的ID只需要配合自定义封包，让服务端传一下（由于要联机显示，所以要传玩家ID和皮肤ID两个值），事情就成了。

这个方法还需要你自己能编写写轮眼功能，这样才能批量把高版本的皮肤存成10XXXXX的名称形式，或者你有其他的方法实现这个伤害皮肤那更好。

插件

新建文件 ezorsia/DamageSkin.h

#pragma once
#include <map>

std::map<int, int> skinIdMap;

int skinId = 0;
int charId = 0;


DWORD dmgN1Rtn = 0x004380F5;
__declspec(naked) void dmgNumber1(){
    __asm {
        movsx   eax, al
        sub     eax, 30h

        push    eax
        mov     eax, [ebp + 14h]
        sub     eax, edi
        jnz     label_return
        
        pop     eax
        add     eax, skinId
        push    eax
        
        label_return:
        jmp     dmgN1Rtn
    }
}

DWORD dmgN2Rtn = 0x00438282;
__declspec(naked) void dmgNumber2() {
    __asm {
        movsx   eax, al
        sub     eax, 30h

        push    eax
        mov     eax, [ebp + 14h]
        sub     eax, edi
        jnz     label_return

        pop     eax
        add     eax, skinId
        push    eax

        label_return :
        jmp     dmgN2Rtn
    }
}

void setSID() {
    //std::cout << "setSID charId " << charId << std::endl;
    int sid = skinIdMap[charId];
    skinId = sid ? sid : 0;
    skinId *= 10;
    //std::cout << "setSID skinId " << skinId << std::endl;
}

DWORD onHitRtn = 0x00668E01;
__declspec(naked) void onHit() {
    __asm {
        // 设置皮肤
        push    eax
        mov     eax, [ebp + 8]
        mov     charId, eax
        pop     eax
        call    setSID
        xor     ecx, ecx
        cmp     eax, ebx
        setz    cl
        jmp     onHitRtn
    }
}

DWORD dmgMissRtn = 0x00438A73;
__declspec(naked) void dmgMiss() {
    __asm {
        mov     ecx, [ebp + 10h]
        sub     ecx, ebx
        jnz     label_original
        
        mov     ecx, 100000
        add     ecx, skinId
        push    ecx
        jmp     label_return

        label_original:
        push    3D8h

        label_return:
        jmp     dmgMissRtn
    }
}

DWORD dmgWidthAddRtn = 0x00437F99;
DWORD dmgWidthAddJnz = 0x00437F9F;
__declspec(naked) void dmgWidthAdd() {
    __asm {
        add     esi, 15
        mov     [ebp - 24h], esi
        jnz     label_jnz
        jmp     dmgWidthAddRtn

        label_jnz:
        jmp     dmgWidthAddJnz
    }
}

// 调整字符间隔，备用别删
//DWORD dmgWidthAdd2Rtn = 0x00437F54;
//__declspec(naked) void dmgWidthAdd2() {
//    __asm {
//        cmp     [ebp - 10h], edi
//        mov     ebx, eax
//        add     ebx, 10
//        jmp     dmgWidthAdd2Rtn
//    }
//}

class DamageSkin {
public:
	static void Hook() {
        Memory::CodeCave(dmgMiss, 0x00438A6E, 5);
        Memory::CodeCave(dmgNumber1, 0x004380EE, 7);
        Memory::CodeCave(dmgNumber2, 0x0043827B, 7);
        Memory::CodeCave(onHit, 0x00668DFA, 7);
        Memory::CodeCave(dmgWidthAdd, 0x00437F94, 5); // 最右侧宽度加大
        //Memory::CodeCave(dmgWidthAdd2, 0x00437F4F, 5); // 间隔
	}
    static void SetSkinId(int charId, int skinId) {
        //std::cout << "SetSkinId charId " << charId << " skinId " << skinId << std::endl;
        skinIdMap[charId] = skinId;
        //std::cout << "done! skinId " << skinIdMap[charId] << std::endl;
    }
    static int GetSkinId(int charId) {
        int result = skinIdMap[charId];
        result = result ? result : 0;
        //std::cout << "GetSkinId charId " << charId << " skinId " << result << std::endl;
        return result;
    }
};

编辑接收自定义封包的文件

添加头文件

#include "DamageSkin.h"

新增方法

void SetSkinId(CInPacket in) {
	int cId = in.decode<int>();
	int sId = in.decode<int>();
	DamageSkin::SetSkinId(cId, sId);
}

在你接收封包的 switch 中添加

		case 0x172:
			SetSkinId(in);
			return 0;

在合适的地方调用下面方法来让内存修改生效

DamageSkin::Hook();

修改 StringPool 的实现用于处理皮肤id，在

auto ret = _StringPool__GetString(pThis, edx, result, 1, formal);

下面添加

        if (nIdx > 5657) // 超出自带部分须特殊处理
        {
            if (nIdx == 100000)
            {
                *ret = "Miss";
            }
            else if (nIdx > 100000 && nIdx < 200000)
            {
                *ret = (std::to_string((nIdx - 100000) / 10) + "Miss").c_str();
            }

            return ret;
        }

        ret = _StringPool__GetString(pThis, edx, result, nIdx, formal);

写轮眼

因为各个写轮眼的写法都不太一样，我只列出我这里的核心写法，需要你自行看着修改，就是把伤害皮肤的名称改成 sid+数字或者Miss的形式保存到对应的目录下，你还要自行处理好Outlink等

        /// <summary>  
        /// 伤害皮肤名称转换  
        /// </summary>  
        public void EditDmgSkinNodeName()  
        {  
            var t0 = DateTime.Now;  
  
            foreach (var obj in clipboard)  
                //this causes minor weirdness with png's in copied nodes but otherwise memory is not free'd   
                obj.Dispose();  
  
            clipboard.Clear();  
  
            string[] nodeList = { "NoRed0", "NoRed1", "NoCri0", "NoCri1" };  
            List<string> noRed0Allow = new List<string> { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "Miss" };  
  
            foreach (WzNode node in DataTree.SelectedNodes)  
            {  
                if (node.Text != "BasicEff.img")  
                {  
                    MessageBox.Show("请右键 BasicEff.img 节点使用");  
                    return;  
                }  
  
                foreach(string targetNodeName in nodeList)  
                {  
                    foreach (WzNode imgData in node.Nodes)  
                    {  
                        if (imgData.Text != "damageSkin") continue;  
  
                        foreach (WzNode skinId in imgData.Nodes)  
                        {  
                            string sId = skinId.Text;  
                            foreach (WzNode skin in skinId.Nodes)  
                            {  
                                if (skin.Text != targetNodeName) continue;  
  
                                bool changed = true;  
                                foreach (WzNode dataNode in skin.Nodes)  
                                {  
                                    if (dataNode.Text != "0") continue;  
  
                                    changed = false;  
                                    break;  
                                }  
  
                                if (changed) continue;  
  
                                // 修改节点名称并写入剪贴板  
                                foreach (WzNode dataNode in skin.Nodes)  
                                {  
                                    if (targetNodeName == "NoRed0" && !noRed0Allow.Contains(dataNode.Text)) continue;  
                                    Console.WriteLine("复制 " + targetNodeName + "/" + sId + "/" + dataNode.Text);  
                                    dataNode.ChangeName(sId + dataNode.Text);  
  
                                    var wzObj = (WzObject)dataNode.Tag;  
                                    var clone = CloneWzObject(wzObj);  
                                    if (clone == null) continue;  
                                    if (clone is WzImage image)  
                                    {  
                                        // Decrypt any List.wz entries so that we paste them as decrypted  
                                        // Otherwise we need to know the key to decrypt them on paste  
                                        ListWzContainerImpl.MarkListWzProperty(image, false);  
                                    }  
                                    else if (clone is WzImageProperty prop)  
                                    {  
                                        // No parent image so we need to grab it from source  
                                        ListWzContainerImpl.MarkListWzProperty(prop, false, ((WzImageProperty)wzObj).ParentImage.wzKey);  
                                    } // Can't copy directories atm so they don't need handling  
  
                                    clipboard.Add(clone);  
                                }  
                            }  
                        }  
                    }  
  
                    Console.WriteLine("粘贴 " + targetNodeName);  
                    foreach (WzNode imgData in node.Nodes)  
                    {  
                        if (imgData.Text != targetNodeName) continue;  
  
                        DataTree.BeginUpdate();  
                        try  
                        {  
                            var parent = imgData;  
                            var parentObj = (WzObject)parent.Tag;  
  
                            if (parent.Tag is WzImage && parent.Nodes.Count == 0)  
                            {  
                                ParseOnDataTreeSelectedItem(parent); // only parse the main node.  
                            }  
  
                            if (parentObj is WzFile file)  
                            {  
                                parentObj = file.WzDirectory;  
                            }  
  
                            var handler = MainForm.CreateDefaultDuplicateHandler();  
  
                            foreach (var obj in clipboard)  
                            {  
                                if (((!(obj is WzDirectory) && !(obj is WzImage)) || !(parentObj is WzDirectory)) &&  
                                    (!(obj is WzImageProperty) || !(parentObj is IPropertyContainer)))  
                                {  
                                    continue;  
                                }  
  
                                var clone = CloneWzObject(obj);  
                                if (clone == null)  
                                {  
                                    continue;  
                                }  
  
                                if (clone is WzImage image)  
                                {  
                                    // Cloning also clones wz key  
                                    // But they could now be different, update it  
                                    image.wzKey = WzKeyGenerator.GenerateWzKey(WzTool.GetIvByMapleVersion(parentObj.WzFileParent.MapleVersion));  
                                }  
  
                                _mainForm.AddObjectWithNode(handler, parent, clone);  
                            }  
                        }  
                        finally  
                        {  
                            DataTree.EndUpdate();  
                        }  
                    }  
                }  
                  
            }  
  
            var useTime = (DateTime.Now - t0).TotalSeconds;  
            MessageBox.Show("操作完成.\r\n耗时: " + useTime + " 秒");  
        }

服务端

增加玩家属性

编辑 src/main/java/client/Character.java 在合适的位置添加

public int damageSkin = 0;

请自行补充Get和Set方法以及保存数据到数据库的部分

新建封包

编辑 src/main/java/net/opcodes/SendOpcode.java 添加ENUM DAMAGE_SKIN(0x172)

编辑 src/main/java/tools/PacketCreator.java 添加封包

    public static Packet damageSkin(int charId, int skinId) {
        OutPacket p = OutPacket.create(SendOpcode.DAMAGE_SKIN);
        p.writeInt(charId);
        p.writeInt(skinId);
        return p;
    }

地图广播皮肤ID

编辑 src/main/java/server/maps/MapleMap.java 添加两个新方法

    public void broadcastDamageSkin(int charId, int skinId) {
        chrRLock.lock();
        try {
            for (Character chr : characters) {
                chr.sendPacket(PacketCreator.damageSkin(charId, skinId));
            }
        } finally {
            chrRLock.unlock();
        }
    }

    public void broadcastDamageSkinToNewer(Character player) {
        chrRLock.lock();
        try {
            for (Character chr : characters) {
                player.sendPacket(PacketCreator.damageSkin(chr.getId(), chr.getDamageSkin()));
            }
        } finally {
            chrRLock.unlock();
        }
    }

在

sendObjectPlacement(chr.getClient());

上面添加

        broadcastDamageSkin(chr.getId(),chr.getDamageSkin()); // 向地图广播自己的伤害皮肤
        broadcastDamageSkinToNewer(chr); // 地图玩家给自己广播伤害皮肤

添加GM命令用于设置自己的皮肤

新建文件 src/main/java/client/command/commands/gm0/SkinCommand.java

package client.command.commands.gm0;

import client.Character;
import client.Client;
import client.command.Command;
import constants.id.NpcId;

public class SkinCommand extends Command {
    {
        setDescription("设置伤害皮肤");
    }

    @Override
    public void execute(Client c, String[] params) {
        c.getAbstractPlayerInteraction().openNpc(NpcId.MAPLE_ADMINISTRATOR, "伤害皮肤");
    }
}

编辑 src/main/java/client/command/CommandsExecutor.java

在(你自己喜欢的地方)

addCommand("gmsg", 5, GMessageCommand.class);

下面添加

addCommand("skin", 5, SkinCommand.class);

新建脚本 scripts/npc/伤害皮肤.js

/**
 * @author: lee
 */

let status, skinId;

function start() {
    status = -1;
    action(1, 0, 0);
}

function action(mode, type, selection) {
    if (mode === -1 || (mode === 0 && type > 0)) {
        cm.dispose();
        return;
    }

    updateStatus(mode);

    if (status === 0) {
        let msg = "";

        let skinIds = [];
        for (let i = 0; i <= 29; i++) {
            skinIds.push(i);
        }
        for (let i = 1001; i <= 1007; i++) {
            skinIds.push(i);
        }
        for (let i = 1010; i <= 1012; i++) {
            skinIds.push(i);
        }
        for (let i = 1015; i <= 1021; i++) {
            skinIds.push(i);
        }
        for (let i = 1024; i <= 1043; i++) {
            skinIds.push(i);
        }
        skinIds.push(1045);
        skinIds.push(1048);
        skinIds.push(1049);
        for (let i = 1051; i <= 1054; i++) {
            skinIds.push(i);
        }
        skinIds.push(1056);
        for (let i = 1058; i <= 1060; i++) {
            skinIds.push(i);
        }

        skinIds.forEach(id => {
            msg = msg + "#L" + id + "#" + id + "  #fEffect/BasicEff.img/NoRed0/" + (id !== 0 ? id : "") + "Miss##l\r\n";
        })
        cm.sendSimple(msg);
    } else if (status == 1) {
        skinId = selection;
        let msg = "你确定要使用这款皮肤吗？\r\n\r\n"
        let line1 = "", line2 = "", line3 = "", line4 = "";
        for (let i = 0; i <= 9; i++) {
            line1 = line1 + "#fEffect/BasicEff.img/NoRed0/" + (skinId !== 0 ? skinId * 10 + i : i) + "#";
            //line2 = line2 + "#fEffect/BasicEff.img/NoRed1/" + (skinId !== 0 ? skinId * 10 + i : i) + "#";
            line3 = line3 + "#fEffect/BasicEff.img/NoCri0/" + (skinId !== 0 ? skinId * 10 + i : i) + "#";
            //line4 = line4 + "#fEffect/BasicEff.img/NoCri1/" + (skinId !== 0 ? skinId * 10 + i : i) + "#";
        }
        msg = msg + line1 + "\r\n↑↑↑↑↑↑ 常规效果 ↑↑↑↑↑↑\r\n" + line2 + "\r\n" + line3 + "\r\n↑↑↑↑↑↑ 强力效果 ↑↑↑↑↑↑\r\n" + line4 + "\r\n#fEffect/BasicEff.img/NoRed0/" + (skinId !== 0 ? skinId : "") + "Miss"
        cm.sendNextPrev(msg);
    } else if (status == 2) {
        let player = cm.getPlayer();
        player.setDamageSkin(skinId);
        player.getMap().broadcastDamageSkin(player.getId(), skinId);
        cm.sendOk("设置成功！");
        cm.dispose();
    }
}

function updateStatus(mode) {
    if (mode === 1) {
        status++;
    } else {
        status--;
    }
}

function generateMenu(array) {
    // #fUI/Basic.img/HScr4/enabled/next2#
    let menu = "";
    for (let i = 1; i <= array.length; i++) {
        menu += "#L" + i + "##b" + i + ". " + array[i - 1] + "#k#l\r\n";
    }
    return menu;
}