import miaoTool from "./miaoTool.js";

export default function content (config, pack) {
    lib.miaoTool = miaoTool
    /*---------------------------------------------------------------以下为杂项---------------------------------------------------------------*/
    get.is.xuemai = function (skill) {
        var info = lib.skill[skill];
        if (typeof info.xuemai == "function") return info.xuemai(skill);
        if (info.xuemai == false) return false;
        if (info.trigger && info.forced) return true;
        if (info.mod) return true;
        if (info.xuemai) return true;
        return false;
    };

    game.changeRoundNumber = function () {
        /*接受输入num，游戏轮数+=num */
        //event.trigger("changeRoundNumberBegin");
        var num = 1,
            source = _status.event.player,
            is_skip = false;
        for (var i = 0; i < arguments.length; i++) {
            if (typeof arguments[i] == "number") {
                num = arguments[i];
            } else if (arguments[i] == "skip") {
                is_skip = true;
            } else if (get.itemtype(arguments[i]) == "player" || arguments[i] == null) {
                source = arguments[i];
            }
        }
        if (is_skip) {
            game.roundNumber += num;
        } else {
            while (num > 0) {
                num--;
                game.roundNumber++;
                game.updateRoundNumber();
                _status.event.trigger("roundStart");
            }
        }
        game.updateRoundNumber();
        //event.trigger("changeRoundNumberEnd");
    };

    // 重写废除判定区相关
    lib.element.content.enableJudge = function () {
        "step 0"
        if (!player.storage._disableJudge || player.storage._disableJudge == false) event.finish();
        // 多次废除恢复判断
        if (!player.storage._disableJudge_layer) {
            player.storage._disableJudge_layer = 0;
        }
        player.storage._disableJudge_layer--;
        if (player.storage._disableJudge_layer < 0) {
            player.storage._disableJudge_layer = 0;
            event.finish();
        }
        if (player.storage._disableJudge_layer > 0) event.finish();
        "step 1"
        game.log(player, "恢复了判定区");
        player.storage._disableJudge = false;
        // player.markSkill('_disableJudge');
        "step 2"
        game.broadcastAll(function (player, card) {
            player.$enableJudge();
        }, player);
    };

    lib.element.content.disableJudge = function () {
        "step 0"
        // if (player.storage._disableJudge == true) return;
        // 多次废除恢复判断
        if (!player.storage._disableJudge_layer) {
            player.storage._disableJudge_layer = 0;
        }
        player.storage._disableJudge_layer++;
        if (player.storage._disableJudge_layer > 1) {
            event.finish();
        }
        "step 1"
        game.log(player, "废除了判定区");
        var js = player.getCards("j");
        if (js.length) player.discard(js);
        player.storage._disableJudge = true;
        //player.markSkill('_disableJudge');
        "step 2"
        game.broadcastAll(function (player, card) {
            player.$disableJudge();
        }, player);
    };

    // 并不是很好的写法
    let gameAddPlayerBak = game.addPlayer
    game.addPlayer = (position, character, character2) => {
        let player = gameAddPlayerBak(position, character, character2)
        // if (position < 0 || position > game.players.length + game.dead.length || position == undefined)
        // 	position = Math.ceil(Math.random() * (game.players.length + game.dead.length));
        // const players = game.players.concat(game.dead);
        // ui.arena.setNumber(players.length + 1);
        // players.forEach(value => {
        // 	if (parseInt(value.dataset.position) >= position) value.dataset.position = parseInt(value.dataset.position) + 1;
        // });
        // const player = ui.create.player(ui.arena).animate("start");
        // if (character) player.init(character, character2);

        // //技能修复
        // var skills=lib.character[character][3];
        // if(character2)skills.concat(lib.character[character2][3])
        // for(var i of skills){
        // 	game.log(i)
        // 	player.removeSkill(i)
        // 	player.addSkill(i);
        // }

        // 属性
        player.storage.enhancementArray = {
            attack: 0, //攻击力
            defend: 0, //防御力
            miss: 0, //闪避率
            hit: 0, //命中率
            strike: 0, //暴击率，目前没用
            draw: 0, //摸牌，目前没用
            locked: false,
            locked_end: -1,
            locked_type: null
        };
        game.players.push(player);
        player.playerid = get.id();
        game.playerMap[player.playerid] = player;
        // game.log(game.playerMap)
        // for(var i in game.playerMap){
        // 	game.log(i)
        // }
        // game.playerMap.push(player);
        player.dataset.position = position;
        game.arrangePlayers();
        return player;
    };

    // //多位主公死亡情况
    // lib.skill._miao_zhu_dying = {

    // }

    //更换武将头像
    lib.element.player.changeAvatarMiao = function (imgFrom, imgTo) {
        var path = this.node.avatar.style.backgroundImage.split(imgFrom)[0];

        this.node.avatar.style.backgroundImage = path + imgTo + '")';
    };
    //获得限伤
    lib.element.player.addDamageLimiter = function () {
        if (!this.storage._damageLimiter_Miao) {
            this.storage._damageLimiter_Miao = [];
        }
        var id = _status.event.name,
            num = 1,
            source = _status.event.player,
            nolog = false;
        for (var i = 0; i < arguments.length; i++) {
            if (arguments[i] == "nolog") {
                nolog = true;
            } else if (typeof arguments[i] == "number") {
                num = arguments[i];
            } else if (get.itemtype(arguments[i]) == "player" || arguments[i] == null) {
                source = arguments[i];
            } else if (typeof arguments[i] == "string") {
                id = arguments[i];
            }
        }

        this.removeDamageLimiter(id, "noUnmark");
        var Limiter = {};
        Limiter.id = id;
        Limiter.num = num;
        Limiter.source = source;
        this.storage._damageLimiter_Miao.push(Limiter);
        this.markSkill("_DamageLimiter");
    };

    //移除限伤
    lib.element.player.removeDamageLimiter = function () {
        if (!this.storage._damageLimiter_Miao) {
            this.storage._damageLimiter_Miao = [];
        }
        var id = _status.event.name,
            noUnmark = false,
            nolog = false;
        for (var i = 0; i < arguments.length; i++) {
            if (arguments[i] == "nolog") {
                nolog = true;
            } else if (arguments[i] == "noUnmark") {
                noUnmark = true;
            } else if (typeof arguments[i] == "string") {
                id = arguments[i];
            }
        }
        for (var i = 0; i < this.storage._damageLimiter_Miao.length; i += 1) {
            if (this.storage._damageLimiter_Miao[i].id == id) {
                this.storage._damageLimiter_Miao.splice(i, 1);
            }
        }
        if (this.storage._damageLimiter_Miao.length == 0 && noUnmark == false) this.unmarkSkill("_DamageLimiter");
    };

    lib.skill["_DamageLimiter"] = {
        trigger: {
            player: ["damageBegin3"]
        },
        filter: function (event, player) {
            if (!player.storage._damageLimiter_Miao) return false;
            var min = Infinity;
            for (var i = 0; i < player.storage._damageLimiter_Miao.length; ++i) {
                var limiter = player.storage._damageLimiter_Miao[i];
                if (player.storage._damageLimiter_Miao[i].num < min) min = player.storage._damageLimiter_Miao[i].num;
            }
            return event.num > min;
        },
        priority: -705831,
        forced: true,
        silent:true,
        charlotte: true,
        unique: true,
        mark: true,
        marktext: "限伤",
        intro: {
            name: "最大伤害限制",
            mark: function (dialog, storage, player) {
                var min = Infinity;
                for (var i = 0; i < player.storage._damageLimiter_Miao.length; ++i) {
                    var limiter = player.storage._damageLimiter_Miao[i];
                    if (player.storage._damageLimiter_Miao[i].num < min) min = player.storage._damageLimiter_Miao[i].num;
                }
                return "你受到的所有伤害不超过" + min + "点";
            }
        },
        content: function () {
            var min = Infinity;
            for (var i = 0; i < player.storage._damageLimiter_Miao.length; ++i) {
                var limiter = player.storage._damageLimiter_Miao[i];
                if (player.storage._damageLimiter_Miao[i].num < min) min = player.storage._damageLimiter_Miao[i].num;
            }
            if (trigger.num > min) trigger.num = min;
            game.log(player, "触发了限伤");
            _status.event.trigger("damageLimit");
        }
    };

    //获得缓伤，即百分比减伤
    lib.element.player.addDamageMitigationer = function () {
        if (!this.storage._damageMitigationer_Miao) {
            this.storage._damageMitigationer_Miao = [];
        }
        var id = _status.event.name,
            num = 1,
            source = _status.event.player,
            nolog = false;
        for (var i = 0; i < arguments.length; i++) {
            if (arguments[i] == "nolog") {
                nolog = true;
            } else if (typeof arguments[i] == "number") {
                num = arguments[i];
            } else if (get.itemtype(arguments[i]) == "player" || arguments[i] == null) {
                source = arguments[i];
            } else if (typeof arguments[i] == "string") {
                id = arguments[i];
            }
        }

        this.removeDamageMitigationer(id);
        var Limiter = {};
        Limiter.id = id;
        Limiter.num = num;
        Limiter.source = source;
        this.storage._damageMitigationer_Miao.push(Limiter);
        this.markSkill("_DamageMitigationer");
    };

    lib.element.player.removeDamageMitigationer = function () {
        if (!this.storage._damageMitigationer_Miao) {
            this.storage._damageMitigationer_Miao = [];
        }
        var id = _status.event.name,
            nolog = false;
        for (var i = 0; i < arguments.length; i++) {
            if (arguments[i] == "nolog") {
                nolog = true;
            } else if (typeof arguments[i] == "string") {
                id = arguments[i];
            }
        }
        for (var i = 0; i < this.storage._damageMitigationer_Miao.length; i += 1) {
            if (this.storage._damageMitigationer_Miao[i].id == id) {
                this.storage._damageMitigationer_Miao.splice(i, 1);
            }
        }
        if (this.storage._damageMitigationer_Miao.length == 0) this.unmarkSkill("_DamageMitigationer");
    };

    lib.skill["_DamageMitigationer"] = {
        trigger: {
            player: ["damageBegin4"]
        },
        filter: function (event, player) {
            if (!player.hp_float) {
                player.hp_float = 0; //储存浮点位的hp
            }
            if (!player.storage._damageMitigationer_Miao || player.storage._damageMitigationer_Miao.length == 0) return false;
            return true;
        },
        priority: -Infinity, //保证优先级最低
        forced: true,
        silent:true,
        charlotte: true,
        unique: true,
        mark: true,
        marktext: "减伤",
        intro: {
            name: "伤害减免",
            mark: function (dialog, storage, player) {
                var min = Infinity;
                for (var i = 0; i < player.storage._damageMitigationer_Miao.length; ++i) {
                    limiter = player.storage._damageMitigationer_Miao[i];
                    if (player.storage._damageMitigationer_Miao[i].num < min) min = player.storage._damageMitigationer_Miao[i].num;
                }
                return "你受到的所有伤害减少" + (100 - min * 100).toString() + "%";
            }
        },
        content: function () {
            "step 0"
            var min = 1;
            for (var i = 0; i < player.storage._damageMitigationer_Miao.length; ++i) {
                limiter = player.storage._damageMitigationer_Miao[i];
                if (player.storage._damageMitigationer_Miao[i].num < min) min = player.storage._damageMitigationer_Miao[i].num;
            }
            n1 = trigger.num;
            n2 = parseFloat((n1 * min + 0.00001).toFixed(4));
            // nint = parseInt(n2)
            // game.log(n2,nint,n2-nint)
            // nfloathp = parseFloat(n2 - nint)
            // player.hp_float = player.hp_float + parseFloat(nfloathp)
            // trigger.num = parseInt(n2)
            // if(parseFloat(nfloathp) != 0){
            //     trigger.num += 1
            // }
            // game.log(player.hp_float >= 1)
            // flag=false
            // if(player.hp_float == 0 && n2 > 0){
            //     // if(player.hujia > 0){
            //     //     player.changeHujia(-1)
            //     // }
            //     // else{
            //     //     player.hp-=1
            //     // }
            //     trigger.num += 1

            // }
            player.hp_float -= n2;
            // game.log(player.hp_float)
            trigger.num = 0;
            // if(flag){
            //     trigger.num += 1
            // }
            while (player.hp_float < 0) {
                player.hp_float += 1;
                trigger.num += 1;
            }
            // if(player.hp_float == 0){
            //     // if(player.hujia > 0){
            //     //     player.changeHujia(1)
            //     // }
            //     // else{
            //     //     player.hp+=1
            //     // }
            //     trigger.num -= 1
            // }
            // game.log(player.hp_float,'sss',trigger.num)
            game.log(player, "触发了减伤，实际受到<span class='yellowtext'>" + n2 + "</span>点伤害");
            if (n2 < 1) {
                if (player.hujia != 0) {
                    player.changeHujia(-trigger.num);
                } else player.hp -= trigger.num;
                if (trigger.source) {
                    player.$damage(trigger.source);
                } else {
                    player.$damage();
                }
                player.update();
                trigger.num = 0;
            }
            _status.event.trigger("damageMitigation");
            "step 1"
            if (player.hp <= 0 && player.hp_float <= 0) {
                player.nodying = false;
                // game.log(player.hp,player.hp_float);
                player.dying();
            }
        }
    };
    //濒死阶段0.xhp处理
    lib.skill["_DyingWithFloatHp"] = {
        trigger: {
            player: ["dying"]
        },
        direct: true,
        unique: true,
        silent:true,
        // forceunique:true,
        filter: function (event, player) {
            if (!player.hp_float) {
                player.hp_float = 0; //储存浮点位的hp
            }
            return player.hp == 0 && player.hp_float > 0;
        },
        init: function (player) {
            if (!player.hp_float) {
                player.hp_float = 0; //储存浮点位的hp
            }
        },
        content: function () {
            // game.log(player.hp,player.hp_float)
            trigger.cancel();
            for (var i = 0; i < _status.dying.length; ++i) {
                if (_status.dying[i] == player) {
                    _status.dying.splice(i, 1);
                }
            }
            // trigger.nodying = true
        }
    };
    //回满血0.xhp处理
    lib.skill["_RecoverWithFloatHp"] = {
        trigger: {
            player: ["recoverEnd"]
        },
        direct: true,
        unique: true,
        silent:true,
        forceunique: true,
        filter: function (event, player) {
            if (!player.hp_float) {
                player.hp_float = 0; //储存浮点位的hp
            }
            return player.hp == player.maxHp;
        },
        init: function (player) {
            if (!player.hp_float) {
                player.hp_float = 0; //储存浮点位的hp
            }
        },
        content: function () {
            player.hp_float = 0;
        }
    };

    lib.skill["zioy_lockHp"] = {
        trigger: {
            player: ["damageBegin", "loseHpBegin"]
        },
        direct: true,
        unique: true,
        silent:true,
        forceunique: true,
        filter: function (event, player) {
            return true;
        },
        mark: true,
        marktext: "锁血",
        intro: {
            name: "锁血"
        },
        init: function (player) {},
        content: function () {
            trigger.cancel();
        }
    };

    /*-----------------------------------------------------------以下部分为全局状态相关----------------------------------------------------------- */

    game.globalStatus = {
        name: null,
        /*全局状态名称,string or null*/
        timing_type: null,
        /*全局状态计时类型，轮:'round'or回合:"phase"or null */
        locked_timing_type: null,
        /*全局状态锁定计时类型，轮:'round'or回合:"phase"or null */
        source: null,
        /*全局状态来源,player or null*/
        end: 0,
        /*全局状态结束时间,int */
        locked_end: -1,
        /*锁定结束时间,int */
        storage: {
            remove_timing_locked: true
        },
        /*存放全局状态需要的数据,object */
        isLocked: function () {
            /*返回全局状态是否锁定 */
            if (this.locked_timing_type == "round") return this.locked_end > game.roundNumber;
            else return this.locked_end > 0;
        },
        translation: function () {
            /*返回全局状态的中文字符名称 */
            return get.status(this).translation;
        }
    };

    game.changeGlobalStatus = function () {
        /*改变场上状态，example：game.changeGlobalStatus(5,3,"xiyu",ture,"phase") 表示强制转换为细雨天气5回合并锁定3回合，来源默认为event.player*/
        if (!game.hasGlobalStatusButton) {
            game.hasGlobalStatusButton = true;
            ui.globalStatusButton = ui.create.system("喵喵", null, true);
            ui.globalStatusButton.style.display = "hidden";
            lib.setPopped(ui.globalStatusButton, ui.click.globalStatusButton, 170);
            if (get.is.phoneLayout()) {
                ui.globalStatus = ui.create.div(".touchinfo.right", ui.window);
            } else {
                ui.globalStatus = ui.create.div(ui.gameinfo);
            }
        }
        var status = null,
            timing_type = null,
            locked_timing_type = null,
            num = -1,
            locked_num = -1,
            source = _status.event.player,
            forced = false,
            Overridable = false,
            nolog = false; //最后不game.log(xxxxx)
        for (var i = 0; i < arguments.length; i++) {
            if (arguments[i] == "nolog") {
                nolog = true;
            } else if (arguments[i] == "round" || arguments[i] == "phase") {
                if (timing_type == null) timing_type = arguments[i];
                else locked_timing_type = arguments[i];
            } else if (typeof arguments[i] == "boolean") {
                forced = arguments[i];
            } else if (typeof arguments[i] == "number") {
                if (num == -1) num = arguments[i];
                else if (locked_num == -1) locked_num = arguments[i];
            } else if (get.itemtype(arguments[i]) == "player" || arguments[i] == null) {
                source = arguments[i];
            } else if (typeof arguments[i] == "string") {
                status = arguments[i];
            }
        }

        if (timing_type == null) timing_type = "round";
        if (locked_timing_type == null) locked_timing_type = timing_type;
        _status.event.trigger("changeGlobalStatusBegin");
        /*以上处理输入信息 */
        if (get.status(status) == null) status = null;
        var skill = get.status(status).skill;
        if (num <= -1) {
            num = 1;
        }
        if (locked_num <= -1) {
            locked_num = 0;
        }
        if (locked_num > num) {
            locked_num = num;
        }
        if (forced) {
            Overridable = true;
        } else if (
            (get.status(status).type == get.status(game.globalStatus).type || get.status(null).type == get.status(game.globalStatus).type) &&
            !game.globalStatus.isLocked()
        ) {
            Overridable = true;
        }
        var str = "";
        var str1 = lib.globalStatusTypeTranslation[get.status(game.globalStatus).type];
        /*全局状态类型中文字符 */
        var str2 = "轮",
            str4 = str2;
        var flag1 = true;
        if (timing_type == "phase") str2 = "回合";
        if (locked_timing_type == "phase") str4 = "回合";
        //event.trigger("changeGlobalStatus");
        if (Overridable) {
            if (game.globalStatus && game.globalStatus.name != null) {
                if (game.globalStatus.name != status) {
                    /*若当前全局状态与待召唤全局状态不一致则删除上一全局状态 */
                    game.removeGlobalSkillMiao(get.status(game.globalStatus).skill);
                } else {
                    /*若当前全局状态与待召唤全局状态一致则跳过添加全局状态 */
                    flag1 = false;
                }
            }
            if (flag1) {
                game.addGlobalSkillMiao(skill);
                // game.addGlobalSkill("globalStatusRemover");
                // game.addGlobalSkill("globalStatusRemover1");
            }
            game.globalStatus.name = status;
            game.globalStatus.end = Math.max(game.roundNumber + num,game.globalStatus.end);
            game.globalStatus.locked_end = Math.max(game.roundNumber + locked_num,game.globalStatus.locked_end)
            game.globalStatus.source = source;
            game.globalStatus.timing_type = timing_type;
            game.globalStatus.locked_timing_type = locked_timing_type;
            game.globalStatus.storage.remove_timing_locked = true; //防止当前回合更改
            if (timing_type == "phase") {
                game.globalStatus.end = num;
            }
            if (locked_timing_type == "phase") {
                game.globalStatus.locked_end = locked_num;
            }

            // if(_status.event.getParent()['triggername'] == 'phaseBegin' && timing_type == 'phase'){
            // 	/*回合开始阶段修正 */
            // 	game.globalStatus.end += 1;
            // }

            // if(_status.event.getParent()['triggername'] == 'phaseBegin' && locked_timing_type == 'phase'){
            // 	/*回合开始阶段修正 */
            // 	game.globalStatus.locked_end += 1;
            // }

            if (!(status == null && locked_num <= 0)) {
                /*更新str1全局状态类型中文字符 */
                str1 = lib.globalStatusTypeTranslation[get.status(game.globalStatus).type];
            }
            str +=
                "召唤场上" +
                str1 +
                "为：<span class='yellowtext'>" +
                get.status(status).translation +
                "</span>,持续<span class='yellowtext'>" +
                num +
                "</span>" +
                str2;
            if (locked_num == num) {
                str =
                    "锁定场上" +
                    str1 +
                    "为：<span class='yellowtext'>" +
                    get.status(status).translation +
                    "</span>,持续<span class='yellowtext'>" +
                    locked_num +
                    "</span>" +
                    str4;
            } else if (locked_num > 0) {
                str += "并锁定<span class='yellowtext'>" + locked_num + "</span>" + str4;
            }
            if (status == null && locked_num <= 0) {
                str = "清除了场上" + str1;
            }
            if (forced) str = "强制" + str;
            if (!nolog) game.log(source, str);
            ui.updateGlobalStatus();
        } else {
            str += "召唤" + lib.globalStatusTypeTranslation[get.status(status).type] + "失败";
            if (!nolog) game.log(source, str);
        }
        /*以上更改全局状态并输出 */
        _status.event.trigger("changeGlobalStatus_End");
    };

    game.changeGlobalStatusEnd = function () {
        /*改变场上状态持续时间*/
        if (game.globalStatus.name == null) {
            return;
        }
        var num = 0,
            // timing_type = game.globalStatus.timing_type,
            locked_num = 0,
            source = _status.event.player,
            nolog = false; //最后不game.log(xxxxx)
        for (var i = 0; i < arguments.length; i++) {
            if (arguments[i] == "nolog") {
                nolog = true;
            } else if (arguments[i] == "round" || arguments[i] == "phase") {
                timing_type = arguments[i];
            } else if (typeof arguments[i] == "number") {
                if (num == 0) num = arguments[i];
                else if (locked_num == 0) locked_num = arguments[i];
            } else if (get.itemtype(arguments[i]) == "player" || arguments[i] == null) {
                source = arguments[i];
            }
        }

        if (num == 0 && locked_num == 0) return;

        var str = "",
            str1 = "",
            str2 = "";
        if (num > 0) {
            str1 = "延长";
        } else {
            str1 = "减少";
            num = -num;
        }
        if (locked_num > 0) {
            str2 = "延长";
        } else {
            str2 = "减少";
            locked_num = -locked_num;
        }
        if (num != 0) {
            str = str + str1 + '<span class="yellowtext">' + get.status(game.globalStatus).translation + "</span>:<span class='yellowtext'>" + num + "</span>";
            if (game.globalStatus.timing_type == "round") str = str + "轮";
            else str = str + "回合";
        }
        if (locked_num != 0) {
            if (str != "") str = str + ",";
            str = str + str2 + '锁定<span class="yellowtext">' + locked_num + "</span>";
            if (game.globalStatus.locked_timing_type == "round") str = str + "轮";
            else str = str + "回合";
        }
        game.log(source, str);

        /*处理锁定时间大于持续时间 */
        if (game.globalStatus.timing_type == game.globalStatus.locked_timing_type) {
            if (game.globalStatus.locked_end + locked_num > game.globalStatus.end + num) {
                locked_num = game.globalStatus.end + num - game.globalStatus.locked_end;
            }
        }

        /*处理锁定时间小于0 */
        if (game.globalStatus.locked_timing_type == "round") {
            if (game.globalStatus.locked_end + locked_num <= game.roundNumber) {
                locked_num = -game.globalStatus.locked_end + 1;
            }
        } else {
            if (game.globalStatus.locked_end + locked_num <= 0) {
                locked_num = -game.globalStatus.locked_end;
            }
        }

        game.globalStatus.end = game.globalStatus.end + num;
        game.globalStatus.locked_end = game.globalStatus.locked_end + locked_num;
        game.globalStatus.source = source;
        game.globalStatus.storage.remove_timing_locked = true; //防止当前回合更改
        // game.globalStatus.timing_type = timing_type;

        /*处理剩余时间小于0 */
        if (game.globalStatus.timing_type == "round") {
            if (game.globalStatus.end <= game.roundNumber) {
                game.clearGlobalStatus(true, "nolog");
            }
        } else {
            if (game.globalStatus.end <= 0) {
                game.clearGlobalStatus(true, "nolog");
            }
        }
    };
    game.clearGlobalStatus = function () {
        /*强制或状态非锁定则清除场上状态 */
        var force = false,
            source = _status.event.player,
            nolog = false,
            str1 = "清除" + lib.globalStatusTypeTranslation[get.status(game.globalStatus).type];
        for (var i = 0; i < arguments.length; i++) {
            if (arguments[i] == true) {
                force = true;
            } else if (get.itemtype(arguments[i]) == "player" || arguments[i] == null) {
                source = arguments[i];
            } else if (arguments[i] == "nolog") {
                nolog = true;
            }
        }
        //event.trigger("clearGlobalStatusBegin");
        //event.trigger("clearGlobalStatus");
        if (force || !game.globalStatus.isLocked() || game.globalStatus.name == null) {
            if (force) {
                str1 = "强制" + str1;
            }
            game.changeGlobalStatus("nolog", true, null);
            // game.removeGlobalSkill("globalStatusRemover");
            // game.removeGlobalSkill("globalStatusRemover1");
            ui.updateGlobalStatus();
            if (!nolog) game.log(source, str1 + "成功");
        } else {
            if (!nolog) game.log(source, str1 + "失败");
        }
        //event.trigger("clearGlobalStatusEnd");
    };
    game.addGlobalSkillMiao = function (skill) {
        /*添加globalSkill的同时处理skill的init和groupM*/
        if (!lib.skill[skill]) return;

        game.addGlobalSkill(skill);

        /*处理skill的init */
        if (lib.skill[skill].init && typeof lib.skill[skill].init == "function") {
            let p = _status.event.player;
            do {
                lib.skill[skill].init(p);
                p = p.next;
            } while (p != _status.event.player);
        }

        /*直接使用group会出错，这里使用groupM */
        if (lib.skill[skill].groupM) {
            if (typeof lib.skill[skill].groupM == "string") {
                game.log("hello");
                game.addGlobalSkillMiao(lib.skill[skill].groupM);
            } else {
                for (let i in lib.skill[skill].groupM) {
                    game.addGlobalSkillMiao(i);
                }
            }
        }
    };
    game.removeGlobalSkillMiao = function (skill) {
        /*添加globalSkill的同时处理skill的onremove和groupM*/
        if (!lib.skill[skill]) return;

        game.removeGlobalSkill(skill);

        /*处理skill的onremove */
        if (lib.skill[skill].onremove && typeof lib.skill[skill].onremove == "function") {
            let p = _status.event.player;
            do {
                lib.skill[skill].onremove(p);
                p = p.next;
            } while (p != _status.event.player);
        }

        /*直接使用group会出错，这里使用groupM */
        if (lib.skill[skill].groupM) {
            if (typeof lib.skill[skill].groupM == "string") {
                game.removeGlobalSkillMiao(lib.skill[skill].groupM);
            } else {
                for (let i in lib.skill[skill].groupM) {
                    game.removeGlobalSkillMiao(i);
                }
            }
        }
    };

    // game.hasGlobalStatus = function () {
    // 	/*返回目前是否拥有状态，没啥用 */
    // 	if (!game.globalStatus || game.globalStatus == null || game.globalStatus.name == null) return false;
    // 	return true;
    // };

    get.status = function (status) {
        /*如果输入一个object或string，返回lib.globalStatus中key对应的内容，否则返回lib.globalStatus[null] */
        var s = status;
        if (typeof status == "object" && status != null) {
            return get.status(s.name);
        }
        if (lib.globalStatus[status]) {
            return lib.globalStatus[status];
        }
        return lib.globalStatus[null];
    };
    ui.updateGlobalStatus = function () {
        /*时钟边上的全局状态显示 */
        if (game.globalStatus.name != null) {
            ui.globalStatus.innerHTML = lib.globalStatusTypeTranslation[get.status(game.globalStatus).type] + ":" + get.status(game.globalStatus).translation;
        } else {
            ui.globalStatus.innerHTML = "当前无天气/环境";
        }
        if (get.is.phoneLayout()) ui.globalStatus.innerHTML = "<br>" + ui.globalStatus.innerHTML;
    };
    ui.click.globalStatusButton = function () {
        /*喵喵按钮 */
        var uiintro = ui.create.dialog("hidden");
        uiintro.listen(function (e) {
            e.stopPropagation();
        });
        var num;
        if (game.online) {
            num = _status.cardPileNum || 0;
        } else {
            num = ui.cardPile.childNodes.length;
        }
        if (game.globalStatus.name == null) {
            uiintro.add("当前无天气/环境");
        } else {
            uiintro.add(
                '<div class="text center">>>>当前' +
                    lib.globalStatusTypeTranslation[get.status(game.globalStatus).type] +
                    "为<<<</div><br>" +
                    get.status(game.globalStatus).translation
                // +"<br>"
            );
            var str = "",
                str2 = "轮",
                num1 = game.globalStatus.end - game.roundNumber,
                num2 = game.globalStatus.locked_end - game.roundNumber;
            if (game.globalStatus.timing_type == "phase") {
                str2 = "回合";
                num1 = game.globalStatus.end;
            }
            str = '<div class="text center"><P align=left>--->剩余:' + num1 + str2 + "<br>";
            if (game.globalStatus.locked_timing_type == "phase") {
                str2 = "回合";
                num2 = game.globalStatus.locked_end;
            }
            if (game.globalStatus.isLocked()) {
                str += "--->锁定:" + num2 + str2 + "</P></div>";
            } else {
                str += "--->未被锁定</P></div>";
            }
            str += '<div class="text center"><P align=left>--->效果:' + get.status(game.globalStatus).intro.replace('<br>','<br>--->') + "</P></div>";
            uiintro.add(str);
        }
        return uiintro;
    };

    lib.globalStatusTypeTranslation = {
        /*储存全局状态类型对应的中文字符 */
        "weather": "天气",
        "environment": "环境",
        null: "状态"
    };

    lib.globalStatus = {
        /*存储所有全局状态信息 */

        /*以下为天气 */

        "rerang": {
            translation: "热浪",
            skill: "zioy_status_rerang",
            type: "weather",
            intro: "火属性伤害+1。"
        },
        "xiyu": {
            translation: "细雨",
            skill: "zioy_status_xiyu",
            type: "weather",
            intro: "火属性伤害将被视为无属性伤害。"
        },
        "chunfeng": {
            translation: "台风",
            skill: "zioy_status_taifeng",
            type: "weather",
            intro: "角色受伤时，概率将其随机一张牌移动至下家的对应位置。"
        },
        "shuguang": {
            translation: "曙光",
            skill: "zioy_status_shuguang",
            type: "weather",
            intro: "回合结束阶段清除当前角色的所有异常状态。"
        },
        "fenfang": {
            translation: "芬芳",
            skill: "zioy_status_fenfang",
            type: "weather",
            intro: "回合结束阶段，若当前回合角色体力值不大于2，其回复1点体力。"
        },
        "shenlou": {
            translation: "海市蜃楼",
            skill: "zioy_status_shenlou",
            type: "weather",
            intro: "回合结束阶段令当前回合角色执行[失去log3(X)点体力（X为海市蜃楼剩余回合数，向上取整），将牌弃置至Y张（Y为体力值，至少弃置1张），获得“睡眠”异常]中随机任意项。<br>当海市蜃楼结束时，当前回合角色失去所有体力。"
        },
        "heiwu": {
            translation: "黑雾",
            skill: "zioy_status_heiwu",
            type: "weather",
            intro: "所有角色体力上限-1直到“黑雾”天气结束。"
        },

        /*以下为环境 */

        "mizhang": {
            translation: "迷嶂",
            skill: "zioy_status_mizhang",
            type: "environment",
            intro: "所有角色进攻距离-1。"
        },
        "hexu": {
            translation: "云归鹤墟",
            skill: "zioy_status_hexu",
            type: "environment",
            intro: "还没想出来。"
        },
        "huoshan": {
            translation: "风林火山",
            skill: "zioy_status_huoshan",
            type: "environment",
            intro: "回复体力时令回复体力值减半（向下取整）。"
        },
        "senluowanxiang": {
            translation: "森罗万象",
            skill: "zioy_status_senluowanxiang",
            type: "environment",
            intro: "回合结束阶段，你随机摸0~6张牌，然后你有10*N%几率进入睡眠/混乱状态（N为你以此法获得的牌的数量）。"
        },

        /*以下为其他状态 */

        null: {
            translation: "无",
            skill: null,
            type: null,
            intro: "目前场上无任何状态。"
        },

        "test": {
            translation: "测试",
            skill: null,
            type: null,
            intro: "测试。"
        }
    };

    lib.skill["zioy_status"] = {
        /*储存全局状态对应技能 */
        subSkill: {
            example: {
                trigger: {
                    global: "phaseEnd"
                },
                sub: true,
                forced: true,
                direct: true,
                unique: true,
                silent:true,
                charlotte: true,
                filter: function (event, player) {
                    return true;
                },
                init: function (player) {},
                onremove: function (player) {},
                content: function () {},
                mod: {},
                groupM: "zioy_status_example1"
            },
            xiyu: {
                sub: true,
                forced: true,
                direct: true,
                unique: true,
                silent:true,
                charlotte: true,
                trigger: {
                    source: "damageBegin1"
                },
                filter: function (event) {
                    return event.hasNature("fire");
                },
                priority: -5,
                content: function () {
                    trigger.nature = null;
                }
            },
            rerang: {
                sub: true,
                forced: true,
                direct: true,
                unique: true,
                silent:true,
                charlotte: true,
                trigger: {
                    source: "damageBegin1"
                },
                filter: function (event) {
                    return event.hasNature("fire");
                },
                priority: -5,
                content: function () {
                    trigger.num += 1;
                }
            },
            mizhang: {
                sub: true,
                forced: true,
                direct: true,
                silent:true,
                unique: true,
                charlotte: true,
                mod: {
                    globalFrom: function (from, to, distance) {
                        return distance + 1;
                    }
                }
            },
            shuguang: {
                sub: true,
                forced: true,
                direct: true,
                unique: true,
                silent:true,
                charlotte: true,
                trigger: {
                    player: "phaseEnd"
                },
                priority: -2523,
                content: function () {
                    player.removeBuff("all");
                }
            },
            shenlou: {
                trigger: {
                    player: "phaseEnd"
                },
                sub: true,
                forced: true,
                direct: true,
                unique: true,
                silent:true,
                charlotte: true,
                filter: function (event, player) {
                    return !player.storage.shenlou_noLoseHp;
                },
                init: function (player) {},
                onremove: function (player) {
                    let p = _status.currentPhase
                    if(!p.storage.shenlou_noLoseHp){
                        p.loseHp(p.hp)
                    }
                },
                content: function () {
                    var r = function () {
                        return [true, false].randomGet();
                    };
                    if (r()) {
                        let n = game.globalStatus.end
                        if(game.globalStatus.timing_type === 'round'){
                            n = (n - game.roundNumber)*game.players.length
                        }
                        n = Math.ceil(Math.log(n)/Math.log(3))
                        player.loseHp(n);
                    }
                    if (r()) {
                        var n = player.countCards() - player.hp;
                        if (player.countCards() > 0 && n <= 0) n = 1;
                        player.chooseToDiscard(true, n);
                    }
                    if (r()) {
                        player.addBuff("shuimian", null);
                    }
                },
                mod: {},
                "_priority": 6485
            },
            huoshan: {
                trigger: {
                    player: "recoverBegin"
                },
                sub: true,
                forced: true,
                direct: true,
                silent:true,
                unique: true,
                charlotte: true,
                filter: function (event, player) {
                    return !player.storage.huoshan_no;
                },
                init: function (player) {},
                onremove: function (player) {},
                content: function () {
                    trigger.num = parseInt(trigger.num / 2);
                },
                mod: {},
                "_priority": 685
            },
            fenfang: {
                trigger: {
                    player: "phaseEnd"
                },
                sub: true,
                forced: true,
                direct: true,
                unique: true,
                silent:true,
                charlotte: true,
                filter: function (event, player) {
                    return true;
                },
                init: function (player) {},
                onremove: function (player) {},
                content: function () {
                    if(player.hp <= 2)player.recover()
                },
                mod: {},
            },
            senluowanxiang: {
                trigger: {
                    player: "phaseEnd"
                },
                sub: true,
                forced: true,
                direct: true,
                silent:true,
                unique: true,
                charlotte: true,
                filter: function (event, player) {
                    return true;
                },
                init: function (player) {},
                onremove: function (player) {},
                content: function () {
                    let num = parseInt(Math.random()*7)
                    player.draw(num)
                    if(Math.random() < 0.1*num){
                        // console.log(12)
                        player.addBuff('shuimian')
                    }
                },
                mod: {},
            },
            
            heiwu: {
                trigger: {
                    global: "phaseEnd"
                },
                sub: true,
                forced: true,
                direct: true,
                unique: true,
                silent:true,
                charlotte: true,
                filter: function (event, player) {
                    return false;
                },
                init: function (player) {
                    player.loseMaxHp(1);
                },
                onremove: function (player) {
                    player.gainMaxHp(1);},
                content: function () {},
                mod: {},
            },

            test: {
                sub: true,
                forced: true,
                direct: true,
                unique: true,
                silent:true,
                charlotte: true,
                mod: {}
            }
        }
    };

    lib.skill["_globalStatusRemover"] = {
        /*轮类型全局状态倒计时 */
        trigger: {
            global: "roundStart"
        },
        filter: function (card, player, target) {
            if (game.globalStatus.storage.remove_timing_locked == true) return false;
            if (game.globalStatus.timing_type != "round") return false;
            return game.globalStatus.end <= game.roundNumber;
        },
        direct: true,
        charlotte: true,
        silent:true,
        unique: true,
        content: function () {
            if (game.globalStatus.timing_type == "round" && game.globalStatus.end <= game.roundNumber) {
                game.clearGlobalStatus(true, "nolog", null);
                ui.updateGlobalStatus();
            }
        }
        //group:"globalStatusRemover1",
    };
    lib.skill["_globalStatusRemover1"] = {
        /*回合类型全局状态倒计时 */
        trigger: {
            player: "phaseBegin"
        },
        direct: true,
        charlotte: true,
        silent:true,
        unique: true,
        filter: function (event, player) {
            if (game.globalStatus.storage.remove_timing_locked == true) return false;
            return true;
            if (game.globalStatus.locked_timing_type == "phase") game.globalStatus.locked_end--;
            if (game.globalStatus.timing_type != "phase") return false;
            game.globalStatus.end--;
            return game.globalStatus.end <= 0;
        },
        content: function () {
            if (game.globalStatus.locked_timing_type == "phase") game.globalStatus.locked_end--;
            // game.log(123)
            if (game.globalStatus.timing_type == "phase") {
                if (game.globalStatus.storage.remove_timing_locked == true) return;
                game.globalStatus.end--;
                game.globalStatus.storage.remove_timing_locked = true;
                // game.log(game.globalStatus.end);
                if (game.globalStatus.end <= 0) {
                    game.clearGlobalStatus(true, "nolog", null);
                    ui.updateGlobalStatus();
                }
            }
        }
    };

    lib.skill["_globalStatusRemover2"] = {
        /*回合类型全局状态倒计时 */
        trigger: {
            player: "phaseEnd"
        },
        direct: true,
        charlotte: true,
        silent:true,
        unique: true,
        filter: function (event, player) {
            return true;
        },
        content: function () {
            // game.log(666);
            game.globalStatus.storage.remove_timing_locked = false;
        }
    };

    /*---------------------------------------------------------------以下部分为异常相关---------------------------------------------------------------*/

    lib.element.player.addBuff = function () {
        /*添加异常状态 */
        var buff = null,
            num = 1, //暂时没用，异常状态的持续时间应由异常状态本身决定
            force = false, //暂时没用
            source = _status.event.player; //暂时没用
        for (var i = 0; i < arguments.length; i++) {
            if (typeof arguments[i] == "number") {
                num = arguments[i];
            } else if (get.itemtype(arguments[i]) == "player" || arguments[i] == null) {
                source = arguments[i];
            } else if (typeof arguments[i] == "string") {
                buff = arguments[i];
            } else if (arguments[i] == true) {
                force = true;
            }
        }

        if (buff == null || !lib.buffMiao[buff]) {
            game.log("buff not found_1");
            return;
        }
        if (!this.storage.buffArray) {
            this.storage.buffArray = [];
        }
        if (!this.storage.immuneBuffArray) {
            //Translated by deepl
            this.storage.immuneBuffArray = [];
        }
        var skill = lib.buffMiao[buff].skill;
        for (let i = 0; i < this.storage.immuneBuffArray.length; i++) {
            if (force == true) break;
            //若免疫此buff则return
            if (lib.buffMiao[this.storage.immuneBuffArray[i].name] == lib.buffMiao[buff]) {
                game.log(this, "免疫<span class='yellowtext'>" + lib.buffMiao[buff].translation + "</span>异常");
                return;
            }
        }
        for (let i = 0; i < this.storage.buffArray.length; i++) {
            //若有相同buff则return
            if (lib.buffMiao[this.storage.buffArray[i]] == lib.buffMiao[buff]) {
                return;
            }

            //移除已有同类型Buff
            if (lib.buffMiao[this.storage.buffArray[i]].type == lib.buffMiao[buff].type) {
                this.removeBuff(this.storage.buffArray[i]);
            }
        }
        // console.log(this)
        if(skill == 'mad'){
            this.addTempSkill(skill,'phaseEnd')
        }else{
            this.addSkill(skill);
        }
        this.storage.buffArray.push(buff);
        var strf = "";
        if (force) strf = "强制";
        if (source != null) {
            game.log(source, "令", this, strf, "获得<span class='yellowtext'>" + lib.buffMiao[buff].translation + "</span>异常");
        } else {
            game.log(this, strf, "获得了<span class='yellowtext'>" + lib.buffMiao[buff].translation + "</span>异常");
        }
    };

    lib.element.player.removeBuff = function () {
        /*移去异常状态 */
        var buff = null,
            all = false,
            force = false, //暂时没用
            source = _status.event.player; //暂时没用
        for (var i = 0; i < arguments.length; i++) {
            if (typeof arguments[i] == "number") {
                num = arguments[i];
            } else if (arguments[i] == "all" || arguments[i] == "All") {
                all = true;
            } else if (get.itemtype(arguments[i]) == "player" || arguments[i] == null) {
                source = arguments[i];
            } else if (typeof arguments[i] == "string") {
                buff = arguments[i];
            } else if (arguments[i] == true) {
                force = true;
            }
        }
        if (all) {
            for (let i in lib.buffMiao) {
                this.removeBuff(i);
            }
            return;
        }
        if (buff == null || !lib.buffMiao[buff]) {
            game.log("buff not found_2");
            return;
        }
        if (!this.storage.buffArray) {
            this.storage.buffArray = [];
        }
        var skill = lib.buffMiao[buff].skill;
        for (let i = 0; i < this.storage.buffArray.length; i++) {
            if (this.storage.buffArray[i] == buff) {
                this.removeSkill(skill);
                this.storage.buffArray.splice(i, 1);
                game.log(this, "移除了<span class='yellowtext'>" + lib.buffMiao[buff].translation + "</span>异常");
                break;
            }
        }
    };

    lib.element.player.addBuffImmune = function () {
        /*添加异常免疫 */
        if (!this.storage.buffArray) {
            this.storage.buffArray = [];
        }
        if (!this.storage.immuneBuffArray) {
            //Translated by deepl
            this.storage.immuneBuffArray = [];
        }
        if (!this.storage.immuneBuffRemover) {
            //Translated by deepl
            this.storage.immuneBuffRemover = [];
        }
        var buff = [],
            num = Infinity,
            type = "round",
            id = _status.event.name, // 区分不同来源的异常免疫
            clear = false, //添加免疫时移除已有但免疫的异常
            all = false; //免疫所有异常
        for (var i = 0; i < arguments.length; i++) {
            if (arguments[i] == "all" || arguments[i] == "All") {
                all = true;
            } else if (arguments[i] == "phase") {
                type = "phase";
            } else if (arguments[i] == "round") {
                type = "round";
            } else if (typeof arguments[i] == "string" && arguments[i].substring(0,3) == "id=") {
                id = arguments[i].substring(3)
            } else if (arguments[i] == true) {
                clear = true;
            } else if (typeof arguments[i] == "number") {
                num = arguments[i];
            } else if (typeof arguments[i] == "object") {
                for (var j = 0; j < arguments[i].length; j++) {
                    buff.push(arguments[i][j]);
                }
            } else if (typeof arguments[i] == "string") {
                buff.push(arguments[i]);
            }
        }
        if (all == true) {
            for (let i in lib.buffMiao) {
                this.addBuffImmune(i, clear, num, type, 'id='+id);
            }
            return;
        }
        var flag = true;
        for (var i = 0; i < buff.length; i++) {
            var b = buff[i];
            flag = true;
            if (b == null || !lib.buffMiao[b]) {
                game.log("buff not found_3", b);
                return;
            }
            if (clear == true) {
                for (let i = 0; i < this.storage.buffArray.length; i++) {
                    if (lib.buffMiao[this.storage.buffArray[i]] == lib.buffMiao[b]) {
                        this.removeBuff(b);
                        break;
                    }
                }
            }
            var getmax = function(arr){
                var max = -1
                for(let i of arr){

                }
            }
            // //若已免疫此buff则continue
            // for (let j = 0; j < this.storage.immuneBuffArray.length; j++) {
            // 	if (lib.buffMiao[this.storage.immuneBuffArray[j].name] == lib.buffMiao[b]) {
            // 		var n = this.storage.immuneBuffArray[j].name;
            // 		for(let ibr of this.storage.immuneBuffRemover){
            // 			if(ibr.id == id && ibr.num > num && ibr.type == type){
            // 				flag = false
            // 			}
            // 		}
            // 		if (flag == false) break;
            // 		// if (this.storage.immuneBuffRemover[b].type != type || this.storage.immuneBuffRemover[b].num >= num) {
            // 		// 	flag = false;
            // 		// 	break;
            // 		// }
            // 	}
            // }
            // if (flag == false) continue;
            if (this.storage.immuneBuffArray.filter(v=>v.name == b && v.id == id).length == 0) this.storage.immuneBuffArray.push({"name":b,"id":id});
            // this.storage.immuneBuffRemover[b] = {};
            // this.storage.immuneBuffRemover[b].num = num;
            // this.storage.immuneBuffRemover[b].type = type;
            // this.storage.immuneBuffRemover[b].id = id;
            if (_status.event.getParent() && _status.event.getParent()["triggername"] == "phaseBegin" && type == "phase") {
                /*回合开始阶段修正 */
                num += 1;
            }
            flag = false
            for(let v of this.storage.immuneBuffRemover){
                if(v.name == b && v.type == type && v.id == id){
                    if(v.num < num)v.num = num
                    flag = true
                }
            }
            if(flag == false)this.storage.immuneBuffRemover.push({
                "name":b,
                "num":num,
                "type":type,
                "id":id
            })
            if (_status.event.getParent() && _status.event.getParent()["triggername"] == "phaseBegin" && type == "phase") {
                num -= 1;
            }
            var str = "获得<span class='yellowtext'>" + lib.buffMiao[b].translation + "</span>免疫";
            if (num != Infinity) {
                str = str + '<span class="yellowtext">' + num;
                if (type == "round") {
                    str = str + "</span>轮";
                } else {
                    str = str + "</span>回合";
                }
            }
            game.log(this, str);
            this.markSkill("zioy_buff_mianyi");
        }
    };

    lib.element.player.removeBuffImmune = function () {
        /*移除异常免疫 */
        if (!this.storage.buffArray) {
            this.storage.buffArray = [];
        }
        if (!this.storage.immuneBuffArray) {
            //Translated by deepl
            this.storage.immuneBuffArray = [];
        }
        if (!this.storage.immuneBuffRemover) {
            //Translated by deepl
            this.storage.immuneBuffRemover = [];
        }
        var buff = [],
            source = null,
            id = _status.event.name // 区分不同来源的异常免疫
            // all_flag = false
        for (var i = 0; i < arguments.length; i++) {
            if (arguments[i] == "all" || arguments[i] == "All") {
                for (let i in lib.buffMiao) {
                    // this.removeBuffImmune(i,source,"id="+id);
                    buff.push(i)
                }
            } else if (typeof arguments[i] == "string" && arguments[i].substring(0,3) == "id=") {
                id = arguments[i].substring(3)
            } else if (typeof arguments[i] == "object") {
                for (var j = 0; j < arguments[i].length; j++) {
                    buff.push(arguments[i][j]);
                }
            } else if (get.itemtype(arguments[i]) == "player" || arguments[i] == null) {
                source = arguments[i];
            } else if (typeof arguments[i] == "string") {
                buff.push(arguments[i]);
            } else if (arguments[i] == true) {
                force = true;
            }
        }
        // console.log(buff,id,this.storage.immuneBuffArray)
        // if(all_flag){
        // 	for (let i in lib.buffMiao) {
        // 		this.removeBuffImmune(i,source,"id="+id);
        // 	}
        // 	return;
        // }

        var flag = true;
        for (var b of buff) {
            // var b = buff[i];
            // console.log(b)
            flag = true;
            if (b == null || !lib.buffMiao[b]) {
                game.log("buff not found_4");
                return;
            }

            //若未免疫此buff则continue
            for (let i = 0; i < this.storage.immuneBuffArray.length; i++) {
                if (lib.buffMiao[this.storage.immuneBuffArray[i].name] == lib.buffMiao[b]) {
                    flag = false;
                    break;
                }
            }
            if (flag == true) continue;
            // 失去免疫
            this.storage.immuneBuffArray = this.storage.immuneBuffArray.filter(i=>i.name != b || i.id != id)
            this.storage.immuneBuffRemover = this.storage.immuneBuffRemover.filter(i=>i.name != b || i.id != id)
            if(this.storage.immuneBuffArray.filter(v=>v.name == b).length == 0){
                game.log(this, "失去<span class='yellowtext'>" + lib.buffMiao[b].translation + "</span>免疫");
            }
            // console.log('123')
        }
        if (this.storage.immuneBuffArray.length == 0) this.unmarkSkill("zioy_buff_mianyi");
    };

    lib.skill._miao_removeBuffImmune1 = {
        /*轮次类型计数移除异常免疫 */
        trigger: {
            global: "roundStart"
        },
        filter: function (card, player, target) {
            return player.storage.immuneBuffRemover;
        },
        direct: true,
        charlotte: true,
        silent:true,
        unique: true,
        content: function () {
            // 检查是否所有计时器都结束
            var checkRemovable=name=>{
                for(let v of player.storage.immuneBuffRemover){
                    if(v.name == name && v.num > 0)return false
                }
                return true
            }
            let i = 0
            while(i < player.storage.immuneBuffRemover.length) {
                // console.log(player.storage.immuneBuffRemover[i],player.storage.immuneBuffRemover,i)
                if (player.storage.immuneBuffRemover[i].type == "round") {
                    player.storage.immuneBuffRemover[i].num -= 1;
                    if (player.storage.immuneBuffRemover[i].num == 0) {
                        var name = player.storage.immuneBuffRemover[i].name
                        if(checkRemovable(name)){
                            player.removeBuffImmune(player.storage.immuneBuffRemover[i].name,"id="+player.storage.immuneBuffRemover[i].id);
                        }else{
                            i++
                        }
                    }else{
                        i++
                    }
                }else{
                    i++
                }
            }
            player.storage.immuneBuffRemover=player.storage.immuneBuffRemover.filter(v=>v.num > 0)
        }
    };

    lib.skill._miao_removeBuffImmune2 = {
        /*回合类型计数移除异常免疫 */
        trigger: {
            global: "phaseBegin"
        },
        direct: true,
        charlotte: true,
        silent:true,
        unique: true,
        filter: function (event, player) {
            return player.storage.immuneBuffRemover;
        },
        content: function () {
            // 检查是否所有计时器都结束
            var checkRemovable=name=>{
                for(let v of player.storage.immuneBuffRemover){
                    if(v.name == name && v.num > 0)return false
                }
                return true
            }
            let i = 0
            while(i < player.storage.immuneBuffRemover.length) {
                // console.log(player.storage.immuneBuffRemover[i],player.storage.immuneBuffRemover,i)
                if (player.storage.immuneBuffRemover[i].type == "phase") {
                    player.storage.immuneBuffRemover[i].num -= 1;
                    if (player.storage.immuneBuffRemover[i].num == 0) {
                        var name = player.storage.immuneBuffRemover[i].name
                        if(checkRemovable(name)){
                            player.removeBuffImmune(player.storage.immuneBuffRemover[i].name,"id="+player.storage.immuneBuffRemover[i].id);
                        }else{
                            i++
                        }
                    }else{
                        i++
                    }
                }else{
                    i++
                }
            }
            player.storage.immuneBuffRemover=player.storage.immuneBuffRemover.filter(v=>v.num > 0)
        }
    };

    lib.buffMiao = {
        /*存储所有异常状态信息 */
        "shuimian": {
            translation: "睡眠",
            skill: "zioy_buff_shuimian",
            type: "control",
            intro: "始终跳过出牌阶段，无法使用或打出任何牌，每轮游戏开始时有25*n%概率移除此状态,受到伤害时立即移除此状态。（n为异常状态已持续轮数）"
        },
        // "bingdong": {
        // 	translation: "冰冻",
        // 	skill: "zioy_buff_bingdong",
        // 	type: "control",
        // 	intro:
        // 		"跳过判定阶段，摸牌阶段，出牌阶段与弃牌阶段，受到的所有伤害-1，回合开始阶段有15*n%概率移除此状态。受到火属性伤害时立即移除此状态。（n为异常状态已持续轮数）"
        // },
        // "ranshao": {
        // 	translation: "燃烧",
        // 	skill: "zioy_status_ranshao",
        // 	type: "damage",
        // 	intro: "balabala"
        // },
        "mad":{
            translation: "混乱",
            skill: "mad",
            type: "damage",
            intro:"角色陷入混乱"
        }
    };

    lib.skill["zioy_buff"] = {
        /*储存异常状态对应技能，如写正常技能一般即可 */
        subSkill: {
            mianyi: {
                mark: true,
                marktext: "免疫",
                intro: {
                    name: "免疫以下异常状态",
                    mark: function (dialog, storage, player) {
                        var flag = 0,
                            str = "",
                            buff_name="";
                        var getn = (name,type)=>{
                            var arr = player.storage.immuneBuffRemover
                            var max = -1
                            for(let i of arr){
                                // console.log(i.name , name , i.type , type)
                                if(i.name == name && i.type == type){
                                    var n = i.num
                                    // if(i.type == 'round'){
                                    // 	n *= game.players.length
                                    // }
                                    if(n > max)max = n
                                }
                            }
                            return max
                        }
                        function unique(arr) {
                            return arr.filter(function(item, index, arr) {
                              return arr.indexOf(item, 0) === index;
                            });
                        }
                        var ls = unique(player.storage.immuneBuffArray.map(v=>v.name))
                        for (let a of ls) {
                            // var a = player.storage.immuneBuffArray[i].name;
                            for(let typei of ['round','phase']){
                                var n = getn(a,typei)
                                if (n == -1)continue
                                if (n != Infinity) {
                                    // buff_name = lib.buffMiao[a].translation + ":" + player.storage.immuneBuffRemover[a].num;
                                    buff_name = lib.buffMiao[a].translation + ":" + n;
                                } else {
                                    buff_name = lib.buffMiao[a].translation + ":∞";
                                }
                                if (typei == "round") {
                                    buff_name = buff_name + "轮";
                                } else {
                                    buff_name = buff_name + "回合";
                                }
                                if (flag % 2 == 0 && flag != 0) str += "<br>";
                                else {
                                    if (flag != 0) str += ",";
                                }
                                flag++;
                                str += buff_name;
                            }
                            // if (player.storage.immuneBuffRemover[a].num != Infinity) {
                            // 	buff_name = lib.buffMiao[a].translation + ":" + player.storage.immuneBuffRemover[a].num;
                            // } else {
                            // 	buff_name = lib.buffMiao[a].translation + ":∞";
                            // }
                            // // if (player.storage.immuneBuffRemover[a].type == "round") {
                            // 	// buff_name = buff_name + "轮";
                            // // } else {
                            // 	buff_name = buff_name + "回合";
                            // // }
                            // if (flag % 2 == 0 && flag != 0) str += "<br>";
                            // else {
                            // 	if (flag != 0) str += ",";
                            // }
                            // flag++;
                            // str += buff_name;
                        }
                        return str;
                    }
                }
            },
            shuimian: {
                mark: true,
                marktext: "睡眠",
                init: function (player) {
                    player.storage.shuimian_count = 0;
                },
                trigger: {
                    player: "phaseUseBegin"
                },
                priority: 3014745327,
                direct: true,
                silent:true,
                filter: function () {
                    return true;
                },
                content: function () {
                    trigger.cancel(null, null, "notrigger");
                },
                mod:{
                    cardEnabled:function(card,player){
                        return false;
                    },
                    cardRespondable:function(card,player){
                        return false;
                    },
                    // cardSavable:function(card,player){
                    // 	return false;
                    // },
                },
                group: ["zioy_buff_shuimian_awake1", "zioy_buff_shuimian_awake2"],
                intro: {
                    name: "睡眠",
                    mark: function (dialog, storage, player) {
                        var n = player.storage.shuimian_count + 1;
                        return "始终跳过出牌阶段，无法使用或打出任何牌，下轮游戏开始时有" + 25 * n + "%概率移除此状态,受到伤害后立即移除此状态。";
                    }
                }
            },
            shuimian_awake1: {
                trigger: {
                    player: "damageEnd"
                },
                priority: -301745327,
                direct: true,
                silent:true,
                filter: function () {
                    return true;
                },
                content: function () {
                    player.removeBuff("shuimian");
                }
            },
            shuimian_awake2: {
                trigger: {
                    global: "roundStart"
                },
                priority: -3456301727,
                direct: true,
                silent:true,
                filter: function () {
                    return true;
                },
                content: function () {
                    player.storage.shuimian_count++;
                    if (player.storage.shuimian_count * 0.25 > Math.random()) player.removeBuff("shuimian");
                }
            }
        }
    };

    lib.element.player.goMad_old = lib.element.player.goMad
    lib.element.player.goMad = function(end ,force){
        // console.log(this, this.storage )
        if (!this.storage.buffArray) {
            this.storage.buffArray = [];
        }
        if (!this.storage.immuneBuffArray) {
            //Translated by deepl
            this.storage.immuneBuffArray = [];
        }
        if (!this.storage.immuneBuffRemover) {
            //Translated by deepl
            this.storage.immuneBuffRemover = [];
        }
        for (let i = 0; i < this.storage.immuneBuffArray.length; i++) {
            if (force == true) break;
            //若免疫此buff则return
            if (lib.buffMiao[this.storage.immuneBuffArray[i].name] == lib.buffMiao['mad']) {
                game.log(this, "免疫<span class='yellowtext'>" + lib.buffMiao['mad'].translation + "</span>异常");
                return;
            }
        }
        this.goMad_old(end)

    }
    /*---------------------------------------------------------------以下部分为强化相关---------------------------------------------------------------*/

    lib.element.player.changeEnhancement = function () {
        /*获得/失去强化 */
        var enhancements = [],
            num = 1,
            source = _status.event.player,
            forced = false,
            strlog = "",
            flag = false;
        // nolog = false; //最后不game.log(xxxxx)
        for (var i = 0; i < arguments.length; i++) {
            if (arguments[i] == "nolog") {
                nolog = true;
            } else if (arguments[i] == "all") {
                enhancements = ["attack", "miss", "defend", "hit", "strike"];
            } else if (typeof arguments[i] == "boolean") {
                forced = arguments[i];
            } else if (typeof arguments[i] == "number") {
                num = arguments[i];
            } else if (get.itemtype(arguments[i]) == "player" || arguments[i] == null) {
                source = arguments[i];
            } else if (typeof arguments[i] == "string") {
                enhancements.push(arguments[i]);
            } else if (typeof arguments[i] == "object") {
                for (var j = 0; j < arguments[i].length; j++) {
                    enhancements.push(arguments[i][j]);
                }
            }
        }
        if (num == 0) {
            return;
        }
        if (this.storage.enhancementArray["locked"] == true && forced == false) {
            game.log(this, "的强化已<span class='yellowtext'>锁定</span>");
            return;
        }
        if (num > 0) {
            strlog = "获得了" + num + '级<span class="yellowtext">';
        } else if (num < 0) {
            strlog = "失去了" + -num + '级<span class="yellowtext">';
        }
        for (var i = 0; i < enhancements.length; ++i) {
            var e = enhancements[i];
            if (this.storage.enhancementArray[e] || this.storage.enhancementArray[e] == 0) {
                this.storage.enhancementArray[e] += num;
                let s;
                switch (e) {
                    case "attack":
                        s = "攻击";
                        break;
                    case "defend":
                        s = "防御";
                        break;
                    case "miss":
                        s = "闪避";
                        break;
                    case "hit":
                        s = "命中";
                        break;
                    case "strike":
                        s = "暴击";
                        break;
                    case "draw":
                        s = "摸牌";
                        break;
                }
                if (flag) s = '</span>，<span class="yellowtext">' + s;
                flag = true;
                if (this.storage.enhancementArray[e] > 6) {
                    this.storage.enhancementArray[e] = 6;
                }
                if (this.storage.enhancementArray[e] < -6) {
                    this.storage.enhancementArray[e] = -6;
                }
                this.storage["miao_enhancement_mark_" + e] = this.storage.enhancementArray[e];
                this.storage["miao_enhancement_mark_" + e + "1"] = this.storage.enhancementArray[e];
                // if (this.storage.enhancementArray[e] > 0) {
                // 	this.markSkill("miao_enhancement_mark_" + e + "1");
                // } else if (this.storage.enhancementArray[e] == 0) {
                // 	this.unmarkSkill("miao_enhancement_mark_" + e);
                // 	this.unmarkSkill("miao_enhancement_mark_" + e + "1");
                // } else if (this.storage.enhancementArray[e] < 0) {
                // 	this.markSkill("miao_enhancement_mark_" + e);
                // }
                strlog = strlog + s;
            }
        }
        strlog = strlog + "</span>强化";
        game.log(this, strlog);
        flag = true;
        for (var i in this.storage.enhancementArray) {
            if (!["attack", "miss", "defend", "hit", "strike"].includes(i)) continue;
            if (this.storage.enhancementArray[i] != 0) {
                flag = false;
                this.markSkill("miao_enhancement_mark_mark");
                break;
            }
        }
        if (flag) this.unmarkSkill("miao_enhancement_mark_mark");
    };

    lib.element.player.lockEnhancement = function () {
        /*锁定强化 */
        var num = -1, //锁定回合数
            source = _status.event.player,
            forced = false,
            type = "round",
            strlog = "";
        for (var i = 0; i < arguments.length; i++) {
            if (arguments[i] == "nolog") {
                nolog = true;
            } else if (typeof arguments[i] == "boolean") {
                forced = arguments[i];
            } else if (typeof arguments[i] == "number") {
                num = arguments[i];
            } else if (get.itemtype(arguments[i]) == "player" || arguments[i] == null) {
                source = arguments[i];
            } else if (typeof arguments[i] == "string") {
                type = arguments[i];
            }
        }
        if (num < 0 || (type == this.storage.enhancementArray["locked_type"] && num < this.storage.enhancementArray["locked_end"])) {
            return;
        }
        this.storage.enhancementArray["locked"] = true;
        this.storage.enhancementArray["locked_end"] = num;
        // game.log(_status.event.getParent().name);
        // for(var i in _status.event.getParent()){
        // 	game.log(i,':',_status.event.getParent()[i]);
        // }
        if (_status.event.getParent()["triggername"] == "phaseBegin" && type == "phase") {
            /*回合开始阶段修正 */
            this.storage.enhancementArray["locked_end"] += 1;
        }
        this.storage.enhancementArray["locked_type"] = type;
        this.markSkill("miao_enhancement_mark_locked");
        strlog = strlog + "已锁定强化<span class='yellowtext'>";
        this.addSkill("miao_enhancement_locked");
        this.addSkill("miao_enhancement_locked2");
        strlog = strlog + num + "</span>";
        if (type == "round") {
            strlog = strlog + "轮";
        } else {
            strlog = strlog + "回合";
        }
        game.log(this, strlog);
    };

    lib.element.player.unlockEnhancement = function () {
        /*解锁强化 */
        var source = _status.event.player,
            forced = false,
            strlog = "";
        for (var i = 0; i < arguments.length; i++) {
            if (arguments[i] == "nolog") {
                nolog = true;
            } else if (typeof arguments[i] == "boolean") {
                forced = arguments[i];
            } else if (get.itemtype(arguments[i]) == "player" || arguments[i] == null) {
                source = arguments[i];
            }
        }
        if (this.storage.enhancementArray["locked"] == false) {
            return;
        }
        // if (num > 0) {
        // 	strlog = "获得了" + num + '级<span class="yellowtext">';
        // } else if (num < 0) {
        // 	strlog = "失去了" + -num + '级<span class="yellowtext">';
        // }
        this.storage.enhancementArray["locked"] = false;
        this.storage.enhancementArray["locked_end"] = -1;
        this.storage.enhancementArray["locked_type"] = null;
        this.unmarkSkill("miao_enhancement_mark_locked");
        this.removeSkill("miao_enhancement_locked");
        this.removeSkill("miao_enhancement_locked2");
        strlog = strlog + "已解锁强化";
        game.log(this, strlog);
    };

    lib.element.player.clearEnhancement = function () {
        /*清空强化 */
        var nolog = null,
            source = _status.event.player,
            forced = false;

        for (var i = 0; i < arguments.length; i++) {
            if (arguments[i] == "nolog") {
                nolog = "nolog";
            } else if (typeof arguments[i] == "boolean") {
                forced = arguments[i];
            } else if (get.itemtype(arguments[i]) == "player" || arguments[i] == null) {
                source = arguments[i];
            }
        }
        if (this.storage.enhancementArray["locked"] == true && !forced) {
            game.log(this, "已锁定强化");
            return;
        }
        var c = ["attack", "miss", "defend", "hit", "strike"];
        for (var l = 0; l < c.length; ++l) {
            i = c[l];
            if (nolog != null) this.changeEnhancement(i, -this.storage.enhancementArray[i], source, forced, nolog);
            this.changeEnhancement(i, -this.storage.enhancementArray[i], source, forced);
        }
    };

    lib.element.player._miao_check_enhancement = function () {
        if (!this.storage.enhancementArray)
            this.storage.enhancementArray = {
                attack: 0, //攻击力
                defend: 0, //防御力
                miss: 0, //闪避率
                hit: 0, //命中率
                strike: 0, //暴击率，目前没用
                draw: 0, //摸牌，目前没用
                locked: false,
                locked_end: -1,
                locked_type: null
            };
    };
    lib.skill._miao_enhancement_init = {
        /*游戏开始时设置player.storage.enhancementArray */
        // addplayer时会出错，需要注意
        unique: true,
        trigger: {
            global: "phaseBefore",
            player: ["enterGame", "showCharacterAfter"]
        },
        priority: 70582140,
        forced: true,
        silent:true,
        locked: true,
        direct: true,
        filter: function (event, player) {
            return event.name != "phase" || game.phaseNumber == 0 || !player.storage.enhancementArray;
        },
        content: function () {
            player.storage.enhancementArray = {
                attack: 0, //攻击力
                defend: 0, //防御力
                miss: 0, //闪避率
                hit: 0, //命中率
                strike: 0, //暴击率，目前没用
                draw: 0, //摸牌，目前没用
                locked: false,
                locked_end: -1,
                locked_type: null
            };
        }
    };
    lib.skill._miao_enhancement_attack = {
        /*根据攻击与防御强化进行伤害修正 */
        trigger: {
            source: "damageBegin1"
        },
        priority: -70582140,
        forced: true,
        filter: function (card, player, target) {
            return true;
        },
        direct: true,
        silent:true,
        charlotte: true,
        unique: true,
        content: function () {
            if (!player.storage.enhancementArray) {
                player.storage.enhancementArray = {
                    attack: 0, //攻击力
                    defend: 0, //防御力
                    miss: 0, //闪避率
                    hit: 0, //命中率
                    strike: 0, //暴击率，目前没用
                    draw: 0, //摸牌，目前没用
                    locked: false,
                    locked_end: -1,
                    locked_type: null
                };
            }
            if (!trigger.player.storage.enhancementArray) {
                player.storage.enhancementArray = {
                    attack: 0, //攻击力
                    defend: 0, //防御力
                    miss: 0, //闪避率
                    hit: 0, //命中率
                    strike: 0, //暴击率，目前没用
                    draw: 0, //摸牌，目前没用
                    locked: false,
                    locked_end: -1,
                    locked_type: null
                };
            }
            var numDamage = trigger.num,
                numAtk = player.storage.enhancementArray["attack"],
                numDfd = trigger.player.storage.enhancementArray["defend"];
            var dmm = numAtk - numDfd; //Damage modifier multiplier
            // game.log(player,trigger.player,dmm);
            if (dmm > 0) {
                numDamage *= 0.5 * dmm + 1;
                numDamage = parseInt(numDamage);
            } else if (dmm < 0) {
                numDamage *= 1 / (-dmm * 0.5 + 1);
                numDamage = Math.ceil(numDamage);
            }
            trigger.num = numDamage;
        }
    };

    lib.skill._miao_enhancement_miss = {
        /*根据命中与闪避强化判定是否闪避 */
        trigger: {
            player: ["chooseToRespondBegin", "chooseToUseBegin"]
        },
        filter: function (event, player) {
            if (event.responded) return false;
            if (event.miss_skill_miaomiao) return false;
            if (!event.filterCard || !event.filterCard({ name: "shan" }, player, event)) return false;
            if (event.name == "chooseToRespond" && !lib.filter.cardRespondable({ name: "shan" }, player, event)) return false;
            return true;
        },
        priority: 70582140,
        forced: true,
        direct: true,
        silent:true,
        charlotte: true,
        unique: true,
        content: function () {
            if (!player.storage.enhancementArray) {
                player.storage.enhancementArray = {
                    attack: 0, //攻击力
                    defend: 0, //防御力
                    miss: 0, //闪避率
                    hit: 0, //命中率
                    strike: 0, //暴击率，目前没用
                    draw: 0, //摸牌，目前没用
                    locked: false,
                    locked_end: -1,
                    locked_type: null
                };
            }
            if (!trigger.player.storage.enhancementArray) {
                player.storage.enhancementArray = {
                    attack: 0, //攻击力
                    defend: 0, //防御力
                    miss: 0, //闪避率
                    hit: 0, //命中率
                    strike: 0, //暴击率，目前没用
                    draw: 0, //摸牌，目前没用
                    locked: false,
                    locked_end: -1,
                    locked_type: null
                };
            }
            event.miss_skill_miaomiao = true;
            var numMis = player.storage.enhancementArray["miss"],
                numHit = trigger.player.storage.enhancementArray["hit"];
            var num = numMis - numHit;
            if (num <= 0) return;
            else {
                num = 0.05 * num;
            }
            if (num > Math.random()) {
                trigger.untrigger();
                trigger.set("responded", true);
                trigger.result = { bool: true, card: { name: "shan", isCard: false } };
            }
        }
    };

    lib.skill._miao_enhancement_strike = {
        /*根据攻击与防御强化进行伤害修正 */
        trigger: {
            source: "damageBegin1"
        },
        priority: -70582140,
        forced: true,
        filter: function (card, player, target) {
            return true;
        },
        direct: true,
        charlotte: true,
        silent:true,
        unique: true,
        content: function () {
            if (!player.storage.enhancementArray) {
                player.storage.enhancementArray = {
                    attack: 0, //攻击力
                    defend: 0, //防御力
                    miss: 0, //闪避率
                    hit: 0, //命中率
                    strike: 0, //暴击率，目前没用
                    draw: 0, //摸牌，目前没用
                    locked: false,
                    locked_end: -1,
                    locked_type: null
                };
            }
            if (!trigger.player.storage.enhancementArray) {
                player.storage.enhancementArray = {
                    attack: 0, //攻击力
                    defend: 0, //防御力
                    miss: 0, //闪避率
                    hit: 0, //命中率
                    strike: 0, //暴击率，目前没用
                    draw: 0, //摸牌，目前没用
                    locked: false,
                    locked_end: -1,
                    locked_type: null
                };
            }
            var numDamage = trigger.num,
                num = player.storage.enhancementArray["strike"];
            if (num * 0.05 > Math.random()) {
                trigger.num *= 2;
                game.log(player, "暴击了");
            }
        }
    };

    lib.skill._miao_enhancement_locked = {
        /*轮次类型计数移除强化锁定 */
        trigger: {
            global: "roundStart"
        },
        filter: function (card, player, target) {
            return true;
        },
        direct: true,
        silent:true,
        charlotte: true,
        unique: true,
        content: function () {
            if (!player.storage.enhancementArray || player.storage.enhancementArray.locked_type != "round") {
                return;
            }
            player.storage.enhancementArray.locked_end -= 1;
            if (player.storage.enhancementArray.locked_end == 0) {
                player.unlockEnhancement();
            }
        }
    };

    lib.skill._miao_enhancement_locked2 = {
        /*回合类型计数移除强化锁定 */
        trigger: {
            global: "phaseBegin"
        },
        direct: true,
        silent:true,
        charlotte: true,
        unique: true,
        filter: function (event, player) {
            return true;
        },
        content: function () {
            if (!player.storage.enhancementArray || player.storage.enhancementArray.locked_type != "phase") {
                return;
            }
            player.storage.enhancementArray.locked_end -= 1;
            if (player.storage.enhancementArray.locked_end == 0) {
                player.unlockEnhancement();
            }
        }
    };

    lib.skill.miao_enhancement_mark = {
        /*强化的mark，指示用,CPU is cheap,memory is cheap,life is beautiful */
        subSkill: {
            mark: {
                mark: true,
                marktext: "强化",
                intro: {
                    name: "强化等级",
                    mark: function (dialog, storage, player) {
                        var str = "",
                            count = 0;
                        for (var i in player.storage.enhancementArray) {
                            if (!["attack", "miss", "defend", "hit", "strike"].includes(i) || player.storage.enhancementArray[i] == 0) continue;
                            var e = i;
                            var s = "";
                            count++;
                            if (count != 1 && (count - 1) % 3 == 0) {
                                str = str + "<br>";
                            } else if (count != 1) {
                                str = str + ",";
                            }
                            switch (e) {
                                case "attack":
                                    s = "攻击";
                                    break;
                                case "defend":
                                    s = "防御";
                                    break;
                                case "miss":
                                    s = "闪避";
                                    break;
                                case "hit":
                                    s = "命中";
                                    break;
                                case "strike":
                                    s = "暴击";
                                    break;
                                case "draw":
                                    s = "摸牌";
                                    break;
                            }
                            if (player.storage.enhancementArray[i] > 0) {
                                s = s + "+";
                            }
                            s = s + player.storage.enhancementArray[i];
                            str = str + s;
                        }
                        return str;
                    }
                }
            },
            attack: {
                mark: true,
                marktext: "攻击",
                intro: {
                    name: "攻击"
                }
            },

            defend: {
                mark: true,
                marktext: "防御",
                intro: {
                    name: "防御"
                }
            },
            miss: {
                mark: true,
                marktext: "闪避",
                intro: {
                    name: "闪避"
                }
            },
            hit: {
                mark: true,
                marktext: "命中",
                intro: {
                    name: "命中"
                }
            },
            strike: {
                mark: true,
                marktext: "暴击",
                intro: {
                    name: "暴击"
                }
            },
            draw: {
                mark: true,
                marktext: "摸牌",
                intro: {
                    name: "摸牌"
                }
            },
            attack1: {
                mark: true,
                marktext: "攻击+",
                intro: {
                    name: "攻击"
                }
            },
            defend1: {
                mark: true,
                marktext: "防御+",
                intro: {
                    name: "防御"
                }
            },
            miss1: {
                mark: true,
                marktext: "闪避+",
                intro: {
                    name: "闪避"
                }
            },
            hit1: {
                mark: true,
                marktext: "命中+",
                intro: {
                    name: "命中"
                }
            },
            strike1: {
                mark: true,
                marktext: "暴击+",
                intro: {
                    name: "暴击"
                }
            },
            draw1: {
                mark: true,
                marktext: "摸牌+",
                intro: {
                    name: "摸牌"
                }
            },
            locked: {
                mark: true,
                marktext: "锁强",
                intro: {
                    name: "已锁定强化等级",
                    mark: function (dialog, storage, player) {
                        var str;
                        if (player.storage.enhancementArray["locked_type"] == "round") str = " 轮";
                        else {
                            str = " 回合";
                        }
                        return "剩余 " + player.storage.enhancementArray["locked_end"] + str;
                    }
                }
            }
        }
    };

    /*---------------------------------------------------------------以下部分为武将势力相关---------------------------------------------------------------*/

    // 暂时不可用
    game.AddGroupNatureMiao = function (name, translation, mapping) {
        /*设定势力的函数，from活动武将 */
        if (!mapping || !Array.isArray(mapping) || mapping.length != 3) mapping = [199, 21, 133];
        var gradient = [mapping, mapping];
        var y = "(" + mapping[0] + "," + mapping[1] + "," + mapping[2];
        var y1 = y + ",1)",
            y2 = y + ")";
        var s = document.createElement("style");
        var l;
        //omg
        l = ".player .identity[data-color='miao_" + name + "'],";
        l += "div[data-nature='miao_" + name + "'],";
        l +=
            "span[data-nature='miao_" +
            name +
            "'] {text-shadow: black 0 0 1px,rgba" +
            y1 +
            " 0 0 2px,rgba" +
            y1 +
            " 0 0 5px,rgba" +
            y1 +
            " 0 0 10px,rgba" +
            y1 +
            " 0 0 10px}";
        l += "div[data-nature='miao_" + name + "m'],";
        l +=
            "span[data-nature='miao_" +
            name +
            "m'] {text-shadow: black 0 0 1px,rgba" +
            y1 +
            " 0 0 2px,rgba" +
            y1 +
            " 0 0 5px,rgba" +
            y1 +
            " 0 0 5px,rgba" +
            y1 +
            " 0 0 5px,black 0 0 1px;}";
        l += "div[data-nature='miao_" + name + "mm'],";
        l +=
            "span[data-nature='miao_" +
            name +
            "mm'] {text-shadow: black 0 0 1px,rgba" +
            y1 +
            " 0 0 2px,rgba" +
            y1 +
            " 0 0 2px,rgba" +
            y1 +
            " 0 0 2px,rgba" +
            y1 +
            " 0 0 2px,black 0 0 1px;}";
        s.innerHTML = l;
        document.head.appendChild(s);
        if (gradient && Array.isArray(gradient) && Array.isArray(gradient[0]) && gradient[0].length == 3) {
            var str = "",
                st2 = [];
            for (var i = 0; i < gradient.length; i++) {
                str += ",rgb(" + gradient[i][0] + "," + gradient[i][1] + "," + gradient[i][2] + ")";
                if (i < 2) st2[i] = "rgb(" + gradient[i][0] + "," + gradient[i][1] + "," + gradient[i][2] + ")";
            }
            var tenUi = document.createElement("style");
            tenUi.innerHTML = ".player>.camp-zone[data-camp='" + name + "']>.camp-back {background: linear-gradient(to bottom" + str + ");}";
            tenUi.innerHTML += ".player>.camp-zone[data-camp='" + name + "']>.camp-name {text-shadow: 0 0 5px " + st2[0] + ", 0 0 10px " + st2[1] + ";}";
            document.head.appendChild(tenUi);
        }
        //lib.group.push(n);
        lib.translate[name] = translation;
        lib.groupnature[name] = "miao_" + name;
    };
    game.AddGroupNatureMiao("daqin", "秦", [255, 165, 0]);
    game.AddGroupNatureMiao(null, "?", [0, 0, 0]);
    // game.AddGroupNatureMiao('test', "测试", [0, 0, 0]);
}