Merge pull request #1414 from mengxinzxz/PR-Branch

部分新武将；素材补充；bugfix

character/huicui/character.js

@@ -1,11 +1,12 @@
 const characters = {
+	yue_zhugeguo: ["female", "shu", 3, ["dcxidi", "dcchengyan"]],
+	yue_zoushi: ["female", "qun", 3, ["dcyunzheng", "dchuoxin"]],
+	zhupeilan: ["female", "wu", 3, ["dccilv", "dctongdao"]],
+	yue_miheng: ["male", "qun", 3, ["dcjigu", "dcsirui"]],
+	chezhou: ["male", "wei", 4, ["dcshefu", "dcpigua"]],
 	dc_lifeng: ["male", "shu", 3, ["dctunchu", "dcshuliang"]],
 	wupu: ["male", "qun", 4, ["dcduanti", "dcshicao"]],
-	dc_caoshuang: ["male", "wei", 4, ["dcjianzhuan", "dcfanshi"]],
 	zangba: ["male", "wei", 4, ["rehengjiang"]],
-	dc_simashi: ["male", "wei", 3, ["dcsanshi", "dczhenrao", "dcchenlve"]],
-	dc_wangling: ["male", "wei", 4, ["dcjichou", "dcmouli"], ["clan:太原王氏"]],
-	dc_jiangji: ["male", "wei", 3, ["dcshiju", "dcyingshi"]],
 	gongsunxiu: ["male", "qun", 4, ["dcgangu", "dckuizhen"]],
 	dc_liuli: ["male", "shu", 3, ["dcfuli", "dcdehua"]],
 	yue_daqiao: ["female", "wu", 3, ["dcqiqin", "dczixi"]],

character/huicui/characterReplace.js

@@ -1,5 +1,6 @@
 const characterReplaces = {
 	lifeng: ["dc_lifeng", "lifeng"],
+	zhugeguo: ["yue_zhugeguo", "zhugeguo"],
 };
 
 export default characterReplaces;

character/huicui/intro.js

@@ -1,4 +1,6 @@
 const characterIntro = {
+	zhupeilan: "景皇后朱氏（234年―265年），吴郡吴县（今江苏省苏州市）人，吴景帝孙休的皇后，野史记载其名为朱佩兰。骠骑将军朱据与朱公主的独生女，吴末帝孙皓的表姐和叔母。出身江南四大姓之一吴郡朱氏。赤乌末年，与孙休成婚，永安元年（258年），孙休继位，封为夫人，永安五年（262年），被立为皇后。孙休去世后为太后，甘露元年秋（265年）被孙皓逼杀，葬于定陵。",
+	chezhou: "车胄（？－199年至200年） （chē zhòu），东汉末年武将，为曹操所置徐州刺史。建安四年，左将军刘备率军出征，前往下邳，于同年或次年杀死车胄。",
 	dc_liuli: "刘理（？—244年），字奉孝，涿郡涿县（今河北涿州）人，三国时期蜀汉昭烈帝刘备之子，蜀汉后主刘禅、甘陵王刘永异母弟。章武元年（221年），刘备称帝，派司徒许靖封刘理为梁王。建兴八年（230年），改封为安平王。延熙七年（244年），刘理去世，谥号悼王。",
 	xingdaorong: "邢道荣是《三国演义》中虚构的人物，为零陵太守刘度手下武将，被评价有万夫不当之勇，于《三国演义》第五十二回登场，被赵云刺死。",
 	caoxing: "曹性，东汉末年吕布部将，史载他曾与身为自己上司的反叛者郝萌交战，并砍去郝萌一臂，受到吕布的嘉奖。在罗贯中所著古典小说《三国演义》中，也有关于曹性箭射夏侯惇左目的描述，而曹性也随即被暴怒的夏侯惇所杀。在穿越小说《三国之银河射手》中，主角穿越成为曹性，经过一番闯荡之后，被封为“银河射手”。",

character/huicui/skill.js

@@ -2,6 +2,605 @@ import { lib, game, ui, get, ai, _status } from "../../noname.js";
 
 /** @type { importCharacterConfig['skill'] } */
 const skills = {
+	//乐诸葛果
+	dcxidi: {
+		audio: 2,
+		trigger: {
+			global: "phaseBefore",
+			player: "enterGame",
+		},
+		filter(event, player) {
+			return event.name != "phase" || game.phaseNumber == 0;
+		},
+		forced: true,
+		content() {
+			const cards = player.getCards("h");
+			player.addGaintag(cards, "dcxidi_tag");
+		},
+		mod: {
+			ignoredHandcard(card) {
+				if (card.hasGaintag("dcxidi_tag")) return true;
+			},
+			cardDiscardable(card, _, name) {
+				if (name == "phaseDiscard" && card.hasGaintag("dcxidi_tag")) return false;
+			},
+		},
+		group: "dcxidi_guanxing",
+		subSkill: {
+			guanxing: {
+				audio: "dcxidi",
+				trigger: { player: "phaseZhunbeiBegin" },
+				filter(event, player) {
+					return player.hasCard(card => card.hasGaintag("dcxidi_tag"), "h");
+				},
+				forced: true,
+				locked: false,
+				preHidden: true,
+				async content(event, trigger, player) {
+					const num = player.countCards("h", card => card.hasGaintag("dcxidi_tag"));
+					const cards = get.cards(Math.min(num, 5));
+					await game.cardsGotoOrdering(cards);
+					const next = player.chooseToMove();
+					next.set("list", [["牌堆顶", cards], ["牌堆底"]]);
+					next.set("prompt", "羲笛：点击将牌移动到牌堆顶或牌堆底");
+					next.processAI = list => {
+						const cards = list[0][1],
+							player = _status.event.player;
+						const top = [];
+						const judges = player.getCards("j");
+						let stopped = false;
+						if (!player.hasWuxie()) {
+							for (let i = 0; i < judges.length; i++) {
+								const judge = get.judge(judges[i]);
+								cards.sort((a, b) => judge(b) - judge(a));
+								if (judge(cards[0]) < 0) {
+									stopped = true;
+									break;
+								} else {
+									top.unshift(cards.shift());
+								}
+							}
+						}
+						let bottom;
+						if (!stopped) {
+							cards.sort((a, b) => get.value(b, player) - get.value(a, player));
+							while (cards.length) {
+								if (get.value(cards[0], player) <= 5) break;
+								top.unshift(cards.shift());
+							}
+						}
+						bottom = cards;
+						return [top, bottom];
+					};
+					const {
+						result: { moved },
+					} = await next;
+					const top = moved[0];
+					const bottom = moved[1];
+					top.reverse();
+					await game.cardsGotoPile(top.concat(bottom), ["top_cards", top], (event, card) => {
+						if (event.top_cards.includes(card)) return ui.cardPile.firstChild;
+						return null;
+					});
+					player.popup(get.cnNumber(top.length) + "上" + get.cnNumber(bottom.length) + "下");
+					game.log(player, "将" + get.cnNumber(top.length) + "张牌置于牌堆顶");
+					await game.asyncDelayx();
+				},
+			},
+		},
+	},
+	dcchengyan: {
+		audio: 2,
+		trigger: { player: "useCardToPlayered" },
+		filter(event, player) {
+			if (!player.isPhaseUsing()) return false;
+			if (event.card.name != "sha" && get.type(event.card) != "trick") return false;
+			return event.target != player;
+		},
+		logTarget: "target",
+		async content(event, trigger, player) {
+			const target = trigger.target;
+			const cards = get.cards();
+			await game.cardsGotoOrdering(cards);
+			await player.showCards(cards, get.translation(player) + "发动了【乘烟】");
+			const card = cards[0];
+			if (card.name == "sha" || (get.type(card) == "trick" && get.info(card).filterTarget)) {
+				player.addTempSkill("dcchengyan_effect");
+				player.markAuto("dcchengyan_effect", [[trigger.card, card, target]]);
+			}
+			if (card.name != "sha" && get.type(card) != "trick") {
+				await player.gain(card, "gain2").set("gaintag", ["dcxidi_tag"]);
+			}
+			else await game.cardsDiscard(cards);
+		},
+		subSkill: {
+			effect: {
+				charlotte: true,
+				onremove: true,
+				trigger: { player: "useCardToBegin" },
+				filter(event, player) {
+					const storage = player.getStorage("dcchengyan_effect");
+					return storage.some(list => list[0] == event.card && list[2] == event.target);
+				},
+				forced: true,
+				popup: false,
+				firstDo: true,
+				async content(event, trigger, player) {
+					const list = player.getStorage("dcchengyan_effect").find(list => list[0] == trigger.card && list[2] == trigger.target);
+					trigger.setContent(lib.card[list[1].name].content);
+				},
+			},
+		},
+	},
+	//乐邹氏
+	dcyunzheng: {
+		audio: 2,
+		trigger: {
+			global: "phaseBefore",
+			player: "enterGame",
+		},
+		filter(event, player) {
+			return event.name != "phase" || game.phaseNumber == 0;
+		},
+		forced: true,
+		content() {
+			const cards = player.getCards("h");
+			player.addGaintag(cards, "dcyunzheng_tag");
+		},
+		mod: {
+			ignoredHandcard(card) {
+				if (card.hasGaintag("dcyunzheng_tag")) return true;
+			},
+			cardDiscardable(card, _, name) {
+				if (name == "phaseDiscard" && card.hasGaintag("dcyunzheng_tag")) return false;
+			},
+		},
+		group: "dcyunzheng_fengyin",
+		subSkill: {
+			fengyin: {
+				audio: "dcyunzheng",
+				trigger: {
+					global: ["phaseBefore", "loseAfter", "loseAsyncAfter", "gainAfter", "equipAfter", "addJudgeAfter", "addToExpansionAfter"],
+					player: ["dchuoxin_update", "enterGame"],
+				},
+				filter(event, player) {
+					if (
+						["lose", "loseAsync", "gain", "equip", "addJudge", "addToExpansion"].includes(event.name) &&
+						!game.hasPlayer(target => {
+							const evt = event.getl(target);
+							return evt && (evt.hs || []).length;
+						})
+					)
+						return false;
+					return game.hasPlayer(target => {
+						return target.hasCard(card => card.hasGaintag("dcyunzheng_tag"), "h") == !target.hasSkill("dcyunzheng_block");
+					});
+				},
+				logTarget(event, player) {
+					return game
+						.filterPlayer(target => {
+							return target.hasCard(card => card.hasGaintag("dcyunzheng_tag"), "h") == !target.hasSkill("dcyunzheng_block");
+						})
+						.sortBySeat();
+				},
+				forced: true,
+				content() {
+					const targets = game
+						.filterPlayer(target => {
+							return target.hasCard(card => card.hasGaintag("dcyunzheng_tag"), "h") == !target.hasSkill("dcyunzheng_block");
+						})
+						.sortBySeat();
+					for (const target of targets) {
+						target[target.hasSkill("dcyunzheng_block") ? "removeSkill" : "addSkill"]("dcyunzheng_block");
+					}
+				},
+			},
+			block: {
+				inherit: "fengyin",
+			},
+		},
+	},
+	dchuoxin: {
+		audio: 2,
+		trigger: { player: "useCardToPlayered" },
+		filter(event, player) {
+			if (
+				!player.hasHistory("lose", evt => {
+					if (evt.getParent() != event.getParent()) return false;
+					return event.cards.some(card => (evt.hs || []).includes(card));
+				})
+			)
+				return false;
+			return event.target != player && event.target.countCards("h");
+		},
+		forced: true,
+		logTarget: "target",
+		async content(event, trigger, player) {
+			const target = trigger.target;
+			const result = await player.choosePlayerCard("h", target, true, "惑心：展示" + get.translation(target) + "的一张手牌").forResult();
+			if (result.bool) {
+				let cards = result.cards.slice();
+				await player.showCards(cards, get.translation(player) + "发动了【惑心】");
+				const cardx = cards.filter(card => card.hasGaintag("dcyunzheng_tag") || get.suit(card) == get.suit(trigger.card));
+				if (cardx.length) {
+					cards.removeArray(cardx);
+					await player.gain(cardx, target, "give");
+					await event.trigger("dchuoxin_update");
+				}
+				if (cards.some(card => !card.hasGaintag("dcyunzheng_tag"))) {
+					target.addGaintag(
+						cards.filter(card => !card.hasGaintag("dcyunzheng_tag")),
+						"dcyunzheng_tag"
+					);
+					await event.trigger("dchuoxin_update");
+				}
+			}
+		},
+	},
+	//朱佩兰
+	dccilv: {
+		audio: 2,
+		trigger: { target: "useCardToTargeted" },
+		filter(event, player) {
+			return get.type(event.card) == "trick" && player.getStorage("dccilv").length < 3;
+		},
+		async content(event, trigger, player) {
+			await player.draw(3 - player.getStorage("dccilv").length);
+			if (player.countCards("h") > player.maxHp) {
+				let result,
+					list = ["无效", "防伤", "获得"].filter(i => !player.getStorage("dccilv").includes(i));
+				if (list.length == 1) result = { control: list[0] };
+				else
+					result = await player
+						.chooseControl(list)
+						.set("prompt", "辞虑：选择执行并移去一项")
+						.set("ai", () => {
+							const player = get.event("player"),
+								trigger = get.event().getTrigger();
+							let controls = get.event("controls").slice();
+							if (controls.includes("防伤")) {
+								if (get.tag(card, "damage")) return "防伤";
+								else controls.remove("防伤");
+							}
+							if (get.effect(player, trigger.card, trigger.player, player) < 0 && controls.includes("无效")) return "无效";
+							return controls[controls.length - 1];
+						})
+						.forResult();
+				const choice = result.control;
+				player.popup(choice);
+				game.log(player, "选择了", "#y" + choice);
+				switch (choice) {
+					case "无效":
+						trigger.getParent().excluded.add(player);
+						game.log(trigger.card, "对", player, "无效");
+						break;
+					case "防伤":
+						player.addTempSkill("dccilv_effect");
+						player.markAuto("dccilv_effect", [trigger.card]);
+						break;
+					case "获得":
+						player
+							.when({ global: "useCardAfter" })
+							.filter(evt => evt == trigger.getParent())
+							.then(() => {
+								const cards = (trigger.cards || []).filterInD();
+								if (cards.length) player.gain(cards, "gain2");
+							});
+						break;
+				}
+				player.markAuto("dccilv", [choice]);
+			}
+		},
+		mark: true,
+		intro: {
+			markcount: storage => 3 - (storage || []).length,
+			content: storage => ((storage || []).length ? "已移去了$项" : "暂未移去任何项"),
+		},
+		subSkill: {
+			effect: {
+				charlotte: true,
+				trigger: { player: "damageBegin4" },
+				filter(event, player) {
+					const evt = event.getParent(2);
+					return evt && evt.name == "useCard" && player.getStorage("dccilv_effect").includes(evt.card);
+				},
+				forced: true,
+				content() {
+					trigger.cancel();
+				},
+				ai: {
+					effect: {
+						target(card, player, target) {
+							if (player.getStorage("dccilv_effect").includes(card)) return "zeroplayertarget";
+						},
+					},
+				},
+			},
+		},
+	},
+	dctongdao: {
+		unique: true,
+		limited: true,
+		trigger: { player: "dying" },
+		skillAnimation: true,
+		animationColor: "fire",
+		async cost(event, trigger, player) {
+			event.result = await player
+				.chooseTarget(get.prompt2("dctongdao"))
+				.set("ai", target => {
+					const player = get.event("player");
+					if (player.hp + player.countCards("hs", card => player.canSaveCard(card, player)) > 0) return target == player ? 1 : 0;
+					return target.hp + 114514;
+				})
+				.forResult();
+		},
+		async content(event, trigger, player) {
+			const target = event.targets[0];
+			player.awakenSkill("dctongdao");
+			const removeSkills = target.getSkills(null, false, false).filter(i => {
+				const info = get.info(i);
+				return !info || !info.charlotte;
+			});
+			if (removeSkills.length) target.removeSkill(removeSkills);
+			const gainSkills = target.getStockSkills(true, true).filter(i => {
+				const info = get.info(i);
+				if (info && info.zhuSkill && !player.isZhu2()) return false;
+				return !info || !info.charlotte;
+			});
+			if (gainSkills.length) {
+				//抽象
+				//混沌初开——牢戏
+				Object.keys(target.storage)
+				.filter(i => gainSkills.some(skill => i.startsWith(skill)))
+				.forEach(storage => delete target.storage[storage]);
+				target.addSkill(gainSkills);
+				const suffixs = ["used", "round", "block", "blocker"];
+				for (const skill of gainSkills) {
+					const info = get.info(skill);
+					if (typeof info.usable == "number") {
+						if (target.hasSkill("counttrigger") && target.storage.counttrigger[skill] && target.storage.counttrigger[skill] >= 1) {
+							delete target.storage.counttrigger[skill];
+						}
+						if (typeof get.skillCount(skill) == "number" && get.skillCount(skill) >= 1) {
+							delete target.getStat("skill")[skill];
+						}
+					}
+					if (info.round && target.storage[skill + "_roundcount"]) {
+						delete target.storage[skill + "_roundcount"];
+					}
+					if (target.storage[`temp_ban_${skill}`]) {
+						delete target.storage[`temp_ban_${skill}`];
+					}
+					if (target.awakenedSkills.includes(skill)) {
+						target.restoreSkill(skill);
+					}
+					for (const suffix of suffixs) {
+						if (target.hasSkill(skill + "_" + suffix)) {
+							target.removeSkill(skill + "_" + suffix);
+						}
+					}
+				}
+			}
+			if (target != player && target.hp > player.hp) {
+				await player.recoverTo(target.hp);
+			}
+		},
+	},
+	//乐祢衡
+	dcjigu: {
+		audio: 2,
+		trigger: {
+			global: "phaseBefore",
+			player: "enterGame",
+		},
+		filter(event, player) {
+			return event.name != "phase" || game.phaseNumber == 0;
+		},
+		forced: true,
+		content() {
+			const cards = player.getCards("h");
+			player.addGaintag(cards, "dcjigu");
+		},
+		mod: {
+			ignoredHandcard(card) {
+				if (card.hasGaintag("dcjigu")) return true;
+			},
+			cardDiscardable(card, _, name) {
+				if (name == "phaseDiscard" && card.hasGaintag("dcjigu")) return false;
+			},
+		},
+		group: "dcjigu_temp",
+		subSkill: {
+			temp: {
+				audio: "dcjigu",
+				trigger: {
+					player: "damageEnd",
+					source: "damageSource",
+				},
+				filter(event, player) {
+					return player.countCards("e") == player.countCards("h", card => card.hasGaintag("dcjigu"));
+				},
+				usable: 1,
+				prompt2(event, player) {
+					return (
+						"摸" +
+						get.cnNumber(
+							Array.from({ length: 5 })
+								.map((_, i) => i + 1)
+								.reduce((sum, i) => sum + player.countEmptySlot(i), 0)
+						) +
+						"张牌"
+					);
+				},
+				content() {
+					player.draw(
+						Array.from({ length: 5 })
+							.map((_, i) => i + 1)
+							.reduce((sum, i) => sum + player.countEmptySlot(i), 0)
+					);
+				},
+			},
+		},
+	},
+	dcsirui: {
+		audio: 2,
+		enable: "phaseUse",
+		filter(event, player) {
+			if (!player.countCards("hes")) return false;
+			return get
+				.inpileVCardList(info => {
+					const name = info[2];
+					if (get.type(name) != "basic" && get.type(name) != "trick") return false;
+					return true;
+				})
+				.some(card => player.hasCard(cardx => get.cardNameLength(cardx) == get.cardNameLength(card[2]) && event.filterCard({ name: card[2], nature: card[3], cards: [cardx] }, player, event), "hes"));
+		},
+		usable: 1,
+		chooseButton: {
+			dialog(event, player) {
+				const list = get
+					.inpileVCardList(info => {
+						const name = info[2];
+						if (get.type(name) != "basic" && get.type(name) != "trick") return false;
+						return true;
+					})
+					.filter(card => player.hasCard(cardx => get.cardNameLength(cardx) == get.cardNameLength(card[2]) && event.filterCard({ name: card[2], nature: card[3], cards: [cardx] }, player, event), "hes"));
+				return ui.create.dialog("思锐", [list, "vcard"]);
+			},
+			check(button) {
+				return get.event("player").getUseValue({
+					name: button.link[2],
+					nature: button.link[3],
+				});
+			},
+			backup(links, player) {
+				return {
+					audio: "dcsirui",
+					filterCard(card, player) {
+						return get.cardNameLength(card) == get.cardNameLength(lib.skill.dcsirui_backup.viewAs.name);
+					},
+					popname: true,
+					viewAs: {
+						name: links[0][2],
+						nature: links[0][3],
+					},
+					check(card) {
+						return 7 - get.value(card);
+					},
+					position: "hes",
+				};
+			},
+			prompt(links, player) {
+				return "将一张字数为" + get.cardNameLength(links[0][2]) + "的牌当作" + get.translation(links[0][3] || "") + "【" + get.translation(links[0][2]) + "】使用";
+			},
+		},
+		ai: {
+			order(item, player) {
+				let list = get
+					.inpileVCardList(info => {
+						const name = info[2];
+						if (get.type(name) != "basic" && get.type(name) != "trick") return false;
+						return true;
+					})
+					.filter(card => player.hasCard(cardx => get.cardNameLength(cardx) == get.cardNameLength(card[2]) && player.hasUseTarget(get.autoViewAs({ name: card[2], nature: card[3] }, [cardx]), true, true), "hes"))
+					.map(card => {
+						return { name: card[2], nature: card[3] };
+					})
+					.filter(card => player.getUseValue(card, true, true) > 0);
+				if (!list.length) return 0;
+				list.sort((a, b) => (player.getUseValue(b, true, true) || 0) - (player.getUseValue(a, true, true) || 0));
+				return get.order(list[0], player) * 0.99;
+			},
+			result: { player: 1 },
+		},
+		subSkill: {
+			backup: { audio: "dcsirui" },
+		},
+	},
+	//侧肘
+	dcshefu: {
+		audio: 2,
+		trigger: {
+			player: "damageBegin2",
+			source: "damageBegin1",
+		},
+		filter(event, player) {
+			if (!event.source || event.source == event.player) return false;
+			const evt = event.getParent(2);
+			return evt && evt.name == "useCard";
+		},
+		forced: true,
+		logTarget(event, player) {
+			return event.source == player ? event.player : event.source;
+		},
+		content() {
+			const evt = trigger.getParent(2);
+			const cards = evt.cards.filter(card => {
+				if (trigger.source._start_cards.includes(card)) return true;
+				return trigger.source.getAllHistory("gain", evt => {
+					return evt.cards.includes(card);
+				}).length;
+			});
+			trigger.num =
+				cards.length +
+				cards.reduce((sum, card) => {
+					let num = 0,
+						history = trigger.source.actionHistory;
+					for (let i = history.length - 1; i >= 0; i--) {
+						if (history[i].gain.some(evtx => evtx.cards.includes(card))) break;
+						if (history[i].isRound) num++;
+						if (i == 0 && trigger.source._start_cards.includes(card)) num--;
+					}
+					return sum + num;
+				}, 0);
+		},
+		ai: {
+			effect: {
+				target(card, player, target) {
+					if (target == player || !get.tag(card, "damage")) return;
+					if (!(card.cards || []).length) return "zeroplayertarget";
+				},
+				player: function () {
+					return lib.skill.dcshefu.ai.effect.target.apply(this, arguments);
+				},
+			},
+		},
+	},
+	dcpigua: {
+		audio: 2,
+		trigger: { source: "damageSource" },
+		filter(event, player) {
+			if (event.player == player) return false;
+			return event.num > 1 && event.player.isIn() && event.player.countCards("he") && game.roundNumber > 0;
+		},
+		async cost(event, trigger, player) {
+			const target = trigger.player;
+			let result = await player.gainPlayerCard(target, "he", [1, game.roundNumber]).set("prompt", get.prompt2("dcpigua", target)).set("logSkill", ["dcpigua", target]).forResult();
+			result.bool = Boolean((result.cards || []).length);
+			event.result = result;
+		},
+		popup: false,
+		async content(event, trigger, player) {
+			player.addTempSkill("dcpigua_effect");
+			player.addGaintag(event.cards, "dcpigua_effect");
+		},
+		subSkill: {
+			effect: {
+				charlotte: true,
+				onremove(player, skill) {
+					player.removeGaintag(skill);
+				},
+				mod: {
+					ignoredHandcard(card) {
+						if (card.hasGaintag("dcpigua_effect")) return true;
+					},
+					cardDiscardable(card, _, name) {
+						if (name == "phaseDiscard" && card.hasGaintag("dcpigua_effect")) return false;
+					},
+				},
+			},
+		},
+	},
 	//李丰
 	dctunchu: {
 		audio: 2,
@@ -1590,12 +2189,12 @@ const skills = {
 						const card = player
 							.getCards("h", card => {
 								if (get.value(card) >= 7) return false;
-								return card.hasGaintag("dcqiqin_tag") && game.hasPlayer(target => target.canAddJudge(get.autoViewAs({ name: "dczixi_" + name }, [card])));
+								return card.hasGaintag("dcqiqin_tag") && game.hasPlayer(target => target.canAddJudge(get.autoViewAs({ name: "dczixi_" + button.link }, [card])));
 							})
 							.sort((a, b) => get.value(a) - get.value(b))[0];
 						if (
 							game.hasPlayer(current => {
-								return get.attitude(player, current) < 0 && lib.skill.dczixi.zixiList.some(name => current.canAddJudge(get.autoViewAs({ name: "dczixi_" + name }, [card])));
+								return get.attitude(player, current) < 0 && lib.skill.dczixi.zixiList.some(name => current.canAddJudge(get.autoViewAs({ name: "dczixi_" + button.link }, [card])));
 							})
 						)
 							return list.indexOf(button.link) + 1;

character/huicui/sort.js

@@ -11,8 +11,8 @@ const characterSort = {
 	sp_jishi: ["dc_jiben", "zhenghun", "dc_sunhanhua", "liuchongluojun", "wupu"],
 	sp_raoting: ["dc_huanghao", "dc_sunziliufang", "dc_sunchen", "dc_jiachong"],
 	sp_yijun: ["gongsundu", "mengyou", "dc_sp_menghuo", "gongsunxiu"],
-	sp_zhengyin: ["yue_caiwenji", "yue_zhoufei", "yue_caiyong", "yue_xiaoqiao", "yue_daqiao"],
-	sp_zhonghu: ["dc_jiangji", "dc_wangling", "dc_simashi", "dc_caoshuang"],
+	sp_zhengyin: ["yue_caiwenji", "yue_zhoufei", "yue_caiyong", "yue_xiaoqiao", "yue_daqiao", "yue_miheng", "yue_zoushi", "yue_zhugeguo"],
+	huicui_waitforsort: ["chezhou", "zhupeilan"],
 };
 
 const characterSortTranslate = {
@@ -29,7 +29,7 @@ const characterSortTranslate = {
 	sp_raoting: "绕庭之鸦",
 	sp_yijun: "异军突起",
 	sp_zhengyin: "正音雅乐",
-	sp_zhonghu: "冢虎狼顾",
+	huicui_waitforsort: "等待分包",
 };
 
 export { characterSort, characterSortTranslate };

character/huicui/translate.js

@@ -496,19 +496,16 @@ const translates = {
 	dcgangu_info: "锁定技。每回合限一次。当其他角色失去体力后，你摸两张牌，然后失去1点体力。",
 	dckuizhen: "溃阵",
 	dckuizhen_info: "出牌阶段限一次。你可以令一名手牌数或体力值大于你的角色视为对你使用一张【决斗】。若你：受到渠道为此牌的伤害，你观看其手牌并获得其中所有的【杀】（你使用以此法得到的牌无任何次数限制）；未受到渠道为此牌的伤害，其失去1点体力。",
-	dc_jiangji: "蒋济",
 	dcshiju: "势举",
 	dcshiju_info: "其他角色的出牌阶段限一次。其可以交给你一张牌，若此牌为装备牌，你可以使用之，然后其本回合攻击范围+X（X为你装备区里的牌数）。若你以此法替换了装备，你与其各摸两张牌。",
 	dcyingshi: "应时",
 	dcyingshi_info: "每回合每项各限一次。当你使用普通锦囊牌指定目标后，你可令其中一个目标选择一项：⒈令你于此牌结算结束后视为对其使用一张与此牌牌名相同的牌；⒉弃置X张牌，此牌对其无效（X为你装备区里的牌数）。",
-	dc_wangling: "王淩",
 	dcjichou: "集筹",
 	dcjichou_info: "出牌阶段结束时，若你于此阶段使用过牌且这些牌的牌名均不同，你可以观看位于弃牌堆中的这些牌，选择任意张牌并选择等量角色，将这些牌交给这些角色各一张，然后你摸X张牌（X为你本局游戏首次发动〖集筹〗给出的牌数）。",
 	dcmouli: "谋立",
 	dcmouli_info: "觉醒技。回合结束时，若你因〖集筹〗给出的牌的牌名总数大于5，你加1点体力上限并回复1点体力，然后获得〖自缚〗。",
 	dczifu: "自缚",
 	dczifu_info: "锁定技。出牌阶段开始时，你将手牌摸至体力上限（至多摸至五张）。若你以此法得到牌，你须选择手牌中不同牌名的牌各一张，然后弃置其余的手牌。",
-	dc_simashi: "司马师",
 	dcsanshi: "散士",
 	dcsanshi_tag: "死士",
 	dcsanshi_info: "锁定技。①第一轮游戏开始时，你令系统将牌堆中每个点数的随机一张牌永久标记为“死士”（“死士”对你可见）。②一名角色的回合结束时，若本回合有“死士”不因你使用或打出而进入弃牌堆，你于弃牌堆中获得这些牌。③你使用“死士”不能被响应。",
@@ -516,8 +513,6 @@ const translates = {
 	dczhenrao_info: "每回合每名角色限一次。当你使用牌指定第一个目标后，若目标角色包含其他角色，或当其他角色使用牌指定你为目标后，你可以选择手牌数大于你的其中一个目标或此牌的使用者，然后对其造成1点伤害。",
 	dcchenlve: "沉略",
 	dcchenlve_info: "限定技。出牌阶段，你可以将牌堆、弃牌堆、场上及其他角色的手牌区里的所有“死士”置入处理区，然后你获得这些牌。若如此做，你获得如下效果：1.此回合结束时，你将这些牌移出游戏；2.当你死亡时，你将所有以此法移出游戏的“死士”置入弃牌堆。",
-	dc_caoshuang: "新杀曹爽",
-	dc_caoshuang_prefix: "新杀",
 	dcjianzhuan: "渐专",
 	dcjianzhuan_info: "锁定技。①当你于出牌阶段使用牌时，你选择此阶段未执行过的一项执行：⒈令一名角色弃置X张牌；⒉摸X张牌；⒊重铸X张牌；⒋弃置X张牌（X为此技能于本阶段的发动次数）。②出牌阶段结束时，若你本阶段执行过〖渐专①〗的所有选项，则你随机移除〖渐专①〗的一项。",
 	dcjianzhuan_faq: "渐专概率",
@@ -537,6 +532,36 @@ const translates = {
 	dctunchu_info: "锁定技。①游戏开始时，你将手牌数摸至游戏人数的四倍。②你的手牌不能被弃置。③准备阶段，若你的手牌数大于你的体力值，则你本回合至多使用三张牌。",
 	dcshuliang: "输粮",
 	dcshuliang_info: "一名角色的回合结束时，你可以将任意张手牌交给任意名没有手牌的角色各一张，然后本次获得可以指定自己为目标的牌的角色可以依次选择是否使用本次获得的牌。",
+	chezhou: "车胄",
+	dcshefu: "慑伏",
+	dcshefu_info: "锁定技。你对其他角色/其他角色对你使用牌造成的伤害改为X（X为此牌对应的所有实体牌最近一次被伤害来源获得后至现在经过的轮次数之和）。",
+	dcpigua: "披挂",
+	dcpigua_info: "当你对一名其他角色造成超过1点伤害后，你可以获得其至多等同于游戏轮次的牌，这些牌本回合不计入你的手牌上限。",
+	yue_miheng: "乐祢衡",
+	yue_miheng_prefix: "乐",
+	dcjigu: "激鼓",
+	dcjigu_info: "锁定技。①游戏开始时，你将所有手牌标记为“激鼓”。②你的“激鼓”牌不计入手牌上限。③每回合限一次，当你造成或受到伤害后，若你的你的“激鼓”牌数等于你的装备区的牌数，则你可以摸X张牌（X为你的空缺装备栏数）。",
+	dcsirui: "思锐",
+	dcsirui_info: "出牌阶段限一次，你可以将一张牌当作与其字数相同的一张基本牌或普通锦囊牌使用。",
+	zhupeilan: "朱佩兰",
+	dccilv: "辞虑",
+	dccilv_info: "当你成为普通锦囊牌的目标后，你可以摸剩余选项数的牌，然后若你的手牌数大于你的体力上限，则你选择执行并移去一项：①令此牌对你无效；②防止此牌对你造成的伤害；③于此牌结算完毕后获得此牌对应的所有实体牌。",
+	dctongdao: "痛悼",
+	dctongdao_info: "限定技，当你进入濒死状态时，你可以选择一名角色，令其将其拥有的技能重置至游戏开始时的状态，然后若其不为你，则你将体力值回复至与其相同。",
+	yue_zoushi: "乐邹氏",
+	yue_zoushi_prefix: "乐",
+	dcyunzheng: "韵筝",
+	dcyunzheng_tag: "筝",
+	dcyunzheng_info: "锁定技。①游戏开始时，你将所有手牌标记为“筝”。②你的“筝”牌不计入手牌上限。③手牌中有“筝”的角色的非锁定技失效。",
+	dchuoxin: "惑心",
+	dchuoxin_info: "锁定技，当你使用手牌指定其他角色为目标后，你展示其一张手牌。若此牌为“筝”牌或与你使用牌花色相同，你获得之；否则你将此牌标记为“筝”。",
+	yue_zhugeguo: "乐诸葛果",
+	yue_zhugeguo_prefix: "乐",
+	dcxidi: "羲笛",
+	dcxidi_tag: "笛",
+	dcxidi_info: "锁定技。①游戏开始时，你将所有手牌标记为“笛”。②你的“笛”牌不计入手牌上限。③准备阶段，若你的手牌中有“笛”，则你观看牌堆顶X张牌，然后将这些牌以任意顺序置于牌堆顶和牌堆底（X为你手牌中的“笛”数，且X至多为5）。",
+	dcchengyan: "乘烟",
+	dcchengyan_info: "当你于出牌阶段使用【杀】或普通锦囊牌指定其他角色为目标后，你可以亮出牌堆顶的一张牌，若此牌为【杀】或可指定目标的普通锦囊牌，你将此牌对其的结算方式改为此牌牌名的结算方式；若此牌不为【杀】和普通锦囊牌，你获得此牌并将此牌标记为“笛”。",
 };
 
 export default translates;

character/huicui/voices.js

@@ -195,7 +195,9 @@ export default {
 	"#dcanliao2": "水草丰沛，当展宏图。",
 	"#gongsundu:die": "为何都不愿出仕！",
 	"#dcyiyong1": "关氏鼠辈，庞令明之子来邪！",
-	"#dcyiyong2": "凭一腔勇力，父仇定可报还。",
+	"#dcyiyong2": "凭一腔勇力，父仇定可报还！",
+	"#dcsuchou1": "关家人我杀定了，谁也保不住！",
+	"#dcsuchou2": "身陷仇海，谁知道我是怎么过的！",
 	"#panghui:die": "大仇虽报，奈何心有余创……",
 	"#dccuijin1": "军令如山，诸君焉敢不前？",
 	"#dccuijin2": "前攻者赏之，后靡斩之！",
@@ -459,4 +461,9 @@ export default {
 	"#llqshenwei2": "红妆非我愿，学武觅封侯。",
 	"#wushuang_lvlingqi1": "猛将策良骥，长戟破敌营。",
 	"#wushuang_lvlingqi2": "杀气腾剑戟，严风卷戎装。",
+	"#dcjigu1": "我接着奏乐，诸公接着舞。",
+	"#dcjigu2": "这不是鼓，而是曹公的脸面！",
+	"#dcsirui1": "暑气可借酒气消，此间艳阳醉着酒。",
+	"#dcsirui2": "诸君饮泥而醉，举事唯我独醒！",
+	"#yue_miheng:die": "映日荷花今犹在，不见当年采荷人……",
 };

character/jsrg/skill.js

@@ -8041,7 +8041,7 @@ const skills = {
 				})
 				.set("max", trigger.target.countDiscardableCards(player, "he"))
 				.set("goon", get.attitude(player, trigger.target) < 0)
-				.set("logSkill", ["jsrgjuelie_discard", trigger.target]);
+				.set("logSkill", ["jsrgjuelie", trigger.target]);
 			("step 1");
 			if (result.bool) {
 				var num = result.cards.length;

character/mobile/characterReplace.js

@@ -18,7 +18,7 @@ const characterReplaces = {
 	sunhanhua: ["dc_sunhanhua", "sunhanhua"],
 	zhoubuyi: ["zhoubuyi", "yj_zhoubuyi"],
 	xianglang: ["xianglang", "mb_xianglang"],
-	miheng: ["re_miheng", "miheng"],
+	miheng: ["yue_miheng", "re_miheng", "miheng"],
 	peixiu: ["ol_peixiu", "peixiu"],
 };
 

character/mobile/translate.js

@@ -360,8 +360,7 @@ const translates = {
 	requanfeng_info: "限定技。①其他角色死亡时，你可失去〖弘仪〗，然后获得其武将牌上的所有非主公技，非隐匿技和非Charlotte技，加1点体力上限并回复1点体力。②当你处于濒死状态时，你可以加2点体力上限，然后回复4点体力。",
 	quanfeng: "劝封",
 	quanfeng_info: "锁定技，限定技，一名角色死亡时，你选择获得其的一个技能（主公技，限定技，觉醒技，隐匿技，使命技，带有Charlotte标签的技能除外），然后加1点体力上限并回复1点体力。",
-	simashi: "手杀司马师",
-	simashi_prefix: "手杀",
+	simashi: "司马师",
 	baiyi: "败移",
 	baiyi_info: "限定技，出牌阶段，若你已受伤，你可以交换两名其他角色的座次。",
 	jinglve: "景略",
@@ -787,8 +786,7 @@ const translates = {
 	mutao_info: "出牌阶段限一次。你可以选择一名角色，令其将手牌中所有的【杀】置于武将牌上，然后将这些牌依次随机交给其下家开始的每一名角色。然后其对最后一名以此法获得【杀】的角色A造成X点伤害（X为A手牌中【杀】的数量且至多为2）。",
 	yimou: "毅谋",
 	yimou_info: "当一名角色受到伤害后，若其存活且你至其的距离不大于1，你可以选择一项：1.令其从牌堆中获得一张【杀】；2.令其将一张手牌交给另一名角色，然后摸一张牌。",
-	jiangji: "手杀蒋济",
-	jiangji_prefix: "手杀",
+	jiangji: "蒋济",
 	jilun: "机论",
 	jilun_info: "①当你受到伤害后，若你拥有技能〖急筹〗，则你可以一项：1.摸两张牌。2.获得1枚“机论”标记。②一名角色的结束阶段，若你拥有“机论”，则重复选择执行以下项直到你没有“机论”标记：1.失去1枚“机论”标记，视为使用一张〖急筹①〗记录过且未被〖机论②〗记录过的普通锦囊牌并记录此牌牌名。2.失去所有“机论”标记。",
 	liwei: "李遗",

character/onlyOL/skill.js

@@ -394,7 +394,7 @@ const skills = {
 				if (result.index == 0) {
 					await player.gainPlayerCard(target, "he", true);
 				} else {
-					player.addTempSkill("olzhenjie_effect");
+					player.addTempSkill("olzhenlie_effect");
 					player.addMark("olzhenlie_effect", 1, false);
 				}
 			}

character/rank.js

@@ -147,6 +147,8 @@ window.noname_character_rank = {
 		"guanyue",
 		"wupu",
 		"xukun",
+		"ol_feiyi",
+		"ol_jiangwan",
 	],
 	a: [
 		"star_caoren",
@@ -285,6 +287,9 @@ window.noname_character_rank = {
 		"zhangqiying",
 		"wangyuanji",
 		"miheng",
+		"yue_miheng",
+		"chezhou",
+		"zhupeilan",
 		"re_guojia",
 		"re_sunquan",
 		"re_zhangjiao",
@@ -712,6 +717,7 @@ window.noname_character_rank = {
 		"jsrg_yuanshao",
 		"sb_handang",
 		"sb_gongsunzan",
+		"yue_zoushi",
 	],
 	bp: [
 		"ol_peixiu",
@@ -1136,6 +1142,7 @@ window.noname_character_rank = {
 		"mb_simafu",
 	],
 	b: [
+		"yue_zhugeguo",
 		"std_dc_yanghu",
 		"std_re_dengzhi",
 		"std_mateng",
@@ -1773,6 +1780,7 @@ window.noname_character_rank = {
 	],
 	rarity: {
 		legend: [
+			"ol_feiyi",
 			"dc_wuyi",
 			"sp_sunce",
 			"star_caoren",
@@ -1975,6 +1983,7 @@ window.noname_character_rank = {
 			"jsrg_yuanshao",
 		],
 		epic: [
+			"ol_jiangwan",
 			"xukun",
 			"clan_zhongyao",
 			"dc_caoshuang",
@@ -2268,8 +2277,12 @@ window.noname_character_rank = {
 			"jsrg_zhangjiao",
 			"ol_sb_pangtong",
 			"dc_sb_zhugejin",
+			"yue_miheng",
 		],
 		rare: [
+			"yue_zhugeguo",
+			"yue_zoushi",
+			"chezhou",
 			"std_sunhao",
 			"std_chengpu",
 			"std_mayunlu",
@@ -2842,6 +2855,7 @@ window.noname_character_rank = {
 			"junk_xuyou",
 			"re_zhongyao",
 			"junk_zhangjiao",
+			"zhupeilan",
 		],
 	},
 };

character/shiji/characterReplace.js

@@ -21,6 +21,7 @@ const characterReplaces = {
 	sp_jiangqing: ["sp_jiangqing", "tw_jiangqing", "jiangqing"],
 	kongrong: ["dc_kongrong", "sp_kongrong", "jsrg_kongrong", "kongrong"],
 	dc_mifuren: ["dc_mifuren", "sp_mifuren"],
+	sp_jiangwan: ["ol_jiangwan", "sp_jiangwan"],
 };
 
 export default characterReplaces;

character/shiji/translate.js

@@ -125,8 +125,7 @@ const translates = {
 	spchijie_info: "每回合限一次。当你成为其他角色使用牌的唯一目标时，你可判定。若结果大于6，则你取消此牌的所有目标。",
 	reduoji: "夺冀",
 	reduoji_info: "出牌阶段限一次，你可将一张牌置于其他角色的武将牌上，称为“冀”。当有装备牌因使用而进入一名角色的装备区后，若该角色有“冀”且其为使用者，则你获得此装备牌，其移去一个“冀”并摸一张牌。一名其他角色的回合结束后，若其有“冀”，则你获得其的所有“冀”。",
-	wangling: "手杀王淩",
-	wangling_prefix: "手杀",
+	wangling: "王淩",
 	mouli: "谋立",
 	mouli_info: "出牌阶段限一次，你可以将一张手牌交给一名其他角色，其获得如下效果直到你的下回合开始：其可以将黑色牌当做【杀】，红色牌当做【闪】使用。其第一次触发“使用【杀】/【闪】结算完成后”的时机时，你摸三张牌。",
 	zifu: "自缚",
@@ -282,7 +281,8 @@ const translates = {
 	spdifei_info: "锁定技。每回合限一次，当你受到伤害后，你摸一张牌或弃置一张手牌，然后展示所有手牌。若此伤害的渠道为没有花色的牌或你的手牌中没有与此牌花色相同的牌，则你回复1点体力。",
 	spyanjiao: "严教",
 	spyanjiao_info: "出牌阶段限一次。你可以将手牌中一种花色的所有牌交给一名其他角色，对其造成1点伤害。然后你于自己的下回合开始时摸等量的牌。",
-	sp_jiangwan: "蒋琬",
+	sp_jiangwan: "手杀蒋琬",
+	sp_jiangwan_prefix: "手杀",
 	spzhenting: "镇庭",
 	spzhenting_info: "每回合限一次。当你攻击范围内的角色成为【杀】或延时锦囊的目标时，若你不是此牌的使用者且不是此牌的目标，则你可以将此目标改为自己。然后你选择一项：①弃置使用者的一张手牌。②摸一张牌。",
 	spjincui: "尽瘁",

character/sp/character.js

@@ -1,4 +1,5 @@
 const characters = {
+	ol_jiangwan: ["male", "shu", 3, ["olziruo", "olxvfa"]],
 	caimao: ["male", "wei", 4, ["olzuolian", "oljingzhou"]],
 	ol_peixiu: ["male", "wei", 4, ["olmaozhu", "oljinlan"]],
 	yadan: ["male", "qun", 4, ["olqingya", "oltielun"]],

character/sp/dynamicTranslate.js

@@ -87,5 +87,9 @@ const dynamicTranslates = {
 		if (player.storage.olxuanzhu) return '转换技，每回合限一次，你可以将一张牌称为“玄”置于武将牌上，然后视为使用：阴，任意基本牌；<span class="bluetext">阳，任意普通锦囊牌（须指定目标且仅指定一个目标）</span>。若此次置于武将牌上的“玄”：不为装备牌，你弃置一张牌；为装备牌，你将所有“玄”置入弃牌堆，然后摸等量的牌。';
 		return '转换技，每回合限一次，你可以将一张牌称为“玄”置于武将牌上，然后视为使用：<span class="bluetext">阴，任意基本牌</span>；阳，任意普通锦囊牌（须指定目标且仅指定一个目标）。若此次置于武将牌上的“玄”：不为装备牌，你弃置一张牌；为装备牌，你将所有“玄”置入弃牌堆，然后摸等量的牌。';
 	},
+	olziruo(player){
+		if (player.storage.olziruo) return '转换技，锁定技。①你不能整理手牌。②当你使用最{阴：左；<span class="bluetext">阳：右</span>}侧的手牌时，你摸一张牌。';
+		return '转换技，锁定技。①你不能整理手牌。②当你使用最{<span class="bluetext">阴：左</span>；阳：右}侧的手牌时，你摸一张牌。';
+	},
 };
 export default dynamicTranslates;

character/sp/skill.js

@@ -2,6 +2,187 @@ import { lib, game, ui, get, ai, _status } from "../../noname.js";
 
 /** @type { importCharacterConfig['skill'] } */
 const skills = {
+	//蒋济
+	olziruo: {
+		audio: 2,
+		trigger: { player: "useCard" },
+		filter(event, player) {
+			if (!event.olziruo || !event.olziruo[player.playerid]) return false;
+			return event.olziruo[player.playerid][Boolean(player.storage.olziruo) ? 1 : 0];
+		},
+		forced: true,
+		async content(event, trigger, player) {
+			player.changeZhuanhuanji("olziruo");
+			await player.draw();
+		},
+		mark: true,
+		marktext: "☯",
+		zhuanhuanji: true,
+		intro: { content: storage => "当你使用最" + (storage ? "右" : "左") + "侧的卡牌时，你摸一张牌" },
+		global: "olziruo_mark",
+		ai: { noSortCard: true },
+		mod: {
+			aiOrder(player, card, num) {
+				if (typeof card == "object") {
+					const cards = player.getCards("h");
+					if (cards.indexOf(card) == (player.storage.olziruo ? cards.length - 1 : 0)) return num + 10;
+				}
+			},
+		},
+		subSkill: {
+			mark: {
+				charlotte: true,
+				trigger: { player: "useCardBegin" },
+				filter(event, player) {
+					const cards = player.getCards("h");
+					if (!cards.length) return false;
+					return (event.cards || []).some(card => cards[0] == card || cards[cards.length - 1] == card);
+				},
+				forced: true,
+				popup: false,
+				content() {
+					const cards = player.getCards("h");
+					if (!trigger.olziruo) trigger.olziruo = {};
+					trigger.olziruo[player.playerid] = [trigger.cards.some(card => cards[0] == card), trigger.cards.some(card => cards[cards.length - 1] == card)];
+				},
+			},
+		},
+	},
+	olxvfa: {
+		audio: 2,
+		enable: "phaseUse",
+		filter(event, player) {
+			return (!player.hasSkill("olxvfa_0") && player.countCards("h")) || (!player.hasSkill("olxvfa_1") && player.getExpansions("olxvfa").length);
+		},
+		chooseButton: {
+			dialog(_, player) {
+				let dialog = ui.create.dialog("蓄发：请选择一项", "hidden");
+				const list = [
+					["0", "将至少一半手牌称为“蓄发”置于武将牌上（向上取整），然后可以视为使用“蓄发”牌中的一张普通锦囊牌"],
+					["1", "移去一半“蓄发”牌（向上取整），然后可以视为使用其中一张普通锦囊牌"],
+				].filter(listx => {
+					if (listx[0] == "0") return !player.hasSkill("olxvfa_0") && player.countCards("h");
+					return !player.hasSkill("olxvfa_1") && player.getExpansions("olxvfa").length;
+				});
+				dialog.add([list, "textbutton"]);
+				if (list.length == 1) dialog.direct = true;
+				return dialog;
+			},
+			filter(button, player) {
+				if (button.link == "0") return !player.hasSkill("olxvfa_0") && player.countCards("h");
+				return !player.hasSkill("olxvfa_1") && player.getExpansions("olxvfa").length;
+			},
+			check: () => 1 + Math.random(),
+			backup: links => get.copy(lib.skill["olxvfa_" + ["put", "remove"][parseInt(links[0])]]),
+			prompt(links) {
+				if (links[0] == "0") return "###蓄发###将至少一半手牌称为“蓄发”置于武将牌上（向上取整），然后可以视为使用“蓄发”牌中的一张普通锦囊牌";
+				return "###蓄发###移去一半“蓄发”牌（向上取整），然后可以视为使用其中一张普通锦囊牌";
+			},
+		},
+		intro: {
+			content: "expansion",
+			markcount: "expansion",
+		},
+		onremove(player, skill) {
+			const cards = player.getExpansions(skill);
+			if (cards.length) player.loseToDiscardpile(cards);
+		},
+		subSkill: {
+			backup: {},
+			0: { charlotte: true },
+			1: { charlotte: true },
+			put: {
+				audio: "olxvfa",
+				filterCard: true,
+				selectCard: () => [Math.ceil(get.event("player").countCards("h") / 2), Infinity],
+				position: "h",
+				check(card) {
+					const player = get.event("player"),
+						value = player.getUseValue(card, true);
+					if (value > 0) return get.type(card) == "trick" ? 20 + value : 0;
+					return 15 - get.value(card) - get.useful(card);
+				},
+				lose: false,
+				discard: false,
+				delay: 0,
+				async content(event, trigger, player) {
+					player.addTempSkill("olxvfa_0", "phaseUseAfter");
+					await player.addToExpansion(event.cards, player, "give").set("gaintag", ["olxvfa"]);
+					const cards = player.getExpansions("olxvfa");
+					if (cards.some(card => get.type(card) == "trick" && player.hasUseTarget({ name: card.name, isCard: true }, true))) {
+						const result = await player
+							.chooseButton(["蓄发：是否视为使用一张“蓄发”牌？", cards])
+							.set("filterButton", button => {
+								const player = get.event("player"),
+									card = button.link;
+								return get.type(card) == "trick" && player.hasUseTarget({ name: card.name, isCard: true }, true);
+							})
+							.set("ai", button => {
+								const player = get.event("player"),
+									card = button.link;
+								return player.getUseValue({ name: card.name, isCard: true }, true);
+							})
+							.forResult();
+						if (result.bool) {
+							const card = result.links[0];
+							await player.chooseUseTarget({ name: card.name, isCard: true }, true, false);
+						}
+					}
+				},
+			},
+			remove: {
+				audio: "olxvfa",
+				filterCard: () => false,
+				selectCard: -1,
+				delay: 0,
+				async content(event, trigger, player) {
+					player.addTempSkill("olxvfa_1", "phaseUseAfter");
+					const cards = player.getExpansions("olxvfa"),
+						num = Math.ceil(cards.length / 2);
+					const result = await player
+						.chooseButton(["蓄发：请移去至少" + get.cnNumber(num) + "张“蓄发”牌", cards], [num, Infinity], true)
+						.set("ai", button => {
+							const player = get.event("player"),
+								value = player.getUseValue(button.link, true);
+							if (value > 0 && get.type(button.link) == "trick") {
+								if (
+									!ui.selected.buttons.some(but => {
+										return get.type(but.link) == "trick" && player.getUseValue(but.link, true) > 0;
+									})
+								)
+									return 20 + value;
+								return 0;
+							}
+							return 1 / (get.useful(button.link) || 0.5);
+						})
+						.forResult();
+					if (result.bool) {
+						const cardx = result.links;
+						await player.loseToDiscardpile(cardx);
+						if (cardx.some(card => get.type(card) == "trick" && player.hasUseTarget({ name: card.name, isCard: true }, true))) {
+							const result2 = await player
+								.chooseButton(["蓄发：是否视为使用一张移去的“蓄发”牌？", cardx])
+								.set("filterButton", button => {
+									const player = get.event("player"),
+										card = button.link;
+									return get.type(card) == "trick" && player.hasUseTarget({ name: card.name, isCard: true }, true);
+								})
+								.set("ai", button => {
+									const player = get.event("player"),
+										card = button.link;
+									return player.getUseValue({ name: card.name, isCard: true }, true);
+								})
+								.forResult();
+							if (result2.bool) {
+								const card = result2.links[0];
+								await player.chooseUseTarget({ name: card.name, isCard: true }, true, false);
+							}
+						}
+					}
+				},
+			},
+		},
+	},
 	//蔡瑁
 	olzuolian: {
 		audio: 2,

character/sp/sort.js

@@ -12,7 +12,7 @@ const characterSort = {
 	sp_zhongdan: ["cuiyan", "huangfusong"],
 	sp_guozhan2: ["sp_dongzhuo", "zhangren"],
 	sp_others: ["hanba", "caiyang"],
-	sp_waitforsort: ["ol_luyusheng", "ol_tw_zhangji", "ol_liwan", "ol_liuyan", "ol_peixiu", "caimao"],
+	sp_waitforsort: ["ol_luyusheng", "ol_tw_zhangji", "ol_liwan", "ol_liuyan", "ol_peixiu", "caimao", "ol_jiangwan"],
 };
 
 const characterSortTranslate = {

character/sp/translate.js

@@ -1261,6 +1261,11 @@ const translates = {
 	olzuolian_info: "出牌阶段限一次，你可以选择至多X名有牌的角色（X为你的体力值），你随机展示这些角色的各一张牌，然后你可以将这些牌与牌堆和弃牌堆中的属性【杀】进行交换。",
 	oljingzhou: "精舟",
 	oljingzhou_info: "当你受到伤害时，你可以选择至多X名角色（X为你的体力值）这些角色中处于/未处于连环状态的角色重置/横置武将牌。",
+	ol_jiangwan:'蒋琬',
+	olziruo:'自若',
+	olziruo_info:'转换技，锁定技。①你不能整理手牌。②当你使用最{阴：左；阳：右}侧的手牌时，你摸一张牌。',
+	olxvfa:'蓄发',
+	olxvfa_info:'出牌阶段各限一次，你可以：①将至少一半手牌称为“蓄发”置于武将牌上（向上取整），然后你可以视为使用“蓄发”牌中的一张普通锦囊牌；②移去一半“蓄发”牌（向上取整），然后你可以视为使用其中一张普通锦囊牌。',
 };
 
 export default translates;

character/sp/voices.js

@@ -760,4 +760,7 @@ export default {
 	"#olpijing1": "今青锋在手，必破敌军于域外。",
 	"#olpijing2": "荆楚多锦绣，安能丧于小儿之手！",
 	"#liupan:die": "今袍泽离散，无以为战……",
+	"#olqingya1": "罡风从虎，威震四方！",
+	"#olqingya1": "铁车过处，寸草不生！",
+	"#yadan:die": "多谢丞相不杀之恩……",
 };

character/sp2/characterReplace.js

@@ -31,7 +31,7 @@ const characterReplaces = {
 	jsp_guanyu: ["jsp_guanyu", "dc_jsp_guanyu", "jsrg_guanyu"],
 	mushun: ["mushun", "sp_mushun"],
 	wangjun: ["dc_wangjun", "wangjun"],
-	zoushi: ["re_zoushi", "jsrg_zoushi"],
+	re_zoushi: ["yue_zoushi", "re_zoushi", "jsrg_zoushi"],
 	zhangmancheng: ["dc_zhangmancheng", "tw_zhangmancheng"],
 };
 

character/xianding/character.js

@@ -1,4 +1,8 @@
 const characters = {
+	dc_caoshuang: ["male", "wei", 4, ["dcjianzhuan", "dcfanshi"]],
+	dc_simashi: ["male", "wei", 3, ["dcsanshi", "dczhenrao", "dcchenlve"]],
+	dc_wangling: ["male", "wei", 4, ["dcjichou", "dcmouli"], ["clan:太原王氏"]],
+	dc_jiangji: ["male", "wei", 3, ["dcshiju", "dcyingshi"]],
 	dc_sb_zhugejin: ["male", "wu", 3, ["dcsbtaozhou", "dcsbhoude"]],
 	dc_sb_jiaxu: ["male", "qun", 3, ["dcsbsushen", "dcsbfumou"]],
 	guanyue: ["male", "shu", 4, ["dcshouzhi", "dcfenhui"]],

character/xianding/index.js

@@ -22,7 +22,7 @@ game.import("character", function () {
 		characterSubstitute: {
 			dc_sb_simayi: [],
 			dc_sb_zhouyu: [],
-			//dc_sb_lusu: [],
+			dc_sb_lusu: [],
 		},
 		characterFilter: { ...characterFilters },
 		characterTitle: {

character/xianding/skill.js

@@ -2919,8 +2919,7 @@ const skills = {
 				yield player.logSkill("dcsbmengmou", target);
 				player.addTempSkill("dcsbmengmou_" + (storage || false));
 				player.changeZhuanhuanji("dcsbmengmou");
-				//鲁肃暂时没有另一张原画（悲
-				//player.changeSkin("dcsbmengmou", "dc_sb_lusu" + (player.storage.dcsbmengmou ? "_shadow" : ""));
+				player.changeSkin("dcsbmengmou", "dc_sb_lusu" + (player.storage.dcsbmengmou ? "_shadow" : ""));
 				while (num > 0) {
 					num--;
 					var result2;
@@ -2988,8 +2987,7 @@ const skills = {
 				check: () => Math.random() > 0.5,
 				content() {
 					player.changeZhuanhuanji("dcsbmengmou");
-					//鲁肃暂时没有另一张原画（悲
-					//player.changeSkin("dcsbmengmou", "dc_sb_lusu" + (player.storage.dcsbmengmou ? "_shadow" : ""));
+					player.changeSkin("dcsbmengmou", "dc_sb_lusu" + (player.storage.dcsbmengmou ? "_shadow" : ""));
 				},
 			},
 		},

character/xianding/sort.js

@@ -14,6 +14,7 @@ const characterSort = {
 	sp2_gaoshan: ["wanglang", "liuhui", "zhangjian"],
 	sp2_wumiao: ["wu_zhugeliang", "wu_luxun", "wu_guanyu"],
 	sp2_mouding: ["dc_sb_jiaxu", "dc_sb_lusu", "dc_sb_zhouyu", "dc_sb_simayi"],
+	sp2_zhonghu: ["dc_jiangji", "dc_wangling", "dc_simashi", "dc_caoshuang"],
 	sp2_zijing: ["dc_sb_zhugejin"],
 };
 
@@ -33,6 +34,7 @@ const characterSortTranslate = {
 	sp2_gaoshan: "高山仰止",
 	sp2_qifu: "祈福",
 	sp2_mouding: "谋定天下",
+	sp2_zhonghu: "冢虎狼顾",
 	sp2_zijing: "子敬邀刀",
 };
 

character/xianding/translate.js

@@ -607,6 +607,14 @@ const translates = {
 	dcsbhoude_info: "当你于其他角色的出牌阶段内首次成为红色【杀】/黑色普通锦囊牌的目标后，你可以弃置你/其的一张牌，令此牌对你无效。",
 	dcsbzijin: "自矜",
 	dcsbzijin_info: "锁定技。①你不能成为〖讨州〗的目标。②当你使用牌结算结束后，若此牌未造成过伤害，你须弃置一张牌或失去1点体力。",
+	dc_wangling: "新杀谋王淩",
+	dc_wangling_prefix: "新杀谋",
+	dc_simashi: "新杀谋司马师",
+	dc_simashi_prefix: "新杀谋",
+	dc_caoshuang: "新杀谋曹爽",
+	dc_caoshuang_prefix: "新杀谋",
+	dc_jiangji: "新杀谋蒋济",
+	dc_jiangji_prefix: "新杀谋",
 };
 
 export default translates;

character/xianding/voices.js

@@ -65,8 +65,8 @@ export default {
 	"#dc_sb_zhouyu:die": "人生之艰难，犹如不息之长河……",
 	"#dcsbmingshi1": "联刘以抗曹，此可行之大势。",
 	"#dcsbmingshi2": "强敌在北，唯协力可御之。",
-	"#dcsbmengmou1": "合左抑右，定两家之盟。",
-	"#dcsbmengmou2": "求同存异，邀英雄问鼎。",
+	"#dcsbmengmou1": "南北同仇，请皇叔移驾江东，共观花火。",
+	"#dcsbmengmou2": "孙刘一家，慕英雄之意，忾窃汉之敌。",
 	"#dc_sb_lusu:die": "虎可为之用，亦可为之伤……",
 	"#dcqiongying1": "冰心碎玉壶，光转琼英灿。",
 	"#dcqiongying2": "玉心玲珑意，撷英倚西楼。",

noname/library/element/content.js

@@ -3152,7 +3152,6 @@ export const Content = {
 		game.syncState();
 		game.addVideo("phaseChange", player);
 		if (game.phaseNumber == 1) {
-			delete player._start_cards;
 			if (lib.configOL.observe) {
 				lib.configOL.observeReady = true;
 				game.send("server", "config", lib.configOL);

noname/ui/create/index.js

@@ -2770,7 +2770,7 @@ export class Create {
 		// }
 
 		ui.sortCard = ui.create.system("整理手牌", function () {
-			if (!game.me) return;
+			if (!game.me || game.me.hasSkillTag("noSortCard")) return;
 			var hs = game.me.getCards("h");
 			if (!hs.length) return;
 			game.addVideo("lose", game.me, [get.cardsInfo(hs), [], [], []]);