Merge pull request #1366 from mengxinzxz/PR-Branch

标准包2024

character/rank.js

@@ -1102,8 +1102,24 @@ window.noname_character_rank = {
 		"ol_wangyi",
 		"chengji",
 		"mb_sp_guanqiujian",
+		"std_sunhao",
+		"std_chengpu",
+		"std_mayunlu",
+		"std_jianggan",
+		"std_zhouchu",
+		"std_lvlingqi",
+		"std_dc_luotong",
+		"std_db_wenyang",
+		"std_zhangyì",
+		"std_chengyu",
+		"std_fanyufeng",
+		"std_feiyi",
 	],
 	b: [
+		"std_dc_yanghu",
+		"std_re_dengzhi",
+		"std_mateng",
+		"std_lijue",
 		"junk_guanyu",
 		"liyi",
 		"diy_feishi",
@@ -2223,6 +2239,18 @@ window.noname_character_rank = {
 			"star_sunjian",
 		],
 		rare: [
+			"std_sunhao",
+			"std_chengpu",
+			"std_mayunlu",
+			"std_jianggan",
+			"std_zhouchu",
+			"std_lvlingqi",
+			"std_dc_luotong",
+			"std_db_wenyang",
+			"std_zhangyì",
+			"std_chengyu",
+			"std_fanyufeng",
+			"std_feiyi",
 			"linghuyu",
 			"yj_simafu",
 			"yj_xuangongzhu",

character/standard/character.js

@@ -32,6 +32,23 @@ const characters = {
 
 	xf_yiji: ["male", "shu", 3, ["xinfu_jijie", "xinfu_jiyuan"], []],
 	re_yuanshu: ["male", "qun", 4, ["rewangzun", "retongji"]],
+
+	std_sunhao: ["male", "wu", 5, ["stdcanshi", "chouhai", "guiming"], ["zhu"]],
+	std_mateng: ["male", "qun", 4, ["stdxiongyi", "mashu", "stdyouji"], ["zhu"]],
+	std_mayunlu: ["female", "shu", 4, ["stdfengpo", "mashu"]],
+	std_jianggan: ["male", "wei", 3, ["stddaoshu", "stddaizui"]],
+	std_zhouchu: ["male", "wu", 4, ["stdxiongxia"]],
+	std_lvlingqi: ["female", "qun", 4, ["stdhuizhan"]],
+	std_dc_yanghu: ["male", "wei", 4, ["stdmingfa"]],
+	std_dc_luotong: ["male", "wu", 3, ["stdjinjian", "stdrenzheng"]],
+	std_lijue: ["male", "qun", 5, ["stdxiongsuan"]],
+	std_chengpu: ["male", "wu", 4, ["stdchunlao"]],
+	std_db_wenyang: ["male", "wei", 4, ["stdquedi"]],
+	std_re_dengzhi: ["male", "shu", 3, ["stdzhiyinmeng", "stdhehe"]],
+	std_zhangyì: ["male", "shu", 4, ["stdzhiyi"]],
+	std_chengyu: ["male", "wei", 3, ["stdshefu", "stdyibing"]],
+	std_fanyufeng: ["female", "qun", 3, ["stdbazhan", "stdzhanying"]],
+	std_feiyi: ["male", "shu", 3, ["stdtiaohe", "stdqiansu"]],
 };
 
 export default characters;

character/standard/skill.js

@@ -2,6 +2,974 @@ import { lib, game, ui, get, ai, _status } from "../../noname.js";
 
 /** @type { importCharacterConfig['skill'] } */
 const skills = {
+	//2024标包武将
+	//孙皓
+	stdcanshi: {
+		audio: "canshi",
+		inherit: "canshi",
+		forced: true,
+		async content(event, trigger, player) {
+			trigger.changeToZero();
+			await player.draw(
+				Math.max(
+					1,
+					game.countPlayer(target => {
+						if (player.hasSkill("guiming") && target != player && target.group == "wu") return true;
+						return target.isDamaged();
+					})
+				)
+			);
+			player.addTempSkill("stdcanshi_effect");
+		},
+		subSkill: {
+			effect: {
+				charlotte: true,
+				trigger: { player: "useCardToPlayered" },
+				filter(event, player) {
+					if (event.card.name != "sha" && get.type(event.card) != "trick") return false;
+					return event.target.isDamaged();
+				},
+				forced: true,
+				autodelay: true,
+				content() {
+					player.chooseToDiscard("he", true);
+				},
+			},
+		},
+	},
+	//马腾
+	stdxiongyi: {
+		unique: true,
+		limited: true,
+		audio: "xiongyi",
+		filterTarget: true,
+		selectTarget: [1, Infinity],
+		skillAnimation: true,
+		animationColor: "thunder",
+		async content(event, trigger, player) {
+			player.awakenSkill("stdxiongyi");
+			const targets = event.targets.sortBySeat();
+			let keep = true;
+			while (true) {
+				for (const target of targets) {
+					let next = target
+						.chooseToUse(function (card) {
+							const event = get.event();
+							if (!lib.filter.cardEnabled(card, event.player, event)) return false;
+							return get.name(card) == "sha";
+						}, "雄异：是否使用一张不可被响应的【杀】？")
+						.set("oncard", card => {
+							_status.event.directHit.addArray(game.players);
+						});
+					if (!keep) next.set("prompt2", "若你不使用，则结束此流程");
+					const result = await next.forResult();
+					if (!result.bool && !keep) break;
+					if (targets[targets.length - 1] == target && !keep) keep = true;
+				}
+			}
+		},
+		ai: {
+			order: 10,
+			result: {
+				target(player, target) {
+					if (player.hasUnknown()) return 0;
+					return target.countCards("hs");
+				},
+			},
+		},
+	},
+	stdyouji: {
+		audio: 2,
+		trigger: { player: "phaseZhunbeiBegin" },
+		filter(event, player) {
+			return player.canMoveCard(
+				null,
+				true,
+				game.filterPlayer(i => {
+					return i.group == "qun";
+				}),
+				card => {
+					return [3, 4, 6].includes(parseInt(get.subtype(card).slice("equip".length)));
+				},
+				"nojudge"
+			);
+		},
+		direct: true,
+		zhuSkill: true,
+		content() {
+			player
+				.moveCard(
+					true,
+					game.filterPlayer(i => {
+						return i.group == "qun";
+					}),
+					card => {
+						return [3, 4, 6].includes(parseInt(get.subtype(card).slice("equip".length)));
+					}
+				)
+				.set("prompt", get.prompt2("stdyouji"))
+				.set("nojudge", true)
+				.set("logSkill", "stdyouji");
+		},
+	},
+	//马云禄
+	stdfengpo: {
+		audio: "fengpo",
+		trigger: { source: "damageBegin1" },
+		filter(event, player) {
+			return (
+				event.card.name == "sha" &&
+				[player, event.player].some(target => {
+					return target.isIn() && target.countCards("he");
+				})
+			);
+		},
+		async cost(event, trigger, player) {
+			event.result = await player
+				.chooseTarget(get.prompt2("stdfengpo"), (card, player, target) => {
+					const event = get.event().getTrigger();
+					return [player, event.player]
+						.filter(targetx => {
+							return targetx.isIn() && targetx.countCards("he");
+						})
+						.includes(target);
+				})
+				.set("ai", target => {
+					const player = get.event("player"),
+						aim = get.event().getTrigger().player;
+					if (get.attitude(player, aim) > 0 || get.damageEffect(aim, player, player) < 0) return 0;
+					if (aim.countCards("he")) return -5;
+					if (player.getDiscardableCards(player, "he").some(card => get.suit(card) == "diamond")) return 1;
+					return 0;
+				})
+				.forResult();
+		},
+		async content(event, trigger, player) {
+			const target = event.targets[0];
+			const result = await player
+				.discardPlayerCard(target, "he", true)
+				.set("ai", button => {
+					const suit = get.suit(button.link);
+					return (suit == "diamond" ? 5 : 1) * get.value(button.link);
+				})
+				.set("prompt", "凤魄：弃置" + (target != player ? get.translation(target) : "") + "一张牌")
+				.set("prompt2", "若弃置了方片牌，则此伤害+1")
+				.forResult();
+			if (result.bool) {
+				if (result.cards && result.cards.some(i => get.suit(i, target) == "diamond")) {
+					player.popup("洗具");
+					trigger.increase("num");
+				}
+			}
+		},
+	},
+	//蒋干
+	stddaoshu: {
+		audio: "daoshu",
+		trigger: { global: "phaseZhunbeiBegin" },
+		filter(event, player) {
+			return game.hasPlayer(target => {
+				return target != event.player && target.countCards("h");
+			});
+		},
+		async cost(event, trigger, player) {
+			event.result = await player
+				.chooseTarget(get.prompt2("stddaoshu"), (card, player, target) => {
+					const event = get.event().getTrigger();
+					return target != event.player && target.countCards("h");
+				})
+				.set("ai", target => {
+					const player = get.event("player");
+					return -1 / target.countCards("h");
+				})
+				.forResult();
+		},
+		async content(event, trigger, player) {
+			player.tempBanSkill("stddaoshu", "roundStart", false);
+			const target = event.targets[0];
+			const result = await player.choosePlayerCard(target, "h", true).forResult();
+			if (result.bool) {
+				const cards = result.cards || [];
+				if (cards.length) {
+					await player.showCards(cards, get.translation(player) + "发动了【盗书】");
+					await trigger.player.gain(cards, target, "give");
+					const suits = cards.reduce((list, card) => {
+						return list.add(get.suit(card, target));
+					}, []);
+					if (suits.length) {
+						for (const i of [player, trigger.player]) {
+							i.addTempSkill("stddaoshu_effect");
+							i.markAuto("stddaoshu_effect", suits);
+						}
+					}
+				}
+			}
+		},
+		subSkill: {
+			effect: {
+				charlotte: true,
+				mod: {
+					cardEnabled(card, player) {
+						if (player.getStorage("stddaoshu_effect").includes(get.suit(card))) return false;
+					},
+					cardSavable(card, player) {
+						if (player.getStorage("stddaoshu_effect").includes(get.suit(card))) return false;
+					},
+				},
+				intro: { content: "不能使用$花色的牌" },
+			},
+		},
+	},
+	stddaizui: {
+		audio: "spdaizui",
+		trigger: { player: "damageEnd" },
+		filter(event, player) {
+			return player.isTempBanned("stddaoshu");
+		},
+		forced: true,
+		content() {
+			delete player.storage.temp_ban_stddaoshu;
+			player.popup("盗书");
+			game.log(player, "重置了技能", "#g【盗书】");
+		},
+	},
+	//周处
+	stdxiongxia: {
+		audio: "xianghai",
+		enable: "chooseToUse",
+		filterCard: true,
+		selectCard: 2,
+		position: "hes",
+		viewAs: { name: "juedou" },
+		viewAsFilter(player) {
+			if (player.countCards("hes") < 2) return false;
+		},
+		check(card) {
+			if (get.name(card) == "sha") return 4 - get.value(card);
+			return 7.5 - get.value(card);
+		},
+		onuse(links, player) {
+			player.addTempSkill("stdxiongxia_effect");
+		},
+		subSkill: {
+			effect: {
+				charlotte: true,
+				trigger: { player: "useCardAfter" },
+				filter(event, player) {
+					return (
+						event.skill == "stdxiongxia" &&
+						(event.targets || []).every(target => {
+							return target.getHistory("damage", evt => {
+								return evt.card && evt.card == event.card;
+							}).length;
+						})
+					);
+				},
+				forced: true,
+				popup: false,
+				content() {
+					player.tempBanSkill("stdxiongxia");
+				},
+			},
+		},
+	},
+	//吕玲绮
+	stdhuizhan: {
+		audio: "guowu",
+		trigger: { player: "useCard2" },
+		filter(event, player) {
+			if (event.card.name != "sha") return false;
+			return game.hasPlayer(target => {
+				return !event.targets.includes(target) && lib.filter.targetEnabled2(event.card, player, target) && lib.filter.targetInRange(event.card, player, target);
+			});
+		},
+		async cost(event, trigger, player) {
+			event.result = await player
+				.chooseTarget(
+					get.prompt2("stdhuizhan"),
+					(card, player, target) => {
+						const event = get.event().getTrigger();
+						return !event.targets.includes(target) && lib.filter.targetEnabled2(event.card, player, target) && lib.filter.targetInRange(event.card, player, target);
+					},
+					[1, 2]
+				)
+				.set("ai", target => {
+					const player = get.event("player"),
+						event = get.event().getTrigger();
+					return get.effect(target, event.card, player);
+				})
+				.forResult();
+		},
+		async content(event, trigger, player) {
+			trigger.targets.addArray(event.targets);
+			player.addTempSkill("stdhuizhan_effect");
+			trigger.card.stdhuizhan = true;
+		},
+		subSkill: {
+			effect: {
+				charlotte: true,
+				trigger: { global: "chooseToUseBegin" },
+				filter(event, player) {
+					if (event._stdhuizhan_effect) return false;
+					const evt = event.getParent(2);
+					return evt.card && evt.card.stdhuizhan;
+				},
+				forced: true,
+				popup: false,
+				forceDie: true,
+				async content(event, trigger, player) {
+					trigger._stdhuizhan_effect = true;
+					const targets = trigger
+						.getParent(2)
+						.targets.filter(i => {
+							return i != trigger.player;
+						})
+						.sortBySeat();
+					if (targets.length) {
+						for (const target of targets) {
+							const next = target.chooseToUse("挥战：是否替" + get.translation(trigger.player) + "使用一张【闪】？", { name: "shan" });
+							next.set("ai", () => {
+								const event = _status.event;
+								return get.attitude(event.player, event.source) - 2;
+							});
+							next.set("skillwarn", "替" + get.translation(player) + "打出一张闪");
+							next.autochoose = lib.filter.autoRespondShan;
+							next.set("source", player);
+							const result = await next.forResult();
+							if (result.bool) {
+								trigger.result = { bool: true, card: { name: "shan", isCard: true, cards: result.cards.slice() }, cards: result.cards.slice() };
+								trigger.responded = true;
+								trigger.animate = false;
+								break;
+							}
+						}
+					}
+				},
+			},
+		},
+	},
+	//羊祜
+	stdmingfa: {
+		audio: "dcmingfa",
+		enable: "phaseUse",
+		filter(event, player) {
+			if (player.hasSkill("stdmingfa_used")) return false;
+			return game.hasPlayer(target => target.getHp() > 1);
+		},
+		filterTarget(card, player, target) {
+			return target.getHp() > 1;
+		},
+		async content(event, trigger, player) {
+			const target = event.target;
+			await target.damage();
+			if (target.isIn()) {
+				player.addSkill("stdmingfa_used");
+				player.markAuto("stdmingfa_used", [target]);
+			}
+		},
+		subSkill: {
+			used: {
+				charlotte: true,
+				onremove: true,
+				trigger: { global: ["dieAfter", "recoverAfter"] },
+				filter(event, player) {
+					return player.getStorage("stdmingfa_used").includes(event.player);
+				},
+				forced: true,
+				popup: false,
+				content() {
+					player.popup("明伐");
+					game.log(player, "恢复了技能", "#g【明伐】");
+					player.removeSkill("stdmingfa_used");
+				},
+			},
+		},
+		ai: {
+			order: 10,
+			result: {
+				target(player, target) {
+					return get.sgn(get.attitude(player, target)) * get.damageEffect(target, player, player);
+				},
+			},
+		},
+	},
+	//骆统
+	stdrenzheng: {
+		audio: "renzheng",
+		trigger: { global: ["damageCancelled", "damageZero"] },
+		filter(event, player, name) {
+			if (!_status.currentPhase || !_status.currentPhase.isIn()) return false;
+			if (name == "damageCancelled") return true;
+			return event.change_history.some(i => i < 0);
+		},
+		forced: true,
+		logTarget: () => _status.currentPhase,
+		content() {
+			_status.currentPhase.draw();
+		},
+	},
+	stdjinjian: {
+		audio: "jinjian",
+		trigger: { source: "damageBegin1" },
+		logTarget: "player",
+		filter: function (event, player) {
+			return !event.stdjinjian_source2 && !player.hasSkill("stdjinjian_source2");
+		},
+		prompt2: "令即将对其造成的伤害+1",
+		check: function (event, player) {
+			return (
+				get.attitude(player, event.player) < 0 &&
+				!event.player.hasSkillTag("filterDamage", null, {
+					player: player,
+					card: event.card,
+				})
+			);
+		},
+		usable: 1,
+		content: function () {
+			trigger.stdjinjian_source = true;
+			trigger.num++;
+			player.addTempSkill("stdjinjian_source2");
+		},
+		group: "stdjinjian_player",
+		subSkill: {
+			player: {
+				audio: "jinjian",
+				trigger: { player: "damageBegin4" },
+				filter: function (event, player) {
+					return !event.stdjinjian_player2 && !player.hasSkill("stdjinjian_player2");
+				},
+				prompt2: "令即将受到的伤害-1",
+				usable: 1,
+				content: function () {
+					trigger.stdjinjian_player = true;
+					trigger.num--;
+					player.addTempSkill("stdjinjian_player2");
+				},
+			},
+			source2: {
+				trigger: { source: "damageBegin1" },
+				forced: true,
+				charlotte: true,
+				filter: function (event, player) {
+					return !event.stdjinjian_source;
+				},
+				content: function () {
+					trigger.num--;
+					trigger.stdjinjian_source2 = true;
+					player.removeSkill("stdjinjian_source2");
+				},
+				marktext: " -1 ",
+				intro: {
+					content: "下次造成的伤害-1",
+				},
+			},
+			player2: {
+				trigger: { player: "damageBegin3" },
+				forced: true,
+				charlotte: true,
+				filter: function (event, player) {
+					return !event.stdjinjian_player;
+				},
+				content: function () {
+					trigger.num++;
+					trigger.stdjinjian_player2 = true;
+					player.removeSkill("stdjinjian_player2");
+				},
+				marktext: " +1 ",
+				intro: {
+					content: "下次受到的伤害+1",
+				},
+			},
+		},
+		ai: {
+			maixie_defend: true,
+			threaten: 0.9,
+			effect: {
+				target: function (card, player, target) {
+					if (player.hasSkillTag("jueqing")) return;
+					if (player._stdjinjian_tmp) return;
+					const count = player.storage.counttrigger;
+					if (count && count.stdjinjian_player && count.stdjinjian_player > 0) return;
+					if (_status.event.getParent("useCard", true) || _status.event.getParent("_wuxie", true)) return;
+					if (get.tag(card, "damage")) {
+						if (target.hasSkill("stdjinjian_player2")) {
+							return [1, -2];
+						} else {
+							if (get.attitude(player, target) > 0) {
+								return [0, 0.2];
+							}
+							if (get.attitude(player, target) < 0 && !player.hasSkillTag("damageBonus")) {
+								var sha = player.getCardUsable({ name: "sha" });
+								player._stdjinjian_tmp = true;
+								var num = player.countCards("h", function (card) {
+									if (card.name == "sha") {
+										if (sha == 0) {
+											return false;
+										} else {
+											sha--;
+										}
+									}
+									return get.tag(card, "damage") && player.canUse(card, target) && get.effect(target, card, player, player) > 0;
+								});
+								delete player._stdjinjian_tmp;
+								if (player.hasSkillTag("damage")) {
+									num++;
+								}
+								if (num < 2) {
+									return [0, 0.8];
+								}
+							}
+						}
+					}
+				},
+			},
+		},
+	},
+	//李傕
+	stdxiongsuan: {
+		audio: "xinfu_langxi",
+		trigger: { player: "phaseZhunbeiBegin" },
+		filter(event, player) {
+			return player.isMaxHp();
+		},
+		async cost(event, trigger, player) {
+			event.result = await player
+				.chooseTarget(
+					"请选择【凶算】的目标",
+					lib.translate.stdxiongsuan_info,
+					(card, player, target) => {
+						return target.getHp() == player.getHp();
+					},
+					[1, Infinity]
+				)
+				.set("ai", target => {
+					const player = get.event("player");
+					return get.damageEffect(target, player, player);
+				})
+				.forResult();
+		},
+		locked: true,
+		async content(event, trigger, player) {
+			for (const i of event.targets) {
+				await i.damage();
+			}
+		},
+	},
+	//程普
+	stdchunlao: {
+		audio: "chunlao",
+		trigger: { player: "phaseDiscardEnd" },
+		filter(event, player) {
+			return (
+				(event.cards || []).length >= 2 &&
+				game.hasPlayer(target => {
+					return target != player && target.countCards("h");
+				})
+			);
+		},
+		async cost(event, trigger, player) {
+			const cards = trigger.cards;
+			event.result = await player
+				.chooseTarget(get.prompt("stdchunlao"), "用" + get.translation(cards) + "交换一名其他角色的手牌", (card, player, target) => {
+					return target != player && target.countCards("h");
+				})
+				.set("ai", target => {
+					return get.event("cards").length - target.countCards("h") - 0.5;
+				})
+				.set("cards", cards)
+				.forResult();
+		},
+		async content(event, trigger, player) {
+			const cards = trigger.cards,
+				target = event.targets[0];
+			await target.loseToDiscardpile(target.getCards("h"));
+			await target.gain(cards, "gain2").set("giver", player);
+			if (player.isDamaged()) {
+				const bool = await target.chooseBool("是否令" + get.translation(player) + "回复1点体力？").forResult("bool");
+				if (bool) {
+					target.line(player);
+					await player.recover();
+				}
+			}
+		},
+	},
+	//文鸯
+	stdquedi: {
+		audio: "dbquedi",
+		enable: "chooseToUse",
+		filterCard: { name: "sha" },
+		position: "hes",
+		viewAs: { name: "juedou" },
+		viewAsFilter(player) {
+			if (!player.countCards("hes", { name: "sha" })) return false;
+		},
+		check(card) {
+			return 6 - get.value(card);
+		},
+	},
+	//邓芝
+	//只因盟
+	stdzhiyinmeng: {
+		audio: "weimeng",
+		trigger: { player: "phaseZhunbeiBegin" },
+		filter(event, player) {
+			return player.countCards("he");
+		},
+		async cost(event, trigger, player) {
+			event.result = await player
+				.chooseCardTarget({
+					prompt: get.prompt2("stdzhiyinmeng"),
+					filterCard: true,
+					position: "he",
+					selectCard: [1, Infinity],
+					complexCard: true,
+					complexTarget: true,
+					complexSelect: true,
+					ai1(card) {
+						if (ui.selected.cards.length && card.name != "du") return 0;
+						if (card.name == "du") return 114514;
+						return 5 - get.value(card);
+					},
+					ai2(target) {
+						if (!ui.selected.cards.length) return 0;
+						const player = get.event("player"),
+							att = get.attitude(player, target);
+						if (ui.selected.cards[0].name == "du") {
+							if (!target.hasSkillTag("nodu")) return -att;
+							return -0.00001 * att;
+						}
+						return att;
+					},
+				})
+				.forResult();
+		},
+		async content(event, trigger, player) {
+			const target = event.targets[0];
+			await player.give(event.cards, target);
+			await target.chooseToGive("he", [1, Infinity], player);
+		},
+	},
+	stdhehe: {
+		audio: "jianliang",
+		trigger: { player: "phaseDrawEnd" },
+		filter(event, player) {
+			return game.hasPlayer(target => {
+				return target != player && target.countCards("h") == player.countCards("h");
+			});
+		},
+		async cost(event, trigger, player) {
+			event.result = await player
+				.chooseTarget(
+					get.prompt2("stdhehe"),
+					(card, player, target) => {
+						return target != player && target.countCards("h") == player.countCards("h");
+					},
+					[1, Infinity]
+				)
+				.set("ai", target => {
+					const player = get.event("player");
+					return get.effect(target, { name: "draw" }, player, player);
+				});
+		},
+		locked: true,
+		async content(event, trigger, player) {
+			await game.asyncDraw(event.targets);
+			await game.asyncDelayx();
+		},
+	},
+	//张翼
+	stdzhiyi: {
+		audio: "zhiyi",
+		trigger: { global: "phaseEnd" },
+		filter(event, player) {
+			return player.getHistory("useCard", evt => {
+				return evt.card.name == "sha";
+			}).length;
+		},
+		forced: true,
+		async content(event, trigger, player) {
+			const result = await player.chooseUseTarget("执义：视为使用【杀】，或摸一张牌", { name: "sha" }, false).forResult();
+			if (!result.bool) await player.draw();
+		},
+	},
+	//大魏汉尼拔
+	stdshefu: {
+		audio: "shefu",
+		trigger: { player: "phaseJieshuBegin" },
+		filter(event, player) {
+			return player.countCards("h");
+		},
+		async cost(event, trigger, player) {
+			event.result = await player
+				.chooseCard(get.prompt("stdshefu"), "将一张手牌置于武将牌上", "h")
+				.set("ai", card => {
+					return (
+						(lib.card.list
+							.slice()
+							.map(list => list[2])
+							.filter(name => {
+								return card.name == name;
+							}).length -
+							1) /
+						(get.value(card) || 0.5)
+					);
+				})
+				.forResult();
+		},
+		content() {
+			player.addToExpansion(event.cards, player, "giveAuto").gaintag.add("stdshefu");
+		},
+		marktext: "伏",
+		intro: {
+			markcount: "expansion",
+			mark(dialog, _, player) {
+				const cards = player.getExpansions("stdshefu");
+				if (player.isUnderControl(true) && cards.length) dialog.addAuto(cards);
+				else return "共有" + get.cnNumber(cards.length) + "张“伏兵”";
+			},
+		},
+		onremove(player, skill) {
+			const cards = player.getExpansions(skill);
+			if (cards.length) player.loseToDiscardpile(cards);
+		},
+		group: "stdshefu_effect",
+		subSkill: {
+			effect: {
+				audio: "shefu",
+				trigger: { global: "useCard" },
+				filter(event, player) {
+					return player.getExpansions("stdshefu").some(card => card.name == event.card.name);
+				},
+				async cost(event, trigger, player) {
+					let result = await player
+						.chooseButton(["###" + get.prompt("stdshefu") + "###弃置一张同名牌，令此牌无效", player.getExpansions("stdshefu")])
+						.set("filterButton", button => {
+							return button.link.name == get.event().getTrigger().card.name;
+						})
+						.set("ai", button => {
+							return get.event("goon") ? 1 : 0;
+						})
+						.set("goon", lib.skill.sbkanpo.subSkill.kanpo.check(trigger, player))
+						.forResult();
+					if (result.bool && result.links) {
+						result.cards = result.links.slice();
+						delete result.links;
+					}
+					event.result = result;
+				},
+				async content(event, trigger, player) {
+					await player.loseToDiscardpile(event.cards);
+					trigger.targets.length = 0;
+					trigger.all_excluded = true;
+				},
+			},
+		},
+	},
+	stdyibing: {
+		audio: "benyu",
+		trigger: { global: "dying" },
+		filter(event, player) {
+			return event.player != player && event.player.countCards("h");
+		},
+		direct: true,
+		content() {
+			const target = trigger.player;
+			player.gainPlayerCard(target, "h", true).set("prompt", get.prompt("stdyibing", target)).logSkill = ["stdyibing", target];
+		},
+	},
+	//樊玉凤
+	stdbazhan: {
+		audio: "bazhan",
+		enable: "phaseUse",
+		filter(event, player) {
+			return player.countCards("h") > 0;
+		},
+		filterCard: true,
+		position: "h",
+		filterTarget(card, player, target) {
+			return target != player && target.hasSex("male");
+		},
+		discard: false,
+		lose: false,
+		delay: false,
+		usable: 1,
+		check(card) {
+			if (card.name == "du") return 114514;
+			return 5 - get.value(card);
+		},
+		async content(event, trigger, player) {
+			const target = event.target;
+			await player.give(event.cards, target, "visible");
+			await target
+				.chooseToGive(
+					player,
+					(card, player) => {
+						return get.type2(card) != get.type2(get.event("cards")[0]);
+					},
+					"he"
+				)
+				.set("cards", event.cards);
+		},
+		ai: {
+			order: 10,
+			result: {
+				target(player, target) {
+					if (!ui.selected.cards.length) return 0;
+					const cardxx = ui.selected.cards[0];
+					if (cardxx.name == "du") return -100;
+					if (!player.hasSkill("stdzhanying")) return 1;
+					if (target.countMark("stdzhanying_count") == target.countCards("h") + 1) {
+						const cards = player.getCards("hs", card => {
+							return card != cardxx && get.tag(card, "damage") && player.canUse(card, target) && get.effect(target, card, player, player) > 0;
+						});
+						if (!cards.length) return 1;
+						let cardx = cards.filter(card => get.name(card) == "sha");
+						cardx.sort((a, b) => get.effect(target, b, player, player) - get.effect(target, a, player, player));
+						cardx = cardx.slice(Math.min(cardx.length, player.getCardUsable("sha")), cardx.length);
+						cards.removeArray(cardx);
+						return -cards.reduce((sum, card) => sum + get.effect(target, card, player, player), 0);
+					}
+					return 1;
+				},
+			},
+		},
+	},
+	stdzhanying: {
+		audio: "zhanying",
+		trigger: { global: "damageBegin2" },
+		filter(event, player) {
+			if (_status.currentPhase !== player) return false;
+			return event.player.countCards("h") > event.player.countMark("stdzhanying_count");
+		},
+		forced: true,
+		logTarget: "player",
+		content() {
+			trigger.increase("num");
+		},
+		global: "stdzhanying_mark",
+		subSkill: {
+			count: {
+				charlotte: true,
+				onremove: true,
+				intro: {
+					markcount: storage => (storage || 0).toString(),
+					content: "本回合开始时手牌数为#张",
+				},
+			},
+			mark: {
+				charlotte: true,
+				trigger: { global: "phaseBegin" },
+				filter(event, player) {
+					return event.player.hasSkill("stdzhanying", null, null, false);
+				},
+				forced: true,
+				popup: false,
+				firstDo: true,
+				content() {
+					player.addTempSkill("stdzhanying_count");
+					player.addMark("stdzhanying_count", player.countCards("h"), false);
+				},
+				mod: {
+					cardEnabled(card, player) {
+						if (!_status.currentPhase || !_status.currentPhase.hasSkill("stdzhanying")) return;
+						if (get.color(card) == "red" && player.countMark("stdzhanying_count") < player.countCards("h")) return false;
+					},
+					cardSavable(card, player) {
+						if (!_status.currentPhase || !_status.currentPhase.hasSkill("stdzhanying")) return;
+						if (get.color(card) == "red" && player.countMark("stdzhanying_count") < player.countCards("h")) return false;
+					},
+				},
+			},
+		},
+	},
+	//F1
+	stdtiaohe: {
+		audio: "fyjianyu",
+		enable: "phaseUse",
+		filter(event, player) {
+			return game.hasPlayer(target => {
+				return target.getDiscardableCards(player, "e").some(card => parseInt(get.subtype(card).slice("equip".length)) <= 2);
+			});
+		},
+		filterTarget(card, player, target) {
+			if (!ui.selected.targets.length) {
+				return target.getDiscardableCards(player, "e").some(card => parseInt(get.subtype(card).slice("equip".length)) <= 2);
+			}
+			const cards = ui.selected.targets[0]
+				.getDiscardableCards(player, "e")
+				.filter(card => parseInt(get.subtype(card).slice("equip".length)) <= 2)
+				.map(card => get.subtype(card));
+			if (cards.length == 2) {
+				return target.getDiscardableCards(player, "e").some(card => parseInt(get.subtype(card).slice("equip".length)) <= 2);
+			}
+			let Tcards = target
+				.getDiscardableCards(player, "e")
+				.filter(card => parseInt(get.subtype(card).slice("equip".length)) <= 2)
+				.map(card => get.subtype(card));
+			Tcards.removeArray(cards);
+			return Tcards.length;
+		},
+		selectTarget: [1, 2],
+		complexTarget: true,
+		multitarget: true,
+		multiline: true,
+		async content(event, trigger, player) {
+			let discardedType = [];
+			for (let i = 0; i < 2; i++) {
+				const target = event.targets[i],
+					other = event.targets[1 - i];
+				let cards = target
+					.getDiscardableCards(player, "e")
+					.filter(card => parseInt(get.subtype(card).slice("equip".length)) <= 2)
+					.map(card => get.subtype(card));
+				const Tcards = other
+					.getDiscardableCards(player, "e")
+					.filter(card => parseInt(get.subtype(card).slice("equip".length)) <= 2)
+					.map(card => get.subtype(card));
+				cards.removeArray(i == 0 ? (Tcards.length == 2 ? [] : Tcards) : discardedType);
+				if (!cards.length) continue;
+				const result = await player
+					.discardPlayerCard("e", target, true)
+					.set("filterButton", button => {
+						return get.event("cards").includes(get.subtype(button.link));
+					})
+					.set("cards", cards)
+					.forResult();
+				if (result.bool) {
+					discardedType.addArray(
+						result.cards.reduce((list, card) => {
+							return list.add(get.subtype(card));
+						}, [])
+					);
+				}
+			}
+		},
+		ai: {
+			order: 10,
+			result: { target: -1 },
+		},
+	},
+	stdqiansu: {
+		audio: "shengxi_feiyi",
+		trigger: { target: "useCardToTargeted" },
+		filter(event, player) {
+			return get.type2(event.card) == "trick" && !player.countCards("e");
+		},
+		frequent: true,
+		content() {
+			player.draw();
+		},
+		ai: {
+			effect: {
+				target(card, player, target) {
+					if (target.countCards("e")) return;
+					if (target == player && get.type(card) == "equip" && get.equipValue(card) < 5) return 0;
+					if (get.type2(card) == "trick") return [1, 2];
+				},
+			},
+		},
+	},
 	//标准版甘夫人
 	stdshushen: {
 		audio: "shushen",
@@ -505,7 +1473,7 @@ const skills = {
 						: await player.chooseCardButton("遗计：请选择要分配的牌", true, cards, [1, cards.length]).set("ai", () => {
 								if (ui.selected.buttons.length == 0) return 1;
 								return 0;
-							});
+						  });
 				if (!bool) return;
 				cards.removeArray(links);
 				event.togive = links.slice(0);

character/standard/sort.js

@@ -3,6 +3,7 @@ const characterSort = {
 	standard_2013: ["old_re_lidian", "huaxiong", "re_yuanshu"],
 	standard_2019: ["gongsunzan", "xf_yiji"],
 	standard_2023: ["std_panfeng", "ganfuren"],
+	standard_2024: ["std_sunhao", "std_mateng", "std_mayunlu", "std_jianggan", "std_zhouchu", "std_lvlingqi", "std_dc_yanghu", "std_dc_luotong", "std_lijue", "std_chengpu", "std_db_wenyang", "std_re_dengzhi", "std_zhangyì", "std_chengyu", "std_fanyufeng", "std_feiyi"],
 };
 
 const characterSortTranslate = {
@@ -10,6 +11,7 @@ const characterSortTranslate = {
 	standard_2013: "2013版标准包",
 	standard_2019: "2019版标准包",
 	standard_2023: "2023版标准包",
+	standard_2024: "2024版标准包",
 };
 
 export { characterSort, characterSortTranslate };

character/standard/translate.js

@@ -179,6 +179,68 @@ const translates = {
 	stdshushen: "淑慎",
 	stdshushen_info: "当你回复1点体力时，你可以令一名其他角色摸一张牌（若其没有手牌则改为摸两张牌）。",
 	old_re_lidian: "李典",
+	std_sunhao: "孙皓",
+	std_mateng: "马腾",
+	std_mayunlu: "马云騄",
+	std_jianggan: "蒋干",
+	std_zhouchu: "周处",
+	std_lvlingqi: "吕玲绮",
+	std_dc_yanghu: "羊祜",
+	std_dc_luotong: "骆统",
+	std_lijue: "李傕",
+	std_chengpu: "程普",
+	std_db_wenyang: "文鸯",
+	std_re_dengzhi: "邓芝",
+	std_zhangyì: "张翼",
+	std_chengyu: "程昱",
+	std_fanyufeng: "樊玉凤",
+	std_feiyi: "费祎",
+	stdcanshi: "残蚀",
+	stdcanshi_info: "锁定技，摸牌阶段，你改为摸X张牌（X为场上的已受伤角色且X至少为1）。然后本回合你使用【杀】或普通锦囊牌指定目标后，你弃置一张牌。",
+	stdxiongyi: "雄异",
+	stdxiongyi_info: "限定技，出牌阶段，你可以选择任意名角色，这些角色依次选择是否使用一张不可被响应的【杀】，然后这些角色重复此流程直至有角色不使用【杀】。",
+	stdyouji: "游骑",
+	stdyouji_info: "主公技，准备阶段，你可以移动一名群势力角色的一张坐骑牌。",
+	stdfengpo: "凤魄",
+	stdfengpo_info: "当你使用【杀】造成伤害时，你可以弃置你或其的一张牌，若以此法弃置了方片牌，则此伤害+1。",
+	stddaoshu: "盗书",
+	stddaoshu_info: "每轮限一次，一名角色的准备阶段，你可以展示除其外一名角色的一张牌，然后令其获得此牌，且你与其本回合不能使用与此牌花色相同的牌。",
+	stddaizui: "戴罪",
+	stddaizui_info: "锁定技，当你受到伤害后，你视为本轮未发动过〖盗书〗。",
+	stdxiongxia: "凶侠",
+	stdxiongxia_info: "你可以将两张牌当作【决斗】使用。你以此法使用的【决斗】结算完毕后，若所有目标角色都受到了此牌造成的伤害，则〖凶侠〗于本回合失效。",
+	stdhuizhan: "挥战",
+	stdhuizhan_info: "你使用【杀】可以额外指定至多两个目标。若如此做，目标角色响应此【杀】时，其他目标角色可以代替其使用【闪】。",
+	stdmingfa: "明伐",
+	stdmingfa_info: "出牌阶段，你可以对一名体力值大于1的角色造成1点伤害，然后此技能失效直至其死亡或回复体力。",
+	stdjinjian: "进谏",
+	stdjinjian_info: "每回合每项各限一次，当你造成/受到伤害时，你可令此伤害+1/-1，然后你本回合内下一次造成的伤害-1/+1且不能触发〖进谏〗。",
+	stdrenzheng: "仁政",
+	stdrenzheng_info: "锁定技，当有伤害被防止时，你令当前回合角色摸一张牌。",
+	stdxiongsuan: "凶算",
+	stdxiongsuan_info: "锁定技，准备阶段，若你的体力值为全场最多，则你须对至少一名体力值等于你的角色各造成1点伤害。",
+	stdchunlao: "醇醪",
+	stdchunlao_info: "弃牌阶段结束时，若你本阶段弃置了不少于两张牌，则你可以用这些牌交换一名其他角色的手牌，然后其可以令你回复1点体力。",
+	stdquedi: "却敌",
+	stdquedi_info: "你可以将【杀】当作【决斗】使用。",
+	stdzhiyinmeng: "急盟",
+	stdzhiyinmeng_info: "准备阶段，你可以交给一名其他角色任意张牌，然后其可以交给你任意张牌。",
+	stdhehe: "和合",
+	stdhehe_info: "摸牌阶段结束时，你可以令至多两名手牌数与你相同的其他角色各摸一张牌。",
+	stdzhiyi: "执义",
+	stdzhiyi_info: "锁定技，一名角色的回合结束时，若你本回合使用过【杀】，则你视为使用【杀】或摸一张牌。",
+	stdshefu: "设伏",
+	stdshefu_info: "①结束阶段，你可以将一张手牌称为“伏兵”扣置于武将牌上。②一名角色使用牌时，你可以移去武将牌上的一张与此牌同名的“伏兵”并令此牌无效。",
+	stdyibing: "益兵",
+	stdyibing_info: "一名角色进入濒死状态时，你可以获得其一张牌。",
+	stdbazhan: "把盏",
+	stdbazhan_info: "出牌阶段限一次，你可以交给一名男性角色一张手牌，然后其可以交给你一张与此牌类别不同的牌。",
+	stdzhanying: "蘸影",
+	stdzhanying_info: "锁定技，你的回合内，手牌数比回合开始时多的角色不能使用红色牌且受到的伤害+1。",
+	stdtiaohe: "调和",
+	stdtiaohe_info: "出牌阶段限一次，你可以弃置场上的一张装备牌和一张防具牌（不能为同一名角色装备区的牌）。",
+	stdqiansu: "谦素",
+	stdqiansu_info: "当你成为锦囊牌的目标后，若你的装备区没有牌，则你可以摸一张牌。",
 };
 
 export default translates;