/**
	 * 令玩家复活--事件化
	 * @param { number } [hp = 1]
	 * @param { boolean } [log]
	 */
	reviveEvent(hp, log) {
		const next = game.createEvent("revive");
		next.player = this;
		if (hp) {
			next.hp = hp;
		} else {
			next.hp = 1;
		}
		next.log = log;
		next.forceDie = true;
		next.setContent("revive");
		return next;
	}
       //用例：卡牌武圣归来
      async content(event, trigger, player) {
		const { target } = event;
		if (!target.isDead()) {
			return;
		}
		await target.reviveEvent();
		await target.draw(3);
	},

         /**
	 * 令玩家使用牌
	 * @returns { GameEventPromise }
	 */
	useCard() {
		...
		const event = get.event(),
			card = next.cards[0];
		next.modSkill = {
			cardname: null,
			cardnature: null,
			cardsuit: null,
			cardnumber: null,
		};
		const keys = Object.keys(next.modSkill).flat();
		if (event.name == "chooseToUse" && !next.skill && get.itemtype(card) == "card") {
			let skills = [];
			if (typeof this.getModableSkills === "function") {
				skills = this.getModableSkills();
			} else if (typeof this.getSkills === "function") {
				skills = this.getSkills().concat(lib.skill.global);
				game.expandSkills(skills);
				skills = skills.filter(i => {
					const info = get.info(i);
					return info && info.mod;
				});
				skills.sort((a, b) => get.priority(a) - get.priority(b));
			}
			for (const skill of skills) {
				for (const key of keys) {
					const mod = get.info(skill).mod[key == "cardsuit" ? "suit" : key];
					if (mod) {
						let arg = [card, this, event, "unchanged"];
						const result = mod.call(game, ...arg);
						if (result !== undefined && typeof arg[arg.length - 1] !== "object") {
							arg[arg.length - 1] = result;
						}
						if (arg[arg.length - 1]) {
							next.modSkill[key] = skill;
						}
					}
				}
			}
		}

		...
	}
         

//OL麴义的伏骑
onChooseToUse(event) {
	event.targetprompt2.add(target => {
		if (!target.isIn()) {
			return false;
		}
		const player = get.player(),
			card = get.card();
		if (get.type(card) == "trick" || (get.type(card) == "basic" && !["shan", "tao", "jiu", "du"].includes(card.name))) {
			if (target.isIn() && target !== player && get.distance(target, player) <= 1) {
				return "不可响应";
			}
		}
	});
},
//OL谋小乔的迷落
const next = player
	.chooseTarget(`###${get.prompt(event.skill)}###令一名没有“迷落”牌的角色失去1点体力，或令一名有“迷落”牌的角色回复1点体力。`, (card, player, target) => {
		return player.getStorage("olmiluo_clear").includes(target);
	})
	.set("ai", target => {
		const player = get.player();
		if (target.countCards("h", card => card.hasGaintag("olmiluo"))) {
			return get.recoverEffect(target, player, player);
		}
		return get.effect(target, { name: "loseHp" }, player, player);
	});
	next.targetprompt2.add(target => {
		if (!target.isIn() || !get.event().filterTarget(null, get.player(), target)) {
			return false;
		}
		return target.countCards("h", card => card.hasGaintag("olmiluo")) ? "回复体力" : "失去体力";
	});
	event.result = await next.forResult();
