noname/character/ddd/skill.js

import { lib, game, ui, get, ai, _status } from "../../noname.js";

/** @type { importCharacterConfig['skill'] } */
const skills = {
	//牵招
	dddyuanzhen: {
		audio: 2,
		trigger: { player: "useCardToPlayered" },
		forced: true,
		filter(event, player) {
			return event.target != player && get.distance(player, event.target) != 1 && event.isFirstTarget && event.targets.length == 1;
		},
		logTarget: "target",
		*content(event, map) {
			const player = map.player,
				trigger = map.trigger,
				target = trigger.target;
			let result;
			game.delayex();
			if (!target.countCards("he")) result = { bool: false };
			else
				result = yield target
					.chooseToDiscard("he", `${get.translation(player)}对你使用了【远振】`, "请弃置一张牌，或点击“取消”令其摸一张牌")
					.set("ai", card => {
						if (get.event("goon")) return 4.5 - get.value(card);
					})
					.set("goon", get.attitude(target, player) > 0);
			if (!result.bool) {
				target.line(player);
				player.draw();
			}
		},
	},
	dddzhishu: {
		audio: 2,
		trigger: { player: "phaseUseBegin" },
		filter(event, player) {
			return player.canMoveCard(null, true);
		},
		check(event, player) {
			return player.canMoveCard(true, true);
		},
		*content(event, map) {
			const player = map.player;
			let result = yield player.moveCard();
			const targets = result.targets;
			const guohe = new lib.element.VCard({
				name: "guohe",
				isCard: true,
			});
			if (targets[0].canUse(guohe, targets[1])) targets[0].useCard(guohe, targets[1], "noai");
		},
	},
	//张邈
	dddxiaxing: {
		audio: 2,
		enable: "chooseToUse",
		hiddenCard(player, name) {
			if (player.hasSkill("dddxiaxing_used")) return false;
			return name == "tao";
		},
		filter(event, player) {
			if (event.type != "dying") return false;
			if (!player.countCards("he")) return false;
			const evt = get.event().getParent("_save");
			if (!evt || !evt.dying || !evt.dying.isIn()) return false;
			return !player.hasSkill("dddxiaxing_used");
		},
		check: card => {
			return 7 - get.value(card);
		},
		filterCard: true,
		position: "he",
		discard: false,
		delay: false,
		lose: false,
		group: ["dddxiaxing_begin", "dddxiaxing_viewas"],
		prompt() {
			const evt = get.event().getParent("_save");
			return `将一张牌置于牌堆顶，视为${get.translation(evt.dying)}使用一张【桃】`;
		},
		*content(event, map) {
			const player = map.player,
				cards = event.cards;
			player.addTempSkill("dddxiaxing_used", "roundStart");
			game.log(player, "将一张牌置于了牌堆顶");
			player.$throw(cards.length, 1000);
			yield player.lose(cards, ui.cardPile, "insert");
			const evt = event.getParent("_save");
			yield evt.dying.chooseUseTarget("tao", true);
			if (!player.hasMark("dddxiaxing")) player.addMark("dddxiaxing");
		},
		marktext: "侠",
		intro: {
			markcount: () => 0,
			name: "侠行",
			name2: "侠",
			content: "已拥有“侠”标记",
		},
		ai: {
			order: 4,
			result: {
				player(player) {
					if (_status.event.dying) return get.attitude(player, _status.event.dying);
					return 1;
				},
			},
		},
		subSkill: {
			begin: {
				audio: 2,
				trigger: { global: "phaseZhunbeiBegin" },
				filter(event, player) {
					if (!player.countCards("he")) return false;
					return !player.hasSkill("dddxiaxing_used");
				},
				direct: true,
				*content(event, map) {
					const player = map.player,
						trigger = map.trigger,
						target = trigger.player;
					let result = yield player
						.chooseCard(get.prompt("dddxiaxing"), `将一张牌置于牌堆顶，视为${get.translation(target)}使用一张【酒】`, "he")
						.set("ai", card => {
							if (get.event("goon")) return 5 - get.value(card);
							return 0;
						})
						.set("goon", get.effect(target, { name: "jiu" }, player, player) > 0);
					if (!result.bool) return event.finish();
					const cards = result.cards;
					player.logSkill("dddxiaxing_begin", target);
					player.addTempSkill("dddxiaxing_used", "roundStart");
					game.log(player, "将一张牌置于了牌堆顶");
					player.$throw(cards.length, 1000);
					yield player.lose(cards, ui.cardPile, "insert");
					yield target.chooseUseTarget("jiu", true);
					if (!player.hasMark("dddxiaxing")) player.addMark("dddxiaxing");
				},
			},
			used: { charlotte: true },
			viewas: {
				audio: "dddxiaxing",
				enable: "chooseToUse",
				filter(event, player) {
					if (event.type == "wuxie" || !player.hasMark("dddxiaxing")) return false;
					for (const name of ["sha", "shan"]) {
						if (event.filterCard({ name: name, isCard: true }, player, event)) return true;
					}
					return false;
				},
				chooseButton: {
					dialog(event, player) {
						const vcards = [];
						for (const name of ["sha", "shan"]) {
							const card = { name: name, isCard: true };
							if (event.filterCard(card, player, event)) vcards.push(["基本", "", name]);
						}
						const dialog = ui.create.dialog("侠行", [vcards, "vcard"], "hidden");
						dialog.direct = true;
						return dialog;
					},
					backup(links, player) {
						return {
							filterCard: () => false,
							selectCard: -1,
							viewAs: {
								name: links[0][2],
								isCard: true,
							},
							popname: true,
							precontent() {
								player.logSkill("dddxiaxing_viewas");
								player.clearMark("dddxiaxing");
							},
						};
					},
					prompt(links, player) {
						return "侠行：移去“侠”标记，视为使用一张【" + get.translation(links[0][2]) + "】";
					},
				},
				ai: {
					order(item, player) {
						const event = get.event();
						if (event.filterCard({ name: "sha" }, player, event)) {
							if (
								!player.hasShan() &&
								!game.hasPlayer(function (current) {
									return player.canUse("sha", current) && current.hp == 1 && get.effect(current, { name: "sha" }, player, player) > 0;
								})
							) {
								return 0;
							}
							return 2.95;
						} else return 3.15;
					},
					respondSha: true,
					respondShan: true,
					skillTagFilter(player, tag, arg) {
						if (!player.hasMark("dddxiaxing")) return false;
						if (arg != "use") return false;
					},
					result: {
						player: 1,
					},
				},
			},
		},
	},
	//张承
	dddjuxian: {
		enable: "phaseUse",
		usable: 2,
		filter(event, player) {
			return !player.hasSkill("dddjuxian_ban");
		},
		chooseButton: {
			dialog(event, player) {
				var dialog = ui.create.dialog("聚贤：请选择一项", "hidden");
				dialog.add([
					[
						["top", "展示一张牌，然后将此牌置于牌堆顶"],
						["hand", "展示一张牌，然后将此牌交给一名其他角色"],
					],
					"textbutton",
				]);
				return dialog;
			},
			filter(button, player) {
				return !player.hasSkill("dddjuxian_" + button.link, null, null, false);
			},
			check(button) {
				return 1;
			},
			backup(links) {
				return get.copy(lib.skill["dddjuxian_" + links[0]]);
			},
			prompt(links) {
				if (links[0] == "top") return "展示一张牌，然后将此牌置于牌堆顶";
				return "展示一张牌，然后将此牌交给一名其他角色";
			},
		},
		ai: {
			order: 10,
			threaten: 1.7,
			result: { player: 1 },
		},
		subSkill: {
			backup: { audio: "dddjuxian" },
			ban: { charlotte: true },
			top: {
				audio: "dddjuxian",
				filterCard: true,
				selectCard: 1,
				position: "he",
				discard: false,
				delay: false,
				lose: false,
				*content(event, map) {
					const player = map.player,
						cards = event.cards;
					player.addTempSkill("dddjuxian_top", "phaseUseAfter");
					player.showCards(cards);
					const color1 = get.color(cards);
					player.$throw(cards, 1000);
					game.log(player, "将", cards, "置于了牌堆顶");
					yield player.lose(cards, ui.cardPile, "insert");
					const targets = game.filterPlayer(target => target.countGainableCards(player, "he"));
					let result;
					if (!targets.length) return event.finish();
					else if (targets.length == 1) result = { bool: true, targets: targets };
					else
						result = yield player
							.chooseTarget(
								"聚贤：获得一名其他角色的一张牌",
								(card, player, target) => {
									if (target == player) return false;
									return target.countGainableCards(player, "he");
								},
								true
							)
							.set("ai", target => {
								const player = get.player();
								return get.effect(target, { name: "shunshou" }, player, player);
							});
					if (!result.bool) return event.finish();
					const target = result.targets[0];
					player.line(target);
					result = yield player.gainPlayerCard(target, "he", true);
					if (!result.bool) return event.finish();
					const cards2 = result.links;
					const color2 = get.color(cards2);
					if (color1 && color2 && color1 != color2) player.addTempSkill("dddjuxian_ban");
				},
				ai: {
					result: {
						player: 1,
					},
				},
			},
			hand: {
				audio: "dddjuxian",
				filterTarget: lib.filter.notMe,
				filterCard: true,
				selectCard: 1,
				position: "he",
				discard: false,
				delay: false,
				lose: false,
				*content(event, map) {
					const player = map.player,
						cards = event.cards,
						target = event.targets[0];
					player.addTempSkill("dddjuxian_hand", "phaseUseAfter");
					player.showCards(cards);
					const color1 = get.color(cards);
					let result;
					yield player.give(cards, target);
					result = yield player.draw();
					const cards2 = result.filter(i => get.owner(i) == player && get.position(i) == "h");
					if (!cards.length) return event.finish();
					const color2 = get.color(cards2);
					player.showCards(cards2);
					if (color1 && color2 && color1 != color2) player.addTempSkill("dddjuxian_ban");
				},
				ai: {
					result: {
						player: 1,
						target: 1,
					},
				},
			},
		},
	},
	dddjungui: {
		audio: 2,
		trigger: { player: "phaseJieshuBegin" },
		direct: true,
		*content(event, map) {
			const player = map.player;
			let result = yield player.chooseTarget(get.prompt2("dddjungui"));
			if (!result.bool) return event.finish();
			const target = result.targets[0];
			player.logSkill("dddjungui", target);
			target.draw(2);
			yield target.showHandcards();
			const targetSuitsCount = target
				.getCards("h")
				.map(card => {
					return get.suit(card);
				})
				.toUniqued().length;
			const usedCount = player
				.getHistory("useCard")
				.map(evt => {
					return get.suit(evt.card);
				})
				.toUniqued().length;
			let decreasedCount = 0;
			if (usedCount > 0) {
				const numbers = Array.from({ length: usedCount }, (_, i) => get.cnNumber(i + 1, true));
				result = yield player
					.chooseControl(numbers, "cancel2")
					.set("prompt", `是否令${get.translation(target)}少弃置任意张牌？`)
					.set("ai", () => {
						return get.event("choice");
					})
					.set("choice", get.attitude(player, target) > 0 ? numbers.lastItem : "cancel2");
				if (result.control != "cancel") {
					decreasedCount = result.index + 1;
					game.log(player, "选择令", target, "少弃置", get.cnNumber(decreasedCount), "张牌");
				}
			}
			const toDiscardNum = targetSuitsCount - decreasedCount;
			if (toDiscardNum <= 0) return event.finish();
			target
				.chooseToDiscard(`隽轨：请弃置${get.cnNumber(toDiscardNum)}张花色不同的手牌`, toDiscardNum, true, (card, player) => {
					const suit = get.suit(card);
					for (const cardx of ui.selected.cards) {
						if (get.suit(cardx) == suit) return false;
					}
					return true;
				})
				.set("complexCard", true);
		},
	},
	//刘宠
	dddjinggou: {
		audio: 2,
		trigger: { player: "useCardAfter" },
		forced: true,
		filter(event, player) {
			if (get.type(event.card) != "equip") return false;
			if (get.subtype(event.card) != "equip1") return false;
			const range = player.getAttackRange();
			return !game.hasPlayer(current => {
				return current.getAttackRange() > range;
			});
		},
		direct: true,
		*content(event, map) {
			const player = map.player;
			let result = yield player.chooseTarget("精彀：对一名其他角色造成1点伤害", true, lib.filter.notMe).set("ai", target => {
				var player = get.player();
				return get.damageEffect(target, player, player);
			});
			if (result.bool) {
				const target = result.targets[0];
				player.logSkill("dddjinggou", target);
				target.damage();
			}
		},
	},
	dddmoyan: {
		audio: 2,
		trigger: { global: "roundStart" },
		*content(event, map) {
			const player = map.player;
			const cards = game.cardsGotoOrdering(get.cards(3)).cards;
			yield player.showCards(cards, `${get.translation(player)}发动了【末焱】`);
			let result = yield player.chooseTarget("末焱：选择一名角色获得其中至少一张牌").set("ai", target => get.attitude(get.player(), target));
			if (!result.bool) return event.finish();
			const target = result.targets[0];
			result = yield target.chooseButton(["末焱：获得至少一张牌", cards], true, [1, cards.length]).set("ai", button => {
				return get.value(button.link);
			});
			if (!result.bool) return event.finish();
			const gains = result.links;
			target.gain(gains, "gain2");
			player.setStorage("dddmoyan_target", [target, gains.length]);
			player.addTempSkill("dddmoyan_target", "roundStart");
		},
		subSkill: {
			target: {
				onremove: true,
				trigger: { player: "damageBegin3" },
				filter(event, player) {
					const info = player.getStorage("dddmoyan_target");
					return info[0] && info[0].isIn() && info[0].countCards("h") <= info[1];
				},
				forced: true,
				charlotte: true,
				content() {
					trigger.increase("num");
				},
			},
		},
	},
	//罗宪
	dddshilie: {
		audio: 2,
		enable: "chooseToUse",
		hiddenCard(player, name) {
			if (!player.countCards("h")) return false;
			return name == "sha" || name == "shan";
		},
		filter(event, player) {
			if (event.type == "wuxie" || !_status.currentPhase) return false;
			if (!player.countCards("h") || player.hasSkill("dddshilie_used", null, null, false)) return false;
			for (var name of ["sha", "shan"]) {
				if (event.filterCard({ name: name, isCard: true }, player, event)) return true;
			}
			return false;
		},
		chooseButton: {
			dialog(event, player) {
				var vcards = [];
				for (var name of ["sha", "shan"]) {
					var card = { name: name, isCard: true };
					if (event.filterCard(card, player, event)) vcards.push(["基本", "", name]);
				}
				const dialog = ui.create.dialog("示烈", [vcards, "vcard"], "hidden");
				dialog.direct = true;
				return dialog;
			},
			check(button) {
				return 1;
			},
			backup(links, player) {
				return {
					filterCard(card) {
						return !get.is.shownCard(card);
					},
					filterOk: () => {
						return (
							ui.selected.cards
								.map(card => {
									return get.number(card);
								})
								.reduce((p, c) => {
									return p + c;
								}, 0) >=
							get.player().getHp() + (_status.currentPhase ? _status.currentPhase.getHp() : 0)
						);
					},
					selectCard: [1, Infinity],
					viewAs: {
						name: links[0][2],
						isCard: true,
					},
					popname: true,
					ignoreMod: true,
					ai1(card) {
						const need = get.player().getHp() + (_status.currentPhase ? _status.currentPhase.getHp() : 0);
						let num = 0;
						for (var i = 0; i < ui.selected.cards.length; i++) {
							num += get.number(ui.selected.cards[i]);
						}
						if (num + get.number(card) == need) return 20 - get.value(card);
						if (ui.selected.cards.length == 0) {
							var cards = _status.event.player.getCards("h");
							for (var i = 0; i < cards.length; i++) {
								for (var j = i + 1; j < cards.length; j++) {
									if (cards[i].number + cards[j].number >= need) {
										if (cards[i] == card || cards[j] == card) return 15 - get.value(card);
									}
								}
							}
						}
						return 0.1;
					},
					precontent() {
						"step 0";
						player.logSkill("dddshilie");
						player.addTempSkill("dddshilie_used");
						var cards = event.result.cards.slice();
						player.addShownCards(cards, "visible_dddshilie");
						delete event.result.skill;
						player.showCards(cards, get.translation(player) + "发动了【示烈】");
						if (
							cards
								.map(card => {
									return get.number(card);
								})
								.reduce((p, c) => {
									return p + c;
								}, 0) ==
							player.getHp() + (_status.currentPhase ? _status.currentPhase.getHp() : 0)
						) {
							player.draw(cards.length);
						}
						event.result.card = new lib.element.VCard({
							name: event.result.card.name,
							isCard: true,
						});
						event.result.cards = [];
						game.delayx();
					},
				};
			},
			prompt(links, player) {
				return `###示烈###明置任意张点数之和不小于${player.getHp() + (_status.currentPhase ? _status.currentPhase.getHp() : 0)}的牌，视为使用【${get.translation(links[0][2])}】`;
			},
		},
		subSkill: { used: { charlotte: true } },
		ai: {
			order(item, player) {
				const evt = get.event();
				for (var name of ["sha", "shan"]) {
					if (evt.filterCard({ name: name }, player, evt)) return get.order({ name: name }) + 0.1;
				}
				return 1;
			},
			respondSha: true,
			respondShan: true,
			skillTagFilter(player, tag, arg) {
				if (!player.countCards("h")) return false;
			},
			result: {
				player(player) {
					return 1;
				},
			},
		},
	},
	//李娥
	dddyeshen: {
		trigger: { global: "phaseJieshuBegin" },
		logTarget: "player",
		prompt2(event, player) {
			var num = player.countMark("dddyeshen");
			var str = "亮出牌堆底的" + get.cnNumber(3 - num) + "张牌，然后其将其中的一张牌当作【铁索连环】使用或打出。";
			if (num >= 2) str += "然后你受到1点火属性伤害并重置此技能。";
			return str;
		},
		check(event, player) {
			if (player.countMark("dddyeshen") >= 2 && get.damageEffect(player, player, player, "fire") < 0) return false;
			return get.attitude(player, event.player) > 0;
		},
		content() {
			"step 0";
			event.target = trigger.player;
			var cards = get.bottomCards(3 - player.countMark("dddyeshen"));
			event.cards = cards;
			game.cardsGotoOrdering(cards);
			player.showCards(cards, get.translation(player) + "对" + get.translation(target) + "发动了【冶身】");
			if (!cards.some(card => get.color(card) == "black")) event.goto(4);
			"step 1";
			if (target.isIn()) {
				var blacks = cards.filter(card => get.color(card) == "black");
				if (blacks.length > 1) target.chooseButton(["选择一张牌当作【铁索连环】使用或重铸", blacks], true).set("ai", button => get.translation(button.link.name).length);
				else
					event._result = {
						bool: true,
						links: blacks,
					};
			} else event.goto(4);
			"step 2";
			if (result.bool) {
				event.links = result.links.slice(0);
				var card = get.autoViewAs({ name: "tiesuo" }, result.links);
				var maxNum = get.translation(result.links[0].name).length;
				if (!game.hasPlayer(current => target.canUse(card, current))) {
					event._result = { bool: false };
				} else
					target
						.chooseTarget(
							"请选择【铁索连环】的目标，或点“取消”重铸",
							function (card, player, target) {
								var card = _status.event.card;
								return player.canUse(card, target);
							},
							[1, Math.min(maxNum, game.countPlayer())]
						)
						.set("card", card)
						.set("ai", function (target) {
							var player = _status.event.player,
								card = _status.event.card;
							return get.effect_use(target, card, player, player);
						});
			}
			"step 3";
			if (result.bool && result.targets.length > 0) {
				var card = get.autoViewAs({ name: "tiesuo" }, event.links);
				target.useCard(result.targets, card, event.links);
			} else {
				target.recast(event.links, (player, cards) => game.cardsDiscard(cards));
			}
			"step 4";
			for (var card of cards) {
				if (get.position(card, true) == "o") ui.cardPile.insertBefore(card, ui.cardPile.firstChild);
			}
			"step 5";
			var num = player.countMark("dddyeshen");
			if (num < 2) {
				player.addMark("dddyeshen", 1, false);
				game.log(player, "的", "#g【冶身】", "的亮出牌数-1");
			} else {
				player.removeMark("dddyeshen", num, false);
				game.log(player, "还原了", "#g【冶身】", "的亮出牌数");
				player.damage("fire", "nocard");
			}
		},
	},
	dddqiaoduan: {
		trigger: { global: "linkAfter" },
		direct: true,
		usable: 1,
		filter(event, player) {
			var num = game.countPlayer(current => current.isLinked());
			if (event.player.isLinked()) {
				return player.countCards("he") >= num && game.hasPlayer(current => current.isDamaged());
			} else {
				return num > 0;
			}
		},
		content() {
			"step 0";
			if (trigger.player.isLinked()) {
				var num = game.countPlayer(current => current.isLinked());
				player.chooseCardTarget({
					prompt: get.prompt("dddqiaoduan"),
					prompt2: "操作提示：选择" + get.cnNumber(num) + "张牌和一名已受伤的角色。将这些牌置于牌堆底（先选择的在上），然后该角色回复1点体力。",
					filterCard: true,
					selectCard: num,
					filterTarget: (card, player, target) => target.isDamaged(),
					ai1: card => 5 - get.value(card),
					ai2: target => {
						var player = _status.event.player;
						return get.recoverEffect(target, player, player);
					},
				});
			} else event.goto(2);
			"step 1";
			if (result.bool) {
				player.logSkill("dddqiaoduan", result.targets[0]);
				player.loseToDiscardpile(result.cards, ui.cardPile);
				result.targets[0].recover();
			} else player.storage.counttrigger.dddqiaoduan--;
			event.finish();
			"step 2";
			var num = game.countPlayer(current => current.isLinked());
			player.chooseTarget(get.prompt("dddqiaoduan"), [1, num], "令至多" + get.cnNumber(num) + "名角色各摸一张牌").set("ai", function (target) {
				var player = _status.event.player;
				var att = get.attitude(player, target) / Math.sqrt(1 + target.countCards("h"));
				if (target.hasSkillTag("nogain")) att /= 10;
				return att;
			});
			"step 3";
			if (result.bool) {
				var targets = result.targets.sortBySeat();
				player.logSkill("dddqiaoduan", targets);
				game.asyncDraw(targets);
				game.delayex();
			} else player.storage.counttrigger.dddqiaoduan--;
		},
	},
	//孙亮
	ddddiedang: {
		enable: "phaseUse",
		usable: 1,
		filter(event, player) {
			if (player.storage.ddddiedang) return player.countCards("he") >= 3;
			return true;
		},
		filterCard: true,
		position: "he",
		selectCard() {
			var player = _status.event.player;
			return player.storage.ddddiedang ? 3 : 0;
		},
		prompt() {
			var player = _status.event.player;
			if (player.storage.ddddiedang) return "弃置三张牌，然后摸一张牌";
			return "摸三张牌，然后弃置一张牌";
		},
		check: card => 5 - get.value(card),
		content() {
			"step 0";
			if (player.storage.ddddiedang) {
				player.draw();
			} else {
				player.draw(3);
				player.chooseToDiscard(true, "he");
			}
			"step 1";
			if (player.isMaxHandcard() || player.isMinHandcard()) player.storage.ddddiedang = !player.storage.ddddiedang;
		},
		ai: {
			order: 1,
			result: {
				player(player) {
					if (ui.selected.cards.length) {
						var num = 1 + player.countCards("h", card => !ui.selected.cards.includes(card));
						if (
							!game.hasPlayer(current => {
								return current != player && current.countCards("h") > num;
							}) ||
							!game.hasPlayer(current => {
								return current != player && current.countCards("h") < num;
							})
						)
							return 1;
						return -1;
					}
					return 1;
				},
			},
		},
	},
	dddanliu: {
		trigger: { player: "phaseJieshuBegin" },
		direct: true,
		filter(event, player) {
			return (
				player.countCards("h") > 0 &&
				game.hasPlayer(function (current) {
					return current != player && current.countCards("h") > 0;
				})
			);
		},
		content() {
			"step 0";
			player
				.chooseTarget(get.prompt2("dddanliu"), function (card, player, target) {
					return target != player && target.countCards("h") > 0;
				})
				.set("ai", function (target) {
					return get.attitude(get.player(), target) * Math.sqrt(1 + target.countCards("h"));
				});
			"step 1";
			if (result.bool) {
				var target = result.targets[0];
				player.logSkill("dddanliu", target);
				event.target = target;
			} else event.finish();
			"step 2";
			player
				.choosePlayerCard(target, true, "h", "visible", [0, 1])
				.set("filterOk", () => ui.selected.buttons.length > 0)
				.set("ai", button => {
					var player = get.player(),
						target = _status.event.target;
					var color = get.color(button.link);
					if (
						player.hasCard(function (card) {
							return get.color(card) == color;
						}, "h")
					) {
						if (color == "red") return get.recoverEffect(player, player, player) + 2 / Math.max(2, get.value(button.link));
						if (color == "black") return 2 * get.effect(target, { name: "draw" }, target, player) + 2 / Math.max(2, get.value(button.link));
					}
					return get.value(button.link) / 3;
				});
			"step 3";
			if (result.bool) {
				event.card1 = result.cards[0];
				target
					.choosePlayerCard(player, true, "h", "visible", [0, 1], get.translation(player) + "选择了你的" + get.translation(event.card1) + "。请选择其的一张牌")
					.set("ai", function (button) {
						var evt = _status.event.getParent();
						var player = evt.target,
							card = evt.card1,
							source = evt.player;
						var color = get.color(card);
						if (get.attitude(player, target) > 0) {
							if (get.color(button.link) == color) return 20 - get.value(card);
							return -get.value(card);
						} else {
							if (get.color(button.link) == "black") return 20 + get.value(card);
							return get.value(card);
						}
					})
					.set("filterOk", () => ui.selected.buttons.length > 0);
			}
			"step 4";
			if (result.bool) {
				event.card2 = result.cards[0];
				var color = get.color(event.card1);
				if (color != "none" && get.color(event.card2) == color) {
					event.color = color;
					var next = player.chooseBool("是否与" + get.translation(target) + "交换展示牌");
					var prompt2 = "用" + get.translation(event.card1) + "交换对方的" + get.translation(event.card2);
					if (color == "black") {
						prompt2 += "，然后对方摸两张牌";
						next.set("goon", 2 * get.effect(target, { name: "draw" }, target, player) > 0);
					} else if (color == "red" && player.isDamaged()) {
						prompt2 += "，然后你回复1点体力";
						next.set("goon", get.recoverEffect(player, player, player) > 0);
					}
					next.set("prompt2", prompt2);
					next.set("ai", () => Boolean(_status.event.goon));
				} else event.finish();
			}
			"step 5";
			if (result.bool) {
				player.swapHandcards(target, [event.card2], [event.card1]);
				if (event.color == "black") {
					target.draw(2);
				} else if (event.color == "red") {
					player.recover();
				}
			}
		},
	},
	dddguiying: {
		zhuSkill: true,
		trigger: { player: "phaseZhunbeiBegin" },
		direct: true,
		filter(event, player) {
			return (
				player.hasZhuSkill("dddguiying") &&
				game.hasPlayer(function (current) {
					return current != player && current.group == "wu" && player.hasZhuSkill("dddguiying", current) && current.countCards("h") > 0;
				})
			);
		},
		gainEffect(player) {
			var gainers = game.filterPlayer(current => current.countCards("ej"));
			if (!gainers.length) return 0;
			var min = Math.min.apply(
				Math,
				gainers.map(current => {
					return Math.min.apply(
						Math,
						current.getCards("ej").map(function (card) {
							return get.number(card, current);
						})
					);
				})
			);
			return Math.max.apply(
				Math,
				game
					.filterPlayer(function (target) {
						return target.hasCard(function (card) {
							return get.number(card, target) == min && lib.filter.canBeGained(card, player, target);
						}, "ej");
					})
					.map(function (target) {
						var cards = target.getCards("ej", function (card) {
								return get.number(card, target) == min && lib.filter.canBeGained(card, player, target);
							}),
							att = get.attitude(player, target);
						return Math.max.apply(
							Math,
							cards.map(card => {
								if (target.getCards("j").includes(card)) {
									var efff = get.effect(
										target,
										{
											name: card.viewAs || card.name,
											cards: [card],
										},
										player,
										player
									);
									if (efff > 0) return -0.5 * att;
									if (efff == 0) return 0;
									return 1.5 * att;
								}
								if (target.getCards("e").includes(card)) {
									var evalue = get.value(card, target);
									if (target.hasSkillTag("noe")) {
										if (evalue >= 7) {
											return (-evalue / 6) * att;
										}
										return (-evalue / 10) * att;
									}
									return (-evalue / 3) * att;
								}
							})
						);
					})
			);
		},
		content() {
			"step 0";
			event.targets = game
				.filterPlayer(function (current) {
					return current != player && current.group == "wu" && player.hasZhuSkill("dddguiying", current);
				})
				.sortBySeat();
			if (!event.targets.length) event.finish();
			"step 1";
			var target = event.targets.shift();
			event.target = target;
			if (target.isIn() && target.group == "wu" && target.countCards("h") > 0) {
				target
					.chooseBool("归萤：是否响应" + get.translation(player) + "的主公技？", "你可以展示所有手牌，将点数最大的牌交给该角色；然后你可以获得场上点数最小的一张牌")
					.set("ai", function () {
						var player = get.player(),
							source = _status.event.getParent().player;
						if (_status.event.gainEffect <= 0) return 0;
						return get.attitude(player, source) > 0;
					})
					.set("gainEffect", lib.skill.dddguiying.gainEffect(target));
			} else event.goto(7);
			"step 2";
			if (result.bool) {
				target.logSkill("dddguiying", player);
				target.showHandcards(get.translation(target) + "响应了〖归萤〗");
			} else event.goto(7);
			"step 3";
			if (target.isIn()) {
				var cards = target.getCards("he");
				if (!cards.length) event.goto(7);
				var max = Math.max.apply(
					Math,
					cards.map(card => get.number(card, target))
				);
				var gives = cards.filter(card => get.number(card, target) == max);
				if (gives.length <= 1) event._result = { bool: true, cards: gives };
				else
					target
						.chooseCard("he", true, "选择给出一张点数最大的牌", function (card) {
							return _status.event.cards.includes(card);
						})
						.set("cards", gives);
			} else event.goto(7);
			"step 4";
			if (result.bool) {
				target.give(result.cards, player, "visible");
			} else event.goto(7);
			"step 5";
			var gainers = game.filterPlayer(current => current.countCards("ej"));
			if (target.isIn() && gainers.length > 0) {
				var min = Math.min.apply(
					Math,
					gainers.map(current => {
						return Math.min.apply(
							Math,
							current.getCards("ej").map(function (card) {
								return get.number(card, current);
							})
						);
					})
				);
				target
					.chooseTarget("是否获得场上点数最小的一张牌？", function (card, player, target) {
						var num = _status.event.minNum;
						return target.hasCard(function (card) {
							return get.number(card, target) == num && lib.filter.canBeGained(card, player, target);
						}, "ej");
					})
					.set("minNum", min)
					.set("ai", function (target) {
						var player = get.player(),
							min = _status.event.minNum;
						var cards = target.getCards("ej", function (card) {
								return get.number(card, target) == min && lib.filter.canBeGained(card, player, target);
							}),
							att = get.attitude(player, target);
						return Math.max.apply(
							Math,
							cards.map(card => {
								if (target.getCards("j").includes(card)) {
									var efff = get.effect(
										target,
										{
											name: card.viewAs || card.name,
											cards: [card],
										},
										player,
										player
									);
									if (efff > 0) return -0.5 * att;
									if (efff == 0) return 0;
									return 1.5 * att;
								}
								if (target.getCards("e").includes(card)) {
									var evalue = get.value(card, target);
									if (target.hasSkillTag("noe")) {
										if (evalue >= 7) {
											return (-evalue / 6) * att;
										}
										return (-evalue / 10) * att;
									}
									return (-evalue / 3) * att;
								}
							})
						);
					});
			} else event.goto(7);
			"step 6";
			if (result.bool) {
				var target2 = result.targets[0];
				target.line(target2, "green");
				var min = Math.min.apply(
						Math,
						target2.getCards("ej").map(function (card) {
							return get.number(card, target2);
						})
					),
					cards = target2.getCards("ej", card => get.number(card, target2) == min);
				if (cards.length <= 1) target.gain(cards, target2, "give", "bySelf");
				else
					target
						.gainPlayerCard(target2, "ej", true)
						.set("filterButton", function (button) {
							return _status.event.cards.includes(button.link);
						})
						.set("cards", cards);
			}
			"step 7";
			if (targets.length > 0) event.goto(1);
		},
	},
	//王伉吕凯
	dddbingjian: {
		enable: ["chooseToUse", "chooseToRespond"],
		filter(event, player) {
			if (event.type == "wuxie") return false;
			if (player.countMark("dddbingjian_used") >= 2) return false;
			if (player.countCards("h") == 2) return false;
			return (
				event.filterCard(
					{
						name: "sha",
						isCard: true,
					},
					player,
					event
				) ||
				event.filterCard(
					{
						name: "shan",
						isCard: true,
					},
					player,
					event
				)
			);
		},
		chooseButton: {
			dialog(event, player) {
				return ui.create.dialog(
					"并肩",
					// [[
					// 	[2,'调整至2张'],
					// 	[4,'调整至4张']
					// ],'tdnodes'],
					[["sha", "shan"], "vcard"],
					"hidden"
				);
			},
			// select:2,
			filter(button, player) {
				if (ui.selected.buttons.length) {
					if (typeof button.link == typeof ui.selected.buttons[0].link) return false;
				}
				// if(typeof button.link=='number'){
				// 	return button.link!=player.countCards('h');
				// }
				return _status.event.getParent().filterCard({
					name: button.link[2],
					isCard: true,
				});
			},
			check(button) {
				// if(typeof button.link=='number') return button.link;
				return 1;
			},
			backup(links, player) {
				// if(typeof links[0]=='number') links.reverse();
				var skill = {
					viewAs: {
						name: links[0][2],
						suit: "none",
						number: null,
						isCard: true,
					},
				};
				var num = 2 - player.countCards("h");
				if (num > 0) {
					skill.draw = num;
					skill.filterCard = function () {
						return false;
					};
					skill.selectCard = -1;
					skill.precontent = lib.skill.dddbingjian.content_draw;
				} else {
					skill.selectCard = -num;
					skill.ignoreMod = true;
					skill.filterCard = lib.filter.cardDiscardable;
					skill.precontent = lib.skill.dddbingjian.content_discard;
					skill.check = function (card) {
						return 5 - get.value(card);
					};
				}
				return skill;
			},
			prompt(links, player) {
				// if(typeof links[0]=='number') links.reverse();
				var num = 2 - player.countCards("h");
				if (num > 0) {
					return "摸" + get.cnNumber(num) + "张牌并视为使用" + get.translation(links[0][2]);
				} else {
					return "弃置" + get.cnNumber(-num) + "张牌并视为使用" + get.translation(links[0][2]);
				}
			},
		},
		ai: {
			pretao: true,
			order(item, player) {
				if (player.countCards("h") < 4) return get.order({ name: "sha" }, player) + 0.2;
				return 1;
			},
			result: {
				player: 1,
			},
		},
		content_draw() {
			"step 0";
			delete event.result.skill;
			player.logSkill("dddbingjian");
			player.draw(lib.skill.dddbingjian_backup.draw);
			player.addTempSkill("dddbingjian_used");
			player.addMark("dddbingjian_used", 1, false);
			"step 1";
			player.chooseTarget("是否令一名其他角色摸等量的牌？", lib.filter.notMe).set("ai", target => {
				var player = get.player();
				return get.effect(target, { name: "draw" }, player, player);
			});
			"step 2";
			if (result.bool) {
				var target = result.targets[0];
				player.line(target, "green");
				target.draw(lib.skill.dddbingjian_backup.draw);
			}
		},
		content_discard() {
			"step 0";
			delete event.result.skill;
			player.logSkill("dddbingjian");
			player.discard(event.result.cards);
			event.num = event.result.cards.length;
			player.addTempSkill("dddbingjian_used");
			player.addMark("dddbingjian_used", 1, false);
			event.result.card = {
				name: event.result.card.name,
				isCard: true,
			};
			event.result.cards = [];
			"step 1";
			player
				.chooseTarget("是否弃置一名其他角色等量的牌？", lib.filter.notMe)
				.set("ai", target => {
					var player = get.player(),
						num = target.countCards("he") - get.event("num");
					if (num >= 0) num = 1;
					else num = 1 - num / 5;
					var eff = get.effect(target, { name: "guohe_copy2" }, player, player);
					return eff / num;
				})
				.set("num", event.num);
			"step 2";
			if (result.bool) {
				var target = result.targets[0];
				player.line(target, "fire");
				player.discardPlayerCard(target, "he", true, event.num);
			}
		},
		content_draw_old() {
			"step 0";
			delete event.result.skill;
			player.logSkill("dddbingjian");
			player.addTempSkill("dddbingjian_round", "roundStart");
			player.draw(lib.skill.dddbingjian_backup.draw);
			"step 1";
			player.chooseTarget("是否令一名角色本轮内不能使用或打出" + get.translation(event.result.card) + "？").set("ai", function (target) {
				var player = _status.event.player;
				return -get.attitude(player, target) * get.threaten(target, player) * Math.sqrt(1 + target.countCards("h"));
			});
			"step 2";
			if (result.bool) {
				var target = result.targets[0];
				player.line(target, "fire");
				player.chat("你不许使用" + get.translation(event.result.card));
				target.addTempSkill("dddbingjian_blocker", "roundStart");
				target.markAuto("dddbingjian_blocker", [event.result.card.name]);
				game.delayx();
			}
		},
		content_discard_old() {
			"step 0";
			delete event.result.skill;
			player.logSkill("dddbingjian");
			player.discard(event.result.cards);
			event.result.card = {
				name: event.result.card.name,
				isCard: true,
			};
			event.result.cards = [];
			"step 1";
			var hs = player.countCards("h");
			if (!game.hasPlayer(current => current.countCards("h") != hs)) {
				event.finish();
			} else {
				player
					.chooseTarget("是否令一名角色将手牌调整至" + get.cnNumber(player.countCards("h")) + "张？", function (card, player, target) {
						return target.countCards("h") != player.countCards("h");
					})
					.set("ai", function (target) {
						var player = _status.event.player,
							num = target.countCards("h") - player.countCards("h");
						if (num > 0) return get.attitude(player, target) * Math.sqrt(1 + Math.abs(num));
						return -get.attitude(player, target) * Math.sqrt(-num);
					});
			}
			"step 2";
			if (result.bool) {
				var target = result.targets[0];
				player.line(target, "fire");
				var num = target.countCards("h") - player.countCards("h");
				if (num > 0) target.chooseToDiscard("h", true, num);
				else target.draw(Math.min(5, -num));
			}
		},
		subSkill: {
			round: { charlotte: true },
			blocker: {
				charlotte: true,
				mod: {
					cardEnabled(card, player) {
						if (player.getStorage("dddbingjian_blocker").includes(card.name)) return false;
					},
					cardRespondable(card, player) {
						if (player.getStorage("dddbingjian_blocker").includes(card.name)) return false;
					},
					cardSavable(card, player) {
						if (player.getStorage("dddbingjian_blocker").includes(card.name)) return false;
					},
				},
				mark: true,
				intro: {
					content: "本轮内不能使用或打出$",
				},
			},
			used: {
				charlotte: true,
				onremove: true,
			},
		},
	},
	//梁习
	dddtongyu: {
		enable: "phaseUse",
		usable: 1,
		filter(event, player) {
			return player.countCards("hs") > 0;
		},
		viewAs: {
			name: "wugu",
		},
		selectCard: [1, 4],
		filterCard(card) {
			var suit = get.suit(card);
			if (suit == "none") return false;
			if (!ui.selected.cards.length) return true;
			for (var card of ui.selected.cards) {
				if (get.suit(card) == suit) return false;
			}
			return true;
		},
		complexCard: true,
		position: "hs",
		prompt: "将任意张花色不同的牌当做【五谷丰登】使用",
		check(card) {
			return 5 - get.value(card);
		},
		precontent() {
			if (!event.result.card.storage) event.result.card.storage = {};
			event.result.card.storage.chooseDirection = true;
			event.result.card.storage.extraCardsNum = event.result.cards.length;
			player.addTempSkill("dddtongyu_effect");
		},
		ai: {
			order: 1,
		},
		subSkill: {
			effect: {
				trigger: { global: "useCardToTargeted" },
				forced: true,
				charlotte: true,
				popup: false,
				filter(event, player) {
					return event.skill == "dddtongyu" && event.isFirstTarget;
				},
				content() {
					"step 0";
					event.targets = trigger.targets.slice().sortBySeat(_status.currentPhase || player);
					"step 1";
					var target = targets.shift();
					event.target = target;
					if (!target.isUnderControl(true) && !target.isOnline()) game.delayx();
					target
						.chooseControl()
						.set("choiceList", ["本回合不能使用或打出手牌", "令" + get.translation(trigger.card) + "对自己无效"])
						.set("ai", function () {
							var player = _status.event.player;
							var source = _status.event.getTrigger().player;
							return player == source ? 1 : 0;
						});
					"step 2";
					if (result.index == 0) {
						target.chat("接受五谷");
						target.addTempSkill("dddtongyu_blocker");
						game.log(target, "本回合不能使用或打出手牌");
					} else {
						target.chat("拒绝五谷");
						trigger.excluded.add(target);
						var evt = trigger.getParent();
						if (!evt.dddtongyu_targets) evt.dddtongyu_targets = [];
						evt.dddtongyu_targets.add(target);
						game.log(target, "令", trigger.card, "对其无效");
					}
					if (targets.length) event.goto(1);
				},
				group: "dddtongyu_give",
			},
			give: {
				trigger: { player: "wuguRemained" },
				direct: true,
				filter(event, player) {
					if (event.skill != "dddtongyu" || event.remained.filterInD().length == 0) return false;
					var list = event.getParent().dddtongyu_targets;
					return list.some(target => target.isIn());
				},
				content() {
					"step 0";
					event.cards = trigger.remained.filterInD();
					player
						.chooseTarget("仝御：令一名角色获得" + get.translation(event.cards), function (card, player, target) {
							return _status.event.targets.includes(target);
						})
						.set("targets", trigger.getParent().dddtongyu_targets)
						.set("ai", function (target) {
							var att = get.attitude(_status.event.player, target);
							if (att < 3) return 0;
							if (target.hasJudge("lebu")) att /= 2;
							if (target.hasSkillTag("nogain")) att /= 10;
							return att / (1 + get.distance(player, target, "absolute"));
						});
					"step 1";
					if (result.bool) {
						var target = result.targets[0];
						player.logSkill("dddtongyu_give", target);
						target.gain(cards, "gain2");
					}
				},
			},
			blocker: {
				mark: true,
				intro: { content: "本回合不能使用或打出手牌" },
				mod: {
					cardEnabled2(card) {
						return false;
					},
				},
			},
		},
	},
	dddzhilian: {
		trigger: { global: "phaseEnd" },
		direct: true,
		filter(event, player) {
			var targets = game.filterPlayer2(function (current) {
				return current.getHistory("useCard").length + current.getHistory("respond").length > 0;
			});
			if (!targets.includes(player) || !targets.some(target => target != player && target.hasSex("male"))) return false;
			return targets.length == 2 && !targets.some(target => !target.isIn());
		},
		content() {
			"step 0";
			var targets = game
				.filterPlayer(function (current) {
					return current.getHistory("useCard").length + current.getHistory("respond").length > 0;
				})
				.sortBySeat(trigger.player);
			event.targets = targets;
			var choices = ["摸牌"];
			var prompt2 = "令";
			for (var i = 0; i < 2; i++) {
				if (targets[i] == player) prompt2 += "你";
				else prompt2 += get.translation(targets[i]);
				if (i == 0) prompt2 += "和";
			}
			prompt2 += "各摸一张牌";
			if (targets.some(target => target.countCards("he") > 0)) {
				prompt2 += "或各弃置一张牌";
				choices.push("弃牌");
			}
			player
				.chooseControl(choices, "cancel2")
				.set("prompt", get.prompt("dddzhilian"))
				.set("prompt2", prompt2)
				.set("ai", function () {
					var player = _status.event.player;
					var targets = _status.event.getParent().targets.slice(0);
					if (targets.includes(player)) {
						targets.remove(player);
						if (get.attitude(player, targets[0]) > 0) return 0;
						if (targets[0].countCards("he") > 0 && !targets[0].hasCard(card => get.value(card, targets[0]) <= 0, "e") && player.countCards("h", "sha") > 0) return 1;
						return "cancel2";
					} else {
						var att1 = get.attitude(player, targets[0]),
							att2 = get.attitude(player, targets[1]);
						if (get.sgn(att1) != get.sgn(att2)) return "cancel2";
						return att1 > 0 ? 0 : 1;
					}
				});
			"step 1";
			if (result.control != "cancel2") {
				player.logSkill("dddzhilian", targets);
				if (result.control == "摸牌") {
					game.asyncDraw(targets);
					game.delayex();
				} else {
					for (var target of targets) target.chooseToDiscard("he", true);
				}
				if (!targets.includes(player)) event.finish();
			} else event.finish();
			"step 2";
			var cards = [];
			game.getGlobalHistory("cardMove", function (evt) {
				if ((evt.name == "lose" && evt.position == ui.discardPile) || evt.name == "cardsDiscard") cards.addArray(evt.cards);
			});
			cards = cards.filter(card => card.name == "sha" && get.position(card, true) == "d");
			if (cards.length > 0) player.gain(cards, "gain2");
		},
	},
	dddjijian: {
		enable: "phaseUse",
		usable: 1,
		filterCard: { name: "sha" },
		position: "h",
		discard: false,
		delay: false,
		lose: false,
		filter: (event, player) => game.hasPlayer(current => lib.skill.dddjijian.filterTarget(null, player, current)),
		filterTarget: (card, player, target) => target != player && target.hasSex("male"),
		content() {
			"step 0";
			player.showCards(cards);
			player.give(cards, target);
			"step 1";
			var cards = target.getCards("h");
			if (!cards.length) event.finish();
			else if (cards.length == 1) event._result = { bool: true, cards: cards };
			else
				target
					.chooseCard("h", true, [1, 2], "请展示一至两张颜色相同的【杀】或普通锦囊牌", (card, player) => {
						var color = get.color(card);
						for (var cardx of ui.selected.cards) {
							if (get.color(cardx) != color) return false;
						}
						return get.name(card) == "sha" || get.type(card) == "trick";
					})
					.set("complexCard", true)
					.set("ai", function (card) {
						var player = _status.event.player,
							source = _status.event.getParent().player;
						if (get.attitude(source, player) <= 0) return -get.value(card);
						var name = get.name(card),
							color = get.color(card);
						if (
							name == "sha" ||
							player.getUseValue(card) <= 0 ||
							player.hasCard(card2 => {
								return card2 != card && !ui.selected.cards.includes(card2) && get.name(card2) == name;
							})
						) {
							if (!ui.selected.cards.length && color == "black") return 1 + Math.random();
							return Math.random();
						}
						if (!ui.selected.cards.length || get.color(ui.selected.cards[0] == "red")) {
							if (color == "black") return 0.2 - player.getUseValue(card) / 100 + Math.random();
						}
						return 0.1 - player.getUseValue(card) / 100;
					});
			"step 2";
			if (result.bool) {
				var cards = result.cards;
				event.cards = cards;
				target.showCards(cards, get.translation(player) + "对" + get.translation(target) + "发动了【赍剑】");
				event.usedName = [];
				event.targets = [player, target].sortBySeat(_status.currentPhase || player);
			} else event.finish();
			"step 3";
			var current = event.targets.shift();
			if (!current.isIn()) {
				event.goto(5);
				return;
			}
			event.current = current;
			var list = event.cards
				.filter(card => {
					return (
						!event.usedName.includes(get.name(card)) &&
						current.hasUseTarget({
							name: get.name(card),
							nature: get.nature(card),
						})
					);
				})
				.map(card => {
					return [get.type(card), "", get.name(card), get.nature(card)];
				});
			if (!list.length) event.finish();
			else
				current.chooseButton(["赍剑：视为使用一张牌", [list, "vcard"]], true).set("ai", function (button) {
					return get.player().getUseValue({
						name: button.link[2],
						nature: button.link[3],
					});
				});
			"step 4";
			if (result.bool) {
				var name = result.links[0][2];
				event.usedName.add(name);
				event.current.chooseUseTarget(
					{
						name: name,
						nature: result.links[0][3],
						isCard: true,
					},
					true,
					false
				);
			}
			"step 5";
			if (event.targets.length) event.goto(3);
		},
		ai: {
			order: 4,
			result: {
				player(player, target) {
					if (get.attitude(player, target) > 0 && player.hasCard(card => get.name(card) == "sha", "h")) return target.countCards("h");
					return 0.1 / target.countCards("h");
				},
			},
		},
	},
	dddjijian_old: {
		enable: "phaseUse",
		usable: 1,
		filter: (event, player) => game.hasPlayer(current => lib.skill.dddjijian_old.filterTarget(null, player, current)),
		filterTarget: (card, player, target) => target != player && target.hasSex("male") && target.countCards("h") > 0,
		content() {
			"step 0";
			target.chooseCard("h", true, [1, 2], "请展示一至两张手牌").set("ai", function (card) {
				var player = _status.event.player,
					source = _status.event.getParent().player;
				if (get.attitude(source, player) <= 0) return -get.value(card);
				var name = get.name(card),
					color = get.color(card);
				if (
					name == "sha" ||
					player.getUseValue(card) <= 0 ||
					player.hasCard(card2 => {
						return card2 != card && !ui.selected.cards.includes(card2) && get.name(card2) == name;
					})
				) {
					if (!ui.selected.cards.length && color == "black") return 1 + Math.random();
					return Math.random();
				}
				if (!ui.selected.cards.length || get.color(ui.selected.cards[0] == "red")) {
					if (color == "black") return 0.2 - player.getUseValue(card) / 100 + Math.random();
				}
				return 0.1 - player.getUseValue(card) / 100;
			});
			"step 1";
			if (result.bool) {
				var cards = result.cards;
				event.cards = cards;
				target.showCards(cards, get.translation(player) + "对" + get.translation(target) + "发动了【赍剑】");
				if (
					!player.hasCard(card => {
						if (_status.connectMode) return true;
						return get.name(card, player) == "sha";
					}, "h")
				)
					event.finish();
			} else event.finish();
			"step 2";
			var colors = [];
			for (var card of cards) colors.add(get.color(card, target));
			colors.sort();
			var str = "若你给出的【杀】为";
			for (var i = 0; i < colors.length; i++) {
				str += get.translation(colors[i]);
				if (i < colors.length - 1) str += "或";
			}
			str += "，则其获得后续增益效果";
			player
				.chooseCard("h", (card, player) => get.name(card, player) == "sha", "是否交给" + get.translation(target) + "一张【杀】？", str)
				.set("colors", colors)
				.set("ai", function (card) {
					var player = _status.event.player,
						target = _status.event.getParent().target;
					if (get.attitude(player, target) < 0) return false;
					if (!_status.event.colors.includes(get.color(card, player))) return 0;
					if (game.hasNature(card)) return 1.2;
					return 1;
				});
			"step 3";
			if (result.bool) {
				player.give(result.cards, target, "giveAuto");
				var num = 0,
					color = get.color(result.cards[0], player);
				for (var card of cards) {
					if (get.color(card, target) == color) num++;
				}
				if (!num) event.finish();
				else event.num = num;
			} else event.finish();
			"step 4";
			var cards = target.getCards("h");
			cards.removeArray(event.cards);
			var names = [];
			for (var card of cards) {
				var name = get.name(card, target),
					type = get.type(card);
				if (type != "basic" && type != "trick") continue;
				if (name == "sha") {
					var natures = get.natureList(card, target);
					for (var nature of natures) {
						if (nature && lib.nature.has(nature)) name += "|" + nature;
					}
				}
				names.push(name);
			}
			if (!names.length) event.finish();
			else event.names = names;
			"step 5";
			event.num--;
			target
				.chooseButton([
					"是否视为使用一张牌？",
					[
						event.names.map(name => {
							if (name.indexOf("sha|") == 0) {
								return ["基本", "", "sha", name.slice(4).split("|")];
							}
							return [get.type(name), "", name];
						}),
						"vcard",
					],
				])
				.set("filterButton", function (button) {
					var card = {
							name: button.link[2],
							nature: button.link[3],
							isCard: true,
						},
						player = _status.event.player;
					return player.hasUseTarget(card);
				})
				.set("ai", function (button) {
					var card = {
							name: button.link[2],
							nature: button.link[3],
							isCard: true,
						},
						player = _status.event.player;
					return player.getUseValue(card);
				});
			"step 6";
			if (result.bool) {
				var card = {
					name: result.links[0][2],
					nature: result.links[0][3],
					isCard: true,
				};
				target.chooseUseTarget(card, true, false);
				if (event.num > 0) {
					var name = card.name;
					if (name == "sha") {
						var natures = get.natureList(card, target);
						for (var nature of natures) {
							if (nature && lib.nature.has(nature)) name += "|" + nature;
						}
					}
					event.names.remove(name);
					if (event.names.length > 0) event.goto(5);
				}
			} else event.finish();
		},
		ai: {
			order: 4,
			result: {
				player(player, target) {
					if (get.attitude(player, target) > 0 && player.hasCard(card => get.name(card) == "sha", "h")) return target.countCards("h");
					return 0.1 / target.countCards("h");
				},
			},
		},
	},
	dddzhengjun: {
		trigger: {
			global: ["damageEnd", "loseHpEnd", "recoverEnd", "loseAfter", "equipAfter", "addJudgeAfter", "gainAfter", "loseAsyncAfter", "addToExpansionAfter"],
		},
		filter(event, player) {
			if (!player.isPhaseUsing()) return false;
			if (event.name == "damage" || event.name == "loseHp" || event.name == "recover") {
				if (player.hasSkill("dddzhengjun_hp")) return false;
				return event.player.getHp() == player.getHp();
			}
			const info = get.info("dddzhengjun");
			const hs_check = info.hs_check,
				es_check = info.es_check;
			return game.hasPlayer(target => {
				if (event.getg && event.getg(target) && event.getg(target).length && hs_check(player, target)) return true;
				const evt = event.getl(target);
				if (evt && evt.hs && evt.hs.length && hs_check(player, target)) return true;
				if (event.name == "equip" && event.player == target && (!evt || evt.cards.length != 1) && es_check(player, target)) return true;
				return evt && evt.es && evt.es.length && es_check(player, target);
			});
		},
		hs_check(player, target) {
			return !player.hasSkill("dddzhengjun_hs") && target.countCards("h") == player.countCards("h");
		},
		es_check(player, target) {
			return !player.hasSkill("dddzhengjun_es") && target.countCards("e") == player.countCards("e");
		},
		async cost(event, trigger, player) {
			if (trigger.name == "damage" || trigger.name == "loseHp" || trigger.name == "recover") {
				let list = ["失去体力", "cancel2"];
				if (trigger.player.isDamaged()) list.unshift("回复体力");
				const {
					result: { control },
				} = await player
					.chooseControl(list)
					.set("prompt", get.prompt("dddzhengjun", trigger.player))
					.set("prompt2", "令" + get.translation(event.player) + "执行其中一项")
					.set("ai", () => {
						const player = get.event("player"),
							target = get.event().getTrigger().player;
						if (get.event("controls").includes("回复体力") && get.recoverEffect(target, player, player) > 0) return "回复体力";
						return get.effect(target, { name: "losehp" }, player, player) > 0 ? "失去体力" : "cancel2";
					});
				event.result = {
					bool: control != "cancel2",
					targets: [trigger.player],
					cost_data: control,
				};
			} else {
				let map = {};
				const hs_targets = game.filterPlayer(target => {
					if (!get.info("dddzhengjun").hs_check(player, target)) return false;
					if (trigger.getg && trigger.getg(target) && trigger.getg(target).length) return true;
					const evt = trigger.getl(target);
					return evt && evt.hs && evt.hs.length;
				});
				const es_targets = game.filterPlayer(target => {
					if (!get.info("dddzhengjun").es_check(player, target)) return false;
					const evt = trigger.getl(target);
					if (trigger.name == "equip" && trigger.player == target && (!evt || evt.cards.length != 1)) return true;
					return evt && evt.es && evt.es.length;
				});
				if (hs_targets.length) {
					let target;
					if (hs_targets.length == 1) target = hs_targets[0];
					else {
						let targets = await player
							.chooseTarget(get.prompt("dddzhengjun"), "令其中一名角色摸一张牌或弃置一张牌", (card, player, target) => {
								return get.event("targets").includes(target);
							})
							.set("ai", target => {
								const player = get.event("player");
								return Math.max(get.effect(target, { name: "guohe_copy2" }, target, player), get.effect(target, { name: "draw" }, player, player));
							})
							.set("targets", hs_targets)
							.forResultTargets();
						if (targets && targets.length) target = targets[0];
					}
					if (target) {
						let list = ["摸牌"];
						if (target.countCards("h")) list.push("弃牌");
						const {
							result: { control },
						} = await player
							.chooseControl(list, "cancel2")
							.set("prompt", get.prompt("dddzhengjun", target))
							.set("prompt2", "令" + get.translation(target) + "执行其中一项")
							.set("ai", () => {
								const player = get.event("player"),
									target = get.event().getTrigger().player;
								if (get.event("controls").includes("弃牌") && get.effect(target, { name: "guohe_copy2" }, player, player) > 0) return "弃牌";
								return get.effect(target, { name: "draw" }, player, player) > 0 ? "摸牌" : "cancel2";
							});
						if (control != "cancel2") {
							map.hs_target = [target, control];
						}
					}
				}
				if (es_targets.length) {
					let target;
					if (hs_targets.length == 1) {
						const {
							result: { bool },
						} = await player
							.chooseBool()
							.set("prompt", get.prompt("dddzhengjun", hs_targets[0]))
							.set("prompt2", "移动" + get.translation(hs_targets[0]) + "的一张装备牌")
							.set("choice", () => player.canMoveCard(true, true, hs_targets[0]));
						if (bool) target = hs_targets[0];
					} else {
						let targets = await player
							.chooseTarget(get.prompt("dddzhengjun"), "移动其中一名角色的一张装备牌", (card, player, target) => {
								return get.event("targets").includes(target);
							})
							.set("ai", target => {
								const player = get.event("player");
								return player.canMoveCard(true, true, target) ? 1 + Math.random() : 0;
							})
							.set("targets", es_targets)
							.forResultTargets();
						if (targets && targets.length) target = targets[0];
					}
					if (target) {
						map.es_target = target;
					}
				}
				event.result = {
					bool: map.hs_target || map.es_target,
					targets: [(map.hs_target || [])[0]].concat(map.es_target ? [map.es_target] : []),
					cost_data: map,
				};
			}
		},
		async content(event, trigger, player) {
			const data = event.cost_data;
			if (trigger.name == "damage" || trigger.name == "loseHp" || trigger.name == "recover") {
				player.addTempSkill("dddzhengjun_hp", "phaseUseAfter");
				await trigger.player[data == "回复体力" ? "recover" : "loseHp"]();
			} else {
				if (data.hs_target) {
					player.addTempSkill("dddzhengjun_hs", "phaseUseAfter");
					if (data.hs_target[1] == "摸牌") await data.hs_target[0].draw();
					else await data.hs_target[0].chooseToDiscard("he", true);
				}
				if (data.es_target) {
					player.addTempSkill("dddzhengjun_es", "phaseUseAfter");
					await player.moveCard(true, data.es_target);
				}
			}
		},
		subSkill: {
			hs: { charlotte: true },
			es: { charlotte: true },
			hp: { charlotte: true },
		},
	},
	dddxianxi: {
		trigger: {
			player: "useCard2",
		},
		direct: true,
		filter(event, player) {
			if (event.card.name != "sha" || !player.isPhaseUsing()) return false;
			return game.hasPlayer(function (current) {
				return !event.targets.includes(current) && lib.filter.targetEnabled2(event.card, player, current);
			});
		},
		content() {
			"step 0";
			player
				.chooseTarget(
					get.prompt("dddxianxi"),
					"为" + get.translation(trigger.card) + "增加任意个目标",
					function (card, player, target) {
						var event = _status.event.getTrigger();
						return !event.targets.includes(target) && lib.filter.targetEnabled2(event.card, player, target);
					},
					[1, Infinity]
				)
				.set("ai", function (target) {
					var evt = _status.event.getTrigger();
					if (get.damageEffect(target, evt.player, evt.player) < 0) return 0;
					return get.effect(target, evt.card, evt.player, evt.player);
				});
			"step 1";
			if (result.bool) {
				var targets = result.targets.sortBySeat();
				event.targets = targets;
				if (!event.isMine() && !event.isOnline()) game.delayx();
			} else event.finish();
			"step 2";
			player.logSkill("dddxianxi", targets);
			trigger.targets.addArray(targets);
			if (!trigger._dddxianxi_map) trigger._dddxianxi_map = {};
			trigger._dddxianxi_map[player.playerid] = targets.slice(0);
			player.addTempSkill("dddxianxi_delay");
		},
		subSkill: {
			delay: {
				charlotte: true,
				trigger: {
					player: "useCardAfter",
				},
				forced: true,
				filter(event, player) {
					if (!event._dddxianxi_map || !event._dddxianxi_map[player.playerid]) return false;
					for (var target of event._dddxianxi_map[player.playerid]) {
						if (
							!target.hasHistory("damage", function (evt) {
								return evt.card == event.card;
							})
						)
							return true;
					}
					return false;
				},
				content() {
					"step 0";
					var targets = trigger._dddxianxi_map[player.playerid]
						.filter(function (target) {
							return !target.hasHistory("damage", function (evt) {
								return evt.card == trigger.card;
							});
						})
						.sortBySeat();
					event.targets = targets;
					var num = targets.length;
					player.chooseToDiscard("he", num, "险袭：选择弃置" + get.cnNumber(num) + "张牌", "然后对" + get.translation(targets) + "各造成1点伤害。或点击「取消」，改为摸" + get.cnNumber(num) + "张牌并失去1点体力").set("ai", function (card) {
						return 7 - get.value(card);
					});
					"step 1";
					if (result.bool) {
						for (var i of targets) {
							player.line(i);
							i.damage();
						}
					} else {
						player.draw(targets.length);
						player.loseHp();
					}
				},
				sub: true,
			},
		},
	},
	dddlingyong: {
		trigger: {
			global: ["phaseZhunbeiSkipped", "phaseZhunbeiCancelled", "phaseDrawSkipped", "phaseDrawCancelled", "phaseJudgeSkipped", "phaseJudgeCancelled", "phaseUseSkipped", "phaseUseCancelled", "phaseDiscardSkipped", "phaseDiscardCancelled", "phaseJieshuSkipped", "phaseJieshuCancelled"],
		},
		frequent: true,
		content() {
			"step 0";
			player
				.judge(function (card) {
					var name = get.name(card, false);
					if (name == "sha") return -2;
					return 2;
				})
				.set("callback", function () {
					if (event.judgeResult.name != "sha") {
						var card = event.judgeResult.card;
						if (get.position(card, true) == "o") player.chooseUseTarget(card);
					}
				}).judge2 = function (result) {
				return result.bool;
			};
			"step 1";
			if (result.bool) {
				player.chooseBool("是否继续进行【灵涌】判定？").set("frequentSkill", "dddlingyong");
			} else event.finish();
			"step 2";
			if (result.bool) event.goto(0);
		},
	},
	dddxuxiao: {
		trigger: {
			global: ["loseAfter", "loseAsyncAfter"],
		},
		direct: true,
		filter(event, player) {
			if (event.type != "discard") return false;
			var cards = event.getd();
			for (var i of cards) {
				if (get.position(i, true) == "d" && get.color(i, false) == "black" && get.type(i, null, true) == "basic") {
					var card = get.autoViewAs({ name: "bingliang" }, [i]);
					if (
						game.hasPlayer(function (current) {
							return current.canAddJudge(card);
						})
					)
						return true;
				}
			}
			return false;
		},
		content() {
			"step 0";
			if (!event.cards) event.cards = [];
			var cards = trigger.getd().filter(function (i) {
				if (!event.cards.includes(i) && get.position(i, true) == "d" && get.color(i, false) == "black" && get.type(i, null, true) == "basic") {
					var card = get.autoViewAs({ name: "bingliang" }, [i]);
					if (
						game.hasPlayer(function (current) {
							return current.canAddJudge(card);
						})
					)
						return true;
				}
				return false;
			});
			if (cards.length) {
				player.chooseButton([get.prompt("dddxuxiao"), cards]);
			} else event.finish();
			"step 1";
			if (result.bool) {
				var card = result.links[0];
				event.cards.push(card);
				event.card = card;
				player
					.chooseTarget(true, "请选择【兵粮寸断】的目标", "将" + get.translation(card) + "置于一名角色的判定区内，然后其摸两张牌", function (card, player, target) {
						var card = get.autoViewAs({ name: "bingliang" }, [_status.event.card]);
						return target.canAddJudge(card);
					})
					.set("card", card)
					.set("ai", function (target) {
						var card = get.autoViewAs({ name: "bingliang" }, [_status.event.card]),
							player = _status.event.player;
						return get.attitude(player, target) + Math.max(0, get.effect(target, card, player, player));
					});
			}
			"step 2";
			if (result.bool) {
				var target = result.targets[0];
				player.logSkill("dddxuxiao", target);
				target.addJudge({ name: "bingliang" }, [card]);
				target.draw(2);
				event.goto(0);
			}
		},
	},
	dddxuyu: {
		trigger: {
			player: "useCardAfter",
		},
		content() {
			player.draw();
			player
				.when({ player: "useCardAfter", global: "phaseAfter" })
				.filter(evt => evt != trigger)
				.then(() => {
					if (trigger.name == "useCard") player.chooseToDiscard("he", true);
				});
		},
	},
	dddshijian: {
		trigger: {
			global: "useCardAfter",
		},
		filter(event, player) {
			if (player == event.player) return false;
			const evt = event.getParent("phaseUse");
			if (!evt || evt.player != event.player) return false;
			return (
				event.player.getHistory(
					"useCard",
					evtx => {
						return evtx.getParent("phaseUse") == evt;
					},
					event
				).length == 2
			);
		},
		direct: true,
		*content(event, map) {
			const player = map.player,
				trigger = map.trigger,
				target = trigger.player;
			let result = yield player
				.chooseCard("he", get.prompt("dddshijian", target), `交给${get.translation(target)}一张牌，然后其本回合使用下一张牌指定目标时，你令此牌额外结算一次或摸一张牌。`)
				.set("ai", card => {
					if (get.event("goon")) return 6 - get.value(card);
					return 0;
				})
				.set("goon", get.attitude(player, target) > 0 && target.hasCard(card => target.hasValueTarget(card)));
			if (!result.bool) return event.finish();
			player.logSkill("dddshijian", target);
			player.give(result.cards, target);
			player.addTempSkill("dddshijian_extra");
			player.markAuto("dddshijian_extra", target);
		},
		subSkill: {
			extra: {
				trigger: { global: "useCardToPlayer" },
				filter(event, player) {
					if (!event.isFirstTarget) return false;
					return player.getStorage("dddshijian_extra").includes(event.player);
				},
				charlotte: true,
				forced: true,
				onremove: true,
				*content(event, map) {
					const player = map.player,
						trigger = map.trigger,
						target = trigger.player;
					if (trigger.targets && trigger.targets.length) {
						let result = yield player
							.chooseControl(["额外结算", "摸一张牌"])
							.set("prompt", "实荐：请选择一项")
							.set("prompt2", `令${get.translation(trigger.card)}额外结算一次，或摸一张牌`)
							.set("ai", () => {
								return get.event("choice");
							})
							.set(
								"choice",
								(function () {
									if (trigger.card.name === "tiesuo" || !["basic", "trick"].includes(get.type(trigger.card))) return 1;
									if (
										trigger.targets.reduce((p, c) => {
											return p + get.effect(c, trigger.card, target, _status.event.player);
										}, 0) >= get.effect(player, { name: "draw" }, player, _status.event.player)
									)
										return 0;
									return 1;
								})()
							);
						if (result.index == 0) {
							trigger.getParent().effectCount++;
							game.log(player, "令", trigger.card, "额外结算一次");
						} else player.draw();
					} else player.draw();
					player.removeSkill("dddshijian_extra");
				},
			},
		},
	},
	dddxuyu_old: {
		trigger: {
			player: "useCardAfter",
		},
		filter(event, player) {
			var evt = event.getParent("phaseUse");
			if (!evt || evt.player != player) return false;
			return (
				player.getHistory(
					"useCard",
					function (evtx) {
						return evtx.getParent("phaseUse") == evt;
					},
					event
				).length == 1
			);
		},
		content() {
			player.draw(2);
			player.addTempSkill("dddxuyu_old_discard", "phaseUseAfter");
		},
		subSkill: {
			discard: {
				trigger: {
					player: "useCardAfter",
				},
				filter(event, player) {
					if (!player.countCards("he")) return false;
					var evt = event.getParent("phaseUse");
					if (!evt || evt.player != player) return false;
					return (
						player.getHistory(
							"useCard",
							function (evtx) {
								return evtx.getParent("phaseUse") == evt;
							},
							event
						).length == 3
					);
				},
				forced: true,
				charlotte: true,
				content() {
					player.chooseToDiscard("he", true);
				},
				sub: true,
			},
		},
	},
	dddshijian_old: {
		trigger: {
			global: "useCardAfter",
		},
		filter(event, player) {
			if (player == event.player) return false;
			var evt = event.getParent("phaseUse");
			if (!evt || evt.player != event.player) return false;
			return (
				event.player.getHistory(
					"useCard",
					function (evtx) {
						return evtx.getParent("phaseUse") == evt;
					},
					event
				).length == 3
			);
		},
		logTarget: "player",
		check(event, player) {
			return get.attitude(player, event.player) > 0;
		},
		content() {
			trigger.player.draw();
			player.addTempSkill("dddshijian_old_draw", "phaseUseAfter");
		},
		subSkill: {
			draw: {
				trigger: {
					global: "useCardAfter",
				},
				filter(event, player) {
					if (!event.player.countCards("he")) return false;
					var evt = event.getParent("phaseUse");
					if (!evt || evt.player != event.player) return false;
					return (
						event.player.getHistory(
							"useCard",
							function (evtx) {
								return evtx.getParent("phaseUse") == evt;
							},
							event
						).length == 4
					);
				},
				forced: true,
				charlotte: true,
				content() {
					player.draw(2);
				},
				sub: true,
			},
		},
	},
	dddtaisi: {
		trigger: {
			global: "phaseEnd",
		},
		direct: true,
		filter(event, player) {
			if (!game.getGlobalHistory("changeHp").some(evt => evt.player == player)) return false;
			return game.getGlobalHistory("cardMove").some(function (evt) {
				if (evt.name != "cardsDiscard") {
					if (evt.name != "lose" || evt.position != ui.discardPile) return false;
				}
				return evt.cards.some(card => get.position(card, true) == "d");
			});
		},
		content() {
			"step 0";
			player.chooseTarget(get.prompt("dddtaisi"), "你可以令一名角色获得一张于本回合内进入弃牌堆的牌。若该角色于本回合内对你造成过伤害，则你摸两张牌。").set("ai", function (target) {
				var player = _status.event.player,
					att = get.attitude(player, target);
				if (player.hasHistory("damage", evt => evt.source == target)) return 10 + att;
				return att;
			});
			"step 1";
			if (result.bool) {
				var target = result.targets[0];
				player.logSkill("dddtaisi", target);
				event.target = target;
			} else event.finish();
			"step 2";
			var cards = [];
			game.getGlobalHistory("cardMove", function (evt) {
				if (evt.name != "cardsDiscard") {
					if (evt.name != "lose" || evt.position != ui.discardPile) return false;
				}
				cards.addArray(evt.cards.filter(card => get.position(card, true) == "d"));
			});
			if (!cards.length) event.finish();
			else if (cards.length == 1) event._result = { bool: true, links: cards };
			else
				player.chooseButton(["令" + get.translation(target) + "获得一张牌", cards], true).set("ai", function (button) {
					var player = _status.event.player,
						target = _status.event.getParent().target;
					var att = get.attitude(player, target) - 0.1;
					return get.sgn(att) * get.value(button.link, target);
				});
			"step 3";
			if (result.bool) {
				target.gain(result.links, "gain2");
			} else event.finish();
			"step 4";
			if (player.hasHistory("damage", evt => evt.source == target)) player.draw(2);
		},
	},
	dddquche: {
		enable: "phaseUse",
		limited: true,
		skillAnimation: true,
		animationColor: "thunder",
		filter(event, player) {
			return player.hasCard({ color: "red" }, "he");
		},
		filterCard: {
			color: "red",
		},
		filterTarget(card, player, target) {
			return player != target;
		},
		discard: false,
		delay: false,
		lose: false,
		content() {
			"step 0";
			event.count = 1;
			player.awakenSkill("dddquche");
			player.addTempSkill("dddquche_effect");
			player.addMark("dddquche_effect", 1, false);
			player.give(cards, target);
			event.goto(3);
			"step 1";
			if (
				player.hasCard(function (card) {
					if (_status.connectMode && get.position(card) == "h") return true;
					return get.color(card) == "red";
				}, "he")
			) {
				player.chooseCardTarget({
					prompt: "是否将一张红色牌交给一名其他角色？",
					filterCard: { color: "red" },
					filterTarget: lib.filter.notMe,
					position: "he",
				});
			} else event.finish();
			"step 2";
			if (result.bool) {
				player.addMark("dddquche_effect", 1, false);
				player.give(result.cards, result.targets[0]);
			} else event.finish();
			"step 3";
			if (
				player.hasCard(function (card) {
					if (_status.connectMode && get.position(card) == "h") return true;
					return get.color(card) == "black";
				}, "hes")
			) {
				player.chooseCardTarget({
					prompt: "是否将一张黑色牌当做【杀】使用？",
					position: "he",
					filterCard(card, player) {
						if (get.color(card) != "black") return false;
						var card = get.autoViewAs({ name: "sha" }, [card]);
						return lib.filter.cardEnabled(card, player);
					},
					selectTarget() {
						var card = get.autoViewAs({ name: "sha" }, ui.selected.cards);
						return lib.filter.selectTarget(card, _status.event.player);
					},
					filterTarget(card, player, target) {
						var card = get.autoViewAs({ name: "sha" }, ui.selected.cards);
						return lib.filter.targetEnabled(card, player, target) && lib.filter.targetInRange(card, player, target);
					},
				});
			} else event.finish();
			"step 4";
			if (result.bool) {
				player.addMark("dddquche_effect", 1, false);
				player.useCard({ name: "sha" }, result.cards, result.targets, false);
				event.goto(1);
			} else event.finish();
		},
		subSkill: {
			effect: {
				charlotte: true,
				onremove: true,
				mod: {
					globalFrom(from, to, distance) {
						return distance - from.countMark("dddquche_effect");
					},
				},
				intro: {
					content: "至其他角色的距离-#",
				},
				sub: true,
			},
		},
		mark: true,
		intro: {
			content: "limited",
		},
		init(player, skill) {
			player.storage[skill] = false;
		},
	},
	dddqianlong: {
		zhuSkill: true,
		trigger: {
			source: "dieAfter",
		},
		forced: true,
		filter: (event, player) => player.hasZhuSkill("dddqianlong"),
		content() {
			player.draw(3);
		},
		group: "dddqianlong_cancel",
		subSkill: {
			cancel: {
				trigger: {
					player: ["drawBefore", "discardBefore"],
				},
				forced: true,
				popup: false,
				filter(event, player) {
					if (!player.hasZhuSkill("dddqianlong")) return false;
					var evt = event.getParent();
					return evt && evt.name == "die" && evt.source == player;
				},
				content() {
					trigger.cancel();
				},
				sub: true,
			},
		},
	},
	ddddongcha: {
		trigger: {
			global: "phaseBegin",
		},
		logTarget: "player",
		filter(event, player) {
			return player != event.player && player.countCards("h") > 0 && event.player.countCards("h") > 0;
		},
		check(event, player) {
			return get.attitude(player, event.player) <= 0;
		},
		content() {
			"step 0";
			event.target = trigger.player;
			player.addTempSkill("ddddongcha_effect");
			if (player.countCards("h") > 0) player.chooseCard("h", true, "选择一张牌作为“鉴”");
			"step 1";
			if (result.bool) {
				player.addToExpansion(result.cards, player, "give").gaintag.add("ddddongcha_effect");
			}
			"step 2";
			if (target.countCards("h") > 0) target.chooseCard("h", true, "选择一张牌作为“鉴”");
			"step 3";
			if (result.bool) {
				player.addToExpansion(result.cards, target, "give").gaintag.add("ddddongcha_effect");
			}
		},
		subSkill: {
			effect: {
				charlotte: true,
				trigger: {
					global: "phaseEnd",
				},
				forced: true,
				filter(event, player) {
					return player.getExpansions("ddddongcha_effect").length > 0;
				},
				content() {
					"step 0";
					var cards = player.getExpansions("ddddongcha_effect");
					if (cards.length > 0) {
						if (cards.length == 1)
							event._result = {
								bool: true,
								links: cards,
							};
						else player.chooseButton(["选择获得一张“鉴”", cards], true);
					} else event.finish();
					"step 1";
					if (result.bool) player.gain(result.links, "gain2");
					"step 2";
					var cards = player.getExpansions("ddddongcha_effect");
					if (cards.length > 0 && trigger.player.isIn()) {
						if (cards.length == 1)
							event._result = {
								bool: true,
								links: cards,
							};
						else
							trigger.player.chooseButton(["选择获得一张“鉴”", cards], true).set("ai", function (button) {
								return get.value(button.link, _status.event.player);
							});
					} else event.finish();
					"step 3";
					if (result.bool) trigger.player.gain(result.links, player, "give");
				},
				marktext: "鉴",
				intro: {
					content: "expansion",
					markcount: "expansion",
				},
				sub: true,
			},
		},
	},
	dddzhijie: {
		enable: "chooseToUse",
		filter(event, player) {
			if (event.type == "phase") return false;
			var cards = player.getExpansions("ddddongcha_effect");
			if (cards.length < 2) return false;
			var shan = false,
				wuxie = false;
			for (var i = 0; i < cards.length; i++) {
				for (var j = i + 1; j < cards.length; j++) {
					if (get.color(cards[i], false) == get.color(cards[j], false)) shan = true;
					else wuxie = true;
				}
			}
			if (shan && event.filterCard(get.autoViewAs({ name: "shan" }, "unsure"), player, event)) return true;
			if (wuxie && event.filterCard(get.autoViewAs({ name: "wuxie" }, "unsure"), player, event)) return true;
			return false;
		},
		hiddenCard(player, name) {
			if (name != "shan" && name != "wuxie") return false;
			var cards = player.getExpansions("ddddongcha_effect");
			if (cards.length < 2) return false;
			var shan = false,
				wuxie = false;
			for (var i = 0; i < cards.length; i++) {
				for (var j = i + 1; j < cards.length; j++) {
					if (get.color(cards[i], false) == get.color(cards[j], false)) shan = true;
					else wuxie = true;
				}
			}
			if (shan && name == "shan") return true;
			if (wuxie && name == "wuxie") return true;
			return false;
		},
		chooseButton: {
			dialog(event, player) {
				return ui.create.dialog("智解", player.getExpansions("ddddongcha_effect"), "hidden");
			},
			select: 2,
			filter(button, player) {
				if (!ui.selected.buttons.length) return true;
				var evt = _status.event.getParent(),
					buttons = ui.selected.buttons;
				return evt.filterCard(
					get.autoViewAs(
						{
							name: get.color(buttons[0].link) == get.color(button.link) ? "shan" : "wuxie",
						},
						[button.link, buttons[0].link]
					)
				);
			},
			check: () => 1,
			backup(links, player) {
				return {
					viewAs: {
						name: get.color(links[0]) == get.color(links[1]) ? "shan" : "wuxie",
					},
					cards: links,
					selectCard: -1,
					position: "x",
					filterCard: card => lib.skill["dddzhijie_backup"].cards.includes(card),
					popname: true,
					precontent() {
						player.addTempSkill("dddzhijie_draw");
					},
				};
			},
		},
		ai: {
			combo: "ddddongcha",
			respondShan: true,
			skillTagFilter(player) {
				return lib.skill["dddzhijie"].hiddenCard(player, "shan");
			},
			order: 10,
			result: { player: 1 },
			effect: {
				target: (card, player, target) => {
					if (card.name === "sha" && target.getExpansions("ddddongcha_effect").length < 2 && lib.skill["dddzhijie"].hiddenCard(target, "shan")) return [1, 1, 1, -get.sgn(get.attitude(player, _status.currentPhase))];
				},
			},
		},
		subSkill: {
			draw: {
				trigger: {
					player: "useCardAfter",
				},
				forced: true,
				charlotte: true,
				popup: false,
				filter(event, player) {
					return event.skill == "dddzhijie_backup";
				},
				content() {
					player.draw(2);
				},
				sub: true,
			},
		},
	},
	dddqiahua: {
		trigger: {
			global: "phaseBegin",
		},
		direct: true,
		filter(event, player) {
			return (
				player != event.player &&
				event.player.hp > 0 &&
				player.countCards("h", function (card) {
					return !get.is.shownCard(card);
				}) >= event.player.hp
			);
		},
		content() {
			"step 0";
			var target = trigger.player;
			player
				.chooseCard("h", target.hp, get.prompt("dddqiahua", target), "选择明置" + get.cnNumber(target.hp) + "张手牌，然后" + get.translation(target) + "获得技能〖恂恂〗直到本回合结束。", function (card) {
					return !get.is.shownCard(card);
				})
				.set("goon", get.attitude(player, target) > 0)
				.set("ai", function (card) {
					if (_status.event.goon) return 1 + Math.random();
					return 0;
				});
			"step 1";
			if (result.bool) {
				var target = trigger.player,
					cards = result.cards;
				player.logSkill("dddqiahua", target);
				target.addTempSkills("dddxunxun");
				player.addShownCards(cards, "visible_dddxianglang");
				game.log(player, "选择了", cards, "作为“明”");
				player.showCards(cards, get.translation(player) + "对" + get.translation(target) + "发动了【恰化】");
			}
		},
		ai: {
			expose: 0.15,
		},
		derivation: "dddxunxun",
	},
	dddxunxun: {
		inherit: "xunxun",
		audio: 2,
	},
	dddfusi: {
		mod: {
			ignoredHandcard(card, player) {
				if (get.is.shownCard(card)) return true;
			},
			cardDiscardable(card, player, name) {
				if (name == "phaseDiscard" && get.is.shownCard(card)) return false;
			},
		},
		global: "dddfusi_global",
		subSkill: {
			refused: {
				charlotte: true,
				sub: true,
			},
			allowed: {
				charlotte: true,
				sub: true,
			},
		},
	},
	dddfusi_global: {
		mod: {
			cardEnabled2(card, player) {
				var source = _status.currentPhase;
				if (
					!source ||
					source == player ||
					!source.hasSkill("dddfusi") ||
					source.countCards("h") == 0 ||
					source.hasCard(function (card) {
						return !get.is.shownCard(card);
					}, "h")
				)
					return;
				if (player.getCards("h").includes(card)) return false;
			},
		},
		enable: "chooseToUse",
		filter(event, player) {
			if (event._dddfusi_refused || player.hasSkill("dddfusi_refused")) return false;
			var players = game.filterPlayer(function (current) {
				return current != player && current.hasSkill("dddfusi");
			});
			for (var source of players) {
				var cards = source.getShownCards();
				for (var i of cards) {
					var card = get.autoViewAs(i);
					if (event.filterCard(card, player, event)) return true;
				}
			}
			return false;
		},
		hiddenCard(player, name) {
			if (player.hasSkill("dddfusi_refused")) return false;
			var players = game.filterPlayer(function (current) {
				return current != player && current.hasSkill("dddfusi");
			});
			for (var source of players) {
				var cards = source.getShownCards();
				for (var i of cards) {
					var card = get.autoViewAs(i);
					if (name == card.name) return true;
				}
			}
			return false;
		},
		chooseButton: {
			dialog(event, player) {
				var dialog = ui.create.dialog("腹笥", "hidden");
				var players = game
					.filterPlayer(function (current) {
						return current != player && current.hasSkill("dddfusi");
					})
					.sortBySeat();
				for (var source of players) {
					var cards = source.getShownCards();
					if (cards.length) {
						var str = '<div class="text center">';
						str += get.translation(source);
						var num = source.getSeatNum();
						if (num > 0) str += "（" + get.cnNumber(num, true) + "号位）";
						str += "</div>";
						dialog.add(str);
						dialog.add(cards);
					}
				}
				return dialog;
			},
			filter(button, player) {
				var card = get.autoViewAs(button.link),
					evt = _status.event.getParent();
				return evt.filterCard(card, player, evt);
			},
			check(button) {
				if (_status.event.getParent().type != "phase") return 1;
				return _status.event.player.getUseValue(get.autoViewAs(button.link), null, true);
			},
			backup(links, player) {
				return {
					card: links[0],
					viewAs: get.autoViewAs(links[0]),
					filterCard: () => false,
					selectCard: -1,
					precontent() {
						"step 0";
						var card = lib.skill["dddfusi_global_backup"].card;
						event.card = card;
						event.result.cards = [card];
						event.source = get.owner(card);
						if (!event.result.card.storage) event.result.card.storage = {};
						event.result.card.storage._dddfusi_owner = event.source;
						delete event.result.skill;
						player.logSkill("dddfusi_global", event.source);
						if (player.hasSkill("dddfusi_allowed")) event.finish();
						"step 1";
						if (event.result.targets && event.result.targets.length) player.line(event.result.targets, event.result.card.nature);
						player.showCards([card], get.translation(player) + "向" + get.translation(source) + "发动【腹笥】");
						source
							.chooseButton(
								[
									"是否同意" + get.translation(player) + "使用" + get.translation(card) + "？",
									'<div class="text center">' +
										(function () {
											if (event.result.targets && event.result.targets.length) return "（目标角色：" + get.translation(event.result.targets) + "）";
											return "（无目标角色）";
										})() +
										"</div>",
									[["　　 同意 　　", "　　不同意　　"], "tdnodes"],
									[["　　 同意且本回合内不再提示 　　"], "tdnodes"],
									[["　　不同意且本回合内不再提示　　"], "tdnodes"],
									"forcebutton",
								],
								true
							)
							.set("forceAuto", true);
						"step 2";
						if (result.links[0].indexOf("不同意") == -1) {
							source.chat("同意");
							if (result.links[0].indexOf("本回合内不再提示") > 0) player.addTempSkill("dddfusi_allowed");
						} else if (result.links[0].indexOf("不同意") != -1) {
							source.chat("不同意");
							if (result.links[0].indexOf("本回合内不再提示") > 0) player.addTempSkill("dddfusi_refused");
							else if (event.result.card.name == "wuxie") player.addTempSkill("dddfusi_refused", "_wuxieAfter");
							var evt = event.getParent();
							evt.set("_dddfusi_refused", true);
							evt.goto(0);
						}
					},
				};
			},
			prompt(links, player) {
				return "请选择" + get.translation(links[0]) + "的目标";
			},
		},
		ai: {
			order: 10,
			result: {
				player(player, target) {
					if (
						!game.hasPlayer(function (current) {
							return current != player && current.hasSkill("dddfusi") && get.attitude(player, current) >= 0;
						})
					)
						return 0;
					if (_status.event.dying) return get.attitude(player, _status.event.dying);
					return 1;
				},
			},
			respondSha: true,
			respondShan: true,
			skillTagFilter(player, tag, arg) {
				var name;
				switch (tag) {
					case "respondSha":
						name = "sha";
						break;
					case "respondShan":
						name = "shan";
						break;
				}
				return lib.skill["dddfusi_global"].hiddenCard(player, name);
			},
		},
	},
	dddtuoji: {
		trigger: { global: "useCardAfter" },
		frequent: true,
		filter(event, player) {
			return (
				event.card.storage &&
				event.card.storage._dddfusi_owner == player &&
				!player.hasCard(function (card) {
					return !get.is.shownCard(card);
				}, "h")
			);
		},
		content() {
			player.draw(3);
		},
		ai: {
			combo: "dddfusi",
		},
	},
	dddchashi: {
		trigger: { global: "phaseUseBegin" },
		direct: true,
		filter(event, player) {
			return player != event.player && player.countCards("he") > 0;
		},
		*content(event, map) {
			const player = map.player,
				trigger = map.trigger,
				target = trigger.player;
			const valuableCards = target.getCards("hs", card => target.hasValueTarget(card));
			let result = yield player
				.chooseToDiscard(get.prompt("dddchashi", target), "弃置一张牌，若其使用的下一张牌的花色或类型与此牌相同，你与其各摸一张牌", "he")
				.set("logSkill", ["dddchashi", target])
				.set("ai", card => {
					if (!get.event("goon")) return 0;
					var list = get.event("list");
					return list[0].includes(get.suit(card)) || list[1].includes(get.type2(card));
				})
				.set("list", [valuableCards.map(card => get.suit(card)).toUniqued(), valuableCards.map(card => get.type2(card)).toUniqued()])
				.set("goon", get.attitude(player, target) > 0);
			if (!result.bool) return event.finish();
			player.storage["dddchashi"] = [result.cards[0], target];
			player.addTempSkill("dddchashi_effect", "phaseUseAfter");
			target.addTempSkill("dddchashi_ai", {
				player: ["phaseUseAfter", "useCard1"],
			});
		},
		content_old() {
			"step 0";
			var target = trigger.player,
				history = target.getHistory("useCard", function (evt) {
					return evt.getParent("phaseUse") == trigger;
				});
			event.target = target;
			if (history.length > 0) {
				var suit = get.suit(history[0].card);
				event.suit = suit;
				player
					.chooseCard("he", get.prompt("dddchashi", target), "你可以展示一张牌。若此牌花色为" + get.translation(suit) + "，则" + get.translation(target) + "获得你展示的牌，然后你摸一张牌。")
					.set("goon", get.sgn(get.attitude(player, target)))
					.set("ai", function (card) {
						if (_status.event.goon <= 0) return _status.event.goon * (get.value(card) + 0.01);
						return 2 / Math.max(0.1, get.value(card));
					});
			} else event.goto(2);
			"step 1";
			if (result.bool) {
				player.logSkill("dddchashi", target);
				var card = result.cards[0];
				player.showCards(card, get.translation(player) + "对" + get.translation(target) + "发动了【察势】");
				if (get.color(card) == event.suit) {
					target.gain(card, player, "give");
					player.draw();
				}
			}
			event.finish();
			"step 2";
			player
				.chooseCard("he", get.prompt("dddchashi", target), "你可以展示一张牌。若其本阶段内使用的第一张牌与此牌花色相同，则" + get.translation(target) + "获得你展示的牌，然后你摸一张牌。")
				.set("goon", get.sgn(get.attitude(player, target)))
				.set("ai", function (card) {
					if (_status.event.goon <= 0) return _status.event.goon * (get.value(card) + 0.01);
					return 2 / Math.max(0.1, get.value(card));
				});
			"step 3";
			if (result.bool) {
				player.logSkill("dddchashi", target);
				var card = result.cards[0];
				player.showCards(card, get.translation(player) + "对" + get.translation(target) + "发动了【察势】");
				player.addTempSkill("dddchashi_effect", "phaseUseAfter");
				player.addGaintag([card], "dddchashi");
				player.storage["dddchashi"] = [card, target];
				target.addTempSkill("dddchashi_ai", {
					player: ["phaseUseAfter", "useCard1"],
				});
			}
		},
		subSkill: {
			effect: {
				trigger: { global: "useCard" },
				forced: true,
				charlotte: true,
				filter(event, player) {
					var storage = player.getStorage("dddchashi");
					if (!storage || !storage.length) return false;
					if (event.player != storage[1] || !event.player.isIn()) return false;
					// if(!player.getCards('he').includes(storage[0])||!storage[0].hasGaintag('dddchashi')) return false;
					if (get.suit(event.card) != get.suit(storage[0]) && get.type2(event.card) != get.type2(storage[0])) return false;
					// var evt=event.getParent('phaseUse');
					// if(evt.player)
					// if(event.player.getHistory('useCard',function(evtx){
					// 	return evtx.getParent('phaseUse')==evt;
					// }).indexOf(event)!=0) return false;
					return true;
				},
				content() {
					var storage = player.getStorage("dddchashi");
					// storage[1].gain(storage[0],player,'give');
					// player.draw();
					game.asyncDraw([player, storage[1]].sortBySeat(_status.currentPhase));
					player.removeSkill("dddchashi_effect");
				},
				onremove(player, storage) {
					delete player.storage["dddchashi"];
					// player.removeGaintag('dddchashi');
				},
			},
			ai: {
				charlotte: true,
			},
		},
	},
	dddqice: {
		trigger: { player: "phaseZhunbeiBegin" },
		filter(event, player) {
			return !player.storage["dddqice"];
		},
		content() {
			player.draw(2);
			// player.addTempSkill('dddqice_effect');
			player.setStorage("dddqice", true);
			player
				.when("useCard1")
				.filter(evt => get.type2(evt.card) == "trick")
				.then(() => {
					delete player.storage["dddqice"];
				});
		},
		subSkill: {
			effect: {
				trigger: { player: "phaseJieshuBegin" },
				forced: true,
				charlotte: true,
				content() {
					"step 0";
					var list = [];
					player.getHistory("useCard", function (evt) {
						if (get.type(evt.card) == "trick") list.add(evt.card.name);
					});
					list.sort();
					if (list.length > 0) {
						player
							.chooseButton(["齐策：是否视为使用一张牌？", [list, "vcard"]], function (button) {
								return _status.event.player.hasUseTarget({
									name: button.link[2],
									isCard: true,
								});
							})
							.set("ai", function (button) {
								var card = {
										name: button.link[2],
										nature: button.link[3],
										isCard: true,
									},
									player = _status.event.player;
								return player.getUseValue(card);
							});
					} else {
						player.removeSkills("dddqice");
						event.finish();
					}
					"step 1";
					if (result.bool) {
						player.chooseUseTarget(true, {
							name: result.links[0][2],
							isCard: true,
						});
					}
				},
			},
		},
	},
	//甄姬
	dddmiaoxing: {
		audio: 2,
		trigger: { global: "gameDrawBegin" },
		forced: true,
		content() {
			var me = player;
			var numx = trigger.num;
			trigger.num =
				typeof numx == "function"
					? function (player) {
							if (player == me) {
								return 3 * numx(player);
							}
							return numx(player);
						}
					: function (player) {
							if (player == me) {
								return 3 * numx;
							}
							return numx;
						};
			player._dddmiaoxing = true;
		},
		group: ["dddmiaoxing_out", "dddmiaoxing_balance"],
		marktext: "水",
		intro: {
			name: "水相",
			markcount(storage, player) {
				return "" + player.getExpansions("dddmiaoxing_1").length + "/" + player.getExpansions("dddmiaoxing_2").length;
			},
			mark(dialog, content, player) {
				var content1 = player.getExpansions("dddmiaoxing_1");
				var content2 = player.getExpansions("dddmiaoxing_2");
				if ((content1 && content1.length) || (content2 && content2.length)) {
					if (player == game.me || player.isUnderControl()) {
						dialog.addText("第一组");
						dialog.addAuto(content1);
						dialog.addText("第二组");
						dialog.addAuto(content2);
					} else {
						return "第一组“水相”有" + get.cnNumber(content1.length) + "张；" + "第二组“水相”有" + get.cnNumber(content2.length) + "张";
					}
				}
			},
		},
		subSkill: {
			out: {
				trigger: {
					global: "phaseBefore",
				},
				forced: true,
				filter(event, player) {
					return game.phaseNumber == 0 && player._dddmiaoxing;
				},
				content() {
					"step 0";
					delete player._dddmiaoxing;
					var cardsx = player.getCards("h"),
						num = Math.ceil(cardsx.length / 3);
					var cards = [cardsx.slice(0, num), cardsx.slice(num, 2 * num), cardsx.slice(2 * num)];
					event.cards = cards;
					player.chooseControl("第一组", "第二组", "第三组").set("dialog", ["淼形：选择一组作为你的手牌", '<span class="text center">第一组</span>', cards[0], '<span class="text center">第二组</span>', cards[1], '<span class="text center">第三组</span>', cards[2]]);
					"step 1";
					event.cards.splice(result.index, 1);
					var cards = event.cards;
					player.addToExpansion(cards[0], player, "giveAuto", false).gaintag.add("dddmiaoxing_1");
					player.addToExpansion(cards[1], player, "giveAuto").gaintag.add("dddmiaoxing_2");
					player.markSkill("dddmiaoxing");
				},
			},
			balance: {
				trigger: { player: "phaseDrawAfter" },
				forced: true,
				content() {
					"step 0";
					var forced = player.getExpansions("dddmiaoxing_1").length != player.countCards("h") && player.getExpansions("dddmiaoxing_2").length != player.countCards("h");
					var next = player.chooseButton([1, 2], ["淼形：将至少一组“水相”调整至与手牌数相等", [["第一组", "第二组"], "tdnodes"], '<span class="text center">第一组</span>', player.getExpansions("dddmiaoxing_1"), '<span class="text center">第二组</span>', player.getExpansions("dddmiaoxing_2")], forced);
					next.set("filterButton", button => {
						var type = typeof button.link;
						return type != "object";
					});
					next.set("ai", button => {
						var player = _status.event.player;
						var ind = ["第一组", "第二组"].indexOf(button.link) + 1;
						if (ind == -1) return -100;
						return player.countCards("h") - player.getExpansions("dddmiaoxing_" + ind).length;
					});
					"step 1";
					if (result.bool) {
						var choices = result.links;
						event.choices = choices;
						// var hs=result.moved[0],sx1=result.moved[1],sx2=result.moved[2];
						// hs.removeArray(player.getCards('h'));
						// sx1.removeArray(player.getExpansions('dddmiaoxing_1'));
						// sx2.removeArray(player.getExpansions('dddmiaoxing_2'));
						// if(!hs.length&&!sx1.length&&!sx2.length) return;
						// player.gain(hs,'gain2');
						// player.addToExpansion(sx1,player,'giveAuto').gaintag.add('dddmiaoxing_1');
						// player.addToExpansion(sx2,player,'giveAuto').gaintag.add('dddmiaoxing_2');
					} else event.finish();
					"step 2";
					if (event.choices.includes("第一组")) {
						var del = player.countCards("h") - player.getExpansions("dddmiaoxing_1").length;
						if (del >= 0) {
							if (del != 0) player.addToExpansion(get.cards(del), player, "draw").gaintag.add("dddmiaoxing_1");
							event.goto(4);
						} else {
							player.chooseButton(["淼形：移除" + get.cnNumber(-del) + "张第一组的“水相”", player.getExpansions("dddmiaoxing_1")], -del, true).set("ai", button => {
								return -get.buttonValue(button);
							});
						}
					}
					"step 3";
					if (result.bool) {
						player.loseToDiscardpile(result.links);
					}
					"step 4";
					player.markSkill("dddmiaoxing");
					if (event.choices.includes("第二组")) {
						var del = player.countCards("h") - player.getExpansions("dddmiaoxing_2").length;
						if (del >= 0) {
							if (del != 0) player.addToExpansion(get.cards(del), player, "draw").gaintag.add("dddmiaoxing_2");
							event.goto(6);
						} else {
							player.chooseButton(["淼形：移除" + get.cnNumber(-del) + "张第二组的“水相”", player.getExpansions("dddmiaoxing_2")], -del, true).set("ai", button => {
								return -get.buttonValue(button);
							});
						}
					}
					"step 5";
					if (result.bool) {
						player.loseToDiscardpile(result.links);
					}
					"step 6";
					player.markSkill("dddmiaoxing");
				},
			},
		},
	},
	dddfushi: {
		audio: 2,
		trigger: { player: ["useCardAfter", "respondAfter"] },
		filter(event, player) {
			return get.type(event.card) == "basic" && !player.hasSkill("dddfushi_used");
		},
		direct: true,
		content() {
			"step 0";
			player
				.chooseControl("第一组", "第二组", "cancel2")
				.set("dialog", [get.prompt("dddfushi"), '<span class="text center">用所有手牌交换一组“水相”</span>', '<span class="text center">第一组</span>', player.getExpansions("dddmiaoxing_1"), '<span class="text center">第二组</span>', player.getExpansions("dddmiaoxing_2")])
				.set("ai", () => {
					return _status.event.choice;
				})
				.set(
					"choice",
					(function () {
						var fn = player == _status.currentPhase ? "useful" : "value";
						var list = [
							[1, player.getExpansions("dddmiaoxing_1").reduce((p, c) => p + get[fn](c), 0)],
							[2, player.getExpansions("dddmiaoxing_2").reduce((p, c) => p + get[fn](c), 0)],
							[3, player.getCards("h").reduce((p, c) => p + get[fn](c), 0)],
						].sort((a, b) => b[1] - a[1]);
						return list[0][0] - 1;
					})()
				);
			"step 1";
			if (result.control == "cancel2") event.finish();
			else {
				player.logSkill("dddfushi");
				player.addTempSkill("dddfushi_used");
				var index = result.index + 1;
				player.addToExpansion(player.getCards("h"), player, "giveAuto").gaintag.add("dddmiaoxing_" + index);
				player.gain(player.getExpansions("dddmiaoxing_" + index), "draw");
				game.log(player, "获得了" + get.cnNumber(player.getExpansions("dddmiaoxing_" + index).length) + "张“水相”");
			}
			"step 2";
			player.markSkill("dddmiaoxing");
			player
				.chooseTarget("是否令一名男性角色选择是否交换“水相”？", (card, player, target) => {
					return target.hasSex("male");
				})
				.set("ai", target => get.attitude(_status.event.player, target));
			"step 3";
			if (result.bool) {
				var target = result.targets[0];
				event.target = target;
				player.line(target);
				target
					.chooseControl("第一组", "第二组", "cancel2")
					.set("dialog", ["浮世：是否用所有手牌交换一组“水相”？", '<span class="text center">第一组</span>', player.getExpansions("dddmiaoxing_1"), '<span class="text center">第二组</span>', player.getExpansions("dddmiaoxing_2")])
					.set("ai", () => {
						return _status.event.choice;
					})
					.set(
						"choice",
						(function () {
							var fn = target == _status.currentPhase ? "useful" : "value";
							var list = [
								[1, player.getExpansions("dddmiaoxing_1").reduce((p, c) => p + get[fn](c), 0)],
								[2, player.getExpansions("dddmiaoxing_2").reduce((p, c) => p + get[fn](c), 0)],
								[3, target.getCards("h").reduce((p, c) => p + get[fn](c), 0)],
							].sort((a, b) => b[1] - a[1]);
							return list[0] - 1;
						})()
					);
			} else event.finish();
			"step 4";
			if (result.control == "cancel2") event.finish();
			else {
				var index = result.index + 1;
				player.addToExpansion(target.getCards("h"), target, "giveAuto").gaintag.add("dddmiaoxing_" + index);
				target.gain(player.getExpansions("dddmiaoxing_" + index), player, "giveAuto");
			}
			"step 5";
			player.markSkill("dddmiaoxing");
		},
		subSkill: {
			used: { charlotte: true },
		},
	},
	//赵昂
	dddfenji: {
		audio: 2,
		trigger: { player: ["phaseDrawBegin1", "phaseDiscardBegin"] },
		direct: true,
		filter(event, player) {
			if (event.name == "phaseDraw" && event.numFixed) return false;
			return lib.inpile.filter(i => get.type(i) == "trick").removeArray(player.getStorage("dddfenji")).length > 0;
		},
		content() {
			"step 0";
			var cards = lib.inpile
				.filter(i => {
					return get.type(i) == "trick" && !player.getStorage("dddfenji").includes(i);
				})
				.map(i => ["锦囊", "", i]);
			player
				.chooseButton([get.prompt("dddfenji"), [cards, "vcard"]])
				.set("ai", button => {
					var evt = _status.event.getTrigger();
					if (evt.name == "phaseDraw") {
						if (!get.tag({ name: button.link[2] }, "damage")) return 0;
					} else {
						if (
							lib.skill.xunshi.isXunshi({
								name: button.link[2],
							})
						)
							return 0;
					}
					return _status.event.player.getUseValue({
						name: button.link[2],
					});
				})
				.set("filterButton", button => {
					return player.hasUseTarget(button.link[2]);
				});
			"step 1";
			if (result.bool) {
				player.logSkill("dddfenji");
				player.markAuto("dddfenji", [result.links[0][2]]);
				player.chooseUseTarget(result.links[0][2], true);
			} else event.finish();
			"step 2";
			if (trigger.name == "phaseDraw") {
				trigger.changeToZero();
				var num = 0;
				game.filterPlayer(current => {
					current.getHistory("sourceDamage", evt => {
						if (evt.getParent(4) == event) num += evt.num;
					});
				});
				if (num > 0) player.draw(num);
			} else {
				trigger.cancel();
				var num = 0;
				player.getHistory("useCard", evt => {
					if (evt.getParent(2) == event) num = evt.targets.length;
				});
				if (num > 0 && player.countCards("he")) player.chooseToDiscard(num, true);
			}
		},
	},
	//周处
	dddxiaheng: {
		audio: 2,
		trigger: { player: "phaseUseBegin" },
		forced: true,
		onremove: ["dddxiaheng", "dddxiaheng_del"],
		intro: { content: "已因此技能对$造成过伤害" },
		content() {
			"step 0";
			event.targets = [];
			player.chooseTarget("侠横：令一名角色弃置两张牌", true).set("ai", target => {
				var player = _status.event.player,
					eff = get.effect(target, { name: "guohe_copy2" }, player, player),
					eff2 = get.damageEffect(target, player, player);
				if (player.storage["dddxiaheng_del"]) return eff;
				var toself = false;
				if (eff2 > eff * 2) {
					toself = !player.isDamaged() && player.countCards("he", card => get.value(card, player) < 5) >= 2;
				}
				if (toself) return target == player ? 100 : 0;
				return eff * (eff2 > eff * 2 ? 0.5 : 1.5);
			});
			"step 1";
			if (result.bool) {
				var target = result.targets[0];
				event.targets.add(target);
				player.line(target);
				target.chooseToDiscard(2, true, "he");
			}
			"step 2";
			player
				.chooseTarget("侠横：对一名角色造成1点伤害", true)
				.set("ai", target => {
					var player = _status.event.player,
						eff = get.damageEffect(target, player, player),
						targetx = _status.event.targetx;
					if (player.storage["dddxiaheng_del"]) return eff;
					var fix = player.getStorage("dddxiaheng").includes(target) ? 0.75 : 1;
					if (target == player && targetx != player && player.isHealthy() && !player.getStorage("dddxiaheng").includes(player) && player.hp > 2) return 100;
					return eff * (player.hp == 1 || target == targetx ? 0.1 : 1) * fix;
				})
				.set("targetx", targets[0]);
			"step 3";
			if (result.bool) {
				var target = result.targets[0];
				event.targets.add(target);
				player.line(target);
				target.damage();
				player.markAuto("dddxiaheng", [target]);
			}
			"step 4";
			if (player.storage["dddxiaheng_del"]) event.finish();
			else {
				if (!targets.includes(player)) player.loseMaxHp();
				if (targets.length == 1) {
					player.removeSkills("dddxiaheng");
				}
			}
			"step 5";
			if (player.getStorage("dddxiaheng").length >= 3) {
				player.storage["dddxiaheng_del"] = true;
			}
		},
	},
	//刘巴
	dddfengzheng: {
		audio: 2,
		global: "dddfengzheng_global",
		trigger: {
			global: "roundStart",
		},
		filter(event, player) {
			return game.hasPlayer(current => {
				var history = current.actionHistory;
				for (var i = history.length - 2; i >= 0; i--) {
					var evts = history[i].useSkill;
					for (var evt of evts) {
						if (evt.skill == "dddfengzheng_global") return true;
					}
					if (history[i].isRound) break;
				}
				return false;
			});
		},
		prompt2(event, player) {
			var num = game.countPlayer(current => {
				var history = current.actionHistory;
				for (var i = history.length - 2; i >= 0; i--) {
					var evts = history[i].useSkill;
					for (var evt of evts) {
						if (evt.skill == "dddfengzheng_global") return true;
					}
					if (history[i].isRound) break;
				}
				return false;
			});
			return "观看并分配牌堆顶的" + get.cnNumber(num) + "张牌";
		},
		content() {
			"step 0";
			var num = game.countPlayer(current => {
				var history = current.actionHistory;
				for (var i = history.length - 2; i >= 0; i--) {
					var evts = history[i].useSkill;
					for (var evt of evts) {
						if (evt.skill == "dddfengzheng_global") return true;
					}
					if (history[i].isRound) break;
				}
				return false;
			});
			var cards = game.cardsGotoOrdering(get.cards(num)).cards;
			event.cards = cards;
			if (_status.connectMode)
				game.broadcastAll(function () {
					_status.noclearcountdown = true;
				});
			event.given_map = {};
			"step 1";
			if (event.cards.length > 1) {
				player.chooseCardButton("丰政：请选择要分配的牌", true, event.cards, [1, event.cards.length]).set("ai", function (button) {
					if (ui.selected.buttons.length == 0) return 1;
					return 0;
				});
			} else if (event.cards.length == 1)
				event._result = {
					links: event.cards.slice(0),
					bool: true,
				};
			else event.finish();
			"step 2";
			if (result.bool) {
				event.cards.removeArray(result.links);
				event.togive = result.links.slice(0);
				player
					.chooseTarget("选择一名角色获得" + get.translation(result.links), true)
					.set("ai", function (target) {
						var fix = (_status.event.getParent().given_map[target.playerid] || 0) + 1;
						var att = get.attitude(_status.event.player, target) / Math.sqrt(fix);
						if (_status.event.enemy) return -att;
						else if (att > 0) return att / (1 + target.countCards("h"));
						else return att / 100;
					})
					.set("enemy", get.value(event.togive[0], player, "raw") < 0);
			}
			"step 3";
			if (result.targets.length) {
				var id = result.targets[0].playerid,
					map = event.given_map;
				if (!map[id]) map[id] = [];
				map[id].addArray(event.togive);
			}
			if (cards.length > 0) event.goto(1);
			"step 4";
			if (_status.connectMode) {
				game.broadcastAll(function () {
					delete _status.noclearcountdown;
					game.stopCountChoose();
				});
			}
			var list = [],
				lose = false;
			for (var i in event.given_map) {
				var source = (_status.connectMode ? lib.playerOL : game.playerMap)[i];
				player.line(source, "green");
				list.push([source, event.given_map[i]]);
				if (event.given_map[i].length > 2) lose = true;
			}
			game.loseAsync({
				gain_list: list,
				giver: player,
				animate: "draw",
			}).setContent("gaincardMultiple");
			if (!lose) event.finish();
			"step 5";
			player.removeSkills("dddfengzheng");
		},
		subSkill: {
			global: {
				audio: "dddfengzheng",
				enable: "phaseUse",
				usable: 1,
				filter(event, player) {
					return game.hasPlayer(current => current.hasSkill("dddfengzheng"));
				},
				filterCard(card, player) {
					var num = 0;
					for (var i = 0; i < ui.selected.cards.length; i++) {
						num += get.number(ui.selected.cards[i]);
					}
					return get.number(card) + num <= 13;
				},
				selectCard: [1, Infinity],
				filterOk() {
					var num = 0;
					for (var i = 0; i < ui.selected.cards.length; i++) {
						num += get.number(ui.selected.cards[i]);
					}
					return num == 13;
				},
				popname: true,
				complexCard: true,
				prompt: "将任意张点数和为13的手牌当【无中生有】使用",
				check(card) {
					var num = 0;
					for (var i = 0; i < ui.selected.cards.length; i++) {
						num += get.number(ui.selected.cards[i]);
					}
					if (num + get.number(card) == 13) return 5.5 - get.value(card);
					if (ui.selected.cards.length == 0) {
						var cards = _status.event.player.getCards("h");
						for (var i = 0; i < cards.length; i++) {
							for (var j = i + 1; j < cards.length; j++) {
								if (get.number(cards[i]) + get.number(cards[j]) == 13) {
									if (cards[i] == card || cards[j] == card) return 6 - get.value(card);
								}
							}
						}
					}
					return 0;
				},
				position: "hs",
				viewAs: { name: "wuzhong" },
			},
		},
	},
	dddyulv: {
		audio: 2,
		trigger: {
			global: "phaseBefore",
			player: "enterGame",
		},
		forced: true,
		filter(event, player) {
			return event.name != "phase" || game.phaseNumber == 0;
		},
		group: "dddyulv_enter",
		content() {
			"step 0";
			player.draw();
			"step 1";
			if (!player.countCards("he")) event.finish();
			else player.chooseCard("玉律：将一张牌置于武将牌上", true);
			"step 2";
			if (result.bool) {
				player.addToExpansion(result.cards, player, "give").gaintag.add("dddyulv");
			}
		},
		marktext: "律",
		intro: {
			markcount: "expansion",
			content: "expansion",
		},
		subSkill: {
			enter: {
				trigger: {
					global: ["loseAfter", "cardsDiscardAfter", "loseAsyncAfter", "equipAfter"],
				},
				forced: true,
				direct: true,
				filter(event, player) {
					var cards = event.getd();
					if (!cards.length) return false;
					const card = player.getExpansions("dddyulv")[0];
					if (!card) return false;
					const number = get.number(card, false);
					if (!_status.currentPhase || !_status.currentPhase.isIn()) return false;
					return cards.some(i => get.number(i, false) == number);
				},
				content() {
					"step 0";
					player
						.chooseControl("摸牌", "弃牌")
						.set("prompt", "玉律：令" + get.translation(_status.currentPhase) + "摸一张牌或弃置一张牌")
						.set("ai", () => {
							return get.attitude(_status.event.player, _status.currentPhase) > 0 ? "摸牌" : "弃牌";
						});
					"step 1";
					player.logSkill("dddyulv_enter", _status.currentPhase);
					var reset = false;
					if (result.index == 0) _status.currentPhase.draw();
					else _status.currentPhase.chooseToDiscard(true, "he");
					var reset =
						player.getHistory("useSkill", evt => {
							return evt.skill == "dddyulv_enter";
						}).length == 2;
					if (!reset) event.finish();
					"step 2";
					if (!player.countCards("h")) player.draw();
					"step 3";
					if (!player.countCards("h")) event.finish();
					else player.chooseCard("玉律：选择一张手牌交换“玉律”（" + get.translation(player.getExpansions("dddyulv")) + "）", true);
					"step 4";
					if (result.bool) {
						player.gain(player.getExpansions("dddyulv"), player, "give");
						player.addToExpansion(result.cards, player, "log", "give").gaintag.add("dddyulv");
					}
				},
			},
		},
	},
	dddyulv_old: {
		audio: 2,
		trigger: {
			global: "phaseBefore",
			player: "enterGame",
		},
		forced: true,
		filter(event, player) {
			return event.name != "phase" || game.phaseNumber == 0;
		},
		group: "dddyulv_old_enter",
		content() {
			"step 0";
			player
				.chooseControl(Array.from({ length: 13 }, (_, i) => get.strNumber(i + 1)))
				.set("prompt", "玉律：声明一个点数")
				.set("ai", () => _status.event.controls.randomGet());
			"step 1";
			player.popup(result.control);
			var number = result.index + 1;
			player.storage["dddyulv_old"] = number;
			player.markSkill("dddyulv_old");
		},
		intro: {
			content: "声明的点数为#",
		},
		subSkill: {
			enter: {
				trigger: {
					global: ["loseAfter", "cardsDiscardAfter", "loseAsyncAfter", "equipAfter"],
				},
				forced: true,
				direct: true,
				filter(event, player) {
					var cards = event.getd();
					if (!cards.length || !player.storage["dddyulv_old"]) return false;
					if (!_status.currentPhase || !_status.currentPhase.isIn()) return false;
					return cards.some(i => get.number(i, false) == player.storage["dddyulv_old"]);
				},
				content() {
					"step 0";
					player
						.chooseControl("摸牌", "弃牌")
						.set("prompt", "玉律：令" + get.translation(_status.currentPhase) + "摸一张牌或弃置一张牌")
						.set("ai", () => {
							return get.attitude(_status.event.player, _status.currentPhase) > 0 ? "摸牌" : "弃牌";
						});
					"step 1";
					player.logSkill("dddyulv_old_enter", _status.currentPhase);
					var reset = false;
					if (result.index == 0) _status.currentPhase.draw();
					else _status.currentPhase.chooseToDiscard(true, "he");
					if (_status.currentPhase.hasSkill("dddyulv_old_" + result.index)) reset = true;
					_status.currentPhase.removeSkill("dddyulv_old_0");
					_status.currentPhase.removeSkill("dddyulv_old_1");
					_status.currentPhase.addSkill("dddyulv_old_" + result.index);
					if (!reset) event.finish();
					"step 2";
					player
						.chooseControl(Array.from({ length: 13 }, (_, i) => get.strNumber(i + 1)))
						.set("prompt", "玉律：重新声明一个点数")
						.set("ai", () => _status.event.controls.randomGet());
					"step 3";
					player.popup(result.control);
					var number = result.index + 1;
					player.storage["dddyulv_old"] = number;
					player.markSkill("dddyulv_old");
					"step 4";
					var evt = trigger.getParent("phaseUse");
					if (evt && evt.name == "phaseUse") {
						evt.skipped = true;
					}
					var evt = trigger.getParent("phase");
					if (evt && evt.name == "phase") {
						game.log(evt.player, "结束了回合");
						evt.finish();
						evt.untrigger(true);
					}
				},
			},
			0: { charlotte: true },
			1: { charlotte: true },
		},
	},
	//蹇硕
	dddfenye: {
		audio: 2,
		enable: "phaseUse",
		usable: 1,
		filterTarget(card, player, target) {
			return player.canCompare(target);
		},
		filter(event, player) {
			return player.countCards("h") > 0;
		},
		content() {
			"step 0";
			player.chooseToCompare([target]).setContent(lib.skill["dddfenye"].chooseToCompareFenye);
			"step 1";
			result.winner.forEach(i => i.addExpose(0.05));
			result.loser.forEach(i => i.addExpose(0.05));
			if (result.winner.length && result.loser.length) {
				var players = result.winner;
				event.players = players.sortBySeat();
				event.targets = result.loser;
			} else event.finish();
			"step 2";
			var current = event.players.shift();
			event.current = current;
			current
				.chooseTarget("是否视为对一名没赢的角色使用一张【杀】？", (card, player, target) => {
					return player.canUse("sha", target, false) && _status.event.targets.includes(target);
				})
				.set("ai", target => {
					return get.effect(target, { name: "sha" }, get.player(), get.player());
				})
				.set("targets", event.targets);
			"step 3";
			if (result.bool) {
				if (!event.isMine() && !event.isOnline()) game.delayx();
				var target = result.targets[0];
				event.current.useCard({ name: "sha", isCard: true }, target, false);
				event.targets.remove(target);
			}
			if (event.targets.length && event.players.length) event.goto(2);
		},
		chooseToCompareFenye() {
			"step 0";
			var target = event.targets[0];
			event.targets.unshift(player);
			event.targetx = target;
			if (player.countCards("h") == 0 || target.countCards("h") == 0) {
				event.result = { cancelled: true, bool: false };
				event.finish();
				return;
			}
			game.log(player, "对", target, "发起拼点");
			"step 1";
			var send = function (targets) {
				var next = game.createEvent("dddfenye_choose", false);
				// next.player=game.me;
				next.targets = targets;
				next.ai = event.ai;
				next.fixedResult = event.fixedResult;
				next.setContent(lib.skill["dddfenye"].contentx);
				game.resume();
			};
			var sendback = function (result, player) {
				if (!Array.isArray(result)) {
					result = [null, null];
				}
				event.results.push([player, result]);
			};
			event.ai_targets = [];
			event.results = [];
			var players = game.filterPlayer().sortBySeat();
			var time = 10000;
			if (lib.configOL && lib.configOL.choose_timeout) time = parseInt(lib.configOL.choose_timeout) * 1000;
			for (var i = 0; i < players.length; i++) {
				players[i].showTimer(time);
				if (players[i].isOnline()) {
					event.withol = true;
					players[i].send(send, targets);
					players[i].wait(sendback);
				} else if (players[i] == game.me) {
					event.withme = true;
					var next = game.createEvent("dddfenye_choose", false);
					next.player = game.me;
					next.targets = targets;
					next.ai = event.ai;
					next.fixedResult = event.fixedResult;
					next.setContent(lib.skill["dddfenye"].contentx);
					if (_status.connectMode) game.me.wait(sendback);
				} else {
					event.ai_targets.push(players[i]);
				}
			}
			if (event.ai_targets.length) {
				for (var i = 0; i < event.ai_targets.length; i++) {
					if (targets.includes(event.ai_targets[i])) {
						var target = event.ai_targets[i];
						var cards = target.getCards("h").sort((a, b) => {
							return event.ai(b) - event.ai(a);
						});
						sendback([target, cards[0]], target);
						event.ai_targets.splice(i--, 1);
					}
				}
				if (event.ai_targets.length) {
					event.ai_targets.randomSort();
					setTimeout(function () {
						event.interval = setInterval(
							function () {
								var target = event.ai_targets.shift();
								var cards = target
									.getCards("h", card => get.value(card) < 4)
									.sort((a, b) => {
										return event.ai(b) - event.ai(a);
									});
								if (!cards.length) {
									sendback([null, null], target);
								} else {
									if (Math.abs(get.number(cards[0]) - 7) <= 2) {
										sendback([null, null], target);
									} else {
										var sgn = get.number(cards[0]) >= 7 ? 1 : -1;
										var targetsx = targets.slice().sort((a, b) => {
											var attA = get.attitude(target, a),
												attB = get.attitude(target, b);
											return sgn * (attB - attA);
										});
										sendback([targetsx[0], cards[0]], target);
									}
								}
								if (!event.ai_targets.length) {
									clearInterval(event.interval);
									if (event.withai) game.resume();
								}
							},
							_status.connectMode ? 750 : 75
						);
					}, 500);
				}
			}
			"step 2";
			if (event.withme) {
				if (_status.connectMode) game.me.unwait(result, game.me);
				else {
					if (!Array.isArray(result)) {
						result = [null, null];
					}
					event.results.push([game.me, result]);
				}
			}
			"step 3";
			if (event.withol && !event.resultOL) {
				game.pause();
			}
			"step 4";
			if (event.ai_targets.length > 0) {
				event.withai = true;
				game.pause();
			}
			"step 5";
			delete event._global_waiting;
			for (var i of game.players) i.hideTimer();
			var cards = [];
			var targets = [];
			var lose_list = [];
			event.results.sort((a, b) => lib.sort.seat(a[0], b[0]));
			for (var res of event.results) {
				var target = res[0],
					card = res[1][1],
					skill = res[1][2];
				if (!target || !card) continue;
				if (skill && lib.skill[skill] && lib.skill[skill].onCompare) {
					target.logSkill(skill);
					res[1][1] = lib.skill[skill].onCompare(target);
					if (target != player) cards.push(res[1][1]);
				} else {
					if (target != player) cards.push(card);
					lose_list.push([target, [card]]);
				}
				if (target != player) targets.push(target);
			}
			if (lose_list.length) {
				game.loseAsync({
					lose_list: lose_list,
				}).setContent("chooseToCompareLose");
			}
			event.lose_list = lose_list;
			event.getNum = function (card) {
				for (var i of event.lose_list) {
					if (i[1].includes && i[1].includes(card)) return get.number(card, i[0]);
				}
				return get.number(card, false);
			};
			event.cardlist = cards;
			event.cards = cards;
			event.card1 = event.results[0][1][1];
			event.num1 = event.getNum(event.card1);
			event.iwhile = 0;
			event.targets = targets;
			event.tempplayer = event.player;
			event.players = event.results.filter(i => i[1][0] == player && i[1][1]).map(i => i[0]);
			event.targetsx = event.results.filter(i => i[1][0] == event.targetx && i[1][1]).map(i => i[0]);
			event.result = {
				player: event.card1,
				targets: event.cardlist.slice(0),
				num1: [event.num1],
				num2: [],
				winner: [],
				loser: [],
			};
			game.log(player, "的拼点牌为", event.card1);
			"step 6";
			event.target = null;
			event.trigger("compare");
			lib.skill["dddfenye"].$compareFenye(
				event.players,
				event.results.filter(i => i[1][0] == player).map(i => i[1][1]),
				event.targetsx,
				event.results.filter(i => i[1][0] == event.targetx).map(i => i[1][1])
			);
			"step 7";
			if (event.iwhile < targets.length) {
				event.target = targets[event.iwhile];
				event.target.addTempClass("target");
				event.card2 = event.cardlist[event.iwhile];
				event.num2 = event.getNum(event.card2);
				game.log(event.target, "的拼点牌为", event.card2);
				delete event.player;
				event.trigger("compare");
			} else {
				game.delay(0, 1000);
				event.goto(9);
			}
			"step 8";
			var key = event.players.includes(target) ? "num1" : "num2";
			event.result[key].push(event.num2);
			event.iwhile++;
			event.goto(7);
			"step 9";
			event.player = event.tempplayer;
			delete event.tempplayer;
			var str;
			var num1 = event.result.num1.reduce((p, c) => p + c, 0) / event.result.num1.length,
				num2 = event.result.num2.reduce((p, c) => p + c, 0) / event.result.num2.length;
			game.log(event.player, "方的点数均值为", "#y" + Math.floor(num1 * 100) / 100);
			game.log(event.targetx, "方的点数均值为", "#y" + Math.floor(num2 * 100) / 100);
			if (num1 > num2) {
				str = get.translation(event.players) + "拼点成功";
				event.players.forEach(i => i.popup("胜"));
				event.targetsx.forEach(i => i.popup("负"));
				event.result.winner = event.players;
				event.result.loser = event.targetsx;
			} else {
				str = get.translation(event.players) + "拼点失败";
				if (num1 == num2) {
					event.players.forEach(i => i.popup("平"));
					event.targetsx.forEach(i => i.popup("平"));
					event.result.loser = event.players.addArray(event.targetsx);
				} else {
					event.players.forEach(i => i.popup("负"));
					event.targetsx.forEach(i => i.popup("胜"));
					event.result.winner = event.targetsx;
					event.result.loser = event.players;
				}
			}
			game.broadcastAll(function (str) {
				var dialog = ui.create.dialog(str);
				dialog.classList.add("center");
				setTimeout(function () {
					dialog.close();
				}, 1000);
			}, str);
			game.delay(3);
			("step 10");
			game.broadcastAll(ui.clear);
			("step 11");
			event.cards.add(event.card1);
		},
		contentx() {
			"step 0";
			var player = game.me;
			event.player = player;
			event._global_waiting = true;
			event.result = [];
			if (targets.includes(player)) {
				if (event.fixedResult && event.fixedResult[player.playerid]) {
					event.result[0] = player;
					event.result[1] = event.fixedResult[player.playerid];
					event.finish();
				} else player.chooseCard("请选择拼点牌", true).set("type", "compare").set("glow_result", true).set("_global_waiting", true).ai = event.ai;
			} else {
				player.chooseCardTarget({
					targets: targets,
					filterTarget(card, player, target) {
						return _status.event.targets.includes(target);
					},
					selectCard: 1,
					prompt: "是否于此次拼点加入其中一方？",
					position: "h",
					_global_waiting: true,
					ai1: event.ai,
					ai2(target) {
						var player = _status.event.player,
							sgn = -1;
						if (player.hasCard(card => get.number(card) > 10 && get.value(card) < 5)) sgn = 1;
						return sgn * get.attitude(player, target);
					},
				});
			}
			"step 1";
			if (targets.includes(player)) {
				event.result[0] = player;
				event.result[1] = result.cards[0];
				event.result[2] = result.skill;
			} else {
				if (result.bool) {
					event.result[0] = result.targets[0];
					event.result[1] = result.cards[0];
				} else {
					event.result = [null, null];
				}
			}
		},
		$compareFenye(players, cards1, targets, cards2) {
			game.broadcast(
				function (players, cards1, targets, cards2) {
					lib.skill["dddfenye"].$compareFenye(players, cards1, targets, cards2);
				},
				players,
				cards1,
				targets,
				cards2
			);
			var left0 = -players.length * 52 - (players.length - 1) * 8;
			for (var i = 0; i < players.length; i++) {
				(function (target, card1, i) {
					var left = left0 + i * 120;
					var node1;
					if (left < 0) {
						node1 = target.$throwxy2(card1, "calc(50% - " + -left + "px)", "calc(50% + 10px)", "perspective(600px) rotateY(180deg)", true);
					} else {
						node1 = target.$throwxy2(card1, "calc(50% + " + left + "px)", "calc(50% + 10px)", "perspective(600px) rotateY(180deg)", true);
					}
					if (lib.config.cardback_style != "default") {
						node1.style.transitionProperty = "none";
						ui.refresh(node1);
						node1.classList.add("infohidden");
						ui.refresh(node1);
						node1.style.transitionProperty = "";
					} else {
						node1.classList.add("infohidden");
					}
					node1.style.transform = "perspective(600px) rotateY(180deg) translateX(0)";
					var onEnd02 = function () {
						node1.removeEventListener("webkitTransitionEnd", onEnd02);
						setTimeout(function () {
							node1.style.transition = "all ease-in 0.3s";
							node1.style.transform = "perspective(600px) rotateY(270deg) translateX(52px)";
							var onEnd = function () {
								node1.classList.remove("infohidden");
								node1.style.transition = "all 0s";
								ui.refresh(node1);
								node1.style.transform = "perspective(600px) rotateY(-90deg) translateX(52px)";
								ui.refresh(node1);
								node1.style.transition = "";
								ui.refresh(node1);
								node1.style.transform = "";
								node1.removeEventListener("webkitTransitionEnd", onEnd);
							};
							node1.listenTransition(onEnd);
						}, 200);
					};
					node1.listenTransition(onEnd02);
				})(players[i], cards1[i], i);
			}
			setTimeout(function () {
				var left0 = -targets.length * 52 - (targets.length - 1) * 8;
				for (var i = 0; i < targets.length; i++) {
					(function (target, card2, i) {
						var left = left0 + i * 120;
						var node2;
						if (left < 0) {
							node2 = target.$throwxy2(card2, "calc(50% - " + -left + "px)", "calc(50% - 114px)", "perspective(600px) rotateY(180deg)", true);
						} else {
							node2 = target.$throwxy2(card2, "calc(50% + " + left + "px)", "calc(50% - 114px)", "perspective(600px) rotateY(180deg)", true);
						}
						if (lib.config.cardback_style != "default") {
							node2.style.transitionProperty = "none";
							ui.refresh(node2);
							node2.classList.add("infohidden");
							ui.refresh(node2);
							node2.style.transitionProperty = "";
						} else {
							node2.classList.add("infohidden");
						}
						node2.style.transform = "perspective(600px) rotateY(180deg) translateX(0)";
						var onEnd02 = function () {
							node2.removeEventListener("webkitTransitionEnd", onEnd02);
							setTimeout(function () {
								node2.style.transition = "all ease-in 0.3s";
								node2.style.transform = "perspective(600px) rotateY(270deg) translateX(52px)";
								var onEnd = function () {
									node2.classList.remove("infohidden");
									node2.style.transition = "all 0s";
									ui.refresh(node2);
									node2.style.transform = "perspective(600px) rotateY(-90deg) translateX(52px)";
									ui.refresh(node2);
									node2.style.transition = "";
									ui.refresh(node2);
									node2.style.transform = "";
									node2.removeEventListener("webkitTransitionEnd", onEnd);
								};
								node2.listenTransition(onEnd);
							}, 200);
						};
						node2.listenTransition(onEnd02);
					})(targets[i], cards2[i], i);
				}
			}, 200);
		},
		ai: {
			order: 1,
			result: {
				target: -1,
			},
			threaten: 1.3,
		},
	},
	dddshichao: {
		audio: 2,
		trigger: {
			player: "phaseZhunbeiBegin",
		},
		filter(event, player) {
			return player.countMark("dddshichao") + 1 <= game.countPlayer();
		},
		onremove: true,
		forced: true,
		content() {
			"step 0";
			var N = player.countMark("dddshichao") + 1;
			player
				.chooseTarget("逝潮：选择一名手牌数第" + get.cnNumber(N) + "大的角色", true, (card, player, target) => {
					return _status.event.targets.includes(target);
				})
				.set("ai", target => {
					var zhu = get.zhu(player) || game.filterPlayer(i => i.getSeatNum() == 1)[0];
					return Math.min(target.countCards("h") - player.countCards("h"), zhu.maxHp - player.countCards("h"));
				})
				.set(
					"targets",
					(function () {
						var list = game
							.filterPlayer()
							.map(i => [i, i.countCards("h")])
							.sort((a, b) => b[1] - a[1]);
						var targets = [];
						var ind = 0,
							tmp = Infinity;
						for (var i of list) {
							if (i[1] < tmp) {
								ind++;
								tmp = i[1];
							}
							if (ind == N) {
								targets.push(i[0]);
							}
							if (ind > N) break;
						}
						if (!targets.length) targets = game.filterPlayer(i => i.countCards("h") == list[list.length - 1][1]);
						return targets;
					})()
				);
			"step 1";
			if (result.bool) {
				var target = result.targets[0];
				player.logSkill("dddshichao", target);
				var zhu = get.zhu(player) || game.filterPlayer(i => i.getSeatNum() == 1)[0];
				var del = Math.min(target.countCards("h") - player.countCards("h"), zhu.maxHp - player.countCards("h"));
				if (del > 0) player.draw(del);
				if (del < 0) player.chooseToDiscard(-del, true);
				target.addSkill("dddshichao_up");
				target.markAuto("dddshichao_up", [player]);
				player.addTempSkill("dddshichao_clear", {
					player: "phaseBegin",
				});
				player.markAuto("dddshichao_clear", [target]);
			}
		},
		subSkill: {
			up: {
				trigger: { source: "damageBegin2" },
				filter(event, player) {
					return player.getStorage("dddshichao_up").includes(event.player);
				},
				charlotte: true,
				check(event, player) {
					var eff = get.damageEffect(event.player, player, player);
					return (event.player.hasSkill("dddshichao") && eff < 0) || (event.num == 1 && eff < 13);
				},
				logTarget: "player",
				content() {
					"step 0";
					trigger.cancel();
					if (trigger.player.hasSkill("dddshichao")) {
						trigger.player.addMark("dddshichao", 1, false);
					}
				},
			},
			clear: {
				charlotte: true,
				onremove(player) {
					game.filterPlayer(current => {
						current.unmarkAuto("dddshichao_up", [player]);
					});
				},
			},
		},
	},
	//管宁
	dddyouxue: {
		audio: 2,
		trigger: { global: "roundStart" },
		forced: true,
		content() {
			"step 0";
			if (!game.hasPlayer(current => current.hasMark("dddyouxue"))) player.addMark("dddyouxue");
			if (!game.hasPlayer(current => !current.hasMark("dddyouxue"))) event.finish();
			"step 1";
			player
				.chooseTarget("游学：将“游学”标记交给另一名角色", true, (card, player, target) => {
					return !target.hasMark("dddyouxue");
				})
				.set("ai", target => {
					return get.distance(
						game.findPlayer(current => current.hasMark("dddyouxue")),
						target
					);
				});
			"step 2";
			if (result.bool) {
				var target = result.targets[0];
				var source = game.findPlayer(current => current.hasMark("dddyouxue"));
				if (source == player) player.line(target, "green");
				else player.line2([source, target], "green");
				source.clearMark("dddyouxue");
				target.addMark("dddyouxue");
				player.draw(get.distance(source, target));
			}
		},
		marktext: "游",
		intro: {
			name: "游学",
			content: () => get.translation(game.filterPlayer(current => current.hasSkill("dddyouxue"))) + "到此一游",
		},
	},
	dddchengjing: {
		audio: 2,
		trigger: { global: "phaseEnd" },
		filter(event, player) {
			if (!event.player.hasMark("dddyouxue")) return false;
			return event.player.hasHistory("useCard", evt => {
				if (!["basic", "trick"].includes(get.type(evt.card))) return false;
				if (!evt.card.isCard || evt.cards.length != 1) return false;
				return get.position(evt.cards[0], true) == "d";
			});
		},
		forced: true,
		locked: false,
		group: "dddchengjing_use",
		logTarget: "player",
		*content(event, map) {
			const player = map.player,
				trigger = map.trigger,
				target = trigger.player;
			let history = target.getHistory("useCard").reverse();
			let cards = [];
			for (var evt of history) {
				if (!["basic", "trick"].includes(get.type(evt.card))) continue;
				if (!evt.card.isCard || evt.cards.length != 1) continue;
				if (get.position(evt.cards[0], true) == "d") {
					cards.addArray(evt.cards);
					break;
				}
			}
			const jing = player.getExpansions("dddchengjing");
			if (jing.length) player.loseToDiscardpile(jing);
			player.addToExpansion(cards, "log", "gain2").gaintag.add("dddchengjing");
		},
		marktext: "经",
		intro: {
			name: "经(承经)",
			name2: "经",
			markcount: "expansion",
			content: "expansion",
		},
		subSkill: {
			use: {
				audio: "dddchengjing",
				enable: "phaseUse",
				usable: 1,
				filterCard: true,
				position: "hes",
				filter(event, player) {
					return player.getExpansions("dddchengjing").length > 0;
				},
				viewAs(cards, player) {
					const card = player.getExpansions("dddchengjing")[0];
					return new lib.element.VCard({
						name: get.name(card, false),
						nature: get.nature(card, false),
						storage: { dddchengjing: true },
					});
				},
				popname: true,
				prompt() {
					const card = get.player().getExpansions("dddchengjing")[0];
					return (
						"将一张牌当" +
						get.translation({
							name: get.name(card, false),
							nature: get.nature(card, false),
						}) +
						"使用"
					);
				},
				precontent() {
					player
						.when("useCardAfter")
						.filter(evt => evt.card.storage.dddchengjing)
						.then(() => {
							var cards = trigger.cards.filterInD("od");
							if (!cards.length) {
								event.finish();
								return;
							}
							var target = game.findPlayer(current => current.hasMark("dddyouxue"));
							if (!target) {
								event.finish();
								return;
							}
							target = target.getNext();
							event.target = target;
							player.chooseBool(`承经：是否将${get.translation(cards)}交给${get.translation(target)}？`).set("choice", get.attitude(player, target) > 0);
						})
						.then(() => {
							if (result.bool) {
								player.line(event.target);
								player.addExpose(0.1);
								event.target.gain(trigger.cards.filterInD("od"), "gain2");
							}
						});
				},
			},
		},
		ai: {
			combo: "dddyouxue",
		},
	},
	dddyouxue_old: {
		audio: 2,
		trigger: { global: "roundStart" },
		forced: true,
		content() {
			"step 0";
			var vpos = player.hasMark("dddyouxue_old") ? game.filterPlayer2(i => i.getSeatNum() == player.countMark("dddyouxue_old"))[0] : player;
			event.vpos = vpos;
			player
				.chooseTarget("游学：选择你的行动次序", true)
				.set("ai", target => {
					return get.distance(_status.event.vpos, target);
				})
				.set("vpos", vpos);
			"step 1";
			if (result.bool) {
				var target = result.targets[0];
				if (event.vpos == player) player.line(target, "green");
				else player.line2([event.vpos, target], "green");
				event.num = get.distance(event.vpos, target);
				player.storage["dddyouxue_old"] = target.getSeatNum();
				player.addSkill("dddyouxue_old_act");
				player.markSkill("dddyouxue_old");
			} else event.finish();
			"step 2";
			var next = player.phaseDraw();
			next.set("num", num);
			delete next.skill;
			"step 3";
			player.skip("phaseDraw");
		},
		marktext: "虚",
		intro: {
			name: "虚位",
			content: "当前虚位为#号",
		},
		subSkill: {
			act: {
				trigger: {
					global: ["phaseBefore", "phaseAfter", "phaseYouxueed"],
				},
				forced: true,
				firstDo: true,
				charlotte: true,
				filter(event, player, name) {
					if (event.skill) return false;
					var vseat = player.countMark("dddyouxue_old");
					if (name != "phaseBefore") {
						if (player.hasSkill("dddyouxue_old_acted", null, false, false)) return false;
						var seat = event.player.getSeatNum();
						var next = event.player.next;
						if (!game.players.includes(next)) next = game.findNext(next);
						var seat2 = next.getSeatNum();
						if (seat == seat2) return false;
						if (seat < seat2) return vseat > seat && vseat <= seat2;
						return seat2 >= vseat;
					} else {
						return event.player == player;
					}
				},
				content() {
					if (event.triggername == "phaseBefore") {
						trigger.finish();
						trigger.untrigger(true);
						trigger._triggered = 5;
						trigger.trigger("phaseYouxueed");
					} else {
						player.insertPhase("dddyouxue_old_act");
						player.addTempSkill("dddyouxue_old_acted", "roundStart");
					}
				},
			},
			acted: { charlotte: true },
		},
	},
	dddchengjing_old: {
		audio: 2,
		usable: 1,
		enable: "phaseUse",
		filter(event, player) {
			return player.countCards("hes") > 0 && player.countMark("dddyouxue_old") > 0 && lib.skill["dddchengjing_old"].getList(player).length > 0;
		},
		getList(player) {
			var vpos = player.hasMark("dddyouxue_old") ? game.filterPlayer2(i => i.getSeatNum() == player.countMark("dddyouxue_old"))[0] : player;
			if (!vpos || !vpos.isIn()) return [];
			var vcard = [];
			var history = vpos.getPrevious().actionHistory.filter(evt => !evt.custom.some(i => i["dddyouxue_old"]));
			history = history[history.length - 2];
			var evts = history.useCard;
			for (var evt of evts) {
				var card = evt.card;
				var type = get.type(card);
				if (type != "basic" && type != "trick") continue;
				if (card.name == "sha") {
					vcard.push(["基本", "", card.name, card.nature]);
				} else vcard.push([type, "", card.name]);
			}
			return vcard;
		},
		chooseButton: {
			dialog(event, player) {
				var list = lib.skill["dddchengjing_old"].getList(player);
				list.sort((a, b) => {
					return 100 * (lib.inpile.indexOf(a[2]) - lib.inpile.indexOf(b[2])) + lib.inpile_nature.indexOf(a[3]) - lib.inpile_nature.indexOf(b[3]);
				});
				list.filter(vcard => {
					return event.filterCard({ name: vcard[2], nature: vcard[3] }, player, event);
				});
				return ui.create.dialog("承经", [list, "vcard"]);
			},
			filter(button, player) {
				return _status.event.getParent().filterCard({ name: button.link[2] }, player, _status.event.getParent());
			},
			check(button) {
				if (_status.event.getParent().type != "phase") return 1;
				var player = _status.event.player;
				return player.getUseValue({
					name: button.link[2],
					nature: button.link[3],
				});
			},
			backup(links, player) {
				return {
					filterCard: true,
					audio: "dddchengjing_old",
					popname: true,
					check(card) {
						return 8 - get.value(card);
					},
					position: "hes",
					viewAs: {
						name: links[0][2],
						nature: links[0][3],
						storage: { dddchengjing_old: true },
					},
					precontent() {
						player.addTempSkill("dddchengjing_old_effect");
					},
				};
			},
			prompt(links, player) {
				return "将一张牌当做" + (get.translation(links[0][3]) || "") + get.translation(links[0][2]) + "使用";
			},
		},
		ai: {
			combo: "dddyouxue_old",
			order: 1,
			result: {
				player: 1,
			},
		},
		subSkill: {
			effect: {
				audio: "dddchengjing_old",
				trigger: { global: "useCardAfter" },
				charlotte: true,
				direct: true,
				filter(event, player) {
					return event.card && event.card.storage && event.card.storage["dddchengjing_old"];
				},
				content() {
					"step 0";
					var damaged = game.hasPlayer2(current => current.hasHistory("damage", evt => evt.card == trigger.card));
					event.damaged = damaged;
					var vpos = player.hasMark("dddyouxue_old") ? game.filterPlayer2(i => i.getSeatNum() == player.countMark("dddyouxue_old"))[0] : player;
					var target = vpos.getNext();
					event.target = target;
					player
						.chooseControl(" +1 ", " -1 ", "cancel2")
						.set("prompt", "是否令“虚位”下家(" + get.translation(target) + ")下回合的" + (damaged ? "摸牌数" : "手牌上限") + "+1或-1？")
						.set("ai", function () {
							var sgn = get.sgn(get.attitude(_status.event.player, _status.event.target));
							if (sgn == 0) return 2;
							if (sgn == 1) return 0;
							return 1;
						})
						.set("target", target);
					"step 1";
					if (result.index != 2) {
						player.logSkill("dddchengjing_old_effect", target);
						var name = (event.damaged ? "draw" : "limit") + result.index;
						target.addTempSkill("dddchengjing_old_check", {
							player: "phaseAfter",
						});
						target.addMark("dddchengjing_old_" + name, 1, false);
						game.log(target, "下回合的" + (event.damaged ? "摸牌数" : "手牌上限"), "#y" + ["+1", "-1"][result.index]);
					}
				},
			},
			check: {
				trigger: { player: "phaseDrawBegin2" },
				charlotte: true,
				forced: true,
				filter(event, player) {
					return player.countMark("dddchengjing_old_draw0") > 0 || player.countMark("dddchengjing_old_draw1") > 0;
				},
				content() {
					trigger.num += player.countMark("dddchengjing_old_draw0") - player.countMark("dddchengjing_old_draw1");
				},
				mod: {
					maxHandcard(player, num) {
						return num + player.countMark("dddchengjing_old_limit0") - player.countMark("dddchengjing_old_limit1");
					},
				},
				onremove(player) {
					delete player.storage["dddchengjing_old_draw0"];
					delete player.storage["dddchengjing_old_draw1"];
					delete player.storage["dddchengjing_old_limit0"];
					delete player.storage["dddchengjing_old_limit1"];
				},
				mark: true,
				marktext: "承",
				intro: {
					name: "承经",
					content(storage, player) {
						var str = "";
						if (player.countMark("dddchengjing_old_draw0") || player.countMark("dddchengjing_old_draw1")) {
							var num = player.countMark("dddchengjing_old_draw0") - player.countMark("dddchengjing_old_draw1");
							str += "<li>摸牌阶段摸牌数" + (num >= 0 ? "+" : "") + num;
						}
						if (player.countMark("dddchengjing_old_limit0") || player.countMark("dddchengjing_old_limit1")) {
							var num = player.countMark("dddchengjing_old_limit0") - player.countMark("dddchengjing_old_limit1");
							str += "<li>手牌上限" + (num >= 0 ? "+" : "") + num;
						}
						return str;
					},
				},
			},
			draw0: { charlotte: true },
			draw1: { charlotte: true },
			limit0: { charlotte: true },
			limit1: { charlotte: true },
		},
	},
	dddduanbing: {
		enable: "phaseUse",
		filter(event, player) {
			return player.canAddJudge("bingliang") && player.hasCard(card => lib.skill["dddduanbing"].filterCard(card, player), "he");
		},
		filterCard(card, player) {
			if (get.color(card) != "black" || get.type2(card) == "trick") return false;
			return player.canAddJudge(get.autoViewAs({ name: "bingliang" }, [card]));
		},
		check(card) {
			return 8.2 - get.value(card);
		},
		discard: false,
		lose: false,
		delay: false,
		prepare: "throw",
		group: "dddduanbing_effect",
		position: "he",
		content() {
			"step 0";
			player.addJudge({ name: "bingliang" }, cards);
			"step 1";
			game.delayx();
			player.draw(2);
			"step 2";
			player.chooseUseTarget(
				{
					name: "sha",
					isCard: true,
					storage: { _dddduanbing: true },
				},
				false,
				"nodistance"
			);
		},
		ai: {
			order(item, player) {
				return get.order({ name: "sha" }) - 0.1;
			},
			result: {
				player(player) {
					return player.getUseValue({ name: "sha" }, false);
				},
			},
		},
		subSkill: {
			effect: {
				trigger: { source: "damageSource" },
				charlotte: true,
				filter(event, player) {
					if (event.getParent().type != "card" || !event.player.isIn()) return false;
					return player.hasCard(card => {
						return (card.viewAs || card.name) == "bingliang" && event.player.canAddJudge(card);
					}, "j");
				},
				prompt: event => "是否将【兵粮寸断】转移给" + get.translation(event.player) + "？",
				check(event, player) {
					return player.hasCard(card => {
						return (
							(card.viewAs || card.name) == "bingliang" &&
							event.player.canAddJudge(card) &&
							get.effect(
								event.player,
								new lib.element.VCard({
									name: "bingliang",
									cards: [card],
								}),
								player,
								_status.event.player
							) >= 0
						);
					}, "j");
				},
				content() {
					var cards = player.getCards("j", card => {
						return (card.viewAs || card.name) == "bingliang" && trigger.player.canAddJudge(card);
					});
					var target = trigger.player;
					player.line(target);
					player.$give(cards, target, false);
					cards.forEach(card => {
						target.addJudge({ name: "bingliang" }, card);
					});
				},
			},
		},
	},
	//轲比能
	dddxiaoxing: {
		audio: 2,
		trigger: { global: "gameDrawBegin" },
		forced: true,
		group: "dddxiaoxing_remove",
		init(player, skill) {
			if (game.online) return;
			var bool = get.event().getParent("phaseLoop", true);
			if (!bool) return;
			if (player.hasSkill(skill)) {
				player.logSkill("dddxiaoxing");
				player.draw(3);
			}
		},
		content() {
			var me = player;
			var numx = trigger.num;
			trigger.num =
				typeof numx == "function"
					? function (player) {
							if (player == me) {
								return 3 + numx(player);
							}
							return numx(player);
						}
					: function (player) {
							if (player == me) {
								return 3 + numx;
							}
							return numx;
						};
		},
		mod: {
			attackRange: (player, num) => num + 3,
			maxHandcard: (player, num) => num + 3,
		},
		subSkill: {
			remove: {
				trigger: { player: "dying" },
				forced: true,
				// direct:true,
				// filter(event,player){
				// 	return event.source&&event.source.isIn()&&event.source.getEquips(1).length>0;
				// },
				content() {
					player.removeSkills("dddxiaoxing");
				},
				content_old() {
					"step 0";
					trigger.source
						.chooseBool(get.prompt("dddxiaoxing", player), "废除武器栏，令其失去〖枭行〗")
						.set("ai", () => {
							if (_status.event.maybe) return Math.random() < 0.5;
							return false;
						})
						.set(
							"maybe",
							player.countCards("hs", {
								name: ["tao", "jiu"],
							}) && player.countCards("h") >= 3
						);
					"step 1";
					if (result.bool) {
						trigger.source.logSkill("dddxiaoxing", player);
						trigger.source.disableEquip(1);
						player.removeSkills("dddxiaoxing");
					}
				},
			},
		},
	},
	dddlangzhi: {
		audio: 2,
		trigger: { player: "phaseJieshuBegin" },
		logTarget(event, player) {
			return game.filterPlayer(current => player.inRange(current) && current.countCards("he"));
		},
		prompt: "是否发动【狼志】？",
		prompt2(event, player) {
			return `展示${get.translation(game.filterPlayer(current => player.inRange(current) && current.countCards("he")))}的各一张牌，然后选择一项：1.用任意张牌替换其中等量张牌；2.获得所有展示牌，失去〖狼志〗。`;
		},
		content() {
			"step 0";
			event.targets = game.filterPlayer(current => player.inRange(current) && current.countCards("he"));
			event.cards = [];
			event.num = 0;
			"step 1";
			var target = targets[num];
			event.num++;
			event.target = target;
			player.choosePlayerCard("狼志：展示" + get.translation(target) + "一张牌", "he", target, true);
			"step 2";
			if (result.bool) {
				var card = result.links[0];
				player.showCards(card, get.translation(target) + "被展示");
				event.cards.push(card);
			}
			"step 3";
			if (num < targets.length) event.goto(1);
			else {
				event.videoId = lib.status.videoId++;
				if (event.isMine()) {
					event.dialog = ui.create.dialog('###是否替换其中的任意张牌？###<div class="text center">或点击“取消”，获得所有展示牌，然后失去〖狼志〗</div>', cards);
					event.dialog.videoId = event.videoId;
				} else if (player.isOnline2()) {
					player.send(
						function (cards, id) {
							var dialog = ui.create.dialog('###是否替换其中的任意张牌？###<div class="text center">或点击“取消”，获得所有展示牌，然后失去〖狼志〗</div>', cards);
							dialog.videoId = id;
						},
						cards,
						event.videoId
					);
				}
				player
					.chooseCard([1, cards.length], "he")
					.set("ai", card => {
						if (ui.selected.cards.length >= _status.event.num) return 0;
						return 100 - get.value(card);
					})
					.set(
						"num",
						(function () {
							if (cards.length < Math.floor(game.countPlayer() / 2 - 0.5)) return 0;
							var val = cards.reduce((p, c) => p + get.value(c), 0);
							if (val < cards.length * 6) return 0;
							var list1 = player.getCards("he").map(card => get.value(card, player)),
								list2 = cards.map((card, i) => get.value(card, targets[i]) * get.sgnAttitude(player, targets[i]));
							list1.sort((a, b) => a[1] - b[1]);
							list2.sort((a, b) => b[1] - a[1]);
							list2 = list2.filter(i => i > 0);
							var count = 0;
							for (var i of list2) {
								for (var j = 0; j < list1.length; j++) {
									if (i > list1[j]) {
										count++;
										list1.splice(j, 1);
										break;
									}
								}
							}
							return count;
						})()
					)
					.set("prompt", false);
			}
			"step 4";
			if (result.bool) {
				var cards2 = result.cards;
				event.cards2 = cards2;
				var func = function (id) {
					var dialog = get.idDialog(id);
					if (dialog) dialog.content.childNodes[1].innerHTML = '<div class="text center">选择要交换的牌（按选择的顺序一一交换）</div>';
				};
				if (event.isMine()) func(event.videoId);
				else if (player.isOnline2()) player.send(func, event.videoId);
				player
					.chooseButton(cards2.length, true)
					.set("dialog", event.videoId)
					.set("ai", button => {
						return get.value(button.link);
					});
				event.goto(6);
			} else {
				for (var i = 0; i < cards.length; i++) {
					targets[i].$give(cards[i], player, false);
				}
				player.gain(cards, "log");
			}
			"step 5";
			player.removeSkills("dddlangzhi");
			event.finish();
			"step 6";
			game.broadcastAll("closeDialog", event.videoId);
			if (result.bool) {
				var cards2 = event.cards2,
					cards3 = result.links;
				if (cards2.length != cards3.length) return;
				for (var i = 0; i < cards2.length; i++) {
					player.swapHandcards(get.owner(cards3[i]), [cards2[i]], [cards3[i]]);
				}
			} else event.finish();
			"step 7";
			game.delayx();
		},
	},
	dddfuyi: {
		audio: 2,
		zhuSkill: true,
		trigger: {
			// global:['discardBegin','drawBegin'],
			global: "dieAfter",
		},
		filter(event, player) {
			if (!event.source || !event.source.isIn() || event.source.group != "qun") return false;
			if (!event.source.countCards("he") < 2) return false;
			if (!player.hasZhuSkill("dddfuyi", event.source)) return false;
			const skills = player.getStockSkills(true, true).filter(skill => {
				return !player.hasSkill(skill, null, false, false);
			});
			return skills.length > 0;
		},
		filter_old(event, player) {
			var evt = event.getParent();
			if (evt.name != "die" || evt.source != event.player || event.player == player) return false;
			if (!player.hasZhuSkill("dddfuyi", event.player)) return false;
			var skills = player.getSkills("dddxiaoxing", null, false, false);
			return !skills.includes("dddxiaoxing") || !skills.includes("dddlangzhi");
		},
		direct: true,
		global: "dddfuyi_sha",
		content() {
			"step 0";
			trigger.source.chooseCard("是否响应" + get.translation(player) + "的【附义】？", "弃置两张牌，令其获得其武将牌上的一个技能", "he", 2, lib.filter.cardDiscardable).set("ai", () => {
				let zhu = _status.event.getParent().player;
				if (!zhu.getStockSkills(true, true).some(skill => {
					return !zhu.hasSkill(skill, null, false, false);
				}) || get.attitude(_status.event.player, zhu) <= 2) return 0;
				return 6 - get.value(card);
			});
			"step 1";
			if (result.bool) {
				player.logSkill("dddfuyi", trigger.source);
				trigger.source.discard(result.cards).discarder = trigger.source;
				var skills = player.getStockSkills(true, true).filter(skill => {
					return !player.hasSkill(skill, null, false, false);
				});
				if (skills.length == 1) event._result = { control: skills[0] };
				else if (!skills.length) event.finish();
				else
					trigger.source
						.chooseControl(skills)
						.set(
							"choiceList",
							skills.map(skill => {
								return '<div class="skill">【' + get.translation(lib.translate[skill + "_ab"] || get.translation(skill).slice(0, 2)) + "】</div><div>" + get.skillInfoTranslation(skill, player) + "</div>";
							})
						)
						.set("displayIndex", false)
						.set("prompt", `附义：选择令${get.translation(player)}获得一个技能`)
						.set("ai", () => {
							var controls = get.event("controls");
							if (controls.includes("dddxiaoxing")) return "dddxiaoxing";
							return controls.sort((a, b) => {
								return get.skillrank(b, "inout") - get.skillrank(a, "inout");
							})[0];
						});
			} else event.finish();
			"step 2";
			var skill = result.control;
			player.addSkills(skill);
		},
		content_old() {
			"step 0";
			var str = "取消此次奖惩，令其获得";
			var skills = player.getSkills("dddxiaoxing", null, false, false);
			var bool1 = !skills.includes("dddxiaoxing"),
				bool2 = !skills.includes("dddlangzhi");
			var choices = [];
			if (bool1) {
				str += "〖枭行〗";
				choices.push("dddxiaoxing");
			}
			if (bool1 && bool2) str += "/";
			if (bool2) {
				str += "〖狼志〗";
				choices.push("dddlangzhi");
			}
			if (bool1 && bool2) {
				str += "中的一或两个";
				choices.push("dddfuyi_both");
			}
			choices.push("cancel2");
			trigger.player
				.chooseControl(choices)
				.set("prompt", "是否对" + get.translation(player) + "发动【附义】？")
				.set("prompt2", str)
				.set("ai", () => {
					if (get.attitude(_status.event.player, _status.event.getParent().player) <= 2) return "cancel2";
					if (_status.event.choices.includes("dddfuyi_both")) return "dddfuyi_both";
					if (_status.event.choices.includes("dddlangzhi")) return "dddlangzhi";
					return Math.random() < 0.5 ? "dddxiaoxing" : "cancel2";
				});
			"step 1";
			if (result.control != "cancel2") {
				trigger.player.logSkill("dddfuyi", player);
				trigger.cancel();
				var skills = [result.control];
				if (result.control == "dddfuyi_both") {
					skills = ["dddxiaoxing", "dddlangzhi"];
					player.draw(3);
				} else event.finish();
				player.addSkills(skills);
			} else event.finish();
			"step 2";
			player.removeSkills("dddfuyi");
		},
		subSkill: {
			sha: {
				mod: {
					cardUsable(card, player, num) {
						if (card.name == "sha") {
							if (player.group != "qun") return;
							return (
								num +
								game.countPlayer(current => {
									return current.hasZhuSkill("dddfuyi", player);
								})
							);
						}
					},
				},
			},
		},
	},
	//曹爽
	dddzhuanshe: {
		audio: 2,
		trigger: { global: "phaseUseBegin" },
		filter(event, player) {
			return player.countCards("h") > 0 && event.player != player;
		},
		direct: true,
		content() {
			"step 0";
			player
				.chooseCard(get.prompt2("dddzhuanshe", trigger.player))
				.set("ai", card => {
					var target = _status.event.getTrigger().player;
					if (!_status.event.goon) {
						if (get.value(card) < 4) return -target.getUseValue(card) + 0.001;
						return 0;
					}
					return target.getUseValue(card);
				})
				.set("goon", get.attitude(player, trigger.player));
			"step 1";
			if (result.bool) {
				var card = result.cards[0];
				player.logSkill("dddzhuanshe", trigger.player);
				player.give(card, trigger.player, true);
				player.addTempSkill("dddzhuanshe_effect");
				player.markAuto("dddzhuanshe_effect", [card.name]);
			}
		},
		subSkill: {
			effect: {
				audio: "dddzhuanshe",
				trigger: { global: "useCard2" },
				filter(event, player) {
					if (!player.getStorage("dddzhuanshe_effect").includes(event.card.name)) return false;
					if (event.player != _status.currentPhase) return false;
					var type = get.type(event.card, null, false);
					if (type != "basic" && type != "trick") return false;
					var info = get.info(event.card);
					if (info.allowMultiple == false) return false;
					if (event.targets && !info.multitarget) {
						if (
							game.hasPlayer(function (current) {
								return !event.targets.includes(current) && lib.filter.targetEnabled2(event.card, event.player, current);
							})
						) {
							return true;
						}
					}
					return false;
				},
				direct: true,
				group: "dddzhuanshe_damage",
				charlotte: true,
				onremove: true,
				content() {
					"step 0";
					var prompt2 = "为" + get.translation(trigger.card) + "增加一个目标";
					player
						.chooseTarget(get.prompt("dddzhuanshe_effect"), function (card, player, target) {
							var player = _status.event.source;
							return !_status.event.targets.includes(target) && lib.filter.targetEnabled2(_status.event.card, player, target);
						})
						.set("prompt2", prompt2)
						.set("ai", function (target) {
							var trigger = _status.event.getTrigger();
							var player = _status.event.source;
							return get.effect(target, trigger.card, player, _status.event.player);
						})
						.set("targets", trigger.targets)
						.set("card", trigger.card)
						.set("source", trigger.player);
					"step 1";
					if (result.bool) {
						if (!event.isMine() && !event.isOnline()) game.delayx();
						event.targets = result.targets;
					} else {
						event.finish();
					}
					"step 2";
					if (event.targets) {
						player.logSkill(event.name, event.targets);
						trigger.targets.addArray(event.targets);
						game.log(event.targets, "也成为了", trigger.card, "的目标");
					}
				},
			},
			damage: {
				audio: "dddzhuanshe",
				trigger: { global: "phaseEnd" },
				filter(event, player) {
					var list = player.getStorage("dddzhuanshe_effect").slice();
					event.player.getHistory("useCard", evt => {
						list.remove(evt.card.name);
					});
					return list.length;
				},
				charlotte: true,
				logTarget: "player",
				prompt2: "对其造成1点伤害",
				check(event, player) {
					return get.damageEffect(event.player, player, player) >= 0;
				},
				content() {
					trigger.player.damage(player);
				},
			},
		},
	},
	dddweiqiu: {
		audio: 2,
		trigger: { global: "recoverBefore" },
		filter(event, player) {
			return !player.countCards("h");
		},
		forced: true,
		direct: true,
		content() {
			trigger.player.logSkill("dddweiqiu", player);
			trigger.cancel();
			player.draw();
		},
	},
	//薛灵芸
	dddlianer: {
		audio: 2,
		trigger: { player: "useCardAfter" },
		filter(event, player) {
			return event.cards.filterInD("od").length > 0 && get.color(event.card) == "red";
		},
		content() {
			"step 0";
			var cards = trigger.cards.filterInD("od");
			event.cards = cards;
			player.gain(cards, "gain2");
			"step 1";
			var number = get.number(cards[0]);
			if (cards.length == 1 && typeof number == "number") {
				player.addTempSkill("dddlianer_ceiling");
				player.storage["dddlianer_ceiling"] = number;
			}
		},
		mod: {
			aiOrder(player, card, num) {
				if (get.itemtype(card) == "card" && get.color(card) == "red") {
					if (!player.storage["dddlianer_ceiling"]) return;
					var numx = get.number(card);
					if (typeof numx == "number") {
						return num + 10 / Math.max(1, player.storage["dddlianer_ceiling"] - numx);
					}
				}
			},
		},
		subSkill: {
			ceiling: {
				onremove: true,
				charlotte: true,
				mod: {
					cardEnabled(card, player) {
						if (!player.storage["dddlianer_ceiling"]) return;
						var num = get.number(card);
						if (num != "unsure" && (typeof num != "number" || player.storage["dddlianer_ceiling"] <= num)) return false;
					},
					cardRespondable(card, player) {
						if (!player.storage["dddlianer_ceiling"]) return;
						var num = get.number(card);
						if (num != "unsure" && (typeof num != "number" || player.storage["dddlianer_ceiling"] <= num)) return false;
					},
					cardSavable(card, player) {
						if (!player.storage["dddlianer_ceiling"]) return;
						var num = get.number(card);
						if (num != "unsure" && (typeof num != "number" || player.storage["dddlianer_ceiling"] <= num)) return false;
					},
				},
			},
		},
	},
	dddanzhi: {
		audio: 2,
		trigger: { global: "phaseBegin" },
		filter(event, player) {
			var evts = game.getAllGlobalHistory("everything", evt => ["useCard", "respond"].includes(evt.name));
			if (!evts.length) return false;
			const color = get.color(evts.lastItem.card, false);
			return color == "black";
		},
		direct: true,
		content() {
			"step 0";
			player.chooseTarget(get.prompt("dddanzhi"), "选择一名角色，此回合其第一次成为黑色牌的目标时，此牌对其无效").set("ai", target => {
				return get.attitude(_status.event.player, target);
			});
			"step 1";
			if (result.bool) {
				var target = result.targets[0];
				player.logSkill("dddanzhi", target);
				target.addTempSkill("dddanzhi_effect");
			}
		},
		subSkill: {
			effect: {
				trigger: { target: "useCardToTarget" },
				filter(event, player) {
					return get.color(event.card) == "black";
				},
				forced: true,
				charlotte: true,
				content() {
					trigger.targets.remove(player);
					trigger.getParent().triggeredTargets2.remove(player);
					trigger.untrigger();
					game.log(trigger.card, "对", player, "无效了");
					game.delayx();
					player.removeSkill("dddanzhi_effect");
				},
			},
		},
	},
	//刘宏
	dddshixing: {
		audio: 2,
		trigger: {
			global: ["changeHp", "useCard1", "phaseBefore"],
		},
		forced: true,
		onremove: true,
		filter(event, player) {
			var num = player.countMark("dddshixing");
			if (event.name == "changeHp") {
				if (event.player.hasSex("female")) {
					var bool = !event.player.isDamaged();
					if ((bool && (num & 1) == 0) || (!bool && (num & 1) == 1)) {
						return true;
					}
				}
				return false;
			}
			if (event.name == "useCard") {
				var bool = game.getGlobalHistory("useCard", evt => get.type2(evt.card) == "trick").length == 0;
				if ((bool && (num & 2) == 0) || (!bool && (num & 2) == 2)) {
					return true;
				}
				return false;
			}
			return true;
		},
		content() {
			lib.skill["dddshixing"].applyChange(player);
		},
		applyChange(player) {
			player.removeAdditionalSkill("dddshixing");
			var bool1 = game.hasPlayer(current => !current.isDamaged() && current.hasSex("female")),
				bool2 = game.getGlobalHistory("useCard", evt => get.type2(evt.card) == "trick").length == 0;
			player.storage["dddshixing"] = bool1 + 2 * bool2;
			var list = [];
			if (bool1) list.push("xiangle");
			if (bool2) list.push("jiushi");
			if (!bool1 && !bool2) list.push("rezhiheng");
			player.addAdditionalSkill("dddshixing", list);
		},
		derivation: ["xiangle", "jiushi", "rezhiheng"],
	},
	ddddanggu: {
		audio: 2,
		trigger: { player: "phaseJieshuBegin" },
		filter(event, player) {
			return game.countPlayer(current => current.isLinked()) < game.countPlayer(current => current.group == "qun");
		},
		forced: true,
		group: "ddddanggu_negative",
		content() {
			"step 0";
			if (!event.loop) event.loop = 0;
			var num = game.countPlayer(current => current.group == "qun") - game.countPlayer(current => current.isLinked());
			player
				.chooseTarget("党锢：横置至少" + get.cnNumber(num) + "名角色", [num, Infinity], true, (card, player, target) => {
					return !target.isLinked();
				})
				.set("ai", target => {
					return get.effect(target, { name: "tiesuo" }, _status.event.player);
				});
			"step 1";
			if (result.bool) {
				var targets = result.targets.sortBySeat();
				player.logSkill("ddddanggu", targets);
				targets.forEach(i => i.link());
			}
		},
		discard() {
			"step 0";
			game.log(player, "进入了弃牌阶段");
			event.num = Math.max(0, player.countCards("he", card => !player.canIgnoreHandcard(card)) - player.getHandcardLimit());
			if (event.num <= 0) event.finish();
			else {
				if (lib.config.show_phase_prompt) {
					player.popup("弃牌阶段");
				}
			}
			event.trigger("phaseDiscard");
			"step 1";
			player.chooseToDiscard(num, true, "he");
			"step 2";
			event.cards = result.cards;
		},
		subSkill: {
			negative: {
				trigger: { global: "phaseDiscardBegin" },
				filter(event, player) {
					return event.player != player && event.player.isLinked();
				},
				forced: true,
				logTarget: "player",
				content() {
					trigger.setContent(lib.skill["ddddanggu"].discard);
				},
			},
		},
	},
	dddfuzong: {
		audio: 2,
		zhuSkill: true,
		trigger: {
			global: "phaseBefore",
			player: "enterGame",
		},
		forced: true,
		filter(event, player) {
			if (!player.hasZhuSkill("dddfuzong")) return false;
			return event.name != "phase" || game.phaseNumber == 0;
		},
		group: "dddfuzong_discard",
		content() {
			player.draw(
				game.countPlayer(current => {
					return current.group == "qun";
				})
			);
		},
		subSkill: {
			discard: {
				trigger: { global: "die" },
				filter(event, player) {
					if (!player.hasZhuSkill("dddfuzong")) return false;
					return event.player.group == "qun";
				},
				zhuSkill: true,
				forced: true,
				logTarget: "player",
				content() {
					trigger.player.discardPlayerCard(player, "he", true).set("forceDie", true);
				},
			},
		},
	},
	//夏侯玄
	dddlanghuai: {
		audio: 2,
		trigger: { player: "phaseDrawBegin1" },
		zhuanhuanji: true,
		direct: true,
		content() {
			"step 0";
			if (player.hasMark("dddxuanlun_del")) event._result = { bool: true };
			else
				player
					.chooseBool(get.prompt("dddlanghuai"), "展示手牌（无牌则不展示），并改为摸其中" + (!player.storage["dddlanghuai"] ? "包含" : "缺少") + "花色数的牌")
					.set("ai", () => _status.event.bool)
					.set(
						"bool",
						(function () {
							var list = [],
								cards = player.getCards("h");
							for (var i of cards) {
								var suit = get.suit(i, player);
								if (!lib.suit.includes(suit)) continue;
								list.add(suit);
							}
							if (player.storage["dddlanghuai"]) {
								list = list.removeArray(lib.suit);
							}
							return (list.length == 2 && !player.storage["dddlanghuai"]) || list.length > 2;
						})()
					);
			"step 1";
			if (result.bool) {
				player.logSkill("dddlanghuai");
				delete player.storage["dddxuanlun_del"];
				if (player.countCards("h")) player.showHandcards();
			} else event.finish();
			"step 2";
			var list = [],
				cards = player.getCards("h");
			for (var i of cards) {
				var suit = get.suit(i, player);
				if (!lib.suit.includes(suit)) continue;
				list.add(suit);
			}
			if (player.storage["dddlanghuai"]) {
				list = lib.suit.slice().removeArray(list);
			}
			player.changeZhuanhuanji("dddlanghuai");
			trigger.changeToZero();
			if (list.length) player.draw(list.length);
		},
		mark: true,
		intro: {
			content(storage, player) {
				return "摸牌阶段，你可展示手牌（无牌则不展示），并改为摸其中" + (!storage ? "包含" : "缺少") + "花色数的牌。";
			},
		},
		marktext: "☯",
	},
	dddxuanlun: {
		audio: 2,
		trigger: { player: "damageEnd" },
		content() {
			player.draw(4);
			player.addTempSkill("dddxuanlun_choose");
		},
		ai: {
			maixie: true,
			maixie_hp: true,
			result: {
				effect(card, player, target) {
					if (get.tag(card, "damage")) {
						if (player.hasSkillTag("jueqing", false, target)) return [1, -2];
						if (!target.hasFriend()) return;
						var num = 1;
						if (get.attitude(player, target) > 0) {
							if (player.needsToDiscard()) num = 0.7;
							else num = 0.5;
						}
						if (target.hp >= 4) return [1, num * 2.5];
						if (target.hp == 3) return [1, num * 1.5];
						if (target.hp == 2) return [1, num * 0.5];
					}
				},
			},
			threaten: 0.6,
		},
		subSkill: {
			choose: {
				trigger: { global: "phaseEnd" },
				forced: true,
				charlotte: true,
				filter(event, player) {
					if (player.hasMark("dddxuanlun_del") && !player.countCards("h")) return false;
					return true;
				},
				content() {
					"step 0";
					var choices = [];
					var choiceList = ["将四张牌以任意顺序置于牌堆顶或底", "删去此项和〖朗怀〗中的“可”，直到你发动〖朗怀〗"];
					if (player.countCards("he") >= 4 || player.hasMark("dddxuanlun_del")) choices.push("选项一");
					else choiceList[0] = '<span style="opacity:0.5; ">' + choiceList[0] + "</span>";
					if (!player.hasMark("dddxuanlun_del")) choices.push("选项二");
					else choiceList[1] = '<span style="opacity:0.5; text-decoration:line-through; ">' + choiceList[1] + "</span>";
					if (choices.length == 1 && choices[0] == "选项一") event._result = { control: "选项一" };
					else
						player
							.chooseControl(choices)
							.set("choiceList", choiceList)
							.set("ai", () => {
								if (!_status.event.controls.includes("选项一")) return 1;
								if (!_status.event.controls.includes("选项二")) return 0;
								var player = _status.event.player;
								var num = 0;
								for (var card of player.getCards("he")) {
									if (get.value(card, player) <= 5) num++;
									if (num >= 4) break;
								}
								return num >= 4 ? 0 : 1;
							});
					"step 1";
					game.log(player, "选择了", "#y" + result.control);
					if (result.control == "选项一") {
						var cards = player.getCards("he");
						if (cards.length <= 4)
							event._result = {
								bool: true,
								cards: cards,
							};
						else player.chooseCard("玄论：将四张牌置于牌堆顶或牌堆底", "he", true, 4);
					} else {
						player.addMark("dddxuanlun_del", 1, false);
						event.finish();
					}
					"step 2";
					if (result.bool) {
						var cards = result.cards;
						event.cards = cards;
						player
							.chooseToMove()
							.set("list", [["牌堆顶", cards], ["牌堆底"]])
							.set("prompt", "玄论：将这些牌置于牌堆顶或牌堆底")
							.set("processAI", function (list) {
								var cards = list[0][1],
									player = _status.event.player;
								var target = _status.currentPhase.next;
								var att = get.sgn(get.attitude(player, target));
								var top = [];
								var judges = target.getCards("j");
								var stopped = false;
								if (player != target || !target.hasWuxie()) {
									for (var i = 0; i < judges.length; i++) {
										var judge = get.judge(judges[i]);
										cards.sort(function (a, b) {
											return (judge(b) - judge(a)) * att;
										});
										if (judge(cards[0]) * att < 0) {
											stopped = true;
											break;
										} else {
											top.unshift(cards.shift());
										}
									}
								}
								var bottom;
								if (!stopped) {
									cards.sort(function (a, b) {
										return (get.value(b, player) - get.value(a, player)) * att;
									});
									while (cards.length) {
										if (get.value(cards[0], player) <= 5 == att > 0) break;
										top.unshift(cards.shift());
									}
								}
								bottom = cards;
								return [top, bottom];
							});
					} else event.finish();
					"step 3";
					if (result.bool) {
						var top = result.moved[0];
						var bottom = result.moved[1];
						top.reverse();
						player.popup(get.cnNumber(top.length) + "上" + get.cnNumber(bottom.length) + "下");
						var cards = top.addArray(bottom);
						player.$throw(cards.length, 1000);
						player.lose(cards, ui.cardPile).set("top", top).insert_index = function (event, card) {
							if (event.top.includes(card)) return ui.cardPile.firstChild;
							return null;
						};
					}
				},
			},
		},
	},
	//张闿
	dddjiexing: {
		audio: 2,
		trigger: {
			global: ["recoverBegin", "useCard"],
		},
		filter(event, player) {
			if (event.player == player) return false;
			if (event.name == "recover") return player.isDamaged();
			return get.type(event.card, false) == "equip" && event.cards.some(i => get.position(i, true) == "o" && player.canEquip(i, true));
		},
		limited: true,
		skillAnimation: true,
		animationColor: "legend",
		logTarget: "player",
		check(event, player) {
			if (get.attitude(player, event.player) >= 0) return false;
			if (event.name == "recover") return get.recoverEffect(event.player, player, player) < get.recoverEffect(player, player, player);
			return get.effect(event.targets[0], event.card, player, player) < get.effect(player, event.card, player, player);
		},
		content() {
			player.awakenSkill("dddjiexing");
			player.addSkill("dddjiexing_reset");
			if (trigger.name == "recover") {
				trigger.cancel();
				player.recover(trigger.num);
			} else {
				trigger.all_excluded = true;
				trigger.targets.length = 0;
				var cards = trigger.cards.filterInD();
				for (var i of cards) {
					if (player.canEquip(i, true)) player.equip(i);
				}
			}
		},
		subSkill: {
			reset: {
				audio: "dddjiexing",
				trigger: { player: ["recoverAfter", "useCardAfter"] },
				filter(event, player) {
					if (event.getParent().name == "dddjiexing") return false;
					if (event.name == "useCard") return get.type(event.card, false) == "equip";
					return true;
				},
				forced: true,
				charlotte: true,
				content() {
					player.restoreSkill("dddjiexing");
					player.removeSkill("dddjiexing_reset");
				},
			},
		},
	},
	dddbailei: {
		audio: 2,
		trigger: { player: "phaseZhunbeiBegin" },
		filter(event, player) {
			return game.hasPlayer(current => current.isMaxEquip(true) && current.countGainableCards(player, "he")) || game.hasPlayer(current => current.getHp() == 1);
		},
		direct: true,
		content() {
			"step 0";
			player
				.chooseTarget(get.prompt2("dddbailei"), (card, player, target) => {
					return (target.isMaxEquip(true) && target.countGainableCards(player, "he")) || target.getHp() == 1;
				})
				.set("ai", target => {
					var att = get.attitude(_status.event.player, target);
					if (att >= 3) return false;
					if (target.hp == 1) return 100;
					return 1;
				});
			"step 1";
			if (result.bool) {
				var target = result.targets[0];
				event.target = target;
				player.logSkill("dddbailei", target);
				if (target.isMaxEquip(true) && target.hp == 1) {
					if (target.countGainableCards(player, "he")) {
						player.gainPlayerCard("拜泪：获得" + get.translation(target) + "一张牌，或点击“取消”对其造成1点伤害", "he", target);
					} else event._result = { bool: false };
				} else if (target.isMaxEquip(true)) player.gainPlayerCard("拜泪：获得" + get.translation(target) + "一张牌", "he", target, true);
				else {
					event._result = { bool: false };
				}
			} else event.finish();
			"step 2";
			if (!result.bool) {
				player.line(target);
				// player.trySkillAnimate('dddbailei_animate','dddbailei_animate',player.checkShow('dddbailei'));
				target.damage();
				game.delayx();
			} else event.finish();
			"step 3";
			if (target.isIn()) {
				event.finish();
				return;
			}
			player.removeSkills("dddbailei");
		},
		subSkill: {
			animate: {
				skillAnimation: true,
				animationColor: "fire",
			},
		},
	},
};

export default skills;