Merge pull request #1278 from copcap/dev

新增「关樾」；武将修改；原画补充

character/huicui.js

@@ -4366,66 +4366,56 @@ game.import("character", function () {
 			//裴元绍
 			dcmoyu: {
 				audio: 2,
-				init: () => {
+				init() {
 					game.addGlobalSkill("dcmoyu_ai");
 				},
-				onremove: () => {
+				onremove() {
-					if (!game.hasPlayer((i) => i.hasSkill("dcmoyu"), true))
+					if (!game.hasPlayer(i => i.hasSkill("dcmoyu"), true)) game.removeGlobalSkill("dcmoyu_ai");
-						game.removeGlobalSkill("dcmoyu_ai");
 				},
 				enable: "phaseUse",
-				filter: function (event, player) {
+				filter(event, player) {
-					return (
+					return game.hasPlayer((current) => lib.skill.dcmoyu.filterTarget(null, player, current));
-						!player.hasSkill("dcmoyu_ban") &&
-						game.hasPlayer((current) => lib.skill.dcmoyu.filterTarget(null, player, current))
-					);
 				},
-				filterTarget: function (card, player, target) {
+				filterTarget(card, player, target) {
-					return (
+					return player != target && !player.getStorage("dcmoyu_clear").includes(target) && target.countGainableCards(player, "hej");
-						player != target &&
-						!player.getStorage("dcmoyu_clear").includes(target) &&
-						target.countGainableCards(player, "hej")
-					);
 				},
-				content: function () {
+				async content(event, trigger, player) {
-					"step 0";
+					const target = event.target;
 					player.addTempSkill("dcmoyu_clear");
 					player.markAuto("dcmoyu_clear", [target]);
-					player.gainPlayerCard(target, "hej", true);
+					await player.gainPlayerCard(target, "hej", true, 1 + player.hasSkill("dcmoyu_add"));
-					"step 1";
+					player.removeSkill("dcmoyu_add");
-					var num = player.getStorage("dcmoyu_clear").length;
+					const num = player.getStorage("dcmoyu_clear").length;
-					target
+					const result = await target
-						.chooseToUse(function (card, player, event) {
+						.chooseToUse(
-							if (get.name(card) != "sha") return false;
+							function (card, player, event) {
-							return lib.filter.filterCard.apply(this, arguments);
+								if (get.name(card) != "sha") return false;
-						}, "是否对" +
+								return lib.filter.filterCard.apply(this, arguments);
-							get.translation(player) +
+							},
-							"使用一张无距离限制的【杀】（伤害基数为" +
+							"是否对" + get.translation(player) + "使用一张无距离限制的【杀】？"
-							num +
+						)
-							"）？")
 						.set("targetRequired", true)
 						.set("complexSelect", true)
 						.set("filterTarget", function (card, player, target) {
-							if (
+							if (target != _status.event.sourcex && !ui.selected.targets.includes(_status.event.sourcex)) return false;
-								target != _status.event.sourcex &&
-								!ui.selected.targets.includes(_status.event.sourcex)
-							)
-								return false;
 							return lib.filter.targetEnabled.apply(this, arguments);
 						})
 						.set("sourcex", player)
 						.set("num", num)
-						.set("oncard", (card) => {
+						.set("oncard", card => {
 							_status.event.baseDamage = _status.event.getParent().num;
-						});
+						})
-					"step 2";
+						.forResult();
 					if (result.bool) {
 						if (
-							player.hasHistory("damage", (evt) => {
+							player.hasHistory("damage", evt => {
 								return evt.card && evt.card.name == "sha" && evt.getParent(4) == event;
 							})
-						)
+						) {
-							player.addTempSkill("dcmoyu_ban");
+							player.tempBanSkill("dcmoyu");
+						} else {
+							player.addTempSkill("dcmoyu_add", "phaseChange");
+						}
 					}
 				},
 				subSkill: {
@@ -4439,6 +4429,12 @@ game.import("character", function () {
 						marktext: "欲",
 						intro: { content: "偷马贼被反打了！" },
 					},
+					add: {
+						charlotte: true,
+						mark: true,
+						marktext: "欲",
+						intro: { content: "欲望加速，下次抢两张！" },
+					},
 					ai: {
 						trigger: { player: "dieAfter" },
 						filter: () => {
@@ -4516,7 +4512,167 @@ game.import("character", function () {
 											savable = savable(card, player, player);
 										return savable;
 									}) <=
-									player.getStorage("dcmoyu_clear").length + 1
+									1
+							)
+								return 0;
+							return eff;
+						},
+					},
+				},
+			},
+			oldmoyu: {
+				audio: "dcmoyu",
+				init: () => {
+					game.addGlobalSkill("oldmoyu_ai");
+				},
+				onremove: () => {
+					if (!game.hasPlayer((i) => i.hasSkill("oldmoyu"), true))
+						game.removeGlobalSkill("oldmoyu_ai");
+				},
+				enable: "phaseUse",
+				filter: function (event, player) {
+					return (
+						!player.hasSkill("oldmoyu_ban") &&
+						game.hasPlayer((current) => lib.skill.oldmoyu.filterTarget(null, player, current))
+					);
+				},
+				filterTarget: function (card, player, target) {
+					return (
+						player != target &&
+						!player.getStorage("oldmoyu_clear").includes(target) &&
+						target.countGainableCards(player, "hej")
+					);
+				},
+				content: function () {
+					"step 0";
+					player.addTempSkill("oldmoyu_clear");
+					player.markAuto("oldmoyu_clear", [target]);
+					player.gainPlayerCard(target, "hej", true);
+					"step 1";
+					var num = player.getStorage("oldmoyu_clear").length;
+					target
+						.chooseToUse(function (card, player, event) {
+							if (get.name(card) != "sha") return false;
+							return lib.filter.filterCard.apply(this, arguments);
+						}, "是否对" +
+							get.translation(player) +
+							"使用一张无距离限制的【杀】（伤害基数为" +
+							num +
+							"）？")
+						.set("targetRequired", true)
+						.set("complexSelect", true)
+						.set("filterTarget", function (card, player, target) {
+							if (
+								target != _status.event.sourcex &&
+								!ui.selected.targets.includes(_status.event.sourcex)
+							)
+								return false;
+							return lib.filter.targetEnabled.apply(this, arguments);
+						})
+						.set("sourcex", player)
+						.set("num", num)
+						.set("oncard", (card) => {
+							_status.event.baseDamage = _status.event.getParent().num;
+						});
+					"step 2";
+					if (result.bool) {
+						if (
+							player.hasHistory("damage", (evt) => {
+								return evt.card && evt.card.name == "sha" && evt.getParent(4) == event;
+							})
+						)
+							player.addTempSkill("oldmoyu_ban");
+					}
+				},
+				subSkill: {
+					clear: {
+						charlotte: true,
+						onremove: true,
+					},
+					ban: {
+						charlotte: true,
+						mark: true,
+						marktext: "欲",
+						intro: { content: "偷马贼被反打了！" },
+					},
+					ai: {
+						trigger: { player: "dieAfter" },
+						filter: () => {
+							return !game.hasPlayer((i) => i.hasSkill("oldmoyu"), true);
+						},
+						silent: true,
+						forceDie: true,
+						content: () => {
+							game.removeGlobalSkill("oldmoyu_ai");
+						},
+						ai: {
+							effect: {
+								target: function (card, player, target, current) {
+									if (get.type(card) == "delay" && current < 0) {
+										var currentx = _status.currentPhase;
+										if (!currentx || !currentx.isIn()) return;
+										var list = game.filterPlayer((current) => {
+											if (current == target) return true;
+											if (!current.hasSkill("oldmoyu")) return false;
+											if (current.hasJudge("lebu")) return false;
+											return get.attitude(current, target) > 0;
+										});
+										list.sortBySeat(currentx);
+										if (list.indexOf(target) != 0) return "zerotarget";
+									}
+								},
+							},
+						},
+					},
+				},
+				ai: {
+					order: 9,
+					threaten: 2.4,
+					result: {
+						target: function (player, target) {
+							var num = get.sgn(get.attitude(player, target));
+							var eff = get.effect(target, { name: "shunshou" }, player, player) * num;
+							if (eff * num > 0) return eff / 10;
+							if (
+								player.hasShan() &&
+								!target.hasSkillTag(
+									"directHit_ai",
+									true,
+									{
+										target: player,
+										card: { name: "sha" },
+									},
+									true
+								)
+							)
+								return eff;
+							if (
+								target.hasSha() &&
+								player.hp +
+									player.countCards("hs", function (card) {
+										var mod2 = game.checkMod(
+											card,
+											player,
+											"unchanged",
+											"cardEnabled2",
+											player
+										);
+										if (mod2 != "unchanged") return mod2;
+										var mod = game.checkMod(
+											card,
+											player,
+											player,
+											"unchanged",
+											"cardSavable",
+											player
+										);
+										if (mod != "unchanged") return mod;
+										var savable = get.info(card).savable;
+										if (typeof savable == "function")
+											savable = savable(card, player, player);
+										return savable;
+									}) <=
+									player.getStorage("oldmoyu_clear").length + 1
 							)
 								return 0;
 							return eff;
@@ -13163,22 +13319,23 @@ game.import("character", function () {
 					if (result.bool) {
 						if (!target.countCards("hej")) event.finish();
 						else {
-							event.giver = target;
+							// event.giver = target;
-							event.gainner = player;
+							// event.gainner = player;
-							target.choosePlayerCard(
+							player.gainPlayerCard(
 								target,
 								true,
 								"hej",
 								2,
-								"交给" + get.translation(player) + "两张牌"
+								"获得" + get.translation(target) + "区域里的两张牌"
 							);
 						}
 					} else if (result.tie) {
 						delete player.getStat("skill").refenglve;
-						event.finish();
+						if (get.position(result.player, true) == "d") player.gain(result.player, "gain2");
+						// event.finish();
 					} else {
 						if (get.position(result.player, true) == "d") target.gain(result.player, "gain2");
-						event.finish();
+						// event.finish();
 						/*if(!player.countCards('he')) event.finish();
 						else{
 							event.giver=player;
@@ -13187,7 +13344,7 @@ game.import("character", function () {
 						}*/
 					}
 					"step 2";
-					if (result.bool) event.giver.give(result.cards, event.gainner);
+					// if (result.bool) event.giver.give(result.cards, event.gainner);
 				},
 				ai: {
 					order: 8,
@@ -13222,7 +13379,7 @@ game.import("character", function () {
 						event.source &&
 						event.source == _status.currentPhase &&
 						event.num == 1 &&
-						event.player != event.source &&
+						// event.player != event.source &&
 						event.player.isIn() &&
 						player.countCards("he") > 0 &&
 						event.source
@@ -15766,10 +15923,10 @@ game.import("character", function () {
 			re_xunchen: "荀谌",
 			refenglve: "锋略",
 			refenglve_info:
-				"出牌阶段限一次，你可以和一名其他角色进行拼点。若你赢，其将区域内的两张牌交给你；若平局，则你令此技能于本阶段内的发动次数上限+1；若你输，其获得你的拼点牌。",
+				"出牌阶段限一次，你可以和一名其他角色进行拼点。若你赢，你获得其区域里的两张牌；若平局，则你获得你的拼点牌且令此技能于本阶段内的发动次数上限+1；若你输，其获得你的拼点牌。",
 			anyong: "暗涌",
 			anyong_info:
-				"当一名角色于其回合内第一次对另一名其他角色造成伤害后，若伤害值为1，则你可弃置一张牌，并对受伤角色造成1点伤害。",
+				"当一名角色于其回合内第一次造成伤害后，若伤害值为1，则你可弃置一张牌，并对受伤角色造成1点伤害。",
 			wanniangongzhu: "万年公主",
 			zhenge: "枕戈",
 			zhenge_info:
@@ -16070,9 +16227,12 @@ game.import("character", function () {
 			dcsigong_info:
 				"其他角色的回合结束时，若其于本回合内使用牌被响应过，你可以将手牌摸至或弃置至1，视为对其使用一张需使用X张【闪】抵消的【杀】，且此【杀】的伤害基数+1（X为你以此法弃置的牌数且至少为1）。当你以此法造成伤害后，该技能于本轮失效。",
 			peiyuanshao: "裴元绍",
+			oldmoyu: "没欲",
+			oldmoyu_info:
+				"出牌阶段每名角色限一次。你可以获得一名其他角色区域里的一张牌，然后其可以对你使用一张无距离限制的【杀】，且此【杀】伤害基数为X（X为你于本回合发动此技能的次数）。若此【杀】对你造成了伤害，你令此技能于本回合失效。",
 			dcmoyu: "没欲",
 			dcmoyu_info:
-				"出牌阶段每名角色限一次。你可以获得一名其他角色区域里的一张牌，然后其可以对你使用一张无距离限制的【杀】，且此【杀】伤害基数为X（X为你于本回合发动此技能的次数）。若此【杀】对你造成了伤害，你令此技能于本回合失效。",
+				"出牌阶段每名角色限一次。你可以获得一名其他角色区域里的一张牌，然后其可以对你使用一张无距离限制的【杀】。若此【杀】：未对你造成过伤害，你将此技能于此阶段下次获得的牌数改为两张；对你造成过伤害，你令此技能于本回合失效。",
 			zhangchu: "张楚",
 			dcjizhong: "集众",
 			dcjizhong_info:

character/rank.js

@@ -143,6 +143,7 @@ window.noname_character_rank = {
 		"sp_zhenji",
 		"wu_guanyu",
 		"clan_zhongyao",
+		"guanyue",
 	],
 	a: [
 		"star_caoren",
@@ -1915,6 +1916,7 @@ window.noname_character_rank = {
 			"dc_xujing",
 			"caoxian",
 			"wu_guanyu",
+			"guanyue",
 		],
 		epic: [
 			"clan_zhongyao",

character/sp.js

@@ -31,9 +31,6 @@ game.import("character", function () {
 			ol_mengda(mode) {
 				return mode !== "guozhan";
 			},
-			ol_mengda(mode) {
-				return mode !== "guozhan";
-			},
 		},
 		character: {
 			sp_sunce: ["male", "qun", 4, ["olliantao"]],
@@ -1802,11 +1799,12 @@ game.import("character", function () {
 					target.popup(list[result[1]]);
 					for (let current of [player, target]) {
 						switch (list[result[current == player ? 0 : 1]]) {
-							case "重铸":
+							case "重铸": {
 								let result2 = yield current.chooseCard("he", "请重铸一张牌", (card, player) => player.canRecast(card), true);
 								if (result2.bool) current.recast(result2.cards);
 								break;
-							case "出杀":
+							}
+							case "出杀": {
 								current.chooseToUse({
 									prompt: "请使用一张【杀】",
 									filterCard: function (card, player) {
@@ -1819,9 +1817,11 @@ game.import("character", function () {
 									},
 								});
 								break;
-							case "弃牌":
+							}
+							case "弃牌": {
 								current.chooseToDiscard("he", 2, true);
 								break;
+							}
 						}
 					}
 				},
@@ -2112,7 +2112,7 @@ game.import("character", function () {
 										}),
 									att = get.attitude(player, target);
 								if (goon) return 5 * att;
-								if (!!player.countCards("he", cardx => player.canSaveCard(cardx, player))) return att;
+								if (player.countCards("he", cardx => player.canSaveCard(cardx, player)) > 0) return att;
 								return 0;
 							},
 						})
@@ -23588,7 +23588,7 @@ game.import("character", function () {
 						event.count--;
 						var card = event.history.shift().card;
 						card = { name: card.name, nature: card.nature };
-						if (card.name != "jiu" && lib.filter.cardEnabled(card)) {
+						if (player.hasUseTarget(card, true, true)) {
 							if (
 								game.hasPlayer(function (current) {
 									return player.canUse(card, current);
@@ -27841,19 +27841,21 @@ game.import("character", function () {
 							"step 1";
 							var num = get.rand(0, 2);
 							switch (num) {
-								case 0:
+								case 0: {
 									player.line(trigger.player, "fire");
 									trigger.player.damage("fire");
 									trigger.player.addTempSkill("xinfu_xionghuo_disable");
 									trigger.player.markAuto("xinfu_xionghuo_disable", [player]);
 									break;
-								case 1:
+								}
+								case 1: {
 									player.line(trigger.player, "water");
 									trigger.player.loseHp();
 									trigger.player.addMark("xinfu_xionghuo_low", 1, false);
 									trigger.player.addTempSkill("xinfu_xionghuo_low");
 									break;
-								case 2:
+								}
+								case 2: {
 									player.line(trigger.player, "green");
 									/*
 									var card1=trigger.player.getCards('h').randomGet();
@@ -27866,6 +27868,7 @@ game.import("character", function () {
 									const cards = trigger.player.getGainableCards(player, "he");
 									if (cards.length) player.gain(cards.randomGets(2), trigger.player, "giveAuto", "bySelf");
 									break;
+								}
 							}
 							"step 2";
 							game.delay();
@@ -28891,7 +28894,6 @@ game.import("character", function () {
 			ruiji: ["ruiji", "dc_ruiji"],
 			jsp_huangyueying: ["jsp_huangyueying", "re_jsp_huangyueying"],
 			ganfuren: ["ganfuren", "dc_ganfuren", "jsp_ganfuren"],
-			wenqin: ["wenqin", "pe_wenqin"],
 			zhouqun: ["ol_zhouqun", "zhouqun"],
 			qianzhao: ["ol_qianzhao", "qianzhao"],
 			ol_pengyang: ["ol_pengyang", "sp_pengyang"],
@@ -29398,7 +29400,7 @@ game.import("character", function () {
 			chenqing: "陈情",
 			chenqing_info: "每轮限一次，当一名角色处于濒死状态时，你可以令另一名其他角色摸四张牌，然后其弃置四张牌。若其以此法弃置的四张牌花色各不相同，则视为该角色对濒死的角色使用一张【桃】。",
 			mozhi: "默识",
-			mozhi_info: "结束阶段开始时，你可以将一张手牌当作你本回合出牌阶段内使用的第一张基本或普通锦囊牌使用。然后，你可以将一张手牌当做你本回合出牌阶段内使用的第二张基本或普通锦囊牌使用。（你不能通过此技能使用【酒】）",
+			mozhi_info: "结束阶段，你可以将一张手牌当做你本回合出牌阶段内使用的第一张基本或普通锦囊牌使用。然后你可以将一张手牌当做你本回合出牌阶段内使用的第二张基本或普通锦囊牌使用（以此法使用的牌须满足使用的限制）。",
 			ranshang: "燃殇",
 			ranshang2: "燃殇",
 			ranshang_info: "锁定技，当你受到1点火焰伤害后，你获得1枚“燃”标记；结束阶段开始时，你失去X点体力。若X大于2，则你减2点体力上限并摸两张牌。（X为“燃”标记的数量）",

character/sp2.js

@@ -192,7 +192,7 @@ game.import("character", function () {
 					order: 9,
 					result: {
 						player(player, target) {
-							let res = 2 * get.effect(player, { name: "draw", player, player });
+							let res = 2 * get.effect(player, { name: "draw" }, player, player);
 							if (player !== target)
 								res += get.effect(player, { name: "losehp" }, player, player);
 							return res;
@@ -1434,7 +1434,7 @@ game.import("character", function () {
 						list.length > 1
 							? `，令${get.translation(event.card)}目标改为${get.translation(
 									list
-							  )}中的一名随机角色`
+								)}中的一名随机角色`
 							: ""
 					}。${gainText}`;
 				},
@@ -1832,13 +1832,14 @@ game.import("character", function () {
 				forced: true,
 				juexingji: true,
 				derivation: ["mashu", "dcnuchen"],
-				filter: function (event, player) {
+				filter(event, player) {
-					return player.countCards("h") > player.hp;
+					return player.countCards("hej") > player.getHp();
 				},
 				async content(event, trigger, player) {
 					player.awakenSkill("dcdanji");
 					await player.loseMaxHp();
 					await player.recover(player.maxHp - player.hp);
+					await player.draw(player.getHp());
 					await player.addSkills(["mashu", "dcnuchen"]);
 				},
 				ai: {
@@ -2252,8 +2253,8 @@ game.import("character", function () {
 				filter: function (event, player) {
 					return player.countCards("h") > 0;
 				},
-				getSkills: function (target) {
+				getSkills(target, skills) {
-					return target.getSkills(null, false).filter((skill) => {
+					return (target && !skills ? target.getSkills(null, false) : skills).filter((skill) => {
 						var str = get.skillInfoTranslation(skill, target);
 						if (str.indexOf("当你于出牌阶段") != -1) return true;
 						var skills = game.expandSkills([skill]);
@@ -2362,7 +2363,7 @@ game.import("character", function () {
 						content: function () {
 							"step 0";
 							var skill = trigger.sourceSkill || trigger.skill;
-							player.removeSkill(skill);
+							player.removeSkills(skill);
 							player.unmarkAuto("dclongsong_remove", [skill]);
 						},
 					},
@@ -2372,100 +2373,124 @@ game.import("character", function () {
 				audio: "dclongsong",
 				trigger: { player: "phaseUseBegin" },
 				filter(event, player) {
-					return game.hasPlayer((target) => {
+					return game.hasPlayer(target => {
 						if (target == player) return false;
-						return target.hasCard((card) => {
+						return target.hasCard(card => {
 							if (get.position(card) == "h") return true;
 							return get.color(card) == "red" && lib.filter.canBeGained(card, player, target);
 						}, "he");
 					});
 				},
 				async cost(event, trigger, player) {
-					const func = function (player) {
-						game.countPlayer((target) => {
-							if (target != player) {
-								const skills = lib.skill.dclongsong.getSkills(target);
-								if (skills.length) {
-									target.prompt(skills.map((i) => get.translation(i)).join("<br>"));
-								}
-							}
-						});
-					};
-					if (event.player == game.me) func(player);
-					else if (event.isOnline()) player.send(func, player);
 					event.result = await player
-						.chooseTarget(get.prompt2("longsong"), (card, player, target) => {
+						.chooseCardTarget({
-							if (target == player) return false;
+							prompt: get.prompt2("longsong"),
-							return target.hasCard((card) => {
+							filterTarget(card, player, target) {
-								if (get.position(card) == "h") return true;
+								if (target === player) return false;
-								return (
+								const skills = lib.skill.dclongsong.getSkills(target).map(skill => get.translation(skill));
-									get.color(card) == "red" && lib.filter.canBeGained(card, player, target)
+								if (skills.length) {
-								);
+									target.prompt(skills.join("<br>"));
-							}, "he");
+								}
-						})
+								return ui.selected.cards.length || target.hasCard(card => {
-						.set("ai", (target) => {
+									if (get.position(card) == "h") return true;
-							const player = get.event("player"),
+									return get.color(card) == "red" && lib.filter.canBeGained(card, player, target);
-								att = get.attitude(player, target);
+								}, "he");
-							if (
+							},
-								att > 0 &&
+							filterCard: { color: "red" },
-								!target
+							selectCard: [0, 1],
-									.getGainableCards(player, "he")
+							multitarget: true,
-									.some((card) => get.color(card) == "red")
+							ai1(card) {
-							)
+								const ai2 = get.event("ai2");
-								return 0;
+								if (
-							return (
+									game.hasPlayer(current => {
-								lib.skill.dclongsong.getSkills(target).length +
+										return ai2(current) > 0;
-								(att > 0
+									})
-									? 0
+								) {
-									: Math.max(
+									return -1 - get.value(card);
-											0,
+								}
-											get.effect(target, { name: "shunshou_copy2" }, player, player)
+								return 6 - get.value(card);
-									  ))
+							},
-							);
+							ai2(target) {
+								const player = get.event("player"),
+									att = get.attitude(player, target);
+								if (att > 0 && !target.getGainableCards(player, "he").some(card => get.color(card) == "red")) return 0;
+								return lib.skill.dclongsong.getSkills(target).length + (att > 0 ? 0 : Math.max(0, get.effect(target, { name: "shunshou_copy2" }, player, player)));
+							},
 						})
 						.forResult();
 				},
 				async content(event, trigger, player) {
 					const target = event.targets[0],
-						cards = target
+						cards = event.cards,
-							.getGainableCards(player, "he")
+						gainableCards = target.getGainableCards(player, "he").filter(card => get.color(card) == "red");
-							.filter((card) => get.color(card) == "red");
+					if (cards) {
-					if (cards.length) {
+						await player.give(cards, target);
-						let dialog = ["龙诵：获得" + get.translation(target) + "的一张红色牌"];
+					} else {
-						let cards1 = cards.filter((i) => get.position(i) == "h"),
+						if (gainableCards.length) {
-							cards2 = cards.filter((i) => get.position(i) == "e");
+							let dialog = ["龙诵：获得" + get.translation(target) + "的一张红色牌"];
-						if (cards1.length) {
+							let cards1 = gainableCards.filter(i => get.position(i) == "h"),
-							dialog.push('<div class="text center">手牌区</div>');
+								cards2 = gainableCards.filter(i => get.position(i) == "e");
-							if (player.hasSkillTag("viewHandcard", null, target, true)) dialog.push(cards1);
+							if (cards1.length) {
-							else dialog.push([cards1.randomSort(), "blank"]);
+								dialog.push('<div class="text center">手牌区</div>');
-						}
+								if (player.hasSkillTag("viewHandcard", null, target, true)) dialog.push(cards1);
-						if (cards2.length) {
+								else dialog.push([cards1.randomSort(), "blank"]);
-							dialog.push('<div class="text center">装备区</div>');
+							}
-							dialog.push(cards2);
+							if (cards2.length) {
-						}
+								dialog.push('<div class="text center">装备区</div>');
-						const {
+								dialog.push(cards2);
-							result: { bool, links },
+							}
-						} = await player.chooseButton(dialog, true).set("ai", (button) => {
+							const {
-							const player = get.event("player"),
+								result: { bool, links },
-								target = get.event().getParent().targets[0];
+							} = await player.chooseButton(dialog, true).set("ai", button => {
-							return get.value(button.link, player) * get.value(button.link, target) * (1 + Math.random());
+								const player = get.event("player"),
-						});
+									target = get.event().getParent().targets[0];
-						if (bool) {
+								return get.value(button.link, player) * get.value(button.link, target) * (1 + Math.random());
+							});
+							if (!bool) return;
 							await player.gain(links, target, "giveAuto", "bySelf");
-							const skills = lib.skill.dclongsong.getSkills(target);
+						} else {
-							if (skills.length) {
+							player.popup("杯具");
-								if (!event.isMine() && !event.isOnline()) await game.asyncDelayx();
+							player.chat("无牌可得？！");
-								for (const skill of skills) {
+							game.log("但是", target, "没有红色牌可被" + get.translation(player) + "获得！");
-									player.popup(skill, "thunder");
+						}
-									await player.addTempSkills(skill, ["phaseUseAfter", "phaseAfter"]);
+					}
-								}
+					let skills = lib.skill.dclongsong.getSkills(target),
+						fromTarget = true;
+					if (!skills.length) {
+						if (!_status.characterlist) {
+							lib.skill.pingjian.initList();
+						}
+						const allList = _status.characterlist.slice(0);
+						allList.randomSort();
+						for (const name of allList) {
+							const curSkills = lib.character[name][3];
+							const filteredSkills = lib.skill.dclongsong.getSkills(null, curSkills);
+							if (filteredSkills.length > 0) {
+								skills = filteredSkills.randomGets(1);
+								fromTarget = false;
+								break;
 							}
 						}
-					} else {
-						player.popup("杯具");
-						player.chat("无牌可得？！");
-						game.log("但是", target, "没有红色牌可被" + get.translation(player) + "获得！");
 					}
+					if (!skills.length) return;
+					if (!event.isMine() && !event.isOnline()) await game.asyncDelayx();
+					skills.forEach(skill => {
+						player.popup(skill, "thunder");
+					});
+					if (fromTarget) {
+						target.disableSkill("dclongsong_back", skills);
+						target.markAuto("dclongsong_back", skills);
+						target.addTempSkill("dclongsong_back", ["phaseUseAfter", "phaseAfter"]);
+						let str = "";
+						for (let i = 0; i < skills.length; i++) {
+							str += "【" + get.translation(skills[i]) + "】";
+							if (i != skills.length - 1) str += "、";
+						}
+						game.log(target, "的技能", "#g" + str, "失效了");
+					}
+					player.addTempSkill("dclongsong_remove", ["phaseUseAfter", "phaseAfter"]);
+					player.markAuto("dclongsong_remove", skills);
+					await player.addTempSkills(skills, ["phaseUseAfter", "phaseAfter"]);
 				},
 			},
 			//伏完
@@ -14459,7 +14484,7 @@ game.import("character", function () {
 				"出牌阶段开始时，你可以将一张红色牌交给一名其他角色。然后其须选择其所有的发动时机包含“出牌阶段”的技能，其于此阶段这些技能失效，你获得这些技能且至多可以发动一次。",
 			longsong: "龙诵",
 			longsong_info:
-				"出牌阶段开始时，你可以获得一名其他角色的一张红色牌，然后你本阶段视为拥有其所有的发动时机包含“出牌阶段”的技能。",
+				"出牌阶段开始时，你可以将一张红色牌交给一名其他角色或获得一名其他角色的一张红色牌，然后你本阶段获得其所有的发动时机包含“出牌阶段”的技能且至多可以发动一次，若其没有符合条件的技能，则改为随机获得一个满足条件的技能。",
 			dc_mengda: "孟达",
 			dclibang: "利傍",
 			dclibang_info:
@@ -14471,7 +14496,7 @@ game.import("character", function () {
 			dc_jsp_guanyu_prefix: "新杀SP",
 			dcdanji: "单骑",
 			dcdanji_info:
-				"觉醒技。准备阶段，若你的手牌数大于体力值，你减1点体力上限，将体力回复至体力上限，然后获得〖马术〗和〖怒嗔〗。",
+				"觉醒技。准备阶段，若你区域内的牌数大于体力值，你减1点体力上限，将体力回复至体力上限并摸等同于体力值的牌，然后获得〖马术〗和〖怒嗔〗。",
 			dcnuchen: "怒嗔",
 			dcnuchen_info:
 				"出牌阶段限一次。你可以展示一名其他角色的一张手牌，然后选择一项：1.弃置任意张该花色的牌，对其造成等量伤害；2.获得该角色手牌中所有此花色的牌。",

character/xianding.js

@@ -4,6 +4,7 @@ game.import("character", function () {
 		name: "xianding",
 		connect: true,
 		character: {
+			guanyue: ["male", "shu", 4, ["dcshouzhi", "dcfenhui"]],
 			sp_zhenji: ["female", "qun", 3, ["dcjijie", "dchuiji"]],
 			wu_guanyu: ["male", "shu", 5, ["dcjuewu", "dcwuyou", "dcyixian"]],
 			caofang: ["male", "wei", 4, ["dczhimin", "dcjujian"], ["zhu"]],
@@ -172,7 +173,7 @@ game.import("character", function () {
 					"bailingyun",
 				],
 				sp2_jichu: ["zhaoang", "dc_liuye", "dc_wangyun", "yanghong", "huanfan", "xizheng", "lvfan"],
-				sp2_yuxiu: ["dongguiren", "dc_tengfanglan", "zhangjinyun", "zhoubuyi", "dc_xujing"],
+				sp2_yuxiu: ["dongguiren", "dc_tengfanglan", "zhangjinyun", "zhoubuyi", "dc_xujing", "guanyue"],
 				sp2_qifu: ["dc_guansuo", "xin_baosanniang", "dc_zhaoxiang"],
 				sp2_gaoshan: ["wanglang", "liuhui", "zhangjian"],
 				sp2_wumiao: ["wu_zhugeliang", "wu_luxun", "wu_guanyu"],
@@ -183,6 +184,214 @@ game.import("character", function () {
 			dc_sb_simayi: [],
 		},
 		skill: {
+			//关樾
+			dcshouzhi: {
+				audio: 2,
+				trigger: {
+					global: "phaseEnd",
+				},
+				filter(event, player) {
+					let delt = 0;
+					player.checkHistory("lose", evt => {
+						delt -= evt.hs.length;
+					});
+					player.checkHistory("gain", evt => {
+						delt += evt.cards.length;
+					});
+					return delt < 0 || delt > 0 && player.countCards("h");
+				},
+				locked(skill, player) {
+					return player && player.storage.dcshouzhi_modified;
+				},
+				derivation: ["dcshouzhi_modified"],
+				onremove: ["dcshouzhi_modified"],
+				async cost(event, trigger, player) {
+					let delt = 0;
+					player.checkHistory("lose", evt => {
+						delt -= evt.hs.length;
+					});
+					player.checkHistory("gain", evt => {
+						delt += evt.cards.length;
+					});
+					const forced = !player.storage.dcshouzhi_modified;
+					if (delt < 0) {
+						const bool = forced ? true : await player.chooseBool(get.prompt("dcshouzhi"), "你可以摸两张牌。").forResultBool();
+						event.result = { bool };
+					} else {
+						const next = player.chooseCard("守执：请弃置一张手牌").set("filterCard", (card, player) => {
+							return lib.filter.cardDiscardable(card, player, "dcshouzhi");
+						});
+						next.set("forced", forced);
+						if (!forced) {
+							next.set("prompt", get.prompt("dcshouzhi"))
+								.set("prompt2", "你可以弃置一张手牌。")
+								.set("ai", card => {
+									const player = get.player();
+									if (player.hasSkill("dcxingmen") && get.recoverEffect(player, player) > 0) return 6 - get.value(card);
+									return 0;
+								});
+						}
+						event.result = await next.forResult();
+					}
+				},
+				async content(event, trigger, player) {
+					const { cards } = event;
+					if (cards && cards.length) await player.discard(cards);
+					else await player.draw(2);
+					await game.asyncDelayx();
+				},
+			},
+			dcfenhui: {
+				audio: 2,
+				enable: "phaseUse",
+				limited: true,
+				filterTarget(card, player, target) {
+					const list = get.event("dcfenhui_enabled");
+					if (!list || !list.length) return false;
+					return list.includes(target);
+				},
+				onChooseToUse(event) {
+					if (game.online) return;
+					const player = event.player;
+					const evts = player.getAllHistory("useCard", evt => {
+						return get.color(evt.card, player) === "black" && evt.targets && evt.targets.length;
+					});
+					event.set(
+						"dcfenhui_enabled",
+						game.filterPlayer(current => {
+							return evts.filter(evt => evt.targets.includes(current)).length;
+						})
+					);
+				},
+				skillAnimation: true,
+				animationColor: "fire",
+				derivation: ["dcxingmen"],
+				async content(event, trigger, player) {
+					player.awakenSkill("dcfenhui");
+					const target = event.target;
+					const count = player.getAllHistory("useCard", evt => {
+						return get.color(evt.card, player) === "black" && evt.targets && evt.targets.includes(target);
+					}).length;
+					target.addMark("dcfenhui_mark", Math.min(5, count));
+					player.addSkill("dcfenhui_effect");
+				},
+				subSkill: {
+					effect: {
+						audio: "dcfenhui",
+						trigger: {
+							source: "damageBegin1",
+							global: "die",
+						},
+						filter(event, player) {
+							return event.player.hasMark("dcfenhui_mark");
+						},
+						logTarget: "player",
+						forced: true,
+						charlotte: true,
+						async content(event, trigger, player) {
+							if (trigger.name === "damage") {
+								trigger.player.removeMark("dcfenhui_mark", 1);
+								trigger.num++;
+							} else {
+								await player.loseMaxHp();
+								player.storage.dcshouzhi_modified = true;
+								await player.addSkills("dcxingmen");
+							}
+						},
+					},
+					mark: {
+						marktext: "恨",
+						intro: {
+							name: "恨(奋恚)",
+							name2: "恨",
+							content: "mark",
+						}
+					},
+				},
+				ai: {
+					order: 6,
+					result: {
+						target(player, target) {
+							if (!player.hasCard(card => {
+								return get.tag(card, "damage") && player.canUse(card, target, true, true) && get.effect(target, card, player, player) > 0;
+							}, "hs")) return 0;
+							const count = Math.min(
+								5,
+								player.getAllHistory("useCard", evt => {
+									return get.color(evt.card, player) === "black" && evt.targets && evt.targets.includes(target);
+								}).length
+							);
+							let value = Math.max(player.getHp(true), 3) - count;
+							if (
+								(count - 1) *
+									(target.hasSkillTag("filterDamage", null, {
+										player: player,
+									})
+										? 1
+										: 2) >=
+								target.getHp(true) +
+									target.countCards("hs", card => {
+										return target.canSaveCard(card, target);
+									})
+							)
+								value -= 2;
+							return Math.min(0, value);
+						},
+					},
+				},
+			},
+			dcxingmen: {
+				audio: 2,
+				trigger: {
+					player: "loseAfter",
+				},
+				filter(event, player) {
+					return event.getParent(2).name === "dcshouzhi" && player.isDamaged();
+				},
+				frequent: true,
+				prompt2: "你可以回复1点体力。",
+				group: ["dcxingmen_norespond"],
+				check(event, player) {
+					return get.recoverEffect(player, player) > 0;
+				},
+				async content(event, trigger, player) {
+					await player.recover();
+				},
+				subSkill: {
+					norespond: {
+						audio: "dcxingmen",
+						trigger: {
+							player: "gainAfter",
+						},
+						filter(event, player) {
+							return event.getParent().name === "draw" && event.cards.length >= 2 && event.cards.every(card => get.color(card) === "red");
+						},
+						forced: true,
+						locked: false,
+						popup: false,
+						async content(event, trigger, player) {
+							player.addGaintag(trigger.cards, "dcxingmen");
+							player.addSkill("dcxingmen_directHit");
+						},
+					},
+					directHit: {
+						audio: "dcxingmen",
+						trigger: { player: "useCard" },
+						forced: true,
+						charlotte: true,
+						filter(event, player) {
+							return player.hasHistory("lose", evt => {
+								if (evt.getParent() !== event) return false;
+								return Object.values(evt.gaintag_map).some(tags => tags.includes("dcxingmen"));
+							});
+						},
+						async content(event, trigger, player) {
+							trigger.directHit.addArray(game.filterPlayer());
+							game.log(trigger.card, "不可被响应");
+						},
+					},
+				},
+			},
 			//武关羽
 			dcjuewu: {
 				audio: 2,
@@ -1681,19 +1890,17 @@ game.import("character", function () {
 				logTarget: "player",
 				async content(event, trigger, player) {
 					player
-						.judge((card) => {
+						.judge(card => {
 							const evt = get.event().getParent(get.event("eventName")).getTrigger();
-							if (!evt.source.isIn() || !evt.card || typeof get.number(evt.card) !== "number")
+							if (!evt.source || !evt.source.isIn() || !evt.card || typeof get.number(evt.card) !== "number") return 0;
-								return 0;
 							if (get.number(card) > get.number(evt.card)) return 1.5;
 							return 0;
 						})
-						.set("judge2", (r) => r.bool)
+						.set("judge2", r => r.bool)
 						.set("callback", () => {
 							const evtx = event.getParent();
 							const evt = event.getParent(evtx.eventName).getTrigger();
-							if (!evt.source.isIn() || !evt.card || typeof get.number(evt.card) !== "number")
+							if (!evt.source || !evt.source.isIn() || !evt.card || typeof get.number(evt.card) !== "number") return;
-								return;
 							if (event.judgeResult.number > get.number(evt.card)) {
 								const sha = new lib.element.VCard({ name: "sha" }),
 									target = evt.source;
@@ -5488,7 +5695,7 @@ game.import("character", function () {
 												},
 												target,
 												target
-										  ))
+											))
 								);
 							})
 							.set("card", card);
@@ -7727,7 +7934,6 @@ game.import("character", function () {
 					var evt = lib.skill.dcjianying.getLastUsed(player, trigger.getParent());
 					player.draw(trigger.targets.filter((target) => evt.targets.includes(target)).length);
 				},
-				locked: false,
 				mod: {
 					aiOrder: function (player, card, num) {
 						var evt = player.getLastUsed();
@@ -8578,13 +8784,13 @@ game.import("character", function () {
 					},
 				},
 			},
-			dcjinjie: {
+			oldjinjie: {
-				audio: 2,
+				audio: "dcjinjie",
 				trigger: { global: "dying" },
 				hasPhase: function (player) {
 					var history = player.actionHistory;
 					for (var i = history.length - 1; i >= 0; i--) {
-						if (history[i].isMe) return true;
+						if (history[i].isMe && !history[i].isSkipped) return true;
 						if (history[i].isRound) break;
 					}
 					return false;
@@ -8593,28 +8799,28 @@ game.import("character", function () {
 				content: function () {
 					"step 0";
 					player
-						.chooseBool(get.prompt("dcjinjie", trigger.player), "令其摸一张牌")
+						.chooseBool(get.prompt("oldjinjie", trigger.player), "令其摸一张牌")
 						.set("ai", () => {
 							return get.attitude(_status.event.player, _status.event.getTrigger().player) > 0;
 						});
 					"step 1";
 					if (result.bool) {
-						player.logSkill("dcjinjie", trigger.player);
+						player.logSkill("oldjinjie", trigger.player);
 						trigger.player.draw();
 					} else event.finish();
-					if (lib.skill.dcjinjie.hasPhase(player)) event.finish();
+					if (lib.skill.oldjinjie.hasPhase(player)) event.finish();
 					"step 2";
 					var num = 0;
 					var history = player.actionHistory;
 					for (var i = history.length - 1; i >= 0; i--) {
 						for (var evt of history[i].useSkill) {
-							if (evt.skill == "dcjinjie") num++;
+							if (evt.skill == "oldjinjie") num++;
 						}
 						if (history[i].isRound) break;
 					}
 					if (num == 0) {
 						player
-							.chooseBool(get.prompt("dcjinjie", trigger.player), "令其回复1点体力")
+							.chooseBool(get.prompt("oldjinjie", trigger.player), "令其回复1点体力")
 							.set("ai", () => {
 								var player = _status.event.player;
 								return (
@@ -8629,7 +8835,7 @@ game.import("character", function () {
 					} else {
 						player
 							.chooseToDiscard(
-								get.prompt("dcjinjie", trigger.player),
+								get.prompt("oldjinjie", trigger.player),
 								"弃置" + get.cnNumber(num) + "张牌，令其回复1点体力",
 								"he",
 								num
@@ -8648,8 +8854,101 @@ game.import("character", function () {
 					}
 				},
 			},
-			dcjue: {
+			dcjinjie: {
 				audio: 2,
+				trigger: { global: "dying" },
+				async cost(event, trigger, player) {
+					const target = trigger.player;
+					const result = await player
+						.chooseControl(
+							[0, 1, 2, 3].map(i => get.cnNumber(i, true)),
+							"cancel2"
+						)
+						.set("prompt", get.prompt("dcjinjie", target))
+						.set("prompt2", `令${get.translation(target)}摸至多三张牌，然后你可以弃置等量的牌令其回复1点体力。`)
+						.set("ai", () => {
+							return get.event("choice");
+						})
+						.set(
+							"choice",
+							(() => {
+								if (get.attitude(player, target) <= 0) return "cancel2";
+								if (target === player) return 3;
+								const unusefulCount = player.countCards("he", card => {
+									return lib.filter.cardDiscardable(card, player, "dcjinjie") && get.value(card) < 5 && !player.canSaveCard(card, target);
+								});
+								if (
+									[player, target]
+										.unique()
+										.map(current => {
+											return current.countCards("hs", card => {
+												return player.canSaveCard(card, target);
+											});
+										})
+										.reduce((p, c) => p + c) > unusefulCount
+								) {
+									return 3;
+								}
+								return Math.min(3, unusefulCount);
+							})()
+						)
+						.forResult();
+					if (result.control !== "cancel2") {
+						event.result = {
+							bool: true,
+							cost_data: {
+								index: result.index,
+							},
+						};
+					}
+				},
+				round: 1,
+				logTarget: "player",
+				async content(event, trigger, player) {
+					const num = event.cost_data.index,
+						target = trigger.player;
+					if (num > 0) await target.draw(num);
+					let next;
+					if (num > 0) {
+						next = player
+							.chooseToDiscard(`尽节：是否弃置${get.cnNumber(num)}张牌，令${get.translation(target)}回复1点体力？`, num, "he")
+							.set("ai", card => {
+								if (get.event("goon")) {
+									return 100 / Math.max(0.01, get.value(card) + 20);
+								}
+								return 0;
+							})
+							.set(
+								"goon",
+								(() => {
+									if (get.attitude(player, target) <= 0) return false;
+									const count = player.countCards("hs", card => {
+										return player.canSaveCard(card, target);
+									});
+									return (
+										!count ||
+										(count > 0 &&
+											player.countCards("he", card => {
+												return get.value(card) < 5;
+											}) >= num)
+									);
+								})()
+							);
+					} else {
+						next = player.chooseBool(`尽节：是否令${get.translation(target)}回复1点体力？`).set("choice", get.attitude(player, target) > 0);
+					}
+					const bool = await next.forResultBool();
+					if (bool) {
+						player.line(target, "green");
+						await target.recover();
+					}
+				},
+				subSkill:{
+					round:{},
+				}
+			},
+			oldjue: {
+				audio: "dcjue",
 				trigger: { player: "phaseZhunbeiBegin" },
 				direct: true,
 				filter: function (event, player) {
@@ -8664,7 +8963,7 @@ game.import("character", function () {
 					"step 0";
 					player
 						.chooseTarget(
-							get.prompt("dcjue"),
+							get.prompt("oldjue"),
 							"视为对一名体力值或手牌数大于你的角色使用一张【杀】",
 							(card, player, target) => {
 								return (
@@ -8680,11 +8979,72 @@ game.import("character", function () {
 					"step 1";
 					if (result.bool) {
 						var target = result.targets[0];
-						player.logSkill("dcjue", target);
+						player.logSkill("oldjue", target);
 						player.useCard({ name: "sha", isCard: true }, target, false);
 					}
 				},
 			},
+			dcjue: {
+				audio: 2,
+				trigger: { global: "phaseJieshuBegin" },
+				filter(event, player) {
+					if (!lib.skill.dcjue.getCards().length) return false;
+					return (
+						(event.player !== player && event.player.isIn()) ||
+						(event.player === player &&
+							game.hasPlayer(current => {
+								return current.isIn();
+							}))
+					);
+				},
+				round: 1,
+				async cost(event, trigger, player) {
+					let maxLimit = lib.skill.dcjue.getCards().length;
+					if (trigger.player === player) {
+						event.result = await player
+							.chooseTarget(get.prompt("dcjue"), `选择一名其他角色，视为对其依次随机使用X次【杀】/【过河拆桥】/【五谷丰登】（X为${maxLimit}与其体力上限中的较小值）。`)
+							.set("filterTarget", lib.filter.notMe)
+							.set("ai", target => {
+								return -get.attitude(get.player(), target);
+							})
+							.forResult();
+					} else {
+						const target = trigger.player;
+						maxLimit = Math.min(maxLimit, target.maxHp);
+						event.result = await player
+							.chooseBool(get.prompt("dcjue", target), `视为对${get.translation(target)}依次随机使用${get.cnNumber(maxLimit)}次【杀】/【过河拆桥】/【五谷丰登】。`)
+							.set("choice", get.attitude(player, target) < 0)
+							.forResult();
+					}
+				},
+				logTarget: "player",
+				getCards() {
+					const cards = [];
+					game.countPlayer2(current => {
+						current.getHistory("lose", evt => {
+							if (evt.type == "discard") cards.addArray(evt.cards2.filterInD("d"));
+						});
+					});
+					return cards;
+				},
+				async content(event, trigger, player) {
+					const target = event.targets ? event.targets[0] : trigger.player;
+					const nameList = ["sha", "guohe", "wugu"];
+					let maxLimit = Math.min(lib.skill.dcjue.getCards().length, target.maxHp);
+					while (maxLimit--) {
+						if (!target.isIn()) return;
+						const list = nameList.slice().randomSort();
+						for (const name of list) {
+							const card = new lib.element.VCard({ name });
+							if (player.canUse(card, target)) {
+								await player.useCard(card, target);
+								await game.asyncDelayx();
+								break;
+							}
+						}
+					}
+				},
+			},
 			//杨弘
 			dcjianji: {
 				audio: 2,
@@ -18748,6 +19108,7 @@ game.import("character", function () {
 			zhugemengxue: "诸葛氏（“梦雪”为网络小说虚构），诸葛亮的大姐。",
 			caoyi: "曹轶，游卡桌游旗下产品《三国杀》原创角色。设定上为曹纯所收养的孙女，从小受到曹纯的教导，在军营中长大，性情坚毅有担当，军事谋略丰富，战斗能力超强。曹轶喜欢美食，特别是甜食，并且擅长制作各种点心。她身边跟随的雪白小老虎是曹纯在她及笄时送的生辰礼物，希望她如小老虎一样，英勇无畏。曹轶与曹婴交好，两人以姐妹相称。曹轶成年后继承祖父衣钵，接手精锐部队“虎豹骑”，成为新的虎豹骑的统领者。",
 			huzun: "胡遵（？～256年），安定临泾（今甘肃省镇原县）人，三国时期曹魏大臣，官至卫将军，封阴密侯。出身安定胡氏。历任征东将军、征东大将军、卫将军等职。早年由张既征辟。后追随司马懿，参与平定匈奴胡薄居姿职叛乱、抵御诸葛亮北伐、平定公孙渊叛乱。嘉平四年（252年），作为曹魏三征之一的征东将军，主持征讨东吴，被诸葛恪击败。正元元年（255年）参与平定淮南三叛的第二叛毌丘俭、文钦之乱，事后升任卫将军。甘露元年（256年）秋七月己卯去世，追赠车骑将军。",
+			guanyue: "关樾，传说记载之人物，声称是关羽之孙，关平长子。未见载于正史，仅记载于清朝地方志以及传说。清·《江陵县志》：“娶镇东将军女赵氏。生子樾，世居江陵。”。清·《关氏宗谱·江陵县儒学册结》：“平子樾，因守祖、父陵墓遂家于荆州焉，此荆州之关氏所由来也。”",
 		},
 		characterTitle: {
 			// wulan:'#b对决限定武将',
@@ -18907,6 +19268,11 @@ game.import("character", function () {
 					return '转换技。出牌阶段每名角色限一次，你可以令一名攻击范围内的其他角色交给你一张牌。阴：当你于本阶段内下次对其造成伤害时，取消之；<span class="bluetext">阳：当你于本阶段内下次对其造成伤害后，你可以选择除其外的至多三名其他角色，对这些角色依次造成1点伤害。</span>';
 				return '转换技。出牌阶段每名角色限一次，你可以令一名攻击范围内的其他角色交给你一张牌。<span class="bluetext">阴：当你于本阶段内下次对其造成伤害时，取消之；</span>阳：当你于本阶段内下次对其造成伤害后，你可以选择除其外的至多三名其他角色，对这些角色依次造成1点伤害。';
 			},
+			dcshouzhi(player) {
+				let skillName = "dcshouzhi";
+				if (player.storage.dcshouzhi_modified) skillName += "_modified";
+				return lib.translate[`${skillName}_info`];
+			},
 		},
 		characterReplace: {
 			wenyang: ["wenyang", "db_wenyang", "diy_wenyang"],
@@ -19368,11 +19734,16 @@ game.import("character", function () {
 			dczhaohan: "昭汉",
 			dczhaohan_info:
 				"摸牌阶段，你可以多摸两张牌，然后你于得到牌后选择一项：1.将两张手牌交给一名没有手牌的角色；2.弃置两张手牌。",
+			oldjinjie: "尽节",
+			oldjinjie_info:
+				"当一名角色进入濒死状态时，你可以令其摸一张牌。然后若你本轮未进行过回合，你可以弃置X张手牌令其回复1点体力（X为本轮你发动过〖尽节〗的次数）。",
 			dcjinjie: "尽节",
 			dcjinjie_info:
-				"当一名角色进入濒死状态时，可以令其摸一张牌。然后若你本轮未进行过回合，你可以弃置X张手牌令其回复1点体力（X为本轮你发动过〖尽节〗的次数）。",
+				"每轮限一次。当一名角色进入濒死状态时，你可以声明一个整数X（X∈[0,3]），令其摸X张牌，然后你可以弃置X张牌令其回复1点体力（若X为0则跳过摸牌和弃牌的步骤）。",
+			oldjue: "举讹",
+			oldjue_info: "准备阶段，你可以视为对一名体力值或手牌数大于你的角色使用一张【杀】。",
 			dcjue: "举讹",
-			dcjue_info: "准备阶段，你可以视为对一名体力值或手牌数大于你的角色使用一张【杀】。",
+			dcjue_info: "每轮限一次。一名角色的结束阶段，你可以视为对其随机使用【杀】/【过河拆桥】/【五谷丰登】，直到你以此法使用的牌数不小于Y（Y为本回合因弃置进入弃牌堆的牌数，且至多为其体力上限）。若此时是你的回合，改为你选择一名其他角色。",
 			dc_tengfanglan: "滕芳兰",
 			dcluochong: "落宠",
 			dcluochong_info:
@@ -19704,6 +20075,15 @@ game.import("character", function () {
 			dchuiji: "惠济",
 			dchuiji_info:
 				"出牌阶段限一次。你可以令一名角色摸两张牌或从牌堆中随机使用一张不为赠物的装备牌，然后若其手牌数不小于存活角色数，其视为使用一张【五谷丰登】。系统不于此牌使用准备工作结束时执行亮出牌堆顶的牌的动作，改为你令其将所有手牌置于处理区，然后令所有目标角色依次获得其中一张牌。当这些牌因执行【五谷丰登】的执行动作而置于弃牌堆后，你令其获得这些牌。",
+			guanyue: "关樾",
+			dcshouzhi: "守执",
+			dcshouzhi_info: "锁定技。一名角色的回合结束时，若你的手牌数：大于本回合开始时的手牌数，你弃置一张手牌；小于本回合开始时的手牌数，你摸两张牌。",
+			dcshouzhi_modified: "守执·改",
+			dcshouzhi_modified_info: "一名角色的回合结束时，若你的手牌数：大于本回合开始时的手牌数，你可以弃置一张手牌；小于本回合开始时的手牌数，你可以摸两张牌。",
+			dcfenhui: "奋恚",
+			dcfenhui_info: "限定技。出牌阶段，你可以令一名角色获得X枚“恨”标记，你摸等量的牌（X为本局游戏你使用黑色牌指定其为目标的次数，至多为5）。你获得如下效果：⒈当你对其造成伤害时，你移去其1枚“恨”，令此伤害+1；⒉当其死亡时，若其有“恨”，你减1点体力上限，修改〖守执〗并获得〖兴门〗。",
+			dcxingmen: "兴门",
+			dcxingmen_info: "①当你因〖守执〗弃置而失去牌后，你可以回复1点体力。②当你因摸牌而得到牌后，若这些牌均为红色且牌数不小于2，则你使用这些牌时不能被响应。",
 
 			sp2_yinyu: "隐山之玉",
 			sp2_huben: "百战虎贲",