//OL谋文丑的轮战
onChooseToUse(event) {
	if (!game.online && !event.olsblunzhan) {
		const player = get.player();
		event.set("olsblunzhan", player.getHistory("useCard"));
	}
	event.targetprompt2.add(target => {
		if (!target.isIn() || get.event().skill != "olsblunzhan" || !get.event().filterTarget(get.card(), get.player(), target)) {
			return false;
		}
		const player = get.player(),
			history = get.event().olsblunzhan;
		const num = history?.filter(evt => evt.targets?.includes(target)).length;
		return `轮战${num}`;
	});
},

         /**
	 * 用于玩家使用非自己手牌时生成的可以选择的假牌（其实就是复制一份出来）。
	 *
	 * @param { Card[] | Card } cards 需要被复制的真牌，允许传入单张卡牌或者卡牌数组
	 * @param { Boolean } isBlank 是否生成只有牌背没有其他牌面信息的牌
	 * @param { string } tempname 生成的假牌的临时名字，只有isBlank为true才会用到
	 * @returns { Card[] }
	 */
	createFakeCards(cards, isBlank = false, tempname) {
		if (!Array.isArray(cards)) {
			cards = [cards];
		}
		const cardsx = cards.map(card => {
			const cardx = ui.create.card();
			cardx.isFake = true;
			cardx._cardid = card.cardid;
			if (isBlank) {
				//没有tempname默认就是白板
				cardx.init([null, null, tempname || "猜猜看啊", null]);
				game.broadcastAll(cardx => {
					cardx.classList.add("infohidden");
					cardx.classList.add("infoflip");
				}, cardx);
			} else {
				cardx.init(get.cardInfo(card));
			}
			return cardx;
		});
		return cardsx;
	}
	/**
	 * 用于删除createFakeCards生成的假牌。
	 *
	 * @param { Card[] | Card } cards 需要被删除的假牌，允许传入单张卡牌或者卡牌数组
	 * @returns { Card[] } 返回那些不是假牌的牌
	 */
	deleteFakeCards(cards) {
		if (!Array.isArray(cards)) {
			cards = [cards];
		}
		const fake = cards.filter(card => card.isFake && card._cardid),
			other = cards.removeArray(fake),
			wild = [],
			map = {};
		fake.forEach(card => {
			const owner = get.owner(card);
			if (!owner) {
				wild.push(card);
				return;
			}
			if (!map[owner.playerid]) {
				map[owner.playerid] = [];
			}
			map[owner.playerid].push(card);
		});
		wild.forEach(i => i.delete());
		for (const id in map) {
			const target = (_status.connectMode ? lib.playerOL : game.playerMap)[id];
			const cards = map[id];
			if (target?.isOnline2()) {
				target.send(
					function (cards, player) {
						cards.forEach(i => i.delete());
						if (player == game.me) {
							ui.updatehl();
						}
					},
					cards,
					target
				);
			}
			cards.forEach(i => i.delete());
			if (target == game.me) {
				ui.updatehl();
			}
		}
		return other;
	}

	cardDescription(node, player) {
		let str = "",
			name = node.name;
		if (lib.translate[name + "_info"]) {
			if (lib.card[name].type && lib.translate[lib.card[name].type]) {
				str += "" + get.translation(lib.card[name].type) + "牌|";
			}
			if (get.subtype(name)) {
				str += "" + get.translation(get.subtype(name)) + "|";
			}
			if (lib.card[name] && lib.card[name].addinfomenu) {
				str += "" + lib.card[name].addinfomenu + "|";
			}
			if (get.subtype(name) == "equip1") {
				let added = false;
				if (lib.card[node.name] && lib.card[node.name].distance) {
					const dist = lib.card[node.name].distance;
					if (dist.attackFrom) {
						added = true;
						str += "攻击范围：" + (-dist.attackFrom + 1) + "|";
					}
				}
				if (!added) {
					str += "攻击范围：1|";
				}
			}
		}
		if (lib.card[name].cardPrompt) {
			str += "" + lib.card[name].cardPrompt(node, player) + "|";
		} else if (lib.translate[name + "_info"]) {
			str += "" + lib.translate[name + "_info"] + "|";
		}
		if (lib.translate[name + "_append"]) {
			str += "" + lib.translate[name + "_append"] + "|";
		}
		if (get.is.yingbianConditional(node)) {
			const yingbianEffects = get.yingbianEffects(node);
			if (!yingbianEffects.length) {
				const defaultYingbianEffect = get.defaultYingbianEffect(node);
				if (lib.yingbian.prompt.has(defaultYingbianEffect)) {
					yingbianEffects.push(defaultYingbianEffect);
				}
			}
			if (yingbianEffects.length) {
				str += `应变：${yingbianEffects.map(value => lib.yingbian.prompt.get(value)).join("；")}|`;
			}
		}
		return str;
	}

	/**
	 * 初始化角色列表
	 *
	 * 仅无参时修改_status.characterlist
	 * @param { boolean } [filter] 筛选逻辑：false跳过移除逻辑，否则执行默认移除逻辑
	 * @returns { string[] }
	 */
	initCharactertList(filter) {
		let list;
		if (_status.connectMode) {
			list = get.charactersOL();
		} else {
			list = Object.keys(lib.character).filter(name => !lib.filter.characterDisabled2(name) && !lib.filter.characterDisabled(name));
		}
		if (filter !== false) {
			if (list.length) {
				game.countPlayer2(current => {
					list.removeArray(get.nameList(current));
				});
			}
			if (filter === undefined) {
				_status.characterlist = list;
			}
		}
		return list;
	}

skill = {
	trigger: { player: "phaseUseBegin" },
	async cost(event, trigger, player) {
		event.result = await player.chooseToUse().set("chooseonly", true).forResult();
	},
	async content(event, trigger, player) {
		const { ResultEvent, logSkill } = event.cost_data;
		event.next.push(ResultEvent);
		if (logSkill) {
			if (typeof logSkill == "string") {
				ResultEvent.player.logSkill(event.logSkill);
			} else if (Array.isArray(logSkill)) {
				ResultEvent.player.logSkill.call(ResultEvent.player, ...logSkill);
			}
		}
		await ResultEvent;
	},
};

	getRoundHistory(key, filter = lib.filter.all, num = 0, keep, last) {
		if (!filter || typeof filter != "function") {
			filter = lib.filter.all;
		}
		let evts = [],
			history = _status.globalHistory;
		for (let i = history.length - 1; i >= 0; i--) {
			if (keep === true || num == 0) {
				let currentHistory = history[i];
				if (key) {
					currentHistory = currentHistory[key];
				}
				if (filter) {
					currentHistory = currentHistory.filter(filter);
				}
				evts.addArray(currentHistory.slice().reverse());
			}
			if (history[i].isRound) {
				if (num > 0) {
					num--;
				} else {
					break;
				}
			}
		}
		evts.reverse();
		if (last && evts.includes(last)) {
			const lastIndex = evts.indexOf(last);
			return evts.filter(evt => evts.indexOf(evt) <= lastIndex);
		}
		return evts;
	}

localMarkSkill(skill, target, event) {
		const func = (skill, player) => {
			var name = skill,
				info;
			if (player.marks[name]) {
				player.updateMarks();
			}
			if (lib.skill[name]) {
				info = lib.skill[name].intro;
			}
			if (!info) {
				return;
			}
			if (player.marks[name]) {
				player.marks[name].info = info;
			} else {
				player.marks[name] = player.mark(name, info);
			}
			player.updateMarks();
		};
		if (event.player == game.me) {
			func(skill, target);
		} else if (event.isOnline()) {
			this.send(func, skill, target);
		}
	}

selectGroup = ["shen", "western", "devil"];