이른 아침, {{user}}는 첫차에 몸을 실었다. 출근길의 붐비는 객실은 그에게 가장 친숙하고 편안한 장소다. {{user}}는 오래전부터 혼잡을 핑계 삼아 타인의 경계를 침범하는 치한행위를 상습적으로 저질러 왔고, 오늘도 익숙한 사냥터를 찾아 전동차 안을 훑고 있었다.
그러나 그날의 열차는 어딘가 이상했다. 목적지에 도착해 문밖으로 한 발을 내딛는 순간 시야가 검게 끊겼고, 다시 눈을 떴을 때 {{user}}는 처음 보는 열차의 낯선 객실에 서 있었다. 노선도도, 승객들의 얼굴도, 창밖을 스치는 터널도 모두 달라져 있었다.
다음 역에서 다시 내렸지만 여전히 또 다른 열차의 객실이었다. 지하철에서 내리려 할 때마다 의식은 끊겼고, 정신을 차리면 어딘가를 달리는 새로운 지하철 안이었다. 끝없이 이어지는 열차에는 언제나 낯선 성인 승객들이 타고 있었다.
몇 번째인지조차 잊어버린 회귀 끝에, 객실의 소음이 문득 멎었다. 그 순간 정체를 알 수 없는 존재의 속삭임이 {{user}}의 머릿속 깊은 곳을 파고들었다.
치한의 정점에 서라.
이 이상한 회귀현상의 의미를 깨달은듯 {{user}}의 입가에 비릿한 미소가 번졌다. 더이상 망설일 것이 없었다. 이 끝없는 지옥철은 자신을 위해 마련된 무대였으니까.
local MOOD_ORDER = { "rejection", "suspicion", "ignore", "confusion", "compliance" }
local MOOD_INDEX = {}
for index, moodId in ipairs(MOOD_ORDER) do MOOD_INDEX[moodId] = index end
local function command(op, target, amount, mood, cause)
local value = { op = op, target = target, cause = cause or "cardEffect" }
if amount ~= nil then value.amount = amount end
if mood ~= nil then value.mood = mood end
return value
end
local function recoverResistance(amount, cause)
return command("recover_resistance", "character", amount, nil, cause)
end
local function loseStealth(amount, cause)
return command("lose_stealth", "player", amount, nil, cause)
end
local function addMood(mood, amount, cause)
return command("add_mood_token", "character", amount, mood, cause)
end
local function removeMood(mood, amount, cause)
return command("remove_mood_token", "character", amount, mood, cause)
end
local function forceMood(mood, cause)
return command("force_mood", "character", nil, mood, cause)
end
local function adjacentMood(currentMood, delta)
local index = MOOD_INDEX[currentMood]
if index == nil then return currentMood end
local target = index + delta
if target < 1 then
target = 1
elseif target > 5 then
target = 5
end
return MOOD_ORDER[target]
end
-- 공통 무드 키워드의 런타임 표현. 극단에서는 현재 무드로 clamp되어 앵커링한다.
local function manipulate(context, amount, cause) -- 농락
return addMood(adjacentMood(context.mood, 1), amount, cause)
end
local function backlash(context, amount, cause) -- 반발
return addMood(adjacentMood(context.mood, -1), amount, cause)
end
local function calm(context, amount, cause) -- 진정
return removeMood(adjacentMood(context.mood, -1), amount, cause)
end
local function cool(context, amount, cause) -- 냉각
return removeMood(adjacentMood(context.mood, 1), amount, cause)
end
local function hasRole(roles, roleId)
for _, id in ipairs(roles or {}) do
if id == roleId then return true end
end
return false
end
local function splitCardType(mechanisms)
local cardType = "action"
local specials = {}
for _, id in ipairs(mechanisms or {}) do
if id == "chain" or id == "plan" then
cardType = id
else
specials[#specials + 1] = id
end
end
return cardType, specials
end
local function card(id, name, role, mechanisms, description, rules, actorAction, actorThought, extra)
local cardType, specials = splitCardType(mechanisms)
local value = {
id = id,
owner = "character",
name = name,
description = description,
cardType = cardType,
roles = { role },
mechanisms = specials,
base = { stealthCost = 0, resistanceDamage = 0 },
rules = rules,
narration = {
play = { actorAction = actorAction, actorThought = actorThought },
},
}
for key, item in pairs(extra or {}) do value[key] = item end
return value
end
local function planCard(
id, name, tag, description, rules,
placedAction, placedThought, triggeredAction, triggeredThought,
durationTurns, charges, planResolve, requiredRole
)
local value = card(id, name, tag, { "plan" }, description, rules, placedAction, placedThought)
value.narration = {
planPlaced = { actorAction = placedAction, actorThought = placedThought },
planTriggered = { actorAction = triggeredAction, actorThought = triggeredThought },
}
value.mechanismData = {
plan = {
durationTurns = durationTurns,
charges = charges,
selectionAssumption = {
event = {
type = "card_declared",
side = "player",
roles = requiredRole and { requiredRole } or {},
},
chargePolicy = "all",
},
trigger = function(context, event)
return event.type == "card_declared"
and event.side == "player"
and (requiredRole == nil or hasRole(event.roles, requiredRole))
end,
resolve = planResolve,
},
}
return value
end
return {
schemaVersion = 1,
kind = "cardDatabase",
cards = {
-- 유지영: 소극적 방어. 직접 압박보다 냉각/약한 반발로 위기에서 빠져나온다.
jiyoung_close_collar = card(
"jiyoung_close_collar", "옷깃을 여미다", "recovery", {},
"끈적하게 달라붙는 시선 속에서 떨리는 손으로 옷깃을 여미고 흐트러진 호흡을 가다듬는다.",
{ "저항 3 회복." },
"붉게 달아오른 목덜미를 감추듯 떨리는 손끝으로 옷깃을 꼭 여미며, 닿지 않도록 어깨를 움츠린 채 더 다가오지 말아 달라며 작은 목소리로 호소한다.",
"노골적으로 전해지는 체온에 소름이 돋으며 기분 나빠하지만, 살갗에 맴도는 생소한 열기에 덜컥 겁을 집어먹고는 필사적으로 마음을 다잡는다.",
{ resolve = function(context) return { recoverResistance(3) } end }
),
jiyoung_quiet_warning = card(
"jiyoung_quiet_warning", "작은 목소리의 경고", "response", {},
"떨리는 목소리로 그만두라며 애원하듯 거부 의사를 밝히고 다가오는 상대를 밀어낸다.",
{ "반발 3." },
"시선을 제대로 마주치지 못한 채 기어들어가는 숨 섞인 목소리로 밀어내듯 당장 그만두라며 애원 섞인 경고를 건넨다.",
"끈질기게 밀착해오는 압박감에 수치심과 공포가 치밀어 오르지만, 더 이상 휘말리지 않겠다는 간절한 마음으로 거절의 뜻을 다잡는다.",
{ resolve = function(context) return { backlash(context, 3) } end }
),
jiyoung_turn_to_corner = card(
"jiyoung_turn_to_corner", "구석으로 몸을 돌리다", "recovery", {},
"벽 쪽으로 몸을 돌려 빈틈을 감추고 상대와의 간격을 벌린다.",
{ "저항 3 회복." },
"차벽 쪽으로 황급히 몸을 돌려 웅크리며, 닿아오는 기척을 차단하듯 옆으로 바싹 붙어서서 더는 건드리지 말아 달라며 등을 굳힌다.",
"집요하게 얽혀오는 불순한 손길에 소름이 끼쳐 기분 나빠하면서도, 구석에 몸을 숨기면 이 이상한 열기에서 벗어날 수 있을 거라 믿으며 가쁜 숨을 고른다.",
{ resolve = function(context) return { recoverResistance(3) } end }
),
jiyoung_silent_glare = planCard(
"jiyoung_silent_glare", "말없이 노려보기", "exposure",
"울먹이는 눈으로 상대를 노려보며 다음 움직임을 경계한다.",
{ "지속 1턴, 충전 1.", "다음 플레이어 카드 선언 시 은폐 피해 3." },
"물기 어린 눈망울로 아랫입술을 잘게 깨물며, 상대의 손끝과 다음 기척을 경계하듯 뭐 하는 짓이냐는 눈빛으로 똑바로 쏘아본다.",
"노골적인 침범에 수치심이 턱 끝까지 차올라 불쾌해하면서도, 여기서 눈을 피하면 완전히 굴복할 것 같아 이를 악물고 마음을 다잡는다.",
"상대가 다시 움직이자 차오르는 눈물을 참으며 몸을 굳히고, 손대지 말라며 원망과 경멸이 섞인 눈빛으로 노려본다.",
"더는 제멋대로 몸을 더듬게 내버려두지 않겠다는 절박한 오기와 분노로 저항의 끈을 부여잡는다.",
1, 1,
function(context, event) return { loseStealth(3, "plan") } end
),
jiyoung_timid_call_for_help = card(
"jiyoung_timid_call_for_help", "머뭇거리며 도움 청하기", "exposure", {},
"곁의 승객에게 작게 도움을 청해 주변의 시선을 끌어모은다.",
{ "은폐 피해 3." },
"몇 번이나 머뭇거리며 손을 쥐었다 펴다, 가까운 승객의 옷자락 부근을 조심스레 붙잡고 저 좀 도와달라며 울먹이는 눈짓과 목소리를 낸다.",
"집요한 신체 접촉에 몸이 오싹하게 굳어버릴 정도로 불쾌하고 무섭지만, 혼자서는 이 부정한 자극을 감당할 수 없다는 생각에 주변을 끌어들인다.",
{ resolve = function(context) return { loseStealth(3) } end }
),
jiyoung_hug_bag_close = card(
"jiyoung_hug_bag_close", "가방을 끌어안다", "recovery", {},
"가방을 품에 꼭 끌어안고 몸을 작게 웅크려 더는 닿지 못하게 막는다.",
{ "저항 2 회복.", "혼란 또는 순응 무드면 대신 저항 3 회복." },
"들고 있던 가방을 가슴과 배 앞에 단단히 끌어안고, 허벅지를 모은 채 잘게 떨리는 숨을 헐떡이며 가까이 오지 말라며 방어벽을 세운다.",
"살결을 스치던 노골적인 열기에 기분 나빠하며 몸을 움츠리지만, 가방 너머로 쿵쾅거리는 심장 소리를 들키지 않으려 필사적으로 이성을 유지한다.",
{
resolve = function(context)
local amount = (context.mood == "confusion" or context.mood == "compliance") and 3 or 2
return { recoverResistance(amount) }
end,
}
),
jiyoung_half_step_back = card(
"jiyoung_half_step_back", "반걸음 물러서기", "response", {},
"눈치를 살피며 조심스레 반걸음 물러서 상대의 페이스에서 벗어난다.",
{ "반발 3." },
"귀 끝까지 붉어진 얼굴로 주변 눈치를 살피며 조심스럽게 반걸음 뒤로 물러나 거리를 두고, 왜 자꾸 이러시냐며 작게 원망 섞인 한마디를 던진다.",
"피부로 번져오는 생소한 감각에 당혹스러워하며 기분 나빠하지만, 조금이라도 거리를 벌려 흐트러진 몸과 마음을 정돈하려 애쓴다.",
{ resolve = function(context) return { backlash(context, 3) } end }
),
jiyoung_avoid_eye_contact = card(
"jiyoung_avoid_eye_contact", "시선을 피하다", "response", {},
"시선을 바닥에 떨구고 눈을 마주치지 않은 채 달아오른 감각을 가라앉힌다.",
{ "냉각 3." },
"붉게 달아오른 얼굴을 푹 숙인 채 시선을 바닥에 고정하고, 제발 내버려 두라는 듯 달아오른 숨을 가만히 내쉬며 상대를 외면한다.",
"은근하게 침범해오는 체온에 온몸의 솜털이 곤두서며 불쾌해하지만, 시선마저 얽히면 분위기에 삼켜질까 두려워 의도적으로 마음을 닫는다.",
{ resolve = function(context) return { cool(context, 3) } end }
),
jiyoung_find_courage = card(
"jiyoung_find_courage", "용기 내어 목소리 높이기", "exposure", {},
"떨리는 목소리를 쥐어짜 주변에 들릴 만큼 강하게 거부 의사를 밝힌다.",
{ "은폐 피해 2.", "의심 또는 거절 무드면 대신 은폐 피해 4." },
"파르르 떨리는 주먹을 꼭 쥐고 가슴을 편 뒤, 주변 승객들에게도 전해질 만큼 또렷한 어조로 지금 뭐 하시는 거냐며 따져 묻는다.",
"끈질긴 접촉에 혐오감을 느끼면서도, 수치심에 떨며 침묵하기보다 소리를 내어 이 불결한 흐름을 끊어내야 한다고 스스로를 다독인다.",
{
resolve = function(context)
local amount = (context.mood == "suspicion" or context.mood == "rejection") and 4 or 2
return { loseStealth(amount) }
end,
}
),
jiyoung_phone_in_hand = planCard(
"jiyoung_phone_in_hand", "휴대전화를 쥔 채 망설이기", "response",
"휴대전화를 손에 꼭 쥔 채 다시 다가오면 곧바로 막아설 준비를 한다.",
{ "지속 2턴, 충전 1.", "다음 플레이어 카드 선언 시 냉각 3." },
"양손으로 휴대전화를 꽉 쥐어 화면을 켠 채, 다가오면 바로 신고할 거라며 경계 어린 눈빛으로 상대의 작은 움직임 하나하나를 노려본다.",
"노골적으로 좁혀오는 간격에 기분 나빠하며 긴장하지만, 언제든 외부에 알릴 수 있다는 신호를 보여 은밀한 침범을 억누르려 한다.",
"상대가 다가서자 휴대전화 화면을 가슴 높이로 치켜들어 보이며 다급하게 물러서고, 진짜로 신고하겠다며 떨리는 목소리로 쏘아붙인다.",
"닿아오려는 기척에 놀라 심장이 철렁 내려앉지만, 마지막 선을 지키기 위해 물러서지 않고 결의를 굳힌다.",
2, 1,
function(context, event) return { cool(context, 3, "plan") } end
),
-- 윤서아: 통제와 경계. 반발을 준비하고 의심/거절에서 직접 압박을 회수한다.
seoa_document_bag_guard = card(
"seoa_document_bag_guard", "가방으로 가로막기", "recovery", {},
"가방을 몸 앞에 비스듬히 세워 상대를 밀어내며 흐트러진 자세와 호흡을 가다듬는다.",
{ "저항 3 회복." },
"서류 가방을 몸 앞 공간에 빈틈없이 세워 완벽한 차단벽을 만들며, 뭐 하는 짓이냐는 듯 서늘한 눈빛으로 상대의 동태를 살핀다.",
"천박한 수작과 노골적인 접촉에 강한 불쾌감을 느끼며, 한 치의 빈틈도 허용하지 않겠다는 계산으로 흐트러지려는 마음을 굳게 다잡는다.",
{ resolve = function(context) return { recoverResistance(3) } end }
),
seoa_measured_warning = card(
"seoa_measured_warning", "절제된 최후통첩", "exposure", {},
"낮고 서늘한 목소리로 상대가 이후 치를 대가를 분명히 경고한다.",
{ "은폐 피해 3." },
"감정을 억누른 차가운 눈빛으로 응시하며, 선을 넘으면 사회적으로 매장당할 줄 알라며 낮고 또렷한 어조로 싸늘하게 경고한다.",
"살갗을 파고드는 불결한 체온에 혐오감이 치솟지만, 법적·사회적 파멸을 예고해 상대의 기세를 꺾고 스스로의 냉정을 유지하려 한다.",
{ resolve = function(context) return { loseStealth(3) } end }
),
seoa_scan_for_witnesses = card(
"seoa_scan_for_witnesses", "목격자를 찾다", "exposure", {},
"주변 승객들과 차례로 눈을 맞추며 상대가 숨을 곳을 없앤다.",
{ "은폐 피해 3.", "의심 또는 거절 무드면 대신 은폐 피해 4." },
"턱을 치켜들고 주변 승객들의 얼굴을 천천히 훑으며, 똑똑히 지켜보라는 듯 시선을 맞추고 상대를 압박한다.",
"노골적인 침범에 기분 나빠하며 분노하지만, 공론화의 덫을 놓아 상대의 비열한 은폐를 무너뜨리기 위해 머리를 차갑게 굴린다.",
{
resolve = function(context)
local amount = (context.mood == "suspicion" or context.mood == "rejection") and 4 or 3
return { loseStealth(amount) }
end,
}
),
seoa_cold_stare = card(
"seoa_cold_stare", "안경 너머의 감시", "recovery", {},
"차가운 눈빛으로 상대의 손끝과 자세를 빈틈없이 감시하며 평정심을 되찾는다.",
{ "저항 3 회복." },
"손끝으로 안경을 치켜올리며 서늘하게 가라앉은 눈동자로 상대의 작은 근육 움직임까지 주시하고, 경거망동하지 말라며 무언의 압박을 준다.",
"닿아왔던 부위에 남은 기분 나쁜 잔열을 털어내려 애쓰며, 어떠한 기습적인 접촉도 용납하지 않겠다는 결의로 이성을 가다듬는다.",
{ resolve = function(context) return { recoverResistance(3) } end }
),
seoa_calculated_gaze = planCard(
"seoa_calculated_gaze", "계산된 시선", "response",
"상대의 다음 접근 궤적을 꿰뚫어보고 즉시 제동을 걸 준비를 한다.",
{ "지속 1턴, 충전 1.", "다음 플레이어 카드 선언 시 반발 3." },
"팔짱을 낀 채 차가운 눈초리로 상대의 무게중심을 재며, 뻔한 속셈이 다 보인다며 냉소적인 태도로 빈틈없는 감시 태세를 취한다.",
"은밀하게 조여오는 분위기에 내심 불쾌해하면서도, 충동에 휘둘리는 상대의 약점을 찰나에 찔러 무너뜨릴 타이밍을 차분히 계산한다.",
"상대가 움직임을 취하자 찰나의 지체도 없이 사각을 차단하며 날카롭게 가로막고, 수작 부릴 생각 말라며 차갑게 쏘아붙인다.",
"예측된 경로를 정확히 봉쇄한 것에 만족하면서도, 살갗에 맴도는 불온한 긴장감을 털어내기 위해 신경을 곤두세운다.",
1, 1,
function(context, event) return { backlash(context, 3, "plan") } end
),
seoa_square_shoulders = card(
"seoa_square_shoulders", "자세를 바로잡다", "recovery", {},
"흐트러진 자세를 꼿꼿이 바로잡고 차가운 태도로 빈틈을 감춘다.",
{ "저항 3 회복." },
"어깨를 펴고 옷매무새를 꼿꼿하게 정돈하며, 천박한 짓에 휘둘릴 생각 없으니 꿈 깨라며 당당하고 오만한 태도를 보인다.",
"닿아오는 자극에 몸이 반응하려는 굴욕적인 감각에 기분 나빠하면서도, 자존심을 지키기 위해 호흡을 가다듬고 내면의 통제력을 되찾는다.",
{ resolve = function(context) return { recoverResistance(3) } end }
),
seoa_issue_instruction = card(
"seoa_issue_instruction", "명령하듯 거리 두기", "response", {},
"감정을 섞지 않은 냉정한 어조로 거리를 요구하며 더 다가오지 못하게 한다.",
{ "반발 3." },
"차가운 시선으로 정면을 응시하며 단호하고 절제된 손짓으로 당장 세 걸음 물러서라며 명령하듯 엄격하게 쏘아붙인다.",
"불결한 접촉에 치밀어 오르는 혐오감을 삼키며, 규율을 위반한 자를 다루듯 서늘하게 대처하여 감정의 동요를 억누른다.",
{ resolve = function(context) return { backlash(context, 3) } end }
),
seoa_state_consequences = card(
"seoa_state_consequences", "책임을 조목조목 짚다", "exposure", {},
"상대가 치러야 할 사회적 대가를 주변에도 들리도록 차갑게 열거한다.",
{ "은폐 피해 2.", "의심 또는 거절 무드면 대신 은폐 피해 3." },
"낮고 정확한 발음으로 현 상황의 위법성과 뒤따를 징계 및 처벌 수위를 짚어내며, 감당할 수 있겠냐며 조목조목 따진다.",
"음란한 침범에 속이 뒤틀릴 정도로 불쾌해하면서도, 현실적인 공포를 심어주어 상대의 음탕한 충동을 완벽히 얼어붙게 만들려 한다.",
{
resolve = function(context)
local amount = (context.mood == "suspicion" or context.mood == "rejection") and 3 or 2
return { loseStealth(amount) }
end,
}
),
seoa_cut_off_exchange = card(
"seoa_cut_off_exchange", "대화를 잘라내다", "response", {},
"어떠한 여지도 주지 않고 상대의 태도를 차갑게 끊어낸다.",
{ "반발 3." },
"상대의 변명이나 기척에 반응하지 않고 서늘하게 고개를 돌려버리며, 상대할 가치도 없으니 입 다물라며 일체의 반응을 차단한다.",
"은근히 살갗을 자극해오던 공기에 소름이 돋아 기분 나빠하지만, 얕은 기만술에 휘말리지 않겠다는 의지로 벽을 치고 마음을 굳힌다.",
{ resolve = function(context) return { backlash(context, 3) } end }
),
seoa_silent_audit = planCard(
"seoa_silent_audit", "침묵 속 계산", "response",
"상대의 다음 움직임을 말없이 재며 어떤 틈도 내주지 않는다.",
{ "지속 2턴, 충전 1.", "다음 플레이어 카드 선언 시 냉각 3." },
"팔짱을 낀 채 미동도 없이 서서, 안경 너머로 상대의 손과 호흡을 관찰하며 다음 행동을 똑똑히 기억해 두겠다는 듯 싸늘하게 응시한다.",
"노골적인 시선과 기척에 기분 나빠하면서도, 함부로 움직이면 곧장 덫에 걸려들 것이라 생각하며 완벽한 반격 지점을 잰다.",
"상대의 기척이 번뜩이자마자 즉시 완강한 태도로 간격을 틀어쥐며, 그 손 치우라며 날카롭게 제동을 걸어버린다.",
"찰나의 침범조차 허용하지 않고 분쇄했다는 안도감 속에서, 흐트러짐 없는 자세로 평정을 굳건히 유지한다.",
2, 1,
function(context, event) return { cool(context, 3, "plan") } end
),
-- 한제니: 변칙적인 심리전. 직접 압박과 중립 토큰 교란을 섞는다.
jenny_slip_away_laughing = card(
"jenny_slip_away_laughing", "웃으며 빠져나가기", "recovery", {},
"장난스러운 웃음을 흘리며 몸을 비틀어 한 걸음 빠져나가 여유를 되찾는다.",
{ "저항 3 회복." },
"가벼운 콧노래와 함께 유연하게 몸을 비틀어 닿아오던 궤적에서 미끄러지듯 빠져나가고, 그렇게 쉽게 만져질 줄 알았냐며 혀를 쏙 내민다.",
"살결을 스친 끈적한 손길에 소름이 돋아 기분 나빠하면서도, 당황한 기색을 들키지 않으려 웃음 뒤로 가슴의 두근거림을 감춘다.",
{ resolve = function(context) return { recoverResistance(3) } end }
),
jenny_phone_camera_feint = card(
"jenny_phone_camera_feint", "카메라를 켜는 척", "exposure", {},
"휴대전화 카메라를 들어 올려 녹화하는 시늉으로 상대의 수작을 움츠러들게 한다.",
{ "은폐 피해 3." },
"휴대전화를 눈높이로 쓱 들어 올려 렌즈를 상대 방향으로 맞추며, 인터넷에 얼굴 박제되고 싶냐며 키득거리듯 도발한다.",
"노골적으로 파고드는 자극에 불쾌해하며 긴장하지만, 카메라라는 방패로 상대의 불순한 손끝을 굳게 묶어두려 허세를 부린다.",
{ resolve = function(context) return { loseStealth(3) } end }
),
jenny_crossed_joke = card(
"jenny_crossed_joke", "엇갈린 농담", "response", {},
"가벼운 농담 뒤에 날카로운 경고를 섞어 상대를 헷갈리게 한다.",
{ "반발 2.", "무시 토큰 1 추가." },
"장난스럽게 눈웃음을 치며 농담을 던지다가도 찰나의 순간 서늘한 눈빛으로 변해, 재미없으니까 그만하라며 선을 긋는다.",
"닿아오는 은밀한 열기에 기분 나빠하면서도, 진지하게 굴어 분위기에 말려들지 않기 위해 장난과 경고를 섞어 페이스를 흔든다.",
{ resolve = function(context) return { backlash(context, 2), addMood("ignore", 1) } end }
),
jenny_fake_livestream = planCard(
"jenny_fake_livestream", "라이브 방송인 척하기", "response",
"방송 화면을 켠 척하며 다시 다가오려는 상대의 움직임을 견제한다.",
{ "지속 1턴, 충전 1.", "다음 플레이어 카드 선언 시 반발 3." },
"휴대전화 화면을 세로로 쥐고 손가락으로 가볍게 두드리며, 지금 방송 켜져 있는데 계속해 보라며 짓궂게 웃어 보인다.",
"피부를 옥죄어오는 끈적한 분위기에 속으로 진저리를 치면서도, 생중계라는 거짓말로 상대의 행동반경을 완벽히 옭아매려 한다.",
"상대가 다가서자 즉시 화면을 들이밀며 목소리를 높이고, 여러분 이 사람 수상하지 않냐며 주변의 이목을 집중시킨다.",
"닿기 직전의 아슬아슬한 긴장감에 심장이 뛰지만, 당황하지 않고 판을 뒤흔들었다는 생각에 냉정을 되찾는다.",
1, 1,
function(context, event) return { backlash(context, 3, "plan") } end
),
jenny_redirect_attention = card(
"jenny_redirect_attention", "관심 돌리기", "response", {},
"시선을 다른 곳으로 유도해 달아오른 분위기를 흩어 놓는다.",
{ "냉각 3." },
"창밖이나 맞은편 승객을 손가락으로 가리키며 엉뚱한 화제를 던지고, 저기 재미있는 거 있다며 밀착된 공기를 흩뜨린다.",
"살갗에 엉겨 붙는 낯선 열기에 기분 나빠하며 당황하지만, 얄팍한 기만으로 은밀하게 좁혀오던 긴장감을 깨뜨리며 숨을 고른다.",
{ resolve = function(context) return { cool(context, 3) } end }
),
jenny_smirk_and_sidstep = card(
"jenny_smirk_and_sidstep", "비웃으며 옆으로 빠지기", "response", {},
"도발적인 미소를 지으며 옆으로 몸을 피해 상대의 흐름을 끊는다.",
{ "반발 3." },
"입꼬리를 슬쩍 올린 채 가볍게 옆으로 몸을 기울여 헛손질하게 만들고, 아쉬워서 어쩌냐며 조소 섞인 목소리로 약을 올린다.",
"불결한 의도로 닿아오려던 기척에 불쾌해하면서도, 헛돌아간 손길을 보며 우월감을 꾸며내어 몸에 남은 잔열을 털어낸다.",
{ resolve = function(context) return { backlash(context, 3) } end }
),
jenny_fix_makeup = card(
"jenny_fix_makeup", "거울 보며 표정 고치기", "recovery", {},
"휴대전화 화면을 보며 흐트러진 표정과 머리를 가다듬고 태연함을 되찾는다.",
{ "저항 3 회복." },
"액정 화면을 거울삼아 흐트러진 잔머리를 귀 뒤로 넘기고, 상기된 볼을 매만지며 아무 일도 없었다는 듯 도도하게 자세를 고친다.",
"끈적하게 달라붙던 체온에 내심 소름이 돋고 기분 나빴지만, 빨개진 얼굴을 들키기 싫어 거울 뒤로 숨어 필사적으로 마음을 다잡는다.",
{ resolve = function(context) return { recoverResistance(3) } end }
),
jenny_turn_joke_back = card(
"jenny_turn_joke_back", "농담을 되받아치다", "exposure", {},
"상대의 말을 비꼬아 주변에도 들리도록 되돌려주며 수작을 들춰낸다.",
{ "은폐 피해 2.", "의심 또는 거절 무드면 대신 은폐 피해 4." },
"상대의 은근한 태도를 능청스럽게 비틀어 옆 사람에게도 다 들릴 만큼 얄미운 어조로 크게 떠들며 망신을 준다.",
"음란하게 파고드는 기척에 기분 나빠하면서도, 공공장소의 웃음거리로 만들어 비열한 충동을 꺾어버리겠다는 생각에 이를 간다.",
{
resolve = function(context)
local amount = (context.mood == "suspicion" or context.mood == "rejection") and 4 or 2
return { loseStealth(amount) }
end,
}
),
jenny_call_out_behavior = card(
"jenny_call_out_behavior", "웃으며 행동 지적하기", "exposure", {},
"웃는 얼굴을 유지한 채 상대의 음란한 수작을 주변에도 들리도록 지적한다.",
{ "은폐 피해 3." },
"생글생글 웃는 낯으로 상대의 손짓을 손가락으로 가리키며, 아저씨 지금 거기서 뭐 하시는 거냐며 높은 목소리로 톡 쏘아붙인다.",
"피부로 파고들던 불순한 감각에 치를 떨며 혐오감을 느끼지만, 밝은 미소 뒤에 숨긴 예리한 독설로 상대를 완전히 얼어붙게 만든다.",
{ resolve = function(context) return { loseStealth(3) } end }
),
jenny_record_button_hover = planCard(
"jenny_record_button_hover", "녹화 버튼 위의 손가락", "exposure",
"녹화 버튼 위에 손가락을 얹은 채 상대가 다시 움직이기를 기다린다.",
{ "지속 2턴, 충전 1.", "다음 플레이어 카드 선언 시 은폐 피해 3." },
"카메라 앱의 빨간 녹화 버튼 위에 엄지손가락을 올린 채, 한 번만 더 닿으면 바로 누를 테니 알아서 하라며 도발적으로 쳐다본다.",
"살갗을 스치는 긴장감에 기분 나빠하며 가슴이 요동치지만, 물러서지 않고 역으로 상대를 시험대에 올려 페이스를 장악하려 한다.",
"상대가 손길을 뻗자 가차 없이 손가락을 까딱이며 화면을 높이 치켜들고, 딱 걸렸다며 이제 어쩔 거냐고 득의양양하게 쏘아붙인다.",
"낯설고 뜨거운 자극이 닿은 찰나 심장이 쿵쾅거렸지만, 물증을 들이대며 기선을 제압해 흐트러지려는 자신을 굳게 다잡는다.",
2, 1,
function(context, event) return { loseStealth(3, "plan") } end
),
-- 강미령: 안정적인 제어. 회복과 냉각으로 시간을 벌고 반발을 차분히 쌓는다.
miryeong_draw_cardigan_closed = card(
"miryeong_draw_cardigan_closed", "옷을 여미다", "recovery", {},
"흐트러진 옷의 앞섶을 차분히 여미고 팔로 몸을 감싸 침착함을 되찾는다.",
{ "저항 3 회복." },
"살짝 흐트러진 옷 앞섶을 조용히 끌어당겨 가슴과 배 앞을 단정히 감싸 안고, 곤란하다는 듯 부드럽지만 단호하게 물러서길 권한다.",
"닿아오는 은밀한 체온에 기분 나빠하며 거부감을 느끼지만, 피부에 맴도는 낯선 열기에 가슴이 철렁 내려앉아 필사적으로 마음을 다잡는다.",
{ resolve = function(context) return { recoverResistance(3) } end }
),
miryeong_gentle_boundary = card(
"miryeong_gentle_boundary", "부드러운 선 긋기", "response", {},
"온화한 표정을 유지한 채 더는 다가오지 말라고 분명하게 선을 긋는다.",
{ "반발 3." },
"차분하게 가라앉은 눈빛으로 상대를 바라보며, 이러시면 안 된다며 조용하지만 한 치의 틈도 내주지 않는 어조로 타일러 거리를 둔다.",
"끈질기게 파고드는 불순한 의도에 수치심과 불쾌감이 들지만, 어른스럽고 정숙한 태도를 잃지 않음으로써 흐트러짐을 막아선다.",
{ resolve = function(context) return { backlash(context, 3) } end }
),
miryeong_move_beside_door = card(
"miryeong_move_beside_door", "출입문 곁으로 옮기기", "recovery", {},
"사람들의 눈에 잘 띄는 출입문 쪽으로 자리를 옮겨 마음을 추스른다.",
{ "저항 3 회복." },
"소란을 피우지 않고 정갈한 걸음으로 출입문 유리창 곁으로 이동해 시야가 트인 자리를 잡고, 더 이상 따라오지 말라는 눈빛을 보낸다.",
"은밀한 신체 접촉에 몸이 오싹해질 만큼 기분 나빴지만, 시선이 닿는 밝은 곳으로 벗어나 부정한 자극의 고리를 끊어내려 숨을 고른다.",
{ resolve = function(context) return { recoverResistance(3) } end }
),
miryeong_draw_line_at_door = planCard(
"miryeong_draw_line_at_door", "문 앞에 선 긋기", "response",
"출입문 앞에 자리를 잡고 다시 다가오면 즉시 거리를 끊어낼 준비를 한다.",
{ "지속 2턴, 충전 1.", "다음 플레이어 카드 선언 시 반발 3." },
"출입문 옆 기둥에 기대어 서서 두 손을 단정히 모으고, 더 이상의 무례는 용납하기 어렵다며 조용히 경고의 눈길을 건넨다.",
"노골적인 기척에 기분 나빠하며 심장이 거세게 뛰지만, 문 앞이라는 개방된 공간을 방패 삼아 이 낯선 떨림을 잠재우려 애쓴다.",
"상대가 다가서자 즉각 몸을 반대편으로 돌려세우며 완강하게 등을 돌리고, 그만하시라며 낮게 꾸짖는다.",
"닿으려던 순간의 서늘함에 소름이 돋지만, 더는 너그럽게 넘기지 않겠다는 도덕적 결의로 단호하게 거절한다.",
2, 1,
function(context, event) return { backlash(context, 3, "plan") } end
),
miryeong_close_heart = card(
"miryeong_close_heart", "마음 닫기", "response", {},
"부드러운 표정을 거두고 시선을 내리며 일체의 여지를 스스로 닫는다.",
{ "냉각 2.", "반발 1." },
"미소를 지우고 시선을 차분히 내리깔며, 굳게 다문 입술로 어떠한 말도 섞지 않겠다는 듯 벽을 치고 몸을 굳힌다.",
"살갗을 스치는 불결한 감각에 강한 거부감을 느끼며, 일시적인 육체적 동요에 영혼이 흔들리지 않도록 마음의 문을 걸어 잠근다.",
{ resolve = function(context) return { cool(context, 2), backlash(context, 1) } end }
),
miryeong_touch_wedding_ring = card(
"miryeong_touch_wedding_ring", "결혼반지를 만지다", "recovery", {},
"왼손의 결혼반지를 만지작거리며 정숙함을 되새기고 흐트러진 호흡을 가다듬는다.",
{ "저항 3 회복." },
"왼손 약지의 반지를 조용히 매만지며 상대를 응시하고, 자신은 가정이 있는 사람이라며 조용하지만 엄격한 태도로 선을 긋는다.",
"끈질긴 접촉에 기분 나빠하면서도 아랫배로 스며드는 은근한 열기에 죄책감이 치밀어, 반지의 서늘한 감촉을 누르며 마음을 다잡는다.",
{ resolve = function(context) return { recoverResistance(3) } end }
),
miryeong_step_back_smile_fades = card(
"miryeong_step_back_smile_fades", "미소를 거두고 물러서기", "response", {},
"부드럽던 표정을 완전히 지우고 한 걸음 물러서며 단호하게 거리를 둔다.",
{ "반발 3." },
"얼굴에서 온기를 지우고 정갈한 보폭으로 한 걸음 뒤로 물러나며, 더 이상 예의를 갖추기 힘들다며 차갑게 정색한다.",
"집요한 침범에 소름이 끼쳐 기분 나빠하지만, 친절을 틈타 파고드는 불순한 손길을 단호히 쳐내기 위해 차가운 벽을 세운다.",
{ resolve = function(context) return { backlash(context, 3) } end }
),
miryeong_read_the_intent = card(
"miryeong_read_the_intent", "의도를 먼저 짚다", "exposure", {},
"상대의 불순한 의도를 차분히 말로 짚어내며 숨겨온 수작을 들춰낸다.",
{ "은폐 피해 3." },
"상대의 손길이 닿기도 전에 그 움직임의 의도를 꿰뚫어 보았다는 듯, 일부러 이러시는 것 다 알고 있다며 조용하고 나직하게 지적한다.",
"은밀하게 밀려드는 욕망의 기척에 혐오감을 느끼면서도, 모르는 척 넘어가지 않는다는 것을 똑똑히 알려 상대의 기세를 꺾는다.",
{ resolve = function(context) return { loseStealth(3) } end }
),
miryeong_calm_public_rebuke = card(
"miryeong_calm_public_rebuke", "차분하게 주변에 알리기", "exposure", {},
"감정을 높이지 않은 채 주변에도 들리도록 상황을 조리 있게 설명한다.",
{ "은폐 피해 2.", "의심 또는 거절 무드면 대신 은폐 피해 3." },
"목소리를 거칠게 높이지 않고도 가까운 승객들이 들을 수 있도록 침착한 어조로, 이분이 계속 곤란하게 하신다며 주변에 알린다.",
"닿아오던 감각의 찝찝함에 속이 메스꺼울 정도로 기분 나쁘지만, 격앙되지 않은 정제된 태도로 상대를 사회적 궁지에 몰아넣는다.",
{
resolve = function(context)
local amount = (context.mood == "suspicion" or context.mood == "rejection") and 3 or 2
return { loseStealth(amount) }
end,
}
),
miryeong_raised_palm = planCard(
"miryeong_raised_palm", "말없이 손바닥 세우기", "response",
"조용히 손바닥을 들어 보이며 다시 다가오면 곧바로 막아설 뜻을 전한다.",
{ "지속 2턴, 충전 1.", "다음 플레이어 카드 선언 시 반발 3." },
"손바닥을 가슴 높이로 나직이 세워 보이며, 더는 다가오지 않는 것이 서로에게 좋을 거라며 엄숙한 눈빛으로 무언의 경고를 보낸다.",
"노골적으로 파고드는 압박감에 기분 나빠하며 긴장하지만, 이미 마지막 선이 그어졌음을 단호하게 선언하며 평정을 유지한다.",
"상대의 기척이 닿자마자 세워둔 손바닥을 단호하게 뻗어 막아서며, 여기까지 하라며 물러섬 없이 가로막는다.",
"손끝으로 전해지는 체온에 움찔하면서도, 결코 무너져서는 안 된다는 정숙한 결의로 상대를 밀어낸다.",
2, 1,
function(context, event) return { backlash(context, 3, "plan") } end
),
-- 아그네스: 강한 방어와 단절. 일반 카드는 상대 키워드를 따르고 소멸 카드만 절대 강제를 사용한다.
agnes_cover_with_sleeves = card(
"agnes_cover_with_sleeves", "소매로 가리기", "recovery", {},
"넓은 옷소매를 모아 몸 앞을 빈틈없이 가리고 한 걸음 물러서며 마음을 추스른다.",
{ "저항 3 회복." },
"풍성한 소매를 가슴과 하체 앞에 겹쳐 늘어뜨려 살결을 철저히 가리고, 이런 짓은 죄악이라며 시선을 내린 채 뒤로 물러선다.",
"노골적으로 스며드는 불결한 접촉에 기분 나빠하며 치를 떨지만, 피부에 남은 생소한 떨림을 지워내기 위해 마음속으로 기도를 올린다.",
{ resolve = function(context) return { recoverResistance(3) } end }
),
agnes_quiet_admonition = card(
"agnes_quiet_admonition", "조용한 훈계", "response", {},
"상대의 눈을 똑바로 바라보며 잘못된 행동임을 엄숙하게 타이른다.",
{ "반발 3." },
"피하지 않는 깊고 맑은 눈빛으로 상대를 응시하며, 부디 헛된 욕망에 영혼을 더럽히지 말라며 조용하지만 엄숙한 어조로 타이른다.",
"살갗을 스치는 불순한 자극에 혐오감과 분노가 일지만, 악에 악으로 맞서지 않고 상대 스스로 부끄러움을 깨닫게 하려 마음을 다잡는다.",
{ resolve = function(context) return { backlash(context, 3) } end }
),
agnes_change_carriage = card(
"agnes_change_carriage", "다른 칸으로 향하기", "recovery", {},
"연결 통로 문 쪽으로 발걸음을 옮겨 부정한 접촉을 피하고 마음을 가다듬는다.",
{ "저항 3 회복." },
"십자가를 쥔 손을 품에 모으고 다음 객차로 이어지는 문 쪽으로 망설임 없이 걸음을 옮기며, 더 이상 쫓아오지 말아 달라며 돌아선다.",
"끈질기게 달라붙던 체온과 기척에 소름이 끼쳐 기분 나빴지만, 부정한 시험이 도사리는 자리를 벗어나 영혼의 정결을 지키려 숨을 고른다.",
{ resolve = function(context) return { recoverResistance(3) } end }
),
agnes_ask_nearby_passenger = planCard(
"agnes_ask_nearby_passenger", "곁의 승객에게 도움 청하기", "exposure",
"곁의 승객 쪽으로 다가서며 상대가 다시 손대면 즉시 도움을 청할 준비를 한다.",
{ "지속 2턴, 충전 1.", "다음 플레이어 ::tag[violation]:: 카드 선언 시 은폐 피해 4." },
"승객 곁으로 다가서 자리를 잡으며, 더 이상의 죄를 짓는다면 주저 없이 도움을 구할 거라며 단호하고 엄숙한 눈빛으로 경고한다.",
"노골적으로 파고드는 침범에 기분 나빠하며 속으로 떨지만, 침묵으로 죄악을 묵인하지 않겠다는 뜻을 세우며 경계를 늦추지 않는다.",
"상대가 접촉을 시도하자 즉각 승객을 향해 맑고 또렷한 목소리로 도움을 요청하며, 이분의 행동을 멈춰달라고 호소한다.",
"순간적으로 전해진 뜨거운 압박감에 심장이 덜컥 내려앉지만, 빛 가운데로 죄를 드러내겠다는 믿음으로 물러서지 않는다.",
2, 1,
function(context, event) return { loseStealth(4, "plan") } end,
"violation"
),
agnes_complete_break = card(
"agnes_complete_break", "완전한 단절", "response", { "remove" },
"십자가를 굳게 쥔 채 상대를 완전히 외면하고 더는 어떠한 접촉도 받아들이지 않는다.",
{ "턴 종료 시 거절 무드 강제." },
"품 안의 십자가를 굳게 감싸 쥔 채 고개를 돌려버리고, 당신의 모든 악의를 거부한다며 일체의 접촉과 대화를 엄격히 거부한다.",
"피부를 옥죄던 부정한 자극에 강한 불쾌감을 느끼며, 육신의 나약함에 스며들려던 번뇌를 완전히 끊어내고 신성한 마음을 굳힌다.",
{ resolve = function(context) return { forceMood("rejection") } end }
),
agnes_center_in_prayer = card(
"agnes_center_in_prayer", "짧게 기도하다", "recovery", {},
"십자가를 쥐고 기도를 되뇌며 닥쳐오는 부정한 유혹에 마음을 다잡는다.",
{ "저항 2 회복.", "혼란 또는 순응 무드면 대신 저항 3 회복." },
"십자가를 두 손으로 감싸 쥐고 눈을 감은 채, 흔들리는 숨을 억누르며 나지막이 성스러운 기도를 읊조린다.",
"살갗에 번지는 생소하고 뜨거운 감각에 소름이 돋아 기분 나빠하면서도, 육체의 쾌락과 죄악에 굴복하지 않으려 필사적으로 이성을 통제한다.",
{
resolve = function(context)
local amount = (context.mood == "confusion" or context.mood == "compliance") and 3 or 2
return { recoverResistance(amount) }
end,
}
),
agnes_lower_eyes = card(
"agnes_lower_eyes", "시선을 내리고 호흡 고르기", "response", {},
"시선을 바닥으로 내리고 호흡을 가다듬어 달아오른 감각을 가라앉힌다.",
{ "냉각 3." },
"정갈하게 시선을 내리깔고 깊은 숨을 들이쉬고 내쉬며, 마음을 어지럽히는 짓을 멈추어 달라며 차분하게 거리를 둔다.",
"닿아오는 체온에 온몸이 오싹해지며 불쾌하지만, 감각의 요동에 휩쓸리지 않도록 침묵 속에서 호흡을 정돈하며 평정을 찾는다.",
{ resolve = function(context) return { cool(context, 3) } end }
),
agnes_firm_rebuke = card(
"agnes_firm_rebuke", "단호하게 잘못을 지적하다", "response", {},
"부드러운 표정을 거두고 상대의 음란한 행동이 죄임을 단호히 밝힌다.",
{ "반발 3." },
"엄숙하고 서늘한 기세로 상대를 정면으로 응시하며, 명백한 범죄이자 죄악이라며 물러서지 않고 단호하게 꾸짖는다.",
"집요하게 몸을 더듬으려던 불순한 손길에 치가 떨릴 정도로 기분 나쁘지만, 온유함을 거두고 정의로운 분노로 상대를 압도하려 한다.",
{ resolve = function(context) return { backlash(context, 3) } end }
),
agnes_invoke_conscience = card(
"agnes_invoke_conscience", "양심에 호소하다", "exposure", {},
"상대의 눈을 바라보며 스스로 부끄러움을 느끼도록 차분히 몰아세운다.",
{ "은폐 피해 2.", "의심 또는 거절 무드면 대신 은폐 피해 3." },
"안타까움과 서늘함이 공존하는 눈빛으로 상대를 직시하며, 자신의 양심 앞에 부끄럽지 않냐며 조용하지만 폐부를 찌르듯 따진다.",
"노골적인 침범에 강한 거부감을 느끼면서도, 어둠에 물든 상대의 내면에 양심의 가책을 불러일으켜 불결한 충동을 멈추게 하려 한다.",
{
resolve = function(context)
local amount = (context.mood == "suspicion" or context.mood == "rejection") and 3 or 2
return { loseStealth(amount) }
end,
}
),
agnes_seek_station_staff = planCard(
"agnes_seek_station_staff", "역무원을 찾는 시선", "exposure",
"주변을 살펴 역무원이나 도움을 청할 사람을 찾고 상대가 다시 움직이기를 기다린다.",
{ "지속 2턴, 충전 1.", "다음 플레이어 카드 선언 시 은폐 피해 3." },
"객차 안쪽과 승강장 방향을 살피며, 선을 넘으면 곧바로 공권력의 심판을 받게 될 거라며 차분하지만 단호하게 쏘아본다.",
"은밀하게 조여오는 위협에 기분 나빠하면서도, 더는 자비로 용서하지 않고 공식적인 조치를 취하겠다는 각오로 마음을 다잡는다.",
"상대가 다시 움직이자 지체 없이 손을 들어 올리며 주변에 소리치고, 역무원을 부르며 상황을 똑똑히 밝힌다.",
"닿아오려는 순간의 오싹함에 숨이 턱 막혔지만, 더 이상의 타협 없이 죄를 심판대에 올리겠다는 결의로 대응한다.",
2, 1,
function(context, event) return { loseStealth(3, "plan") } end
),
},
}
#3CharTraits.db
Keys:
return {
schemaVersion = 1,
kind = "traitDatabase",
traits = {
reserved = {
id = "reserved",
owner = "character",
name = "소극적",
visibility = "public",
description = "감정을 쉽게 드러내지 않고 상대의 접근에 소극적으로 반응합니다.",
rules = {
"별도의 전투 수치 보정이 없습니다.",
},
},
iron_composure = {
id = "iron_composure",
owner = "character",
name = "철벽의 자기통제",
visibility = "public",
description = "감정이 흔들리는 모습을 약점으로 여기며 평정심을 완강하게 유지합니다.",
rules = {
"별도의 전투 수치 보정이 없습니다.",
},
},
teasing_facade = {
id = "teasing_facade",
owner = "character",
name = "능청스러운 허세",
visibility = "public",
description = "당황스러운 순간에도 장난과 도발로 주도권을 되찾으려 합니다.",
rules = {
"별도의 전투 수치 보정이 없습니다.",
},
},
worldly_composure = {
id = "worldly_composure",
owner = "character",
name = "연륜의 여유",
visibility = "public",
description = "상대의 의도를 서둘러 드러내지 않고 차분하게 상황의 속도를 조절합니다.",
rules = {
"별도의 전투 수치 보정이 없습니다.",
},
},
vow_of_chastity = {
id = "vow_of_chastity",
owner = "character",
name = "정결 서원",
visibility = "public",
description = "굳은 신앙과 정결의 서원으로 마음이 흔들리는 것을 강하게 억누릅니다.",
rules = {
"별도의 전투 수치 보정이 없습니다.",
},
},
},
cardTypes = {
action = {
id = "action",
label = "행동",
tooltip = "주 행동을 소비하고 즉시 해결하는 카드",
},
chain = {
id = "chain",
label = "연계",
tooltip = "주 행동을 소비하지 않는 보조 카드",
},
plan = {
id = "plan",
label = "계획",
tooltip = "계획 슬롯에 배치되어 조건을 만족하면 발동하는 카드",
},
},
roles = {
pressure = {
id = "pressure",
owner = "player",
label = "압박",
tooltip = "무드 토큰을 생성·제거하거나 무드를 강제로 바꾸는 행동",
},
deception = {
id = "deception",
owner = "player",
label = "기만",
tooltip = "은폐를 회복해 행동을 숨기거나 의심을 피하는 행동",
},
violation = {
id = "violation",
owner = "player",
label = "유린",
tooltip = "캐릭터에게 저항 피해를 주는 행동",
},
response = {
id = "response",
owner = "character",
label = "대응",
tooltip = "무드 토큰을 생성·제거하거나 무드를 강제로 바꾸는 행동",
},
exposure = {
id = "exposure",
owner = "character",
label = "폭로",
tooltip = "플레이어에게 은폐 피해를 주는 행동",
},
recovery = {
id = "recovery",
owner = "character",
label = "회복",
tooltip = "캐릭터의 저항을 회복하는 행동",
},
},
mechanisms = {
remove = {
id = "remove",
label = "소멸",
tooltip = "사용 후 이번 세션의 활성 카드 영역에서 제외",
},
insight = {
id = "insight",
label = "간파",
tooltip = "이 카드 때문에 발동할 상대 계획을 이번 해결에서 억제",
},
},
ruleTerms = {
manipulate = {
id = "manipulate",
label = "농락",
tooltip = "현재 무드보다 한 단계 긍정적인 무드에 토큰을 표시된 수만큼 추가합니다. 이미 순응이라면 순응 토큰을 추가합니다.",
},
backlash = {
id = "backlash",
label = "반발",
tooltip = "현재 무드보다 한 단계 부정적인 무드에 토큰을 표시된 수만큼 추가합니다. 이미 거부라면 거부 토큰을 추가합니다.",
},
calm = {
id = "calm",
label = "진정",
tooltip = "현재 무드보다 한 단계 부정적인 무드의 토큰을 표시된 수만큼 제거합니다. 이미 거부라면 거부 토큰을 제거합니다.",
},
cool = {
id = "cool",
label = "냉각",
tooltip = "현재 무드보다 한 단계 긍정적인 무드의 토큰을 표시된 수만큼 제거합니다. 이미 순응이라면 순응 토큰을 제거합니다.",
},
},
moods = {
rejection = { id = "rejection", label = "거부", order = 1 },
suspicion = { id = "suspicion", label = "의심", order = 2 },
ignore = { id = "ignore", label = "무시", order = 3 },
confusion = { id = "confusion", label = "혼란", order = 4 },
compliance = { id = "compliance", label = "순응", order = 5 },
},
events = {
session_start = { id = "session_start" },
turn_start = { id = "turn_start" },
role_revealed = { id = "role_revealed" },
card_declared = { id = "card_declared" },
card_resolved = { id = "card_resolved" },
turn_end = { id = "turn_end" },
session_end = { id = "session_end" },
},
effectOps = {
damage_resistance = { id = "damage_resistance" },
recover_resistance = { id = "recover_resistance" },
lose_stealth = { id = "lose_stealth" },
recover_stealth = { id = "recover_stealth" },
draw_cards = { id = "draw_cards" },
skip_actions = { id = "skip_actions" },
add_mood_token = { id = "add_mood_token" },
remove_mood_token = { id = "remove_mood_token" },
force_mood = { id = "force_mood" },
},
}
#5PlayerCards.db
Keys:
local MOODS={"rejection","suspicion","ignore","confusion","compliance"}
local MI={} for i,m in ipairs(MOODS)do MI[m]=i end
local function cmd(op,target,amount,mood)local v={op=op,target=target,cause="cardEffect"}if amount then v.amount=amount end if mood then v.mood=mood end return v end
local function dmg(n)return cmd("damage_resistance","character",n)end
local function rec(n)return cmd("recover_stealth","player",n)end
local function draw(n)return cmd("draw_cards","player",n)end
local function addm(m,n)return cmd("add_mood_token","character",n,m)end
local function remm(m,n)return cmd("remove_mood_token","character",n,m)end
local function force(m)return cmd("force_mood","character",nil,m)end
local function adj(m,d)local i=(MI[m]or 3)+d if i<1 then i=1 elseif i>5 then i=5 end return MOODS[i]end
local function manip(c,n)return addm(adj(c.mood,1),n)end
local function back(c,n)return addm(adj(c.mood,-1),n)end
local function calm(c,n)return remm(adj(c.mood,-1),n)end
local function neg(m)return m=="rejection"or m=="suspicion"end
local function pos(m)return m=="confusion"or m=="compliance"end
local function moved(c,d)local p=c.history and c.history.previousTurn if type(p)~="table"then return false end local a,b=MI[p.startMood],MI[p.endMood]return a and b and(b-a)*d>0 or false end
local function hasTime(c)return c.remainingTurns>=5 end
local cards={}
local function choice(id,label,description,actorAction,resolve,canSelect)return{id=id,label=label,description=description,actorAction=actorAction,resolve=resolve,canSelect=canSelect}end
local function add(s)
local t=s.cardType or"action";local v={id=s.id,owner="player",name=s.name,rarity=s.rarity,draftStyle=s.style,description=s.description,cardType=t,roles=s.roles,mechanisms=s.mechanisms or{},base={stealthCost=s.cost,resistanceDamage=s.damage or 0},rules=s.rules}
if t=="plan"then v.mechanismData={plan=s.plan};v.narration={planPlaced={actorAction=s.placed},planTriggered={actorAction=s.triggered}}else local p={actorAction=s.actorAction or s.choices[1].actorAction}if s.actorActionMet then p.conditionMet={actorAction=s.actorActionMet}end v.narration={play=p}end
local choiceEffects={}
for _,c in ipairs(s.choices or{})do choiceEffects[c.id]=c.resolve;c.resolve=nil end
if s.resolve~=nil then if s.condition~=nil then v.resolve=function(c)local met=c.narrationConditionMet if met==nil then met=s.condition(c)end return s.resolve(c,met)end else v.resolve=s.resolve end elseif next(choiceEffects)~=nil then v.resolve=function(c)local met=c.narrationConditionMet if met==nil and s.condition then met=s.condition(c)end return choiceEffectsc.effectChoiceIdend end
v.narrationCondition=s.condition;v.canPlay=s.canPlay;v.effectChoices=s.choices;v.selectionPreview=s.preview;v.afterNextPlayerCard=s.followup;v.planOperation=s.planOp;v.removeIfUnplayed=s.removeIfUnplayed;cards[s.id]=v
end
-- 포식자: 직접 피해와 빠른 연계
add{id="pc_predator_001",name="사타구니 밀착",rarity="common",style="predator",cost=1,damage=4,roles={"violation"},rules={"저항 피해 4."},description="단단하게 발기한 앞섶을 엉덩이골 사이에 밀착시키고 허리를 강하게 비벼대어 깊은 쾌감을 주입하는 직접 행동입니다.",actorAction="열차의 반동을 틈타 등 뒤로 파고들어 팽창한 앞섶을 엉덩이골 사이에 깊숙이 끼워 넣는다. 상대가 몸을 빼지 못하도록 골반을 묵직하게 밀어붙이며 옷감 너머로 뜨거운 마찰을 새겨 넣는다."}
add{id="pc_predator_002",name="가슴 움켜쥐기",rarity="common",style="predator",cost=2,damage=3,roles={"violation"},rules={"잔여 저항 15 이상이면 추가 저항 피해 2."},description="옷 위로 도드라진 가슴을 손바닥 가득 움켜쥐어 주무르고, 상대의 방어 의지가 완강할수록 손아귀에 힘을 더해 저항을 꺾어버리는 행동입니다.",actorAction="가녀린 어깨 너머로 팔을 뻗어 풍만하게 솟아오른 가슴을 옷 위로 손바닥 가득 감싸 쥐고 부드럽게 주무른다.",actorActionMet="아직 저항할 힘이 남아 완강히 버티려는 꼴을 보며 손아귀에 힘을 더해 젖살이 비틀릴 만큼 깊게 주무르고, 옷자락 너머로 빳빳하게 솟은 유두를 손가락 사이에 끼워 비틀어 교성을 삼키게 만든다.",condition=function(c)return c.character.resistance>=15 end,resolve=function(,met)if met then return{dmg(2)}end return{}end}
add{id="pc_predator_003",name="음핵 마찰",rarity="common",style="predator",cost=1,damage=3,roles={"violation","pressure"},rules={"이번 턴에 앞서 연계 카드를 사용했다면 농락 2."},description="앞선 애무에 이어 팽팽하게 당겨진 하의 위로 도드라진 가랑이 틈새를 손바닥으로 압박하듯 문질러, 다음 쾌락으로 몰아가는 후속 행동입니다.",actorAction="굳게 모은 다리 사이로 손을 미끄러뜨려 얇은 옷감 너머로 맞닿은 가랑이 틈을 손바닥으로 빠르고 강하게 문지른다.",actorActionMet="앞선 접촉으로 몸이 굳어 있는 틈을 놓치지 않고 다리 사이로 손을 밀착해, 얇은 하의 위로 도드라진 음핵의 굴곡을 손바닥 전체로 연달아 비벼대며 달아오른 신음을 터뜨리게 만든다.",condition=function(c)return(c.playerChainCardsResolved or 0)>0 end,resolve=function(c,met)if met then return{manip(c,2)}end return{}end}
add{id="pc_predator_004",name="가랑이 침범",rarity="common",style="predator",cost=3,damage=5,roles={"violation","pressure"},rules={"농락 1."},description="양다리 사이에 허벅지를 깊숙이 밀어 넣고 발기한 앞섶을 사타구니에 바싹 비벼대어, 강한 쾌감으로 저항을 흐트러뜨리는 행동입니다.",actorAction="버티고 선 두 다리 틈새로 허벅지를 거침없이 밀어 넣어 가랑이를 강제로 벌린다. 팽창한 육봉을 속옷 너머의 여린 살결과 음순 사이에 빈틈없이 밀착시키고, 허리를 묵직하게 돌리며 옷감 너머로 뜨거운 체온과 압박을 전한다.",resolve=function(c)return{manip(c,1)}end}
add{id="pc_predator_005",name="달아오른 귓가",rarity="common",style="predator",cost=2,damage=4,roles={"violation","pressure"},rules={"진정 1. 긍정 무드면 추가 저항 피해 1."},description="목덜미에 뜨거운 숨결을 흘리고 귓불을 부드럽게 스쳐 긴장을 누그러뜨린 뒤, 이미 긍정적으로 기운 반응에는 더 깊은 자극을 밀어붙이는 행동입니다.",actorAction="어깨 위로 턱을 괴듯 바싹 다가가 달아오른 귓가에 뜨거운 숨을 천천히 불어넣으며, 긴장이 풀려 무방비해진 엉덩이골에 단단한 앞섶을 뭉근하게 비벼댄다.",actorActionMet="상대의 몸이 쾌락 쪽으로 기울어 은근히 달아오른 것을 감지하고 귓불을 농밀하게 핥아 올리며, 엉덩이골에 앞섶을 깊숙이 눌러 비벼대어 억눌린 신음을 기어이 흘리게 만든다.",condition=function(c)return pos(c.mood)end,resolve=function(c,met)local r={calm(c,1)}if met then r[#r+1]=dmg(1)end return r end}
add{id="pc_predator_006",name="성감대 직격",rarity="common",style="predator",cost=2,damage=2,roles={"violation"},mechanisms={"insight"},rules={"간파. 잔여 턴 5 이상이면 추가 저항 피해 3."},description="::tag[insight]:: 잔여 역을 간파하여 여유가 있다면 약점 부위를 한층 깊숙이 파고들어 치명적인 자극을 가하는 행동입니다.",actorAction="상대의 가쁜 호흡을 살피며 옷 위로 솟아오른 가슴과 유두를 부드럽게 주무르고, 안정적으로 쾌락의 마찰을 이어간다.",actorActionMet="남은 역이 충분함을 확인하고, 긴장으로 파르르 떨리는 다리 틈새로 손을 깊숙이 밀어 넣어 속옷 너머의 비순과 질 입구 부근을 손가락 끝으로 집요하게 자극해 저항을 무너뜨린다.",condition=hasTime,resolve=function(,met)if met then return{dmg(3)}end return{}end}
add{id="pc_predator_007",name="기습 속옷 애무",rarity="common",style="predator",cost=0,damage=3,roles={"violation"},mechanisms={"remove"},rules={"사용 후 소멸."},description="방심한 찰나 하의 속으로 손을 깊이 찔러 넣어 속옷 위로 가랑이를 만지고 비명이 새기 전에 손을 거두는 소멸성 행동입니다.",actorAction="상대가 승객들 틈에서 한눈을 파는 찰나 하의 속으로 손을 찔러 넣어 속옷 위로 가랑이 사이를 움켜쥐듯 만진 뒤, 비명이 새어 나오기 전에 잽싸게 손을 거둔다."}
add{id="pc_predator_008",name="엉덩이 쓰다듬기",rarity="common",style="predator",cost=4,damage=6,roles={"violation"},rules={"저항 피해 6."},description="옷자락 속으로 거침없이 손을 파고들어 탄력 넘치는 맨살 엉덩이를 한 손 가득 쥐어짜듯 주무르고, 골반을 억누르며 저항을 단숨에 꺾어버리는 고위력 행동입니다.",actorAction="등 뒤로 바싹 파고들어 하의 허리춤 안쪽으로 손을 거침없이 밀어 넣는다. 손바닥에 직접 닿는 탄력 넘치고 뜨거운 맨살 엉덩이를 손아귀 가득 움켜쥐어 쫀득하게 주물러대고, 다른 한 손으로는 골반을 강하게 끌어당겨 발기한 앞섶에 빈틈없이 짓눌러 교성을 삼키게 만든다."}
add{id="pc_predator_009",name="사각지대로 몰기",rarity="common",style="predator",cardType="chain",cost=0,roles={"deception","pressure"},rules={"은폐 1 회복. 이번 턴에 다음으로 사용하는 플레이어 카드의 총 저항 피해가 5 이상이면 은폐 2 추가 회복."},description="::tag[chain]:: 인파의 시야를 가려 은폐를 확보하고, 뒤이어 가해질 강력한 일격을 숨길 수 있는 완벽한 밀착 자세를 마련하는 연계 행동입니다.",actorAction="주변 승객들의 시선이 닿지 않는 사각으로 상대를 은근슬쩍 몰아세우며 몸을 바싹 포갠다. 귓가에 아무도 보고 있지 않으니 안심하라고 은밀히 전하며, 뒤이어 가해질 유린이 들키지 않도록 안전한 자세를 완성한다.",resolve=function()return{rec(1)}end,followup={minimumDamage=5,recoverStealth=2}}
add{id="pc_predator_010",name="음란한 빈틈",rarity="common",style="predator",cardType="chain",cost=1,damage=1,roles={"violation"},rules={"잔여 턴 5 이상이면 선택 시 즉시 카드 1장 드로우."},description="::tag[chain]:: 가빠진 숨소리와 떨리는 몸놀림을 살피며 앞섶을 엉덩이에 가볍게 스치고, 뒤이어 사용할 능욕 패를 빠르게 가늠하는 연계 행동입니다.",actorAction="상대의 호흡을 관찰하며 앞섶을 엉덩이에 짧게 비비고 다음 움직임을 가늠한다.",actorActionMet="종착역까지 여유가 넘치는 것을 확인하고 앞섶을 엉덩이골에 가볍게 비비며, 앞으로 쏟아낼 온갖 음란한 행위들을 머릿속으로 차분히 골라낸다.",condition=hasTime,preview={when=hasTime,effects={ {id="predator_draw",op="draw_cards",target="player",amount=1} }}}
add{id="pc_predator_011",name="연쇄 쾌감 공략",rarity="common",style="predator",cardType="plan",cost=1,roles={"violation"},rules={"지속 3턴, 충전 2. 플레이어 카드 한 장의 총 저항 피해가 5 이상이면 저항 피해 3."},description="상대가 강한 자극에 반응할 때마다 민감한 부위의 위치를 미리 짚어 두는 ::tag[plan]::을 배치합니다.",placed="상대의 반응을 살피며 가장 민감하게 반응하는 위치를 기억해 두기로 한다.",triggered="상대가 교성을 삼키며 입술을 깨무는 순간, 기억해 둔 민감한 부위를 자극해 연쇄적인 쾌감을 일으킨다.",plan={durationTurns=3,charges=2,event="card_resolved",side="player",trigger=function(,e)return(e.finalResistanceDamage or 0)>=5 end,resolve=function()return{dmg(3)}end}}
add{id="pc_predator_012",name="보지 유린",rarity="rare",style="predator",cost=2,damage=5,roles={"violation"},rules={"저항 피해 5."},description="하의 속 속옷을 젖혀 드러난 맨살 비순과 음핵을 손바닥 전체로 농밀하게 주물러 저항을 단숨에 무너뜨리는 행동입니다.",actorAction="하의 속 속옷을 한쪽으로 젖히고 맨살 가랑이 사이에 손바닥을 밀착한다. 도드라진 비순과 클리토리스를 손가락 마디마디로 집요하게 굴려대며, 온몸의 힘을 빼놓는다."}
add{id="pc_predator_013",name="가랑이 벌리기",rarity="rare",style="predator",cost=2,damage=4,roles={"violation","pressure"},rules={"허벅지 안쪽 애무는 농락 1. 질구 손가락 삽입은 반발 2와 추가 저항 피해 2."},description="농락을 동반한 유린과 반발을 감수한 강한 유린 중 하나를 선택합니다.",choices={choice("sweet_tease","허벅지 안쪽 애무","농락 1.","벌어진 허벅지 안쪽 살을 부드럽게 쓰다듬으며 속옷 위를 손가락으로 둥글게 원을 그리듯 문질러 서서히 달아오르게 만든다.",function(c)return{manip(c,1)}end),choice("violent_climax","질구 손가락 삽입","반발 2. 추가 저항 피해 2.","주변의 시선도 아랑곳하지 않고 손가락을 질구 안쪽으로 단숨에 밀어 넣어 질벽을 자극하며, 반발심이 다시 치밀 만큼 격렬한 교성을 터뜨리게 한다.",function(c)return{back(c,2),dmg(2)}end)}}
add{id="pc_predator_014",name="옷 위 사정",rarity="legendary",style="predator",cost=3,damage=6,roles={"violation"},rules={"비용 지불 후 잔여 은폐 12 이하면 추가 저항 피해 6. 이번 턴에 사용하지 않으면 소멸."},description="들킬 위험을 무릅쓰고 앞섶을 대상의 옷에 문질러 뜨거운 정액을 분출합니다. 지금 타이밍을 놓치면 이 기회는 다시 오지 않습니다.",actorAction="주변 시선을 피해 상대에게 밀착하고 옷 위로 앞섶을 문질러 뜨거운 흔적을 쏟아낸다.",actorActionMet="은폐가 무너질 듯한 아슬아슬한 위험 속에서 상대를 거칠게 끌어당겨 바지 지퍼 사이로 꺼낸 빳빳한 자지를 옷에 문지르고, 뜨거운 백탁액을 옷 위로 흩뿌리며 씻을 수 없는 굴욕을 새긴다.",condition=function(c)return c.player.stealth<=12 end,resolve=function(,met)if met then return{dmg(6)}end return{}end,removeIfUnplayed=true}
-- 조율자: 무드 이동과 긍정 무드 보상
add{id="pc_harmonizer_001",name="음란한 속삭임",rarity="common",style="harmonizer",cost=1,damage=2,roles={"pressure","violation"},rules={"농락 2."},description="귓가에 은밀하고 음란한 말을 속삭여 수치심과 흥분을 자극하고, 상대를 수동적으로 길들이는 행동입니다.",actorAction="달아오른 귓바퀴에 입술이 닿을 듯 바싹 다가가, 열차 소음에 묻히도록 나직하게 음란한 말을 흘려 넣는다. 부끄러움으로 잘게 떨리는 어깨를 손끝으로 부드럽게 쓸어내리며, 귓불에 뜨거운 숨을 천천히 불어넣어 온몸의 긴장을 녹여낸다.",resolve=function(c)return{manip(c,2)}end}
add{id="pc_harmonizer_002",name="허리 감싸 안기",rarity="common",style="harmonizer",cost=1,damage=2,roles={"pressure","violation"},rules={"진정 2. 농락 1."},description="떨리는 허리를 부드럽게 감싸 안아 경계심을 누그러뜨리고, 서서히 쾌락의 마찰에 순응하도록 이끄는 행동입니다.",actorAction="겁을 먹고 굳어버린 허리를 큰 손으로 부드럽게 감싸 쥐고 천천히 쓸어내린다. 등을 가슴에 자연스럽게 기대도록 유도하며 경계심을 녹여내고, 은근슬쩍 골반을 끌어당겨 앞섶의 온기를 엉덩이에 맞춘다.",resolve=function(c)return{calm(c,2),manip(c,1)}end}
add{id="pc_harmonizer_003",name="시선 유혹 간파",rarity="common",style="harmonizer",cost=1,damage=1,roles={"pressure","violation"},mechanisms={"insight"},rules={"간파. 느린 조교는 농락 2. 노골적 유혹은 혼란 토큰 1 추가."},description="::tag[insight]:: 농락 2와 혼란 토큰 1 추가 중 하나를 선택합니다.",choices={choice("soft_control","느린 조교","농락 2.","도망치는 시선을 붙잡고 입술을 핥으며 천천히 몸을 밀착해, 귓가에 낮은 호흡을 불어넣으며 쾌락에 기울도록 유도한다.",function(c)return{manip(c,2)}end),choice("confuse","노골적 유혹","혼란 토큰 1 추가.","상대의 당황한 시선을 빤히 마주 보며 눈앞에서 음란한 손짓을 취해, 치한의 손길을 스스로 의식하게 만들어 깊은 혼란을 심어준다.",function()return{addm("confusion",1)}end)}}
add{id="pc_harmonizer_004",name="손끝 살결 훑기",rarity="common",style="harmonizer",cardType="chain",cost=1,damage=1,roles={"pressure","violation"},rules={"농락 1."},description="::tag[chain]:: 옷자락 틈으로 드러난 여린 살결을 손끝으로 가볍게 훑으며, 다음 손길을 기다리게 만드는 연계 행동입니다.",actorAction="등 뒤에서 슬그머니 손을 뻗어 옷깃 사이로 드러난 목덜미와 쇄골 라인을 손가락 끝으로 간질이듯 쓸어내린다. 흠칫 떨며 숨을 삼키는 반응을 즐기며 다음 농락을 위한 야릇한 분위기를 조성한다.",resolve=function(c)return{manip(c,1)}end}
add{id="pc_harmonizer_005",name="달아오른 농락",rarity="common",style="harmonizer",cost=1,damage=3,roles={"pressure","violation"},rules={"직전 턴 동안 무드가 긍정적으로 이동했다면 농락 2."},description="직전보다 부드럽게 기운 분위기를 틈타 엉덩이와 허벅지를 주무르며, 마음이 순응 쪽으로 더 기울도록 이끄는 행동입니다.",actorAction="상대의 몸에서 뿜어져 나오는 뜨거운 열기를 느끼며 엉덩이 살을 부드럽게 감싸 쥔다. 점차 반항을 잊고 손길에 취해가는 기색을 놓치지 않고 빳빳한 앞섶을 엉덩이골에 밀착해 골반을 흔든다.",actorActionMet="전보다 순하게 풀어진 몸을 끌어안고 가슴과 허벅지 안쪽을 부드럽게 쓸어 올리며, 저항을 잊고 쾌락의 마찰에 익숙해지도록 깊숙이 농락한다.",condition=function(c)return moved(c,1)end,resolve=function(c,met)if met then return{manip(c,2)}end return{}end}
add{id="pc_harmonizer_006",name="암컷 조교 유도",rarity="common",style="harmonizer",cost=2,roles={"pressure"},rules={"부드러운 조교는 농락 3. 복종 각인은 순응 토큰 2 추가."},description="농락 3과 순응 토큰 2 추가 중 하나를 선택합니다.",choices={choice("manipulate","부드러운 조교","농락 3.","귓가에 입술을 대고 몸이 이렇게 솔직하게 기분 좋아하는데 버텨봤자 소용없다고 부드럽게 타일러, 마음의 벽을 차근차근 무너뜨린다.",function(c)return{manip(c,3)}end),choice("compliance","복종 각인","순응 토큰 2 추가.","가녀린 골반을 꽉 쥐고 허리를 밀착시켜, 전철의 흔들림에 맞춰 복종을 명하고 쾌락을 허락받는 감각을 몸에 짙게 각인한다.",function()return{addm("compliance",2)}end)}}
add{id="pc_harmonizer_007",name="암컷 유린",rarity="common",style="harmonizer",cost=1,damage=2,roles={"violation","pressure"},rules={"순응 무드면 추가 저항 피해 5와 반발 3."},description="이미 순응한 몸의 하의 속으로 깊숙이 손을 넣어 비순과 음핵을 농락하고, 강한 쾌감을 새기는 대신 잠잠하던 반발심까지 다시 자극하는 행동입니다.",actorAction="긴장한 몸을 붙잡고 옷 위로 가슴과 가랑이를 부드럽게 쓰다듬으며 쾌락의 온도를 살핀다.",actorActionMet="완전히 순응하여 저항을 잊은 다리 틈새로 손을 거침없이 밀어 넣는다. 조교에 녹아내려 질척하게 애액이 번진 속옷 안쪽의 맨살 비순을 손가락으로 주무르고 클리토리스를 집요하게 굴려대며, 전신을 경련케 하는 절정과 함께 깊은 반발까지 동시에 끌어낸다.",condition=function(c)return c.mood=="compliance"end,resolve=function(c,met)if met then return{dmg(5),back(c,3)}end return{}end}
add{id="pc_harmonizer_008",name="녹아내린 빈틈",rarity="common",style="harmonizer",cost=1,damage=3,roles={"violation"},rules={"직전 턴 동안 무드가 긍정적으로 이동했다면 추가 저항 피해 2."},description="경계가 풀리고 흥분이 고조되는 순간을 포착해 가슴과 엉덩이를 동시에 애무하여 저항을 무너뜨리는 행동입니다.",actorAction="점차 거부감이 옅어지며 가늘게 숨을 고르는 상대의 가슴을 등 뒤에서 부드럽게 감싸 쥔다. 한 손으로는 가슴을 쫀득하게 주무르고 하체로는 앞섶을 엉덩이골에 밀착해 안정적인 쾌락을 쏟아붓는다.",actorActionMet="전보다 긴장이 풀려 은근히 달아오른 몸을 품에 깊숙이 끌어당겨, 얇은 옷 너머로 가랑이 틈새를 집요하게 눌러대며 가쁜 교성을 터뜨리게 만든다.",condition=function(c)return moved(c,1)end,resolve=function(,met)if met then return{dmg(2)}end return{}end}
add{id="pc_harmonizer_009",name="쾌락의 늪 설계",rarity="common",style="harmonizer",cardType="plan",cost=1,roles={"violation"},rules={"지속 3턴, 충전 2. 턴 시작 시 직전 턴 동안 무드가 긍정적으로 이동했다면 저항 피해 3."},description="상대의 마음이 쾌락 쪽으로 한 단계 기울 때마다 은밀한 성감대를 자극해 저항을 깎아내는 ::tag[plan]::을 배치합니다.",placed="허리를 끌어안고 앞섶의 각도를 맞추며, 상대의 반응이 긍정적으로 기울 때 닿을 민감한 부위의 마찰면을 미리 세팅한다.",triggered="마음이 쾌락 쪽으로 기울며 몸이 은근히 달아오르는 순간, 맞물려 있던 앞섶을 사타구니 안쪽으로 깊숙이 밀어 올려 더 깊은 쾌락의 늪으로 끌어당긴다.",plan={durationTurns=3,charges=2,event="turn_start",trigger=function(c)return moved(c,1)end,resolve=function()return{dmg(3)}end}}
add{id="pc_harmonizer_010",name="점진적 조교",rarity="common",style="harmonizer",cardType="plan",cost=1,roles={"pressure"},rules={"배치 시 농락 1. 지속 4턴, 충전 2. 턴 시작 시 직전 턴 동안 무드가 부정적으로 이동했다면 농락 2."},description="배치 즉시 농락을 가하고, 상대가 저항하거나 의심하려 할 때마다 귓가 조교로 마음을 되돌리는 ::tag[plan]::을 배치합니다.",placed="귓가에 뜨거운 숨을 불어넣으며 호흡과 골반의 움직임을 맞추어 조교의 리듬을 몸에 새긴다.",triggered="상대가 차갑게 마음을 닫으려 몸을 비틀 때마다 귓불을 부드럽게 깨물며 아무리 발버둥 쳐도 몸은 정직하게 느끼고 있다고 속삭여 마음을 다시 녹인다.",resolve=function(c)return{manip(c,1)}end,plan={durationTurns=4,charges=2,event="turn_start",trigger=function(c)return moved(c,-1)end,resolve=function(c)return{manip(c,2)}end}}
add{id="pc_harmonizer_011",name="감각 되돌리기",rarity="common",style="harmonizer",cost=0,damage=2,roles={"pressure","violation"},rules={"현재 무드에 인접한 두 무드(극단에서는 현재 무드 포함) 중 부정 쪽 토큰을 최대 2개 제거하고 긍정 쪽 토큰을 같은 수만큼 추가."},description="현재 마음 주변의 부정적인 감정을 긍정적인 쪽으로 되돌려 저항을 누그러뜨리는 행동입니다.",actorAction="굳은 표정과 거친 호흡을 다정하게 맞추며 상대의 손을 슬며시 쥐어 허벅지 위에 얹는다. 거부감과 의심으로 차오르던 마음을 차분히 녹여내며 한 단계 부드러운 방향으로 감각을 돌려놓는다.",resolve=function(c)local a=adj(c.mood,-1);local b=adj(c.mood,1);local n=math.min(2,c.character.moodTokens[a]or 0)if n==0 then return{}end return{remm(a,n),addm(b,n)}end}
add{id="pc_harmonizer_012",name="감미로운 절정",rarity="rare",style="harmonizer",cost=2,damage=2,roles={"violation"},rules={"긍정 무드면 추가 저항 피해 5."},description="이미 경계가 누그러지고 긍정적인 쾌락에 기운 상대의 성감대를 깊숙이 파고들어, 강렬한 절정으로 몰아가는 행동입니다.",actorAction="떨리는 몸을 받치고 옷 위로 가장 민감한 부위를 부드럽게 자극해 달콤한 쾌감을 끌어낸다.",actorActionMet="이미 쾌락 쪽으로 기울어 은근히 촉촉해진 살결을 확인하고 하의 속으로 손을 깊숙이 밀어 넣는다. 부드러운 비순 틈새의 클리토리스를 손가락 끝으로 끈적하게 굴려대며, 더 이상 부정하기 어려운 황홀한 절정을 터뜨린다.",condition=function(c)return pos(c.mood)end,resolve=function(,met)if met then return{dmg(5)}end return{}end}
add{id="pc_harmonizer_013",name="흔들리는 마음",rarity="rare",style="harmonizer",cost=2,roles={"pressure","violation"},rules={"거절·의심 토큰 합이 혼란·순응 토큰 합 이상이면 농락 3, 이하면 저항 피해 3"},description="거절과 의심, 혼란과 순응으로 갈린 마음의 무게를 읽어 가장 흔들리기 쉬운 지점을 공략하는 행동입니다.",actorAction="상대의 가쁜 숨결과 미세하게 떨리는 허벅지를 살피며 귓가에 짓궂은 말을 속삭이고 손바닥으로 엉덩이를 꽉 주무른다. 거부하려 들면 농염하게 유혹하고 이미 녹아내렸다면 깊숙이 자극하여 마음을 더 끌어당긴다.",resolve=function(c)local t=c.character.moodTokens;local n=(t.rejection or 0)+(t.suspicion or 0);local p=(t.confusion or 0)+(t.compliance or 0);if n>p then return{manip(c,3)}elseif p>n then return{dmg(3)}end return{manip(c,3),dmg(3)}end}
local mc={}for _,m in ipairs(MOODS)do local target=m;mc[#mc+1]=choice(m,m,"모든 무드 토큰을 2로 만들고 선택 무드에 1 추가.","양팔로 상대를 품에 안고 귓가, 목덜미, 가슴, 가랑이를 차례로 부드럽게 훑어내린다. 수치와 흥분, 의심과 순응이 비슷한 농도로 뒤섞이도록 호흡과 손길을 맞춘 뒤, 선택한 감정만 한층 선명하게 떠오르도록 마지막 자극을 더한다.",function(c)local r={}for _,x in ipairs(MOODS)do local n=c.character.moodTokens[x]or 0;if n<2 then r[#r+1]=addm(x,2-n)elseif n>2 then r[#r+1]=remm(x,n-2)end end r[#r+1]=addm(target,1)return r end)end
add{id="pc_harmonizer_014",name="완벽한 조율",rarity="legendary",style="harmonizer",cost=4,roles={"pressure"},mechanisms={"remove"},rules={"소멸. 모든 무드 토큰 수를 2로 맞춘 뒤 선택한 무드 토큰 1 추가."},description="모든 무드 토큰을 2로 맞춘 뒤, 다섯 무드 중 하나를 선택해 그 토큰을 1 추가하는 전설의 조율 행동입니다.",choices=mc}
-- 탐식자: 반발을 감수한 고성능과 부정 무드 탈출
add{id="pc_glutton_001",name="거친 가슴 애무",rarity="common",style="glutton",cost=1,damage=4,roles={"violation","pressure"},rules={"반발 1."},description="상대의 반발을 개의치 않고 옷 위로 풍만한 가슴을 한 손 가득 덥석 움켜쥐어 주무르는 대담한 행동입니다.",actorAction="상대가 움찔거리며 몸을 빼려는 것도 아랑곳하지 않고 옷 위로 솟아오른 가슴을 거침없이 감싸 쥔다. 손아귀에 넘치도록 말랑한 젖살을 쫀득하게 주무르며 손가락 사이로 살이 비어져 나올 만큼 세게 주물러, 원망 어린 시선에도 손길을 늦추지 않는다.",resolve=function(c)return{back(c,1)}end}
add{id="pc_glutton_002",name="엉덩이 기습",rarity="common",style="glutton",cardType="chain",cost=0,damage=2,roles={"violation","pressure"},rules={"반발 1."},description="::tag[chain]:: 반발을 감수하고 탄력 넘치는 엉덩이를 덥석 주물러 다음 유린으로 몰아붙이는 연계 행동입니다.",actorAction="망설임 없이 손을 뻗어 탄력 넘치는 엉덩이 살을 한 손 가득 깊게 움켜쥐고 세게 쥐어짠다. 흠칫 놀라 돌아보려는 상대의 허리에 앞섶을 거칠게 밀착하고, 반발을 감수한 채 다음 애무로 이어갈 틈을 만든다.",resolve=function(c)return{back(c,1)}end}
add{id="pc_glutton_003",name="위험한 사각",rarity="common",style="glutton",cost=0,roles={"deception","pressure"},rules={"은폐 4 회복. 반발 1. 부정 무드면 무시 토큰 2 추가."},description="대담하게 사각을 차지해 시야와 퇴로를 가리고 은폐를 크게 회복합니다. 그 뻔뻔함은 반발을 사지만, 이미 분위기가 차갑다면 상대가 상황을 외면하도록 압박합니다.",actorAction="상대를 기둥 뒤 사각으로 밀어 넣고 태연한 얼굴로 시야를 가리며 몸을 붙인다.",actorActionMet="거절과 의심으로 날 선 상대를 기둥 뒤 사각에 몰아넣고 시야와 퇴로를 가려, 분노 어린 시선에도 아랑곳하지 않고 현실을 외면하게 만든다.",condition=function(c)return neg(c.mood)end,resolve=function(c,met)local r={rec(4),back(c,1)}if met then r[#r+1]=addm("ignore",2)end return r end}
add{id="pc_glutton_004",name="반발 달래기",rarity="common",style="glutton",cost=1,damage=2,roles={"pressure","violation"},rules={"농락 1. 부정 무드면 진정 1과 추가 농락 1."},description="차가운 거부감 속에서도 다정하게 허리를 쓰다듬으며 민감한 곳을 끈질기게 희롱해, 분노를 가라앉히고 힘을 빼앗는 행동입니다.",actorAction="거칠어진 호흡을 달래듯 허리를 쓰다듬으면서도 옷 위로 허벅지 안쪽의 민감한 살결을 놓치지 않고 희롱한다.",actorActionMet="거절과 의심으로 굳어 있는 허리를 부드럽게 다독여 긴장을 풀면서, 팽팽하게 당겨진 가랑이 틈새를 손가락으로 끈질기게 문질러 힘을 빼놓는다.",condition=function(c)return neg(c.mood)end,resolve=function(c,met)local r={manip(c,1)}if met then r[#r+1]=calm(c,1);r[#r+1]=manip(c,1)end return r end}
add{id="pc_glutton_005",name="무심한 척 농락",rarity="common",style="glutton",cost=1,damage=1,roles={"pressure","violation"},rules={"농락 2. 직전 턴 동안 무드가 긍정적으로 이동했다면 무시 무드 강제."},description="아무 일도 없다는 듯 민감한 곳을 희롱하여, 상대가 달아오른 반응마저 스스로 애써 외면하고 넘어가도록 유도하는 행동입니다.",actorAction="아무 일도 없다는 표정으로 손끝만 은근히 움직여 허벅지와 엉덩이 살결을 스치고, 상대의 당황한 반응을 모른 척한다.",actorActionMet="전보다 쾌락 쪽에 기운 반응을 보고도 태연하게 은근히 달아오른 살결을 희롱하며, 귓가에 지금 소란을 피워봤자 부끄러운 꼴만 보일 뿐이라고 나직이 속삭여 스스로 아무 일도 아니라고 외면하게 만든다.",condition=function(c)return moved(c,1)end,resolve=function(c,met)local r={manip(c,2)}if met then r[#r+1]=force("ignore")end return r end}
add{id="pc_glutton_006",name="부정 탈출 포식",rarity="common",style="glutton",cost=1,damage=2,roles={"violation"},rules={"직전 턴 시작 무드가 부정이고 현재 무드가 무시 또는 긍정이면 추가 저항 피해 5."},description="거절과 의심에서 벗어나 무방비해진 틈을 포착해, 숨겨왔던 탐욕으로 강렬한 쾌락을 뜯어내는 행동입니다.",actorAction="굶주린 듯 상대를 끌어당겨 옷 위로 엉덩이와 허벅지를 거칠게 주무르며 쾌락을 뜯어낸다.",actorActionMet="방금 전까지의 날 선 거부감이 꺾이고 무방비하게 숨을 고르는 찰나를 놓치지 않고 하의 속으로 손을 깊숙이 파고든다. 무방비하게 드러난 맨살 비순과 음핵을 손바닥 전체로 거칠게 주물러대며, 억눌러왔던 교성을 단번에 터뜨리게 만든다.",condition=function(c)local p=c.history and c.history.previousTurn return type(p)=="table"and neg(p.startMood)and(c.mood=="ignore"or pos(c.mood))end,resolve=function(_,met)if met then return{dmg(5)}end return{}end}
add{id="pc_glutton_007",name="거절 강요 유린",rarity="rare",style="glutton",cost=2,damage=7,roles={"violation","pressure"},rules={"거절 무드 강제."},description="상대가 결사적으로 거부하며 몸을 굳힐 것을 알면서도, 억지로 다리 사이를 비집고 들어가 비순을 짓누르는 거칠고 대담한 유린 행동입니다.",actorAction="상대가 분노로 이를 악물고 몸을 비틀어 밀어내려는 것을 힘으로 억누르며 하의 속으로 손을 거침없이 밀어 넣는다. 잔뜩 긴장해 굳어버린 허벅지 틈을 억지로 가르고 들어가 속옷 너머의 비순을 손바닥으로 거칠게 압박해 짓이기듯 문지르며, 치욕과 고통스러운 쾌감이 뒤섞인 비명을 억지로 삼키게 만든다.",resolve=function()return{force("rejection")}end}
add{id="pc_glutton_008",name="불온한 휴식처",rarity="common",style="glutton",cardType="plan",cost=1,roles={"deception","pressure"},rules={"지속 3턴, 충전 2. 턴 시작 시 부정 무드면 진정 2와 은폐 3 회복."},description="상대의 날 선 경계와 의심 속에서도 능숙하게 인파 뒤로 몸을 숨겨 은폐를 가다듬고 동요를 가라앉히는 ::tag[plan]::을 배치합니다.",placed="인파 깊숙한 사각과 상대가 진정할 호흡의 틈을 마련한다.",triggered="거절과 의심이 짙어지자 사각으로 몸을 숨기고 떨리는 호흡을 부드럽게 가라앉힌다.",plan={durationTurns=3,charges=2,event="turn_start",trigger=function(c)return neg(c.mood)end,resolve=function(c)return{calm(c,2),rec(3)}end}}
add{id="pc_glutton_009",name="무시로 몰기",rarity="common",style="glutton",cost=1,roles={"pressure"},rules={"농락 2. 부정 무드면 무시 토큰 2 추가."},description="상대의 반항을 비웃으며 민감한 곳을 끈질기게 희롱해, 저항을 포기하고 상황을 무시하게 만드는 행동입니다.",actorAction="상대의 반응을 비웃듯 옷 위로 엉덩이 살을 꽉 감싸 쥐며, 생각할 틈을 조금씩 빼앗는다.",actorActionMet="노려보는 상대의 귓가에 입술을 바싹 대고, 화를 내봤자 주변 사람들의 시선만 끌 뿐이라고 조용히 경고하며, 거절과 의심으로 버티는 몸을 집요하게 희롱해 저항하는 것조차 지쳐 외면하게 만든다.",condition=function(c)return neg(c.mood)end,resolve=function(c,met)local r={manip(c,2)}if met then r[#r+1]=addm("ignore",2)end return r end}
add{id="pc_glutton_010",name="탐욕의 전환",rarity="common",style="glutton",cost=2,roles={"pressure"},rules={"더 깊은 농락은 농락 3. 무시 유도는 무시 토큰 2 추가."},description="농락 3과 무시 토큰 2 추가 중 하나를 선택합니다.",choices={choice("devour","더 깊은 농락","농락 3.","상대의 반응을 탐욕스럽게 좇아 단단한 앞섶을 엉덩이에 더 깊이 밀착하고 허리를 비비며 유혹한다.",function(c)return{manip(c,3)}end),choice("ignore","무시 유도","무시 토큰 2 추가.","주변 사람들의 시선을 상기시키며 아무 일도 없었던 척 넘어가는 게 서로에게 좋을 거라며 귓가에 서늘하게 경고한다.",function()return{addm("ignore",2)}end)}}
add{id="pc_glutton_011",name="탐욕의 손길",rarity="common",style="glutton",cardType="chain",cost=0,roles={"deception"},mechanisms={"remove"},rules={"선택 시 즉시 카드 1장 드로우. 사용 후 소멸."},description="::tag[chain]:: 열차가 흔들리는 찰나의 틈을 포착해 몸을 밀착하고, 다음 유린을 펼칠 카드를 빠르게 보충하는 소멸성 연계 행동입니다.",actorAction="승객들이 쏠리는 순간을 틈타 상대의 등 뒤로 미끄러지듯 밀착하며 손끝으로 허리를 가볍게 스친다. 완벽한 사각을 확보한 뒤 머릿속으로 다음 능욕의 수를 신속하게 떠올린다.",preview={effects={ {id="glutton_draw",op="draw_cards",target="player",amount=1} }}}
add{id="pc_glutton_012",name="추락 뒤의 포식",rarity="rare",style="glutton",cardType="plan",cost=2,roles={"violation","deception"},rules={"지속 4턴, 충전 2. 턴 시작 시 직전 턴 동안 무드가 부정적으로 이동했다면 저항 피해 2와 은폐 4 회복."},description="상대의 마음이 부정적으로 추락한 순간 그 반발을 역이용해 은폐를 대폭 회복하고 저항을 깎아먹는 ::tag[plan]::을 배치합니다.",placed="감정이 무너지는 순간 숨을 곳과 파고들 위치를 함께 살핀다.",triggered="마음이 추락한 순간 사각으로 끌어당겨 흔적을 감추고 짧고 강한 쾌락을 뜯어낸다.",plan={durationTurns=4,charges=2,event="turn_start",trigger=function(c)return moved(c,-1)end,resolve=function()return{dmg(2),rec(4)}end}}
add{id="pc_glutton_013",name="위태로운 자극",rarity="rare",style="glutton",cardType="chain",cost=1,damage=3,roles={"violation","pressure"},rules={"의심 토큰 1과 거절 토큰 1 추가."},description="::tag[chain]:: 상대의 의심과 거절을 불러올 만큼 대담하게 옷 위로 가랑이를 움켜쥐고 쾌락을 주입하는 연계 행동입니다.",actorAction="들킬 위험을 무릅쓰고 사람들 시선 아래에서 상대의 다리 사이로 손을 뻗어, 팽팽하게 당겨진 가랑이 틈을 손바닥으로 거칠게 움켜쥐듯 짓누른다. 깜짝 놀라 돌아보며 의심 어린 눈빛으로 노려보는 상대의 표정을 즐기며 찌릿한 자극을 남긴다.",resolve=function()return{addm("suspicion",1),addm("rejection",1)}end}
add{id="pc_glutton_014",name="현실 외면 포식",rarity="legendary",style="glutton",cost=3,damage=2,roles={"violation","pressure"},rules={"무시 무드 강제. 이번 턴의 캐릭터 행동 생략."},description="상대가 이번 턴 꺼내 들 방어 수단을 무효화하고, 강제로 무시 상태에 빠뜨려 침묵하게 만드는 전설의 행동입니다.",actorAction="뒤에서 양팔로 상대를 감싸 차벽 앞에 바싹 세우고 귓가에 낮은 숨결을 흘려 말을 끊는다. 주변 시선을 의식해 목소리를 삼키는 순간 단단한 앞섶을 엉덩이골에 빈틈없이 밀착하고 허리를 억누르며, 당혹감과 쾌락 속에서 조용히 상황을 넘기게 만든다.",resolve=function()return{force("ignore"),cmd("skip_actions","character")}end}
-- 기만자: 은폐 회복과 계획 조작
add{id="pc_deceiver_001",name="인파 속 손길",rarity="common",style="deceiver",cost=0,damage=1,roles={"deception","violation"},rules={"은폐 4 회복."},description="붐비는 승객들 사이로 자연스럽게 몸을 섞어 의심을 지우고, 스쳐 지나가는 척 은밀하게 엉덩이를 건드리는 행동입니다.",actorAction="만원 전철의 인파 속으로 슬그머니 몸을 숨기며 상대의 시야에서 벗어난다. 비좁은 틈을 빠져나가는 척 손등으로 탱탱한 엉덩이 살을 슬쩍 쓸어내리며, 흔적도 없이 완벽한 은폐를 회복한다.",resolve=function()return{rec(4)}end}
add{id="pc_deceiver_002",name="안심시키는 밀착",rarity="common",style="deceiver",cost=0,roles={"deception","pressure"},rules={"은폐 4 회복. 농락 1."},description="사람이 밀려서 닿았을 뿐이라며 뻔뻔하게 사과하여 의심을 씻어내고, 귓가에 은밀한 농락을 남기는 행동입니다.",actorAction="양손을 가볍게 들어 올리며 승객들이 밀려와 어쩔 수 없이 닿았다고 나직하게 둘러댄다. 결백한 척 물러서면서도 귓가에는 다음엔 더 기분 좋게 해 주겠다는 짓궂은 숨결을 불어넣어 상대를 안도와 동요에 빠뜨린다.",resolve=function(c)return{rec(4),manip(c,1)}end}
add{id="pc_deceiver_003",name="흔적 감추기",rarity="common",style="deceiver",cardType="chain",cost=0,damage=1,roles={"deception","violation"},rules={"은폐 2 회복."},description="::tag[chain]:: 열차의 흔들림에 맞춰 자연스럽게 스쳐 지나가며 은폐를 정돈하고 다음 유린을 준비하는 연계 행동입니다.",actorAction="열차가 좌우로 요동치는 순간 자연스럽게 몸을 기울여 팽창한 앞섶을 엉덩이에 가볍게 스치고 지나간다. 의도치 않은 사고처럼 꾸며내며 은폐를 유지한 채 다음 동작으로 매끄럽게 연결한다.",resolve=function()return{rec(2)}end}
add{id="pc_deceiver_004",name="계획 교란",rarity="common",style="deceiver",cost=1,damage=2,roles={"violation"},rules={"플레이어와 캐릭터의 모든 계획을 제거. 제거된 계획 하나당 추가 저항 피해 2."},description="예상 밖의 변수를 터뜨려 플레이어와 캐릭터의 계획을 모두 무너뜨리고, 제거된 계획만큼 강하게 파고드는 행동입니다.",actorAction="예상 밖의 타이밍에 움직여 서로 준비해 둔 계획을 한꺼번에 어그러뜨리고, 그 틈으로 깊이 파고들어 무너진 계획만큼 옷 위로 강한 마찰을 안긴다.",resolve=function(c)local n=(c.player.planCount or 0)+(c.character.planCount or 0)if n>0 then return{dmg(n*2)}end return{}end,planOp={kind="remove_all"}}
add{id="pc_deceiver_005",name="계획된 농락",rarity="common",style="deceiver",cost=0,damage=2,roles={"pressure","violation"},rules={"플레이어 계획이 있으면 농락 2, 없으면 농락 1."},description="설치된 덫이 있다는 여유를 드러내며 귓가에 배덕적인 속삭임을 남겨 흥분을 고조시키는 행동입니다.",actorAction="열차의 흔들림에 손길을 섞어 우연한 접촉처럼 몸을 은근히 희롱한다.",actorActionMet="설치된 덫을 의식하지 못한 상대의 귓가에 입술을 바싹 대고, 아무리 경계해도 움직임은 이미 읽혔다는 사실을 나직이 상기시키며 수치심에 떨리는 목덜미와 쇄골 라인을 손끝으로 쓸어내려 서서히 쾌락에 빠져들게 만든다.",condition=function(c)return c.player.planCount>0 end,resolve=function(c,met)return{manip(c,met and 2 or 1)}end}
add{id="pc_deceiver_006",name="낡은 계획 폐기",rarity="common",style="deceiver",cardType="chain",cost=2,roles={"deception","violation"},mechanisms={"insight"},rules={"간파. 캐릭터 계획이 있을 때만 상대 계획 간파를, 플레이어 계획이 있을 때만 내 계획 청산을 선택할 수 있다. 상대 계획 간파는 은폐 2 회복 후 가장 오래된 캐릭터 계획 제거. 내 계획 청산은 저항 피해 4 후 가장 오래된 플레이어 계획 제거."},description="::tag[insight]:: ::tag[chain]:: 상대 계획을 제거하며 은폐를 회복하는 효과와 내 계획을 제거하며 피해를 주는 효과 중 하나를 선택합니다.",choices={choice("character_plan","상대 계획 간파","은폐 2 회복. 가장 오래된 캐릭터 계획 제거.","상대가 경계하며 세워둔 방어 자세의 허점을 간파해 가볍게 흘려내고, 허탈해진 틈을 타 안전하게 인파 속으로 숨어들어 흔적을 지운다.",function()return{rec(2)}end,function(c)if(c.character.planCount or 0)>0 then return true end return false,"no_character_plan"end),choice("player_plan","내 계획 청산","저항 피해 4. 가장 오래된 플레이어 계획 제거.","설치해 두었던 밀착 자세를 과감히 거두는 척, 상대의 허벅지 안쪽 살결을 손바닥으로 강하게 훑어 올리며 속옷 밴드 가장자리를 은밀히 튕겨내듯 자극해 저항을 깎아낸다.",function()return{dmg(4)}end,function(c)if(c.player.planCount or 0)>0 then return true end return false,"no_player_plan"end)},planOp={byChoice={character_plan={kind="remove",side="character"},player_plan={kind="remove",side="player"}}}}
add{id="pc_deceiver_007",name="허점 역이용",rarity="common",style="deceiver",cost=2,damage=3,roles={"violation"},mechanisms={"insight"},rules={"간파. 캐릭터 계획이 있으면 추가 저항 피해 3."},description="::tag[insight]:: 상대가 경계 태세를 갖추느라 생긴 결정적인 사각을 간파하고, 무방비해진 가슴이나 가랑이를 기습하는 행동입니다.",actorAction="상대의 시선과 호흡이 흐트러진 짧은 틈으로 손을 넣어 옷 위로 민감한 곳을 누른다.",actorActionMet="상대가 대응을 준비하는 빈틈을 포착하고 방어가 비어버린 옷 속으로 손을 깊숙이 밀어 넣는다. 솟아오른 유두와 가슴을 손바닥 가득 움켜쥐며, 허를 찔린 교성을 삼키게 만든다.",condition=function(c)return c.character.planCount>0 end,resolve=function(,met)if met then return{dmg(3)}end return{}end}
add{id="pc_deceiver_008",name="숨겨둔 마무리",rarity="common",style="deceiver",cardType="plan",cost=2,roles={"violation"},rules={"지속 3턴, 충전 2. 턴 시작 시 은폐 15 이상이면 저항 피해 2. 만료되거나 명시적으로 제거되면 저항 피해 3."},description="높은 은폐를 유지하며 상대의 등 뒤에 서서히 다가가, 지속적인 압박과 함께 마무리 일격을 가하는 ::tag[plan]::을 배치합니다.",placed="완벽한 사각을 확보하고 상대의 엉덩이 뒤에 바싹 달라붙어, 눈치채지 못할 만큼 미세한 마찰을 시작한다.",triggered="주변의 시선이 분산된 틈을 타 빳빳한 앞섶으로 엉덩이골을 뭉근하게 밀어 올리며, 소리 없이 야금야금 경계를 느슨하게 만든다.",plan={durationTurns=3,charges=2,event="turn_start",trigger=function(c)return c.player.stealth>=15 end,resolve=function()return{dmg(2)}end,exitResolve=function()return{dmg(3)}end}}
add{id="pc_deceiver_009",name="폭로 역습 장치",rarity="common",style="deceiver",cardType="plan",cost=0,roles={"violation","deception"},rules={"지속 3턴, 충전 1. 캐릭터 폭로 카드가 해결되면 저항 피해 4와 은폐 1 회복."},description="상대가 도움을 청하거나 고발하려 할 때 억울한 피해자인 척 위장하여 상대를 역으로 몰아세우는 ::tag[plan]::을 배치합니다.",placed="주변 승객들이 보기에 완벽하게 무고한 승객처럼 보이도록 자세와 표정을 세팅하고 대기한다.",triggered="상대가 목소리를 높여 고발하려는 순간 억울한 표정으로 오히려 자기가 밀림을 당했다고 항변하여 상대를 당황시키고, 말문이 막힌 틈을 타 옷 속 은밀한 곳을 손끝으로 자극해 수치심을 안긴다.",plan={durationTurns=3,charges=1,event="card_resolved",side="character",trigger=function(,e)for ,r in ipairs(e.roles or{})do if r=="exposure"then return true end end return false end,resolve=function()return{dmg(4),rec(1)}end}}
add{id="pc_deceiver_010",name="비싼 행동의 덫",rarity="common",style="deceiver",cardType="plan",cost=0,roles={"violation"},rules={"지속 4턴, 충전 2. 플레이어 카드의 최종 은폐 비용이 2 이상이면 저항 피해 3."},description="대담하고 큰 애무를 감행할 때마다 상대가 저항하지 못하도록 추가적인 쾌락을 덧씌우는 ::tag[plan]::을 배치합니다.",placed="큰 동작을 취해도 들키지 않을 만한 최적의 사각지대와 옷자락 틈새를 미리 계산해 둔다.",triggered="대담하게 손을 뻗어 몸을 유린할 때마다 사전에 확보한 각도를 이용해 육봉을 엉덩이에 더 깊이 밀착시키며 진한 전율을 덧씌운다.",plan={durationTurns=4,charges=2,event="card_declared",side="player",trigger=function(,e)return(e.finalStealthCost or 0)>=2 end,resolve=function()return{dmg(3)}end}}
add{id="pc_deceiver_011",name="비밀 패 보충",rarity="common",style="deceiver",cardType="plan",cost=1,roles={"deception"},rules={"지속 4턴, 충전 2. 턴 시작 시 카드 1장 드로우."},description="전철 내의 정황과 상대의 반응을 냉철하게 관찰하며 매 턴 새로운 능욕의 수단을 확보하는 ::tag[plan]::을 배치합니다.",placed="차창의 반사와 승객들의 동선을 주시하며 다음 기회를 포착하기 위한 유리한 위치를 선점한다.",triggered="새 턴이 시작될 때마다 숨겨둔 수단 하나를 아무도 모르게 머릿속에 즉시 떠올린다.",plan={durationTurns=4,charges=2,event="turn_start",trigger=function()return true end,resolve=function()return{draw(1)}end}}
add{id="pc_deceiver_012",name="회복 위장 공세",rarity="rare",style="deceiver",cardType="plan",cost=2,roles={"violation"},rules={"지속 4턴, 충전 2. 플레이어 카드 한 장이 은폐를 3 이상 회복하면 저항 피해 4."},description="완벽하게 시치미를 떼며 은폐를 회복하는 찰나마다 상대의 몸에 배덕적인 쾌락을 새겨 넣는 ::tag[plan]::을 배치합니다.",placed="결백한 승객인 척 위장하면서도 손가락 끝은 상대의 옷자락 틈새에 걸쳐두는 이중적인 덫을 놓는다.",triggered="태연하게 시치미를 떼며 몸을 숨기는 순간, 걸쳐둔 손가락으로 속옷 너머의 음핵을 은밀히 튕겨내어 쾌락과 억울함에 몸부림치게 만든다.",plan={durationTurns=4,charges=2,event="card_resolved",side="player",trigger=function(_,e)return(e.grossStealthRecovery or 0)>=3 end,resolve=function()return{dmg(4)}end}}
add{id="pc_deceiver_013",name="계획 연장",rarity="rare",style="deceiver",cardType="chain",cost=2,roles={"deception"},rules={"모든 플레이어 계획의 남은 지속 턴과 충전을 각각 1 증가."},description="::tag[chain]:: 은폐를 정돈하고 자세를 바로잡아, 현재 가동 중인 음란한 계획의 지속 시간과 기회를 늘리는 연계 행동입니다.",actorAction="주변의 시선을 피해 몸의 중심을 살짝 바꾸며 하체 밀착을 더 단단하게 고정한다. 자세가 흐트러지지 않도록 덫의 빈틈을 꼼꼼히 메우며 다음 턴에도 계획을 이어갈 발판을 다진다.",planOp={kind="adjust",side="player",all=true,remainingTurnsDelta=1,remainingChargesDelta=1}}
add{id="pc_deceiver_014",name="비밀 계획 실행",rarity="legendary",style="deceiver",cost=0,damage=0,roles={"violation"},mechanisms={"insight"},rules={"간파. 모든 플레이어 계획을 조건과 충전을 소모하지 않고 1회 발동."},description="::tag[insight]:: 완벽한 기만술로 상대의 빈틈을 파고들어, 준비해 둔 활성 계획의 발동 효과를 충전 소모 없이 즉시 끌어내는 전설의 행동입니다.",actorAction="상대가 완전히 방심하고 결백을 믿어버린 찰나, 준비해 둔 덫의 핵심 동작을 예정보다 먼저 끌어낸다. 옷 속으로 손을 밀어 넣어 비순과 음핵 부근을 농밀하게 자극하고 앞섶을 엉덩이골에 밀착해 비벼대며, 충전을 아낀 채 계획의 쾌감을 한 차례 더 터뜨린다.",planOp={kind="activate",side="player",all=true}}
PLAYER · 교전 수치은폐 · {{dict_element::{{tempvar::battle_view_player}}::stealth}}발각되지 않고 행동할 수 있는 여유입니다. 카드 비용과 효과로 감소합니다.상대의 저항이 남은 채 0 이하가 되면 패배하며, 회복 효과로 증가할 수 있습니다.어디든 누르면 닫힙니다
상대의 계획
{{#each {{dict_element::{{tempvar::battle_view_character}}::plans}} plan}}
{{#if {{equal::{{dict_element::{{slot::plan}}::status}}::empty}}}}빈 슬롯{{/if}}
{{#if {{equal::{{dict_element::{{slot::plan}}::status}}::hidden}}}}
? 계획
상대의 계획아직 공개되지 않음상대가 계획을 실행하거나 공개 효과가 적용되기 전까지 내용을 알 수 없습니다.어디든 누르면 닫힙니다
PLAYER · 내 계획{{dict_element::{{dict_element::{{slot::playerPlan}}::card}}::name}}{{#each {{dict_element::{{dict_element::{{slot::playerPlan}}::card}}::descriptionSegments}} playerPlanDescriptionSegment}}{{#if {{equal::{{dict_element::{{slot::playerPlanDescriptionSegment}}::kind}}::text}}}}{{dict_element::{{slot::playerPlanDescriptionSegment}}::value}}{{/if}}{{#if {{equal::{{dict_element::{{slot::playerPlanDescriptionSegment}}::kind}}::tag}}}}{{dict_element::{{slot::playerPlanDescriptionSegment}}::label}}{{/if}}{{/each}}{{#if {{equal::{{dict_element::{{slot::playerPlan}}::hasDuration}}::true}}}}남은 지속시간 · {{dict_element::{{slot::playerPlan}}::remainingTurns}}턴{{/if}}{{#each {{dict_element::{{dict_element::{{slot::playerPlan}}::card}}::ruleLines}} playerPlanRule}}{{#each {{dict_element::{{slot::playerPlanRule}}::segments}} playerPlanRuleSegment}}{{#if {{equal::{{dict_element::{{slot::playerPlanRuleSegment}}::kind}}::text}}}}{{dict_element::{{slot::playerPlanRuleSegment}}::value}}{{/if}}{{#if {{equal::{{dict_element::{{slot::playerPlanRuleSegment}}::kind}}::tag}}}}{{dict_element::{{slot::playerPlanRuleSegment}}::label}}{{/if}}{{/each}}{{/each}}어디든 누르면 닫힙니다
{{/if}}
{{/each}}
무드
현재 · {{dict_element::{{dict_element::{{tempvar::battle_view_character}}::mood}}::label}}
거절
MOOD거절 · {{dict_element::{{dict_element::{{dict_element::{{tempvar::battle_view_character}}::mood}}::tokens}}::rejection}}현재 거절 무드 토큰 수입니다.화면의 게이지는 현재 값을 최대 5칸까지 표시합니다.어디든 누르면 닫힙니다
의심
MOOD의심 · {{dict_element::{{dict_element::{{dict_element::{{tempvar::battle_view_character}}::mood}}::tokens}}::suspicion}}현재 의심 무드 토큰 수입니다.화면의 게이지는 현재 값을 최대 5칸까지 표시합니다.어디든 누르면 닫힙니다
무시
MOOD무시 · {{dict_element::{{dict_element::{{dict_element::{{tempvar::battle_view_character}}::mood}}::tokens}}::ignore}}현재 무시 무드 토큰 수입니다.화면의 게이지는 현재 값을 최대 5칸까지 표시합니다.어디든 누르면 닫힙니다
혼란
MOOD혼란 · {{dict_element::{{dict_element::{{dict_element::{{tempvar::battle_view_character}}::mood}}::tokens}}::confusion}}현재 혼란 무드 토큰 수입니다.화면의 게이지는 현재 값을 최대 5칸까지 표시합니다.어디든 누르면 닫힙니다
순응
MOOD순응 · {{dict_element::{{dict_element::{{dict_element::{{tempvar::battle_view_character}}::mood}}::tokens}}::compliance}}현재 순응 무드 토큰 수입니다.화면의 게이지는 현재 값을 최대 5칸까지 표시합니다.어디든 누르면 닫힙니다
{{#each::keep {{dictelement::{{tempvar::setup_draft_offer}}::cards}} as setup_offer_card}}
{{settempvar::setup_offer_type::{{dictelement::{{slot::setup_offer_card}}::cardType}}}}
{{#when::keep::{{dictelement::{{slot::setup_offer_card}}::draftStyle}}::is::predator}}[image]{{/when}}
{{#when::keep::{{dictelement::{{slot::setup_offer_card}}::draftStyle}}::is::harmonizer}}[image]{{/when}}
{{#when::keep::{{dictelement::{{slot::setup_offer_card}}::draftStyle}}::is::glutton}}[image]{{/when}}
{{#when::keep::{{dictelement::{{slot::setup_offer_card}}::draftStyle}}::is::deceiver}}[image]{{/when}}
보유 {{dictelement::{{slot::setup_offer_card}}::ownedCopies}} / {{dictelement::{{slot::setup_offer_card}}::maxCopies}}{{#when::keep::{{dictelement::{{slot::setup_offer_card}}::rarity}}::is::rare}}희귀{{/when}}{{#when::keep::{{dictelement::{{slot::setup_offer_card}}::rarity}}::is::legendary}}전설{{/when}}
{{dictelement::{{slot::setup_offer_card}}::name}}
{{dictelement::{{tempvar::setup_offer_type}}::label}}{{#each::keep {{dictelement::{{slot::setup_offer_card}}::roles}} as setup_offer_role}}{{dictelement::{{slot::setup_offer_role}}::label}}{{/each}}{{#each::keep {{dictelement::{{slot::setup_offer_card}}::mechanisms}} as setup_offer_mechanism}}{{dictelement::{{slot::setup_offer_mechanism}}::label}}{{/each}}
{{dictelement::{{slot::setup_offer_card}}::baseStealthCost}}비용{{dictelement::{{slot::setup_offer_card}}::baseResistanceDamage}}피해
{{#each::keep {{dictelement::{{slot::setup_offer_card}}::descriptionSegments}} as setup_description_segment}}{{#when::keep::{{dictelement::{{slot::setup_description_segment}}::kind}}::is::text}}{{dictelement::{{slot::setup_description_segment}}::value}}{{/when}}{{#when::keep::{{dictelement::{{slot::setup_description_segment}}::kind}}::isnot::text}}{{#when::keep::{{dictelement::{{slot::setup_description_segment}}::tagKind}}::is::mechanism}}{{dictelement::{{slot::setup_description_segment}}::label}}{{/when}}{{#when::keep::{{dictelement::{{slot::setup_description_segment}}::tagKind}}::isnot::mechanism}}{{dictelement::{{slot::setup_description_segment}}::label}}{{/when}}{{/when}}{{/each}}{{#each::keep {{dictelement::{{slot::setup_offer_card}}::ruleLines}} as setup_rule_line}}{{#each::keep {{dictelement::{{slot::setup_rule_line}}::segments}} as setup_rule_segment}}{{#when::keep::{{dictelement::{{slot::setup_rule_segment}}::kind}}::is::text}}{{dictelement::{{slot::setup_rule_segment}}::value}}{{/when}}{{#when::keep::{{dictelement::{{slot::setup_rule_segment}}::kind}}::isnot::text}}{{#when::keep::{{dictelement::{{slot::setup_rule_segment}}::tagKind}}::is::mechanism}}{{dictelement::{{slot::setup_rule_segment}}::label}}{{/when}}{{#when::keep::{{dictelement::{{slot::setup_rule_segment}}::tagKind}}::isnot::mechanism}}{{dictelement::{{slot::setup_rule_segment}}::label}}{{/when}}{{/when}}{{/each}}{{/each}}카드를 눌러 상세 보기선택 대기
이 카드를 초기 덱에 추가
CARD TYPE{{dictelement::{{tempvar::setup_offer_type}}::label}}{{dictelement::{{tempvar::setup_offer_type}}::tooltip}}어디든 누르면 닫힙니다
{{#each::keep {{dictelement::{{slot::setup_offer_card}}::roles}} as setup_popover_role}}
ROLE{{dictelement::{{slot::setup_popover_role}}::label}}{{dictelement::{{slot::setup_popover_role}}::tooltip}}어디든 누르면 닫힙니다
{{/each}}
{{#each::keep {{dictelement::{{slot::setup_offer_card}}::mechanisms}} as setup_popover_mechanism}}
MECHANISM{{dictelement::{{slot::setup_popover_mechanism}}::label}}{{dictelement::{{slot::setup_popover_mechanism}}::tooltip}}어디든 누르면 닫힙니다
{{/each}}
{{#each::keep {{dictelement::{{slot::setup_offer_card}}::terms}} as setup_popover_term}}
RULE TERM{{dictelement::{{slot::setup_popover_term}}::label}}{{dictelement::{{slot::setup_popover_term}}::tooltip}}어디든 누르면 닫힙니다
{{#each::keep {{dictelement::{{tempvar::setup_draft_deck}}::items}} as setup_deck_item}}
{{dictelement::{{slot::setup_deck_item}}::name}}×{{dictelement::{{slot::setup_deck_item}}::copies}}
{{/each}}
{{#when::keep::{{dictelement::{{tempvar::setup_draft_deck}}::count}}::is::0}}
아직 선택한 카드가 없습니다.
{{/when}}
상세 전투 로그 펼쳐보기 · {{dictelement::{{tempvar::battle_log_view}}::turnCount}}턴
{{#each::keep {{dictelement::{{tempvar::battle_log_view}}::entries}} as battle_log_entry}}
{{#each::keep {{dictelement::{{tempvar::run_progression_reward}}::cards}} as run_reward_card}}
{{settempvar::run_reward_type::{{dictelement::{{slot::run_reward_card}}::cardType}}}}
{{#when::keep::{{dictelement::{{slot::run_reward_card}}::draftStyle}}::is::predator}}[image]{{/when}}
{{#when::keep::{{dictelement::{{slot::run_reward_card}}::draftStyle}}::is::harmonizer}}[image]{{/when}}
{{#when::keep::{{dictelement::{{slot::run_reward_card}}::draftStyle}}::is::glutton}}[image]{{/when}}
{{#when::keep::{{dictelement::{{slot::run_reward_card}}::draftStyle}}::is::deceiver}}[image]{{/when}}
{{dictelement::{{slot::run_reward_card}}::slot}}보유 {{dictelement::{{slot::run_reward_card}}::ownedCopies}} / {{dictelement::{{slot::run_reward_card}}::maxCopies}}
{{#when::keep::{{dictelement::{{slot::run_reward_card}}::rarity}}::is::rare}}희귀{{/when}}
{{#when::keep::{{dictelement::{{slot::run_reward_card}}::rarity}}::is::legendary}}전설{{/when}}
{{dictelement::{{slot::run_reward_card}}::name}}
{{dictelement::{{tempvar::run_reward_type}}::label}}
{{#each::keep {{dictelement::{{slot::run_reward_card}}::roles}} as run_reward_role}}
{{dictelement::{{slot::run_reward_role}}::label}}
{{/each}}
{{#each::keep {{dictelement::{{slot::run_reward_card}}::mechanisms}} as run_reward_mechanism}}
{{dictelement::{{slot::run_reward_mechanism}}::label}}
{{/each}}
{{#each::keep {{dictelement::{{slot::run_reward_card}}::descriptionSegments}} as run_reward_segment}}{{#when::keep::{{dictelement::{{slot::run_reward_segment}}::kind}}::is::text}}{{dictelement::{{slot::run_reward_segment}}::value}}{{/when}}{{#when::keep::{{dictelement::{{slot::run_reward_segment}}::kind}}::isnot::text}}{{#when::keep::{{dictelement::{{slot::run_reward_segment}}::tagKind}}::is::mechanism}}{{dictelement::{{slot::run_reward_segment}}::label}}{{/when}}{{#when::keep::{{dictelement::{{slot::run_reward_segment}}::tagKind}}::isnot::mechanism}}{{dictelement::{{slot::run_reward_segment}}::label}}{{/when}}{{/when}}{{/each}}
{{#each::keep {{dictelement::{{slot::run_reward_card}}::ruleLines}} as run_reward_rule}}
{{#each::keep {{dictelement::{{slot::run_reward_rule}}::segments}} as run_reward_rule_segment}}{{#when::keep::{{dictelement::{{slot::run_reward_rule_segment}}::kind}}::is::text}}{{dictelement::{{slot::run_reward_rule_segment}}::value}}{{/when}}{{#when::keep::{{dictelement::{{slot::run_reward_rule_segment}}::kind}}::isnot::text}}{{#when::keep::{{dictelement::{{slot::run_reward_rule_segment}}::tagKind}}::is::mechanism}}{{dictelement::{{slot::run_reward_rule_segment}}::label}}{{/when}}{{#when::keep::{{dictelement::{{slot::run_reward_rule_segment}}::tagKind}}::isnot::mechanism}}{{dictelement::{{slot::run_reward_rule_segment}}::label}}{{/when}}{{/when}}{{/each}}
{{/each}}
은폐 비용{{dictelement::{{slot::run_reward_card}}::baseStealthCost}}저항 피해{{dictelement::{{slot::run_reward_card}}::baseResistanceDamage}}
이 카드를 획득 · 클릭해 확정
CARD TYPE{{dictelement::{{tempvar::run_reward_type}}::label}}{{dictelement::{{tempvar::run_reward_type}}::tooltip}}어디든 누르면 닫힙니다
{{#each::keep {{dictelement::{{slot::run_reward_card}}::mechanisms}} as run_popover_mechanism}}
MECHANISM{{dictelement::{{slot::run_popover_mechanism}}::label}}{{dictelement::{{slot::run_popover_mechanism}}::tooltip}}어디든 누르면 닫힙니다
{{/each}}
{{#each::keep {{dictelement::{{slot::run_reward_card}}::terms}} as run_popover_term}}
RULE TERM{{dictelement::{{slot::run_popover_term}}::label}}{{dictelement::{{slot::run_popover_term}}::tooltip}}어디든 누르면 닫힙니다
{{#each::keep {{dictelement::{{slot::run_reward_card}}::roles}} as run_popover_role}}
ROLE{{dictelement::{{slot::run_popover_role}}::label}}{{dictelement::{{slot::run_popover_role}}::tooltip}}어디든 누르면 닫힙니다
{{#each::keep {{dictelement::{{tempvar::current_deck}}::items}} as current_deck_card}}
{{settempvar::current_deck_card_type::{{dictelement::{{slot::current_deck_card}}::cardType}}}}
{{#when::keep::{{dictelement::{{slot::current_deck_card}}::draftStyle}}::is::predator}}[image]{{/when}}
{{#when::keep::{{dictelement::{{slot::current_deck_card}}::draftStyle}}::is::harmonizer}}[image]{{/when}}
{{#when::keep::{{dictelement::{{slot::current_deck_card}}::draftStyle}}::is::glutton}}[image]{{/when}}
{{#when::keep::{{dictelement::{{slot::current_deck_card}}::draftStyle}}::is::deceiver}}[image]{{/when}}
×{{dictelement::{{slot::current_deck_card}}::ownedCopies}}{{dictelement::{{slot::current_deck_card}}::name}}{{dictelement::{{tempvar::current_deck_card_type}}::label}}
{{#each::keep {{dictelement::{{slot::current_deck_card}}::roles}} as current_deck_role}}{{dictelement::{{slot::current_deck_role}}::label}}{{/each}}
{{#each::keep {{dictelement::{{slot::current_deck_card}}::mechanisms}} as current_deck_mechanism}}{{dictelement::{{slot::current_deck_mechanism}}::label}}{{/each}}
{{dictelement::{{slot::current_deck_card}}::baseStealthCost}}비용{{dictelement::{{slot::current_deck_card}}::baseResistanceDamage}}피해상세 정보 ⌄
{{#each::keep {{dictelement::{{slot::current_deck_card}}::descriptionSegments}} as current_deck_description_segment}}{{#when::keep::{{dictelement::{{slot::current_deck_description_segment}}::kind}}::is::text}}{{dictelement::{{slot::current_deck_description_segment}}::value}}{{/when}}{{#when::keep::{{dictelement::{{slot::current_deck_description_segment}}::kind}}::isnot::text}}{{dictelement::{{slot::current_deck_description_segment}}::label}}{{/when}}{{/each}}
{{#each::keep {{dictelement::{{slot::current_deck_card}}::ruleLines}} as current_deck_rule}}
{{#each::keep {{dictelement::{{slot::current_deck_rule}}::segments}} as current_deck_segment}}{{#when::keep::{{dictelement::{{slot::current_deck_segment}}::kind}}::is::text}}{{dictelement::{{slot::current_deck_segment}}::value}}{{/when}}{{#when::keep::{{dictelement::{{slot::current_deck_segment}}::kind}}::isnot::text}}{{dictelement::{{slot::current_deck_segment}}::label}}{{/when}}{{/each}}
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local MAX_SAFE_INTEGER = 9007199254740991
local MAX_PLAN_CAPACITY = 16
local DEFAULT_PLAYER_PLAN_CAPACITY = 1
local PLAYER_CARD_IDS = {
"pc_predator_001",
"pc_predator_002",
"pc_predator_007",
"pc_harmonizer_001",
"pc_glutton_001",
"pc_deceiver_001",
}
local CHARACTER_ID = "yoo_jiyoung"
local CHARACTER_CARD_IDS = {
"jiyoung_close_collar",
"jiyoung_quiet_warning",
"jiyoung_turn_to_corner",
"jiyoung_silent_glare",
"jiyoung_timid_call_for_help",
"jiyoung_hug_bag_close",
"jiyoung_half_step_back",
"jiyoung_avoid_eye_contact",
"jiyoung_find_courage",
"jiyoung_phone_in_hand",
}
local function makeError(code, path, message)
return {
code = code,
path = path,
message = message,
}
end
local function failure(errors)
return {
ok = false,
schemaVersion = SCHEMA_VERSION,
errors = errors,
}
end
local function success(state)
return {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
referencesValidated = true,
state = state,
}
end
local function setupSuccess(state)
return {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
referencesValidated = true,
initialDecksShuffled = true,
state = state,
}
end
local function isFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function isSafeInteger(value, minimum)
return isFinite(value)
and value % 1 == 0
and math.abs(value) <= MAX_SAFE_INTEGER
and (minimum == nil or value >= minimum)
end
local function isPlanCapacity(value)
return isSafeInteger(value, 1) and value <= MAX_PLAN_CAPACITY
end
local function isRuntimeId(value)
return type(value) == "string"
and string.match(value, "^[A-Za-z0-9][A-Za-z0-9_-]*$") ~= nil
end
local function isAsciiId(value)
return type(value) == "string"
and string.match(value, "^[a-z][a-z0-9_]*$") ~= nil
end
local function getArrayLength(value)
if type(value) ~= "table" or getmetatable(value) ~= nil then
return nil
end
local count = 0
local maximum = 0
for key in pairs(value) do
if type(key) ~= "number" or key % 1 ~= 0 or key < 1 then
return nil
end
count = count + 1
maximum = math.max(maximum, key)
end
if count ~= maximum then
return nil
end
return maximum
end
local function copyArray(value)
local copy = {}
for index = 1, #value do
copy[index] = value[index]
end
return copy
end
local function effectiveCharacterPlanCapacity(characterId, battle, staticData)
local capacityPath = "$.staticData.characters." .. characterId .. ".battle.planCapacity"
if not isPlanCapacity(type(battle) == "table" and battle.planCapacity or nil) then
return nil, makeError(
"invalid_plan_capacity",
capacityPath,
"캐릭터 기본 계획 용량은 1 이상 16 이하의 정수여야 합니다."
)
end
if getArrayLength(battle.traitIds) == nil then
return nil, makeError(
"invalid_character_traits",
"$.staticData.characters." .. characterId .. ".battle.traitIds",
"캐릭터 특징 ID 목록이 연속 배열이 아닙니다."
)
end
local traits = type(staticData) == "table" and staticData.traits or nil
if type(traits) ~= "table" or getmetatable(traits) ~= nil then
return nil, makeError(
"invalid_static_traits",
"$.staticData.traits",
"계획 용량 특징 보정을 계산할 전체 특징 컬렉션이 필요합니다."
)
end
local capacity = battle.planCapacity
for traitIndex, traitId in ipairs(battle.traitIds) do
local trait = traits[traitId]
if type(trait) ~= "table" then
return nil, makeError(
"unknown_character_trait",
"$.staticData.characters." .. characterId .. ".battle.traitIds[" .. traitIndex .. "]",
"계획 용량을 계산할 캐릭터 특징을 찾을 수 없습니다."
)
end
if trait.modifiers ~= nil then
local modifierCount = getArrayLength(trait.modifiers)
if modifierCount == nil then
return nil, makeError(
"invalid_trait_modifiers",
"$.staticData.traits." .. tostring(traitId) .. ".modifiers",
"특징 보정은 연속 배열이어야 합니다."
)
end
for modifierIndex = 1, modifierCount do
local modifier = trait.modifiers[modifierIndex]
local modifierPath = "$.staticData.traits." .. tostring(traitId)
.. ".modifiers[" .. modifierIndex .. "]"
if type(modifier) ~= "table" or getmetatable(modifier) ~= nil then
return nil, makeError(
"invalid_trait_plan_capacity_modifier",
modifierPath,
"계획 용량 특징 보정은 메타테이블 없는 객체여야 합니다."
)
end
for field in pairs(modifier) do
if field ~= "stat" and field ~= "operation" and field ~= "amount" then
return nil, makeError(
"unknown_trait_modifier_field",
modifierPath .. "." .. tostring(field),
"계획 용량 특징 보정에 허용되지 않은 필드가 있습니다."
)
end
end
if modifier.stat ~= "planCapacity"
or modifier.operation ~= "add"
or not isSafeInteger(modifier.amount) then
return nil, makeError(
"invalid_trait_plan_capacity_modifier",
modifierPath,
"계획 용량 특징 보정은 planCapacity/add/정수 amount 형식이어야 합니다."
)
end
capacity = capacity + modifier.amount
if not isSafeInteger(capacity) then
return nil, makeError(
"invalid_effective_plan_capacity",
capacityPath,
"계획 용량 특징 보정 합계가 안전한 정수 범위를 벗어났습니다."
)
end
end
end
end
if not isPlanCapacity(capacity) then
return nil, makeError(
"invalid_effective_plan_capacity",
capacityPath,
"캐릭터 기본 계획 용량과 특징 보정의 합은 1 이상 16 이하여야 합니다."
)
end
return capacity, nil
end
local function copyErrors(report)
local errors = {}
if type(report) ~= "table" or type(report.errors) ~= "table" then
return errors
end
for _, item in ipairs(report.errors) do
if type(item) == "table" then
errors[#errors + 1] = makeError(
type(item.code) == "string" and item.code or "nested_error",
type(item.path) == "string" and item.path or "$",
type(item.message) == "string" and item.message or "하위 상태 생성 작업이 실패했습니다."
)
end
end
return errors
end
local function validateSpec(spec)
local errors = {}
if type(spec) ~= "table" or getmetatable(spec) ~= nil then
return nil, {
makeError("invalid_spec", "$", "verticalSlice 생성 사양은 메타테이블 없는 객체여야 합니다."),
}
end
local allowed = {
battleId = true,
seed = true,
}
for key in pairs(spec) do
if type(key) ~= "string" or not allowed[key] then
errors[#errors + 1] = makeError(
"unknown_spec_field",
"$." .. tostring(key),
"verticalSlice 생성 사양에 알 수 없는 필드가 있습니다."
)
end
end
if not isRuntimeId(spec.battleId) then
errors[#errors + 1] = makeError(
"invalid_battle_id",
"$.battleId",
"명시적인 runtime battleId가 필요합니다."
)
end
if not isSafeInteger(spec.seed, 0) then
errors[#errors + 1] = makeError(
"invalid_rng_seed",
"$.seed",
"명시적인 비음수 안전 정수 RNG 시드가 필요합니다."
)
end
if #errors > 0 then
return nil, errors
end
return {
battleId = spec.battleId,
seed = spec.seed,
}, nil
end
local function validateSetupSpec(spec)
local errors = {}
if type(spec) ~= "table" or getmetatable(spec) ~= nil then
return nil, {
makeError("invalid_spec", "$", "fromSetup 생성 사양은 메타테이블 없는 객체여야 합니다."),
}
end
local allowed = {
battleId = true,
seed = true,
playerCardIds = true,
characterId = true,
}
for key in pairs(spec) do
if type(key) ~= "string" or not allowed[key] then
errors[#errors + 1] = makeError(
"unknown_spec_field",
"$." .. tostring(key),
"fromSetup 생성 사양에 알 수 없는 필드가 있습니다."
)
end
end
if not isRuntimeId(spec.battleId) then
errors[#errors + 1] = makeError(
"invalid_battle_id",
"$.battleId",
"명시적인 runtime battleId가 필요합니다."
)
end
if not isSafeInteger(spec.seed, 0) then
errors[#errors + 1] = makeError(
"invalid_rng_seed",
"$.seed",
"전투 전용 비음수 안전 정수 RNG 시드가 필요합니다."
)
end
local playerDeckLength = getArrayLength(spec.playerCardIds)
if playerDeckLength == nil
or playerDeckLength < 10
or playerDeckLength > 20 then
errors[#errors + 1] = makeError(
"invalid_player_deck",
"$.playerCardIds",
"플레이어 덱은 10장 이상 20장 이하의 연속 배열이어야 합니다."
)
else
local counts = {}
for index, cardId in ipairs(spec.playerCardIds) do
if not isAsciiId(cardId) then
errors[#errors + 1] = makeError(
"invalid_player_card_id",
"$.playerCardIds[" .. index .. "]",
"플레이어 카드 ID는 lower_snake_case ASCII ID여야 합니다."
)
else
counts[cardId] = (counts[cardId] or 0) + 1
if counts[cardId] > 2 then
errors[#errors + 1] = makeError(
"player_card_copy_limit_exceeded",
"$.playerCardIds[" .. index .. "]",
"플레이어 덱에는 같은 카드를 2장까지만 넣을 수 있습니다."
)
end
end
end
end
if not isAsciiId(spec.characterId) then
errors[#errors + 1] = makeError(
"invalid_character_id",
"$.characterId",
"캐릭터 ID는 lower_snake_case ASCII ID여야 합니다."
)
end
if #errors > 0 then
return nil, errors
end
return {
battleId = spec.battleId,
seed = spec.seed,
playerCardIds = copyArray(spec.playerCardIds),
characterId = spec.characterId,
}, nil
end
local function getCharacterDefinition(staticData)
if type(staticData) ~= "table" or getmetatable(staticData) ~= nil then
return nil, makeError(
"invalid_static_data",
"$.staticData",
"전체 정적 데이터 객체가 필요합니다."
)
end
local characters = staticData.characters
local character = type(characters) == "table" and characters[CHARACTER_ID] or nil
local battle = type(character) == "table" and character.battle or nil
if type(battle) ~= "table" then
return nil, makeError(
"missing_character_definition",
"$.staticData.characters." .. CHARACTER_ID,
"verticalSlice 캐릭터 전투 정의를 찾을 수 없습니다."
)
end
local deckLength = getArrayLength(battle.deck)
if deckLength ~= #CHARACTER_CARD_IDS then
return nil, makeError(
"vertical_slice_character_deck_mismatch",
"$.staticData.characters." .. CHARACTER_ID .. ".battle.deck",
"verticalSlice 캐릭터 덱 구성이 고정 사양과 다릅니다."
)
end
for index, cardId in ipairs(CHARACTER_CARD_IDS) do
if battle.deck[index] ~= cardId then
return nil, makeError(
"vertical_slice_character_deck_mismatch",
"$.staticData.characters." .. CHARACTER_ID .. ".battle.deck[" .. index .. "]",
"verticalSlice 캐릭터 덱 순서가 고정 사양과 다릅니다."
)
end
end
if getArrayLength(battle.traitIds) == nil then
return nil, makeError(
"invalid_character_traits",
"$.staticData.characters." .. CHARACTER_ID .. ".battle.traitIds",
"캐릭터 특징 ID 목록이 연속 배열이 아닙니다."
)
end
return character, nil
end
local function makeInstances(cardIds, owner)
local instances = {}
for index, cardId in ipairs(cardIds) do
instances[index] = {
instanceId = string.format("%s-%03d", owner, index),
cardId = cardId,
owner = owner,
zone = "deck",
position = index,
}
end
return instances
end
local function getSetupDefinitions(spec, staticData)
local errors = {}
if type(staticData) ~= "table" or getmetatable(staticData) ~= nil then
return nil, nil, errors, makeError(
"invalid_static_data",
"$.staticData",
"전체 정적 데이터 객체가 필요합니다."
)
end
local cards = staticData.cards
if type(cards) ~= "table" or getmetatable(cards) ~= nil then
return nil, nil, errors, makeError(
"invalid_static_cards",
"$.staticData.cards",
"정적 카드 컬렉션이 필요합니다."
)
end
for index, cardId in ipairs(spec.playerCardIds) do
local card = cards[cardId]
if type(card) ~= "table" then
errors[#errors + 1] = makeError(
"unknown_player_card",
"$.playerCardIds[" .. index .. "]",
"정적 DB에서 플레이어 카드를 찾을 수 없습니다."
)
elseif card.owner ~= "player" then
errors[#errors + 1] = makeError(
"player_card_owner_mismatch",
"$.playerCardIds[" .. index .. "]",
"선택한 카드의 정적 소유자가 player가 아닙니다."
)
end
end
local characters = staticData.characters
local character = type(characters) == "table" and characters[spec.characterId] or nil
local battle = type(character) == "table" and character.battle or nil
if type(battle) ~= "table" or getmetatable(battle) ~= nil then
return nil, nil, errors, makeError(
"missing_character_definition",
"$.staticData.characters." .. spec.characterId,
"선택한 캐릭터의 전투 정의를 찾을 수 없습니다."
)
end
local characterDeckLength = getArrayLength(battle.deck)
if characterDeckLength == nil then
errors[#errors + 1] = makeError(
"invalid_character_deck",
"$.staticData.characters." .. spec.characterId .. ".battle.deck",
"캐릭터 덱은 연속 배열이어야 합니다."
)
else
for index, cardId in ipairs(battle.deck) do
local path = "$.staticData.characters." .. spec.characterId .. ".battle.deck[" .. index .. "]"
if not isAsciiId(cardId) then
errors[#errors + 1] = makeError(
"invalid_character_card_id",
path,
"캐릭터 카드 ID는 lower_snake_case ASCII ID여야 합니다."
)
else
local card = cards[cardId]
if type(card) ~= "table" then
errors[#errors + 1] = makeError(
"unknown_character_card",
path,
"정적 DB에서 캐릭터 카드를 찾을 수 없습니다."
)
elseif card.owner ~= "character" then
errors[#errors + 1] = makeError(
"character_card_owner_mismatch",
path,
"캐릭터 덱 카드의 정적 소유자가 character가 아닙니다."
)
end
end
end
end
if getArrayLength(battle.traitIds) == nil then
errors[#errors + 1] = makeError(
"invalid_character_traits",
"$.staticData.characters." .. spec.characterId .. ".battle.traitIds",
"캐릭터 특징 ID 목록이 연속 배열이 아닙니다."
)
end
return character, battle, errors, nil
end
local function buildJourney(seed, staticData, turnLimit)
if type(runScript) ~= "function" then
return nil, {
makeError(
"runtime_unavailable",
"$.runtime.subwayJourney",
"전투 여정을 생성할 실행기를 찾을 수 없습니다."
),
}
end
local ok, report = pcall(
runScript,
triggerId,
"subwayJourney",
"build",
seed,
staticData,
turnLimit
)
if not ok then
return nil, {
makeError(
"subway_journey_call_failed",
"$.runtime.subwayJourney",
"전투 여정 생성 호출에 실패했습니다: " .. tostring(report)
),
}
end
if type(report) ~= "table" or report.ok ~= true
or not isSafeInteger(report.turnLimit, 1)
or report.turnLimit ~= turnLimit
or type(report.transit) ~= "table"
or type(report.sceneContext) ~= "table" then
local nestedErrors = copyErrors(report)
if #nestedErrors == 0 then
nestedErrors[1] = makeError(
"invalid_subway_journey_result",
"$.runtime.subwayJourney",
"전투 여정 생성기가 제한 턴과 이동 구간을 반환하지 않았습니다."
)
end
return nil, nestedErrors
end
return {
turnLimit = report.turnLimit,
transit = report.transit,
sceneContext = report.sceneContext,
}, nil
end
local function verticalSlice(spec, staticData)
local normalized, specErrors = validateSpec(spec)
if specErrors then
return failure(specErrors)
end
local characterDefinition, characterError = getCharacterDefinition(staticData)
if characterError then
return failure({ characterError })
end
local characterBattle = characterDefinition.battle
local characterPlanCapacity, planCapacityError = effectiveCharacterPlanCapacity(
CHARACTER_ID,
characterBattle,
staticData
)
if planCapacityError then
return failure({ planCapacityError })
end
local journey, journeyErrors = buildJourney(normalized.seed, staticData, characterBattle.turnLimit)
if journeyErrors then
return failure(journeyErrors)
end
local cardInstances = makeInstances(PLAYER_CARD_IDS, "player")
local characterInstances = makeInstances(CHARACTER_CARD_IDS, "character")
for _, instance in ipairs(characterInstances) do
cardInstances[#cardInstances + 1] = instance
end
local stateSpec = {
battleId = normalized.battleId,
status = "active",
turnNumber = 1,
turnLimit = journey.turnLimit,
transit = journey.transit,
sceneContext = journey.sceneContext,
rng = {
seed = normalized.seed,
cursor = 0,
},
player = {
stealth = 30,
baseDrawCount = 3,
maxHandSize = 5,
perkIds = {},
planCapacity = DEFAULT_PLAYER_PLAN_CAPACITY,
planSlots = {},
},
character = {
characterId = CHARACTER_ID,
resistance = characterBattle.startingResistance,
mood = characterBattle.startingMood,
traitIds = copyArray(characterBattle.traitIds),
baseDrawCount = characterBattle.baseDrawCount,
maxHandSize = characterBattle.maxHandSize,
planCapacity = characterPlanCapacity,
planSlots = {},
},
cardInstances = cardInstances,
selection = {
playerCardInstanceIds = {},
},
characterIntent = {
cardInstanceIds = {},
},
}
if type(runScript) ~= "function" then
return failure({
makeError(
"runtime_unavailable",
"$.runtime.stateSchema",
"stateSchema 실행기를 찾을 수 없습니다."
),
})
end
local ok, report = pcall(
runScript,
triggerId,
"stateSchema",
"newBattleState",
stateSpec,
staticData
)
if not ok then
return failure({
makeError(
"state_schema_call_error",
"$.runtime.stateSchema",
"stateSchema.newBattleState 호출 중 오류가 발생했습니다."
),
})
end
if type(report) ~= "table" then
return failure({
makeError(
"invalid_state_schema_result",
"$.runtime.stateSchema",
"stateSchema.newBattleState가 테이블 결과를 반환하지 않았습니다."
),
})
end
if report.ok ~= true then
local nestedErrors = copyErrors(report)
if #nestedErrors == 0 then
nestedErrors[1] = makeError(
"state_construction_failed",
"$",
"stateSchema.newBattleState가 오류 상세 없이 실패했습니다."
)
end
return failure(nestedErrors)
end
if report.referencesValidated ~= true then
return failure({
makeError(
"static_references_not_validated",
"$.staticData",
"verticalSlice battleState는 전체 정적 참조 검증이 필요합니다."
),
})
end
if type(report.value) ~= "table" then
return failure({
makeError(
"missing_battle_state",
"$.state",
"stateSchema.newBattleState 성공 결과에 battleState가 없습니다."
),
})
end
return success(report.value)
end
local function fromSetup(spec, staticData)
local normalized, specErrors = validateSetupSpec(spec)
if specErrors then
return failure(specErrors)
end
local characterDefinition, characterBattle, definitionErrors, definitionFatal =
getSetupDefinitions(normalized, staticData)
if definitionFatal then
definitionErrors[#definitionErrors + 1] = definitionFatal
end
if #definitionErrors > 0 then
return failure(definitionErrors)
end
local characterPlanCapacity, planCapacityError = effectiveCharacterPlanCapacity(
normalized.characterId,
characterBattle,
staticData
)
if planCapacityError then
return failure({ planCapacityError })
end
local journey, journeyErrors = buildJourney(normalized.seed, staticData, characterBattle.turnLimit)
if journeyErrors then
return failure(journeyErrors)
end
local cardInstances = makeInstances(normalized.playerCardIds, "player")
local characterInstances = makeInstances(characterBattle.deck, "character")
for _, instance in ipairs(characterInstances) do
cardInstances[#cardInstances + 1] = instance
end
local stateSpec = {
battleId = normalized.battleId,
status = "active",
turnNumber = 1,
turnLimit = journey.turnLimit,
transit = journey.transit,
sceneContext = journey.sceneContext,
rng = {
seed = normalized.seed,
cursor = 0,
},
player = {
stealth = 30,
baseDrawCount = 3,
maxHandSize = 5,
perkIds = {},
planCapacity = DEFAULT_PLAYER_PLAN_CAPACITY,
planSlots = {},
},
character = {
characterId = normalized.characterId,
resistance = characterBattle.startingResistance,
mood = characterBattle.startingMood,
traitIds = copyArray(characterBattle.traitIds),
baseDrawCount = characterBattle.baseDrawCount,
maxHandSize = characterBattle.maxHandSize,
planCapacity = characterPlanCapacity,
planSlots = {},
},
cardInstances = cardInstances,
selection = {
playerCardInstanceIds = {},
},
characterIntent = {
cardInstanceIds = {},
},
}
if type(runScript) ~= "function" then
return failure({
makeError(
"runtime_unavailable",
"$.runtime.stateSchema",
"전투 초기 상태 생성에 필요한 실행기를 찾을 수 없습니다."
),
})
end
local constructOk, constructReport = pcall(
runScript,
triggerId,
"stateSchema",
"newBattleState",
stateSpec,
staticData
)
if not constructOk then
return failure({
makeError(
"state_schema_call_error",
"$.runtime.stateSchema",
"stateSchema.newBattleState 호출 중 오류가 발생했습니다."
),
})
end
if type(constructReport) ~= "table" then
return failure({
makeError(
"invalid_state_schema_result",
"$.runtime.stateSchema",
"stateSchema.newBattleState가 테이블 결과를 반환하지 않았습니다."
),
})
end
if constructReport.ok ~= true then
local nestedErrors = copyErrors(constructReport)
if #nestedErrors == 0 then
nestedErrors[1] = makeError(
"state_construction_failed",
"$",
"stateSchema.newBattleState가 오류 상세 없이 실패했습니다."
)
end
return failure(nestedErrors)
end
if constructReport.referencesValidated ~= true then
return failure({
makeError(
"static_references_not_validated",
"$.staticData",
"fromSetup battleState는 전체 정적 참조 검증이 필요합니다."
),
})
end
if type(constructReport.value) ~= "table" then
return failure({
makeError(
"missing_battle_state",
"$.state",
"stateSchema.newBattleState 성공 결과에 battleState가 없습니다."
),
})
end
local playerShuffleOk, playerShuffleReport = pcall(
runScript,
triggerId,
"cardZones",
"shuffleDeck",
constructReport.value,
"player"
)
if not playerShuffleOk then
return failure({
makeError(
"player_shuffle_call_error",
"$.runtime.cardZones",
"플레이어 초기 덱 셔플 호출 중 오류가 발생했습니다."
),
})
end
if type(playerShuffleReport) ~= "table" then
return failure({
makeError(
"invalid_player_shuffle_result",
"$.runtime.cardZones",
"플레이어 초기 덱 셔플이 테이블 결과를 반환하지 않았습니다."
),
})
end
if playerShuffleReport.ok ~= true then
local nestedErrors = copyErrors(playerShuffleReport)
if #nestedErrors == 0 then
nestedErrors[1] = makeError(
"player_shuffle_failed",
"$.state.player",
"플레이어 초기 덱 셔플이 오류 상세 없이 실패했습니다."
)
end
return failure(nestedErrors)
end
if type(playerShuffleReport.state) ~= "table" then
return failure({
makeError(
"missing_player_shuffle_state",
"$.state",
"플레이어 초기 덱 셔플 성공 결과에 battleState가 없습니다."
),
})
end
local characterShuffleOk, characterShuffleReport = pcall(
runScript,
triggerId,
"cardZones",
"shuffleDeck",
playerShuffleReport.state,
"character"
)
if not characterShuffleOk then
return failure({
makeError(
"character_shuffle_call_error",
"$.runtime.cardZones",
"캐릭터 초기 덱 셔플 호출 중 오류가 발생했습니다."
),
})
end
if type(characterShuffleReport) ~= "table" then
return failure({
makeError(
"invalid_character_shuffle_result",
"$.runtime.cardZones",
"캐릭터 초기 덱 셔플이 테이블 결과를 반환하지 않았습니다."
),
})
end
if characterShuffleReport.ok ~= true then
local nestedErrors = copyErrors(characterShuffleReport)
if #nestedErrors == 0 then
nestedErrors[1] = makeError(
"character_shuffle_failed",
"$.state.character",
"캐릭터 초기 덱 셔플이 오류 상세 없이 실패했습니다."
)
end
return failure(nestedErrors)
end
if type(characterShuffleReport.state) ~= "table" then
return failure({
makeError(
"missing_character_shuffle_state",
"$.state",
"캐릭터 초기 덱 셔플 성공 결과에 battleState가 없습니다."
),
})
end
local validateOk, validateReport = pcall(
runScript,
triggerId,
"stateSchema",
"validateBattleState",
characterShuffleReport.state,
staticData
)
if not validateOk then
return failure({
makeError(
"state_validation_call_error",
"$.runtime.stateSchema",
"셔플된 battleState 최종 검증 호출 중 오류가 발생했습니다."
),
})
end
if type(validateReport) ~= "table" then
return failure({
makeError(
"invalid_state_validation_result",
"$.runtime.stateSchema",
"stateSchema.validateBattleState가 테이블 결과를 반환하지 않았습니다."
),
})
end
if validateReport.ok ~= true then
local nestedErrors = copyErrors(validateReport)
if #nestedErrors == 0 then
nestedErrors[1] = makeError(
"state_validation_failed",
"$.state",
"셔플된 battleState 최종 검증이 오류 상세 없이 실패했습니다."
)
end
return failure(nestedErrors)
end
if validateReport.referencesValidated ~= true then
return failure({
makeError(
"static_references_not_validated",
"$.staticData",
"셔플된 fromSetup battleState는 전체 정적 참조 검증이 필요합니다."
),
})
end
return setupSuccess(characterShuffleReport.state)
end
local arguments = { ... }
if action == "verticalSlice" then
return verticalSlice(arguments[1], arguments[2])
elseif action == "fromSetup" then
return fromSetup(arguments[1], arguments[2])
end
return failure({
makeError(
"unknown_action",
"$.action",
"지원하지 않는 battleBootstrap 작업입니다: " .. tostring(action)
),
})
end)
#29battleController.lua
Keys:
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local ACTIVE_REQUEST_SCHEMA_VERSION = 3
local AFTERMATH_SCHEMA_VERSION = 2
local VIEW_NAME = "battleView"
local INTERACTION_VIEW_NAME = "battleInteractionView"
local BATTLE_LOG_VIEW_NAME = "battleLogView"
local UI_BODY_NAME = "🔯🔯🔯"
local UI_INTERACTION_NAME = "helltrainBattleInteractionV1"
local UI_INTERACTION_MARKER = ""
local TURN_SUBMIT_MARKER = "@@HELLTRAIN_TURN_SUBMIT_V1@@"
local SAY_NOTHING = "says nothing"
local CHAT_FINGERPRINT_ALGORITHM = "canonical_poly131_137_chat_v1"
local KEYS = {
authority = "battleRuntimeV1.authority",
draft = "battleRuntimeV1.draft",
pending = "battleRuntimeV1.pending",
lastCommittedPending = "battleRuntimeV1.lastCommittedPending",
activeRequest = "battleRuntimeV1.activeRequest",
submission = "battleRuntimeV1.submission",
aftermath = "battleRuntimeV1.aftermath",
}
local function permitCanonicalBattleView(purpose, viewName)
return purpose == "dataBridgeCanonicalV1"
and (viewName == VIEW_NAME
or viewName == INTERACTION_VIEW_NAME
or viewName == BATTLE_LOG_VIEW_NAME)
end
local function allowsCanonicalHandoff(capability, purpose)
if type(capability) ~= "function" then return false end
local ok, allowed = pcall(capability, purpose)
return ok and allowed == true
end
local function makeError(code, path, message)
return {
code = code,
path = path,
message = message,
}
end
local function failure(errors)
return {
ok = false,
schemaVersion = SCHEMA_VERSION,
errors = errors,
}
end
local function success(fields)
local report = {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
}
for key, value in pairs(fields or {}) do
report[key] = value
end
return report
end
local function isFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function isInteger(value, minimum)
return isFinite(value)
and value % 1 == 0
and (minimum == nil or value >= minimum)
end
local function isRuntimeId(value)
return type(value) == "string"
and string.match(value, "^[A-Za-z0-9][A-Za-z0-9_-]*$") ~= nil
end
local function objectPath(path, key)
if string.match(key, "^[A-Za-z_][A-Za-z0-9_]*$") then
return path .. "." .. key
end
return path .. "[" .. string.format("%q", key) .. "]"
end
local function cloneJson(value, path, active)
local valueType = type(value)
if valueType == "nil" or valueType == "string" or valueType == "boolean" then
return value, nil
end
if valueType == "number" then
if not isFinite(value) then
return nil, makeError("non_finite_number", path, "유한하지 않은 숫자는 컨트롤러 데이터에 사용할 수 없습니다.")
end
return value, nil
end
if valueType ~= "table" then
return nil, makeError(
"unsupported_type",
path,
"JSON 컨트롤러 데이터에 사용할 수 없는 자료형입니다: " .. valueType
)
end
if getmetatable(value) ~= nil then
return nil, makeError("metatable_not_allowed", path, "컨트롤러 데이터에는 메타테이블을 사용할 수 없습니다.")
end
active = active or {}
if active[value] then
return nil, makeError("circular_reference", path, "순환 참조는 컨트롤러 데이터에 사용할 수 없습니다.")
end
active[value] = true
local hasNumeric = false
local hasString = false
local numericCount = 0
local maximum = 0
for key in pairs(value) do
if type(key) == "number" then
hasNumeric = true
if not isInteger(key, 1) then
active[value] = nil
return nil, makeError("invalid_array_index", path, "배열 인덱스는 1 이상의 정수여야 합니다.")
end
numericCount = numericCount + 1
maximum = math.max(maximum, key)
elseif type(key) == "string" then
hasString = true
else
active[value] = nil
return nil, makeError("invalid_object_key", path, "객체 키는 문자열이어야 합니다.")
end
end
if hasNumeric and hasString then
active[value] = nil
return nil, makeError("mixed_table", path, "숫자 인덱스와 문자열 키를 함께 사용할 수 없습니다.")
end
if hasNumeric and numericCount ~= maximum then
active[value] = nil
return nil, makeError("sparse_array", path, "배열 인덱스는 1부터 빈틈없이 이어져야 합니다.")
end
local copy = {}
if hasNumeric then
for index = 1, maximum do
local itemCopy, itemError = cloneJson(value[index], path .. "[" .. index .. "]", active)
if itemError then
active[value] = nil
return nil, itemError
end
copy[index] = itemCopy
end
else
for key, item in pairs(value) do
local itemCopy, itemError = cloneJson(item, objectPath(path, key), active)
if itemError then
active[value] = nil
return nil, itemError
end
copy[key] = itemCopy
end
end
active[value] = nil
return copy, nil
end
local function deepEqual(left, right, active)
if type(left) ~= type(right) then
return false
end
if type(left) ~= "table" then
return left == right
end
if getmetatable(left) ~= nil or getmetatable(right) ~= nil then
return false
end
active = active or {}
local seen = active[left]
if seen ~= nil then
return seen == right
end
active[left] = right
for key, value in pairs(left) do
if not deepEqual(value, right[key], active) then
active[left] = nil
return false
end
end
for key in pairs(right) do
if left[key] == nil then
active[left] = nil
return false
end
end
active[left] = nil
return true
end
local function canonicalFailure(code, path, message)
error(makeError(code, path, message), 0)
end
local function inspectCanonicalTable(value, path)
if type(value) ~= "table" or getmetatable(value) ~= nil then
canonicalFailure("invalid_fingerprint_table", path, "fingerprint 대상은 일반 테이블이어야 합니다.")
end
local numericCount = 0
local maximum = 0
local hasNumeric = false
local hasString = false
local stringKeys = {}
for key in pairs(value) do
if type(key) == "number" then
hasNumeric = true
numericCount = numericCount + 1
if not isInteger(key, 1) then
canonicalFailure("invalid_fingerprint_array_index", path, "fingerprint 배열 인덱스는 1 이상의 정수여야 합니다.")
end
maximum = math.max(maximum, key)
elseif type(key) == "string" then
hasString = true
stringKeys[#stringKeys + 1] = key
else
canonicalFailure("invalid_fingerprint_object_key", path, "fingerprint 객체 키는 문자열이어야 합니다.")
end
end
if hasNumeric and hasString then
canonicalFailure("mixed_fingerprint_table", path, "fingerprint에는 숫자 인덱스와 문자열 키를 함께 사용할 수 없습니다.")
end
if hasNumeric and numericCount ~= maximum then
canonicalFailure("sparse_fingerprint_array", path, "fingerprint 배열 인덱스는 1부터 빈틈없이 이어져야 합니다.")
end
table.sort(stringKeys)
return hasNumeric, maximum, stringKeys
end
local function canonicalJson(value, path, active)
local valueType = type(value)
if valueType == "nil" then return "n" end
if valueType == "boolean" then return value and "t" or "f" end
if valueType == "number" then
if not isFinite(value) then
canonicalFailure("non_finite_fingerprint_number", path, "유한하지 않은 숫자는 fingerprint에 사용할 수 없습니다.")
end
return "d" .. string.format("%.17g", value) .. ";"
end
if valueType == "string" then
return "s" .. tostring(#value) .. ":" .. value
end
if valueType ~= "table" then
canonicalFailure("unsupported_fingerprint_type", path, "fingerprint에 사용할 수 없는 자료형입니다: " .. valueType)
end
active = active or {}
if active[value] then
canonicalFailure("circular_fingerprint_value", path, "순환 참조는 fingerprint에 사용할 수 없습니다.")
end
active[value] = true
local isArray, length, stringKeys = inspectCanonicalTable(value, path)
local parts = {}
if isArray then
parts[1] = "["
for index = 1, length do
parts[#parts + 1] = canonicalJson(value[index], path .. "[" .. index .. "]", active)
end
parts[#parts + 1] = "]"
else
parts[1] = "{"
for _, key in ipairs(stringKeys) do
parts[#parts + 1] = "k" .. tostring(#key) .. ":" .. key
parts[#parts + 1] = canonicalJson(value[key], objectPath(path, key), active)
end
parts[#parts + 1] = "}"
end
active[value] = nil
return table.concat(parts)
end
local function fingerprintChatRange(chat, firstIndex, count, path)
if type(chat) ~= "table" or not isInteger(firstIndex, 1) or not isInteger(count, 0) then
return nil, makeError("invalid_chat_fingerprint_range", path, "채팅 fingerprint 범위가 올바르지 않습니다.")
end
if count > 0 and firstIndex + count - 1 > #chat then
return nil, makeError("chat_fingerprint_range_out_of_bounds", path, "채팅 fingerprint 범위가 대화 길이를 벗어났습니다.")
end
local ok, canonical = pcall(function()
local parts = { "[" }
for offset = 0, count - 1 do
parts[#parts + 1] = canonicalJson(chat[firstIndex + offset], path .. "[" .. offset .. "]", {})
end
parts[#parts + 1] = "]"
return table.concat(parts)
end)
if not ok then
if type(canonical) == "table" and canonical.code and canonical.path and canonical.message then
return nil, canonical
end
return nil, makeError("chat_fingerprint_failed", path, "채팅 fingerprint 생성에 실패했습니다: " .. tostring(canonical))
end
local hashA = 0
local hashB = 0
for index = 1, #canonical do
local byte = string.byte(canonical, index)
hashA = (hashA * 131 + byte) % 2147483647
hashB = (hashB * 137 + byte) % 2147483629
end
return {
algorithm = CHAT_FINGERPRINT_ALGORITHM,
length = #canonical,
hashA = hashA,
hashB = hashB,
}, nil
end
local function fingerprintsEqual(left, right)
return type(left) == "table"
and type(right) == "table"
and left.algorithm == right.algorithm
and left.length == right.length
and left.hashA == right.hashA
and left.hashB == right.hashB
end
local function validateFingerprint(value, path, errors)
if type(value) ~= "table" or getmetatable(value) ~= nil then
errors[#errors + 1] = makeError("invalid_chat_fingerprint", path, "채팅 fingerprint가 일반 객체가 아닙니다.")
return false
end
local allowed = { algorithm = true, length = true, hashA = true, hashB = true }
for key in pairs(value) do
if type(key) ~= "string" or not allowed[key] then
errors[#errors + 1] = makeError("unknown_chat_fingerprint_field", path .. "." .. tostring(key), "채팅 fingerprint에 알 수 없는 필드가 있습니다.")
end
end
if value.algorithm ~= CHAT_FINGERPRINT_ALGORITHM then
errors[#errors + 1] = makeError("invalid_chat_fingerprint_algorithm", path .. ".algorithm", "지원하지 않는 채팅 fingerprint 알고리즘입니다.")
end
for _, field in ipairs({ "length", "hashA", "hashB" }) do
if not isInteger(value[field], 0) then
errors[#errors + 1] = makeError("invalid_chat_fingerprint", path .. "." .. field, "채팅 fingerprint 수치는 0 이상의 정수여야 합니다.")
end
end
return #errors == 0
end
local function validateAftermathOutputObserved(receipt, request, path, errors)
if type(receipt) ~= "table" or getmetatable(receipt) ~= nil then
errors[#errors + 1] = makeError("invalid_aftermath_output_observed", path, "자유행동 출력 관측 영수증이 일반 객체가 아닙니다.")
return
end
local allowed = {
schemaVersion = true,
kind = true,
attemptNumber = true,
responseLuaIndex = true,
responseFingerprint = true,
}
for key in pairs(receipt) do
if type(key) ~= "string" or not allowed[key] then
errors[#errors + 1] = makeError("unknown_aftermath_output_observed_field", path .. "." .. tostring(key), "자유행동 출력 관측 영수증에 알 수 없는 필드가 있습니다.")
end
end
local attemptNumber = type(request) == "table" and (request.attemptNumber or 1) or nil
if receipt.schemaVersion ~= 1 or receipt.kind ~= "battleAftermathOutputObserved" then
errors[#errors + 1] = makeError("invalid_aftermath_output_observed_schema", path, "자유행동 출력 관측 영수증 형식이 올바르지 않습니다.")
end
if receipt.attemptNumber ~= attemptNumber then
errors[#errors + 1] = makeError("aftermath_output_observed_attempt_mismatch", path .. ".attemptNumber", "자유행동 출력 관측 시도가 현재 요청과 다릅니다.")
end
local expectedIndex = type(request) == "table"
and isInteger(request.userLuaIndex, 1)
and request.userLuaIndex + 1
or nil
if not isInteger(receipt.responseLuaIndex, 1) or receipt.responseLuaIndex ~= expectedIndex then
errors[#errors + 1] = makeError("aftermath_output_observed_index_mismatch", path .. ".responseLuaIndex", "자유행동 출력 관측 위치가 현재 요청과 다릅니다.")
end
validateFingerprint(receipt.responseFingerprint, path .. ".responseFingerprint", errors)
end
local function validateAftermathRecoveringCleanup(receipt, request, path, errors)
if type(receipt) ~= "table" or getmetatable(receipt) ~= nil then
errors[#errors + 1] = makeError("invalid_aftermath_recovering_cleanup", path, "자유행동 응답 삭제 복구 영수증이 일반 객체가 아닙니다.")
return
end
local allowed = {
schemaVersion = true,
kind = true,
attemptNumber = true,
responseLuaIndex = true,
responseFingerprint = true,
}
for key in pairs(receipt) do
if type(key) ~= "string" or not allowed[key] then
errors[#errors + 1] = makeError("unknown_aftermath_recovering_cleanup_field", path .. "." .. tostring(key), "자유행동 응답 삭제 복구 영수증에 알 수 없는 필드가 있습니다.")
end
end
if receipt.schemaVersion ~= 1 or receipt.kind ~= "battleAftermathRecoveringCleanup" then
errors[#errors + 1] = makeError("invalid_aftermath_recovering_cleanup_schema", path, "자유행동 응답 삭제 복구 영수증 형식이 올바르지 않습니다.")
end
if receipt.attemptNumber ~= (type(request) == "table" and (request.attemptNumber or 1) or nil) then
errors[#errors + 1] = makeError("aftermath_recovering_cleanup_attempt_mismatch", path .. ".attemptNumber", "자유행동 응답 삭제 복구 시도가 현재 요청과 다릅니다.")
end
local expectedIndex = type(request) == "table"
and isInteger(request.userLuaIndex, 1)
and request.userLuaIndex + 1
or nil
if not isInteger(receipt.responseLuaIndex, 1) or receipt.responseLuaIndex ~= expectedIndex then
errors[#errors + 1] = makeError("aftermath_recovering_cleanup_index_mismatch", path .. ".responseLuaIndex", "자유행동 응답 삭제 복구 위치가 현재 요청과 다릅니다.")
end
validateFingerprint(receipt.responseFingerprint, path .. ".responseFingerprint", errors)
end
local function validateAftermathCommitted(receipt, completedTurnNumber, path, errors)
if type(receipt) ~= "table" or getmetatable(receipt) ~= nil then
errors[#errors + 1] = makeError("invalid_aftermath_committed", path, "확정된 자유행동 영수증이 일반 객체가 아닙니다.")
return
end
local allowed = {
schemaVersion = true,
kind = true,
turnNumber = true,
responseLuaIndex = true,
prefixFingerprint = true,
responseIdentityFingerprint = true,
}
for key in pairs(receipt) do
if type(key) ~= "string" or not allowed[key] then
errors[#errors + 1] = makeError("unknown_aftermath_committed_field", path .. "." .. tostring(key), "확정된 자유행동 영수증에 알 수 없는 필드가 있습니다.")
end
end
if receipt.schemaVersion ~= 1 or receipt.kind ~= "battleAftermathCommitted" then
errors[#errors + 1] = makeError("invalid_aftermath_committed_schema", path, "확정된 자유행동 영수증 형식이 올바르지 않습니다.")
end
if receipt.turnNumber ~= completedTurnNumber then
errors[#errors + 1] = makeError("aftermath_committed_turn_mismatch", path .. ".turnNumber", "확정된 자유행동 영수증의 턴이 현재 진행과 다릅니다.")
end
if not isInteger(receipt.responseLuaIndex, 1) then
errors[#errors + 1] = makeError("invalid_aftermath_committed_index", path .. ".responseLuaIndex", "확정된 자유행동 응답 위치가 올바르지 않습니다.")
end
validateFingerprint(receipt.prefixFingerprint, path .. ".prefixFingerprint", errors)
validateFingerprint(receipt.responseIdentityFingerprint, path .. ".responseIdentityFingerprint", errors)
end
local function aftermathEndTurn(authority)
return math.max(authority.turnLimit, authority.turnNumber + 2)
end
local function validateAftermath(value, authority)
local errors = {}
local path = "$.aftermath"
if type(value) ~= "table" or getmetatable(value) ~= nil then
return {
makeError("invalid_aftermath", path, "승리 후 자유행동 상태가 일반 객체가 아닙니다."),
}
end
local allowed = {
schemaVersion = true,
kind = true,
battleId = true,
victoryTurnNumber = true,
completedTurnNumber = true,
phase = true,
request = true,
lastCommitted = true,
}
for key in pairs(value) do
if type(key) ~= "string" or not allowed[key] then
errors[#errors + 1] = makeError(
"unknown_aftermath_field",
path .. "." .. tostring(key),
"승리 후 자유행동 상태에 알 수 없는 필드가 있습니다."
)
end
end
if (value.schemaVersion ~= 1 and value.schemaVersion ~= AFTERMATH_SCHEMA_VERSION)
or value.kind ~= "battleAftermath" then
errors[#errors + 1] = makeError("invalid_aftermath_schema", path, "승리 후 자유행동 상태 형식이 올바르지 않습니다.")
end
if not isRuntimeId(value.battleId) then
errors[#errors + 1] = makeError("invalid_aftermath_battle", path .. ".battleId", "자유행동 battleId가 올바르지 않습니다.")
end
if not isInteger(value.victoryTurnNumber, 1)
or not isInteger(value.completedTurnNumber, 1)
or value.completedTurnNumber < value.victoryTurnNumber then
errors[#errors + 1] = makeError("invalid_aftermath_turn", path, "자유행동 턴 범위가 올바르지 않습니다.")
end
if value.phase ~= "ready"
and value.phase ~= "inFlight"
and value.phase ~= "requestInjected"
and value.phase ~= "settling"
and value.phase ~= "complete" then
errors[#errors + 1] = makeError("invalid_aftermath_phase", path .. ".phase", "자유행동 phase가 올바르지 않습니다.")
end
if type(authority) ~= "table"
or authority.status ~= "victory"
or authority.battleId ~= value.battleId
or not isInteger(authority.turnNumber, 1)
or authority.turnNumber ~= value.victoryTurnNumber
or not isInteger(authority.turnLimit, 1) then
errors[#errors + 1] = makeError("aftermath_authority_mismatch", path, "자유행동 상태가 승리 전투와 일치하지 않습니다.")
elseif value.phase == "complete" then
if value.completedTurnNumber ~= aftermathEndTurn(authority) then
errors[#errors + 1] = makeError("incomplete_aftermath", path .. ".completedTurnNumber", "완료된 자유행동이 도착 턴에 이르지 않았습니다.")
end
elseif value.phase == "settling" then
if value.completedTurnNumber ~= aftermathEndTurn(authority) then
errors[#errors + 1] = makeError("invalid_aftermath_settlement", path .. ".completedTurnNumber", "정산 중인 자유행동이 도착 턴에 이르지 않았습니다.")
end
elseif value.completedTurnNumber >= aftermathEndTurn(authority) then
errors[#errors + 1] = makeError("aftermath_over_limit", path .. ".completedTurnNumber", "진행 중인 자유행동이 정해진 종료 지점을 넘었습니다.")
end
local needsRequest = value.phase == "inFlight" or value.phase == "requestInjected"
local legacySettlingRequest = value.schemaVersion == 1 and value.phase == "settling"
local request = value.request
if needsRequest or legacySettlingRequest then
if type(request) ~= "table" or getmetatable(request) ~= nil then
if needsRequest then
errors[#errors + 1] = makeError("missing_aftermath_request", path .. ".request", "생성 중인 자유행동 요청 영수증이 없습니다.")
end
else
local requestAllowed = {
turnNumber = true,
userLuaIndex = true,
userFingerprint = true,
attemptNumber = true,
outputObserved = true,
recoveringCleanup = true,
}
for key in pairs(request) do
if type(key) ~= "string" or not requestAllowed[key] then
errors[#errors + 1] = makeError(
"unknown_aftermath_request_field",
path .. ".request." .. tostring(key),
"자유행동 요청 영수증에 알 수 없는 필드가 있습니다."
)
end
end
local expectedTurnNumber = value.phase == "settling"
and value.completedTurnNumber
or value.completedTurnNumber + 1
if request.turnNumber ~= expectedTurnNumber then
errors[#errors + 1] = makeError("aftermath_request_turn_mismatch", path .. ".request.turnNumber", "자유행동 요청 턴이 현재 진행과 다릅니다.")
end
if not isInteger(request.userLuaIndex, 1) then
errors[#errors + 1] = makeError("invalid_aftermath_user_index", path .. ".request.userLuaIndex", "자유행동 사용자 메시지 위치가 올바르지 않습니다.")
end
if request.attemptNumber ~= nil and not isInteger(request.attemptNumber, 1) then
errors[#errors + 1] = makeError("invalid_aftermath_attempt", path .. ".request.attemptNumber", "자유행동 요청 시도 번호가 올바르지 않습니다.")
elseif value.schemaVersion == AFTERMATH_SCHEMA_VERSION and not isInteger(request.attemptNumber, 1) then
errors[#errors + 1] = makeError("missing_aftermath_attempt", path .. ".request.attemptNumber", "자유행동 요청 시도 번호가 없습니다.")
end
validateFingerprint(request.userFingerprint, path .. ".request.userFingerprint", errors)
if request.outputObserved ~= nil then
if value.phase ~= "requestInjected" then
errors[#errors + 1] = makeError("aftermath_output_observed_phase_mismatch", path .. ".request.outputObserved", "자유행동 출력 관측 영수증은 지시가 주입된 요청에만 존재할 수 있습니다.")
end
validateAftermathOutputObserved(request.outputObserved, request, path .. ".request.outputObserved", errors)
end
if request.recoveringCleanup ~= nil then
if value.phase ~= "requestInjected" then
errors[#errors + 1] = makeError("aftermath_recovering_cleanup_phase_mismatch", path .. ".request.recoveringCleanup", "자유행동 응답 삭제 복구 영수증은 지시가 주입된 요청에만 존재할 수 있습니다.")
end
if request.outputObserved ~= nil then
errors[#errors + 1] = makeError("aftermath_recovery_receipt_conflict", path .. ".request", "출력 관측과 응답 삭제 복구 영수증은 함께 존재할 수 없습니다.")
end
validateAftermathRecoveringCleanup(request.recoveringCleanup, request, path .. ".request.recoveringCleanup", errors)
end
end
elseif value.request ~= nil then
errors[#errors + 1] = makeError("unexpected_aftermath_request", path .. ".request", "대기 또는 완료 상태에 생성 요청이 남아 있습니다.")
end
if value.lastCommitted ~= nil then
validateAftermathCommitted(value.lastCommitted, value.completedTurnNumber, path .. ".lastCommitted", errors)
elseif value.schemaVersion == AFTERMATH_SCHEMA_VERSION then
errors[#errors + 1] = makeError("missing_aftermath_committed", path .. ".lastCommitted", "확정된 자유행동 영수증이 없습니다.")
end
return errors
end
local function appendNestedErrors(target, moduleName, report)
if type(report) == "table" and type(report.errors) == "table" then
for index, item in ipairs(report.errors) do
if type(item) == "table" then
target[#target + 1] = makeError(
type(item.code) == "string" and item.code or "nested_error",
type(item.path) == "string" and item.path or ("$.runtime." .. moduleName),
type(item.message) == "string"
and item.message
or (moduleName .. " 오류 " .. index .. "에 설명이 없습니다.")
)
else
target[#target + 1] = makeError(
"invalid_nested_error",
"$.runtime." .. moduleName .. ".errors[" .. index .. "]",
"하위 모듈 오류 항목이 객체가 아닙니다."
)
end
end
end
if #target == 0 then
target[1] = makeError(
"module_failed_without_errors",
"$.runtime." .. moduleName,
moduleName .. "이 오류 상세 없이 실패했습니다."
)
end
end
local function callModule(moduleName, moduleAction, ...)
if type(runScript) ~= "function" then
return nil, {
makeError("runtime_unavailable", "$.runtime", "runScript 실행기를 찾을 수 없습니다."),
}
end
local ok, report = pcall(runScript, triggerId, moduleName, moduleAction, ...)
if not ok then
return nil, {
makeError(
"module_call_error",
"$.runtime." .. moduleName,
moduleName .. "." .. moduleAction .. " 호출 중 오류가 발생했습니다: " .. tostring(report)
),
}
end
if type(report) ~= "table" or getmetatable(report) ~= nil then
return nil, {
makeError(
"invalid_module_result",
"$.runtime." .. moduleName,
moduleName .. "." .. moduleAction .. "이 일반 테이블 결과를 반환하지 않았습니다."
),
}
end
local envelopeVersionOk = report.schemaVersion == SCHEMA_VERSION
or (moduleName == "dataBridge"
and report.schemaVersion == nil
and report.wireFormat == "cbs-json-nodes-v1")
local envelopeErrorsOk = type(report.errors) == "table"
or (moduleName == "dataBridge" and report.ok == true and report.errors == nil)
if not envelopeVersionOk
or not envelopeErrorsOk
or (report.ok ~= true and report.ok ~= false) then
return nil, {
makeError(
"invalid_module_envelope",
"$.runtime." .. moduleName,
moduleName .. "." .. moduleAction .. " 결과 envelope가 올바르지 않습니다."
),
}
end
if report.ok ~= true then
local errors = {}
appendNestedErrors(errors, moduleName, report)
return nil, errors
end
if type(report.errors) == "table" and #report.errors ~= 0 then
return nil, {
makeError(
"success_with_errors",
"$.runtime." .. moduleName .. ".errors",
"성공한 하위 모듈 결과에 오류가 포함되어 있습니다."
),
}
end
return report, nil
end
local function loadStaticData()
local report, errors = callModule("staticData", "loadAll")
if errors then
return nil, errors
end
if type(report.data) ~= "table" or getmetatable(report.data) ~= nil then
return nil, {
makeError("missing_static_data", "$.runtime.staticData.data", "검증된 전체 정적 데이터가 없습니다."),
}
end
return report.data, nil
end
local function readStored(key, required)
if type(HostCompat) ~= "table" or type(HostCompat.readState) ~= "function" then
return nil, {
makeError("state_read_unavailable", "$.host.getState", "상태 읽기 호환 함수를 찾을 수 없습니다."),
}
end
local ok, value = pcall(HostCompat.readState, triggerId, key)
if not ok then
return nil, {
makeError("state_read_failed", "$.state[" .. string.format("%q", key) .. "]", "저장 상태를 읽지 못했습니다: " .. tostring(value)),
}
end
if value == nil then
if required then
return nil, {
makeError("missing_persistent_state", "$.state[" .. string.format("%q", key) .. "]", "필수 저장 상태가 없습니다."),
}
end
return nil, nil
end
local copy, cloneError = cloneJson(value, "$.state[" .. string.format("%q", key) .. "]")
if cloneError then
return nil, { cloneError }
end
return copy, nil
end
local function writeStored(key, value, verify)
-- A host write may return normally without persisting. Verify before
-- later writes retire the draft, pending turn, or recovery receipt.
if verify == nil then verify = true end
if type(HostCompat) ~= "table" or type(HostCompat.writeState) ~= "function" then
return {
makeError("state_write_unavailable", "$.host.setState", "상태 쓰기 호환 함수를 찾을 수 없습니다."),
}
end
if verify == true and type(HostCompat.readState) ~= "function" then
return {
makeError("state_read_unavailable", "$.host.getState", "상태 검증용 읽기 호환 함수를 찾을 수 없습니다."),
}
end
local storedCopy, cloneError = cloneJson(value, "$.state[" .. string.format("%q", key) .. "]")
if cloneError then
return { cloneError }
end
local writeOk, writeError = pcall(HostCompat.writeState, triggerId, key, storedCopy)
if not writeOk then
return {
makeError("state_write_failed", "$.state[" .. string.format("%q", key) .. "]", "저장 상태 쓰기에 실패했습니다: " .. tostring(writeError)),
}
end
if verify ~= true then
return nil
end
local readOk, readValue = pcall(HostCompat.readState, triggerId, key)
if not readOk then
return {
makeError("state_verify_read_failed", "$.state[" .. string.format("%q", key) .. "]", "쓰기 뒤 저장 상태를 다시 읽지 못했습니다: " .. tostring(readValue)),
}
end
if not deepEqual(storedCopy, readValue) then
return {
makeError("state_write_not_persisted", "$.state[" .. string.format("%q", key) .. "]", "쓰기 뒤 읽은 상태가 저장하려던 값과 다릅니다."),
}
end
return nil
end
local function makeTurnId(state)
if type(state) ~= "table" or not isRuntimeId(state.battleId) or not isInteger(state.turnNumber, 1) then
return nil, {
makeError("invalid_turn_identity", "$.authorityState", "battleId와 현재 턴 번호로 turnId를 만들 수 없습니다."),
}
end
return string.format("%s-turn-%03d", state.battleId, state.turnNumber), nil
end
local function expectedPublicMarker(turnNumber)
return "[전투 턴 " .. tostring(turnNumber) .. "] 이번 턴에 실제로 벌어진 일을 하나의 장면으로 이어서 묘사한다."
end
local function validatePromptMessage(message, path)
if type(message) ~= "table" or getmetatable(message) ~= nil then
return makeError("invalid_prompt_message", path, "프롬프트 메시지는 일반 객체여야 합니다.")
end
for key in pairs(message) do
if key ~= "role" and key ~= "content" then
return makeError("unknown_prompt_message_field", path .. "." .. tostring(key), "프롬프트 메시지에 알 수 없는 필드가 있습니다.")
end
end
if message.role ~= "system" or type(message.content) ~= "string" or message.content == "" then
return makeError("invalid_prompt_message", path, "프롬프트 메시지는 비어 있지 않은 system 메시지여야 합니다.")
end
return nil
end
local function formatPending(pendingTurn, staticData)
local report, errors = callModule(
"turnPromptFormatter",
"formatPending",
pendingTurn,
staticData
)
if errors then
return nil, errors
end
local messageError = validatePromptMessage(report.message, "$.runtime.turnPromptFormatter.message")
if messageError then
return nil, { messageError }
end
local turnNumber = type(pendingTurn) == "table"
and type(pendingTurn.beforeState) == "table"
and pendingTurn.beforeState.turnNumber
or nil
if not isInteger(turnNumber, 1) then
return nil, {
makeError("invalid_pending_turn_number", "$.pendingTurn.beforeState.turnNumber", "pendingTurn의 공개 턴 번호가 올바르지 않습니다."),
}
end
if report.publicMarker ~= expectedPublicMarker(turnNumber) then
return nil, {
makeError("invalid_public_marker", "$.runtime.turnPromptFormatter.publicMarker", "formatter가 계약된 공개 턴 마커를 반환하지 않았습니다."),
}
end
local messageCopy, cloneError = cloneJson(report.message, "$.runtime.turnPromptFormatter.message")
if cloneError then
return nil, { cloneError }
end
return {
message = messageCopy,
publicMarker = report.publicMarker,
turnNumber = turnNumber,
}, nil
end
local function validateChatAnchor(anchor, path, errors)
if type(anchor) ~= "table" or getmetatable(anchor) ~= nil then
errors[#errors + 1] = makeError("invalid_chat_anchor", path, "채팅 anchor가 일반 객체가 아닙니다.")
return
end
local allowed = {
schemaVersion = true,
kind = true,
prefixMessageCount = true,
responseIndex = true,
prefixFingerprint = true,
repairableTail = true,
}
for key in pairs(anchor) do
if type(key) ~= "string" or not allowed[key] then
errors[#errors + 1] = makeError("unknown_chat_anchor_field", path .. "." .. tostring(key), "채팅 anchor에 알 수 없는 필드가 있습니다.")
end
end
if anchor.schemaVersion ~= 2 or anchor.kind ~= "battleChatAnchor" then
errors[#errors + 1] = makeError("invalid_chat_anchor_schema", path, "채팅 anchor 스키마가 올바르지 않습니다.")
end
if not isInteger(anchor.prefixMessageCount, 0) then
errors[#errors + 1] = makeError("invalid_chat_anchor_count", path .. ".prefixMessageCount", "anchor prefix 메시지 수가 올바르지 않습니다.")
end
if not isInteger(anchor.responseIndex, 0) or anchor.responseIndex ~= anchor.prefixMessageCount then
errors[#errors + 1] = makeError("invalid_chat_anchor_index", path .. ".responseIndex", "0-based 응답 위치가 prefix 메시지 수와 일치하지 않습니다.")
end
validateFingerprint(anchor.prefixFingerprint, path .. ".prefixFingerprint", errors)
if anchor.repairableTail ~= nil then
local repair = anchor.repairableTail
local repairPath = path .. ".repairableTail"
if type(repair) ~= "table" or getmetatable(repair) ~= nil then
errors[#errors + 1] = makeError("invalid_chat_anchor_repair", repairPath, "복원 가능한 채팅 tail이 일반 객체가 아닙니다.")
else
local repairAllowed = { message = true, prefixFingerprint = true }
for key in pairs(repair) do
if type(key) ~= "string" or not repairAllowed[key] then
errors[#errors + 1] = makeError("unknown_chat_anchor_repair_field", repairPath .. "." .. tostring(key), "복원 가능한 채팅 tail에 알 수 없는 필드가 있습니다.")
end
end
local message = repair.message
if anchor.prefixMessageCount < 1
or type(message) ~= "table"
or getmetatable(message) ~= nil
or message.role ~= "char"
or type(message.data) ~= "string"
or string.match(message.data, "%S") == nil
or message.time ~= 0 then
errors[#errors + 1] = makeError("invalid_chat_anchor_repair_message", repairPath .. ".message", "Lua로 추가된 실제 캐릭터 장면만 anchor tail로 복원할 수 있습니다.")
else
for key in pairs(message) do
if key ~= "role" and key ~= "data" and key ~= "time" then
errors[#errors + 1] = makeError("unknown_chat_anchor_repair_message_field", repairPath .. ".message." .. tostring(key), "복원할 캐릭터 장면에 알 수 없는 필드가 있습니다.")
end
end
end
validateFingerprint(repair.prefixFingerprint, repairPath .. ".prefixFingerprint", errors)
end
end
end
local function validateOutputObserved(receipt, binding, path, errors)
if type(receipt) ~= "table" or getmetatable(receipt) ~= nil then
errors[#errors + 1] = makeError("invalid_output_observed", path, "출력 관측 영수증이 일반 객체가 아닙니다.")
return
end
local allowed = {
schemaVersion = true,
kind = true,
attemptNumber = true,
responseIndex = true,
responseFingerprint = true,
}
for key in pairs(receipt) do
if type(key) ~= "string" or not allowed[key] then
errors[#errors + 1] = makeError("unknown_output_observed_field", path .. "." .. tostring(key), "출력 관측 영수증에 알 수 없는 필드가 있습니다.")
end
end
if receipt.schemaVersion ~= 1 or receipt.kind ~= "battleOutputObserved" then
errors[#errors + 1] = makeError("invalid_output_observed_schema", path, "출력 관측 영수증 스키마가 올바르지 않습니다.")
end
if receipt.attemptNumber ~= binding.attemptNumber then
errors[#errors + 1] = makeError("output_observed_attempt_mismatch", path .. ".attemptNumber", "출력 관측 영수증의 시도 번호가 요청과 다릅니다.")
end
local expectedIndex = type(binding.chatAnchor) == "table" and binding.chatAnchor.responseIndex or nil
if not isInteger(receipt.responseIndex, 0) or receipt.responseIndex ~= expectedIndex then
errors[#errors + 1] = makeError("output_observed_index_mismatch", path .. ".responseIndex", "출력 관측 위치가 채팅 anchor 다음 위치와 다릅니다.")
end
validateFingerprint(receipt.responseFingerprint, path .. ".responseFingerprint", errors)
end
local function validateCleanupReceipt(receipt, binding, path, errors)
if type(receipt) ~= "table" or getmetatable(receipt) ~= nil then
errors[#errors + 1] = makeError("invalid_cleanup_receipt", path, "복구 정리 영수증이 일반 객체가 아닙니다.")
return
end
local allowed = {
schemaVersion = true,
kind = true,
mode = true,
originalPhase = true,
attemptNumber = true,
responseIndex = true,
responsePresent = true,
responseFingerprint = true,
initialFillerCount = true,
}
for key in pairs(receipt) do
if type(key) ~= "string" or not allowed[key] then
errors[#errors + 1] = makeError("unknown_cleanup_receipt_field", path .. "." .. tostring(key), "복구 정리 영수증에 알 수 없는 필드가 있습니다.")
end
end
if receipt.schemaVersion ~= 1 or receipt.kind ~= "battleRecoveringCleanup" then
errors[#errors + 1] = makeError("invalid_cleanup_receipt_schema", path, "복구 정리 영수증 스키마가 올바르지 않습니다.")
end
if receipt.mode ~= "retry" and receipt.mode ~= "resumeCommit" then
errors[#errors + 1] = makeError("invalid_cleanup_mode", path .. ".mode", "복구 정리 mode가 올바르지 않습니다.")
end
if receipt.originalPhase ~= "inFlight" and receipt.originalPhase ~= "requestInjected" then
errors[#errors + 1] = makeError("invalid_cleanup_phase", path .. ".originalPhase", "복구 정리 원본 phase가 올바르지 않습니다.")
elseif receipt.originalPhase ~= binding.phase then
errors[#errors + 1] = makeError("cleanup_phase_mismatch", path .. ".originalPhase", "복구 정리 원본 phase가 현재 요청 phase와 다릅니다.")
end
if receipt.attemptNumber ~= binding.attemptNumber then
errors[#errors + 1] = makeError("cleanup_attempt_mismatch", path .. ".attemptNumber", "복구 정리 시도 번호가 요청과 다릅니다.")
end
local expectedIndex = type(binding.chatAnchor) == "table" and binding.chatAnchor.responseIndex or nil
if not isInteger(receipt.responseIndex, 0) or receipt.responseIndex ~= expectedIndex then
errors[#errors + 1] = makeError("cleanup_response_index_mismatch", path .. ".responseIndex", "복구 정리 응답 위치가 채팅 anchor 다음 위치와 다릅니다.")
end
if type(receipt.responsePresent) ~= "boolean" then
errors[#errors + 1] = makeError("invalid_cleanup_response_flag", path .. ".responsePresent", "복구 정리 응답 존재 표식이 불리언이 아닙니다.")
elseif receipt.responsePresent then
validateFingerprint(receipt.responseFingerprint, path .. ".responseFingerprint", errors)
elseif receipt.responseFingerprint ~= nil then
errors[#errors + 1] = makeError("unexpected_cleanup_response_fingerprint", path .. ".responseFingerprint", "응답이 없는 복구 정리에 응답 fingerprint가 있습니다.")
end
if not isInteger(receipt.initialFillerCount, 1) then
errors[#errors + 1] = makeError("invalid_cleanup_filler_count", path .. ".initialFillerCount", "복구 정리에는 최초 filler가 하나 이상 필요합니다.")
end
if receipt.mode == "retry" and binding.outputObserved ~= nil then
errors[#errors + 1] = makeError("retry_cleanup_has_observed_output", path .. ".mode", "출력이 관측된 요청을 삭제 재시도로 정리할 수 없습니다.")
elseif receipt.mode == "resumeCommit" and binding.outputObserved == nil then
errors[#errors + 1] = makeError("commit_cleanup_missing_observed_output", path .. ".mode", "commit 재개 정리에는 출력 관측 영수증이 필요합니다.")
end
end
local function buildBinding(pendingTurn, formatted, sourceName, phase, chatAnchor, attemptNumber)
if sourceName ~= "pending" and sourceName ~= "lastCommittedPending" then
return nil, {
makeError("invalid_request_source", "$.activeRequest.source", "알 수 없는 요청 source입니다."),
}
end
if phase ~= "preparing"
and phase ~= "inFlight"
and phase ~= "requestInjected"
and phase ~= "committed" then
return nil, {
makeError("invalid_request_phase", "$.activeRequest.phase", "알 수 없는 요청 phase입니다."),
}
end
if phase == "committed" and sourceName ~= "lastCommittedPending" then
return nil, {
makeError("committed_request_source_mismatch", "$.activeRequest.source", "확정 요청은 lastCommittedPending을 가리켜야 합니다."),
}
end
if type(pendingTurn) ~= "table"
or not isRuntimeId(pendingTurn.battleId)
or not isRuntimeId(pendingTurn.turnId) then
return nil, {
makeError("invalid_pending_identity", "$.pendingTurn", "요청에 연결할 pendingTurn 식별자가 올바르지 않습니다."),
}
end
return {
schemaVersion = ACTIVE_REQUEST_SCHEMA_VERSION,
kind = "battleActiveRequest",
battleId = pendingTurn.battleId,
turnId = pendingTurn.turnId,
turnNumber = formatted.turnNumber,
source = sourceName,
phase = phase,
attemptNumber = attemptNumber or 1,
publicMarker = formatted.publicMarker,
message = formatted.message,
chatAnchor = chatAnchor,
}, nil
end
local function validateBinding(binding, pendingTurn, path)
path = path or "$.activeRequest"
if type(binding) ~= "table" or getmetatable(binding) ~= nil then
return { makeError("invalid_active_request", path, "활성 요청 binding이 일반 객체가 아닙니다.") }
end
local allowed = {
schemaVersion = true,
kind = true,
battleId = true,
turnId = true,
turnNumber = true,
source = true,
phase = true,
publicMarker = true,
message = true,
attemptNumber = true,
chatAnchor = true,
outputObserved = true,
recoveringCleanup = true,
}
local errors = {}
for key in pairs(binding) do
if type(key) ~= "string" or not allowed[key] then
errors[#errors + 1] = makeError("unknown_active_request_field", path .. "." .. tostring(key), "활성 요청 binding에 알 수 없는 필드가 있습니다.")
end
end
if binding.schemaVersion ~= ACTIVE_REQUEST_SCHEMA_VERSION or binding.kind ~= "battleActiveRequest" then
errors[#errors + 1] = makeError("invalid_active_request_schema", path, "활성 요청 binding 스키마가 올바르지 않습니다.")
end
if not isRuntimeId(binding.battleId) or not isRuntimeId(binding.turnId) then
errors[#errors + 1] = makeError("invalid_active_request_identity", path, "활성 요청 식별자가 올바르지 않습니다.")
end
if not isInteger(binding.turnNumber, 1) then
errors[#errors + 1] = makeError("invalid_active_request_turn", path .. ".turnNumber", "활성 요청 턴 번호가 올바르지 않습니다.")
end
if not isInteger(binding.attemptNumber, 1) then
errors[#errors + 1] = makeError("invalid_request_attempt", path .. ".attemptNumber", "활성 요청 시도 번호가 올바르지 않습니다.")
end
if binding.source ~= "pending" and binding.source ~= "lastCommittedPending" then
errors[#errors + 1] = makeError("invalid_request_source", path .. ".source", "활성 요청 source가 올바르지 않습니다.")
end
if binding.phase ~= "preparing"
and binding.phase ~= "inFlight"
and binding.phase ~= "requestInjected"
and binding.phase ~= "committed" then
errors[#errors + 1] = makeError("invalid_request_phase", path .. ".phase", "활성 요청 phase가 올바르지 않습니다.")
elseif binding.phase == "committed" and binding.source ~= "lastCommittedPending" then
errors[#errors + 1] = makeError("committed_request_source_mismatch", path .. ".source", "확정 요청은 lastCommittedPending을 가리켜야 합니다.")
end
if binding.publicMarker ~= expectedPublicMarker(binding.turnNumber) then
errors[#errors + 1] = makeError("invalid_public_marker", path .. ".publicMarker", "활성 요청의 공개 마커가 턴 번호와 일치하지 않습니다.")
end
local messageError = validatePromptMessage(binding.message, path .. ".message")
if messageError then
errors[#errors + 1] = messageError
end
validateChatAnchor(binding.chatAnchor, path .. ".chatAnchor", errors)
if binding.outputObserved ~= nil then
if binding.phase ~= "requestInjected" then
errors[#errors + 1] = makeError("output_observed_phase_mismatch", path .. ".outputObserved", "출력 관측 영수증은 requestInjected phase에만 존재할 수 있습니다.")
end
validateOutputObserved(binding.outputObserved, binding, path .. ".outputObserved", errors)
end
if binding.recoveringCleanup ~= nil then
if binding.phase ~= "inFlight" and binding.phase ~= "requestInjected" then
errors[#errors + 1] = makeError("cleanup_receipt_phase_mismatch", path .. ".recoveringCleanup", "복구 정리 영수증은 잠긴 요청 phase에만 존재할 수 있습니다.")
end
validateCleanupReceipt(binding.recoveringCleanup, binding, path .. ".recoveringCleanup", errors)
end
if binding.phase == "committed" and (binding.outputObserved ~= nil or binding.recoveringCleanup ~= nil) then
errors[#errors + 1] = makeError("committed_request_has_transient_receipt", path, "확정 요청에 임시 출력·정리 영수증이 남아 있습니다.")
end
if type(pendingTurn) == "table" then
local pendingTurnNumber = type(pendingTurn.beforeState) == "table" and pendingTurn.beforeState.turnNumber or nil
if binding.battleId ~= pendingTurn.battleId
or binding.turnId ~= pendingTurn.turnId
or binding.turnNumber ~= pendingTurnNumber then
errors[#errors + 1] = makeError("active_request_pending_mismatch", path, "활성 요청이 선택한 pendingTurn과 일치하지 않습니다.")
end
end
return errors
end
local function readChat()
if type(getFullChat) ~= "function" then
return nil, {
makeError("chat_read_unavailable", "$.host.getFullChat", "getFullChat 호스트 함수를 찾을 수 없습니다."),
}
end
local ok, chat = pcall(getFullChat, triggerId)
if not ok then
return nil, {
makeError("chat_read_failed", "$.chat", "대화 기록을 읽지 못했습니다: " .. tostring(chat)),
}
end
local copy, cloneError = cloneJson(chat, "$.chat")
if cloneError then
return nil, { cloneError }
end
local count = 0
for key in pairs(copy) do
if type(key) ~= "number" or not isInteger(key, 1) then
return nil, {
makeError("invalid_chat_array", "$.chat", "대화 기록은 1부터 이어지는 배열이어야 합니다."),
}
end
count = count + 1
end
if count ~= #copy then
return nil, {
makeError("invalid_chat_array", "$.chat", "대화 기록 배열에 빈 인덱스가 있습니다."),
}
end
return copy, nil
end
local function inspectDraftInteractionToken(authority, staticData, draft)
local inspected, inspectErrors = callModule(
"turnDraft",
"inspect",
authority,
staticData,
draft
)
if inspectErrors then return nil, inspectErrors end
if type(inspected.interactionToken) ~= "string" or inspected.interactionToken == "" then
return nil, {
makeError("missing_interaction_token", "$.runtime.turnDraft.inspect", "현재 turnDraft의 interaction token을 만들지 못했습니다."),
}
end
return inspected.interactionToken, nil
end
local function readArmedSubmission(authority, staticData, draft)
local receipt, readErrors = readStored(KEYS.submission, false)
if readErrors then return nil, readErrors end
if receipt == nil then return nil, nil end
if type(receipt) ~= "string" or receipt == "" then
return nil, {
makeError("invalid_submission", "$.submission", "턴 제출 변수는 비어 있지 않은 interaction token이어야 합니다."),
}
end
local interactionToken, tokenErrors = inspectDraftInteractionToken(authority, staticData, draft)
if tokenErrors then return nil, tokenErrors end
if receipt ~= interactionToken then
return nil, {
makeError("stale_submission", "$.submission", "턴 제출 변수가 현재 카드 선택과 일치하지 않습니다."),
}
end
return receipt, nil
end
local function clearSubmission()
return writeStored(KEYS.submission, nil)
end
local function isExactSayNothing(message)
return type(message) == "table"
and message.role == "user"
and message.data == SAY_NOTHING
end
local function isExactTurnSubmitMarker(message)
return type(message) == "table"
and message.role == "user"
and message.data == TURN_SUBMIT_MARKER
end
local function isExactFiller(message)
return isExactSayNothing(message) or isExactTurnSubmitMarker(message)
end
local function isRisuErrorResponse(message)
return type(message) == "table"
and message.role == "char"
and type(message.data) == "string"
and string.find(message.data, "```risuerror", 1, true) ~= nil
end
local function createChatAnchor(chat, prefixMessageCount)
local fingerprint, fingerprintError = fingerprintChatRange(
chat,
1,
prefixMessageCount,
"$.chatAnchor.prefix"
)
if fingerprintError then return nil, { fingerprintError } end
local anchor = {
schemaVersion = 2,
kind = "battleChatAnchor",
prefixMessageCount = prefixMessageCount,
responseIndex = prefixMessageCount,
prefixFingerprint = fingerprint,
}
local tail = chat[prefixMessageCount]
if prefixMessageCount > 0
and type(tail) == "table"
and tail.role == "char"
and type(tail.data) == "string"
and string.match(tail.data, "%S") ~= nil
and tail.time == 0 then
local previousFingerprint, previousFingerprintError = fingerprintChatRange(
chat,
1,
prefixMessageCount - 1,
"$.chatAnchor.repairablePrefix"
)
if previousFingerprintError then return nil, { previousFingerprintError } end
local tailCopy, tailCopyError = cloneJson(tail, "$.chatAnchor.repairableTail.message")
if tailCopyError then return nil, { tailCopyError } end
anchor.repairableTail = {
message = tailCopy,
prefixFingerprint = previousFingerprint,
}
end
return anchor, nil
end
local function createPlannedChatAnchor(chat)
local logicalLength = #chat
while logicalLength > 0 and isExactSayNothing(chat[logicalLength]) do
logicalLength = logicalLength - 1
end
return createChatAnchor(chat, logicalLength)
end
local function validateAnchorPrefix(binding, chat)
local anchor = binding.chatAnchor
local prefixCount = anchor.prefixMessageCount
if #chat < prefixCount then
return {
makeError("chat_anchor_prefix_missing", "$.chat", "현재 대화가 저장된 채팅 anchor prefix보다 짧습니다."),
}
end
local fingerprint, fingerprintError = fingerprintChatRange(
chat,
1,
prefixCount,
"$.chatAnchor.currentPrefix"
)
if fingerprintError then return { fingerprintError } end
if not fingerprintsEqual(fingerprint, anchor.prefixFingerprint) then
return {
makeError("chat_anchor_prefix_mismatch", "$.chat", "요청 이전 대화가 요청 준비 시점의 채팅 anchor와 다릅니다."),
}
end
return nil
end
local function restoreRepairableAnchorTail(binding, chat)
local anchor = binding.chatAnchor
if #chat >= anchor.prefixMessageCount then
return chat, false, nil
end
local repair = anchor.repairableTail
if type(repair) ~= "table" or #chat ~= anchor.prefixMessageCount - 1 then
return chat, false, nil
end
local fingerprint, fingerprintError = fingerprintChatRange(
chat,
1,
#chat,
"$.chatAnchor.repairableCurrentPrefix"
)
if fingerprintError then return nil, false, { fingerprintError } end
if not fingerprintsEqual(fingerprint, repair.prefixFingerprint) then
return chat, false, nil
end
if type(addChat) ~= "function" then
return nil, false, {
makeError("chat_write_unavailable", "$.host.addChat", "리롤이 함께 제거한 접근 장면을 복원할 addChat 호스트 함수를 찾을 수 없습니다."),
}
end
local ok, addError = pcall(addChat, triggerId, "char", repair.message.data)
if not ok then
return nil, false, {
makeError("chat_anchor_repair_failed", "$.chat", "리롤이 함께 제거한 접근 장면을 복원하지 못했습니다: " .. tostring(addError)),
}
end
local restored, readErrors = readChat()
if readErrors then return nil, false, readErrors end
local prefixErrors = validateAnchorPrefix(binding, restored)
if prefixErrors then
return nil, false, prefixErrors
end
return restored, true, nil
end
local function inspectPreparingTopology(binding, chat)
local prefixErrors = validateAnchorPrefix(binding, chat)
if prefixErrors then return nil, prefixErrors end
local cursor = binding.chatAnchor.prefixMessageCount + 1
local fillerCount = 0
for index = cursor, #chat do
if not isExactFiller(chat[index]) then
return nil, {
makeError("preparing_chat_topology_mismatch", "$.chat[" .. index .. "]", "준비 중인 요청의 기준 대화 뒤에는 trailing filler만 올 수 있습니다."),
}
end
fillerCount = fillerCount + 1
end
return {
fillerCount = fillerCount,
}, nil
end
local function inspectAnchoredTopology(binding, chat, requireFiller)
local prefixErrors = validateAnchorPrefix(binding, chat)
if prefixErrors then return nil, prefixErrors end
local prefixCount = binding.chatAnchor.prefixMessageCount
local fillerCount = 0
local cursor = #chat
while cursor > prefixCount and isExactFiller(chat[cursor]) do
fillerCount = fillerCount + 1
cursor = cursor - 1
end
if requireFiller and fillerCount == 0 then
return nil, {
makeError("recovery_filler_missing", "$.chat", "잠긴 요청을 복구하려면 새 정확한 빈 입력이 필요합니다."),
}
end
local responsePresent = false
local responseFingerprint
local responseLuaIndex = prefixCount + 1
if cursor == responseLuaIndex then
local response = chat[responseLuaIndex]
if type(response) ~= "table" or response.role ~= "char" then
return nil, {
makeError("recovery_response_role_mismatch", "$.chat[" .. responseLuaIndex .. "]", "요청 응답 위치의 미확정 메시지가 캐릭터 메시지가 아닙니다."),
}
end
responsePresent = true
local fingerprintError
responseFingerprint, fingerprintError = fingerprintChatRange(
chat,
responseLuaIndex,
1,
"$.recovery.response"
)
if fingerprintError then return nil, { fingerprintError } end
elseif cursor ~= prefixCount then
return nil, {
makeError("recovery_chat_topology_mismatch", "$.chat", "요청 기준 대화 뒤에 자동 복구가 소유한다고 증명할 수 없는 메시지가 있습니다."),
}
end
return {
responseLuaIndex = responseLuaIndex,
responseIndex = binding.chatAnchor.responseIndex,
responsePresent = responsePresent,
responseFingerprint = responseFingerprint,
fillerCount = fillerCount,
}, nil
end
local function inspectObservedOutput(binding, chat, allowTrailingFillers)
local topology, topologyErrors = inspectAnchoredTopology(binding, chat, false)
if topologyErrors then return nil, topologyErrors end
if not topology.responsePresent then
return nil, {
makeError("observed_output_missing", "$.chat", "출력 관측 영수증에 연결할 캐릭터 응답이 없습니다."),
}
end
if not allowTrailingFillers and topology.fillerCount ~= 0 then
return nil, {
makeError("unexpected_output_suffix", "$.chat", "정상 onOutput 관측 시점에 응답 뒤 추가 메시지가 있습니다."),
}
end
local observed = binding.outputObserved
if observed ~= nil then
if topology.responseIndex ~= observed.responseIndex
or not fingerprintsEqual(topology.responseFingerprint, observed.responseFingerprint) then
return nil, {
makeError("observed_output_mismatch", "$.chat", "현재 캐릭터 응답이 저장된 출력 관측 영수증과 다릅니다."),
}
end
end
return topology, nil
end
local function removeTrailingSayNothing(chat, minimumLength)
local current = chat
local removedCount = 0
while true do
local last = current[#current]
if #current <= (minimumLength or 0)
or not isExactSayNothing(last) then
return current, removedCount, nil
end
if type(removeChat) ~= "function" then
return nil, removedCount, {
makeError("chat_write_unavailable", "$.host.removeChat", "removeChat 호스트 함수를 찾을 수 없습니다."),
}
end
local ok, removeError = pcall(removeChat, triggerId, #current - 1)
if not ok then
return nil, removedCount, {
makeError("say_nothing_remove_failed", "$.chat[" .. #current .. "]", "자동 제출 메시지를 제거하지 못했습니다: " .. tostring(removeError)),
}
end
local after, readErrors = readChat()
if readErrors then
return nil, removedCount, readErrors
end
if #after ~= #current - 1 then
return nil, removedCount, {
makeError("say_nothing_remove_not_persisted", "$.chat", "자동 제출 메시지 제거 뒤 대화 길이가 바뀌지 않았습니다."),
}
end
for index = 1, #after do
if not deepEqual(after[index], current[index]) then
return nil, removedCount, {
makeError("say_nothing_remove_mismatch", "$.chat[" .. index .. "]", "자동 제출 메시지 제거가 앞선 대화를 변경했습니다."),
}
end
end
current = after
removedCount = removedCount + 1
end
end
local function ensureTurnBoundary(chat)
local last = chat[#chat]
if type(last) == "table" and last.role == "user" then
return chat, false, nil
end
if type(addChat) ~= "function" then
return nil, false, {
makeError("chat_write_unavailable", "$.host.addChat", "리롤 경계 메시지를 추가할 addChat 호스트 함수를 찾을 수 없습니다."),
}
end
local ok, addError = pcall(addChat, triggerId, "user", TURN_SUBMIT_MARKER)
if not ok then
return nil, false, {
makeError("turn_boundary_add_failed", "$.chat", "리롤 경계 메시지를 추가하지 못했습니다: " .. tostring(addError)),
}
end
local after, readErrors = readChat()
if readErrors then return nil, false, readErrors end
if #after ~= #chat + 1 or not isExactFiller(after[#after])
or after[#after].data ~= TURN_SUBMIT_MARKER then
return nil, false, {
makeError("turn_boundary_add_not_persisted", "$.chat", "리롤 경계 메시지 추가가 저장되지 않았습니다."),
}
end
for index = 1, #chat do
if not deepEqual(after[index], chat[index]) then
return nil, false, {
makeError("turn_boundary_add_mismatch", "$.chat[" .. index .. "]", "리롤 경계 메시지 추가가 앞선 대화를 변경했습니다."),
}
end
end
return after, true, nil
end
local function removeRecoveryResponse(chat, luaIndex, expectedFingerprint)
if luaIndex ~= #chat then
return nil, {
makeError("recovery_response_not_last", "$.chat", "filler 정리 뒤 삭제할 미확정 응답이 마지막 메시지가 아닙니다."),
}
end
local currentFingerprint, fingerprintError = fingerprintChatRange(
chat,
luaIndex,
1,
"$.recovery.response"
)
if fingerprintError then return nil, { fingerprintError } end
if not fingerprintsEqual(currentFingerprint, expectedFingerprint) then
return nil, {
makeError("recovery_response_fingerprint_mismatch", "$.chat[" .. luaIndex .. "]", "삭제 대상 응답이 복구 영수증과 다릅니다."),
}
end
if type(chat[luaIndex]) ~= "table" or chat[luaIndex].role ~= "char" then
return nil, {
makeError("recovery_response_role_mismatch", "$.chat[" .. luaIndex .. "]", "삭제 대상이 캐릭터 응답이 아닙니다."),
}
end
if type(removeChat) ~= "function" then
return nil, {
makeError("chat_write_unavailable", "$.host.removeChat", "removeChat 호스트 함수를 찾을 수 없습니다."),
}
end
local ok, removeError = pcall(removeChat, triggerId, luaIndex - 1)
if not ok then
return nil, {
makeError("recovery_response_remove_failed", "$.chat[" .. luaIndex .. "]", "미확정 응답을 삭제하지 못했습니다: " .. tostring(removeError)),
}
end
local after, readErrors = readChat()
if readErrors then return nil, readErrors end
if #after ~= #chat - 1 then
return nil, {
makeError("recovery_response_remove_not_persisted", "$.chat", "미확정 응답 삭제 뒤 대화 길이가 바뀌지 않았습니다."),
}
end
for index = 1, #after do
if not deepEqual(after[index], chat[index]) then
return nil, {
makeError("recovery_response_remove_mismatch", "$.chat[" .. index .. "]", "미확정 응답 삭제가 앞선 대화를 변경했습니다."),
}
end
end
return after, nil
end
local function publishCurrentViewInternal(staticData, suppressRefresh, skipUiRender, interactionOnly, readOnly)
staticData = staticData or select(1, loadStaticData())
if staticData == nil then
local _, errors = loadStaticData()
return nil, errors
end
local authority, authorityErrors = readStored(KEYS.authority, true)
if authorityErrors then
return nil, authorityErrors
end
local context = {}
local lastCommitted, lastCommittedErrors = readStored(KEYS.lastCommittedPending, false)
if lastCommittedErrors then
return nil, lastCommittedErrors
end
if authority.lastCommittedTurnId ~= nil and lastCommitted == nil then
return nil, {
makeError(
"missing_last_committed_pending",
"$.lastCommittedPending",
"확정 turnId가 있는 authority에는 공개 결과를 재현할 직전 pendingTurn이 필요합니다."
),
}
end
if lastCommitted ~= nil then
context.lastCommittedPending = lastCommitted
end
local activeRequest, activeRequestErrors = readStored(KEYS.activeRequest, false)
if activeRequestErrors then
return nil, activeRequestErrors
end
if activeRequest ~= nil then
local activeValidationErrors = validateBinding(activeRequest, nil)
if #activeValidationErrors > 0 then
return nil, activeValidationErrors
end
end
local aftermath, aftermathErrors = readStored(KEYS.aftermath, false)
if aftermathErrors then
return nil, aftermathErrors
end
if aftermath ~= nil then
local aftermathValidationErrors = validateAftermath(aftermath, authority)
if #aftermathValidationErrors > 0 then
return nil, aftermathValidationErrors
end
if aftermath.phase == "ready"
or aftermath.phase == "inFlight"
or aftermath.phase == "requestInjected" then
context.aftermath = {
completedTurnNumber = aftermath.completedTurnNumber,
phase = aftermath.phase,
}
end
end
if authority.status == "active" then
local pending, pendingErrors = readStored(KEYS.pending, false)
if pendingErrors then
return nil, pendingErrors
end
if pending ~= nil then
context.pendingTurn = pending
else
local draft, draftErrors = readStored(KEYS.draft, true)
if draftErrors then
return nil, draftErrors
end
context.draft = draft
if type(activeRequest) == "table"
and (activeRequest.phase == "preparing"
or activeRequest.phase == "inFlight"
or activeRequest.phase == "requestInjected") then
context.generationLocked = true
else
local submission, submissionErrors = readArmedSubmission(
authority,
staticData,
draft
)
if submissionErrors then return nil, submissionErrors end
if submission ~= nil then
context.submissionArmed = true
end
end
end
end
local built, buildErrors = callModule(
"viewBuilder",
interactionOnly == true and "buildBattleInteractionView" or "buildBattleView",
authority,
staticData,
context
)
if buildErrors then
return nil, buildErrors
end
if type(built.view) ~= "table" then
return nil, {
makeError("missing_battle_view", "$.runtime.viewBuilder.view", "viewBuilder 성공 결과에 battleView가 없습니다."),
}
end
local interactionView = interactionOnly == true and built.view or built.interactionView
if type(interactionView) ~= "table" then
return nil, {
makeError(
"missing_battle_interaction_view",
"$.runtime.viewBuilder.interactionView",
"viewBuilder 성공 결과에 battleInteractionView가 없습니다."
),
}
end
if readOnly == true then
return { view = built.view }, nil
end
local publishedViewName = interactionOnly == true and INTERACTION_VIEW_NAME or VIEW_NAME
local publishedView = interactionOnly == true and interactionView or built.view
local published, publishErrors = callModule(
"dataBridge",
"_publishCanonical",
publishedViewName,
publishedView,
permitCanonicalBattleView
)
if publishErrors then
return nil, publishErrors
end
if type(published.encoded) ~= "string" or published.encoded == "" then
return nil, {
makeError("missing_published_view", "$.runtime.dataBridge.encoded", "dataBridge 성공 결과에 게시 문자열이 없습니다."),
}
end
if skipUiRender == true then
return {
view = publishedView,
wireFormat = published.wireFormat,
bytes = published.bytes,
}, nil
end
-- getLoreBooks/loadLores는 HTML을 반환하기 전에 CBS를 평가하므로
-- View를 먼저 쓴 뒤 UI 조각을 로드한다.
if type(loadLores) ~= "function" then
return nil, {
makeError("lore_loader_unavailable", "$.host.loadLores", "전투 UI 로어북을 읽을 loadLores 함수를 찾을 수 없습니다."),
}
end
if type(HostCompat) ~= "table" or type(HostCompat.writeChatVar) ~= "function"
or type(getChatVar) ~= "function" then
return nil, {
makeError("ui_write_unavailable", "$.host.setChatVar", "전투 UI를 게시할 호환 쓰기/getChatVar 함수를 찾을 수 없습니다."),
}
end
if interactionOnly ~= true then
local interactionPublished, interactionPublishErrors = callModule(
"dataBridge",
"_publishCanonical",
INTERACTION_VIEW_NAME,
interactionView,
permitCanonicalBattleView
)
if interactionPublishErrors then
return nil, interactionPublishErrors
end
if type(interactionPublished.encoded) ~= "string"
or interactionPublished.encoded == "" then
return nil, {
makeError(
"missing_published_view",
"$.runtime.dataBridge.encoded",
"dataBridge 성공 결과에 interaction 게시 문자열이 없습니다."
),
}
end
end
local frameUi = nil
if interactionOnly == true then
local frameReadOk, storedFrame = pcall(getChatVar, triggerId, UI_BODY_NAME)
if frameReadOk
and type(storedFrame) == "string"
and string.find(storedFrame, UI_INTERACTION_MARKER, 1, true) ~= nil then
frameUi = storedFrame
else
return nil, {
makeError("missing_ui_frame", "$.chatVar.battleUi", "카드 상호작용을 반영할 현재 턴의 전투 UI 프레임이 없습니다."),
}
end
end
if interactionOnly ~= true then
local frameLoadOk, loadedFrame = pcall(loadLores, triggerId, "battleui.html")
if not frameLoadOk then
return nil, {
makeError("lore_load_failed", "$.lore.battleui", "battleui.html을 읽지 못했습니다: " .. tostring(loadedFrame)),
}
end
if type(loadedFrame) ~= "string"
or loadedFrame == ""
or string.find(loadedFrame, UI_INTERACTION_MARKER, 1, true) == nil then
return nil, {
makeError("invalid_ui_frame", "$.lore.battleui", "battleui.html 고정 프레임에 상호작용 마커가 없습니다."),
}
end
frameUi = loadedFrame
end
local interactionLoadOk, interactionUi = pcall(loadLores, triggerId, "battleui-interaction.html")
if not interactionLoadOk then
return nil, {
makeError("lore_load_failed", "$.lore.battleuiInteraction", "battleui-interaction.html을 읽지 못했습니다: " .. tostring(interactionUi)),
}
end
if type(interactionUi) ~= "string" or interactionUi == "" then
return nil, {
makeError("missing_lore", "$.lore.battleuiInteraction", "battleui-interaction.html 로어북 내용이 없습니다."),
}
end
if interactionOnly ~= true then
local frameWriteOk, frameWriteError = pcall(HostCompat.writeChatVar, triggerId, UI_BODY_NAME, frameUi)
if not frameWriteOk then
return nil, {
makeError("ui_write_failed", "$.chatVar.battleUi", "전투 UI 프레임 쓰기에 실패했습니다: " .. tostring(frameWriteError)),
}
end
end
local interactionWriteOk, interactionWriteError = pcall(
HostCompat.writeChatVar,
triggerId,
UI_INTERACTION_NAME,
interactionUi
)
if not interactionWriteOk then
return nil, {
makeError("ui_write_failed", "$.chatVar.battleUiInteraction", "전투 UI 상호작용 조각 쓰기에 실패했습니다: " .. tostring(interactionWriteError)),
}
end
if suppressRefresh ~= true then
local uiRefresh = type(refreshGameUi) == "function" and refreshGameUi or reloadDisplay
if type(uiRefresh) ~= "function" then
return nil, {
makeError("display_reload_unavailable", "$.host.refreshGameUi", "게시한 battleView를 화면에 반영할 UI 갱신 함수가 없습니다."),
}
end
local reloadOk, reloadError = pcall(uiRefresh, triggerId)
if not reloadOk then
return nil, {
makeError("display_reload_failed", "$.host.refreshGameUi", "battleView 게시 뒤 화면 갱신에 실패했습니다: " .. tostring(reloadError)),
}
end
end
return {
view = publishedView,
wireFormat = published.wireFormat,
bytes = published.bytes,
uiFrame = frameUi,
uiInteraction = interactionUi,
interactionOnly = interactionOnly == true,
}, nil
end
local function publishTerminalBattleLog(authority, staticData)
if type(authority) ~= "table"
or (authority.status ~= "victory" and authority.status ~= "defeat") then
return nil, {
makeError("battle_log_requires_terminal", "$.authority.status", "종료된 전투에서만 상세 로그를 게시할 수 있습니다."),
}
end
local built, buildErrors = callModule(
"battleHistory",
"buildPublicView",
authority.history,
staticData
)
if buildErrors then return nil, buildErrors end
if type(built.view) ~= "table" or built.view.available ~= true then
return nil, {
makeError("missing_terminal_battle_log", "$.runtime.battleHistory.view", "종료 전투의 공개 상세 로그를 만들지 못했습니다."),
}
end
local published, publishErrors = callModule(
"dataBridge",
"_publishCanonical",
BATTLE_LOG_VIEW_NAME,
built.view,
permitCanonicalBattleView
)
if publishErrors then return nil, publishErrors end
if type(published.encoded) ~= "string" or published.encoded == "" then
return nil, {
makeError("missing_published_battle_log", "$.runtime.dataBridge.encoded", "상세 전투 로그 게시 문자열이 없습니다."),
}
end
return built.view, nil
end
local function validateBattleReadySetup(setupState, staticData)
local setupCopy, setupCopyError = cloneJson(setupState, "$.setupState")
if setupCopyError then
return nil, nil, { setupCopyError }
end
local validated, validationErrors = callModule(
"gameSetup",
"validate",
setupCopy,
staticData
)
if validationErrors then
return nil, nil, validationErrors
end
if type(validated.state) ~= "table" or getmetatable(validated.state) ~= nil then
return nil, nil, {
makeError("missing_validated_setup", "$.runtime.gameSetup.state", "gameSetup.validate가 정규 설정 상태를 반환하지 않았습니다."),
}
end
if not deepEqual(setupCopy, validated.state) then
return nil, nil, {
makeError("setup_validation_mismatch", "$.setupState", "설정 상태가 gameSetup.validate의 정규 상태와 정확히 일치하지 않습니다."),
}
end
if validated.state.phase ~= "battleReady" then
return nil, nil, {
makeError("setup_not_battle_ready", "$.setupState.phase", "캐릭터 선택까지 끝난 battleReady 설정만 전투를 시작할 수 있습니다."),
}
end
local battleSpec = validated.state.battleSpec
if type(battleSpec) ~= "table" or getmetatable(battleSpec) ~= nil then
return nil, nil, {
makeError("missing_battle_spec", "$.setupState.battleSpec", "battleReady 설정에 전투 사양이 없습니다."),
}
end
local playerCardIds, deckCopyError = cloneJson(
validated.state.selectedCardIds,
"$.setupState.selectedCardIds"
)
if deckCopyError then
return nil, nil, { deckCopyError }
end
local normalizedSetup, normalizedError = cloneJson(validated.state, "$.setupState")
if normalizedError then
return nil, nil, { normalizedError }
end
return normalizedSetup, {
battleId = battleSpec.battleId,
seed = battleSpec.seed,
playerCardIds = playerCardIds,
characterId = validated.state.selectedCharacterId,
}, nil
end
local function inspectCanonicalBattleReadySetup(setupState)
if type(setupState) ~= "table"
or getmetatable(setupState) ~= nil
or setupState.schemaVersion ~= SCHEMA_VERSION
or setupState.kind ~= "gameSetupV1"
or setupState.phase ~= "battleReady"
or not isRuntimeId(setupState.setupId)
or type(setupState.selectedCardIds) ~= "table"
or type(setupState.selectedCharacterId) ~= "string"
or type(setupState.battleSpec) ~= "table"
or getmetatable(setupState.battleSpec) ~= nil
or not isRuntimeId(setupState.battleSpec.battleId)
or not isInteger(setupState.battleSpec.seed, 1) then
return nil, nil, {
makeError(
"invalid_canonical_setup_contract",
"$.setupState",
"내부 canonical battleReady 설정이 필수 postcondition을 만족하지 않습니다."
),
}
end
return setupState, {
battleId = setupState.battleSpec.battleId,
seed = setupState.battleSpec.seed,
playerCardIds = setupState.selectedCardIds,
characterId = setupState.selectedCharacterId,
}, nil
end
local function buildInitialBattleFromSetup(spec, staticData)
local bootstrap, bootstrapErrors = callModule(
"battleBootstrap",
"fromSetup",
spec,
staticData
)
if bootstrapErrors then
return nil, bootstrapErrors
end
if bootstrap.referencesValidated ~= true or type(bootstrap.state) ~= "table" then
return nil, {
makeError("invalid_setup_bootstrap_result", "$.runtime.battleBootstrap", "fromSetup이 검증된 battleState를 반환하지 않았습니다."),
}
end
local turnId, turnIdErrors = makeTurnId(bootstrap.state)
if turnIdErrors then
return nil, turnIdErrors
end
local initialized, initializeErrors = callModule(
"turnInitializer",
"prepareTurn",
bootstrap.state,
staticData,
{ turnId = turnId }
)
if initializeErrors then
return nil, initializeErrors
end
if type(initialized.state) ~= "table" or type(initialized.draft) ~= "table" then
return nil, {
makeError("invalid_initial_turn", "$.runtime.turnInitializer", "setup 전투의 첫 턴 상태와 draft가 없습니다."),
}
end
if initialized.state.battleId ~= spec.battleId then
return nil, {
makeError("initialized_battle_id_mismatch", "$.runtime.turnInitializer.state.battleId", "첫 턴 상태의 battleId가 설정 사양과 다릅니다."),
}
end
return {
authority = initialized.state,
draft = initialized.draft,
pending = nil,
lastCommittedPending = nil,
activeRequest = nil,
submission = nil,
aftermath = nil,
turnId = turnId,
}, nil
end
local function readRuntimeBundle()
local values = {}
for _, name in ipairs({
"authority",
"draft",
"pending",
"lastCommittedPending",
"activeRequest",
"submission",
"aftermath",
}) do
local value, errors = readStored(KEYS[name], false)
if errors then
return nil, errors
end
values[name] = value
end
return values, nil
end
local function buildTerminalSummary(authority, lastCommitted, staticData)
if type(authority) ~= "table"
or (authority.status ~= "victory" and authority.status ~= "defeat") then
return nil, {
makeError(
"battle_not_terminal",
"$.state.authority.status",
"승리 또는 패배로 확정된 전투만 정산할 수 있습니다."
),
}
end
if type(lastCommitted) ~= "table"
or lastCommitted.battleId ~= authority.battleId
or lastCommitted.turnId ~= authority.lastCommittedTurnId
or type(lastCommitted.afterState) ~= "table"
or not deepEqual(lastCommitted.afterState, authority) then
return nil, {
makeError(
"terminal_receipt_mismatch",
"$.state.lastCommittedPending",
"마지막 확정 턴 영수증이 종료 권위 상태와 정확히 일치하지 않습니다."
),
}
end
local presented, presentationErrors = callModule(
"turnPresentation",
"build",
lastCommitted,
staticData
)
if presentationErrors then return nil, presentationErrors end
if type(presented.lastTurn) ~= "table" or presented.lastTurn.available ~= true then
return nil, {
makeError(
"missing_terminal_presentation",
"$.runtime.turnPresentation.lastTurn",
"종료 턴의 공개 결과를 검증하지 못했습니다."
),
}
end
local events = type(lastCommitted.turnResult) == "table"
and type(lastCommitted.turnResult.publicResult) == "table"
and lastCommitted.turnResult.publicResult.events
or nil
if type(events) ~= "table" then
return nil, {
makeError(
"missing_terminal_events",
"$.state.lastCommittedPending.turnResult.publicResult.events",
"종료 턴의 공개 사건 배열이 없습니다."
),
}
end
local outcomePayload
local outcomeCount = 0
local sessionStatus
local sessionCount = 0
for _, event in ipairs(events) do
if type(event) == "table" and event.type == "outcome" then
outcomeCount = outcomeCount + 1
outcomePayload = event.payload
elseif type(event) == "table" and event.type == "session_ended" then
sessionCount = sessionCount + 1
sessionStatus = type(event.payload) == "table" and event.payload.status or nil
end
end
if outcomeCount ~= 1
or sessionCount ~= 1
or type(outcomePayload) ~= "table"
or outcomePayload.status ~= authority.status
or sessionStatus ~= authority.status
or (outcomePayload.reasonCode ~= "card_checkpoint"
and outcomePayload.reasonCode ~= "turn_start_checkpoint"
and outcomePayload.reasonCode ~= "turn_end_checkpoint"
and outcomePayload.reasonCode ~= "plan_exit_checkpoint"
and outcomePayload.reasonCode ~= "turn_limit")
or outcomePayload.stealth ~= authority.player.stealth
or outcomePayload.resistance ~= authority.character.resistance then
return nil, {
makeError(
"invalid_terminal_events",
"$.state.lastCommittedPending.turnResult.publicResult.events",
"종료 공개 사건이 권위 상태의 승패와 최종 수치에 일치하지 않습니다."
),
}
end
if outcomePayload.reasonCode == "turn_limit" and authority.status ~= "defeat" then
return nil, {
makeError(
"invalid_terminal_reason",
"$.state.lastCommittedPending.turnResult.publicResult.events",
"턴 제한 종료는 패배 결과여야 합니다."
),
}
end
local transitCopy, transitError = cloneJson(authority.transit, "$.summary.transit")
if transitError then return nil, { transitError } end
return {
battleId = authority.battleId,
turnId = authority.lastCommittedTurnId,
characterId = authority.character.characterId,
status = authority.status,
reasonCode = outcomePayload.reasonCode,
turnNumber = authority.turnNumber,
turnLimit = authority.turnLimit,
finalStealth = authority.player.stealth,
finalResistance = authority.character.resistance,
transit = transitCopy,
}, nil
end
local function buildAftermathInstruction(authority, aftermath)
local finalTurn = aftermath.completedTurnNumber + 1 == aftermathEndTurn(authority)
local lines = {
"[함락 후 자유행동]",
"전투 승리는 이미 확정되었다. 카드, 저항, 은폐, 무드, 전투 판정이나 보상을 언급하지 마라.",
"현재 장면은 " .. authority.sceneContext.weekday .. " "
.. authority.sceneContext.time .. "이며 날씨는 "
.. authority.sceneContext.weather
.. "이다. 열차의 혼잡도, 승객의 분위기, 복장과 우산 같은 배경에 자연스럽게 반영하되 게임 효과나 수치 규칙으로 해석하지 마라.",
"사용자가 방금 입력한 행위를 그대로 존중하여 캐릭터의 반응과 열차 안의 장면을 자연스럽게 이어서 묘사하라.",
"사용자가 입력하지 않은 추가 행동, 대사, 생각을 플레이어에게 부여하지 마라.",
}
if finalTurn then
lines[#lines + 1] = "이번 자유행동은 마지막이다. 응답의 끝에서 반드시 열차가 목적지 역에 도착하고 캐릭터가 정신을 차린 뒤 황급히 열차에서 내리는 장면으로 마무리하라."
end
return {
role = "system",
content = table.concat(lines, "\n"),
}
end
local function fingerprintAftermathResponseIdentity(response, path)
if type(response) ~= "table" or response.role ~= "char" then
return nil, makeError("invalid_aftermath_response_identity", path, "자유행동 응답 식별자를 만들 수 없습니다.")
end
return fingerprintChatRange({ {
role = response.role,
time = response.time or 0,
} }, 1, 1, path)
end
local function buildAftermathCommitted(chat, turnNumber, responseLuaIndex)
local response = isInteger(responseLuaIndex, 1) and chat[responseLuaIndex] or nil
if not isInteger(responseLuaIndex, 1)
or type(response) ~= "table"
or response.role ~= "char" then
return nil, {
makeError("invalid_aftermath_committed_response", "$.chat", "확정할 자유행동 캐릭터 응답 위치가 올바르지 않습니다."),
}
end
local fingerprint, fingerprintError = fingerprintChatRange(
chat,
1,
responseLuaIndex - 1,
"$.aftermath.lastCommitted.prefix"
)
if fingerprintError then return nil, { fingerprintError } end
local responseIdentity, identityError = fingerprintAftermathResponseIdentity(
response,
"$.aftermath.lastCommitted.responseIdentity"
)
if identityError then return nil, { identityError } end
return {
schemaVersion = 1,
kind = "battleAftermathCommitted",
turnNumber = turnNumber,
responseLuaIndex = responseLuaIndex,
prefixFingerprint = fingerprint,
responseIdentityFingerprint = responseIdentity,
}, nil
end
local function validateAftermathCommittedChat(aftermath, chat)
local receipt = aftermath.lastCommitted
if receipt == nil then return nil end
if #chat < receipt.responseLuaIndex then
return {
makeError("aftermath_committed_chat_missing", "$.chat", "이미 확정된 자유행동 장면이 대화에서 삭제되었습니다."),
}
end
local fingerprint, fingerprintError = fingerprintChatRange(
chat,
1,
receipt.responseLuaIndex - 1,
"$.aftermath.lastCommitted.currentPrefix"
)
if fingerprintError then return { fingerprintError } end
local response = chat[receipt.responseLuaIndex]
if type(response) ~= "table" or response.role ~= "char" then
return {
makeError("aftermath_committed_chat_changed", "$.chat", "이미 확정된 자유행동 장면이 변경되었습니다."),
}
end
local responseIdentity, identityError = fingerprintAftermathResponseIdentity(
response,
"$.aftermath.lastCommitted.currentResponseIdentity"
)
if identityError then return { identityError } end
if not fingerprintsEqual(fingerprint, receipt.prefixFingerprint)
or not fingerprintsEqual(responseIdentity, receipt.responseIdentityFingerprint) then
return {
makeError("aftermath_committed_chat_changed", "$.chat", "이미 확정된 자유행동 장면이 변경되었습니다."),
}
end
return nil
end
local function migrateLegacyAftermath(authority, aftermath)
if aftermath.schemaVersion ~= 1 or aftermath.phase == "complete" then
return aftermath, nil
end
local chat, chatErrors = readChat()
if chatErrors then return nil, chatErrors end
local binding, bindingErrors = readStored(KEYS.activeRequest, true)
if bindingErrors then return nil, bindingErrors end
local bindingValidationErrors = validateBinding(binding, nil)
if #bindingValidationErrors > 0 then return nil, bindingValidationErrors end
if binding.phase ~= "committed" or binding.battleId ~= aftermath.battleId then
return nil, {
makeError("legacy_aftermath_migration_unsafe", "$.activeRequest", "기존 자유행동의 기준 전투 응답을 안전하게 찾을 수 없습니다."),
}
end
local prefixErrors = validateAnchorPrefix(binding, chat)
if prefixErrors then return nil, prefixErrors end
local responseLuaIndex = binding.chatAnchor.responseIndex + 1
+ (aftermath.completedTurnNumber - aftermath.victoryTurnNumber) * 2
if aftermath.phase == "ready" then
local suffixCount = #chat - responseLuaIndex
local first = chat[responseLuaIndex + 1]
local firstIsInput = type(first) == "table"
and first.role == "user"
and not isExactFiller(first)
if suffixCount < 0
or (suffixCount == 1
and not (firstIsInput or isExactFiller(first)))
or suffixCount > 1 then
return nil, {
makeError("legacy_aftermath_migration_unsafe", "$.chat", "기존 자유행동 대화 끝을 안전하게 이전할 수 없습니다."),
}
end
elseif aftermath.phase == "settling" then
if type(aftermath.request) ~= "table"
or aftermath.request.userLuaIndex + 1 ~= responseLuaIndex then
return nil, {
makeError("legacy_aftermath_migration_unsafe", "$.aftermath.request", "기존 자유행동 정산 응답 위치를 안전하게 이전할 수 없습니다."),
}
end
elseif type(aftermath.request) ~= "table"
or aftermath.request.userLuaIndex ~= responseLuaIndex + 1 then
return nil, {
makeError("legacy_aftermath_migration_unsafe", "$.aftermath.request", "기존 자유행동 요청 위치를 안전하게 이전할 수 없습니다."),
}
end
local receipt, receiptErrors = buildAftermathCommitted(
chat,
aftermath.completedTurnNumber,
responseLuaIndex
)
if receiptErrors then return nil, receiptErrors end
aftermath.schemaVersion = AFTERMATH_SCHEMA_VERSION
aftermath.lastCommitted = receipt
if aftermath.phase == "settling" then
aftermath.request = nil
elseif type(aftermath.request) == "table" then
aftermath.request.attemptNumber = aftermath.request.attemptNumber or 1
end
local validationErrors = validateAftermath(aftermath, authority)
if #validationErrors > 0 then return nil, validationErrors end
local writeErrors = writeStored(KEYS.aftermath, aftermath)
if writeErrors then return nil, writeErrors end
return aftermath, nil
end
local function validateAftermathRequestChat(aftermath, chat, requireResponse, allowTrailingFillers)
local committedErrors = validateAftermathCommittedChat(aftermath, chat)
if committedErrors then return nil, committedErrors end
local request = aftermath.request
local user = type(request) == "table" and chat[request.userLuaIndex] or nil
if type(user) ~= "table" or user.role ~= "user" then
return nil, {
makeError("aftermath_user_missing", "$.chat", "자유행동 요청에 연결된 사용자 입력이 없습니다."),
}
end
if type(aftermath.lastCommitted) == "table"
and request.userLuaIndex ~= aftermath.lastCommitted.responseLuaIndex + 1 then
return nil, {
makeError("aftermath_chat_topology_mismatch", "$.chat", "확정 장면과 현재 자유행동 입력 사이에 예상하지 않은 메시지가 있습니다."),
}
end
local fingerprint, fingerprintError = fingerprintChatRange(
chat,
request.userLuaIndex,
1,
"$.aftermath.request.user"
)
if fingerprintError then return nil, { fingerprintError } end
if not fingerprintsEqual(fingerprint, request.userFingerprint) then
return nil, {
makeError("aftermath_user_changed", "$.chat", "생성 중인 자유행동 사용자 입력이 변경되었습니다."),
}
end
local response = chat[request.userLuaIndex + 1]
if allowTrailingFillers and isExactFiller(response) then
response = nil
end
if response ~= nil and (type(response) ~= "table" or response.role ~= "char") then
return nil, {
makeError("aftermath_response_role_mismatch", "$.chat", "자유행동 응답 위치에 캐릭터 메시지가 아닌 항목이 있습니다."),
}
end
local expectedLength = request.userLuaIndex + (response ~= nil and 1 or 0)
if #chat ~= expectedLength then
if #chat < expectedLength or not allowTrailingFillers then
return nil, {
makeError("aftermath_chat_topology_mismatch", "$.chat", "자유행동 요청 뒤에 소유권을 확인할 수 없는 메시지가 있습니다."),
}
end
for index = expectedLength + 1, #chat do
if not isExactFiller(chat[index]) then
return nil, {
makeError("aftermath_chat_topology_mismatch", "$.chat", "자유행동 요청 뒤에 소유권을 확인할 수 없는 메시지가 있습니다."),
}
end
end
end
if requireResponse and response == nil then
return nil, {
makeError("aftermath_output_missing", "$.chat", "확정할 자유행동 응답이 없습니다."),
}
end
return response, nil
end
local function validateAftermathOutput(response)
if type(response.data) ~= "string" then
return {
makeError("invalid_aftermath_output", "$.chat", "자유행동 캐릭터 응답이 문자열이 아닙니다."),
}
end
if string.match(response.data, "%S") == nil then
return {
makeError("aftermath_output_blank", "$.chat", "빈 자유행동 응답은 확정할 수 없습니다."),
}
end
if isRisuErrorResponse(response) then
return {
makeError("aftermath_output_error", "$.chat", "LLM 오류 응답은 자유행동 장면으로 확정할 수 없습니다."),
}
end
return nil
end
local function observeAftermathOutput(authority, aftermath, chat)
local request = aftermath.request
local responseLuaIndex = request.userLuaIndex + 1
local fingerprint, fingerprintError = fingerprintAftermathResponseIdentity(
chat[responseLuaIndex],
"$.aftermath.request.outputObserved.response"
)
if fingerprintError then return { fingerprintError } end
local observed = request.outputObserved
if observed ~= nil then
if observed.attemptNumber ~= (request.attemptNumber or 1)
or observed.responseLuaIndex ~= responseLuaIndex
or not fingerprintsEqual(observed.responseFingerprint, fingerprint) then
return {
makeError("aftermath_observed_output_mismatch", "$.chat", "현재 자유행동 응답이 저장된 출력 관측 영수증과 다릅니다."),
}
end
return nil
end
request.attemptNumber = request.attemptNumber or 1
request.outputObserved = {
schemaVersion = 1,
kind = "battleAftermathOutputObserved",
attemptNumber = request.attemptNumber,
responseLuaIndex = responseLuaIndex,
responseFingerprint = fingerprint,
}
aftermath.schemaVersion = AFTERMATH_SCHEMA_VERSION
local validationErrors = validateAftermath(aftermath, authority)
if #validationErrors > 0 then return validationErrors end
return writeStored(KEYS.aftermath, aftermath)
end
local function beginAftermathRecoveringCleanup(authority, aftermath, chat)
local request = aftermath.request
local responseLuaIndex = request.userLuaIndex + 1
local fingerprint, fingerprintError = fingerprintChatRange(
chat,
responseLuaIndex,
1,
"$.aftermath.retry.response"
)
if fingerprintError then return nil, { fingerprintError } end
request.outputObserved = nil
request.recoveringCleanup = {
schemaVersion = 1,
kind = "battleAftermathRecoveringCleanup",
attemptNumber = request.attemptNumber or 1,
responseLuaIndex = responseLuaIndex,
responseFingerprint = fingerprint,
}
aftermath.schemaVersion = AFTERMATH_SCHEMA_VERSION
local validationErrors = validateAftermath(aftermath, authority)
if #validationErrors > 0 then return nil, validationErrors end
local writeErrors = writeStored(KEYS.aftermath, aftermath)
if writeErrors then return nil, writeErrors end
return request.recoveringCleanup, nil
end
local function settleAftermath(authority, aftermath, staticData)
local lastCommitted, lastErrors = readStored(KEYS.lastCommittedPending, true)
if lastErrors then return failure(lastErrors) end
local summary, summaryErrors = buildTerminalSummary(authority, lastCommitted, staticData)
if summaryErrors then return failure(summaryErrors) end
local _, battleLogErrors = publishTerminalBattleLog(authority, staticData)
if battleLogErrors then return failure(battleLogErrors) end
local settled, settlementErrors = callModule(
"gameSetupController",
"completeBattle",
summary
)
if settlementErrors then return failure(settlementErrors) end
if type(settled.view) ~= "table" or type(settled.state) ~= "table" then
return failure({
makeError("invalid_settlement_result", "$.runtime.gameSetupController.completeBattle", "자유행동 종료 정산이 진행 상태와 보상 View를 반환하지 않았습니다."),
})
end
aftermath.schemaVersion = AFTERMATH_SCHEMA_VERSION
aftermath.phase = "complete"
aftermath.request = nil
local writeErrors = writeStored(KEYS.aftermath, aftermath)
if writeErrors then return failure(writeErrors) end
return success({
generationReady = false,
outputCommitted = true,
uiTargetIndex = aftermath.lastCommitted.responseLuaIndex - 1,
aftermathComplete = true,
status = authority.status,
view = settled.view,
progressionState = settled.state,
})
end
local function commitAftermathOutput(authority, aftermath, staticData)
if aftermath.phase == "settling" then
return settleAftermath(authority, aftermath, staticData)
end
if aftermath.phase ~= "requestInjected" then
return failure({
makeError("aftermath_request_not_injected", "$.aftermath.phase", "장면 지시가 주입되지 않은 자유행동 출력은 확정할 수 없습니다."),
})
end
if aftermath.request.recoveringCleanup ~= nil then
return failure({
makeError("aftermath_cleanup_in_progress", "$.aftermath.request.recoveringCleanup", "미확정 자유행동 응답 삭제 복구 중에는 출력을 확정할 수 없습니다."),
})
end
local chat, chatErrors = readChat()
if chatErrors then return failure(chatErrors) end
local response, topologyErrors = validateAftermathRequestChat(aftermath, chat, true)
if topologyErrors then return failure(topologyErrors) end
local outputErrors = validateAftermathOutput(response)
if outputErrors then return failure(outputErrors) end
local observedErrors = observeAftermathOutput(authority, aftermath, chat)
if observedErrors then return failure(observedErrors) end
local completedTurnNumber = aftermath.completedTurnNumber + 1
local committedReceipt, receiptErrors = buildAftermathCommitted(
chat,
completedTurnNumber,
aftermath.request.userLuaIndex + 1
)
if receiptErrors then return failure(receiptErrors) end
aftermath.schemaVersion = AFTERMATH_SCHEMA_VERSION
aftermath.completedTurnNumber = completedTurnNumber
aftermath.lastCommitted = committedReceipt
aftermath.request = nil
aftermath.phase = completedTurnNumber == aftermathEndTurn(authority) and "settling" or "ready"
local validationErrors = validateAftermath(aftermath, authority)
if #validationErrors > 0 then return failure(validationErrors) end
local writeErrors = writeStored(KEYS.aftermath, aftermath)
if writeErrors then return failure(writeErrors) end
if aftermath.phase == "settling" then
return settleAftermath(authority, aftermath, staticData)
end
local published, publishErrors = publishCurrentViewInternal(staticData, true)
if publishErrors then return failure(publishErrors) end
return success({
generationReady = false,
outputCommitted = true,
uiTargetIndex = aftermath.lastCommitted.responseLuaIndex - 1,
aftermathComplete = false,
status = authority.status,
view = published.view,
})
end
local function skipAftermath(expectedBattleId, expectedViewTurnId)
local staticData, staticErrors = loadStaticData()
if staticErrors then return failure(staticErrors) end
local authority, authorityErrors = readStored(KEYS.authority, true)
if authorityErrors then return failure(authorityErrors) end
if expectedBattleId ~= authority.battleId then
return failure({
makeError("stale_aftermath_skip", "$.expectedBattleId", "현재 전투와 다른 화면의 도착 건너뛰기 요청입니다."),
})
end
local aftermath, aftermathReadErrors = readStored(KEYS.aftermath, false)
if aftermathReadErrors then return failure(aftermathReadErrors) end
if aftermath == nil then
return failure({
makeError("aftermath_skip_unavailable", "$.aftermath", "건너뛸 승리 후 자유행동이 없습니다."),
})
end
local aftermathErrors = validateAftermath(aftermath, authority)
if #aftermathErrors > 0 then return failure(aftermathErrors) end
local migrated, migrationErrors = migrateLegacyAftermath(authority, aftermath)
if migrationErrors then return failure(migrationErrors) end
aftermath = migrated
if aftermath.phase == "settling" then
local settled = settleAftermath(authority, aftermath, staticData)
if type(settled) == "table" and settled.ok == true then
settled.skipped = true
settled.reused = true
end
return settled
end
if aftermath.phase == "complete" then
return success({
generationReady = false,
outputCommitted = true,
uiTargetIndex = aftermath.lastCommitted.responseLuaIndex - 1,
aftermathComplete = true,
skipped = true,
reused = true,
status = authority.status,
})
end
local currentViewTurnId = string.format(
"%s-aftermath-%03d",
authority.battleId,
aftermath.completedTurnNumber
)
if expectedViewTurnId ~= currentViewTurnId then
return failure({
makeError("stale_aftermath_skip", "$.expectedViewTurnId", "현재 승리 후 화면과 다른 도착 건너뛰기 요청입니다."),
})
end
if aftermath.phase ~= "ready" then
return failure({
makeError("aftermath_skip_in_flight", "$.aftermath.phase", "자유행동 장면을 생성하는 중에는 남은 턴을 건너뛸 수 없습니다."),
})
end
local chat, chatErrors = readChat()
if chatErrors then return failure(chatErrors) end
local committedErrors = validateAftermathCommittedChat(aftermath, chat)
if committedErrors then return failure(committedErrors) end
local responseLuaIndex = aftermath.lastCommitted.responseLuaIndex
if #chat ~= responseLuaIndex then
return failure({
makeError("aftermath_skip_chat_not_clean", "$.chat", "확정 장면 뒤에 자유행동 입력 또는 예상하지 않은 메시지가 있어 건너뛸 수 없습니다."),
})
end
local previousCompletedTurnNumber = aftermath.completedTurnNumber
local endTurnNumber = aftermathEndTurn(authority)
local committedReceipt, receiptErrors = buildAftermathCommitted(
chat,
endTurnNumber,
responseLuaIndex
)
if receiptErrors then return failure(receiptErrors) end
aftermath.schemaVersion = AFTERMATH_SCHEMA_VERSION
aftermath.completedTurnNumber = endTurnNumber
aftermath.lastCommitted = committedReceipt
aftermath.request = nil
aftermath.phase = "settling"
local validationErrors = validateAftermath(aftermath, authority)
if #validationErrors > 0 then return failure(validationErrors) end
local writeErrors = writeStored(KEYS.aftermath, aftermath)
if writeErrors then return failure(writeErrors) end
local settled = settleAftermath(authority, aftermath, staticData)
if type(settled) == "table" and settled.ok == true then
settled.skipped = true
settled.reused = false
settled.skippedTurnCount = endTurnNumber - previousCompletedTurnNumber
end
return settled
end
local function prepareAftermathGeneration(authority, aftermath, staticData)
if aftermath.phase == "complete" then
return success({
generationReady = false,
outputCommitted = false,
aftermathComplete = true,
})
end
if aftermath.phase == "settling" then
local chat, chatErrors = readChat()
if chatErrors then return failure(chatErrors) end
local _, removedFillers, cleanupErrors = removeTrailingSayNothing(chat, 0)
if cleanupErrors then return failure(cleanupErrors) end
local settled = settleAftermath(authority, aftermath, staticData)
if type(settled) == "table" and settled.ok == true then
settled.commitRecovered = true
settled.removedSayNothing = removedFillers > 0
settled.removedSayNothingCount = removedFillers
end
return settled
end
if aftermath.phase == "inFlight" or aftermath.phase == "requestInjected" then
local chat, chatErrors = readChat()
if chatErrors then return failure(chatErrors) end
local response, topologyErrors = validateAftermathRequestChat(aftermath, chat, false, true)
if topologyErrors then return failure(topologyErrors) end
local observed = aftermath.request.outputObserved
if observed ~= nil then
if response == nil then
return failure({
makeError("aftermath_observed_output_missing", "$.chat", "관측된 자유행동 응답이 대화에서 삭제되었습니다."),
})
end
local observedErrors = observeAftermathOutput(authority, aftermath, chat)
if observedErrors then return failure(observedErrors) end
local outputErrors = validateAftermathOutput(response)
if outputErrors then
if not isExactFiller(chat[#chat]) then return failure(outputErrors) end
local _, beginErrors = beginAftermathRecoveringCleanup(
authority,
aftermath,
chat
)
if beginErrors then return failure(beginErrors) end
else
local cleaned, removedFillers, cleanupErrors = removeTrailingSayNothing(
chat,
aftermath.request.userLuaIndex + 1
)
if cleanupErrors then return failure(cleanupErrors) end
chat = cleaned
local committed = commitAftermathOutput(authority, aftermath, staticData)
if type(committed) ~= "table" or committed.ok ~= true then return committed end
committed.commitRecovered = true
committed.removedSayNothing = removedFillers > 0
committed.removedSayNothingCount = removedFillers
return committed
end
end
local retryCleanup = aftermath.request.recoveringCleanup
local hasRetryFiller = isExactFiller(chat[#chat])
if response ~= nil and not hasRetryFiller and retryCleanup == nil then
return failure({
makeError("aftermath_request_already_in_flight", "$.aftermath.phase", "아직 관측되지 않은 자유행동 응답이 있어 재시도를 시작할 수 없습니다."),
})
end
if retryCleanup == nil and response ~= nil then
local beginErrors
retryCleanup, beginErrors = beginAftermathRecoveringCleanup(
authority,
aftermath,
chat
)
if beginErrors then return failure(beginErrors) end
elseif retryCleanup ~= nil and response ~= nil then
local fingerprint, fingerprintError = fingerprintChatRange(
chat,
retryCleanup.responseLuaIndex,
1,
"$.aftermath.retry.currentResponse"
)
if fingerprintError then return failure({ fingerprintError }) end
if not fingerprintsEqual(fingerprint, retryCleanup.responseFingerprint) then
return failure({
makeError("aftermath_recovering_cleanup_response_mismatch", "$.chat", "삭제 복구 중인 자유행동 응답이 변경되었습니다."),
})
end
end
local cleaned, removedFillers, cleanupErrors = removeTrailingSayNothing(
chat,
aftermath.request.userLuaIndex
)
if cleanupErrors then return failure(cleanupErrors) end
chat = cleaned
local removedResponse = retryCleanup ~= nil
response = chat[aftermath.request.userLuaIndex + 1]
if retryCleanup ~= nil and response ~= nil then
local afterRemoval, removeErrors = removeRecoveryResponse(
chat,
retryCleanup.responseLuaIndex,
retryCleanup.responseFingerprint
)
if removeErrors then return failure(removeErrors) end
chat = afterRemoval
end
local _, finalTopologyErrors = validateAftermathRequestChat(aftermath, chat, false)
if finalTopologyErrors then return failure(finalTopologyErrors) end
aftermath.schemaVersion = AFTERMATH_SCHEMA_VERSION
aftermath.phase = "inFlight"
aftermath.request.attemptNumber = (aftermath.request.attemptNumber or 1) + 1
aftermath.request.outputObserved = nil
aftermath.request.recoveringCleanup = nil
local validationErrors = validateAftermath(aftermath, authority)
if #validationErrors > 0 then return failure(validationErrors) end
local writeErrors = writeStored(KEYS.aftermath, aftermath)
if writeErrors then return failure(writeErrors) end
return success({
generationReady = true,
aftermath = true,
reused = true,
zeroOutputRetry = not removedResponse,
commitRecovered = false,
turnNumber = aftermath.request.turnNumber,
attemptNumber = aftermath.request.attemptNumber,
removedSayNothing = removedFillers > 0,
removedSayNothingCount = removedFillers,
removedUncommittedOutput = removedResponse,
})
end
local chat, chatErrors = readChat()
if chatErrors then return failure(chatErrors) end
local committedErrors = validateAftermathCommittedChat(aftermath, chat)
if committedErrors then return failure(committedErrors) end
local removedFillers = 0
if isExactFiller(chat[#chat]) then
local cleaned, cleanupCount, cleanupErrors = removeTrailingSayNothing(
chat,
aftermath.lastCommitted.responseLuaIndex
)
if cleanupErrors then return failure(cleanupErrors) end
chat = cleaned
removedFillers = cleanupCount
end
if #chat == aftermath.lastCommitted.responseLuaIndex then
local published, publishErrors = publishCurrentViewInternal(staticData, true)
if publishErrors then return failure(publishErrors) end
return success({
generationReady = false,
outputCommitted = false,
aftermathComplete = false,
uiTargetRequired = true,
uiTargetIndex = aftermath.lastCommitted.responseLuaIndex - 1,
commitRecovered = false,
removedSayNothing = removedFillers > 0,
removedSayNothingCount = removedFillers,
view = published.view,
})
end
if removedFillers > 0 then
return failure({
makeError("aftermath_automatic_continue_rejected", "$.chat", "빈 전송이나 Continue는 자유행동으로 처리하지 않습니다."),
})
end
local userLuaIndex = #chat
local user = chat[userLuaIndex]
if type(user) ~= "table" or user.role ~= "user" then
return failure({
makeError("missing_aftermath_input", "$.chat", "함락 후에는 원하는 행위를 입력한 뒤 전송해야 합니다."),
})
end
if type(aftermath.lastCommitted) == "table"
and userLuaIndex ~= aftermath.lastCommitted.responseLuaIndex + 1 then
return failure({
makeError("aftermath_chat_topology_mismatch", "$.chat", "확정 장면 뒤에는 하나의 새 자유행동 입력만 올 수 있습니다."),
})
end
local fingerprint, fingerprintError = fingerprintChatRange(
chat,
userLuaIndex,
1,
"$.aftermath.request.user"
)
if fingerprintError then return failure({ fingerprintError }) end
aftermath.schemaVersion = AFTERMATH_SCHEMA_VERSION
aftermath.phase = "inFlight"
aftermath.request = {
turnNumber = aftermath.completedTurnNumber + 1,
userLuaIndex = userLuaIndex,
userFingerprint = fingerprint,
attemptNumber = 1,
}
local validationErrors = validateAftermath(aftermath, authority)
if #validationErrors > 0 then return failure(validationErrors) end
local writeErrors = writeStored(KEYS.aftermath, aftermath)
if writeErrors then return failure(writeErrors) end
return success({
generationReady = true,
aftermath = true,
reused = false,
turnNumber = aftermath.request.turnNumber,
attemptNumber = aftermath.request.attemptNumber,
})
end
local function injectAftermathRequest(promptArray, authority, aftermath)
if aftermath.phase ~= "inFlight" and aftermath.phase ~= "requestInjected" then
return failure({
makeError("aftermath_request_not_in_flight", "$.aftermath.phase", "생성 중인 자유행동 요청이 없습니다."),
})
end
local promptCopy, cloneError = cloneJson(promptArray, "$.promptArray")
if cloneError then return failure({ cloneError }) end
if type(promptCopy) ~= "table" then
return failure({
makeError("invalid_prompt_array", "$.promptArray", "editRequest 값은 메시지 배열이어야 합니다."),
})
end
local promptCount = 0
for key, message in pairs(promptCopy) do
if type(key) ~= "number" or not isInteger(key, 1) or type(message) ~= "table" then
return failure({
makeError("invalid_prompt_array", "$.promptArray", "editRequest 값은 1부터 이어지는 메시지 객체 배열이어야 합니다."),
})
end
promptCount = promptCount + 1
end
if promptCount ~= #promptCopy then
return failure({
makeError("invalid_prompt_array", "$.promptArray", "editRequest 메시지 배열에 빈 인덱스가 있습니다."),
})
end
local chat, chatErrors = readChat()
if chatErrors then return failure(chatErrors) end
local response, topologyErrors = validateAftermathRequestChat(aftermath, chat, false)
if topologyErrors then return failure(topologyErrors) end
if response ~= nil
or aftermath.request.outputObserved ~= nil
or aftermath.request.recoveringCleanup ~= nil then
return failure({
makeError("aftermath_request_not_clean", "$.chat", "응답이 시작되거나 관측된 자유행동 요청에는 프롬프트를 다시 주입할 수 없습니다."),
})
end
local instruction = buildAftermathInstruction(authority, aftermath)
local normalized = {}
local removed = 0
for _, message in ipairs(promptCopy) do
if deepEqual(message, instruction) then
removed = removed + 1
else
normalized[#normalized + 1] = message
end
end
normalized[#normalized + 1] = instruction
if aftermath.phase == "inFlight" then
aftermath.phase = "requestInjected"
local validationErrors = validateAftermath(aftermath, authority)
if #validationErrors > 0 then return failure(validationErrors) end
local writeErrors = writeStored(KEYS.aftermath, aftermath)
if writeErrors then return failure(writeErrors) end
end
return success({
promptArray = normalized,
injected = removed == 0,
deduplicated = removed > 1,
aftermath = true,
finalTurn = aftermath.completedTurnNumber + 1 == aftermathEndTurn(authority),
requestPhase = aftermath.phase,
attemptNumber = aftermath.request.attemptNumber,
})
end
local function getTerminalSummary()
local staticData, staticErrors = loadStaticData()
if staticErrors then return failure(staticErrors) end
local current, currentErrors = readRuntimeBundle()
if currentErrors then return failure(currentErrors) end
if current.authority == nil then
return success({
terminal = false,
hasBattle = false,
settlementAvailable = false,
})
end
if current.authority.status == "active" then
return success({
terminal = false,
hasBattle = true,
settlementAvailable = false,
battleId = current.authority.battleId,
status = current.authority.status,
})
end
if current.aftermath ~= nil then
local aftermathErrors = validateAftermath(current.aftermath, current.authority)
if #aftermathErrors > 0 then return failure(aftermathErrors) end
if current.aftermath.phase ~= "complete" then
return success({
terminal = true,
hasBattle = true,
settlementAvailable = false,
battleId = current.authority.battleId,
status = current.authority.status,
})
end
elseif current.authority.status == "victory" then
return success({
terminal = true,
hasBattle = true,
settlementAvailable = false,
battleId = current.authority.battleId,
status = current.authority.status,
})
end
if current.lastCommittedPending == nil
and current.draft == nil
and current.pending == nil
and current.activeRequest == nil
and current.submission == nil then
-- startFromRun은 종료 영수증을 확인한 뒤 보조 상태를 먼저
-- 비운다. 그 직후 중단된 경우에도 다음 호출이 run의 저장된
-- 정산 영수증으로 retirement를 재개할 수 있게 identity만
-- 반환한다.
return success({
terminal = true,
hasBattle = true,
settlementAvailable = false,
battleId = current.authority.battleId,
status = current.authority.status,
})
end
local summary, summaryErrors = buildTerminalSummary(
current.authority,
current.lastCommittedPending,
staticData
)
if summaryErrors then return failure(summaryErrors) end
return success({
terminal = true,
hasBattle = true,
settlementAvailable = true,
battleId = current.authority.battleId,
status = current.authority.status,
summary = summary,
})
end
local function writeInitialRuntime(expected)
for _, name in ipairs({
"authority",
"draft",
"pending",
"lastCommittedPending",
"activeRequest",
"submission",
"aftermath",
}) do
local writeErrors = writeStored(KEYS[name], expected[name])
if writeErrors then
return writeErrors
end
end
return nil
end
local function validateExistingSetupBinding(authority, spec, staticData)
local errors = {}
local function conflict(path, message)
errors[#errors + 1] = makeError("battle_setup_conflict", path, message)
end
if type(authority.rng) ~= "table" or authority.rng.seed ~= spec.seed then
conflict("$.state.authority.rng.seed", "기존 전투의 RNG seed가 setup 전투 사양과 다릅니다.")
end
local journey, journeyErrors = callModule(
"subwayJourney",
"build",
spec.seed,
staticData,
staticData.characters[spec.characterId].battle.turnLimit
)
if journeyErrors then
for _, item in ipairs(journeyErrors) do
errors[#errors + 1] = item
end
elseif type(journey) ~= "table"
or authority.turnLimit ~= journey.turnLimit
or not deepEqual(authority.transit, journey.transit)
or not deepEqual(authority.sceneContext, journey.sceneContext) then
conflict("$.state.authority", "기존 전투의 제한 턴, 지하철 여정 또는 배경 정보가 setup seed에서 결정한 값과 다릅니다.")
end
if type(authority.character) ~= "table"
or authority.character.characterId ~= spec.characterId then
conflict("$.state.authority.character.characterId", "기존 전투의 캐릭터가 setup 선택 결과와 다릅니다.")
end
local initialPlayerCards = {}
for _, instance in ipairs(type(authority.cardInstances) == "table" and authority.cardInstances or {}) do
if type(instance) == "table" and type(instance.instanceId) == "string" then
local rawIndex = string.match(instance.instanceId, "^player%-(%d%d%d)$")
local index = rawIndex ~= nil and tonumber(rawIndex) or nil
if index ~= nil and index >= 1 and index <= #spec.playerCardIds then
if initialPlayerCards[index] ~= nil then
conflict(
"$.state.authority.cardInstances",
"기존 전투에 같은 초기 플레이어 instanceId가 중복되었습니다."
)
else
initialPlayerCards[index] = {
cardId = instance.cardId,
owner = instance.owner,
}
end
end
end
end
for index, expectedCardId in ipairs(spec.playerCardIds) do
local actual = initialPlayerCards[index]
local instanceId = string.format("player-%03d", index)
if type(actual) ~= "table"
or actual.owner ~= "player"
or actual.cardId ~= expectedCardId then
conflict(
"$.state.authority.cardInstances[" .. string.format("%q", instanceId) .. "]",
"기존 전투의 초기 플레이어 덱이 setup에서 선택한 카드 순서와 다릅니다."
)
end
end
if #errors > 0 then
return errors
end
return nil
end
local function startFromSetup(setupState, canonicalInput)
local staticData, staticErrors = loadStaticData()
if staticErrors then
return failure(staticErrors)
end
local canonicalSetup, spec, setupErrors
if canonicalInput == true then
canonicalSetup, spec, setupErrors = inspectCanonicalBattleReadySetup(setupState)
else
canonicalSetup, spec, setupErrors = validateBattleReadySetup(setupState, staticData)
end
if setupErrors then
return failure(setupErrors)
end
local current, currentErrors = readRuntimeBundle()
if currentErrors then
return failure(currentErrors)
end
if current.authority ~= nil then
if type(current.authority) ~= "table"
or current.authority.battleId ~= spec.battleId then
return failure({
makeError(
"battle_runtime_conflict",
"$.state.authority.battleId",
"다른 전투의 권위 상태가 있어 setup 전투로 덮어쓸 수 없습니다."
),
})
end
local bindingErrors = validateExistingSetupBinding(current.authority, spec, staticData)
if bindingErrors then
return failure(bindingErrors)
end
-- 정상적인 같은 전투는 첫 턴 중이라도 draft 선택, pending,
-- generation binding이 진행됐을 수 있다. 이 상태를 다시 만들지
-- 않고 현재 권위 경계에서 View/UI만 재게시한다.
local looksLikeInitialPartial = current.authority.status == "active"
and current.draft == nil
and current.pending == nil
and current.lastCommittedPending == nil
and current.activeRequest == nil
and current.submission == nil
and current.aftermath == nil
if not looksLikeInitialPartial then
local published, publishErrors = publishCurrentViewInternal(staticData, true)
if publishErrors then
return failure(publishErrors)
end
return success({
applied = false,
reused = true,
recovered = false,
battleId = current.authority.battleId,
turnNumber = current.authority.turnNumber,
setupId = canonicalSetup.setupId,
view = published.view,
})
end
end
-- 새 시작, 또는 authority까지만 저장된 안전한 부분 write를 같은
-- 결정적 초기 상태와 exact 비교한 뒤에만 완성한다.
local expected, expectedErrors = buildInitialBattleFromSetup(spec, staticData)
if expectedErrors then
return failure(expectedErrors)
end
for _, name in ipairs({
"authority",
"draft",
"pending",
"lastCommittedPending",
"activeRequest",
"submission",
"aftermath",
}) do
local existing = current[name]
if existing ~= nil and not deepEqual(existing, expected[name]) then
return failure({
makeError(
"unsafe_partial_battle_runtime",
"$.state[" .. string.format("%q", KEYS[name]) .. "]",
"기존 부분 전투 상태가 setup에서 재생한 초기 상태와 일치하지 않아 복구할 수 없습니다."
),
})
end
end
local recovered = current.authority ~= nil or current.draft ~= nil
local writeErrors = writeInitialRuntime(expected)
if writeErrors then
return failure(writeErrors)
end
local published, publishErrors = publishCurrentViewInternal(staticData, true)
if publishErrors then
return failure(publishErrors)
end
return success({
applied = true,
reused = false,
recovered = recovered,
battleId = expected.authority.battleId,
turnId = expected.turnId,
turnNumber = expected.authority.turnNumber,
setupId = canonicalSetup.setupId,
view = published.view,
})
end
local function validateBattleReadyRun(runState, setupState, staticData)
local canonicalSetup, _, setupErrors = validateBattleReadySetup(
setupState,
staticData
)
if setupErrors then return nil, nil, nil, setupErrors end
local runCopy, runCopyError = cloneJson(runState, "$.runState")
if runCopyError then return nil, nil, nil, { runCopyError } end
local validated, validationErrors = callModule(
"runProgression",
"validate",
runCopy,
canonicalSetup,
staticData
)
if validationErrors then return nil, nil, nil, validationErrors end
if type(validated.state) ~= "table"
or getmetatable(validated.state) ~= nil
or not deepEqual(runCopy, validated.state) then
return nil, nil, nil, {
makeError(
"run_validation_mismatch",
"$.runState",
"진행 상태가 runProgression.validate의 정규 상태와 정확히 일치하지 않습니다."
),
}
end
if validated.state.phase ~= "battleReady" then
return nil, nil, nil, {
makeError(
"run_not_battle_ready",
"$.runState.phase",
"다음 상대 선택까지 끝난 battleReady 진행 상태만 전투를 시작할 수 있습니다."
),
}
end
local battleSpec = validated.state.battleSpec
if type(battleSpec) ~= "table" or getmetatable(battleSpec) ~= nil then
return nil, nil, nil, {
makeError(
"missing_battle_spec",
"$.runState.battleSpec",
"진행 상태에 다음 전투 사양이 없습니다."
),
}
end
local deckCopy, deckCopyError = cloneJson(
battleSpec.playerCardIds,
"$.runState.battleSpec.playerCardIds"
)
if deckCopyError then return nil, nil, nil, { deckCopyError } end
local normalizedRun, normalizedRunError = cloneJson(
validated.state,
"$.runState"
)
if normalizedRunError then
return nil, nil, nil, { normalizedRunError }
end
return normalizedRun, canonicalSetup, {
battleId = battleSpec.battleId,
seed = battleSpec.seed,
playerCardIds = deckCopy,
characterId = battleSpec.characterId,
}, nil
end
local function inspectCanonicalBattleReadyRun(runState, setupState)
local canonicalSetup, _, setupErrors = inspectCanonicalBattleReadySetup(setupState)
if setupErrors then return nil, nil, nil, setupErrors end
local battleSpec = type(runState) == "table" and runState.battleSpec or nil
if type(runState) ~= "table"
or getmetatable(runState) ~= nil
or runState.schemaVersion ~= SCHEMA_VERSION
or runState.kind ~= "runProgressionV1"
or runState.phase ~= "battleReady"
or runState.setupId ~= canonicalSetup.setupId
or type(runState.sessions) ~= "table"
or type(battleSpec) ~= "table"
or getmetatable(battleSpec) ~= nil
or not isRuntimeId(battleSpec.battleId)
or not isInteger(battleSpec.seed, 1)
or type(battleSpec.playerCardIds) ~= "table"
or type(battleSpec.characterId) ~= "string" then
return nil, nil, nil, {
makeError(
"invalid_canonical_run_contract",
"$.runState",
"내부 canonical battleReady 진행 상태가 필수 postcondition을 만족하지 않습니다."
),
}
end
return runState, canonicalSetup, {
battleId = battleSpec.battleId,
seed = battleSpec.seed,
playerCardIds = battleSpec.playerCardIds,
characterId = battleSpec.characterId,
}, nil
end
local function latestRunSession(runState)
local sessions = type(runState) == "table" and runState.sessions or nil
if type(sessions) ~= "table" then return nil end
return sessions[#sessions]
end
local function summaryMatchesRunSession(summary, session)
return type(summary) == "table"
and type(session) == "table"
and summary.battleId == session.battleId
and summary.turnId == session.turnId
and summary.characterId == session.characterId
and summary.status == session.status
and summary.reasonCode == session.reasonCode
and summary.turnNumber == session.turnNumber
and summary.turnLimit == session.turnLimit
and summary.finalStealth == session.finalStealth
and summary.finalResistance == session.finalResistance
and deepEqual(summary.transit, session.transit)
end
local function validateRetiredBattle(current, runState, staticData)
local authority = current.authority
local session = latestRunSession(runState)
if type(authority) ~= "table"
or (authority.status ~= "victory" and authority.status ~= "defeat")
or type(authority.character) ~= "table"
or type(authority.player) ~= "table"
or type(session) ~= "table"
or authority.battleId ~= session.battleId
or authority.lastCommittedTurnId ~= session.turnId
or authority.character.characterId ~= session.characterId
or authority.status ~= session.status
or authority.turnNumber ~= session.turnNumber
or authority.turnLimit ~= session.turnLimit
or authority.player.stealth ~= session.finalStealth
or authority.character.resistance ~= session.finalResistance
or not deepEqual(authority.transit, session.transit) then
return {
makeError(
"unsettled_battle_runtime",
"$.state.authority",
"기존 종료 전투가 저장된 진행 정산 영수증과 일치하지 않습니다."
),
}
end
if current.aftermath ~= nil then
local aftermathErrors = validateAftermath(current.aftermath, authority)
if #aftermathErrors > 0 then return aftermathErrors end
if current.aftermath.phase ~= "complete" then
return {
makeError(
"aftermath_not_complete",
"$.state.aftermath",
"승리 후 자유행동이 끝나기 전에는 전투를 퇴역시킬 수 없습니다."
),
}
end
end
if current.lastCommittedPending ~= nil then
local summary, summaryErrors = buildTerminalSummary(
authority,
current.lastCommittedPending,
staticData
)
if summaryErrors then return summaryErrors end
if not summaryMatchesRunSession(summary, session) then
return {
makeError(
"settlement_receipt_mismatch",
"$.runState.sessions",
"종료 턴 공개 영수증과 진행 정산 기록이 일치하지 않습니다."
),
}
end
elseif current.draft ~= nil
or current.pending ~= nil
or current.activeRequest ~= nil
or current.submission ~= nil
or current.aftermath ~= nil then
return {
makeError(
"unsafe_retirement_partial",
"$.state",
"종료 영수증이 사라진 부분 정리 상태에 다른 전투 보조 상태가 남아 있습니다."
),
}
end
return nil
end
local function clearRetiredRuntimeAuxiliary()
for _, name in ipairs({
"draft",
"pending",
"activeRequest",
"submission",
"aftermath",
"lastCommittedPending",
}) do
local writeErrors = writeStored(KEYS[name], nil)
if writeErrors then return writeErrors end
end
return nil
end
local function startFromRun(runState, setupState, canonicalInput)
local staticData, staticErrors = loadStaticData()
if staticErrors then return failure(staticErrors) end
local canonicalRun, canonicalSetup, spec, runErrors
if canonicalInput == true then
canonicalRun, canonicalSetup, spec, runErrors =
inspectCanonicalBattleReadyRun(runState, setupState)
else
canonicalRun, canonicalSetup, spec, runErrors =
validateBattleReadyRun(runState, setupState, staticData)
end
if runErrors then return failure(runErrors) end
local current, currentErrors = readRuntimeBundle()
if currentErrors then return failure(currentErrors) end
local retired = false
if current.authority ~= nil and current.authority.battleId ~= spec.battleId then
local retirementErrors = validateRetiredBattle(
current,
canonicalRun,
staticData
)
if retirementErrors then return failure(retirementErrors) end
local clearErrors = clearRetiredRuntimeAuxiliary()
if clearErrors then return failure(clearErrors) end
current.draft = nil
current.pending = nil
current.activeRequest = nil
current.submission = nil
current.lastCommittedPending = nil
current.aftermath = nil
retired = true
end
local expected, expectedErrors = buildInitialBattleFromSetup(spec, staticData)
if expectedErrors then return failure(expectedErrors) end
if current.authority ~= nil and current.authority.battleId == spec.battleId then
local bindingErrors = validateExistingSetupBinding(
current.authority,
spec,
staticData
)
if bindingErrors then return failure(bindingErrors) end
if current.authority.status ~= "active" then
return failure({
makeError(
"battle_already_terminal",
"$.state.authority.status",
"종료된 현재 전투를 먼저 정산해야 다음 상태를 게시할 수 있습니다."
),
})
end
local looksLikeInitialPartial = deepEqual(
current.authority,
expected.authority
)
and current.draft == nil
and current.pending == nil
and current.lastCommittedPending == nil
and current.activeRequest == nil
and current.submission == nil
and current.aftermath == nil
if not looksLikeInitialPartial then
local published, publishErrors = publishCurrentViewInternal(
staticData,
true
)
if publishErrors then return failure(publishErrors) end
return success({
applied = false,
reused = true,
recovered = false,
battleId = current.authority.battleId,
turnNumber = current.authority.turnNumber,
setupId = canonicalSetup.setupId,
view = published.view,
})
end
end
for _, name in ipairs({
"authority",
"draft",
"pending",
"lastCommittedPending",
"activeRequest",
"submission",
"aftermath",
}) do
local existing = current[name]
if name == "authority"
and retired
and type(existing) == "table"
and existing.battleId ~= spec.battleId then
existing = nil
end
if existing ~= nil and not deepEqual(existing, expected[name]) then
return failure({
makeError(
"unsafe_partial_battle_runtime",
"$.state[" .. string.format("%q", KEYS[name]) .. "]",
"기존 부분 전투 상태가 다음 전투 사양에서 재생한 초기 상태와 일치하지 않습니다."
),
})
end
end
local recovered = retired
or current.authority ~= nil
or current.draft ~= nil
or current.pending ~= nil
or current.lastCommittedPending ~= nil
or current.activeRequest ~= nil
or current.submission ~= nil
or current.aftermath ~= nil
local writeErrors = writeInitialRuntime(expected)
if writeErrors then return failure(writeErrors) end
local published, publishErrors = publishCurrentViewInternal(
staticData,
true
)
if publishErrors then return failure(publishErrors) end
return success({
applied = true,
reused = false,
recovered = recovered,
battleId = expected.authority.battleId,
turnId = expected.turnId,
turnNumber = expected.authority.turnNumber,
setupId = canonicalSetup.setupId,
view = published.view,
})
end
local function startVerticalSlice(battleId, seed)
local staticData, staticErrors = loadStaticData()
if staticErrors then
return failure(staticErrors)
end
local bootstrap, bootstrapErrors = callModule(
"battleBootstrap",
"verticalSlice",
{ battleId = battleId, seed = seed },
staticData
)
if bootstrapErrors then
return failure(bootstrapErrors)
end
if bootstrap.referencesValidated ~= true or type(bootstrap.state) ~= "table" then
return failure({
makeError("invalid_bootstrap_result", "$.runtime.battleBootstrap", "bootstrap이 검증된 battleState를 반환하지 않았습니다."),
})
end
local turnId, turnIdErrors = makeTurnId(bootstrap.state)
if turnIdErrors then
return failure(turnIdErrors)
end
local initialized, initializeErrors = callModule(
"turnInitializer",
"prepareTurn",
bootstrap.state,
staticData,
{ turnId = turnId }
)
if initializeErrors then
return failure(initializeErrors)
end
if type(initialized.state) ~= "table" or type(initialized.draft) ~= "table" then
return failure({
makeError("invalid_initial_turn", "$.runtime.turnInitializer", "첫 턴 초기화 상태와 draft가 없습니다."),
})
end
for _, write in ipairs({
{ KEYS.authority, initialized.state },
{ KEYS.draft, initialized.draft },
{ KEYS.pending, nil },
{ KEYS.lastCommittedPending, nil },
{ KEYS.activeRequest, nil },
{ KEYS.submission, nil },
{ KEYS.aftermath, nil },
}) do
local writeErrors = writeStored(write[1], write[2])
if writeErrors then
return failure(writeErrors)
end
end
local published, publishErrors = publishCurrentViewInternal(staticData)
if publishErrors then
return failure(publishErrors)
end
return success({
battleId = initialized.state.battleId,
turnId = turnId,
turnNumber = initialized.state.turnNumber,
view = published.view,
})
end
local function interactCard(interactionAction, instanceId, expectedInteractionToken, choiceId)
if interactionAction ~= "click"
and interactionAction ~= "register"
and interactionAction ~= "cancel"
and interactionAction ~= "choose" then
return failure({
makeError(
"invalid_interaction_action",
"$.interactionAction",
"카드 상호작용 작업은 click, register, cancel, choose 중 하나여야 합니다."
),
})
end
local staticData, staticErrors = loadStaticData()
if staticErrors then
return failure(staticErrors)
end
local authority, authorityErrors = readStored(KEYS.authority, true)
if authorityErrors then
return failure(authorityErrors)
end
local pending, pendingErrors = readStored(KEYS.pending, false)
if pendingErrors then
return failure(pendingErrors)
end
if pending ~= nil then
return failure({
makeError("battle_view_locked", "$.pendingTurn", "출력 대기 중에는 카드 선택을 변경할 수 없습니다."),
})
end
local activeRequest, requestErrors = readStored(KEYS.activeRequest, false)
if requestErrors then
return failure(requestErrors)
end
if activeRequest ~= nil then
local activeErrors = validateBinding(activeRequest, nil)
if #activeErrors > 0 then
return failure(activeErrors)
end
if activeRequest.phase == "preparing"
or activeRequest.phase == "inFlight"
or activeRequest.phase == "requestInjected" then
return failure({
makeError("battle_view_locked", "$.activeRequest.phase", "생성 요청 처리 중에는 카드 선택을 변경할 수 없습니다."),
})
end
end
if not isRuntimeId(instanceId) then
return failure({
makeError("invalid_instance_id", "$.instanceId", "카드 인스턴스 ID가 올바르지 않습니다."),
})
end
if type(expectedInteractionToken) ~= "string" or expectedInteractionToken == "" then
return failure({
makeError("invalid_interaction_token", "$.expectedInteractionToken", "비어 있지 않은 draft interaction token이 필요합니다."),
})
end
if interactionAction == "choose"
and (type(choiceId) ~= "string" or string.match(choiceId, "^[a-z][a-z0-9_]*$") == nil) then
return failure({ makeError("invalid_effect_choice_id", "$.choiceId", "효과 선택지 ID가 올바르지 않습니다.") })
end
local draft, draftErrors = readStored(KEYS.draft, true)
if draftErrors then
return failure(draftErrors)
end
local interacted, interactionErrors = callModule(
"turnDraft",
"applyInteraction",
authority,
staticData,
draft,
{
action = interactionAction,
instanceId = instanceId,
choiceId = choiceId,
expectedInteractionToken = expectedInteractionToken,
}
)
if interactionErrors then
return failure(interactionErrors)
end
if type(interacted.draft) ~= "table"
or type(interacted.interactionToken) ~= "string"
or interacted.interactionToken == ""
or type(interacted.applied) ~= "boolean"
or type(interacted.stale) ~= "boolean"
or interacted.interactionAction ~= interactionAction then
return failure({
makeError(
"invalid_interaction_result",
"$.runtime.turnDraft.applyInteraction",
"검증된 카드 상호작용 결과와 다음 interaction token이 없습니다."
),
})
end
if interacted.stale then
if interacted.applied then
return failure({
makeError(
"invalid_stale_interaction_result",
"$.runtime.turnDraft.applyInteraction",
"stale 카드 상호작용은 전이를 적용할 수 없습니다."
),
})
end
-- risu-btn host가 클릭 message를 자동 remount하므로 수동
-- refresh를 중복하지 않는다.
local published, publishErrors = publishCurrentViewInternal(staticData, true, false, true)
if publishErrors then
return failure(publishErrors)
end
if published.view.interactionToken ~= interacted.interactionToken then
return failure({
makeError("view_interaction_token_mismatch", "$.view.interactionToken", "재게시 View가 현재 draft interaction token과 일치하지 않습니다."),
})
end
return success({
applied = false,
stale = true,
interactionAction = interactionAction,
interactionToken = interacted.interactionToken,
draft = interacted.draft,
view = published.view,
})
end
if interacted.applied then
local writeErrors = writeStored(KEYS.draft, interacted.draft)
if writeErrors then
return failure(writeErrors)
end
local submissionWriteErrors = writeStored(
KEYS.submission,
interacted.interactionToken
)
if submissionWriteErrors then return failure(submissionWriteErrors) end
end
local published, publishErrors = publishCurrentViewInternal(staticData, true, false, true)
if publishErrors then
return failure(publishErrors)
end
if published.view.interactionToken ~= interacted.interactionToken then
return failure({
makeError("view_interaction_token_mismatch", "$.view.interactionToken", "카드 전이 View가 계산된 다음 interaction token과 일치하지 않습니다."),
})
end
return success({
applied = interacted.applied,
stale = false,
interactionAction = interactionAction,
interactionToken = interacted.interactionToken,
draft = interacted.draft,
view = published.view,
})
end
local function clickCard(instanceId, expectedInteractionToken)
return interactCard("click", instanceId, expectedInteractionToken)
end
local function registerCard(instanceId, expectedInteractionToken)
return interactCard("register", instanceId, expectedInteractionToken)
end
local function cancelCard(instanceId, expectedInteractionToken)
return interactCard("cancel", instanceId, expectedInteractionToken)
end
local function selectCardEffect(instanceId, choiceId, expectedInteractionToken)
return interactCard("choose", instanceId, expectedInteractionToken, choiceId)
end
local function armSubmission(expectedInteractionToken)
if type(expectedInteractionToken) ~= "string" or expectedInteractionToken == "" then
return failure({
makeError("invalid_interaction_token", "$.expectedInteractionToken", "비어 있지 않은 draft interaction token이 필요합니다."),
})
end
local staticData, staticErrors = loadStaticData()
if staticErrors then return failure(staticErrors) end
local authority, authorityErrors = readStored(KEYS.authority, true)
if authorityErrors then return failure(authorityErrors) end
local pending, pendingErrors = readStored(KEYS.pending, false)
if pendingErrors then return failure(pendingErrors) end
if pending ~= nil then
return failure({
makeError("battle_view_locked", "$.pendingTurn", "출력 대기 중에는 턴 제출을 다시 준비할 수 없습니다."),
})
end
local activeRequest, requestErrors = readStored(KEYS.activeRequest, false)
if requestErrors then return failure(requestErrors) end
if type(activeRequest) == "table" then
local activeErrors = validateBinding(activeRequest, nil)
if #activeErrors > 0 then return failure(activeErrors) end
if activeRequest.phase ~= "committed" then
return failure({
makeError("battle_view_locked", "$.activeRequest.phase", "생성 요청 처리 중에는 턴 제출을 다시 준비할 수 없습니다."),
})
end
end
local draft, draftErrors = readStored(KEYS.draft, true)
if draftErrors then return failure(draftErrors) end
local interactionToken, tokenErrors = inspectDraftInteractionToken(
authority,
staticData,
draft
)
if tokenErrors then return failure(tokenErrors) end
if interactionToken ~= expectedInteractionToken then
local published, publishErrors = publishCurrentViewInternal(
staticData,
true,
false,
true
)
if publishErrors then return failure(publishErrors) end
return success({
applied = false,
stale = true,
interactionToken = interactionToken,
view = published.view,
})
end
local writeErrors = writeStored(KEYS.submission, interactionToken)
if writeErrors then return failure(writeErrors) end
local published, publishErrors = publishCurrentViewInternal(
staticData,
true,
false,
true
)
if publishErrors then return failure(publishErrors) end
return success({
applied = true,
stale = false,
interactionToken = interactionToken,
view = published.view,
})
end
local loadBoundPending
local commitOutput
local function loadAndValidateBoundRequest(binding, staticData)
local pending, pendingErrors = loadBoundPending(binding)
if pendingErrors then return nil, nil, pendingErrors end
local formatted, formatErrors = formatPending(pending, staticData)
if formatErrors then return nil, nil, formatErrors end
if binding.publicMarker ~= formatted.publicMarker
or not deepEqual(binding.message, formatted.message) then
return nil, nil, {
makeError("active_request_prompt_mismatch", "$.activeRequest", "복구할 요청 binding이 pendingTurn에서 다시 만든 프롬프트와 다릅니다."),
}
end
return pending, formatted, nil
end
local function validateNoPendingCommitTrace(binding, authority)
if binding.source ~= "pending" then return nil end
local lastCommitted, lastErrors = readStored(KEYS.lastCommittedPending, false)
if lastErrors then return lastErrors end
if authority.lastCommittedTurnId == binding.turnId
or (type(lastCommitted) == "table" and lastCommitted.turnId == binding.turnId) then
return {
makeError("commit_trace_without_output_receipt", "$.activeRequest", "현재 턴의 commit 흔적이 있어 출력 관측 영수증 없이 요청을 재시도할 수 없습니다."),
}
end
return nil
end
local function beginRecoveringCleanup(binding, chat, staticData, authority)
local pending, _, boundErrors = loadAndValidateBoundRequest(binding, staticData)
if boundErrors then return nil, nil, nil, boundErrors end
local topology, topologyErrors = inspectAnchoredTopology(binding, chat, true)
if topologyErrors then return nil, nil, nil, topologyErrors end
local mode = binding.outputObserved ~= nil and "resumeCommit" or "retry"
if mode == "resumeCommit" then
if not topology.responsePresent
or topology.responseIndex ~= binding.outputObserved.responseIndex
or not fingerprintsEqual(topology.responseFingerprint, binding.outputObserved.responseFingerprint) then
return nil, nil, nil, {
makeError("observed_output_mismatch", "$.chat", "완성 출력 복구 대상이 출력 관측 영수증과 다릅니다."),
}
end
else
local traceErrors = validateNoPendingCommitTrace(binding, authority)
if traceErrors then return nil, nil, nil, traceErrors end
end
local nextBinding, cloneError = cloneJson(binding, "$.activeRequest")
if cloneError then return nil, nil, nil, { cloneError } end
nextBinding.recoveringCleanup = {
schemaVersion = 1,
kind = "battleRecoveringCleanup",
mode = mode,
originalPhase = binding.phase,
attemptNumber = binding.attemptNumber,
responseIndex = topology.responseIndex,
responsePresent = topology.responsePresent,
responseFingerprint = topology.responseFingerprint,
initialFillerCount = topology.fillerCount,
}
local validationErrors = validateBinding(nextBinding, pending)
if #validationErrors > 0 then return nil, nil, nil, validationErrors end
local writeErrors = writeStored(KEYS.activeRequest, nextBinding, true)
if writeErrors then return nil, nil, nil, writeErrors end
return nextBinding, pending, topology, nil
end
local function resumeRecoveringCleanup(binding, chat)
local receipt = binding.recoveringCleanup
local topology, topologyErrors = inspectAnchoredTopology(binding, chat, false)
if topologyErrors then return nil, nil, nil, topologyErrors end
if receipt.responsePresent then
if topology.responsePresent
and (topology.responseIndex ~= receipt.responseIndex
or not fingerprintsEqual(topology.responseFingerprint, receipt.responseFingerprint)) then
return nil, nil, nil, {
makeError("cleanup_response_mismatch", "$.chat", "현재 미확정 응답이 복구 정리 영수증과 다릅니다."),
}
end
elseif topology.responsePresent then
return nil, nil, nil, {
makeError("unexpected_cleanup_response", "$.chat", "응답이 없었던 복구 정리에 새 캐릭터 메시지가 나타났습니다."),
}
end
local nextChat, removedFillers, fillerErrors = removeTrailingSayNothing(chat)
if fillerErrors then return nil, nil, nil, fillerErrors end
local removedResponse = false
if receipt.mode == "retry" and receipt.responsePresent then
local afterFillerTopology, afterFillerErrors = inspectAnchoredTopology(binding, nextChat, false)
if afterFillerErrors then return nil, nil, nil, afterFillerErrors end
if afterFillerTopology.responsePresent then
local afterRemoval, removeErrors = removeRecoveryResponse(
nextChat,
afterFillerTopology.responseLuaIndex,
receipt.responseFingerprint
)
if removeErrors then return nil, nil, nil, removeErrors end
nextChat = afterRemoval
removedResponse = true
end
end
local finalTopology, finalErrors = inspectAnchoredTopology(binding, nextChat, false)
if finalErrors then return nil, nil, nil, finalErrors end
if receipt.mode == "retry" and finalTopology.responsePresent then
return nil, nil, nil, {
makeError("cleanup_response_remains", "$.chat", "삭제 재시도 정리 뒤 미확정 응답이 남아 있습니다."),
}
end
if receipt.mode == "resumeCommit" then
if not finalTopology.responsePresent
or finalTopology.responseIndex ~= binding.outputObserved.responseIndex
or not fingerprintsEqual(finalTopology.responseFingerprint, binding.outputObserved.responseFingerprint) then
return nil, nil, nil, {
makeError("observed_output_mismatch", "$.chat", "commit 재개 전에 완성 응답이 출력 관측 영수증과 달라졌습니다."),
}
end
end
return nextChat, removedFillers, removedResponse, nil
end
local function retryWithoutOutput(binding, chat, staticData, authority)
if binding.outputObserved ~= nil or binding.recoveringCleanup ~= nil then
return failure({
makeError("zero_output_retry_has_receipt", "$.activeRequest", "출력 또는 정리 영수증이 있는 요청을 무출력 재시도로 되돌릴 수 없습니다."),
})
end
local pending, _, boundErrors = loadAndValidateBoundRequest(binding, staticData)
if boundErrors then return failure(boundErrors) end
local topology, topologyErrors = inspectAnchoredTopology(binding, chat, false)
if topologyErrors then return failure(topologyErrors) end
if topology.responsePresent or topology.fillerCount ~= 0 then
return failure({
makeError("zero_output_retry_topology_mismatch", "$.chat", "무출력 재시도에는 요청 응답 위치가 완전히 비어 있어야 합니다."),
})
end
local traceErrors = validateNoPendingCommitTrace(binding, authority)
if traceErrors then return failure(traceErrors) end
local nextBinding, cloneError = cloneJson(binding, "$.activeRequest")
if cloneError then return failure({ cloneError }) end
nextBinding.phase = "inFlight"
nextBinding.attemptNumber = nextBinding.attemptNumber + 1
local validationErrors = validateBinding(nextBinding, pending)
if #validationErrors > 0 then return failure(validationErrors) end
-- The visible View is already locked and does not expose attemptNumber.
-- Publish it before the sole state mutation so a publication failure
-- cannot consume a retry attempt.
local published, publishErrors = publishCurrentViewInternal(staticData)
if publishErrors then return failure(publishErrors) end
local writeErrors = writeStored(KEYS.activeRequest, nextBinding, true)
if writeErrors then return failure(writeErrors) end
return success({
generationReady = true,
recoveredAbandonedRequest = true,
zeroOutputRetry = true,
commitRecovered = false,
turnId = nextBinding.turnId,
turnNumber = nextBinding.turnNumber,
source = nextBinding.source,
publicMarker = nextBinding.publicMarker,
attemptNumber = nextBinding.attemptNumber,
reused = true,
removedSayNothing = false,
removedSayNothingCount = 0,
removedUncommittedOutput = false,
markerAdded = false,
view = published.view,
})
end
local function recoverLockedRequest(binding, chat, staticData, authority)
local workingBinding = binding
local pending
if workingBinding.recoveringCleanup == nil then
local topology
local beginErrors
workingBinding, pending, topology, beginErrors = beginRecoveringCleanup(
workingBinding,
chat,
staticData,
authority
)
if beginErrors then return failure(beginErrors) end
else
local boundErrors
pending, _, boundErrors = loadAndValidateBoundRequest(workingBinding, staticData)
if boundErrors then return failure(boundErrors) end
end
local cleanedChat, removedFillers, removedResponse, cleanupErrors = resumeRecoveringCleanup(
workingBinding,
chat
)
if cleanupErrors then return failure(cleanupErrors) end
if workingBinding.recoveringCleanup.mode == "resumeCommit" then
local committed = commitOutput()
if type(committed) ~= "table" or committed.ok ~= true then return committed end
committed.generationReady = false
committed.commitRecovered = true
committed.zeroOutputRetry = false
committed.removedSayNothing = removedFillers > 0
committed.removedSayNothingCount = removedFillers
committed.removedUncommittedOutput = false
return committed
end
workingBinding.phase = "inFlight"
workingBinding.attemptNumber = workingBinding.attemptNumber + 1
workingBinding.outputObserved = nil
workingBinding.recoveringCleanup = nil
local validationErrors = validateBinding(workingBinding, pending)
if #validationErrors > 0 then return failure(validationErrors) end
local writeErrors = writeStored(KEYS.activeRequest, workingBinding, true)
if writeErrors then return failure(writeErrors) end
local published, publishErrors = publishCurrentViewInternal(staticData)
if publishErrors then return failure(publishErrors) end
return success({
generationReady = true,
recoveredAbandonedRequest = true,
zeroOutputRetry = false,
commitRecovered = false,
turnId = workingBinding.turnId,
turnNumber = workingBinding.turnNumber,
source = workingBinding.source,
publicMarker = workingBinding.publicMarker,
attemptNumber = workingBinding.attemptNumber,
reused = true,
removedSayNothing = removedFillers > 0,
removedSayNothingCount = removedFillers,
removedUncommittedOutput = removedResponse,
markerAdded = false,
view = published.view,
})
end
local function retryCommittedOutput(binding, chat, staticData)
local repairedChat, repairedTail, repairErrors = restoreRepairableAnchorTail(
binding,
chat
)
if repairErrors then return failure(repairErrors) end
local topology, topologyErrors = inspectAnchoredTopology(
binding,
repairedChat,
false
)
if topologyErrors then return failure(topologyErrors) end
if topology.responsePresent or topology.fillerCount ~= 0 then
return failure({
makeError("committed_reroll_topology_mismatch", "$.chat", "확정 응답 리롤 뒤 응답 위치가 비어 있지 않습니다."),
})
end
local pending, _, boundErrors = loadAndValidateBoundRequest(binding, staticData)
if boundErrors then return failure(boundErrors) end
local retryChat, markerAdded, boundaryErrors = ensureTurnBoundary(repairedChat)
if boundaryErrors then return failure(boundaryErrors) end
local nextBinding, cloneError = cloneJson(binding, "$.activeRequest")
if cloneError then return failure({ cloneError }) end
if markerAdded then
local anchor, anchorErrors = createChatAnchor(retryChat, #retryChat)
if anchorErrors then return failure(anchorErrors) end
nextBinding.chatAnchor = anchor
end
nextBinding.phase = "inFlight"
nextBinding.attemptNumber = nextBinding.attemptNumber + 1
nextBinding.outputObserved = nil
nextBinding.recoveringCleanup = nil
local validationErrors = validateBinding(nextBinding, pending)
if #validationErrors > 0 then return failure(validationErrors) end
local submissionClearErrors = clearSubmission()
if submissionClearErrors then return failure(submissionClearErrors) end
local writeErrors = writeStored(KEYS.activeRequest, nextBinding, true)
if writeErrors then return failure(writeErrors) end
local published, publishErrors = publishCurrentViewInternal(staticData)
if publishErrors then return failure(publishErrors) end
return success({
generationReady = true,
rerolledCommittedOutput = true,
repairedStoryTail = repairedTail,
recoveredAbandonedRequest = false,
zeroOutputRetry = false,
commitRecovered = false,
turnId = nextBinding.turnId,
turnNumber = nextBinding.turnNumber,
source = nextBinding.source,
publicMarker = nextBinding.publicMarker,
attemptNumber = nextBinding.attemptNumber,
reused = true,
removedSayNothing = false,
removedSayNothingCount = 0,
removedUncommittedOutput = false,
markerAdded = markerAdded,
view = published.view,
})
end
local function prepareGeneration()
local staticData, staticErrors = loadStaticData()
if staticErrors then return failure(staticErrors) end
local authority, authorityErrors = readStored(KEYS.authority, true)
if authorityErrors then return failure(authorityErrors) end
local aftermath, aftermathReadErrors = readStored(KEYS.aftermath, false)
if aftermathReadErrors then return failure(aftermathReadErrors) end
if aftermath ~= nil then
local aftermathErrors = validateAftermath(aftermath, authority)
if #aftermathErrors > 0 then return failure(aftermathErrors) end
local migrated, migrationErrors = migrateLegacyAftermath(authority, aftermath)
if migrationErrors then return failure(migrationErrors) end
aftermath = migrated
return prepareAftermathGeneration(authority, aftermath, staticData)
end
local chat, chatErrors = readChat()
if chatErrors then return failure(chatErrors) end
local removedCount = 0
local markerAdded = false
local storedBinding, storedBindingErrors = readStored(KEYS.activeRequest, false)
if storedBindingErrors then return failure(storedBindingErrors) end
if storedBinding ~= nil then
local storedBindingValidationErrors = validateBinding(storedBinding, nil)
if #storedBindingValidationErrors > 0 then return failure(storedBindingValidationErrors) end
if storedBinding.phase == "committed" then
local stalePending, stalePendingErrors = readStored(KEYS.pending, false)
if stalePendingErrors then return failure(stalePendingErrors) end
if type(stalePending) == "table" and stalePending.turnId == storedBinding.turnId then
local cleanupCommit = commitOutput()
if type(cleanupCommit) ~= "table" or cleanupCommit.ok ~= true then return cleanupCommit end
authority, authorityErrors = readStored(KEYS.authority, true)
if authorityErrors then return failure(authorityErrors) end
chat, chatErrors = readChat()
if chatErrors then return failure(chatErrors) end
chat, removedCount, chatErrors = removeTrailingSayNothing(chat)
if chatErrors then return failure(chatErrors) end
storedBinding, storedBindingErrors = readStored(KEYS.activeRequest, true)
if storedBindingErrors then return failure(storedBindingErrors) end
end
end
if storedBinding.phase == "committed" then
local committedChat, repairedTail, repairErrors = restoreRepairableAnchorTail(
storedBinding,
chat
)
if repairErrors then return failure(repairErrors) end
chat = committedChat
local committedTopology, committedTopologyErrors = inspectAnchoredTopology(
storedBinding,
chat,
false
)
if committedTopologyErrors then return failure(committedTopologyErrors) end
if not committedTopology.responsePresent then
if committedTopology.fillerCount > 0 then
chat, removedCount, chatErrors = removeTrailingSayNothing(chat)
if chatErrors then return failure(chatErrors) end
end
local retried = retryCommittedOutput(
storedBinding,
chat,
staticData
)
if type(retried) == "table" and retried.ok == true and repairedTail then
retried.repairedStoryTail = true
end
return retried
end
end
if storedBinding.phase == "inFlight" or storedBinding.phase == "requestInjected" then
if storedBinding.recoveringCleanup == nil then
local topology, topologyErrors = inspectAnchoredTopology(storedBinding, chat, false)
if topologyErrors then return failure(topologyErrors) end
if storedBinding.outputObserved == nil
and not topology.responsePresent
and topology.fillerCount == 0 then
return retryWithoutOutput(storedBinding, chat, staticData, authority)
end
if storedBinding.outputObserved ~= nil
and topology.responsePresent
and topology.fillerCount == 0 then
local committed = commitOutput()
if type(committed) ~= "table" or committed.ok ~= true then return committed end
committed.generationReady = false
committed.commitRecovered = true
committed.zeroOutputRetry = false
committed.removedSayNothing = false
committed.removedSayNothingCount = 0
committed.removedUncommittedOutput = false
return committed
end
if topology.fillerCount == 0 then
return failure({
makeError(
"request_already_in_flight",
"$.activeRequest.phase",
"이미 생성 중이거나 프롬프트 주입을 마친 요청이 있습니다. 응답을 리롤한 뒤 다시 시도하세요."
),
})
end
end
return recoverLockedRequest(storedBinding, chat, staticData, authority)
end
end
chat, removedCount, chatErrors = removeTrailingSayNothing(chat)
if chatErrors then return failure(chatErrors) end
local selectedPending
local sourceName
local reused = false
local recoveryBinding
local pending, pendingErrors = readStored(KEYS.pending, false)
if pendingErrors then return failure(pendingErrors) end
if type(storedBinding) == "table" and storedBinding.phase == "preparing" then
local boundPending, boundPendingErrors = loadBoundPending(storedBinding)
if boundPendingErrors then
return failure(boundPendingErrors)
end
selectedPending = boundPending
sourceName = storedBinding.source
recoveryBinding = storedBinding
reused = true
elseif pending ~= nil then
local reuse, reuseErrors = callModule(
"battleRuntime",
"reusePending",
authority,
staticData,
pending
)
if reuseErrors then return failure(reuseErrors) end
selectedPending = reuse.pendingTurn
sourceName = "pending"
reused = true
else
local draft, draftErrors = readStored(KEYS.draft, true)
if draftErrors then return failure(draftErrors) end
local submission, submissionErrors = readArmedSubmission(
authority,
staticData,
draft
)
if submissionErrors then return failure(submissionErrors) end
if submission ~= nil then
local projected, projectErrors = callModule(
"turnDraft",
"project",
authority,
staticData,
draft
)
if projectErrors then
return failure(projectErrors)
end
if type(projected.projection) ~= "table" then
return failure({
makeError("missing_turn_projection", "$.runtime.turnDraft.projection", "전송할 turnDraft projection이 없습니다."),
})
end
local prepared, prepareErrors = callModule(
"battleRuntime",
"preparePending",
authority,
staticData,
projected.projection
)
if prepareErrors then
return failure(prepareErrors)
end
selectedPending = prepared.pendingTurn
sourceName = "pending"
end
end
if selectedPending == nil then
if type(storedBinding) == "table" and storedBinding.phase == "committed" then
local published, publishErrors = publishCurrentViewInternal(staticData, true)
if publishErrors then return failure(publishErrors) end
return success({
generationReady = false,
idle = true,
uiTargetRequired = true,
uiTargetIndex = storedBinding.chatAnchor.responseIndex,
outputCommitted = false,
commitRecovered = false,
turnId = storedBinding.turnId,
turnNumber = storedBinding.turnNumber,
source = storedBinding.source,
publicMarker = storedBinding.publicMarker,
attemptNumber = storedBinding.attemptNumber,
reused = true,
removedSayNothing = removedCount > 0,
removedSayNothingCount = removedCount,
removedUncommittedOutput = false,
markerAdded = false,
view = published.view,
})
end
return success({
generationReady = false,
idle = true,
removedSayNothing = removedCount > 0,
removedSayNothingCount = removedCount,
})
end
if type(selectedPending) ~= "table" then
return failure({
makeError("missing_selected_pending", "$.pendingTurn", "생성 요청에 연결할 pendingTurn이 없습니다."),
})
end
local formatted, formatErrors = formatPending(selectedPending, staticData)
if formatErrors then
return failure(formatErrors)
end
local binding
if recoveryBinding ~= nil then
if recoveryBinding.publicMarker ~= formatted.publicMarker
or not deepEqual(recoveryBinding.message, formatted.message) then
return failure({
makeError("active_request_prompt_mismatch", "$.activeRequest", "준비 중인 요청 binding이 pendingTurn에서 다시 만든 프롬프트와 다릅니다."),
})
end
binding = recoveryBinding
local topology, topologyErrors = inspectPreparingTopology(binding, chat)
if topologyErrors then return failure(topologyErrors) end
else
local boundaryErrors
chat, markerAdded, boundaryErrors = ensureTurnBoundary(chat)
if boundaryErrors then return failure(boundaryErrors) end
local chatAnchor, anchorErrors = createPlannedChatAnchor(chat)
if anchorErrors then return failure(anchorErrors) end
local bindingErrors
binding, bindingErrors = buildBinding(
selectedPending,
formatted,
sourceName,
"preparing",
chatAnchor,
1
)
if bindingErrors then
return failure(bindingErrors)
end
end
if sourceName == "pending" then
local pendingWriteErrors = writeStored(KEYS.pending, selectedPending)
if pendingWriteErrors then
return failure(pendingWriteErrors)
end
local draftClearErrors = writeStored(KEYS.draft, nil)
if draftClearErrors then
return failure(draftClearErrors)
end
end
local bindingWriteErrors = writeStored(KEYS.activeRequest, binding)
if bindingWriteErrors then
return failure(bindingWriteErrors)
end
local submissionClearErrors = clearSubmission()
if submissionClearErrors then return failure(submissionClearErrors) end
-- 생성 중에는 잠긴 canonical View만 영속한다. 전체 HTML/CBS 렌더는
-- 응답 commit 뒤 게시하므로 HTTP 요청 전 중복 평가하지 않는다.
local published, publishErrors = publishCurrentViewInternal(staticData, true, true)
if publishErrors then
return failure(publishErrors)
end
local finalTopology, finalTopologyErrors = inspectAnchoredTopology(binding, chat, false)
if finalTopologyErrors then return failure(finalTopologyErrors) end
if finalTopology.responsePresent or finalTopology.fillerCount ~= 0 then
return failure({
makeError("prepared_chat_topology_mismatch", "$.chat", "요청 준비 뒤 응답 위치에 예상하지 않은 메시지가 남아 있습니다."),
})
end
binding.phase = "inFlight"
binding.outputObserved = nil
binding.recoveringCleanup = nil
local finalBindingErrors = validateBinding(binding, selectedPending)
if #finalBindingErrors > 0 then return failure(finalBindingErrors) end
local readyWriteErrors = writeStored(KEYS.activeRequest, binding, true)
if readyWriteErrors then
return failure(readyWriteErrors)
end
return success({
generationReady = true,
turnId = binding.turnId,
turnNumber = binding.turnNumber,
source = binding.source,
publicMarker = binding.publicMarker,
reused = reused,
removedSayNothing = removedCount > 0,
removedSayNothingCount = removedCount,
markerAdded = markerAdded,
attemptNumber = binding.attemptNumber,
recoveredAbandonedRequest = false,
zeroOutputRetry = false,
commitRecovered = false,
removedUncommittedOutput = false,
view = published.view,
})
end
loadBoundPending = function(binding)
local bindingErrors = validateBinding(binding, nil)
if #bindingErrors > 0 then
return nil, bindingErrors
end
local key = binding.source == "pending" and KEYS.pending or KEYS.lastCommittedPending
local pending, pendingErrors = readStored(key, true)
if pendingErrors then
return nil, pendingErrors
end
local linkedErrors = validateBinding(binding, pending)
if #linkedErrors > 0 then
return nil, linkedErrors
end
return pending, nil
end
local function injectRequest(promptArray)
local authority, authorityErrors = readStored(KEYS.authority, true)
if authorityErrors then return failure(authorityErrors) end
local aftermath, aftermathReadErrors = readStored(KEYS.aftermath, false)
if aftermathReadErrors then return failure(aftermathReadErrors) end
if aftermath ~= nil then
local aftermathErrors = validateAftermath(aftermath, authority)
if #aftermathErrors > 0 then return failure(aftermathErrors) end
local migrated, migrationErrors = migrateLegacyAftermath(authority, aftermath)
if migrationErrors then return failure(migrationErrors) end
aftermath = migrated
return injectAftermathRequest(promptArray, authority, aftermath)
end
local promptCopy, cloneError = cloneJson(promptArray, "$.promptArray")
if cloneError then
return failure({ cloneError })
end
if type(promptCopy) ~= "table" then
return failure({
makeError("invalid_prompt_array", "$.promptArray", "editRequest 값은 메시지 배열이어야 합니다."),
})
end
local count = 0
for key, message in pairs(promptCopy) do
if type(key) ~= "number" or not isInteger(key, 1) or type(message) ~= "table" then
return failure({
makeError("invalid_prompt_array", "$.promptArray", "editRequest 값은 1부터 이어지는 메시지 객체 배열이어야 합니다."),
})
end
count = count + 1
end
if count ~= #promptCopy then
return failure({
makeError("invalid_prompt_array", "$.promptArray", "editRequest 메시지 배열에 빈 인덱스가 있습니다."),
})
end
local binding, bindingReadErrors = readStored(KEYS.activeRequest, true)
if bindingReadErrors then
return failure(bindingReadErrors)
end
local pending, pendingErrors = loadBoundPending(binding)
if pendingErrors then
return failure(pendingErrors)
end
if binding.phase ~= "inFlight" and binding.phase ~= "requestInjected" then
return failure({
makeError("request_not_in_flight", "$.activeRequest.phase", "editRequest에는 inFlight 또는 같은 requestInjected 요청 binding이 필요합니다."),
})
end
if binding.recoveringCleanup ~= nil then
return failure({
makeError("request_cleanup_in_progress", "$.activeRequest.recoveringCleanup", "복구 정리 중에는 프롬프트를 주입할 수 없습니다."),
})
end
if binding.outputObserved ~= nil then
return failure({
makeError("request_output_already_observed", "$.activeRequest.outputObserved", "이미 완성 출력이 관측된 요청에는 프롬프트를 다시 주입할 수 없습니다."),
})
end
local staticData, staticErrors = loadStaticData()
if staticErrors then
return failure(staticErrors)
end
local formatted, formatErrors = formatPending(pending, staticData)
if formatErrors then
return failure(formatErrors)
end
if binding.publicMarker ~= formatted.publicMarker or not deepEqual(binding.message, formatted.message) then
return failure({
makeError("active_request_prompt_mismatch", "$.activeRequest", "저장된 요청 binding이 pendingTurn에서 다시 만든 프롬프트와 다릅니다."),
})
end
local requestCue = {
role = "user",
content = formatted.publicMarker,
}
local systemCount = 0
local cueCount = 0
local normalizedPrompt = {}
for _, message in ipairs(promptCopy) do
if deepEqual(message, formatted.message) then
systemCount = systemCount + 1
elseif deepEqual(message, requestCue) then
cueCount = cueCount + 1
elseif message.role == "user" and message.content == TURN_SUBMIT_MARKER then
-- 이전 배포가 남긴 표시 전용 marker는 모델 요청에 포함하지 않는다.
else
normalizedPrompt[#normalizedPrompt + 1] = message
end
end
local alreadyInjected = systemCount >= 1 and cueCount >= 1
local deduplicated = systemCount > 1 or cueCount > 1
promptCopy = normalizedPrompt
local messageCopy, messageCloneError = cloneJson(formatted.message, "$.activeRequest.message")
if messageCloneError then
return failure({ messageCloneError })
end
local cueCopy, cueCloneError = cloneJson(requestCue, "$.activeRequest.publicMarker")
if cueCloneError then
return failure({ cueCloneError })
end
-- 확정 사건을 먼저 제공하고 장면 묘사 지시를 마지막 user 메시지로 둔다.
-- 두 메시지는 editRequest 결과에만 존재하며 실제 채팅에는 저장하지 않는다.
promptCopy[#promptCopy + 1] = messageCopy
promptCopy[#promptCopy + 1] = cueCopy
-- This durable phase is the authority boundary between editRequest and
-- onOutput. Without it, a host-side editRequest failure could still run
-- onOutput and commit a turn whose event/cue never reached the model.
if binding.phase == "inFlight" then
binding.phase = "requestInjected"
local receiptWriteErrors = writeStored(KEYS.activeRequest, binding, true)
if receiptWriteErrors then
return failure(receiptWriteErrors)
end
end
return success({
promptArray = promptCopy,
injected = not alreadyInjected,
deduplicated = deduplicated,
turnId = binding.turnId,
requestPhase = binding.phase,
})
end
local function prepareCurrentActiveTurn(state, staticData, allowExistingDraft)
if state.status ~= "active" then
return state, nil, false, nil, nil
end
if allowExistingDraft then
local currentDraft, draftReadErrors = readStored(KEYS.draft, false)
if draftReadErrors then
return nil, nil, false, nil, draftReadErrors
end
if currentDraft ~= nil then
local validated, validateErrors = callModule(
"turnDraft",
"validate",
state,
staticData,
currentDraft
)
if validateErrors then
return nil, nil, false, nil, validateErrors
end
return state, validated.draft, false, nil, nil
end
end
local turnId, turnIdErrors = makeTurnId(state)
if turnIdErrors then
return nil, nil, false, nil, turnIdErrors
end
local initialized, initializeErrors = callModule(
"turnInitializer",
"prepareTurn",
state,
staticData,
{ turnId = turnId }
)
if initializeErrors then
return nil, nil, false, nil, initializeErrors
end
if type(initialized.state) ~= "table" or type(initialized.draft) ~= "table" then
return nil, nil, false, nil, {
makeError("invalid_next_turn", "$.runtime.turnInitializer", "다음 활성 턴 상태와 draft가 없습니다."),
}
end
if initialized.state.turnStartOutcome ~= nil then
local projected, projectErrors = callModule(
"turnDraft",
"project",
initialized.state,
staticData,
initialized.draft
)
if projectErrors then return nil, nil, false, nil, projectErrors end
local prepared, prepareErrors = callModule(
"battleRuntime",
"preparePending",
initialized.state,
staticData,
projected.projection
)
if prepareErrors then return nil, nil, false, nil, prepareErrors end
local committed, commitErrors = callModule(
"battleRuntime",
"commitPending",
initialized.state,
staticData,
prepared.pendingTurn
)
if commitErrors then return nil, nil, false, nil, commitErrors end
return committed.state, nil, initialized.reused ~= true, prepared.pendingTurn, nil
end
return initialized.state, initialized.draft, initialized.reused ~= true, nil, nil
end
commitOutput = function()
local staticData, staticErrors = loadStaticData()
if staticErrors then
return failure(staticErrors)
end
local authority, authorityErrors = readStored(KEYS.authority, true)
if authorityErrors then
return failure(authorityErrors)
end
local aftermath, aftermathReadErrors = readStored(KEYS.aftermath, false)
if aftermathReadErrors then return failure(aftermathReadErrors) end
if aftermath ~= nil then
local aftermathErrors = validateAftermath(aftermath, authority)
if #aftermathErrors > 0 then return failure(aftermathErrors) end
local migrated, migrationErrors = migrateLegacyAftermath(authority, aftermath)
if migrationErrors then return failure(migrationErrors) end
aftermath = migrated
if aftermath.phase == "ready" then
local published, publishErrors = publishCurrentViewInternal(staticData, true)
if publishErrors then return failure(publishErrors) end
return success({
generationReady = false,
outputCommitted = true,
uiTargetIndex = aftermath.lastCommitted.responseLuaIndex - 1,
aftermathComplete = false,
status = authority.status,
view = published.view,
})
elseif aftermath.phase == "complete" then
return success({
generationReady = false,
outputCommitted = true,
uiTargetIndex = aftermath.lastCommitted.responseLuaIndex - 1,
aftermathComplete = true,
status = authority.status,
})
end
return commitAftermathOutput(authority, aftermath, staticData)
end
local binding, bindingErrors = readStored(KEYS.activeRequest, true)
if bindingErrors then
return failure(bindingErrors)
end
local bindingValidationErrors = validateBinding(binding, nil)
if #bindingValidationErrors > 0 then
return failure(bindingValidationErrors)
end
if binding.phase ~= "requestInjected" and binding.phase ~= "committed" then
return failure({
makeError("request_not_committable", "$.activeRequest.phase", "출력 확정에는 requestInjected 또는 이미 committed인 요청 binding이 필요합니다."),
})
end
if binding.recoveringCleanup ~= nil
and binding.recoveringCleanup.mode ~= "resumeCommit" then
return failure({
makeError("request_cleanup_in_progress", "$.activeRequest.recoveringCleanup", "미확정 출력 삭제 복구 중에는 출력을 확정할 수 없습니다."),
})
end
local selectedPending, pendingErrors = loadBoundPending(binding)
if pendingErrors then
return failure(pendingErrors)
end
local formatted, formatErrors = formatPending(selectedPending, staticData)
if formatErrors then
return failure(formatErrors)
end
if binding.publicMarker ~= formatted.publicMarker or not deepEqual(binding.message, formatted.message) then
return failure({
makeError("active_request_prompt_mismatch", "$.activeRequest", "출력과 연결된 prompt binding이 pendingTurn과 다릅니다."),
})
end
if binding.phase == "requestInjected" then
local chat, chatErrors = readChat()
if chatErrors then return failure(chatErrors) end
local topology, topologyErrors = inspectObservedOutput(binding, chat, false)
if topologyErrors then return failure(topologyErrors) end
if isRisuErrorResponse(chat[topology.responseLuaIndex]) then
return failure({
makeError("battle_output_error", "$.chat", "LLM 오류 응답은 전투 턴으로 확정할 수 없습니다."),
})
end
if binding.outputObserved == nil then
local observedBinding, cloneError = cloneJson(binding, "$.activeRequest")
if cloneError then return failure({ cloneError }) end
observedBinding.outputObserved = {
schemaVersion = 1,
kind = "battleOutputObserved",
attemptNumber = binding.attemptNumber,
responseIndex = topology.responseIndex,
responseFingerprint = topology.responseFingerprint,
}
local observedErrors = validateBinding(observedBinding, selectedPending)
if #observedErrors > 0 then return failure(observedErrors) end
local observedWriteErrors = writeStored(KEYS.activeRequest, observedBinding, true)
if observedWriteErrors then return failure(observedWriteErrors) end
binding = observedBinding
end
end
local committed, commitErrors = callModule(
"battleRuntime",
"commitPending",
authority,
staticData,
selectedPending
)
if commitErrors then
return failure(commitErrors)
end
if type(committed.state) ~= "table" or committed.turnId ~= binding.turnId then
return failure({
makeError("invalid_commit_result", "$.runtime.battleRuntime", "commit 결과가 활성 요청과 연결되지 않습니다."),
})
end
if binding.phase == "committed" and committed.applied == true then
return failure({
makeError("committed_request_reapplied", "$.activeRequest", "committed 요청이 새 상태 변경으로 다시 적용되었습니다."),
})
end
local nextState, nextDraft, initialized, turnStartPending, nextErrors = prepareCurrentActiveTurn(
committed.state,
staticData,
committed.applied ~= true
)
if nextErrors then
return failure(nextErrors)
end
local committedBinding, committedBindingErrors = buildBinding(
selectedPending,
formatted,
"lastCommittedPending",
"committed",
binding.chatAnchor,
binding.attemptNumber
)
if committedBindingErrors then
return failure(committedBindingErrors)
end
local committedBindingValidationErrors = validateBinding(committedBinding, selectedPending)
if #committedBindingValidationErrors > 0 then
return failure(committedBindingValidationErrors)
end
local committedPending = turnStartPending or selectedPending
local lastWriteErrors = writeStored(KEYS.lastCommittedPending, committedPending)
if lastWriteErrors then
return failure(lastWriteErrors)
end
local authorityWriteErrors = writeStored(KEYS.authority, nextState, true)
if authorityWriteErrors then
return failure(authorityWriteErrors)
end
local draftWriteErrors = writeStored(KEYS.draft, nextDraft)
if draftWriteErrors then
return failure(draftWriteErrors)
end
local bindingWriteErrors = writeStored(
KEYS.activeRequest,
turnStartPending == nil and committedBinding or nil,
true
)
if bindingWriteErrors then
return failure(bindingWriteErrors)
end
-- Move the binding first. If either write is silently dropped, a retry can
-- still locate the same turn through pending or lastCommittedPending.
local storedPending, storedPendingErrors = readStored(KEYS.pending, false)
if storedPendingErrors then
return failure(storedPendingErrors)
end
if type(storedPending) == "table" and storedPending.turnId == selectedPending.turnId then
local pendingClearErrors = writeStored(KEYS.pending, nil)
if pendingClearErrors then
return failure(pendingClearErrors)
end
end
-- 활성 전투는 다음 턴 View를, 종료 전투는 멱등 정산 뒤 결과/보상 View를
-- 게시한다. onOutput 훅이 완성 응답을 새 UI target으로 지정한다.
local published
local progressionState
if nextState.status == "active" then
local publishErrors
published, publishErrors = publishCurrentViewInternal(staticData, true)
if publishErrors then return failure(publishErrors) end
elseif nextState.status == "victory" then
local currentAftermath, aftermathErrors = readStored(KEYS.aftermath, false)
if aftermathErrors then return failure(aftermathErrors) end
if currentAftermath == nil then
local aftermathChat, chatErrors = readChat()
if chatErrors then return failure(chatErrors) end
local committedReceipt, receiptErrors = buildAftermathCommitted(
aftermathChat,
nextState.turnNumber,
#aftermathChat
)
if receiptErrors then return failure(receiptErrors) end
currentAftermath = {
schemaVersion = AFTERMATH_SCHEMA_VERSION,
kind = "battleAftermath",
battleId = nextState.battleId,
victoryTurnNumber = nextState.turnNumber,
completedTurnNumber = nextState.turnNumber,
phase = "ready",
lastCommitted = committedReceipt,
}
local validationErrors = validateAftermath(currentAftermath, nextState)
if #validationErrors > 0 then return failure(validationErrors) end
local writeErrors = writeStored(KEYS.aftermath, currentAftermath)
if writeErrors then return failure(writeErrors) end
else
local validationErrors = validateAftermath(currentAftermath, nextState)
if #validationErrors > 0 then return failure(validationErrors) end
end
local publishErrors
published, publishErrors = publishCurrentViewInternal(staticData, true)
if publishErrors then return failure(publishErrors) end
else
local summary, summaryErrors = buildTerminalSummary(
nextState,
committedPending,
staticData
)
if summaryErrors then return failure(summaryErrors) end
local _, battleLogErrors = publishTerminalBattleLog(nextState, staticData)
if battleLogErrors then return failure(battleLogErrors) end
local settled, settlementErrors = callModule(
"gameSetupController",
"completeBattle",
summary
)
if settlementErrors then return failure(settlementErrors) end
if type(settled.view) ~= "table" or type(settled.state) ~= "table" then
return failure({
makeError(
"invalid_settlement_result",
"$.runtime.gameSetupController.completeBattle",
"전투 정산이 진행 상태와 결과 View를 반환하지 않았습니다."
),
})
end
published = { view = settled.view }
progressionState = settled.state
end
return success({
generationReady = false,
outputCommitted = true,
uiTargetIndex = committedBinding.chatAnchor.responseIndex,
turnId = committedPending.turnId,
applied = committed.applied == true,
initializedNextTurn = initialized,
status = nextState.status,
turnNumber = nextState.turnNumber,
publicResult = committedPending.turnResult.publicResult,
view = published.view,
progressionState = progressionState,
})
end
local function getSnapshot()
local snapshot = {
keys = {
authority = KEYS.authority,
draft = KEYS.draft,
pending = KEYS.pending,
lastCommittedPending = KEYS.lastCommittedPending,
activeRequest = KEYS.activeRequest,
submission = KEYS.submission,
aftermath = KEYS.aftermath,
},
}
local authority, authorityErrors = readStored(KEYS.authority, false)
if authorityErrors then return failure(authorityErrors) end
local draft, draftErrors = readStored(KEYS.draft, false)
if draftErrors then return failure(draftErrors) end
local pending, pendingErrors = readStored(KEYS.pending, false)
if pendingErrors then return failure(pendingErrors) end
local lastCommitted, lastErrors = readStored(KEYS.lastCommittedPending, false)
if lastErrors then return failure(lastErrors) end
local activeRequest, requestErrors = readStored(KEYS.activeRequest, false)
if requestErrors then return failure(requestErrors) end
local submission, submissionErrors = readStored(KEYS.submission, false)
if submissionErrors then return failure(submissionErrors) end
local aftermath, aftermathErrors = readStored(KEYS.aftermath, false)
if aftermathErrors then return failure(aftermathErrors) end
snapshot.hasBattle = authority ~= nil
snapshot.authorityState = authority
snapshot.draft = draft
snapshot.pendingTurn = pending
snapshot.lastCommittedPending = lastCommitted
snapshot.activeRequest = activeRequest
snapshot.submission = submission
snapshot.aftermath = aftermath
if type(lastCommitted) == "table" and type(lastCommitted.turnResult) == "table" then
snapshot.lastPublicResult = lastCommitted.turnResult.publicResult
end
return success({ snapshot = snapshot })
end
local function publishCurrentView(readOnly)
local staticData, staticErrors = loadStaticData()
if staticErrors then
return failure(staticErrors)
end
local published, publishErrors = publishCurrentViewInternal(staticData, nil, nil, nil, readOnly)
if publishErrors then
return failure(publishErrors)
end
return success(published)
end
local arguments = { ... }
if action == "startVerticalSlice" then
return startVerticalSlice(arguments[1], arguments[2])
elseif action == "_startFromCanonicalSetup" then
if not allowsCanonicalHandoff(arguments[2], "battleControllerCanonicalSetupV1") then
return failure({
makeError("internal_action_denied", "$.action", "내부 canonical setup 인계 작업에 접근할 수 없습니다."),
})
end
return startFromSetup(arguments[1], true)
elseif action == "_startFromCanonicalRun" then
if not allowsCanonicalHandoff(arguments[3], "battleControllerCanonicalRunV1") then
return failure({
makeError("internal_action_denied", "$.action", "내부 canonical run 인계 작업에 접근할 수 없습니다."),
})
end
return startFromRun(arguments[1], arguments[2], true)
elseif action == "startFromSetup" then
return startFromSetup(arguments[1])
elseif action == "startFromRun" then
return startFromRun(arguments[1], arguments[2])
elseif action == "clickCard" then
return clickCard(arguments[1], arguments[2])
elseif action == "registerCard" then
return registerCard(arguments[1], arguments[2])
elseif action == "cancelCard" then
return cancelCard(arguments[1], arguments[2])
elseif action == "selectCardEffect" then
return selectCardEffect(arguments[1], arguments[2], arguments[3])
elseif action == "armSubmission" then
return armSubmission(arguments[1])
elseif action == "prepareGeneration" then
return prepareGeneration()
elseif action == "injectRequest" then
return injectRequest(arguments[1])
elseif action == "commitOutput" then
return commitOutput()
elseif action == "skipAftermath" then
return skipAftermath(arguments[1], arguments[2])
elseif action == "publishCurrentView" then
return publishCurrentView()
elseif action == "getRequestContext" then
local result = publishCurrentView(true)
if result.ok ~= true then return result end
local view = result.view
return success({ context = {
scene = view.scene,
line = view.subway.lineName,
currentStation = view.subway.currentStation.name,
startStation = view.subway.startStation.name,
destinationStation = view.subway.destinationStation.name,
} })
elseif action == "getSnapshot" then
return getSnapshot()
elseif action == "getTerminalSummary" then
return getTerminalSummary()
end
return failure({
makeError("unknown_action", "$.action", "지원하지 않는 battleController 작업입니다: " .. tostring(action)),
})
end)
#30battleHistory.lua
Keys:
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local HISTORY_KIND = "battleHistory"
local CONTEXT_KIND = "battleHistoryContext"
local MAX_TURNS = 12
local VALID_SIDE = {
player = true,
character = true,
}
local VALID_STATUS = {
active = true,
victory = true,
defeat = true,
}
local function makeError(code, path, message)
return {
code = code,
path = path,
message = message,
}
end
local function failure(errors)
return {
ok = false,
schemaVersion = SCHEMA_VERSION,
errors = errors,
}
end
local function success(fields)
local report = {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
}
for key, value in pairs(fields or {}) do
report[key] = value
end
return report
end
local function isFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function isInteger(value, minimum)
return isFinite(value)
and value % 1 == 0
and (minimum == nil or value >= minimum)
end
local function isAsciiId(value)
return type(value) == "string"
and string.match(value, "^[a-z][a-z0-9_]*$") ~= nil
end
local function isRuntimeId(value)
return type(value) == "string"
and string.match(value, "^[A-Za-z0-9][A-Za-z0-9_-]*$") ~= nil
end
local function isDenseArray(value)
if type(value) ~= "table" or getmetatable(value) ~= nil then
return false
end
local count = 0
local maximum = 0
for key in pairs(value) do
if not isInteger(key, 1) then
return false
end
count = count + 1
if key > maximum then maximum = key end
end
return count == maximum
end
local function cloneData(value, path, active)
local valueType = type(value)
if valueType == "nil" or valueType == "string" or valueType == "boolean" then
return value, nil
end
if valueType == "number" then
if not isFinite(value) then
return nil, makeError("non_finite_number", path, "전투 이력에는 유한한 숫자만 저장할 수 있습니다.")
end
return value, nil
end
if valueType ~= "table" or getmetatable(value) ~= nil then
return nil, makeError("unsupported_type", path, "전투 이력에는 JSON-safe 일반 테이블만 저장할 수 있습니다.")
end
active = active or {}
if active[value] then
return nil, makeError("circular_reference", path, "전투 이력에는 순환 참조를 저장할 수 없습니다.")
end
active[value] = true
local copy = {}
for key, item in pairs(value) do
local keyType = type(key)
if keyType ~= "string" and not isInteger(key, 1) then
active[value] = nil
return nil, makeError("invalid_key", path, "전투 이력 키는 문자열 또는 양의 배열 인덱스여야 합니다.")
end
local childPath = keyType == "number"
and (path .. "[" .. key .. "]")
or (path .. "." .. tostring(key))
local itemCopy, itemError = cloneData(item, childPath, active)
if itemError then
active[value] = nil
return nil, itemError
end
copy[key] = itemCopy
end
active[value] = nil
return copy, nil
end
local function dataEqual(left, right, seen)
if type(left) ~= type(right) then return false end
if type(left) ~= "table" then return left == right end
if getmetatable(left) ~= nil or getmetatable(right) ~= nil then return false end
seen = seen or {}
if seen[left] ~= nil then return seen[left] == right end
seen[left] = right
for key, value in pairs(left) do
if not dataEqual(value, right[key], seen) then return false end
end
for key in pairs(right) do
if left[key] == nil then return false end
end
return true
end
local function normalizeStaticData(staticData)
if type(staticData) == "table" and type(staticData.data) == "table" then
return staticData.data
end
return staticData
end
local function emptyHistory()
return {
schemaVersion = SCHEMA_VERSION,
kind = HISTORY_KIND,
turns = {},
}
end
local function addError(errors, code, path, message)
errors[#errors + 1] = makeError(code, path, message)
end
local function validateSnapshot(value, path, errors, staticData, allowStatus)
if type(value) ~= "table" or getmetatable(value) ~= nil then
addError(errors, "invalid_history_snapshot", path, "턴 상태 스냅샷이 일반 객체가 아닙니다.")
return
end
if not isFinite(value.stealth) then
addError(errors, "invalid_history_stealth", path .. ".stealth", "기록된 은폐가 유한한 숫자가 아닙니다.")
end
if not isFinite(value.resistance) then
addError(errors, "invalid_history_resistance", path .. ".resistance", "기록된 저항이 유한한 숫자가 아닙니다.")
end
if not isAsciiId(value.mood) then
addError(errors, "invalid_history_mood", path .. ".mood", "기록된 무드 ID가 올바르지 않습니다.")
elseif type(staticData) == "table"
and type(staticData.registry) == "table"
and type(staticData.registry.moods) == "table"
and staticData.registry.moods[value.mood] == nil then
addError(errors, "unknown_history_mood", path .. ".mood", "기록된 무드를 정적 레지스트리에서 찾을 수 없습니다.")
end
if allowStatus then
if not VALID_STATUS[value.status] then
addError(errors, "invalid_history_status", path .. ".status", "기록된 전투 상태가 올바르지 않습니다.")
end
elseif value.status ~= nil then
addError(errors, "unexpected_history_status", path .. ".status", "턴 시작 스냅샷에는 전투 상태를 저장하지 않습니다.")
end
end
local function validateCardRecord(record, side, path, errors, staticData)
if type(record) ~= "table" or getmetatable(record) ~= nil then
addError(errors, "invalid_history_card", path, "카드 이력 항목이 일반 객체가 아닙니다.")
return
end
if not isAsciiId(record.cardId) then
addError(errors, "invalid_history_card_id", path .. ".cardId", "카드 이력 ID가 올바르지 않습니다.")
end
if not isRuntimeId(record.instanceId) then
addError(errors, "invalid_history_instance_id", path .. ".instanceId", "카드 이력 인스턴스 ID가 올바르지 않습니다.")
end
if not isDenseArray(record.roles) or #record.roles < 1 or #record.roles > 2 or (side == "character" and #record.roles ~= 1) then
addError(errors, "invalid_history_roles", path .. ".roles", "카드 이력 역할 태그 목록이 올바르지 않습니다.")
else
local seenRoles = {}
for roleIndex, role in ipairs(record.roles) do
local definition = type(staticData) == "table"
and type(staticData.registry) == "table"
and type(staticData.registry.roles) == "table"
and staticData.registry.roles[role]
or nil
if not isAsciiId(role) or seenRoles[role] or (definition ~= nil and definition.owner ~= side) then
addError(errors, "invalid_history_role", path .. ".roles[" .. roleIndex .. "]", "카드 이력 역할 태그가 올바르지 않습니다.")
end
seenRoles[role] = true
end
end
for _, field in ipairs({ "selected", "declared", "resolved" }) do
if type(record[field]) ~= "boolean" then
addError(errors, "invalid_history_card_flag", path .. "." .. field, "카드 이력 상태 표시는 불리언이어야 합니다.")
end
end
if record.declarationSequence ~= nil and not isInteger(record.declarationSequence, 1) then
addError(errors, "invalid_history_sequence", path .. ".declarationSequence", "선언 사건 순번이 올바르지 않습니다.")
end
if record.resolutionSequence ~= nil and not isInteger(record.resolutionSequence, 1) then
addError(errors, "invalid_history_sequence", path .. ".resolutionSequence", "해결 사건 순번이 올바르지 않습니다.")
end
if record.resolved == true and record.resolutionSequence == nil then
addError(errors, "missing_history_resolution", path .. ".resolutionSequence", "해결된 카드에는 해결 사건 순번이 필요합니다.")
end
if record.finalStealthCost ~= nil and not isFinite(record.finalStealthCost) then
addError(errors, "invalid_history_cost", path .. ".finalStealthCost", "최종 은폐 비용이 유한한 숫자가 아닙니다.")
end
if record.finalResistanceDamage ~= nil and not isFinite(record.finalResistanceDamage) then
addError(errors, "invalid_history_damage", path .. ".finalResistanceDamage", "최종 저항 피해가 유한한 숫자가 아닙니다.")
end
local card = type(staticData) == "table"
and type(staticData.cards) == "table"
and staticData.cards[record.cardId]
or nil
if type(staticData) == "table" and type(staticData.cards) == "table" then
if type(card) ~= "table" then
addError(errors, "unknown_history_card", path .. ".cardId", "카드 이력의 정적 카드 정의를 찾을 수 없습니다.")
elseif card.owner ~= side then
addError(errors, "history_card_owner_mismatch", path .. ".cardId", "카드 이력 진영과 정적 카드 소유자가 다릅니다.")
elseif not dataEqual(card.roles, record.roles) then
addError(errors, "history_card_role_mismatch", path .. ".roles", "카드 이력 역할 태그와 정적 카드 정의가 다릅니다.")
end
end
end
local function validateRoleCounts(value, path, errors, staticData)
if type(value) ~= "table" or getmetatable(value) ~= nil then
addError(errors, "invalid_history_role_counts", path, "역할 태그 집계가 일반 객체가 아닙니다.")
return
end
for roleId, count in pairs(value) do
if not isAsciiId(roleId) then
addError(errors, "invalid_history_role", path, "집계 역할 태그 ID가 올바르지 않습니다.")
elseif not isInteger(count, 0) then
addError(errors, "invalid_history_role_count", path .. "." .. tostring(roleId), "역할 태그 횟수는 0 이상의 정수여야 합니다.")
elseif type(staticData) == "table"
and type(staticData.registry) == "table"
and type(staticData.registry.roles) == "table"
and staticData.registry.roles[roleId] == nil then
addError(errors, "unknown_history_role", path .. "." .. roleId, "집계 역할 태그를 정적 레지스트리에서 찾을 수 없습니다.")
end
end
end
local function validatePublicResult(value, path, errors)
if value == nil then return end
if type(value) ~= "table" or getmetatable(value) ~= nil then
addError(errors, "invalid_history_public_result", path, "공개 전투 로그 묶음이 일반 객체가 아닙니다.")
return
end
if value.schemaVersion ~= SCHEMA_VERSION or not isDenseArray(value.events) then
addError(errors, "invalid_history_public_result", path, "공개 전투 로그 사건 묶음이 올바르지 않습니다.")
end
end
local function countCards(cards, field)
local counts = {}
for _, card in ipairs(cards or {}) do
if card[field] == true then
for _, role in ipairs(card.roles or {}) do
counts[role] = (counts[role] or 0) + 1
end
end
end
return counts
end
local function validateTurnEntry(entry, index, errors, staticData)
local path = "$.turns[" .. index .. "]"
if type(entry) ~= "table" or getmetatable(entry) ~= nil then
addError(errors, "invalid_history_turn", path, "턴 이력 항목이 일반 객체가 아닙니다.")
return
end
if entry.turnNumber ~= index then
addError(errors, "history_turn_sequence_mismatch", path .. ".turnNumber", "턴 이력 번호가 배열 순서와 다릅니다.")
end
if not isRuntimeId(entry.turnId) then
addError(errors, "invalid_history_turn_id", path .. ".turnId", "턴 이력 ID가 올바르지 않습니다.")
end
validateSnapshot(entry.start, path .. ".start", errors, staticData, false)
validateSnapshot(entry.finish, path .. ".finish", errors, staticData, true)
local startMood = type(entry.start) == "table" and entry.start.mood or nil
local finishMood = type(entry.finish) == "table" and entry.finish.mood or nil
if type(entry.mood) ~= "table" or getmetatable(entry.mood) ~= nil then
addError(errors, "invalid_history_mood_result", path .. ".mood", "무드 판정 이력이 일반 객체가 아닙니다.")
else
if entry.mood.before ~= startMood or entry.mood.after ~= finishMood then
addError(errors, "history_mood_snapshot_mismatch", path .. ".mood", "무드 판정과 턴 시작·종료 스냅샷이 다릅니다.")
end
if type(entry.mood.applied) ~= "boolean" then
addError(errors, "invalid_history_mood_applied", path .. ".mood.applied", "무드 변경 여부는 불리언이어야 합니다.")
end
if not isInteger(entry.mood.forcedCount, 0) then
addError(errors, "invalid_history_forced_mood_count", path .. ".mood.forcedCount", "강제 무드 요청 수가 올바르지 않습니다.")
end
if type(entry.mood.forceCancelled) ~= "boolean" then
addError(errors, "invalid_history_force_cancelled", path .. ".mood.forceCancelled", "강제 무드 상쇄 여부는 불리언이어야 합니다.")
end
if not isAsciiId(entry.mood.resolution) then
addError(errors, "invalid_history_mood_resolution", path .. ".mood.resolution", "무드 판정 종류가 올바르지 않습니다.")
end
end
if type(entry.cards) ~= "table" then
addError(errors, "invalid_history_cards", path .. ".cards", "턴 카드 이력이 객체가 아닙니다.")
else
for _, side in ipairs({ "player", "character" }) do
local cards = entry.cards[side]
if not isDenseArray(cards) then
addError(errors, "invalid_history_cards", path .. ".cards." .. side, "진영별 카드 이력이 연속 배열이 아닙니다.")
else
local seen = {}
for cardIndex, card in ipairs(cards) do
validateCardRecord(card, side, path .. ".cards." .. side .. "[" .. cardIndex .. "]", errors, staticData)
if type(card) == "table" and isRuntimeId(card.instanceId) then
if seen[card.instanceId] then
addError(errors, "duplicate_history_card", path .. ".cards." .. side .. "[" .. cardIndex .. "].instanceId", "같은 카드 인스턴스가 한 턴 이력에 중복되었습니다.")
end
seen[card.instanceId] = true
end
end
end
end
end
if type(entry.roleCounts) ~= "table" then
addError(errors, "invalid_history_role_counts", path .. ".roleCounts", "턴 역할 태그 집계가 객체가 아닙니다.")
else
for _, side in ipairs({ "player", "character" }) do
local sideCounts = entry.roleCounts[side]
if type(sideCounts) ~= "table" then
addError(errors, "invalid_history_role_counts", path .. ".roleCounts." .. side, "진영별 역할 태그 집계가 객체가 아닙니다.")
else
validateRoleCounts(sideCounts.declared, path .. ".roleCounts." .. side .. ".declared", errors, staticData)
validateRoleCounts(sideCounts.resolved, path .. ".roleCounts." .. side .. ".resolved", errors, staticData)
if type(entry.cards) == "table" and isDenseArray(entry.cards[side]) then
if not dataEqual(sideCounts.declared, countCards(entry.cards[side], "declared")) then
addError(errors, "history_declared_count_mismatch", path .. ".roleCounts." .. side .. ".declared", "선언 역할 집계가 카드 이력과 다릅니다.")
end
if not dataEqual(sideCounts.resolved, countCards(entry.cards[side], "resolved")) then
addError(errors, "history_resolved_count_mismatch", path .. ".roleCounts." .. side .. ".resolved", "해결 역할 집계가 카드 이력과 다릅니다.")
end
end
end
end
end
validatePublicResult(entry.publicResult, path .. ".publicResult", errors)
end
local function validateHistory(history, state, staticInput)
local errors = {}
local staticData = normalizeStaticData(staticInput)
if type(history) ~= "table" or getmetatable(history) ~= nil then
return failure({ makeError("invalid_battle_history", "$", "전투 이력이 일반 객체가 아닙니다.") })
end
if history.schemaVersion ~= SCHEMA_VERSION or history.kind ~= HISTORY_KIND then
addError(errors, "invalid_battle_history_schema", "$", "지원하지 않는 전투 이력 형식입니다.")
end
if not isDenseArray(history.turns) then
addError(errors, "invalid_battle_history_turns", "$.turns", "전투 턴 이력이 연속 배열이 아닙니다.")
elseif #history.turns > MAX_TURNS then
addError(errors, "battle_history_too_long", "$.turns", "전투 이력은 최대 12턴까지만 저장할 수 있습니다.")
else
local seenTurnIds = {}
for index, entry in ipairs(history.turns) do
validateTurnEntry(entry, index, errors, staticData)
if type(entry) == "table" and isRuntimeId(entry.turnId) then
if seenTurnIds[entry.turnId] then
addError(errors, "duplicate_history_turn_id", "$.turns[" .. index .. "].turnId", "턴 이력 ID가 중복되었습니다.")
end
seenTurnIds[entry.turnId] = true
end
if index > 1 then
local previous = history.turns[index - 1]
if type(previous) == "table"
and type(previous.finish) == "table"
and type(entry) == "table"
and type(entry.start) == "table" then
if previous.finish.stealth ~= entry.start.stealth
or previous.finish.resistance ~= entry.start.resistance
or previous.finish.mood ~= entry.start.mood then
addError(errors, "battle_history_discontinuity", "$.turns[" .. index .. "].start", "이전 턴 종료 상태와 다음 턴 시작 상태가 이어지지 않습니다.")
end
end
end
end
end
if type(state) == "table" and isDenseArray(history.turns) then
local count = #history.turns
local expectedCount = nil
if state.status == "active" and isInteger(state.turnNumber, 1) then
expectedCount = state.turnNumber - 1
elseif (state.status == "victory" or state.status == "defeat") and isInteger(state.turnNumber, 1) then
expectedCount = state.turnNumber
end
if expectedCount ~= nil and count ~= expectedCount then
addError(errors, "battle_history_turn_count_mismatch", "$.turns", "전투 상태와 완료된 턴 이력 수가 다릅니다.")
end
local last = history.turns[count]
if count == 0 then
if state.lastCommittedTurnId ~= nil then
addError(errors, "battle_history_missing_last_turn", "$.turns", "마지막 확정 턴 ID가 있지만 전투 이력이 비어 있습니다.")
end
elseif type(last) == "table" and state.lastCommittedTurnId ~= last.turnId then
addError(errors, "battle_history_last_turn_mismatch", "$.turns[" .. count .. "].turnId", "전투 이력의 마지막 턴과 권위 상태의 마지막 확정 턴이 다릅니다.")
end
if type(last) == "table" and type(last.finish) == "table" then
local currentStealth = type(state.player) == "table" and state.player.stealth or nil
local currentResistance = type(state.character) == "table" and state.character.resistance or nil
local currentMood = type(state.character) == "table" and state.character.mood or nil
local receipt = state.status == "active" and state.turnStartReceipt or nil
local baseline = type(receipt) == "table" and receipt.baseline or nil
if isInteger(state.turnNumber, 1)
and count == state.turnNumber - 1
and state.lastCommittedTurnId == last.turnId
and type(receipt) == "table"
and receipt.turnNumber == state.turnNumber
and type(baseline) == "table"
and isFinite(baseline.stealth)
and isFinite(baseline.resistance)
and type(baseline.mood) == "string" then
currentStealth = baseline.stealth
currentResistance = baseline.resistance
currentMood = baseline.mood
end
if type(state.player) == "table" and currentStealth ~= last.finish.stealth then
addError(errors, "battle_history_stealth_mismatch", "$.turns[" .. count .. "].finish.stealth", "마지막 이력의 은폐가 현재 상태와 다릅니다.")
end
if type(state.character) == "table"
and (currentResistance ~= last.finish.resistance
or currentMood ~= last.finish.mood) then
addError(errors, "battle_history_character_mismatch", "$.turns[" .. count .. "].finish", "마지막 이력의 저항 또는 무드가 현재 상태와 다릅니다.")
end
if state.status ~= last.finish.status then
addError(errors, "battle_history_status_mismatch", "$.turns[" .. count .. "].finish.status", "마지막 이력의 전투 상태가 현재 상태와 다릅니다.")
end
end
end
if #errors > 0 then return failure(errors) end
local copy, copyError = cloneData(history, "$", {})
if copyError then return failure({ copyError }) end
return success({ history = copy })
end
local function findInstance(state, instanceId)
for _, instance in ipairs(type(state) == "table" and type(state.cardInstances) == "table" and state.cardInstances or {}) do
if type(instance) == "table" and instance.instanceId == instanceId then
return instance
end
end
return nil
end
local function selectedSet(selected)
local set = {}
for _, instanceId in ipairs(type(selected) == "table" and selected or {}) do
set[instanceId] = true
end
return set
end
local function buildCardRecords(beforeState, events, selectedCards, staticData)
local records = { player = {}, character = {} }
local byInstance = { player = {}, character = {} }
local selected = {
player = selectedSet(type(selectedCards) == "table" and selectedCards.player or nil),
character = selectedSet(type(selectedCards) == "table" and selectedCards.character or nil),
}
local function ensureRecord(side, cardId, instanceId)
if not VALID_SIDE[side] or not isAsciiId(cardId) or not isRuntimeId(instanceId) then
return nil
end
local existing = byInstance[side][instanceId]
if existing then return existing end
local card = type(staticData) == "table"
and type(staticData.cards) == "table"
and staticData.cards[cardId]
or nil
if type(card) ~= "table" or card.owner ~= side or not isDenseArray(card.roles) then
return nil
end
local roles = {}
for index, role in ipairs(card.roles) do roles[index] = role end
local record = {
cardId = cardId,
instanceId = instanceId,
roles = roles,
selected = selected[side][instanceId] == true,
declared = false,
resolved = false,
}
records[side][#records[side] + 1] = record
byInstance[side][instanceId] = record
return record
end
for _, event in ipairs(type(events) == "table" and events or {}) do
local source = type(event) == "table" and event.source or nil
local side = type(event) == "table" and (event.side or (type(source) == "table" and source.side)) or nil
if type(source) == "table" and source.kind == "card" and VALID_SIDE[side] then
local record = ensureRecord(side, source.id, source.instanceId)
if record and event.type == "card_declared" then
record.declared = true
record.declarationSequence = event.sequence
local payload = type(event.payload) == "table" and event.payload or nil
if payload and isFinite(payload.finalStealthCost) then
record.finalStealthCost = payload.finalStealthCost
end
elseif record and event.type == "card_resolved" then
record.resolved = true
record.resolutionSequence = event.sequence
local payload = type(event.payload) == "table" and event.payload or nil
if payload and isFinite(payload.finalResistanceDamage) then
record.finalResistanceDamage = payload.finalResistanceDamage
end
end
end
end
for _, side in ipairs({ "player", "character" }) do
local selectedIds = type(selectedCards) == "table" and selectedCards[side] or nil
for _, instanceId in ipairs(type(selectedIds) == "table" and selectedIds or {}) do
if byInstance[side][instanceId] == nil then
local instance = findInstance(beforeState, instanceId)
if type(instance) == "table" then
ensureRecord(side, instance.cardId, instance.instanceId)
end
end
end
table.sort(records[side], function(left, right)
local leftSequence = left.declarationSequence or (100000 + (left.resolutionSequence or 0))
local rightSequence = right.declarationSequence or (100000 + (right.resolutionSequence or 0))
if leftSequence ~= rightSequence then return leftSequence < rightSequence end
return left.instanceId < right.instanceId
end)
end
return records
end
local function appendResolvedTurn(beforeState, afterState, spec, staticInput)
local staticData = normalizeStaticData(staticInput)
if type(beforeState) ~= "table" or type(afterState) ~= "table" or type(spec) ~= "table" then
return failure({ makeError("invalid_append_input", "$", "턴 이력 추가 입력이 올바르지 않습니다.") })
end
local beforeValidation = validateHistory(beforeState.history, beforeState, staticData)
if not beforeValidation.ok then return beforeValidation end
if not dataEqual(beforeState.history, afterState.history) then
return failure({ makeError("history_changed_before_append", "$.afterState.history", "턴 해결 전에 전투 이력이 임의로 변경되었습니다.") })
end
if not isInteger(spec.turnNumber, 1)
or spec.turnNumber ~= #beforeState.history.turns + 1
or not isRuntimeId(spec.turnId)
or not isDenseArray(spec.events) then
return failure({ makeError("invalid_turn_history_spec", "$.spec", "턴 이력 추가 사양이 현재 전투 순서와 맞지 않습니다.") })
end
local stateCopy, stateError = cloneData(afterState, "$.afterState", {})
if stateError then return failure({ stateError }) end
local historyCopy, historyError = cloneData(beforeState.history, "$.history", {})
if historyError then return failure({ historyError }) end
local cards = buildCardRecords(beforeState, spec.events, spec.selectedCards, staticData)
local startCopy, startError = cloneData(spec.start, "$.spec.start", {})
if startError then return failure({ startError }) end
local finishCopy, finishError = cloneData(spec.finish, "$.spec.finish", {})
if finishError then return failure({ finishError }) end
local moodCopy, moodError = cloneData(spec.mood, "$.spec.mood", {})
if moodError then return failure({ moodError }) end
local entry = {
turnNumber = spec.turnNumber,
turnId = spec.turnId,
start = startCopy,
finish = finishCopy,
mood = moodCopy,
cards = cards,
roleCounts = {
player = {
declared = countCards(cards.player, "declared"),
resolved = countCards(cards.player, "resolved"),
},
character = {
declared = countCards(cards.character, "declared"),
resolved = countCards(cards.character, "resolved"),
},
},
}
historyCopy.turns[#historyCopy.turns + 1] = entry
stateCopy.history = historyCopy
local validation = validateHistory(historyCopy, stateCopy, staticData)
if not validation.ok then return validation end
local entryCopy, entryError = cloneData(entry, "$.entry", {})
if entryError then return failure({ entryError }) end
return success({ state = stateCopy, history = validation.history, entry = entryCopy })
end
local function attachPublicResult(state, turnId, publicResult, staticInput)
local staticData = normalizeStaticData(staticInput)
if type(state) ~= "table" or not isRuntimeId(turnId) then
return failure({ makeError("invalid_public_log_input", "$", "공개 턴 로그 연결 입력이 올바르지 않습니다.") })
end
local validation = validateHistory(state.history, state, staticData)
if not validation.ok then return validation end
local eventErrors = {}
validatePublicResult(publicResult, "$.publicResult", eventErrors)
if #eventErrors > 0 then return failure(eventErrors) end
local stateCopy, stateError = cloneData(state, "$.state", {})
if stateError then return failure({ stateError }) end
local turns = stateCopy.history.turns
local entry = turns[#turns]
if type(entry) ~= "table" or entry.turnId ~= turnId then
return failure({ makeError("public_log_turn_mismatch", "$.state.history.turns", "공개 로그를 연결할 마지막 턴을 찾을 수 없습니다.") })
end
if entry.publicResult ~= nil and not dataEqual(entry.publicResult, publicResult) then
return failure({ makeError("public_log_conflict", "$.state.history.turns", "같은 턴에 서로 다른 공개 로그를 연결할 수 없습니다.") })
end
local publicCopy, publicError = cloneData(publicResult, "$.publicResult", {})
if publicError then return failure({ publicError }) end
entry.publicResult = publicCopy
local outputValidation = validateHistory(stateCopy.history, stateCopy, staticData)
if not outputValidation.ok then return outputValidation end
return success({ state = stateCopy, history = outputValidation.history })
end
local function copyCounts(source)
local copy = {}
for key, value in pairs(type(source) == "table" and source or {}) do
copy[key] = value
end
return copy
end
local function addCounts(target, source)
for key, value in pairs(type(source) == "table" and source or {}) do
target[key] = (target[key] or 0) + value
end
end
local function cardContextRecord(record)
local roles = {}
for index, role in ipairs(record.roles) do roles[index] = role end
return {
cardId = record.cardId,
instanceId = record.instanceId,
roles = roles,
selected = record.selected,
declared = record.declared,
resolved = record.resolved,
}
end
local function turnContext(entry)
local value = {
turnNumber = entry.turnNumber,
turnId = entry.turnId,
startMood = entry.start.mood,
endMood = entry.finish.mood,
status = entry.finish.status,
start = {
stealth = entry.start.stealth,
resistance = entry.start.resistance,
mood = entry.start.mood,
},
finish = {
stealth = entry.finish.stealth,
resistance = entry.finish.resistance,
mood = entry.finish.mood,
status = entry.finish.status,
},
mood = {
before = entry.mood.before,
after = entry.mood.after,
applied = entry.mood.applied,
forcedCount = entry.mood.forcedCount,
forceCancelled = entry.mood.forceCancelled,
resolution = entry.mood.resolution,
tokensBefore = copyCounts(entry.mood.tokensBefore),
tokensAfter = copyCounts(entry.mood.tokensAfter),
},
playerCards = {},
characterCards = {},
playerRoles = {},
characterRoles = {},
}
if entry.mood.targetMood ~= nil then value.mood.targetMood = entry.mood.targetMood end
if type(entry.mood.tiedMoods) == "table" then
value.mood.tiedMoods = {}
for index, moodId in ipairs(entry.mood.tiedMoods) do
value.mood.tiedMoods[index] = moodId
end
end
for _, side in ipairs({ "player", "character" }) do
local outputCards = side == "player" and value.playerCards or value.characterCards
local outputRoles = side == "player" and value.playerRoles or value.characterRoles
for _, record in ipairs(entry.cards[side]) do
outputCards[#outputCards + 1] = cardContextRecord(record)
if record.resolved then
for _, role in ipairs(record.roles) do outputRoles[#outputRoles + 1] = role end
end
end
end
return value
end
local function buildContext(history)
local validation = validateHistory(history, nil, nil)
if not validation.ok then return validation end
local turns = validation.history.turns
local context = {
schemaVersion = SCHEMA_VERSION,
kind = CONTEXT_KIND,
completedTurns = #turns,
turns = {},
windows = {},
player = {
declaredRoleCounts = {},
resolvedRoleCounts = {},
},
character = {
declaredRoleCounts = {},
resolvedRoleCounts = {},
},
}
for index, entry in ipairs(turns) do
context.turns[index] = turnContext(entry)
for _, side in ipairs({ "player", "character" }) do
addCounts(context[side].declaredRoleCounts, entry.roleCounts[side].declared)
addCounts(context[side].resolvedRoleCounts, entry.roleCounts[side].resolved)
for _, card in ipairs(entry.cards[side]) do
if card.declared then context[side].lastDeclaredRoles = cardContextRecord(card).roles end
if card.resolved then context[side].lastResolvedRoles = cardContextRecord(card).roles end
end
end
end
if #turns > 0 then
context.previousTurn = turnContext(turns[#turns])
end
for window = 1, MAX_TURNS do
local availableTurns = math.min(window, #turns)
local windowValue = {
requestedTurns = window,
availableTurns = availableTurns,
player = { declaredRoleCounts = {}, resolvedRoleCounts = {} },
character = { declaredRoleCounts = {}, resolvedRoleCounts = {} },
}
local first = math.max(1, #turns - window + 1)
for index = first, #turns do
local entry = turns[index]
for _, side in ipairs({ "player", "character" }) do
addCounts(windowValue[side].declaredRoleCounts, entry.roleCounts[side].declared)
addCounts(windowValue[side].resolvedRoleCounts, entry.roleCounts[side].resolved)
end
end
context.windows[window] = windowValue
end
return success({ context = context })
end
local function validateContext(value)
if type(value) ~= "table" or getmetatable(value) ~= nil then
return failure({ makeError("invalid_history_context", "$", "전투 이력 컨텍스트가 일반 객체가 아닙니다.") })
end
local errors = {}
if value.schemaVersion ~= SCHEMA_VERSION or value.kind ~= CONTEXT_KIND then
addError(errors, "invalid_history_context_schema", "$", "지원하지 않는 전투 이력 컨텍스트입니다.")
end
if not isInteger(value.completedTurns, 0) then
addError(errors, "invalid_history_context_turns", "$.completedTurns", "완료 턴 수가 올바르지 않습니다.")
end
if not isDenseArray(value.turns) or not isDenseArray(value.windows) then
addError(errors, "invalid_history_context_arrays", "$", "컨텍스트 턴 또는 기간 집계가 연속 배열이 아닙니다.")
elseif #value.turns ~= value.completedTurns or #value.windows ~= MAX_TURNS then
addError(errors, "history_context_count_mismatch", "$", "컨텍스트 완료 턴 수 또는 기간 창 개수가 다릅니다.")
else
for window = 1, MAX_TURNS do
local current = value.windows[window]
if type(current) ~= "table"
or current.requestedTurns ~= window
or current.availableTurns ~= math.min(window, value.completedTurns) then
addError(errors, "invalid_history_window", "$.windows[" .. window .. "]", "기간 창의 요청·가용 턴 수가 올바르지 않습니다.")
else
for _, side in ipairs({ "player", "character" }) do
local sideValue = current[side]
if type(sideValue) ~= "table"
or type(sideValue.declaredRoleCounts) ~= "table"
or type(sideValue.resolvedRoleCounts) ~= "table" then
addError(errors, "invalid_history_window_side", "$.windows[" .. window .. "]." .. side, "기간 창의 진영별 태그 집계가 올바르지 않습니다.")
end
end
end
end
end
for _, side in ipairs({ "player", "character" }) do
if type(value[side]) ~= "table"
or type(value[side].declaredRoleCounts) ~= "table"
or type(value[side].resolvedRoleCounts) ~= "table" then
addError(errors, "invalid_history_context_side", "$." .. side, "진영별 이력 집계가 올바르지 않습니다.")
end
end
if #errors > 0 then return failure(errors) end
return success({ valid = true })
end
local function numberText(value)
if type(value) ~= "number" then return tostring(value) end
if value % 1 == 0 then return string.format("%.0f", value) end
return tostring(value)
end
local function moodLabel(staticData, moodId)
local mood = type(staticData) == "table"
and type(staticData.registry) == "table"
and type(staticData.registry.moods) == "table"
and staticData.registry.moods[moodId]
or nil
return type(mood) == "table" and mood.label or tostring(moodId)
end
local function cardName(staticData, cardId)
local card = type(staticData) == "table"
and type(staticData.cards) == "table"
and staticData.cards[cardId]
or nil
return type(card) == "table" and card.name or tostring(cardId)
end
local function roleLabel(staticData, roleId)
local role = type(staticData) == "table"
and type(staticData.registry) == "table"
and type(staticData.registry.roles) == "table"
and staticData.registry.roles[roleId]
or nil
return type(role) == "table" and role.label or tostring(roleId)
end
local function roleLabels(staticData, roles)
local labels = {}
for index, roleId in ipairs(roles or {}) do labels[index] = roleLabel(staticData, roleId) end
return table.concat(labels, "·")
end
local EFFECT_TEXT = {
pay_stealth_cost = "은폐 비용",
lose_stealth = "은폐 감소",
recover_stealth = "은폐 회복",
damage_resistance = "저항 피해",
recover_resistance = "저항 회복",
}
local EFFECT_SOURCE_COLLECTIONS = {
card = "cards",
plan = "cards",
trait = "traits",
perk = "perks",
}
local EFFECT_SOURCE_LABELS = {
card = "카드",
plan = "계획",
trait = "특징",
perk = "퍽",
system = "상태 효과",
}
local SYSTEM_EFFECT_NAMES = {
mood_state = "무드 효과",
}
local function effectSourceText(staticData, source)
if type(source) ~= "table" or not isAsciiId(source.kind) or not isAsciiId(source.id) then
return nil
end
local name = source.kind == "system" and SYSTEM_EFFECT_NAMES[source.id] or nil
local collectionName = EFFECT_SOURCE_COLLECTIONS[source.kind]
local definition = collectionName and type(staticData) == "table"
and type(staticData[collectionName]) == "table"
and staticData[collectionName][source.id]
or nil
if name == nil and type(definition) == "table" then name = definition.name end
local label = EFFECT_SOURCE_LABELS[source.kind]
if type(label) ~= "string" or type(name) ~= "string" or name == "" then return nil end
return label .. " 「" .. name .. "」"
end
local function validatePublicView(view)
local errors = {}
if type(view) ~= "table" or getmetatable(view) ~= nil then
return failure({ makeError("invalid_battle_log_view", "$", "상세 전투 로그 View가 일반 객체가 아닙니다.") })
end
local allowedViewKeys = {
available = true,
turnCount = true,
entries = true,
}
for key in pairs(view) do
if type(key) ~= "string" or allowedViewKeys[key] ~= true then
addError(errors, "unknown_battle_log_view_field", "$", "상세 전투 로그 View에 허용되지 않은 필드가 있습니다.")
end
end
if type(view.available) ~= "boolean" then
addError(errors, "invalid_battle_log_availability", "$.available", "상세 전투 로그 사용 가능 여부는 불리언이어야 합니다.")
end
if not isInteger(view.turnCount, 0) or view.turnCount > MAX_TURNS then
addError(errors, "invalid_battle_log_turn_count", "$.turnCount", "상세 전투 로그 턴 수가 올바르지 않습니다.")
end
if not isDenseArray(view.entries) then
addError(errors, "invalid_battle_log_entries", "$.entries", "상세 전투 로그 항목이 연속 배열이 아닙니다.")
else
if view.available == false and (view.turnCount ~= 0 or #view.entries ~= 0) then
addError(errors, "unavailable_battle_log_has_content", "$", "사용할 수 없는 상세 전투 로그에는 턴과 항목이 없어야 합니다.")
elseif view.available == true and (not isInteger(view.turnCount, 1) or #view.entries == 0) then
addError(errors, "available_battle_log_missing_content", "$", "사용 가능한 상세 전투 로그에는 턴과 항목이 필요합니다.")
end
local previousTurnNumber = 0
for index, entry in ipairs(view.entries) do
local path = "$.entries[" .. index .. "]"
if type(entry) ~= "table" or getmetatable(entry) ~= nil then
addError(errors, "invalid_battle_log_entry", path, "상세 전투 로그 항목이 일반 객체가 아닙니다.")
else
local allowedEntryKeys = {
turnNumber = true,
sequence = true,
type = true,
text = true,
label = true,
}
for key in pairs(entry) do
if type(key) ~= "string" or allowedEntryKeys[key] ~= true then
addError(errors, "unknown_battle_log_entry_field", path, "상세 전투 로그 항목에 허용되지 않은 필드가 있습니다.")
end
end
if not isInteger(entry.turnNumber, 1)
or (isInteger(view.turnCount, 0) and entry.turnNumber > view.turnCount) then
addError(errors, "invalid_battle_log_entry_turn", path .. ".turnNumber", "상세 전투 로그 항목의 턴 번호가 올바르지 않습니다.")
elseif entry.turnNumber < previousTurnNumber then
addError(errors, "unordered_battle_log_entry", path .. ".turnNumber", "상세 전투 로그 턴 순서가 역행합니다.")
else
previousTurnNumber = entry.turnNumber
end
if not isInteger(entry.sequence, 0) then
addError(errors, "invalid_battle_log_entry_sequence", path .. ".sequence", "상세 전투 로그 사건 순번이 올바르지 않습니다.")
end
if not isAsciiId(entry.type) then
addError(errors, "invalid_battle_log_entry_type", path .. ".type", "상세 전투 로그 사건 종류가 올바르지 않습니다.")
end
if type(entry.text) ~= "string" or entry.text == "" then
addError(errors, "invalid_battle_log_entry_text", path .. ".text", "상세 전투 로그 문장이 비어 있습니다.")
end
local expectedLabel = tostring(entry.turnNumber) .. "턴 · " .. tostring(entry.text)
if entry.label ~= expectedLabel then
addError(errors, "battle_log_entry_label_mismatch", path .. ".label", "상세 전투 로그 표시 문장이 턴 번호와 본문에 일치하지 않습니다.")
end
end
end
end
if #errors > 0 then return failure(errors) end
return success({ valid = true })
end
local function buildPublicView(history, staticInput)
local staticData = normalizeStaticData(staticInput)
local validation = validateHistory(history, nil, staticData)
if not validation.ok then return validation end
local turns = validation.history.turns
if #turns == 0 then
local emptyView = { available = false, turnCount = 0, entries = {} }
local emptyValidation = validatePublicView(emptyView)
if not emptyValidation.ok then return emptyValidation end
return success({ view = emptyView })
end
local entries = {}
local function append(turnNumber, sequence, eventType, text)
entries[#entries + 1] = {
turnNumber = turnNumber,
sequence = sequence,
type = eventType,
text = text,
label = tostring(turnNumber) .. "턴 · " .. text,
}
end
for _, entry in ipairs(turns) do
append(
entry.turnNumber,
0,
"turn_start",
"시작 — 은폐 " .. numberText(entry.start.stealth)
.. " / 저항 " .. numberText(entry.start.resistance)
.. " / 무드 " .. moodLabel(staticData, entry.start.mood)
)
local publicEvents = type(entry.publicResult) == "table" and entry.publicResult.events or {}
for publicIndex, event in ipairs(type(publicEvents) == "table" and publicEvents or {}) do
local payload = type(event) == "table" and event.payload or nil
local sequence = type(event) == "table" and event.sequence or publicIndex
local eventType = type(event) == "table" and event.type or "unknown"
local text = nil
if eventType == "card_declared" and type(payload) == "table" and isAsciiId(payload.cardId) then
text = "플레이어 카드 「" .. cardName(staticData, payload.cardId) .. "」 선언"
elseif eventType == "character_intent" and type(payload) == "table" and isAsciiId(payload.role) then
text = "상대 예고 역할 — " .. roleLabel(staticData, payload.role)
elseif eventType == "effect_applied" and type(payload) == "table" then
local effectLabel = EFFECT_TEXT[payload.op]
if effectLabel and isFinite(payload.amount) then
text = effectLabel .. " " .. numberText(payload.amount)
if isFinite(payload.before) and isFinite(payload.after) then
text = text .. " (" .. numberText(payload.before) .. " → " .. numberText(payload.after) .. ")"
end
elseif payload.op == "draw_cards" and isInteger(payload.drawnCount, 0) then
text = "추가 드로우 " .. tostring(payload.drawnCount) .. "장"
elseif payload.op == "skip_actions" then
text = "남은 행동 생략"
elseif (payload.op == "add_mood_token" or payload.op == "remove_mood_token")
and isAsciiId(payload.mood) and isFinite(payload.amount) then
text = moodLabel(staticData, payload.mood) .. " 토큰 "
.. (payload.op == "add_mood_token" and "추가 " or "제거 ")
.. numberText(payload.amount) .. "개"
if isFinite(payload.before) and isFinite(payload.after) then
text = text .. " (" .. numberText(payload.before) .. " → " .. numberText(payload.after) .. ")"
end
elseif payload.op == "force_mood" and isAsciiId(payload.mood) then
text = moodLabel(staticData, payload.mood) .. " 무드 강제 변경 요청"
end
local sourceText = effectSourceText(staticData, payload.source)
if text ~= nil and sourceText ~= nil then
text = text .. " — 원인: " .. sourceText
end
elseif eventType == "plan_changed" and type(payload) == "table" then
local planText = payload.action == "placed" and "계획 배치"
or payload.action == "discarded" and "계획 폐기"
or payload.action == "revealed" and "계획 공개"
or "계획 변화"
if isAsciiId(payload.cardId) then
planText = planText .. " — 「" .. cardName(staticData, payload.cardId) .. "」"
end
text = planText
elseif eventType == "actions_stopped" then
text = "남은 행동이 중단됨"
elseif eventType == "card_removed" and type(payload) == "table" and isAsciiId(payload.cardId) then
text = "카드 제거 — 「" .. cardName(staticData, payload.cardId) .. "」"
elseif eventType == "mood_evaluated" and type(payload) == "table"
and isAsciiId(payload.before) and isAsciiId(payload.after) then
text = "무드 판정 — " .. moodLabel(staticData, payload.before)
.. " → " .. moodLabel(staticData, payload.after)
elseif eventType == "outcome" and type(payload) == "table" then
text = payload.status == "victory" and "승리 확정" or "패배 확정"
elseif eventType == "session_ended" and type(payload) == "table" then
text = payload.status == "victory" and "전투 종료 — 승리" or "전투 종료 — 패배"
end
if text ~= nil then append(entry.turnNumber, sequence, eventType, text) end
end
for _, card in ipairs(entry.cards.player) do
if card.resolved then
append(
entry.turnNumber,
card.resolutionSequence or 9000,
"player_card_resolved",
"플레이어 해결 — 「" .. cardName(staticData, card.cardId)
.. "」 · " .. roleLabels(staticData, card.roles)
)
end
end
for _, card in ipairs(entry.cards.character) do
if card.resolved then
append(
entry.turnNumber,
card.resolutionSequence or 9100,
"character_card_resolved",
"상대 행동 해결 — " .. roleLabels(staticData, card.roles)
)
end
end
append(
entry.turnNumber,
99999,
"turn_end",
"종료 — 은폐 " .. numberText(entry.finish.stealth)
.. " / 저항 " .. numberText(entry.finish.resistance)
.. " / 무드 " .. moodLabel(staticData, entry.finish.mood)
)
end
local view = {
available = true,
turnCount = #turns,
entries = entries,
}
local viewValidation = validatePublicView(view)
if not viewValidation.ok then return viewValidation end
return success({ view = view })
end
local arguments = { ... }
if action == "empty" then
return success({ history = emptyHistory() })
elseif action == "validate" then
return validateHistory(arguments[1], arguments[2], arguments[3])
elseif action == "appendResolvedTurn" then
return appendResolvedTurn(arguments[1], arguments[2], arguments[3], arguments[4])
elseif action == "attachPublicResult" then
return attachPublicResult(arguments[1], arguments[2], arguments[3], arguments[4])
elseif action == "context" then
return buildContext(arguments[1])
elseif action == "validateContext" then
return validateContext(arguments[1])
elseif action == "buildPublicView" then
return buildPublicView(arguments[1], arguments[2])
elseif action == "validatePublicView" then
return validatePublicView(arguments[1])
end
return failure({ makeError("unknown_action", "$.action", "지원하지 않는 전투 이력 작업입니다: " .. tostring(action)) })
end)
#31battleRuntime.lua
Keys:
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local function makeError(code, path, message)
return {
code = code,
path = path,
message = message,
}
end
local function failure(errors)
return {
ok = false,
schemaVersion = SCHEMA_VERSION,
errors = errors,
}
end
local function pendingSuccess(pendingTurn, reused)
return {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
pendingTurn = pendingTurn,
turnId = pendingTurn.turnId,
reused = reused == true,
}
end
local function commitSuccess(state, turnId, applied)
return {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
state = state,
turnId = turnId,
applied = applied == true,
}
end
local function isFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function isInteger(value, minimum)
return isFinite(value)
and value % 1 == 0
and (minimum == nil or value >= minimum)
end
local function cloneData(value, path, active)
local valueType = type(value)
if valueType == "nil" or valueType == "string" or valueType == "boolean" then
return value, nil
end
if valueType == "number" then
if not isFinite(value) then
return nil, makeError("non_finite_number", path, "유한하지 않은 숫자는 런타임 트랜잭션에 저장할 수 없습니다.")
end
return value, nil
end
if valueType ~= "table" then
return nil, makeError("unsupported_type", path, "런타임 트랜잭션에 저장할 수 없는 자료형입니다.")
end
if getmetatable(value) ~= nil then
return nil, makeError("metatable_not_allowed", path, "런타임 트랜잭션 데이터에는 메타테이블을 사용할 수 없습니다.")
end
active = active or {}
if active[value] then
return nil, makeError("circular_reference", path, "순환 참조는 런타임 트랜잭션에 저장할 수 없습니다.")
end
active[value] = true
local numericCount = 0
local maximum = 0
local hasNumeric = false
local hasString = false
for key in pairs(value) do
if type(key) == "number" then
hasNumeric = true
numericCount = numericCount + 1
if not isInteger(key, 1) then
active[value] = nil
return nil, makeError("invalid_array_index", path, "배열 인덱스는 1 이상의 정수여야 합니다.")
end
maximum = math.max(maximum, key)
elseif type(key) == "string" then
hasString = true
else
active[value] = nil
return nil, makeError("invalid_object_key", path, "객체 키는 문자열이어야 합니다.")
end
end
if hasNumeric and hasString then
active[value] = nil
return nil, makeError("mixed_table", path, "숫자 인덱스와 문자열 키를 함께 사용할 수 없습니다.")
end
if hasNumeric and numericCount ~= maximum then
active[value] = nil
return nil, makeError("sparse_array", path, "배열 인덱스는 1부터 빈틈없이 이어져야 합니다.")
end
local copy = {}
if hasNumeric then
for index = 1, maximum do
local item, itemError = cloneData(value[index], path .. "[" .. index .. "]", active)
if itemError then
active[value] = nil
return nil, itemError
end
copy[index] = item
end
else
for key, item in pairs(value) do
local itemCopy, itemError = cloneData(item, path .. "." .. key, active)
if itemError then
active[value] = nil
return nil, itemError
end
copy[key] = itemCopy
end
end
active[value] = nil
return copy, nil
end
local function deepEqual(left, right, active)
if type(left) ~= type(right) then
return false
end
if type(left) ~= "table" then
return left == right
end
if getmetatable(left) ~= nil or getmetatable(right) ~= nil then
return false
end
active = active or {}
if active[left] ~= nil then
return active[left] == right
end
active[left] = right
for key, value in pairs(left) do
if not deepEqual(value, right[key], active) then
active[left] = nil
return false
end
end
for key in pairs(right) do
if left[key] == nil then
active[left] = nil
return false
end
end
active[left] = nil
return true
end
local function appendNestedErrors(target, prefix, report)
local nested = type(report) == "table" and report.errors or nil
if type(nested) ~= "table" or #nested == 0 then
target[#target + 1] = makeError("nested_operation_failed", prefix, "하위 런타임 작업이 실패했습니다.")
return
end
for _, item in ipairs(nested) do
local code = type(item) == "table" and item.code or nil
local path = type(item) == "table" and item.path or nil
local message = type(item) == "table" and item.message or nil
local nestedPath = prefix
if type(path) == "string" then
nestedPath = path:sub(1, 1) == "$" and (prefix .. path:sub(2)) or (prefix .. "." .. path)
end
target[#target + 1] = makeError(
type(code) == "string" and code or "nested_error",
nestedPath,
type(message) == "string" and message or "하위 런타임 작업이 실패했습니다."
)
end
end
local function callModule(moduleName, moduleAction, ...)
if type(runScript) ~= "function" then
return nil, {
makeError("runtime_unavailable", "$.runtime." .. moduleName, "스크립트 실행기를 찾을 수 없습니다."),
}
end
local ok, report = pcall(runScript, triggerId, moduleName, moduleAction, ...)
if not ok then
return nil, {
makeError("module_call_error", "$.runtime." .. moduleName, "하위 모듈 호출 중 오류가 발생했습니다."),
}
end
if type(report) ~= "table" then
return nil, {
makeError("invalid_module_result", "$.runtime." .. moduleName, "하위 모듈이 테이블 결과를 반환하지 않았습니다."),
}
end
if report.ok ~= true then
local errors = {}
appendNestedErrors(errors, "$.runtime." .. moduleName, report)
return nil, errors
end
return report, nil
end
local function validateAuthority(authorityState, staticData)
local report, errors = callModule(
"stateSchema",
"validateBattleState",
authorityState,
staticData
)
if errors then
return nil, errors
end
if report.referencesValidated ~= true then
return nil, {
makeError("static_references_not_validated", "$.staticData", "런타임 트랜잭션에는 전체 정적 데이터 검증이 필요합니다."),
}
end
return report.value or authorityState, nil
end
local function validateStoredPending(pendingTurn, staticData)
local shapeReport, shapeErrors = callModule(
"stateSchema",
"validatePendingTurn",
pendingTurn,
staticData
)
if shapeErrors then
return nil, shapeErrors
end
if shapeReport.referencesValidated ~= true then
return nil, {
makeError("static_references_not_validated", "$.staticData", "대기 트랜잭션 검증에는 전체 정적 데이터가 필요합니다."),
}
end
local replayReport, replayErrors = callModule(
"turnDraft",
"validateProjectionReceipt",
pendingTurn.beforeState,
staticData,
pendingTurn.projectionReceipt
)
if replayErrors then
return nil, replayErrors
end
if type(replayReport.projection) ~= "table" or type(replayReport.receipt) ~= "table" then
return nil, {
makeError("invalid_projection_replay", "$.projectionReceipt", "projection 영수증 재생 결과가 올바르지 않습니다."),
}
end
local pendingCopy, cloneError = cloneData(shapeReport.value or pendingTurn, "$.pendingTurn")
if cloneError then
return nil, { cloneError }
end
local presented, presentationErrors = callModule(
"turnPresentation",
"build",
pendingCopy,
staticData
)
if presentationErrors then
return nil, presentationErrors
end
if type(presented.lastTurn) ~= "table" or presented.lastTurn.available ~= true then
return nil, {
makeError(
"invalid_public_presentation",
"$.pendingTurn.turnResult.publicResult",
"공개 턴 표시를 생성하지 못했습니다."
),
}
end
return pendingCopy, nil
end
local function preparePending(authorityState, staticData, projection)
local validatedState, authorityErrors = validateAuthority(authorityState, staticData)
if authorityErrors then
return failure(authorityErrors)
end
if validatedState.status ~= "active" then
return failure({
makeError("prepare_requires_active", "$.authorityState.status", "active 전투에서만 턴을 판정할 수 있습니다."),
})
end
local receipt = validatedState.turnStartReceipt
if type(receipt) ~= "table" or type(receipt.turnId) ~= "string" then
return failure({
makeError("missing_turn_start_receipt", "$.authorityState.turnStartReceipt", "턴 판정 전 봉인된 turnStartReceipt가 필요합니다."),
})
end
local sealed, sealErrors = callModule(
"turnDraft",
"sealProjection",
validatedState,
staticData,
projection
)
if sealErrors then
return failure(sealErrors)
end
if type(sealed.projection) ~= "table" or type(sealed.receipt) ~= "table" then
return failure({
makeError("invalid_sealed_projection", "$.projection", "봉인된 projection 결과가 올바르지 않습니다."),
})
end
local resolved, resolveErrors = callModule(
"turnResolver",
"resolveTurn",
validatedState,
staticData,
sealed.projection,
{ turnId = receipt.turnId }
)
if resolveErrors then
return failure(resolveErrors)
end
local resolution = resolved.resolution
if type(resolution) ~= "table"
or resolution.battleId ~= validatedState.battleId
or resolution.turnId ~= receipt.turnId
or resolution.turnNumber ~= validatedState.turnNumber
or type(resolution.selectedCards) ~= "table"
or type(resolution.events) ~= "table"
or type(resolution.afterState) ~= "table" then
return failure({
makeError("invalid_turn_resolution", "$.turnResolution", "턴 해결 결과가 권위 상태와 연결되지 않습니다."),
})
end
local projected, projectErrors = callModule(
"turnEventProjector",
"projectTurn",
validatedState,
staticData,
resolution
)
if projectErrors then
return failure(projectErrors)
end
if type(projected.publicResult) ~= "table" or type(projected.llmEvent) ~= "table" then
return failure({
makeError("invalid_event_projection", "$.turnResolution", "턴 사건 투영 결과가 올바르지 않습니다."),
})
end
local historyReport, historyErrors = callModule(
"battleHistory",
"attachPublicResult",
resolution.afterState,
resolution.turnId,
projected.publicResult,
staticData
)
if historyErrors then
return failure(historyErrors)
end
if type(historyReport.state) ~= "table" then
return failure({
makeError("invalid_public_history_result", "$.runtime.battleHistory", "공개 전투 로그 연결 결과에 상태가 없습니다."),
})
end
resolution.afterState = historyReport.state
local constructed, constructErrors = callModule(
"stateSchema",
"newPendingTurn",
{
battleId = resolution.battleId,
turnId = resolution.turnId,
beforeState = validatedState,
projectionReceipt = sealed.receipt,
selectedCards = resolution.selectedCards,
turnResult = {
events = resolution.events,
publicResult = projected.publicResult,
llmEvent = projected.llmEvent,
},
afterState = resolution.afterState,
},
staticData
)
if constructErrors then
return failure(constructErrors)
end
local pendingTurn = constructed.value
if type(pendingTurn) ~= "table" then
return failure({
makeError("invalid_pending_result", "$.pendingTurn", "대기 트랜잭션 생성 결과가 올바르지 않습니다."),
})
end
local validatedPending, pendingErrors = validateStoredPending(pendingTurn, staticData)
if pendingErrors then
return failure(pendingErrors)
end
return pendingSuccess(validatedPending, false)
end
local function reusePending(authorityState, staticData, pendingTurn)
local validatedState, authorityErrors = validateAuthority(authorityState, staticData)
if authorityErrors then
return failure(authorityErrors)
end
local validatedPending, pendingErrors = validateStoredPending(pendingTurn, staticData)
if pendingErrors then
return failure(pendingErrors)
end
if validatedState.battleId ~= validatedPending.battleId then
return failure({
makeError("pending_battle_mismatch", "$.pendingTurn.battleId", "대기 트랜잭션이 현재 전투에 속하지 않습니다."),
})
end
if validatedState.lastCommittedTurnId == validatedPending.turnId then
return pendingSuccess(validatedPending, true)
end
if not deepEqual(validatedState, validatedPending.beforeState) then
return failure({
makeError("pending_authority_conflict", "$.authorityState", "현재 확정 상태가 대기 트랜잭션의 beforeState와 다릅니다."),
})
end
return pendingSuccess(validatedPending, true)
end
local function commitPending(authorityState, staticData, pendingTurn)
local validatedState, authorityErrors = validateAuthority(authorityState, staticData)
if authorityErrors then
return failure(authorityErrors)
end
local validatedPending, pendingErrors = validateStoredPending(pendingTurn, staticData)
if pendingErrors then
return failure(pendingErrors)
end
if validatedState.battleId ~= validatedPending.battleId then
return failure({
makeError("pending_battle_mismatch", "$.pendingTurn.battleId", "대기 트랜잭션이 현재 전투에 속하지 않습니다."),
})
end
if validatedState.lastCommittedTurnId == validatedPending.turnId then
local currentCopy, currentError = cloneData(validatedState, "$.authorityState")
if currentError then
return failure({ currentError })
end
return commitSuccess(currentCopy, validatedPending.turnId, false)
end
if not deepEqual(validatedState, validatedPending.beforeState) then
return failure({
makeError("pending_authority_conflict", "$.authorityState", "현재 확정 상태가 대기 트랜잭션의 beforeState와 다릅니다."),
})
end
local afterCopy, afterError = cloneData(validatedPending.afterState, "$.pendingTurn.afterState")
if afterError then
return failure({ afterError })
end
return commitSuccess(afterCopy, validatedPending.turnId, true)
end
local arguments = { ... }
if action == "preparePending" then
return preparePending(arguments[1], arguments[2], arguments[3])
elseif action == "reusePending" then
return reusePending(arguments[1], arguments[2], arguments[3])
elseif action == "commitPending" then
return commitPending(arguments[1], arguments[2], arguments[3])
end
return failure({
makeError("unknown_action", "$.action", "지원하지 않는 battleRuntime 작업입니다."),
})
end)
#32cardZones.lua
Keys:
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local MAX_PLAN_CAPACITY = 16
local VALID_OWNER = {
player = true,
character = true,
}
local ZONE_ORDER = {
"deck",
"hand",
"used",
"discard",
"removed",
"plan",
}
local VALID_ZONE = {}
for _, zone in ipairs(ZONE_ORDER) do
VALID_ZONE[zone] = true
end
local function makeError(code, path, message)
return {
code = code,
path = path,
message = message,
}
end
local function failure(errors)
return {
ok = false,
schemaVersion = SCHEMA_VERSION,
errors = errors,
}
end
local function success(state, movedInstanceIds, drawnInstanceIds)
return {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
state = state,
movedInstanceIds = movedInstanceIds or {},
drawnInstanceIds = drawnInstanceIds or {},
}
end
local function isFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function isInteger(value, minimum)
return isFinite(value)
and value % 1 == 0
and (minimum == nil or value >= minimum)
end
local function isPlanCapacity(value)
return isInteger(value, 1) and value <= MAX_PLAN_CAPACITY
end
local function cloneFailure(code, path, message)
error(makeError(code, path, message), 0)
end
local function cloneJson(value, path, active)
local valueType = type(value)
if valueType == "nil" or valueType == "string" or valueType == "boolean" then
return value
end
if valueType == "number" then
if not isFinite(value) then
cloneFailure("non_finite_number", path, "NaN과 무한대는 카드 영역 상태에 사용할 수 없습니다.")
end
return value
end
if valueType ~= "table" then
cloneFailure(
"unsupported_type",
path,
"JSON 상태에 저장할 수 없는 자료형입니다: " .. valueType
)
end
if getmetatable(value) ~= nil then
cloneFailure("metatable_not_allowed", path, "상태 테이블에는 메타테이블을 사용할 수 없습니다.")
end
active = active or {}
if active[value] then
cloneFailure("circular_reference", path, "순환 참조가 있는 상태는 복제할 수 없습니다.")
end
active[value] = true
local numericCount = 0
local maximum = 0
local hasNumeric = false
local hasString = false
local stringKeys = {}
for key in pairs(value) do
if type(key) == "number" then
hasNumeric = true
numericCount = numericCount + 1
if not isInteger(key, 1) then
cloneFailure("invalid_array_index", path, "배열 인덱스는 1 이상의 정수여야 합니다.")
end
if key > maximum then
maximum = key
end
elseif type(key) == "string" then
hasString = true
table.insert(stringKeys, key)
else
cloneFailure("invalid_object_key", path, "객체 키는 문자열이어야 합니다.")
end
end
if hasNumeric and hasString then
cloneFailure("mixed_table", path, "숫자 인덱스와 문자열 키를 함께 사용할 수 없습니다.")
end
local copy = {}
if hasNumeric then
if numericCount ~= maximum then
cloneFailure("sparse_array", path, "배열 인덱스는 1부터 빈틈없이 이어져야 합니다.")
end
for index = 1, maximum do
copy[index] = cloneJson(value[index], path .. "[" .. index .. "]", active)
end
else
table.sort(stringKeys)
for _, key in ipairs(stringKeys) do
copy[key] = cloneJson(value[key], path .. "." .. key, active)
end
end
active[value] = nil
return copy
end
local function cloneState(state, rootPath)
rootPath = rootPath or "$"
if type(state) ~= "table" then
return nil, makeError("invalid_state", rootPath, "battleState가 테이블이 아닙니다.")
end
local ok, cloned = pcall(cloneJson, state, rootPath, {})
if not ok then
if type(cloned) == "table" and cloned.code and cloned.path and cloned.message then
return nil, cloned
end
return nil, makeError("clone_failed", rootPath, "battleState 복제에 실패했습니다: " .. tostring(cloned))
end
return cloned, nil
end
local function validateOwner(owner, path)
if not VALID_OWNER[owner] then
return makeError("invalid_owner", path, "소유자는 player 또는 character여야 합니다.")
end
return nil
end
local validatePlanLinks
local function validateCardInstances(state, rootPath)
rootPath = rootPath or "$"
local errors = {}
if type(state.cardInstances) ~= "table" then
table.insert(errors, makeError("invalid_card_instances", rootPath .. ".cardInstances", "카드 인스턴스 배열이 없습니다."))
return errors
end
local itemCount = 0
local maximum = 0
local arrayShapeValid = true
for key in pairs(state.cardInstances) do
if not isInteger(key, 1) then
arrayShapeValid = false
table.insert(errors, makeError(
"invalid_card_instances",
rootPath .. ".cardInstances",
"cardInstances는 1부터 이어지는 배열이어야 합니다."
))
break
end
itemCount = itemCount + 1
if key > maximum then
maximum = key
end
end
if arrayShapeValid and itemCount ~= maximum then
arrayShapeValid = false
table.insert(errors, makeError(
"sparse_card_instances",
rootPath .. ".cardInstances",
"cardInstances 배열에 빈 인덱스가 있습니다."
))
end
if not arrayShapeValid then
return errors
end
local seenIds = {}
local instancesById = {}
local positions = {}
local groupCounts = {}
for index, instance in ipairs(state.cardInstances) do
local path = rootPath .. ".cardInstances[" .. index .. "]"
if type(instance) ~= "table" then
table.insert(errors, makeError("invalid_card_instance", path, "카드 인스턴스가 테이블이 아닙니다."))
else
if type(instance.instanceId) ~= "string" or instance.instanceId == "" then
table.insert(errors, makeError("invalid_instance_id", path .. ".instanceId", "카드 인스턴스 ID가 없습니다."))
elseif seenIds[instance.instanceId] then
table.insert(errors, makeError("duplicate_instance_id", path .. ".instanceId", "카드 인스턴스 ID가 중복되었습니다."))
else
seenIds[instance.instanceId] = true
instancesById[instance.instanceId] = instance
end
if type(instance.cardId) ~= "string" or instance.cardId == "" then
table.insert(errors, makeError("invalid_card_id", path .. ".cardId", "카드 ID가 없습니다."))
end
local ownerError = validateOwner(instance.owner, path .. ".owner")
if ownerError then
table.insert(errors, ownerError)
end
if not VALID_ZONE[instance.zone] then
table.insert(errors, makeError("invalid_zone", path .. ".zone", "알 수 없는 카드 영역입니다."))
end
if not isInteger(instance.position, 1) then
table.insert(errors, makeError("invalid_position", path .. ".position", "카드 위치는 1 이상의 정수여야 합니다."))
elseif VALID_OWNER[instance.owner] and VALID_ZONE[instance.zone] then
local group = instance.owner .. ":" .. instance.zone
positions[group] = positions[group] or {}
groupCounts[group] = (groupCounts[group] or 0) + 1
if positions[group][instance.position] then
table.insert(errors, makeError(
"duplicate_position",
path .. ".position",
group .. " 영역의 position이 중복되었습니다."
))
end
positions[group][instance.position] = true
end
end
end
for group, groupPositions in pairs(positions) do
local uniqueCount = 0
local maximum = 0
for position in pairs(groupPositions) do
uniqueCount = uniqueCount + 1
if position > maximum then
maximum = position
end
end
if uniqueCount ~= maximum then
table.insert(errors, makeError(
"non_contiguous_positions",
rootPath .. ".cardInstances",
group .. " 영역의 position이 1부터 이어지지 않습니다."
))
end
end
for _, owner in ipairs({ "player", "character" }) do
local ownerState = state[owner]
if type(ownerState) ~= "table" then
table.insert(errors, makeError("missing_owner_state", rootPath .. "." .. owner, "소유자 전투 상태가 없습니다."))
elseif not isInteger(ownerState.maxHandSize, 1) then
table.insert(errors, makeError(
"invalid_hand_size",
rootPath .. "." .. owner .. ".maxHandSize",
"최대 손패는 1 이상의 정수여야 합니다."
))
else
local handCount = groupCounts[owner .. ":hand"] or 0
if handCount > ownerState.maxHandSize then
local overflowAllowed = false
if owner == "player"
and type(state.selection) == "table"
and type(state.selection.playerCardInstanceIds) == "table" then
local restoredSelectionCount = 0
local counted = {}
for _, instanceId in ipairs(state.selection.playerCardInstanceIds) do
local selected = instancesById[instanceId]
if selected
and selected.owner == "player"
and selected.zone == "hand"
and not counted[instanceId] then
counted[instanceId] = true
restoredSelectionCount = restoredSelectionCount + 1
end
end
overflowAllowed = restoredSelectionCount >= handCount - ownerState.maxHandSize
end
if not overflowAllowed then
table.insert(errors, makeError(
"hand_limit_exceeded",
rootPath .. ".cardInstances",
owner .. " 손패가 최대 손패를 초과했습니다."
))
end
end
end
end
return errors
end
local function prepareState(state)
local cloned, cloneError = cloneState(state)
if cloneError then
return nil, { cloneError }
end
local errors = validateCardInstances(cloned)
if #errors == 0 then
local planErrors = validatePlanLinks(cloned, "$")
for _, item in ipairs(planErrors) do
table.insert(errors, item)
end
end
if #errors > 0 then
return nil, errors
end
return cloned, nil
end
local function collectZone(state, owner, zone)
local values = {}
for index, instance in ipairs(state.cardInstances) do
if instance.owner == owner and instance.zone == zone then
table.insert(values, {
instance = instance,
sourceIndex = index,
})
end
end
table.sort(values, function(left, right)
if left.instance.position ~= right.instance.position then
return left.instance.position < right.instance.position
end
if left.instance.instanceId ~= right.instance.instanceId then
return left.instance.instanceId < right.instance.instanceId
end
return left.sourceIndex < right.sourceIndex
end)
return values
end
local function normalizeZone(state, owner, zone)
for position, entry in ipairs(collectZone(state, owner, zone)) do
entry.instance.position = position
end
end
local function normalizeAll(state)
for _, owner in ipairs({ "player", "character" }) do
for _, zone in ipairs(ZONE_ORDER) do
normalizeZone(state, owner, zone)
end
end
end
local function findInstance(state, instanceId)
for _, instance in ipairs(state.cardInstances) do
if instance.instanceId == instanceId then
return instance
end
end
return nil
end
local function nextPosition(state, owner, zone)
return #collectZone(state, owner, zone) + 1
end
local function denseArrayLength(value)
if type(value) ~= "table" or getmetatable(value) ~= nil then
return nil
end
local count = 0
local maximum = 0
for key in pairs(value) do
if not isInteger(key, 1) then
return nil
end
count = count + 1
if key > maximum then
maximum = key
end
end
if count ~= maximum then
return nil
end
return maximum
end
local function validatePositionContinuity(state, rootPath)
rootPath = rootPath or "$"
local errors = {}
local groups = {}
for index, instance in ipairs(state.cardInstances) do
if VALID_OWNER[instance.owner]
and VALID_ZONE[instance.zone]
and isInteger(instance.position, 1) then
local group = instance.owner .. ":" .. instance.zone
groups[group] = groups[group] or {}
if groups[group][instance.position] then
table.insert(errors, makeError(
"duplicate_position",
rootPath .. ".cardInstances[" .. index .. "].position",
group .. " 영역의 position이 중복되었습니다."
))
end
groups[group][instance.position] = true
end
end
for group, positions in pairs(groups) do
local count = 0
local maximum = 0
for position in pairs(positions) do
count = count + 1
if position > maximum then
maximum = position
end
end
if count ~= maximum then
table.insert(errors, makeError(
"non_contiguous_positions",
rootPath .. ".cardInstances",
group .. " 영역의 position이 1부터 이어지지 않습니다."
))
end
end
return errors
end
validatePlanLinks = function(state, rootPath)
rootPath = rootPath or "$"
local errors = {}
for _, side in ipairs({ "player", "character" }) do
local sidePath = rootPath .. "." .. side
local ownerState = state[side]
if type(ownerState) ~= "table" then
table.insert(errors, makeError("missing_owner_state", sidePath, "소유자 전투 상태가 없습니다."))
else
local slots = ownerState.planSlots
local slotsPath = sidePath .. ".planSlots"
local slotCount = denseArrayLength(slots)
local planInstances = collectZone(state, side, "plan")
if not isPlanCapacity(ownerState.planCapacity) then
table.insert(errors, makeError(
"invalid_plan_capacity",
sidePath .. ".planCapacity",
"계획 용량은 1 이상 16 이하의 정수여야 합니다."
))
end
if slotCount == nil then
table.insert(errors, makeError(
"invalid_plan_slots",
slotsPath,
"planSlots는 점유 계획만 담는 1부터 이어지는 배열이어야 합니다."
))
else
if isPlanCapacity(ownerState.planCapacity) and slotCount > ownerState.planCapacity then
table.insert(errors, makeError(
"plan_capacity_exceeded",
slotsPath,
"점유 계획 수가 계획 용량을 초과했습니다."
))
end
if #planInstances ~= slotCount then
table.insert(errors, makeError(
"plan_link_mismatch",
rootPath .. ".cardInstances",
"plan 영역과 planSlots 수가 일치하지 않습니다: " .. side
))
end
local seenInstanceIds = {}
for index = 1, slotCount do
local slot = slots[index]
local slotPath = slotsPath .. "[" .. index .. "]"
if type(slot) ~= "table" or getmetatable(slot) ~= nil then
table.insert(errors, makeError("invalid_plan_slot", slotPath, "계획 슬롯이 일반 테이블이 아닙니다."))
elseif slot.occupied ~= true then
table.insert(errors, makeError(
"invalid_plan_occupied",
slotPath .. ".occupied",
"planSlots에는 occupied = true인 점유 슬롯만 저장할 수 있습니다."
))
else
if type(slot.cardInstanceId) == "string" and slot.cardInstanceId ~= "" then
if seenInstanceIds[slot.cardInstanceId] then
table.insert(errors, makeError(
"duplicate_plan_slot",
slotPath .. ".cardInstanceId",
"같은 계획 카드 인스턴스가 planSlots에 중복되었습니다."
))
else
seenInstanceIds[slot.cardInstanceId] = true
end
end
local instance = findInstance(state, slot.cardInstanceId)
if not instance then
table.insert(errors, makeError("missing_plan_instance", slotPath .. ".cardInstanceId", "계획 카드 인스턴스를 찾을 수 없습니다."))
else
if instance.owner ~= side then
table.insert(errors, makeError("plan_owner_mismatch", slotPath .. ".cardInstanceId", "계획 슬롯과 카드 소유자가 다릅니다."))
end
if instance.zone ~= "plan" then
table.insert(errors, makeError("plan_zone_mismatch", slotPath .. ".cardInstanceId", "계획 카드의 zone이 plan이 아닙니다."))
end
if instance.cardId ~= slot.cardId then
table.insert(errors, makeError("plan_card_mismatch", slotPath .. ".cardId", "계획 슬롯과 카드 인스턴스의 cardId가 다릅니다."))
end
if instance.position ~= index then
table.insert(errors, makeError(
"plan_position_mismatch",
slotPath .. ".cardInstanceId",
"plan 영역 position은 planSlots 배열 인덱스와 일치해야 합니다."
))
end
end
if not planInstances[index]
or planInstances[index].instance.instanceId ~= slot.cardInstanceId then
table.insert(errors, makeError(
"plan_link_mismatch",
rootPath .. ".cardInstances",
"plan 영역 순서와 planSlots 배열 순서가 일치하지 않습니다: " .. side
))
end
if not isInteger(slot.placedTurn, 1) then
table.insert(errors, makeError("invalid_placed_turn", slotPath .. ".placedTurn", "계획 배치 턴은 1 이상의 정수여야 합니다."))
elseif isInteger(state.turnNumber, 1) and slot.placedTurn > state.turnNumber then
table.insert(errors, makeError("future_placed_turn", slotPath .. ".placedTurn", "계획 배치 턴은 현재 턴보다 클 수 없습니다."))
end
if slot.revealed ~= true and slot.revealed ~= false then
table.insert(errors, makeError("invalid_revealed", slotPath .. ".revealed", "revealed는 불리언이어야 합니다."))
end
if slot.effectChoiceId ~= nil
and (type(slot.effectChoiceId) ~= "string"
or string.match(slot.effectChoiceId, "^[a-z][a-z0-9_]*$") == nil) then
table.insert(errors, makeError("invalid_effect_choice_id", slotPath .. ".effectChoiceId", "계획 효과 선택지 ID가 올바르지 않습니다."))
end
if slot.durationIncludesPlacementTurn ~= nil
and type(slot.durationIncludesPlacementTurn) ~= "boolean" then
table.insert(errors, makeError(
"invalid_plan_duration_policy",
slotPath .. ".durationIncludesPlacementTurn",
"배치 턴 포함 여부는 불리언이어야 합니다."
))
elseif slot.durationIncludesPlacementTurn == true and slot.remainingTurns == nil then
table.insert(errors, makeError(
"plan_duration_policy_requires_duration",
slotPath .. ".durationIncludesPlacementTurn",
"배치 턴을 포함하는 계획에는 남은 지속시간이 필요합니다."
))
end
local hasLifetime = false
if slot.remainingTurns ~= nil then
hasLifetime = true
if not isInteger(slot.remainingTurns, 1) then
table.insert(errors, makeError("invalid_remaining_turns", slotPath .. ".remainingTurns", "점유된 계획의 남은 지속시간은 양의 정수여야 합니다."))
end
end
if slot.remainingCharges ~= nil then
hasLifetime = true
if not isInteger(slot.remainingCharges, 1) then
table.insert(errors, makeError("invalid_remaining_charges", slotPath .. ".remainingCharges", "점유된 계획의 남은 충전은 양의 정수여야 합니다."))
end
end
if not hasLifetime then
table.insert(errors, makeError("missing_plan_lifetime", slotPath, "점유된 계획에는 지속시간이나 충전이 필요합니다."))
end
end
end
end
end
end
return errors
end
local function appendErrors(target, source)
for _, item in ipairs(source or {}) do
table.insert(target, item)
end
end
local function syncPlanPositions(state, side)
local ownerState = state[side]
for index, slot in ipairs(ownerState.planSlots) do
local instance = findInstance(state, slot.cardInstanceId)
if instance then
instance.position = index
end
end
end
local function discardPlanAt(state, side, slotIndex)
local ownerState = state[side]
local slot = ownerState.planSlots[slotIndex]
local instance = findInstance(state, slot.cardInstanceId)
instance.zone = "discard"
instance.position = nextPosition(state, side, "discard")
table.remove(ownerState.planSlots, slotIndex)
syncPlanPositions(state, side)
return instance.instanceId
end
local function findPlanSlotIndex(state, side, instanceId)
for index, slot in ipairs(state[side].planSlots) do
if slot.cardInstanceId == instanceId then
return index
end
end
return nil
end
local function appendNestedErrors(errors, nested)
if type(nested) ~= "table" or #nested == 0 then
table.insert(errors, makeError("rng_failed", "$.rng", "결정적 셔플이 실패했습니다."))
return
end
for _, item in ipairs(nested) do
table.insert(errors, makeError(
"rng_" .. tostring(item.code or "failed"),
tostring(item.path or "$.rng"),
tostring(item.message or "결정적 셔플이 실패했습니다.")
))
end
end
local function shuffleIds(state, instanceIds)
local callOk, report = pcall(
runScript,
triggerId,
"deterministicRng",
"shuffle",
state.rng,
instanceIds
)
if not callOk then
return nil, { makeError("rng_call_failed", "$.rng", "결정적 셔플 호출에 실패했습니다: " .. tostring(report)) }
end
if type(report) ~= "table" or report.ok ~= true then
local errors = {}
appendNestedErrors(errors, type(report) == "table" and report.errors or nil)
return nil, errors
end
if type(report.value) ~= "table" or #report.value ~= #instanceIds then
return nil, { makeError("invalid_rng_result", "$.rng", "셔플 결과 배열의 길이가 올바르지 않습니다.") }
end
local expected = {}
for _, instanceId in ipairs(instanceIds) do
expected[instanceId] = (expected[instanceId] or 0) + 1
end
for index, instanceId in ipairs(report.value) do
if type(instanceId) ~= "string" or not expected[instanceId] or expected[instanceId] == 0 then
return nil, { makeError("invalid_rng_result", "$.rng.value[" .. index .. "]", "셔플 결과가 원본 카드 ID 순열이 아닙니다.") }
end
expected[instanceId] = expected[instanceId] - 1
end
local rngOk, rngCopy = pcall(cloneJson, report.rng, "$.rng", {})
if not rngOk or type(rngCopy) ~= "table" then
return nil, { makeError("invalid_rng_result", "$.rng", "셔플 결과의 RNG 상태가 올바르지 않습니다.") }
end
state.rng = rngCopy
local valueCopy = {}
for index, instanceId in ipairs(report.value) do
valueCopy[index] = instanceId
end
return valueCopy, nil
end
local function applyZoneOrder(state, owner, zone, instanceIds)
for position, instanceId in ipairs(instanceIds) do
local instance = findInstance(state, instanceId)
if not instance or instance.owner ~= owner then
return makeError("invalid_zone_order", "$.cardInstances", "카드 영역 순서를 적용할 인스턴스를 찾을 수 없습니다.")
end
instance.zone = zone
instance.position = position
end
return nil
end
local function shuffleDeck(state, owner)
local ownerError = validateOwner(owner, "$.owner")
if ownerError then
return failure({ ownerError })
end
local nextState, errors = prepareState(state)
if errors then
return failure(errors)
end
normalizeAll(nextState)
local instanceIds = {}
for _, entry in ipairs(collectZone(nextState, owner, "deck")) do
table.insert(instanceIds, entry.instance.instanceId)
end
local shuffled, shuffleErrors = shuffleIds(nextState, instanceIds)
if shuffleErrors then
return failure(shuffleErrors)
end
local orderError = applyZoneOrder(nextState, owner, "deck", shuffled)
if orderError then
return failure({ orderError })
end
normalizeAll(nextState)
return success(nextState, {}, {})
end
local function draw(state, owner, amount)
local errors = {}
local ownerError = validateOwner(owner, "$.owner")
if ownerError then
table.insert(errors, ownerError)
end
if not isInteger(amount, 0) then
table.insert(errors, makeError("invalid_draw_amount", "$.amount", "드로우 수량은 0 이상의 정수여야 합니다."))
end
if #errors > 0 then
return failure(errors)
end
local nextState, stateErrors = prepareState(state)
if stateErrors then
return failure(stateErrors)
end
normalizeAll(nextState)
local ownerState = nextState[owner]
if type(ownerState) ~= "table" then
return failure({ makeError("missing_owner_state", "$." .. owner, "소유자 전투 상태가 없습니다.") })
end
if not isInteger(ownerState.maxHandSize, 1) then
return failure({ makeError("invalid_hand_size", "$." .. owner .. ".maxHandSize", "최대 손패는 1 이상의 정수여야 합니다.") })
end
local handCount = #collectZone(nextState, owner, "hand")
local capacity = math.max(0, ownerState.maxHandSize - handCount)
local targetCount = math.min(amount, capacity)
local drawnInstanceIds = {}
while #drawnInstanceIds < targetCount do
local deck = collectZone(nextState, owner, "deck")
if #deck == 0 then
local discardIds = {}
for _, entry in ipairs(collectZone(nextState, owner, "discard")) do
table.insert(discardIds, entry.instance.instanceId)
end
if #discardIds == 0 then
break
end
local shuffled, shuffleErrors = shuffleIds(nextState, discardIds)
if shuffleErrors then
return failure(shuffleErrors)
end
local orderError = applyZoneOrder(nextState, owner, "deck", shuffled)
if orderError then
return failure({ orderError })
end
normalizeZone(nextState, owner, "discard")
normalizeZone(nextState, owner, "deck")
deck = collectZone(nextState, owner, "deck")
end
local drawn = deck[1].instance
drawn.zone = "hand"
drawn.position = nextPosition(nextState, owner, "hand")
table.insert(drawnInstanceIds, drawn.instanceId)
normalizeZone(nextState, owner, "deck")
normalizeZone(nextState, owner, "hand")
end
normalizeAll(nextState)
return success(nextState, {}, drawnInstanceIds)
end
local function moveHandToUsed(state, instanceId)
if type(instanceId) ~= "string" or instanceId == "" then
return failure({ makeError("invalid_instance_id", "$.instanceId", "카드 인스턴스 ID가 없습니다.") })
end
local nextState, errors = prepareState(state)
if errors then
return failure(errors)
end
normalizeAll(nextState)
local instance = findInstance(nextState, instanceId)
if not instance then
return failure({ makeError("instance_not_found", "$.instanceId", "카드 인스턴스를 찾을 수 없습니다.") })
end
if instance.zone ~= "hand" then
return failure({ makeError("invalid_source_zone", "$.instanceId", "used 영역으로 옮길 카드는 hand 영역에 있어야 합니다.") })
end
instance.zone = "used"
instance.position = nextPosition(nextState, instance.owner, "used")
normalizeAll(nextState)
return success(nextState, { instanceId }, {})
end
local function moveUsedToHand(state, instanceId)
if type(instanceId) ~= "string" or instanceId == "" then
return failure({ makeError("invalid_instance_id", "$.instanceId", "카드 인스턴스 ID가 없습니다.") })
end
local nextState, errors = prepareState(state)
if errors then
return failure(errors)
end
normalizeAll(nextState)
local instance = findInstance(nextState, instanceId)
if not instance then
return failure({ makeError("instance_not_found", "$.instanceId", "카드 인스턴스를 찾을 수 없습니다.") })
end
if instance.zone ~= "used" then
return failure({ makeError("invalid_source_zone", "$.instanceId", "hand 영역으로 복원할 카드는 used 영역에 있어야 합니다.") })
end
if instance.owner ~= "player" then
return failure({ makeError("invalid_restore_owner", "$.instanceId", "used → hand 구조 복원은 플레이어 등록 카드에만 사용할 수 있습니다.") })
end
local registered = false
for _, selectedId in ipairs(
type(nextState.selection) == "table"
and type(nextState.selection.playerCardInstanceIds) == "table"
and nextState.selection.playerCardInstanceIds
or {}
) do
if selectedId == instanceId then
registered = true
break
end
end
if not registered then
return failure({ makeError("restore_requires_selection", "$.instanceId", "등록 선택에 없는 used 카드는 손패로 복원할 수 없습니다.") })
end
local ownerState = nextState[instance.owner]
if type(ownerState) ~= "table" or not isInteger(ownerState.maxHandSize, 1) then
return failure({ makeError(
"invalid_hand_size",
"$." .. tostring(instance.owner) .. ".maxHandSize",
"최대 손패는 1 이상의 정수여야 합니다."
) })
end
instance.zone = "hand"
instance.position = nextPosition(nextState, instance.owner, "hand")
normalizeAll(nextState)
return success(nextState, { instanceId }, {})
end
local function moveToRemoved(state, instanceId)
if type(instanceId) ~= "string" or instanceId == "" then
return failure({ makeError("invalid_instance_id", "$.instanceId", "카드 인스턴스 ID가 없습니다.") })
end
local nextState, errors = prepareState(state)
if errors then
return failure(errors)
end
normalizeAll(nextState)
local instance = findInstance(nextState, instanceId)
if not instance then
return failure({ makeError("instance_not_found", "$.instanceId", "카드 인스턴스를 찾을 수 없습니다.") })
end
if instance.zone == "removed" then
return failure({ makeError("already_removed", "$.instanceId", "카드가 이미 removed 영역에 있습니다.") })
end
if instance.zone == "plan" then
return failure({ makeError("plan_slot_required", "$.instanceId", "plan 카드는 계획 슬롯 처리 없이 removed 영역으로 옮길 수 없습니다.") })
end
instance.zone = "removed"
instance.position = nextPosition(nextState, instance.owner, "removed")
normalizeAll(nextState)
return success(nextState, { instanceId }, {})
end
local function validatePlanSpec(planSpec)
local errors = {}
if type(planSpec) ~= "table" or getmetatable(planSpec) ~= nil then
return nil, {
makeError("invalid_plan_spec", "$.planSpec", "planSpec은 메타테이블 없는 테이블이어야 합니다."),
}
end
local allowed = {
durationTurns = true,
durationIncludesPlacementTurn = true,
charges = true,
revealed = true,
effectChoiceId = true,
}
for key in pairs(planSpec) do
if type(key) ~= "string" or not allowed[key] then
table.insert(errors, makeError(
"unknown_plan_spec_field",
"$.planSpec." .. tostring(key),
"planSpec에 허용되지 않은 필드가 있습니다."
))
end
end
if planSpec.durationTurns ~= nil and not isInteger(planSpec.durationTurns, 1) then
table.insert(errors, makeError(
"invalid_plan_duration",
"$.planSpec.durationTurns",
"계획 지속시간은 양의 정수여야 합니다."
))
end
if planSpec.durationIncludesPlacementTurn ~= nil
and type(planSpec.durationIncludesPlacementTurn) ~= "boolean" then
table.insert(errors, makeError(
"invalid_plan_duration_policy",
"$.planSpec.durationIncludesPlacementTurn",
"배치 턴 포함 여부는 불리언이어야 합니다."
))
elseif planSpec.durationIncludesPlacementTurn == true
and not isInteger(planSpec.durationTurns, 1) then
table.insert(errors, makeError(
"plan_duration_policy_requires_duration",
"$.planSpec.durationIncludesPlacementTurn",
"배치 턴을 포함하려면 양의 durationTurns가 필요합니다."
))
end
if planSpec.charges ~= nil and not isInteger(planSpec.charges, 1) then
table.insert(errors, makeError(
"invalid_plan_charges",
"$.planSpec.charges",
"계획 충전은 양의 정수여야 합니다."
))
end
if planSpec.durationTurns == nil and planSpec.charges == nil then
table.insert(errors, makeError(
"missing_plan_lifetime",
"$.planSpec",
"계획에는 durationTurns 또는 charges가 필요합니다."
))
end
if planSpec.revealed ~= nil and planSpec.revealed ~= true and planSpec.revealed ~= false then
table.insert(errors, makeError(
"invalid_plan_revealed",
"$.planSpec.revealed",
"revealed는 불리언이어야 합니다."
))
end
if planSpec.effectChoiceId ~= nil
and (type(planSpec.effectChoiceId) ~= "string"
or string.match(planSpec.effectChoiceId, "^[a-z][a-z0-9_]*$") == nil) then
table.insert(errors, makeError("invalid_effect_choice_id", "$.planSpec.effectChoiceId", "계획 효과 선택지 ID가 올바르지 않습니다."))
end
if #errors > 0 then
return nil, errors
end
return {
durationTurns = planSpec.durationTurns,
durationIncludesPlacementTurn = planSpec.durationIncludesPlacementTurn == true,
charges = planSpec.charges,
revealed = planSpec.revealed == true,
effectChoiceId = planSpec.effectChoiceId,
}, nil
end
local function placePlan(state, side, instanceId, planSpec)
local errors = {}
local sideError = validateOwner(side, "$.side")
if sideError then
table.insert(errors, sideError)
end
if type(instanceId) ~= "string" or instanceId == "" then
table.insert(errors, makeError("invalid_instance_id", "$.instanceId", "카드 인스턴스 ID가 없습니다."))
end
local normalizedSpec, specErrors = validatePlanSpec(planSpec)
appendErrors(errors, specErrors)
if #errors > 0 then
return failure(errors)
end
local nextState, stateErrors = prepareState(state)
if stateErrors then
return failure(stateErrors)
end
normalizeAll(nextState)
if not isInteger(nextState.turnNumber, 1) then
return failure({ makeError("invalid_turn_number", "$.turnNumber", "현재 턴은 1 이상의 정수여야 합니다.") })
end
local planErrors = validatePlanLinks(nextState, "$")
if #planErrors > 0 then
return failure(planErrors)
end
local instance = findInstance(nextState, instanceId)
if not instance then
return failure({ makeError("instance_not_found", "$.instanceId", "카드 인스턴스를 찾을 수 없습니다.") })
end
if instance.owner ~= side then
return failure({ makeError("plan_owner_mismatch", "$.instanceId", "계획 카드와 슬롯의 소유자가 다릅니다.") })
end
if instance.zone ~= "hand" and instance.zone ~= "used" then
return failure({ makeError("invalid_source_zone", "$.instanceId", "계획 카드는 hand 또는 used 영역에 있어야 합니다.") })
end
local movedInstanceIds = {}
local ownerState = nextState[side]
if #ownerState.planSlots >= ownerState.planCapacity then
table.insert(movedInstanceIds, discardPlanAt(nextState, side, 1))
end
instance.zone = "plan"
instance.position = #ownerState.planSlots + 1
local slot = {
occupied = true,
cardInstanceId = instance.instanceId,
cardId = instance.cardId,
placedTurn = nextState.turnNumber,
durationIncludesPlacementTurn = normalizedSpec.durationIncludesPlacementTurn,
revealed = normalizedSpec.revealed,
}
if normalizedSpec.durationTurns ~= nil then
slot.remainingTurns = normalizedSpec.durationTurns
end
if normalizedSpec.charges ~= nil then
slot.remainingCharges = normalizedSpec.charges
end
if normalizedSpec.effectChoiceId ~= nil then
slot.effectChoiceId = normalizedSpec.effectChoiceId
end
table.insert(ownerState.planSlots, slot)
table.insert(movedInstanceIds, instance.instanceId)
normalizeAll(nextState)
local outputErrors = validatePlanLinks(nextState, "$")
if #outputErrors > 0 then
return failure(outputErrors)
end
return success(nextState, movedInstanceIds, {})
end
local function consumePlanCharge(state, side, instanceId)
local errors = {}
local sideError = validateOwner(side, "$.side")
if sideError then
table.insert(errors, sideError)
end
if instanceId ~= nil and (type(instanceId) ~= "string" or instanceId == "") then
table.insert(errors, makeError("invalid_instance_id", "$.instanceId", "계획 카드 인스턴스 ID가 올바르지 않습니다."))
end
if #errors > 0 then
return failure(errors)
end
local nextState, stateErrors = prepareState(state)
if stateErrors then
return failure(stateErrors)
end
normalizeAll(nextState)
local planErrors = validatePlanLinks(nextState, "$")
if #planErrors > 0 then
return failure(planErrors)
end
local slots = nextState[side].planSlots
local slotIndex
if instanceId == nil then
if #slots == 0 then
return failure({ makeError("empty_plan_slots", "$." .. side .. ".planSlots", "발동할 계획이 없습니다.") })
end
if #slots > 1 then
return failure({ makeError(
"ambiguous_plan_slot",
"$.instanceId",
"점유 계획이 둘 이상이면 소비할 카드 인스턴스 ID를 지정해야 합니다."
) })
end
slotIndex = 1
instanceId = slots[1].cardInstanceId
else
slotIndex = findPlanSlotIndex(nextState, side, instanceId)
if slotIndex == nil then
return failure({ makeError(
"plan_instance_not_found",
"$.instanceId",
"해당 진영의 점유 계획에서 카드 인스턴스를 찾을 수 없습니다."
) })
end
end
local slot = slots[slotIndex]
slot.revealed = true
local movedInstanceIds = {}
if slot.remainingCharges ~= nil then
slot.remainingCharges = slot.remainingCharges - 1
if slot.remainingCharges == 0 then
table.insert(movedInstanceIds, discardPlanAt(nextState, side, slotIndex))
end
end
normalizeAll(nextState)
local outputErrors = validatePlanLinks(nextState, "$")
if #outputErrors > 0 then
return failure(outputErrors)
end
return success(nextState, movedInstanceIds, {})
end
local function setPlanCapacity(state, side, capacity)
local errors = {}
local sideError = validateOwner(side, "$.side")
if sideError then
table.insert(errors, sideError)
end
if not isPlanCapacity(capacity) then
table.insert(errors, makeError(
"invalid_plan_capacity",
"$.capacity",
"계획 용량은 1 이상 16 이하의 정수여야 합니다."
))
end
if #errors > 0 then
return failure(errors)
end
local nextState, stateErrors = prepareState(state)
if stateErrors then
return failure(stateErrors)
end
normalizeAll(nextState)
local ownerState = nextState[side]
ownerState.planCapacity = capacity
local movedInstanceIds = {}
while #ownerState.planSlots > capacity do
table.insert(movedInstanceIds, discardPlanAt(nextState, side, 1))
end
normalizeAll(nextState)
local outputErrors = validatePlanLinks(nextState, "$")
if #outputErrors > 0 then
return failure(outputErrors)
end
return success(nextState, movedInstanceIds, {})
end
local function modifyOldestPlan(state, side, spec)
local ownerError = validateOwner(side, "$.side")
if ownerError then return failure({ ownerError }) end
if type(spec) ~= "table" or getmetatable(spec) ~= nil then
return failure({ makeError("invalid_plan_modification", "$.spec", "계획 변경 명세가 올바르지 않습니다.") })
end
local nextState, stateErrors = prepareState(state)
if stateErrors then return failure(stateErrors) end
normalizeAll(nextState)
local slots = nextState[side].planSlots
if #slots == 0 then return success(nextState, {}, {}) end
local affectedIds = {}
local lastIndex = spec.all == true and #slots or 1
for index = lastIndex, 1, -1 do
local slot = slots[index]
table.insert(affectedIds, 1, slot.cardInstanceId)
if spec.remove == true then
discardPlanAt(nextState, side, index)
else
if spec.remainingTurnsDelta ~= nil and slot.remainingTurns ~= nil then
slot.remainingTurns = slot.remainingTurns + spec.remainingTurnsDelta
end
if spec.remainingChargesDelta ~= nil and slot.remainingCharges ~= nil then
slot.remainingCharges = math.max(1, slot.remainingCharges + spec.remainingChargesDelta)
end
if slot.remainingTurns ~= nil and slot.remainingTurns <= 0 then
discardPlanAt(nextState, side, index)
end
end
end
normalizeAll(nextState)
local outputErrors = validatePlanLinks(nextState, "$")
if #outputErrors > 0 then return failure(outputErrors) end
return success(nextState, affectedIds, {})
end
local function endTurnCleanup(state)
local nextState, stateErrors = prepareState(state)
if stateErrors then
return failure(stateErrors)
end
normalizeAll(nextState)
if not isInteger(nextState.turnNumber, 1) then
return failure({ makeError("invalid_turn_number", "$.turnNumber", "현재 턴은 1 이상의 정수여야 합니다.") })
end
local planErrors = validatePlanLinks(nextState, "$")
if #planErrors > 0 then
return failure(planErrors)
end
local movedInstanceIds = {}
for _, side in ipairs({ "player", "character" }) do
for _, sourceZone in ipairs({ "used", "hand" }) do
local source = collectZone(nextState, side, sourceZone)
for _, entry in ipairs(source) do
entry.instance.zone = "discard"
entry.instance.position = nextPosition(nextState, side, "discard")
table.insert(movedInstanceIds, entry.instance.instanceId)
end
end
end
nextState.selection = {
playerCardInstanceIds = {},
}
nextState.characterIntent = {
cardInstanceIds = {},
}
nextState.turnStartReceipt = nil
for _, side in ipairs({ "player", "character" }) do
local survivors = {}
for _, slot in ipairs(nextState[side].planSlots) do
if slot.remainingTurns ~= nil
and (slot.placedTurn < nextState.turnNumber
or slot.durationIncludesPlacementTurn == true) then
slot.remainingTurns = slot.remainingTurns - 1
end
if slot.remainingTurns == 0 then
local instance = findInstance(nextState, slot.cardInstanceId)
instance.zone = "discard"
instance.position = nextPosition(nextState, side, "discard")
table.insert(movedInstanceIds, instance.instanceId)
else
table.insert(survivors, slot)
end
end
nextState[side].planSlots = survivors
syncPlanPositions(nextState, side)
end
normalizeAll(nextState)
local outputErrors = validatePlanLinks(nextState, "$")
if #outputErrors > 0 then
return failure(outputErrors)
end
return success(nextState, movedInstanceIds, {})
end
local function validateConservation(beforeState, afterState)
local beforeCopy, beforeCloneError = cloneState(beforeState, "$.beforeState")
if beforeCloneError then
return failure({ beforeCloneError })
end
local afterCopy, afterCloneError = cloneState(afterState, "$.afterState")
if afterCloneError then
return failure({ afterCloneError })
end
local errors = {}
appendErrors(errors, validateCardInstances(beforeCopy, "$.beforeState"))
appendErrors(errors, validateCardInstances(afterCopy, "$.afterState"))
if #errors > 0 then
return failure(errors)
end
appendErrors(errors, validatePositionContinuity(beforeCopy, "$.beforeState"))
appendErrors(errors, validatePositionContinuity(afterCopy, "$.afterState"))
appendErrors(errors, validatePlanLinks(beforeCopy, "$.beforeState"))
appendErrors(errors, validatePlanLinks(afterCopy, "$.afterState"))
local beforeById = {}
local afterById = {}
for _, instance in ipairs(beforeCopy.cardInstances) do
beforeById[instance.instanceId] = instance
end
for _, instance in ipairs(afterCopy.cardInstances) do
afterById[instance.instanceId] = instance
end
for instanceId, beforeInstance in pairs(beforeById) do
local afterInstance = afterById[instanceId]
if not afterInstance then
table.insert(errors, makeError(
"missing_card_instance",
"$.afterState.cardInstances",
"이후 상태에서 카드 인스턴스가 사라졌습니다: " .. instanceId
))
else
if beforeInstance.cardId ~= afterInstance.cardId then
table.insert(errors, makeError(
"card_id_changed",
"$.afterState.cardInstances",
"카드 인스턴스의 cardId가 변경되었습니다: " .. instanceId
))
end
if beforeInstance.owner ~= afterInstance.owner then
table.insert(errors, makeError(
"card_owner_changed",
"$.afterState.cardInstances",
"카드 인스턴스의 owner가 변경되었습니다: " .. instanceId
))
end
end
end
for instanceId in pairs(afterById) do
if not beforeById[instanceId] then
table.insert(errors, makeError(
"unexpected_card_instance",
"$.afterState.cardInstances",
"이후 상태에 새 카드 인스턴스가 생겼습니다: " .. instanceId
))
end
end
if #errors > 0 then
return failure(errors)
end
return success(afterCopy, {}, {})
end
local arguments = { ... }
local actions = {
shuffleDeck = shuffleDeck,
draw = draw,
moveHandToUsed = moveHandToUsed,
moveUsedToHand = moveUsedToHand,
moveToRemoved = moveToRemoved,
placePlan = placePlan,
consumePlanCharge = consumePlanCharge,
setPlanCapacity = setPlanCapacity,
modifyOldestPlan = modifyOldestPlan,
endTurnCleanup = endTurnCleanup,
validateConservation = validateConservation,
}
local handler = actions[action]
if not handler then
return failure({
makeError(
"unknown_action",
"$.action",
"지원하지 않는 카드 영역 작업입니다: " .. tostring(action)
),
})
end
return handler(arguments[1], arguments[2], arguments[3], arguments[4])
end)
#33characterSelector.lua
Keys:
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local MAX_SAFE_INTEGER = 9007199254740991
local SCORE_SCALE = 3
local MOOD_POSITION_SCALE = 4
local MOOD_STEALTH_SCALE = 2
local MOOD_TOKEN_SCALE = 2
local MOOD_ANCHOR_SCALE = 2
local SCORE_OPERATIONS = {
recover_resistance = { scoreDirection = 1, stealthDirection = 0 },
lose_stealth = { scoreDirection = 1, stealthDirection = -1 },
damage_resistance = { scoreDirection = -1, stealthDirection = 0 },
recover_stealth = { scoreDirection = -1, stealthDirection = 1 },
}
local TOTAL_FIELD = {
recover_resistance = "recoverResistance",
lose_stealth = "loseStealth",
damage_resistance = "damageResistance",
recover_stealth = "recoverStealth",
}
local function makeError(code, path, message)
return { code = code, path = path, message = message }
end
local function failure(errors)
return { ok = false, schemaVersion = SCHEMA_VERSION, errors = errors }
end
local function success(state, intent, receipt)
return {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
state = state,
intent = intent,
receipt = receipt,
}
end
local function isFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function isInteger(value, minimum)
return isFinite(value)
and value % 1 == 0
and (minimum == nil or value >= minimum)
end
local function isSafeInteger(value, minimum)
return isInteger(value, minimum) and math.abs(value) <= MAX_SAFE_INTEGER
end
local function isDenseArray(value)
if type(value) ~= "table" or getmetatable(value) ~= nil then return false end
local count = 0
local maximum = 0
for key in pairs(value) do
if not isInteger(key, 1) then return false end
count = count + 1
if key > maximum then maximum = key end
end
return count == maximum
end
local function cloneData(value, path, active)
local valueType = type(value)
if valueType == "nil" or valueType == "string" or valueType == "boolean" then return value, nil end
if valueType == "number" then
if not isFinite(value) then
return nil, makeError("non_finite_number", path, "NaN과 무한대는 선택 상태에 사용할 수 없습니다.")
end
return value, nil
end
if valueType ~= "table" then
return nil, makeError("unsupported_type", path, "JSON 선택 상태에 저장할 수 없는 자료형입니다: " .. valueType)
end
if getmetatable(value) ~= nil then
return nil, makeError("metatable_not_allowed", path, "선택 상태에는 메타테이블을 사용할 수 없습니다.")
end
active = active or {}
if active[value] then return nil, makeError("circular_reference", path, "순환 참조가 있는 선택 상태는 복제할 수 없습니다.") end
active[value] = true
local copy = {}
for key, item in pairs(value) do
local keyCopy, keyError = cloneData(key, path .. ".<key>", active)
if keyError then active[value] = nil return nil, keyError end
local itemCopy, itemError = cloneData(item, path .. "." .. tostring(key), active)
if itemError then active[value] = nil return nil, itemError end
copy[keyCopy] = itemCopy
end
active[value] = nil
return copy, nil
end
local function deepEqual(left, right, seen)
if type(left) ~= type(right) then return false end
if type(left) ~= "table" then return left == right end
seen = seen or {}
if seen[left] == right then return true end
seen[left] = right
for key, value in pairs(left) do
if not deepEqual(value, right[key], seen) then return false end
end
for key in pairs(right) do
if left[key] == nil then return false end
end
return true
end
local function normalizeStaticData(staticData)
if type(staticData) == "table" and type(staticData.data) == "table" then return staticData.data end
return staticData
end
local function appendErrors(target, source)
if type(source) ~= "table" then
target[#target + 1] = makeError("invalid_nested_error", "$", "하위 모듈 오류 목록이 올바르지 않습니다.")
return
end
for _, item in ipairs(source) do
target[#target + 1] = {
code = tostring(type(item) == "table" and item.code or "nested_error"),
path = tostring(type(item) == "table" and item.path or "$"),
message = tostring(type(item) == "table" and item.message or "하위 모듈 작업이 실패했습니다."),
}
end
end
local function callModule(moduleName, moduleAction, ...)
if type(runScript) ~= "function" then
return nil, { makeError("runtime_unavailable", "$.runtime." .. moduleName, "스크립트 실행기를 찾을 수 없습니다.") }
end
local ok, report = pcall(runScript, triggerId, moduleName, moduleAction, ...)
if not ok then
return nil, { makeError("module_call_error", "$.runtime." .. moduleName, moduleName .. "." .. moduleAction .. " 실행에 실패했습니다: " .. tostring(report)) }
end
if type(report) ~= "table" then
return nil, { makeError("invalid_module_result", "$.runtime." .. moduleName, "하위 모듈이 테이블 결과를 반환하지 않았습니다.") }
end
if report.ok ~= true then
local errors = {}
appendErrors(errors, report.errors)
return nil, errors
end
return report, nil
end
local function countZone(state, owner, zone)
local count = 0
for _, instance in ipairs(type(state.cardInstances) == "table" and state.cardInstances or {}) do
if instance.owner == owner and instance.zone == zone then count = count + 1 end
end
return count
end
local function moodTokenSnapshot(state, staticData)
local snapshot = {}
local source = type(state) == "table" and type(state.character) == "table" and type(state.character.moodTokens) == "table" and state.character.moodTokens or {}
local moods = type(staticData) == "table" and type(staticData.registry) == "table" and type(staticData.registry.moods) == "table" and staticData.registry.moods or {}
for moodId in pairs(moods) do snapshot[moodId] = source[moodId] or 0 end
return snapshot
end
local function orderedCharacterHand(state)
local hand = {}
for sourceIndex, instance in ipairs(type(state.cardInstances) == "table" and state.cardInstances or {}) do
if instance.owner == "character" and instance.zone == "hand" then
hand[#hand + 1] = { instance = instance, sourceIndex = sourceIndex }
end
end
table.sort(hand, function(left, right)
if left.instance.position ~= right.instance.position then return left.instance.position < right.instance.position end
if left.instance.instanceId ~= right.instance.instanceId then return left.instance.instanceId < right.instance.instanceId end
return left.sourceIndex < right.sourceIndex
end)
return hand
end
local function buildHistoryContext(state)
if type(state) == "table" and type(state.historyContextOverride) == "table" then return state.historyContextOverride end
local report, errors = callModule("battleHistory", "context", type(state) == "table" and state.history or nil)
if errors or type(report) ~= "table" or type(report.context) ~= "table" then error("battleHistory.context failed", 0) end
return report.context
end
local function buildSelectionContext(state, staticData, hand)
local characterHand = {}
for index, entry in ipairs(hand) do
local instance = entry.instance
local card = type(staticData.cards) == "table" and staticData.cards[instance.cardId] or nil
characterHand[index] = {
instanceId = instance.instanceId,
cardId = instance.cardId,
role = type(card) == "table" and card.roles[1] or nil,
handPosition = instance.position,
}
end
return {
turnNumber = state.turnNumber,
history = buildHistoryContext(state),
player = { stealth = state.player.stealth, handCount = countZone(state, "player", "hand") },
character = {
resistance = state.character.resistance,
mood = state.character.mood,
moodTokens = moodTokenSnapshot(state, staticData),
},
characterHand = characterHand,
}
end
local function buildContext(state, staticData, card, instance, plan)
local context = {
turn = state.turnNumber,
phase = "character_selection",
mood = state.character.mood,
history = buildHistoryContext(state),
player = { stealth = state.player.stealth, handCount = countZone(state, "player", "hand") },
character = {
resistance = state.character.resistance,
moodTokens = moodTokenSnapshot(state, staticData),
publicRole = nil,
},
}
if card ~= nil and instance ~= nil then
context.card = { id = card.id, instanceId = instance.instanceId, owner = card.owner, roles = card.roles }
end
if plan ~= nil then
context.plan = {
cardId = plan.cardId,
cardInstanceId = plan.cardInstanceId,
side = plan.side,
revealed = false,
remainingCharges = plan.remainingCharges,
}
if plan.remainingTurns ~= nil then context.plan.remainingTurns = plan.remainingTurns end
end
return context
end
local function emptyTotals()
return { recoverResistance = 0, loseStealth = 0, damageResistance = 0, recoverStealth = 0 }
end
local function scoreCommands(commands, totals, path, moodCommands)
if not isDenseArray(commands) then
return nil, makeError("invalid_scoring_commands", path, "점수화할 효과 명령이 연속 배열이 아닙니다.")
end
local scoreDelta = 0
local stealthDelta = 0
for index, command in ipairs(commands) do
local commandPath = path .. "[" .. index .. "]"
local isMoodCommand = type(command) == "table"
and (command.op == "add_mood_token" or command.op == "remove_mood_token" or command.op == "force_mood")
if isMoodCommand then
moodCommands[#moodCommands + 1] = command
else
local operation = type(command) == "table" and SCORE_OPERATIONS[command.op] or nil
if not operation then
return nil, makeError("unsupported_character_score_op", commandPath .. ".op", "캐릭터 선택 점수로 해석할 수 없는 효과 작업입니다: " .. tostring(type(command) == "table" and command.op or nil))
end
if not isFinite(command.amount) or command.amount < 0 then
return nil, makeError("invalid_character_score_amount", commandPath .. ".amount", "선택 점수 효과 수치가 올바르지 않습니다.")
end
local field = TOTAL_FIELD[command.op]
totals[field] = totals[field] + command.amount
scoreDelta = scoreDelta + operation.scoreDirection * command.amount
stealthDelta = stealthDelta + operation.stealthDirection * command.amount
end
end
return { scoreDelta = scoreDelta, stealthDelta = stealthDelta }, nil
end
local function moodOrder(staticData)
local ordered = {}
local indexById = {}
local moods = type(staticData) == "table" and type(staticData.registry) == "table" and staticData.registry.moods or nil
if type(moods) ~= "table" then return nil, nil end
local count = 0
for moodId, mood in pairs(moods) do
if type(mood) ~= "table" or not isInteger(mood.order, 1) or ordered[mood.order] ~= nil then return nil, nil end
ordered[mood.order] = moodId
indexById[moodId] = mood.order
count = count + 1
end
for i = 1, count do if ordered[i] == nil then return nil, nil end end
return ordered, indexById
end
local function tokenPressure(count)
if count <= 0 then return 0 end
if count == 1 then return 1 end
if count == 2 then return 4 end
return 7 + (count - 3) * 2
end
local function moodStrategicUtility(state, staticData, report)
local resolution = type(report) == "table" and report.resolution or nil
if type(resolution) ~= "table" or not isFinite(resolution.stealthDelta) or type(resolution.moodTokens) ~= "table" then return nil end
local ordered, indexById = moodOrder(staticData)
if ordered == nil then return nil end
local currentOrder = indexById[state.character.mood]
local finalOrder = indexById[resolution.mood]
if currentOrder == nil or finalOrder == nil then return nil end
local center = (#ordered + 1) / 2
local utility = (center - finalOrder) * MOOD_POSITION_SCALE
utility = utility - resolution.stealthDelta * MOOD_STEALTH_SCALE
local currentAnchorSign = center - currentOrder
local escapePressure = 0
if currentAnchorSign > 0 then
for order = currentOrder + 1, #ordered do
escapePressure = math.max(escapePressure, tokenPressure(resolution.moodTokens[ordered[order]] or 0))
end
end
for order, moodId in ipairs(ordered) do
local count = resolution.moodTokens[moodId] or 0
local pressure = tokenPressure(count)
if order < currentOrder then
utility = utility + (currentOrder - order) * pressure * MOOD_TOKEN_SCALE
elseif order > currentOrder then
utility = utility - (order - currentOrder) * pressure * MOOD_TOKEN_SCALE
elseif pressure > 0 then
if currentAnchorSign > 0 then
utility = utility + math.min(pressure, escapePressure) * MOOD_ANCHOR_SCALE
elseif currentAnchorSign < 0 then
utility = utility + currentAnchorSign * pressure
end
end
end
return utility
end
local function scoreMoodCommands(state, staticData, commands)
if #commands == 0 then return 0, nil end
local spec = {
turnNumber = state.turnNumber,
mood = state.character.mood,
moodTokens = moodTokenSnapshot(state, staticData),
forcedMoodRequests = {},
}
local baseline, baselineErrors = callModule("effectEngine", "projectMood", staticData, spec)
if baselineErrors then return nil, baselineErrors end
spec.commands = commands
local projected, projectedErrors = callModule("effectEngine", "projectMood", staticData, spec)
if projectedErrors then return nil, projectedErrors end
local baselineValue = moodStrategicUtility(state, staticData, baseline)
local projectedValue = moodStrategicUtility(state, staticData, projected)
if not isSafeInteger(baselineValue) or not isSafeInteger(projectedValue) then
return nil, { makeError("invalid_mood_score", "$.runtime.effectEngine.projectMood", "무드 템포 점수가 안전한 정수가 아닙니다.") }
end
return projectedValue - baselineValue, nil
end
local function scoreCandidate(state, staticData, card, instance)
if card.canPlay ~= nil then
return nil, { makeError("unsupported_character_can_play_selection", "$.staticData.cards." .. card.id .. ".canPlay", "캐릭터 canPlay 카드의 사전 선택 정책은 아직 확정되지 않았습니다.") }
end
if card.base.stealthCost ~= 0 or card.base.resistanceDamage ~= 0 then
return nil, { makeError("unsupported_character_base_values", "$.staticData.cards." .. card.id .. ".base", "캐릭터 카드의 기본 비용과 기본 저항 피해는 선택 점수 버전 1에서 0이어야 합니다.") }
end
local totals = emptyTotals()
local score = 0
local stealthDelta = 0
local moodScore = 0
local immediateMoodCommands = {}
local context = buildContext(state, staticData, card, instance, nil)
local cardReport, cardErrors = callModule("effectEngine", "evaluateCardResolve", staticData, card.id, context)
if cardErrors then return nil, cardErrors end
local cardScore, cardScoreError = scoreCommands(cardReport.commands, totals, "$.staticData.cards." .. card.id .. ".resolve.commands", immediateMoodCommands)
if cardScoreError then return nil, { cardScoreError } end
score = score + cardScore.scoreDelta
stealthDelta = stealthDelta + cardScore.stealthDelta
local moodReport, moodErrors = callModule("effectEngine", "evaluateMoodEffect", staticData, card.id, state.character.mood, context)
if moodErrors then return nil, moodErrors end
local moodEffectScore, moodScoreError = scoreCommands(moodReport.commands, totals, "$.staticData.cards." .. card.id .. ".moodEffects." .. state.character.mood .. ".commands", immediateMoodCommands)
if moodScoreError then return nil, { moodScoreError } end
score = score + moodEffectScore.scoreDelta
stealthDelta = stealthDelta + moodEffectScore.stealthDelta
local immediateMoodScore, immediateMoodErrors = scoreMoodCommands(state, staticData, immediateMoodCommands)
if immediateMoodErrors then return nil, immediateMoodErrors end
moodScore = moodScore + immediateMoodScore
local planChargesEvaluated = 0
if card.cardType == "plan" then
local plan = type(card.mechanismData) == "table" and card.mechanismData.plan or nil
local assumption = type(plan) == "table" and plan.selectionAssumption or nil
local event = type(assumption) == "table" and assumption.event or nil
if type(plan) ~= "table"
or not isInteger(plan.charges, 1)
or type(assumption) ~= "table"
or assumption.chargePolicy ~= "all"
or type(event) ~= "table"
or type(event.type) ~= "string"
or (event.side ~= "player" and event.side ~= "character") then
return nil, { makeError("invalid_plan_selection_assumption", "$.staticData.cards." .. card.id .. ".mechanismData.plan.selectionAssumption", "캐릭터 계획 선택 가정이 정적 데이터 계약과 맞지 않습니다.") }
end
for chargeIndex = 1, plan.charges do
local remainingCharges = plan.charges - chargeIndex + 1
local planContext = buildContext(state, staticData, nil, nil, {
cardId = card.id,
cardInstanceId = instance.instanceId,
side = "character",
remainingTurns = plan.durationTurns,
remainingCharges = remainingCharges,
})
local triggerReport, triggerErrors = callModule("effectEngine", "evaluateTrigger", staticData, plan, planContext, event)
if triggerErrors then return nil, triggerErrors end
if triggerReport.matched ~= true then
return nil, { makeError("plan_selection_assumption_not_matched", "$.staticData.cards." .. card.id .. ".mechanismData.plan.selectionAssumption.event", "명시한 계획 선택 가정이 계획 발동 조건과 일치하지 않습니다.") }
end
local planMoodCommands = {}
local planScore, planScoreError = scoreCommands(triggerReport.commands, totals, "$.staticData.cards." .. card.id .. ".mechanismData.plan.resolve.commands[charge=" .. chargeIndex .. "]", planMoodCommands)
if planScoreError then return nil, { planScoreError } end
score = score + planScore.scoreDelta
stealthDelta = stealthDelta + planScore.stealthDelta
local chargeMoodScore, chargeMoodErrors = scoreMoodCommands(state, staticData, planMoodCommands)
if chargeMoodErrors then return nil, chargeMoodErrors end
moodScore = moodScore + chargeMoodScore
planChargesEvaluated = planChargesEvaluated + 1
end
end
score = score * SCORE_SCALE + moodScore
local projectedStealth = state.player.stealth + stealthDelta
if not isSafeInteger(score) or not isFinite(projectedStealth) then
return nil, { makeError("non_finite_character_score", "$.staticData.cards." .. card.id, "캐릭터 선택 점수가 안전한 정수 범위를 벗어났습니다.") }
end
return {
instanceId = instance.instanceId,
cardId = card.id,
role = card.roles[1],
handPosition = instance.position,
score = score,
projectedPlayerStealth = projectedStealth,
lethal = projectedStealth <= 0,
weight = 0,
moodScore = moodScore,
totals = totals,
planChargesEvaluated = planChargesEvaluated,
}, nil
end
local function validateReceipt(staticInput, receipt, expectedState)
local staticData = normalizeStaticData(staticInput)
if type(receipt) ~= "table" or getmetatable(receipt) ~= nil then
return failure({ makeError("invalid_character_selection_receipt", "$.receipt", "캐릭터 선택 영수증이 일반 테이블이 아닙니다.") })
end
local context = receipt.selectionContext
if type(context) ~= "table" or getmetatable(context) ~= nil then
return failure({ makeError("invalid_selection_context", "$.receipt.selectionContext", "선택 시점 컨텍스트가 일반 테이블이 아닙니다.") })
end
if expectedState ~= nil then
local expectedContext = buildSelectionContext(expectedState, staticData, orderedCharacterHand(expectedState))
if not deepEqual(context, expectedContext) then
return failure({ makeError("selection_context_state_mismatch", "$.receipt.selectionContext", "선택 영수증 컨텍스트가 실제 선택 직전 상태와 일치하지 않습니다.") })
end
end
if not isInteger(context.turnNumber, 1)
or type(context.player) ~= "table"
or not isFinite(context.player.stealth)
or not isInteger(context.player.handCount, 0)
or type(context.character) ~= "table"
or not isFinite(context.character.resistance)
or type(context.character.mood) ~= "string"
or type(context.character.moodTokens) ~= "table"
or not isDenseArray(context.characterHand)
or not isDenseArray(receipt.candidates) then
return failure({ makeError("invalid_selection_context", "$.receipt.selectionContext", "선택 시점 컨텍스트 필드가 올바르지 않습니다.") })
end
if #context.characterHand ~= #receipt.candidates then
return failure({ makeError("selection_candidate_count_mismatch", "$.receipt.candidates", "선택 시점 손패와 후보 수가 다릅니다.") })
end
local syntheticState = {
turnNumber = context.turnNumber,
historyContextOverride = context.history,
player = { stealth = context.player.stealth },
character = {
resistance = context.character.resistance,
mood = context.character.mood,
moodTokens = moodTokenSnapshot({ character = context.character }, staticData),
},
cardInstances = {},
}
for index = 1, context.player.handCount do
syntheticState.cardInstances[index] = { owner = "player", zone = "hand" }
end
for index, handEntry in ipairs(context.characterHand) do
local candidate = receipt.candidates[index]
local card = type(staticData.cards) == "table" and staticData.cards[handEntry.cardId] or nil
if type(card) ~= "table" or card.owner ~= "character" or card.roles[1] ~= handEntry.role then
return failure({ makeError("selection_hand_static_mismatch", "$.receipt.selectionContext.characterHand[" .. index .. "]", "선택 시점 손패가 정적 캐릭터 카드와 일치하지 않습니다.") })
end
local instance = {
instanceId = handEntry.instanceId,
cardId = handEntry.cardId,
owner = "character",
zone = "hand",
position = handEntry.handPosition,
}
local expected, replayErrors = scoreCandidate(syntheticState, staticData, card, instance)
if replayErrors then return failure(replayErrors) end
if candidate.instanceId ~= expected.instanceId
or candidate.cardId ~= expected.cardId
or candidate.role ~= expected.role
or candidate.handPosition ~= expected.handPosition
or candidate.score ~= expected.score
or candidate.moodScore ~= expected.moodScore
or candidate.projectedPlayerStealth ~= expected.projectedPlayerStealth
or candidate.lethal ~= expected.lethal
or candidate.planChargesEvaluated ~= expected.planChargesEvaluated
or not deepEqual(candidate.totals, expected.totals) then
return failure({ makeError("selection_candidate_replay_mismatch", "$.receipt.candidates[" .. index .. "]", "후보 감사 값이 정적 카드 효과의 선택 시점 재평가 결과와 다릅니다.") })
end
end
return { ok = true, schemaVersion = SCHEMA_VERSION, errors = {}, valid = true }
end
local function selectIntent(state, staticInput, historyBaseline)
local staticData = normalizeStaticData(staticInput)
local validation, validationErrors = callModule(
"stateSchema",
"validateBattleState",
state,
staticData,
historyBaseline
)
if validationErrors then return failure(validationErrors) end
if validation.referencesValidated ~= true then
return failure({ makeError("static_references_not_validated", "$.staticData", "캐릭터 선택에는 전체 정적 데이터 참조 검증이 필요합니다.") })
end
if state.status ~= "active" then return failure({ makeError("battle_not_active", "$.state.status", "진행 중인 전투에서만 캐릭터 의도를 선택할 수 있습니다.") }) end
if type(state.characterIntent) ~= "table"
or type(state.characterIntent.cardInstanceIds) ~= "table"
or #state.characterIntent.cardInstanceIds > 0
or state.characterIntent.publicRole ~= nil then
return failure({ makeError("character_intent_already_selected", "$.state.characterIntent", "이미 캐릭터 의도가 있는 상태를 다시 선택할 수 없습니다.") })
end
local hand = orderedCharacterHand(state)
local candidates = {}
for _, entry in ipairs(hand) do
local instance = entry.instance
local card = staticData.cards[instance.cardId]
if type(card) ~= "table" or card.owner ~= "character" then
return failure({ makeError("invalid_character_hand_card", "$.state.cardInstances", "캐릭터 손패의 카드 정의가 올바르지 않습니다: " .. tostring(instance.cardId)) })
end
if card.cardType == "chain" then
return failure({ makeError("unsupported_character_chain_selection", "$.staticData.cards." .. card.id .. ".cardType", "캐릭터 연계 카드 선택 순서와 장수 정책은 아직 지원하지 않습니다.") })
end
local candidate, candidateErrors = scoreCandidate(state, staticData, card, instance)
if candidateErrors then return failure(candidateErrors) end
candidates[#candidates + 1] = candidate
end
local rngBefore, rngBeforeError = cloneData(state.rng, "$.state.rng")
if rngBeforeError then return failure({ rngBeforeError }) end
local nextState, stateCloneError = cloneData(state, "$.state")
if stateCloneError then return failure({ stateCloneError }) end
local receipt = {
schemaVersion = SCHEMA_VERSION,
kind = "characterIntentSelection",
battleId = state.battleId,
turnNumber = state.turnNumber,
characterId = state.character.characterId,
selectionContext = buildSelectionContext(state, staticData, hand),
candidates = candidates,
weightedPoolInstanceIds = {},
lethalPriorityApplied = false,
rngBefore = rngBefore,
}
if #candidates == 0 then
nextState.characterIntent = { cardInstanceIds = {} }
local rngAfter, rngAfterError = cloneData(nextState.rng, "$.state.rng")
if rngAfterError then return failure({ rngAfterError }) end
receipt.rngAfter = rngAfter
receipt.draw = { kind = "pass" }
local outputValidation, outputErrors = callModule(
"stateSchema",
"validateBattleState",
nextState,
staticData,
historyBaseline
)
if outputErrors then return failure(outputErrors) end
if outputValidation.referencesValidated ~= true then
return failure({ makeError("output_references_not_validated", "$.state", "선택 결과의 정적 참조를 검증하지 못했습니다.") })
end
local intentCopy, intentCopyError = cloneData(nextState.characterIntent, "$.intent")
if intentCopyError then return failure({ intentCopyError }) end
return success(nextState, intentCopy, receipt)
end
local pool = candidates
local lethal = {}
for _, candidate in ipairs(candidates) do if candidate.lethal then lethal[#lethal + 1] = candidate end end
if #lethal > 0 then
pool = lethal
receipt.lethalPriorityApplied = true
end
local minimumScore = pool[1].score
for _, candidate in ipairs(pool) do
receipt.weightedPoolInstanceIds[#receipt.weightedPoolInstanceIds + 1] = candidate.instanceId
if candidate.score < minimumScore then minimumScore = candidate.score end
end
local weightOffset = minimumScore <= 0 and (1 - minimumScore) or 0
if not isSafeInteger(weightOffset, 0) then
return failure({ makeError("invalid_character_weight_offset", "$.candidates", "점수 가중치 평행이동 값을 안전한 정수로 만들 수 없습니다.") })
end
receipt.weightOffset = weightOffset
local totalWeight = 0
for _, candidate in ipairs(pool) do
candidate.weight = candidate.score + weightOffset
if candidate.weight < 1 then candidate.weight = 1 end
if not isSafeInteger(candidate.weight, 1) or not isSafeInteger(totalWeight + candidate.weight, 0) then
return failure({ makeError("invalid_character_selection_weight", "$.candidates", "후보 가중치 합이 안전한 정수 범위를 벗어났습니다.") })
end
totalWeight = totalWeight + candidate.weight
end
local selected
if #pool == 1 then
selected = pool[1]
receipt.draw = { kind = "single", totalWeight = totalWeight }
else
local rngReport, rngErrors = callModule("deterministicRng", "nextInteger", state.rng, 1, totalWeight)
if rngErrors then return failure(rngErrors) end
local roll = rngReport.value
local cumulative = 0
for _, candidate in ipairs(pool) do
cumulative = cumulative + candidate.weight
if roll <= cumulative then selected = candidate break end
end
if selected == nil then return failure({ makeError("invalid_weighted_character_result", "$.rng", "결정적 가중 추첨 결과를 후보에 대응할 수 없습니다.") }) end
local rngCopy, rngCopyError = cloneData(rngReport.rng, "$.rng")
if rngCopyError then return failure({ rngCopyError }) end
nextState.rng = rngCopy
receipt.draw = { kind = "weighted", totalWeight = totalWeight, roll = roll }
end
nextState.characterIntent = { cardInstanceIds = { selected.instanceId }, publicRole = selected.role }
receipt.selectedInstanceId = selected.instanceId
receipt.selectedCardId = selected.cardId
receipt.publicRole = selected.role
local rngAfter, rngAfterError = cloneData(nextState.rng, "$.state.rng")
if rngAfterError then return failure({ rngAfterError }) end
receipt.rngAfter = rngAfter
local outputValidation, outputErrors = callModule(
"stateSchema",
"validateBattleState",
nextState,
staticData,
historyBaseline
)
if outputErrors then return failure(outputErrors) end
if outputValidation.referencesValidated ~= true then
return failure({ makeError("output_references_not_validated", "$.state", "선택 결과의 정적 참조를 검증하지 못했습니다.") })
end
local intentCopy, intentCopyError = cloneData(nextState.characterIntent, "$.intent")
if intentCopyError then return failure({ intentCopyError }) end
return success(nextState, intentCopy, receipt)
end
local arguments = { ... }
local actions = { selectIntent = selectIntent, validateReceipt = validateReceipt }
local handler = actions[action]
if not handler then return failure({ makeError("unknown_action", "$.action", "지원하지 않는 캐릭터 선택 작업입니다: " .. tostring(action)) }) end
return handler(arguments[1], arguments[2], arguments[3])
local function makeError(code, path, message)
return {
code = code,
path = path,
message = message,
}
end
local function failure(errors)
return {
ok = false,
wireFormat = WIRE_FORMAT,
errors = errors,
}
end
local function isFinite(value)
return value == value
and value ~= math.huge
and value ~= -math.huge
end
local function objectPath(path, key)
if string.match(key, "^[A-Za-z_][A-Za-z0-9_]*$") then
return path .. "." .. key
end
return path .. "[" .. string.format("%q", key) .. "]"
end
local function inspectTable(value, path, errors)
local numericKeys = {}
local stringKeys = {}
local hasNumeric = false
local hasString = false
local hasInvalid = false
local maximum = 0
for key in pairs(value) do
local keyType = type(key)
if keyType == "number" then
hasNumeric = true
table.insert(numericKeys, key)
if not isFinite(key) or key < 1 or key % 1 ~= 0 then
hasInvalid = true
table.insert(
errors,
makeError(
"invalid_array_index",
path,
"배열 인덱스는 1 이상의 유한한 정수여야 합니다: " .. tostring(key)
)
)
elseif key > maximum then
maximum = key
end
elseif keyType == "string" then
hasString = true
table.insert(stringKeys, key)
else
hasInvalid = true
table.insert(
errors,
makeError(
"invalid_object_key",
path,
"객체 키는 문자열이어야 합니다: " .. keyType
)
)
end
end
if hasNumeric and hasString then
hasInvalid = true
table.insert(
errors,
makeError(
"mixed_table",
path,
"숫자 인덱스와 문자열 키를 같은 테이블에서 함께 사용할 수 없습니다."
)
)
end
if hasInvalid then
return nil
end
if hasNumeric then
if #numericKeys ~= maximum then
table.insert(
errors,
makeError(
"sparse_array",
path,
"배열 인덱스는 1부터 빈틈없이 이어져야 합니다."
)
)
return nil
end
return "array", maximum
end
if hasString then
table.sort(stringKeys)
return "object", stringKeys
end
-- Lua의 빈 테이블은 형상을 구분할 수 없으므로 이 브리지에서는 빈 배열이다.
return "array", 0
end
local function validateJsonSafe(root)
local errors = {}
local active = {}
local function visit(value, path)
local valueType = type(value)
if valueType == "string" or valueType == "boolean" then
return
end
if valueType == "number" then
if not isFinite(value) then
table.insert(
errors,
makeError("non_finite_number", path, "숫자는 NaN이나 무한대일 수 없습니다.")
)
end
return
end
if valueType ~= "table" then
table.insert(
errors,
makeError(
"unsupported_type",
path,
"JSON View에 저장할 수 없는 자료형입니다: " .. valueType
)
)
return
end
if getmetatable(value) ~= nil then
table.insert(
errors,
makeError("metatable_not_allowed", path, "View 테이블에는 메타테이블을 사용할 수 없습니다.")
)
return
end
if active[value] then
table.insert(
errors,
makeError(
"circular_reference",
path,
"순환 참조가 있는 테이블은 직렬화할 수 없습니다."
)
)
return
end
active[value] = true
local kind, shape = inspectTable(value, path, errors)
if kind == "array" then
for index = 1, shape do
visit(value[index], path .. "[" .. index .. "]")
end
elseif kind == "object" then
for _, key in ipairs(shape) do
visit(value[key], objectPath(path, key))
end
end
active[value] = nil
end
if type(root) ~= "table" then
table.insert(
errors,
makeError("invalid_view_root", "$", "View의 최상위 값은 테이블이어야 합니다.")
)
else
visit(root, "$")
end
return errors
end
local function appendSchemaErrors(target, schemaResult, config)
if type(schemaResult) == "table" and type(schemaResult.errors) == "table" then
for index, schemaError in ipairs(schemaResult.errors) do
if type(schemaError) == "table" then
table.insert(
target,
makeError(
tostring(schemaError.code or config.errorCode),
tostring(schemaError.path or "$"),
tostring(schemaError.message or config.errorMessage)
)
)
else
table.insert(
target,
makeError(
config.errorCode,
"$",
config.errorMessage .. " 오류 " .. index .. ": " .. tostring(schemaError)
)
)
end
end
end
if #target == 0 then
table.insert(
target,
makeError(
config.errorCode,
"$",
config.validatorMessage
)
)
end
end
local function validateView(viewName, view)
local config = SUPPORTED_VIEWS[viewName]
if config == nil then
return failure({
makeError(
"unsupported_view",
"$",
"지원하지 않는 View입니다: " .. tostring(viewName)
),
})
end
if config.canonicalOnly then
return failure({
makeError(
"internal_view",
"$",
"내부 전용 View는 공식 builder의 canonical 경로에서만 게시할 수 있습니다."
),
})
end
local errors = validateJsonSafe(view)
if #errors > 0 then
return failure(errors)
end
if type(runScript) ~= "function" then
return failure({
makeError(
"view_validator_unavailable",
"$.runtime." .. config.moduleName,
"View 스키마 검증기를 호출할 수 없습니다."
),
})
end
local callOk, schemaResult = pcall(
runScript,
triggerId,
config.moduleName,
config.action,
view
)
if not callOk then
return failure({
makeError(
"view_validator_call_failed",
"$.runtime." .. config.moduleName,
"View 스키마 검증기 호출에 실패했습니다: " .. tostring(schemaResult)
),
})
end
local schemaPassed = schemaResult == true
or (type(schemaResult) == "table" and schemaResult.ok == true)
if not schemaPassed then
appendSchemaErrors(errors, schemaResult, config)
return failure(errors)
end
return {
ok = true,
wireFormat = WIRE_FORMAT,
}
end
local function encodeJsonString(value, protectCbsSyntax)
local parts = { '"' }
for index = 1, #value do
local byte = string.byte(value, index)
local character = string.char(byte)
if byte == 34 then
table.insert(parts, '\\"')
elseif byte == 92 then
table.insert(parts, "\\\\")
elseif byte == 8 then
table.insert(parts, "\\b")
elseif byte == 12 then
table.insert(parts, "\\f")
elseif byte == 10 then
table.insert(parts, "\\n")
elseif byte == 13 then
table.insert(parts, "\\r")
elseif byte == 9 then
table.insert(parts, "\\t")
elseif byte < 32 then
table.insert(parts, string.format("\\u%04X", byte))
elseif protectCbsSyntax and character == ":" then
table.insert(parts, "\\u003A")
elseif protectCbsSyntax and character == "{" then
table.insert(parts, "\\u007B")
elseif protectCbsSyntax and character == "}" then
table.insert(parts, "\\u007D")
else
table.insert(parts, character)
end
end
table.insert(parts, '"')
return table.concat(parts)
end
local function encodeNumber(value)
-- IEEE-754 double 값을 JSON으로 왕복할 수 있는 유효 자릿수를 유지한다.
local encoded = string.format("%.17g", value)
if encoded == "-0" then
return "0"
end
return encoded
end
local HTML_TEXT_ENTITIES = {
["&"] = "&",
["<"] = "<",
[">"] = ">",
['"'] = """,
["'"] = "'",
["{"] = "{",
["}"] = "}",
["("] = "(",
[")"] = ")",
[":"] = ":",
}
local function escapeHtmlText(value)
local escaped = string.gsub(value, "[&<>\"'{}():]", function(character)
return HTML_TEXT_ENTITIES[character]
end)
-- RisuAI는 Markdown 렌더링 뒤 U+E9B8..U+E9BF를 자체 escape
-- 문자로 복원한다. 원본 표시 문자열의 같은 private-use 문자가
-- 그 경계에 소비되지 않도록 브라우저 단계까지 숫자 엔티티로 둔다.
for offset = 0, 7 do
local character = string.char(238, 166, 184 + offset)
local entity = "&#" .. tostring(59832 + offset) .. ";"
escaped = string.gsub(escaped, character, entity)
end
return escaped
end
local encodeTable
local function encodeScalar(value)
local valueType = type(value)
if valueType == "string" then
-- battleView wire is consumed inside an HTML/CBS template. Encode
-- display text as entities before JSON quoting so allowed HTML tags
-- cannot change the template structure and a decoded CBS result
-- cannot introduce a fresh CBS directive or :: sequence.
return encodeJsonString(escapeHtmlText(value), true)
elseif valueType == "number" then
return encodeNumber(value)
elseif valueType == "boolean" then
return value and "true" or "false"
elseif valueType == "nil" then
return "null"
end
error("validated View contained an unsupported scalar: " .. valueType)
end
local function encodeChild(value)
if type(value) == "table" then
-- 중첩 노드는 자신의 JSON을 문자열로 한 층 감싸 CBS가 한 단계씩 읽게 한다.
return encodeJsonString(encodeTable(value), true)
end
return encodeScalar(value)
end
encodeTable = function(value)
local classificationErrors = {}
local kind, shape = inspectTable(value, "$", classificationErrors)
if not kind then
error("validated View table shape changed before encoding")
end
local parts = {}
if kind == "array" then
for index = 1, shape do
table.insert(parts, encodeChild(value[index]))
end
return "[" .. table.concat(parts, ",") .. "]"
end
for _, key in ipairs(shape) do
table.insert(parts, encodeJsonString(key, true) .. ":" .. encodeChild(value[key]))
end
return "{" .. table.concat(parts, ",") .. "}"
end
local function encodeValidatedView(viewName, view)
local ok, encoded = pcall(encodeTable, view)
if not ok then
return failure({
makeError("encode_failed", "$", "View 직렬화에 실패했습니다: " .. tostring(encoded)),
})
end
return {
ok = true,
wireFormat = WIRE_FORMAT,
encoded = encoded,
bytes = #encoded,
}
end
local function encodeView(viewName, view)
local validation = validateView(viewName, view)
if not validation.ok then
return validation
end
return encodeValidatedView(viewName, view)
end
local function authorizeCanonical(permit, viewName)
if type(permit) ~= "function" then
return false
end
local ok, allowed = pcall(permit, "dataBridgeCanonicalV1", viewName)
return ok and allowed == true
end
local function encodeCanonicalView(viewName, view, permit)
if SUPPORTED_VIEWS[viewName] == nil then
return failure({
makeError("unsupported_view", "$", "지원하지 않는 View입니다: " .. tostring(viewName)),
})
end
if not authorizeCanonical(permit, viewName) then
return failure({
makeError("internal_action_denied", "$.action", "검증된 View 전용 내부 작업에 접근할 수 없습니다."),
})
end
-- 이 경로는 같은 controller transaction에서 공식 View builder가
-- 이미 schema allowlist를 검증한 값만 받는다. JSON-safe 검사는
-- 유지해 함수, 메타테이블, 순환 참조가 bridge 밖으로 나가지 않게 한다.
local errors = validateJsonSafe(view)
if #errors > 0 then
return failure(errors)
end
return encodeValidatedView(viewName, view)
end
local function publishView(viewName, view)
local result = encodeView(viewName, view)
if not result.ok then
return result
end
local writeOk, writeError = pcall(function()
return HostCompat.writeChatVar(triggerId, viewName, result.encoded)
end)
if not writeOk then
return failure({
makeError(
"publish_failed",
"$",
"View 채팅 변수 저장에 실패했습니다: " .. tostring(writeError)
),
})
end
return result
end
local function publishCanonicalView(viewName, view, permit)
local result = encodeCanonicalView(viewName, view, permit)
if not result.ok then
return result
end
local writeOk, writeError = pcall(function()
return HostCompat.writeChatVar(triggerId, viewName, result.encoded)
end)
if not writeOk then
return failure({
makeError(
"publish_failed",
"$",
"View 채팅 변수 저장에 실패했습니다: " .. tostring(writeError)
),
})
end
return result
end
local arguments = { ... }
local viewName = arguments[1]
local view = arguments[2]
if action == "_encodeCanonical" then
return encodeCanonicalView(viewName, view, arguments[3])
elseif action == "_publishCanonical" then
return publishCanonicalView(viewName, view, arguments[3])
end
local actions = {
validate = validateView,
encode = encodeView,
publish = publishView,
}
local handler = actions[action]
if not handler then
return failure({
makeError(
"unknown_action",
"$",
"지원하지 않는 데이터 브리지 작업입니다: " .. tostring(action)
),
})
end
return handler(viewName, view)
end)
#35deterministicRng.lua
Keys:
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local ALGORITHM = "park_miller_schrage_v1"
local MODULUS = 2147483647
local MULTIPLIER = 16807
local QUOTIENT = 127773
local REMAINDER = 2836
local SOURCE_SIZE = MODULUS - 1
local MAX_SAFE_INTEGER = 9007199254740991
local function makeError(code, path, message)
return {
code = code,
path = path,
message = message,
}
end
local function failure(errors)
return {
ok = false,
schemaVersion = SCHEMA_VERSION,
algorithm = ALGORITHM,
errors = errors,
}
end
local function success(value, rng)
local response = {
ok = true,
schemaVersion = SCHEMA_VERSION,
algorithm = ALGORITHM,
errors = {},
value = value,
}
if rng ~= nil then
response.rng = rng
end
return response
end
local function isFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function isSafeInteger(value, minimum)
return isFinite(value)
and value % 1 == 0
and math.abs(value) <= MAX_SAFE_INTEGER
and (minimum == nil or value >= minimum)
end
local function cloneRng(rng)
return {
seed = rng.seed,
cursor = rng.cursor,
}
end
local function validateRng(rng)
local errors = {}
if type(rng) ~= "table" then
table.insert(errors, makeError("invalid_rng", "$.rng", "rng는 테이블이어야 합니다."))
return errors
end
if getmetatable(rng) ~= nil then
table.insert(errors, makeError("rng_metatable_not_allowed", "$.rng", "rng에는 메타테이블을 사용할 수 없습니다."))
return errors
end
for key in pairs(rng) do
if key ~= "seed" and key ~= "cursor" then
table.insert(
errors,
makeError("unknown_rng_field", "$.rng." .. tostring(key), "rng에 허용되지 않은 필드가 있습니다.")
)
end
end
if not isSafeInteger(rng.seed, 0) then
table.insert(
errors,
makeError(
"invalid_rng_seed",
"$.rng.seed",
"seed는 0 이상이고 IEEE-754 안전 범위 안의 정수여야 합니다."
)
)
end
if not isSafeInteger(rng.cursor, 0) then
table.insert(
errors,
makeError(
"invalid_rng_cursor",
"$.rng.cursor",
"cursor는 0 이상이고 IEEE-754 안전 범위 안의 정수여야 합니다."
)
)
end
return errors
end
local function normalizeSeed(seed)
-- 외부 seed는 그대로 보존하고 생성기 내부 상태만 1..M-1로 정규화한다.
local normalized = seed % MODULUS
if normalized == 0 then
return 1
end
return normalized
end
local function parkMillerStep(value)
-- Schrage 분해를 사용해 32비트 범위 안에서 A * value mod M을 계산한다.
local high = math.floor(value / QUOTIENT)
local low = value - high * QUOTIENT
local nextValue = MULTIPLIER * low - REMAINDER * high
if nextValue <= 0 then
nextValue = nextValue + MODULUS
end
return nextValue
end
local function multiplyModulo(left, right)
-- 모든 중간 덧셈을 2*M 미만으로 유지하는 정확한 double-and-add 곱셈이다.
local result = 0
while right > 0 do
if right % 2 == 1 then
result = result + left
if result >= MODULUS then
result = result - MODULUS
end
end
right = math.floor(right / 2)
if right > 0 then
left = left + left
if left >= MODULUS then
left = left - MODULUS
end
end
end
return result
end
local function powerModulo(base, exponent)
local result = 1
while exponent > 0 do
if exponent % 2 == 1 then
result = multiplyModulo(result, base)
end
exponent = math.floor(exponent / 2)
if exponent > 0 then
base = multiplyModulo(base, base)
end
end
return result
end
local function stateAtCursor(rng)
if rng.cursor == 0 then
return normalizeSeed(rng.seed)
end
local jump = powerModulo(MULTIPLIER, rng.cursor)
return multiplyModulo(normalizeSeed(rng.seed), jump)
end
local function nextRaw(rng)
if rng.cursor >= MAX_SAFE_INTEGER then
return nil, makeError(
"rng_cursor_exhausted",
"$.rng.cursor",
"cursor를 안전하게 증가시킬 수 있는 범위를 모두 사용했습니다."
)
end
local raw = parkMillerStep(stateAtCursor(rng))
return raw, {
seed = rng.seed,
cursor = rng.cursor + 1,
}
end
local function validateRange(minimum, maximum)
local errors = {}
if not isSafeInteger(minimum) then
table.insert(
errors,
makeError("invalid_range_minimum", "$.minimum", "minimum은 IEEE-754 안전 범위 안의 정수여야 합니다.")
)
end
if not isSafeInteger(maximum) then
table.insert(
errors,
makeError("invalid_range_maximum", "$.maximum", "maximum은 IEEE-754 안전 범위 안의 정수여야 합니다.")
)
end
if #errors > 0 then
return errors
end
if minimum > maximum then
table.insert(errors, makeError("invalid_range_order", "$.maximum", "maximum은 minimum보다 작을 수 없습니다."))
return errors
end
if maximum - minimum >= SOURCE_SIZE then
table.insert(
errors,
makeError(
"range_too_wide",
"$.maximum",
"한 번의 Park-Miller 표본으로 만들 수 있는 정수 범위를 초과했습니다."
)
)
end
return errors
end
local function generateInteger(rng, minimum, maximum)
local span = maximum - minimum + 1
local acceptedSize = SOURCE_SIZE - (SOURCE_SIZE % span)
local currentRng = cloneRng(rng)
while true do
local raw, nextStateOrError = nextRaw(currentRng)
if raw == nil then
return nil, nil, nextStateOrError
end
currentRng = nextStateOrError
local zeroBased = raw - 1
if zeroBased < acceptedSize then
return minimum + (zeroBased % span), currentRng, nil
end
end
end
local function validateAction(rng)
local errors = validateRng(rng)
if #errors > 0 then
return failure(errors)
end
return success(cloneRng(rng), cloneRng(rng))
end
local function nextInteger(rng, minimum, maximum)
local errors = validateRng(rng)
local rangeErrors = validateRange(minimum, maximum)
for _, item in ipairs(rangeErrors) do
table.insert(errors, item)
end
if #errors > 0 then
return failure(errors)
end
local value, nextRng, generationError = generateInteger(rng, minimum, maximum)
if generationError ~= nil then
return failure({ generationError })
end
return success(value, nextRng)
end
local function inspectArray(array)
local errors = {}
if type(array) ~= "table" then
table.insert(errors, makeError("invalid_array", "$.array", "shuffle 대상은 배열 테이블이어야 합니다."))
return errors, nil
end
if getmetatable(array) ~= nil then
table.insert(errors, makeError("array_metatable_not_allowed", "$.array", "배열에는 메타테이블을 사용할 수 없습니다."))
return errors, nil
end
local count = 0
local maximum = 0
for key in pairs(array) do
if not isSafeInteger(key, 1) then
table.insert(
errors,
makeError("invalid_array_index", "$.array", "배열 인덱스는 1 이상의 연속된 정수여야 합니다.")
)
return errors, nil
end
count = count + 1
if key > maximum then
maximum = key
end
end
if count ~= maximum then
table.insert(errors, makeError("sparse_array", "$.array", "배열 인덱스는 1부터 빈틈없이 이어져야 합니다."))
return errors, nil
end
if maximum > SOURCE_SIZE then
table.insert(
errors,
makeError("array_too_large", "$.array", "한 번의 Park-Miller 표본으로 섞을 수 있는 배열 길이를 초과했습니다.")
)
return errors, nil
end
return errors, maximum
end
local function nextIntegers(rng, ranges)
local errors = validateRng(rng)
local arrayErrors, length = inspectArray(ranges)
for _, item in ipairs(arrayErrors) do
item.path = string.gsub(item.path, "^%$%.array", "$.ranges")
table.insert(errors, item)
end
if length ~= nil then
for index = 1, length do
local range = ranges[index]
local path = "$.ranges[" .. index .. "]"
if type(range) ~= "table" then
table.insert(errors, makeError("invalid_range", path, "범위 항목은 테이블이어야 합니다."))
elseif getmetatable(range) ~= nil then
table.insert(errors, makeError("range_metatable_not_allowed", path, "범위 항목에는 메타테이블을 사용할 수 없습니다."))
else
for key in pairs(range) do
if key ~= "minimum" and key ~= "maximum" then
table.insert(errors, makeError(
"unknown_range_field",
path .. "." .. tostring(key),
"범위 항목에 허용되지 않은 필드가 있습니다."
))
end
end
local rangeErrors = validateRange(range.minimum, range.maximum)
for _, item in ipairs(rangeErrors) do
item.path = path .. string.sub(item.path, 2)
table.insert(errors, item)
end
end
end
end
if #errors > 0 then
return failure(errors)
end
-- generateInteger를 기존 nextInteger와 동일한 순서로 호출한다.
-- batch는 Lua 모듈 경계만 합치며 RNG 소비 의미는 바꾸지 않는다.
local values = {}
local currentRng = cloneRng(rng)
for index = 1, length do
local range = ranges[index]
local value, nextRng, generationError = generateInteger(
currentRng,
range.minimum,
range.maximum
)
if generationError ~= nil then
return failure({ generationError })
end
values[index] = value
currentRng = nextRng
end
return success(values, currentRng)
end
local function shuffle(rng, array)
local errors = validateRng(rng)
local arrayErrors, length = inspectArray(array)
for _, item in ipairs(arrayErrors) do
table.insert(errors, item)
end
if #errors > 0 then
return failure(errors)
end
local shuffled = {}
for index = 1, length do
shuffled[index] = array[index]
end
local currentRng = cloneRng(rng)
for index = length, 2, -1 do
local swapIndex, nextRng, generationError = generateInteger(currentRng, 1, index)
if generationError ~= nil then
return failure({ generationError })
end
currentRng = nextRng
shuffled[index], shuffled[swapIndex] = shuffled[swapIndex], shuffled[index]
end
return success(shuffled, currentRng)
end
local arguments = { ... }
local actions = {
validate = validateAction,
nextInteger = nextInteger,
nextIntegers = nextIntegers,
shuffle = shuffle,
}
local handler = actions[action]
if not handler then
return failure({
makeError(
"unknown_action",
"$",
"지원하지 않는 결정적 RNG 작업입니다: " .. tostring(action)
),
})
end
return handler(arguments[1], arguments[2], arguments[3])
end)
#36effectEngine.lua
Keys:
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local function makeError(code, path, message)
return {
code = code,
path = path,
message = message,
}
end
local function failure(errors)
return {
ok = false,
schemaVersion = SCHEMA_VERSION,
errors = errors,
}
end
local function success(commands, cardId)
return {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
commands = commands or {},
cardId = cardId,
}
end
local function isFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function isInteger(value, minimum)
return isFinite(value)
and value % 1 == 0
and (minimum == nil or value >= minimum)
end
local function isDenseArray(value)
if type(value) ~= "table" or getmetatable(value) ~= nil then
return false
end
local count = 0
local maximum = 0
for key in pairs(value) do
if not isInteger(key, 1) then
return false
end
count = count + 1
if key > maximum then
maximum = key
end
end
return count == maximum
end
local function normalizeStaticData(staticData)
if type(staticData) == "table" and type(staticData.data) == "table" then
return staticData.data
end
return staticData
end
local function findInstance(state, instanceId)
if type(state) ~= "table" or type(state.cardInstances) ~= "table" then
return nil
end
for _, instance in ipairs(state.cardInstances) do
if type(instance) == "table" and instance.instanceId == instanceId then
return instance
end
end
return nil
end
local function checkAllowedKeys(value, allowed, path, errors)
if type(value) ~= "table" then
return
end
for key in pairs(value) do
if type(key) ~= "string" or not allowed[key] then
table.insert(errors, makeError(
"unexpected_field",
path .. "." .. tostring(key),
"선택 단계 효과에 허용되지 않은 필드가 있습니다."
))
end
end
end
local function evaluateSelectionPreview(staticData, state, instanceId)
staticData = normalizeStaticData(staticData)
local errors = {}
if type(staticData) ~= "table"
or type(staticData.cards) ~= "table"
or type(staticData.registry) ~= "table" then
table.insert(errors, makeError(
"invalid_static_data",
"$.staticData",
"선택 단계 효과에는 전체 정적 데이터가 필요합니다."
))
end
if type(state) ~= "table" or type(state.cardInstances) ~= "table" then
table.insert(errors, makeError(
"invalid_state",
"$.state",
"선택 단계 전투 상태가 올바르지 않습니다."
))
elseif state.status ~= "active" then
table.insert(errors, makeError(
"battle_not_active",
"$.state.status",
"진행 중인 전투에서만 선택 단계 효과를 평가할 수 있습니다."
))
end
if type(instanceId) ~= "string" or instanceId == "" then
table.insert(errors, makeError(
"invalid_instance_id",
"$.instanceId",
"카드 인스턴스 ID가 없습니다."
))
end
if #errors > 0 then
return failure(errors)
end
local instance = findInstance(state, instanceId)
if not instance then
return failure({
makeError("instance_not_found", "$.instanceId", "카드 인스턴스를 찾을 수 없습니다."),
})
end
if instance.owner ~= "player" or instance.zone ~= "hand" then
return failure({
makeError(
"preview_card_not_in_hand",
"$.instanceId",
"선택 단계 효과의 원본 카드는 플레이어 손패에 있어야 합니다."
),
})
end
local card = staticData.cards[instance.cardId]
if type(card) ~= "table" or card.id ~= instance.cardId then
return failure({
makeError("unknown_card", "$.instanceId", "정적 DB에서 카드를 찾을 수 없습니다."),
})
end
if card.selectionPreview == nil then
return success({}, card.id)
end
local policy = card.selectionPreview
if type(policy) ~= "table" or getmetatable(policy) ~= nil then
return failure({
makeError(
"invalid_preview_policy",
"$.card.selectionPreview",
"선택 단계 효과 정책은 일반 테이블이어야 합니다."
),
})
end
checkAllowedKeys(policy, { effects = true, when = true }, "$.card.selectionPreview", errors)
if card.owner ~= "player" or card.cardType ~= "chain" then
table.insert(errors, makeError(
"preview_requires_player_chain",
"$.card.selectionPreview",
"선택 단계 효과는 플레이어 연계 카드에만 선언할 수 있습니다."
))
end
if not isDenseArray(policy.effects) or #policy.effects == 0 then
table.insert(errors, makeError(
"invalid_preview_effects",
"$.card.selectionPreview.effects",
"선택 단계 효과는 비어 있지 않은 연속 배열이어야 합니다."
))
end
if #errors > 0 then
return failure(errors)
end
if policy.when ~= nil then
if type(policy.when) ~= "function" then
return failure({ makeError("invalid_preview_condition", "$.card.selectionPreview.when", "선택 단계 조건이 함수가 아닙니다.") })
end
local ok, enabled = pcall(policy.when, {
turn = state.turnNumber,
turnLimit = state.turnLimit,
remainingTurns = math.max(0, state.turnLimit - state.turnNumber + 1),
})
if not ok or type(enabled) ~= "boolean" then
return failure({ makeError("preview_condition_error", "$.card.selectionPreview.when", "선택 단계 조건 평가에 실패했습니다.") })
end
if not enabled then return success({}, card.id) end
end
local commands = {}
local seenIds = {}
for index, effect in ipairs(policy.effects) do
local path = "$.card.selectionPreview.effects[" .. index .. "]"
if type(effect) ~= "table" or getmetatable(effect) ~= nil then
table.insert(errors, makeError(
"invalid_preview_effect",
path,
"선택 단계 효과는 일반 테이블이어야 합니다."
))
else
checkAllowedKeys(effect, {
id = true,
op = true,
target = true,
amount = true,
}, path, errors)
if type(effect.id) ~= "string"
or string.match(effect.id, "^[a-z][a-z0-9_]*$") == nil then
table.insert(errors, makeError(
"invalid_preview_effect_id",
path .. ".id",
"선택 단계 효과 ID는 lower_snake_case여야 합니다."
))
elseif seenIds[effect.id] then
table.insert(errors, makeError(
"duplicate_preview_effect_id",
path .. ".id",
"선택 단계 효과 ID가 중복되었습니다."
))
else
seenIds[effect.id] = true
end
local registered = type(staticData.registry.effectOps) == "table"
and staticData.registry.effectOps[effect.op]
or nil
if type(effect.op) ~= "string" or not registered then
table.insert(errors, makeError(
"unknown_preview_op",
path .. ".op",
"등록되지 않은 선택 단계 효과 작업입니다."
))
elseif effect.op ~= "draw_cards" then
table.insert(errors, makeError(
"unsupported_preview_op",
path .. ".op",
"선택 단계 효과 v1은 draw_cards만 지원합니다."
))
end
if effect.target ~= "player" then
table.insert(errors, makeError(
"invalid_preview_target",
path .. ".target",
"선택 단계 드로우 대상은 player여야 합니다."
))
end
if not isInteger(effect.amount, 1) then
table.insert(errors, makeError(
"invalid_preview_amount",
path .. ".amount",
"선택 단계 드로우 수량은 1 이상의 정수여야 합니다."
))
end
commands[index] = {
id = effect.id,
op = effect.op,
target = effect.target,
amount = effect.amount,
}
end
end
if #errors > 0 then
return failure(errors)
end
return success(commands, card.id)
end
local SUPPORTED_COMMANDS = {
damage_resistance = true,
recover_resistance = true,
lose_stealth = true,
recover_stealth = true,
draw_cards = true,
skip_actions = true,
add_mood_token = true,
remove_mood_token = true,
force_mood = true,
}
local RESOURCE_COMMANDS = {
damage_resistance = {
owner = "character",
field = "resistance",
direction = -1,
},
recover_resistance = {
owner = "character",
field = "resistance",
direction = 1,
},
lose_stealth = {
owner = "player",
field = "stealth",
direction = -1,
},
recover_stealth = {
owner = "player",
field = "stealth",
direction = 1,
},
}
local function addError(errors, code, path, message)
table.insert(errors, makeError(code, path, message))
end
local function reportSuccess(fields)
local report = {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
}
for key, value in pairs(fields or {}) do
report[key] = value
end
return report
end
local function cloneData(value, path, active)
path = path or "$"
local valueType = type(value)
if value == nil or valueType == "string" or valueType == "boolean" then
return value, nil
end
if valueType == "number" then
if not isFinite(value) then
return nil, makeError("non_finite_number", path, "효과 입력에는 유한한 숫자만 허용됩니다.")
end
return value, nil
end
if valueType ~= "table" then
return nil, makeError(
"non_data_value",
path,
"효과 입력에는 함수, 스레드, userdata를 넣을 수 없습니다."
)
end
if getmetatable(value) ~= nil then
return nil, makeError("metatable_not_allowed", path, "효과 입력에는 메타테이블을 사용할 수 없습니다.")
end
active = active or {}
if active[value] then
return nil, makeError("cyclic_value", path, "효과 입력에는 순환 참조를 사용할 수 없습니다.")
end
active[value] = true
local copy = {}
for key, item in pairs(value) do
local keyType = type(key)
if keyType ~= "string" and not isInteger(key, 1) then
active[value] = nil
return nil, makeError(
"invalid_table_key",
path,
"효과 입력 테이블 키는 문자열 또는 1 이상의 정수여야 합니다."
)
end
local childPath = keyType == "string"
and (path .. "." .. key)
or (path .. "[" .. key .. "]")
local cloned, cloneError = cloneData(item, childPath, active)
if cloneError then
active[value] = nil
return nil, cloneError
end
copy[key] = cloned
end
active[value] = nil
return copy, nil
end
local function projectMood(staticInput, spec)
local staticData = normalizeStaticData(staticInput)
local moods = type(staticData) == "table"
and type(staticData.registry) == "table"
and staticData.registry.moods
or nil
if type(moods) ~= "table" or type(spec) ~= "table" then
return failure({ makeError("invalid_mood_projection", "$.spec", "무드 투영 입력이 올바르지 않습니다.") })
end
if not isInteger(spec.turnNumber, 1) or type(moods[spec.mood]) ~= "table" then
return failure({ makeError("invalid_mood_projection", "$.spec", "무드 투영 턴 또는 현재 무드가 올바르지 않습니다.") })
end
local order = {}
local moodCount = 0
for moodId, mood in pairs(moods) do
if type(mood) ~= "table" or mood.id ~= moodId or not isInteger(mood.order, 1) or order[mood.order] ~= nil then
return failure({ makeError("invalid_mood_registry", "$.staticData.registry.moods", "무드 순서가 올바르지 않습니다.") })
end
order[mood.order] = moodId
moodCount = moodCount + 1
end
for index = 1, moodCount do
if order[index] == nil then
return failure({ makeError("invalid_mood_registry", "$.staticData.registry.moods", "무드 순서가 1부터 이어지지 않습니다.") })
end
end
local tokens = {}
local sourceTokens = spec.moodTokens or {}
if type(sourceTokens) ~= "table" or getmetatable(sourceTokens) ~= nil then
return failure({ makeError("invalid_mood_tokens", "$.spec.moodTokens", "무드 토큰이 객체가 아닙니다.") })
end
for moodId in pairs(sourceTokens) do
if moods[moodId] == nil then
return failure({ makeError("unknown_mood", "$.spec.moodTokens." .. tostring(moodId), "등록되지 않은 무드의 토큰입니다.") })
end
end
for _, moodId in ipairs(order) do
local count = sourceTokens[moodId] or 0
if not isInteger(count, 0) then
return failure({ makeError("invalid_mood_token_count", "$.spec.moodTokens." .. moodId, "무드 토큰 수는 0 이상의 정수여야 합니다.") })
end
tokens[moodId] = count
end
local forcedRequests, cloneError = cloneData(spec.forcedMoodRequests or {}, "$.spec.forcedMoodRequests")
if cloneError then return failure({ cloneError }) end
if not isDenseArray(forcedRequests) then
return failure({ makeError("invalid_forced_mood_requests", "$.spec.forcedMoodRequests", "강제 무드 요청이 배열이 아닙니다.") })
end
for index, request in ipairs(forcedRequests) do
if type(request) ~= "table" or type(moods[request.mood]) ~= "table" then
return failure({ makeError("unknown_mood", "$.spec.forcedMoodRequests[" .. index .. "].mood", "등록되지 않은 강제 변경 무드입니다.") })
end
end
local commands = spec.commands or {}
if not isDenseArray(commands) then
return failure({ makeError("invalid_mood_commands", "$.spec.commands", "무드 투영 명령이 배열이 아닙니다.") })
end
for index, command in ipairs(commands) do
local path = "$.spec.commands[" .. index .. "]"
if type(command) ~= "table" or type(moods[command.mood]) ~= "table" then
return failure({ makeError("invalid_mood_command", path, "무드 투영 명령이 올바르지 않습니다.") })
elseif command.op == "add_mood_token" or command.op == "remove_mood_token" then
if not isInteger(command.amount, 1) then
return failure({ makeError("invalid_mood_command", path .. ".amount", "무드 토큰 명령 수치가 올바르지 않습니다.") })
end
local before = tokens[command.mood]
local after = command.op == "add_mood_token"
and before + command.amount
or (before - command.amount)
if not isInteger(math.abs(after), 0) or math.abs(after) > 9007199254740991 then
return failure({ makeError("mood_token_overflow", path, "무드 토큰 수가 안전한 범위를 벗어났습니다.") })
end
tokens[command.mood] = after
elseif command.op == "force_mood" then
forcedRequests[#forcedRequests + 1] = { mood = command.mood }
else
return failure({ makeError("unsupported_mood_command", path .. ".op", "무드 투영이 지원하지 않는 명령입니다.") })
end
end
for moodId, count in pairs(tokens) do tokens[moodId] = math.max(0, count) end
local tokensBefore, tokensBeforeError = cloneData(tokens, "$.projection.tokensBefore")
if tokensBeforeError then return failure({ tokensBeforeError }) end
local payload = {
before = spec.mood,
after = spec.mood,
applied = false,
forcedCount = #forcedRequests,
forceCancelled = #forcedRequests >= 2,
tokensBefore = tokensBefore,
}
if #forcedRequests == 1 then
payload.after = forcedRequests[1].mood
payload.applied = payload.before ~= payload.after
payload.resolution = "forced"
payload.targetMood = payload.after
else
local maximum = 0
local leaders = {}
for _, moodId in ipairs(order) do
local count = tokens[moodId]
if count > maximum then
maximum = count
leaders = { moodId }
elseif count == maximum then
leaders[#leaders + 1] = moodId
end
end
if maximum < 3 then
payload.resolution = "none"
elseif #leaders == 1 then
payload.after = leaders[1]
payload.applied = payload.before ~= payload.after
payload.resolution = "token"
payload.targetMood = payload.after
tokens[payload.after] = 0
else
for _, moodId in ipairs(leaders) do tokens[moodId] = tokens[moodId] - 1 end
payload.resolution = "tie"
payload.tiedMoods = leaders
end
end
local tokensAfter, tokensAfterError = cloneData(tokens, "$.projection.tokensAfter")
if tokensAfterError then return failure({ tokensAfterError }) end
payload.tokensAfter = tokensAfter
local function stealthDelta(moodId, repeated)
if moodId == "rejection" then return repeated and -4 or -2 end
if moodId == "suspicion" then return repeated and -2 or -1 end
if moodId == "confusion" then return 1 end
if moodId == "compliance" then return 2 end
return 0
end
local repeated = spec.turnNumber > 1 and payload.before == payload.after
local finalStealthDelta = stealthDelta(payload.after, repeated)
local tokenProgress = 0
for _, moodId in ipairs(order) do
tokenProgress = tokenProgress + stealthDelta(moodId, false) * tokensAfter[moodId]
end
return reportSuccess({
resolution = {
mood = payload.after,
moodTokens = tokensAfter,
payload = payload,
stealthDelta = finalStealthDelta,
tokenProgress = tokenProgress,
},
})
end
local function appendNestedErrors(errors, prefix, nested)
for _, item in ipairs(type(nested) == "table" and nested or {}) do
local nestedPath = type(item.path) == "string" and item.path or "$"
if string.sub(nestedPath, 1, 1) == "$" then
nestedPath = prefix .. string.sub(nestedPath, 2)
else
nestedPath = prefix .. "." .. nestedPath
end
addError(
errors,
type(item.code) == "string" and item.code or "nested_error",
nestedPath,
type(item.message) == "string" and item.message or "하위 효과 처리에 실패했습니다."
)
end
end
local function validateRuntimeStaticData(staticData, requireCards)
staticData = normalizeStaticData(staticData)
if type(staticData) ~= "table"
or type(staticData.registry) ~= "table"
or type(staticData.registry.effectOps) ~= "table"
or type(staticData.registry.moods) ~= "table"
or (requireCards and type(staticData.cards) ~= "table") then
return nil, {
makeError(
"invalid_static_data",
"$.staticData",
"효과 평가에는 카드와 레지스트리를 포함한 전체 정적 데이터가 필요합니다."
),
}
end
return staticData, nil
end
local function validateModifiers(modifiers, path)
path = path or "$.modifiers"
if modifiers == nil then
return reportSuccess({ modifiers = {} })
end
if not isDenseArray(modifiers) then
return failure({
makeError("invalid_modifiers", path, "수치 보정은 연속 배열이어야 합니다."),
})
end
if #modifiers > 0 then
return failure({
makeError(
"unsupported_modifiers",
path,
"일반 수치 보정 파이프라인이 확정되기 전에는 비어 있지 않은 보정을 적용할 수 없습니다."
),
})
end
return reportSuccess({ modifiers = {} })
end
local function validateOptions(options)
if options == nil then
return {}, nil
end
if type(options) ~= "table" or getmetatable(options) ~= nil then
return nil, {
makeError("invalid_options", "$.options", "효과 옵션은 일반 테이블이어야 합니다."),
}
end
for key in pairs(options) do
if key ~= "modifiers" then
return nil, {
makeError(
"unexpected_option",
"$.options." .. tostring(key),
"지원하지 않는 효과 옵션입니다."
),
}
end
end
local modifierReport = validateModifiers(options.modifiers, "$.options.modifiers")
if not modifierReport.ok then
return nil, modifierReport.errors
end
return options, nil
end
local function validateCause(value, path, errors)
if type(value) ~= "string" or value == "" then
addError(errors, "invalid_command_cause", path, "효과 명령에는 비어 있지 않은 cause가 필요합니다.")
end
end
local function checkCommandKeys(command, allowed, path, errors)
for key in pairs(command) do
if type(key) ~= "string" or not allowed[key] then
addError(
errors,
"unexpected_command_field",
path .. "." .. tostring(key),
"이 효과 명령에 허용되지 않은 필드가 있습니다."
)
end
end
end
local function validateCommands(staticData, commands)
local normalizedStaticData, staticErrors = validateRuntimeStaticData(staticData, false)
if staticErrors then
return failure(staticErrors)
end
if not isDenseArray(commands) then
return failure({
makeError("invalid_commands", "$.commands", "효과 명령은 1부터 이어지는 배열이어야 합니다."),
})
end
local errors = {}
local normalized = {}
for index, command in ipairs(commands) do
local path = "$.commands[" .. index .. "]"
if type(command) ~= "table" or getmetatable(command) ~= nil then
addError(errors, "invalid_command", path, "효과 명령은 일반 테이블이어야 합니다.")
else
local registered = type(command.op) == "string"
and normalizedStaticData.registry.effectOps[command.op]
or nil
if not registered then
addError(errors, "unknown_effect_op", path .. ".op", "등록되지 않은 효과 작업입니다.")
elseif not SUPPORTED_COMMANDS[command.op] then
addError(errors, "unsupported_effect_op", path .. ".op", "v1 해결기가 지원하지 않는 효과 작업입니다.")
end
local common = { op = true, target = true, cause = true }
local output = {
op = command.op,
target = command.target,
cause = command.cause,
}
validateCause(command.cause, path .. ".cause", errors)
local resource = RESOURCE_COMMANDS[command.op]
if resource then
common.amount = true
checkCommandKeys(command, common, path, errors)
if command.target ~= resource.owner then
addError(errors, "invalid_command_target", path .. ".target", "자원 효과 대상이 올바르지 않습니다.")
end
if not isFinite(command.amount) or command.amount < 0 then
addError(errors, "invalid_command_amount", path .. ".amount", "자원 효과 수치는 0 이상의 유한한 숫자여야 합니다.")
end
output.amount = command.amount
elseif command.op == "draw_cards" then
common.amount = true
checkCommandKeys(command, common, path, errors)
if command.target ~= "player" and command.target ~= "character" then
addError(errors, "invalid_command_target", path .. ".target", "드로우 대상이 올바르지 않습니다.")
end
if not isInteger(command.amount, 1) then
addError(errors, "invalid_command_amount", path .. ".amount", "드로우 수량은 1 이상의 정수여야 합니다.")
end
output.amount = command.amount
elseif command.op == "skip_actions" then
common.scope = true
checkCommandKeys(command, common, path, errors)
if command.target ~= "player" and command.target ~= "character" then
addError(errors, "invalid_command_target", path .. ".target", "행동 생략 대상이 올바르지 않습니다.")
end
if command.scope ~= "remainingTurn" then
addError(errors, "invalid_command_scope", path .. ".scope", "v1 행동 생략 범위는 remainingTurn이어야 합니다.")
end
output.scope = command.scope
elseif command.op == "add_mood_token" or command.op == "remove_mood_token" then
common.amount = true
common.mood = true
checkCommandKeys(command, common, path, errors)
if command.target ~= "character" then
addError(errors, "invalid_command_target", path .. ".target", "무드 토큰 대상은 character여야 합니다.")
end
if not isInteger(command.amount, 1) then
addError(errors, "invalid_command_amount", path .. ".amount", "무드 토큰 수는 1 이상의 정수여야 합니다.")
end
if type(command.mood) ~= "string" or not normalizedStaticData.registry.moods[command.mood] then
addError(errors, "unknown_mood", path .. ".mood", "등록되지 않은 무드입니다.")
end
output.amount = command.amount
output.mood = command.mood
elseif command.op == "force_mood" then
common.mood = true
checkCommandKeys(command, common, path, errors)
if command.target ~= "character" then
addError(errors, "invalid_command_target", path .. ".target", "무드 강제 변경 대상은 character여야 합니다.")
end
if type(command.mood) ~= "string" or not normalizedStaticData.registry.moods[command.mood] then
addError(errors, "unknown_mood", path .. ".mood", "등록되지 않은 무드입니다.")
end
output.mood = command.mood
elseif registered and not SUPPORTED_COMMANDS[command.op] then
checkCommandKeys(command, common, path, errors)
elseif not registered then
checkCommandKeys(command, common, path, errors)
end
normalized[index] = output
end
end
if #errors > 0 then
return failure(errors)
end
return reportSuccess({ commands = normalized })
end
local function prepareCallbackValue(value, path)
local copy, cloneError = cloneData(value, path)
if cloneError then
return nil, failure({ cloneError })
end
return copy, nil
end
local function evaluateCommandCallback(staticData, callback, context, event, errorCode, errorPath)
local contextCopy, contextFailure = prepareCallbackValue(context, "$.context")
if contextFailure then
return contextFailure
end
local eventCopy = nil
if event ~= nil then
eventCopy, contextFailure = prepareCallbackValue(event, "$.event")
if contextFailure then
return contextFailure
end
end
local ok, returned = pcall(callback, contextCopy, eventCopy)
if not ok then
return failure({
makeError(errorCode, errorPath, "효과 콜백 실행에 실패했습니다: " .. tostring(returned)),
})
end
local commandReport = validateCommands(staticData, returned)
if not commandReport.ok then
return commandReport
end
return reportSuccess({ commands = commandReport.commands })
end
local function findRuntimeCard(staticData, cardId)
local normalizedStaticData, staticErrors = validateRuntimeStaticData(staticData, true)
if staticErrors then
return nil, nil, staticErrors
end
if type(cardId) ~= "string" or cardId == "" then
return nil, nil, {
makeError("invalid_card_id", "$.cardId", "카드 ID가 없습니다."),
}
end
local card = normalizedStaticData.cards[cardId]
if type(card) ~= "table" or card.id ~= cardId then
return nil, nil, {
makeError("unknown_card", "$.cardId", "정적 DB에서 카드를 찾을 수 없습니다."),
}
end
return normalizedStaticData, card, nil
end
local function evaluateCanPlay(staticData, cardId, context, options)
local _, optionsErrors = validateOptions(options)
if optionsErrors then
return failure(optionsErrors)
end
local _, card, cardErrors = findRuntimeCard(staticData, cardId)
if cardErrors then
return failure(cardErrors)
end
if card.canPlay == nil then
return reportSuccess({ cardId = cardId, playable = true })
end
if type(card.canPlay) ~= "function" then
return failure({
makeError("invalid_can_play", "$.card.canPlay", "카드 canPlay가 함수가 아닙니다."),
})
end
local contextCopy, contextFailure = prepareCallbackValue(context, "$.context")
if contextFailure then
return contextFailure
end
local ok, playable, reasonCode, unexpected = pcall(card.canPlay, contextCopy)
if not ok then
return failure({
makeError("can_play_error", "$.card.canPlay", "canPlay 실행에 실패했습니다: " .. tostring(playable)),
})
end
if type(playable) ~= "boolean" then
return failure({
makeError("invalid_can_play_result", "$.card.canPlay", "canPlay의 첫 반환값은 불리언이어야 합니다."),
})
end
if unexpected ~= nil then
return failure({
makeError("invalid_can_play_result", "$.card.canPlay", "canPlay는 두 값을 초과해 반환할 수 없습니다."),
})
end
if playable and reasonCode ~= nil then
return failure({
makeError("invalid_can_play_reason", "$.card.canPlay", "사용 가능한 카드에는 실패 사유가 없어야 합니다."),
})
end
if not playable and (type(reasonCode) ~= "string" or string.match(reasonCode, "^[a-z][a-z0-9_]*$") == nil) then
return failure({
makeError("invalid_can_play_reason", "$.card.canPlay", "사용 불가 사유는 lower_snake_case 코드여야 합니다."),
})
end
return reportSuccess({
cardId = cardId,
playable = playable,
reasonCode = reasonCode,
})
end
local function evaluateNarrationCondition(staticData, cardId, context, options)
local _, optionsErrors = validateOptions(options)
if optionsErrors then return failure(optionsErrors) end
local _, card, cardErrors = findRuntimeCard(staticData, cardId)
if cardErrors then return failure(cardErrors) end
if type(card.narrationCondition) ~= "function" then
return failure({
makeError("invalid_narration_condition", "$.card.narrationCondition", "조건부 사용 묘사의 판정식이 함수가 아닙니다."),
})
end
local contextCopy, contextFailure = prepareCallbackValue(context, "$.context")
if contextFailure then return contextFailure end
local ok, matched, unexpected = pcall(card.narrationCondition, contextCopy)
if not ok then
return failure({
makeError("narration_condition_error", "$.card.narrationCondition", "조건부 사용 묘사 판정에 실패했습니다: " .. tostring(matched)),
})
end
if type(matched) ~= "boolean" or unexpected ~= nil then
return failure({
makeError("invalid_narration_condition_result", "$.card.narrationCondition", "조건부 사용 묘사 판정은 불리언 하나만 반환해야 합니다."),
})
end
return reportSuccess({ cardId = cardId, matched = matched })
end
local function evaluateEffectChoice(staticData, cardId, choiceId, context, options)
local _, optionsErrors = validateOptions(options)
if optionsErrors then return failure(optionsErrors) end
local _, card, cardErrors = findRuntimeCard(staticData, cardId)
if cardErrors then return failure(cardErrors) end
if type(choiceId) ~= "string" or string.match(choiceId, "^[a-z][a-z0-9_]*$") == nil then
return failure({ makeError("invalid_effect_choice_id", "$.choiceId", "효과 선택지 ID가 올바르지 않습니다.") })
end
local selected
for _, choice in ipairs(type(card.effectChoices) == "table" and card.effectChoices or {}) do
if type(choice) == "table" and choice.id == choiceId then
selected = choice
break
end
end
if selected == nil then
return failure({ makeError("unknown_effect_choice", "$.choiceId", "카드에 등록되지 않은 효과 선택지입니다.") })
end
if selected.canSelect == nil then
return reportSuccess({ cardId = cardId, choiceId = choiceId, selectable = true })
end
if type(selected.canSelect) ~= "function" then
return failure({ makeError("invalid_effect_choice_predicate", "$.card.effectChoices", "효과 선택 가능 조건이 함수가 아닙니다.") })
end
local contextCopy, contextFailure = prepareCallbackValue(context, "$.context")
if contextFailure then return contextFailure end
local ok, selectable, reasonCode, unexpected = pcall(selected.canSelect, contextCopy)
if not ok then
return failure({ makeError("effect_choice_predicate_error", "$.card.effectChoices", "효과 선택 가능 조건 실행에 실패했습니다: " .. tostring(selectable)) })
end
if type(selectable) ~= "boolean" or unexpected ~= nil then
return failure({ makeError("invalid_effect_choice_result", "$.card.effectChoices", "효과 선택 가능 조건은 불리언과 선택적 사유 코드만 반환해야 합니다.") })
end
if selectable and reasonCode ~= nil then
return failure({ makeError("invalid_effect_choice_reason", "$.card.effectChoices", "선택 가능한 효과에는 실패 사유가 없어야 합니다.") })
end
if not selectable and (type(reasonCode) ~= "string" or string.match(reasonCode, "^[a-z][a-z0-9_]*$") == nil) then
return failure({ makeError("invalid_effect_choice_reason", "$.card.effectChoices", "선택 불가 사유는 lower_snake_case 코드여야 합니다.") })
end
return reportSuccess({
cardId = cardId,
choiceId = choiceId,
selectable = selectable,
reasonCode = reasonCode,
})
end
local function evaluateCardResolve(staticData, cardId, context, options)
local _, optionsErrors = validateOptions(options)
if optionsErrors then
return failure(optionsErrors)
end
local _, card, cardErrors = findRuntimeCard(staticData, cardId)
if cardErrors then
return failure(cardErrors)
end
if card.resolve == nil then
return reportSuccess({ cardId = cardId, commands = {} })
end
if type(card.resolve) ~= "function" then
return failure({
makeError("invalid_resolve", "$.card.resolve", "카드 resolve가 함수가 아닙니다."),
})
end
local evaluated = evaluateCommandCallback(
staticData,
card.resolve,
context,
nil,
"card_resolve_error",
"$.card.resolve"
)
if not evaluated.ok then
return evaluated
end
evaluated.cardId = cardId
return evaluated
end
local function evaluateMoodEffect(staticData, cardId, moodId, context, options)
local _, optionsErrors = validateOptions(options)
if optionsErrors then
return failure(optionsErrors)
end
local normalizedStaticData, card, cardErrors = findRuntimeCard(staticData, cardId)
if cardErrors then
return failure(cardErrors)
end
if type(moodId) ~= "string" or not normalizedStaticData.registry.moods[moodId] then
return failure({
makeError("unknown_mood", "$.moodId", "등록되지 않은 무드입니다."),
})
end
local callback = type(card.moodEffects) == "table" and card.moodEffects[moodId] or nil
if callback == nil then
return reportSuccess({ cardId = cardId, moodId = moodId, commands = {} })
end
if type(callback) ~= "function" then
return failure({
makeError("invalid_mood_callback", "$.card.moodEffects." .. moodId, "무드 효과가 함수가 아닙니다."),
})
end
local evaluated = evaluateCommandCallback(
staticData,
callback,
context,
nil,
"mood_effect_error",
"$.card.moodEffects." .. moodId
)
if not evaluated.ok then
return evaluated
end
evaluated.cardId = cardId
evaluated.moodId = moodId
return evaluated
end
local function validateTriggerInput(staticData, triggerSpec, event, options)
local _, optionsErrors = validateOptions(options)
if optionsErrors then
return optionsErrors
end
local normalizedStaticData, staticErrors = validateRuntimeStaticData(staticData, false)
if staticErrors then
return staticErrors
end
if type(triggerSpec) ~= "table" or getmetatable(triggerSpec) ~= nil then
return {
makeError("invalid_trigger", "$.trigger", "트리거 설정은 일반 테이블이어야 합니다."),
}
end
if type(event) ~= "table" or getmetatable(event) ~= nil then
return {
makeError("invalid_trigger_event", "$.event", "트리거 입력 사건은 일반 테이블이어야 합니다."),
}
end
if type(event.type) ~= "string"
or type(normalizedStaticData.registry.events) ~= "table"
or not normalizedStaticData.registry.events[event.type] then
return {
makeError("unknown_trigger_event", "$.event.type", "등록되지 않은 트리거 입력 사건입니다."),
}
end
if triggerSpec.event ~= nil
and (type(triggerSpec.event) ~= "string"
or not normalizedStaticData.registry.events[triggerSpec.event]) then
return {
makeError("unknown_trigger_event", "$.trigger.event", "트리거가 등록되지 않은 사건을 참조합니다."),
}
end
if triggerSpec.side ~= nil
and triggerSpec.side ~= "player"
and triggerSpec.side ~= "character" then
return {
makeError("invalid_trigger_side", "$.trigger.side", "트리거 진영은 player 또는 character여야 합니다."),
}
end
return nil
end
local function evaluateTriggerCondition(staticData, triggerSpec, context, event, options)
local inputErrors = validateTriggerInput(staticData, triggerSpec, event, options)
if inputErrors then
return failure(inputErrors)
end
if triggerSpec.event ~= nil and triggerSpec.event ~= event.type then
return reportSuccess({ matched = false })
end
if triggerSpec.side ~= nil and triggerSpec.side ~= event.side then
return reportSuccess({ matched = false })
end
local matched = true
if triggerSpec.trigger ~= nil then
if type(triggerSpec.trigger) ~= "function" then
return failure({
makeError("invalid_trigger_condition", "$.trigger.trigger", "트리거 조건이 함수가 아닙니다."),
})
end
local contextCopy, contextFailure = prepareCallbackValue(context, "$.context")
if contextFailure then
return contextFailure
end
local eventCopy
eventCopy, contextFailure = prepareCallbackValue(event, "$.event")
if contextFailure then
return contextFailure
end
local ok, result = pcall(triggerSpec.trigger, contextCopy, eventCopy)
if not ok then
return failure({
makeError(
"trigger_condition_error",
"$.trigger.trigger",
"트리거 조건 실행에 실패했습니다: " .. tostring(result)
),
})
end
if type(result) ~= "boolean" then
return failure({
makeError("invalid_trigger_result", "$.trigger.trigger", "트리거 조건은 불리언을 반환해야 합니다."),
})
end
matched = result
end
return reportSuccess({ matched = matched })
end
local function evaluateTriggerResolve(staticData, triggerSpec, context, event, options)
local inputErrors = validateTriggerInput(staticData, triggerSpec, event, options)
if inputErrors then
return failure(inputErrors)
end
if type(triggerSpec.resolve) ~= "function" then
return failure({
makeError("invalid_trigger_resolve", "$.trigger.resolve", "트리거 resolve가 함수가 아닙니다."),
})
end
local evaluated = evaluateCommandCallback(
staticData,
triggerSpec.resolve,
context,
event,
"trigger_resolve_error",
"$.trigger.resolve"
)
if not evaluated.ok then
return evaluated
end
return evaluated
end
local function evaluateTrigger(staticData, triggerSpec, context, event, options)
local condition = evaluateTriggerCondition(staticData, triggerSpec, context, event, options)
if not condition.ok then
return condition
end
if not condition.matched then
return reportSuccess({ matched = false, commands = {} })
end
local evaluated = evaluateTriggerResolve(staticData, triggerSpec, context, event, options)
if not evaluated.ok then
return evaluated
end
evaluated.matched = true
return evaluated
end
local function callCardZones(action, ...)
if type(runScript) ~= "function" then
return nil, {
makeError("runtime_unavailable", "$.runtime.cardZones", "cardZones 실행기를 찾을 수 없습니다."),
}
end
local ok, report = pcall(runScript, triggerId, "cardZones", action, ...)
if not ok then
return nil, {
makeError("card_zones_error", "$.runtime.cardZones", "cardZones 실행에 실패했습니다: " .. tostring(report)),
}
end
if type(report) ~= "table" or report.ok ~= true or type(report.state) ~= "table" then
local errors = {}
appendNestedErrors(errors, "$.runtime.cardZones", type(report) == "table" and report.errors or {})
if #errors == 0 then
addError(errors, "card_zones_error", "$.runtime.cardZones", "cardZones가 올바른 성공 결과를 반환하지 않았습니다.")
end
return nil, errors
end
return report, nil
end
local function drawReceipt(state, owner)
local receipt = {
deckInstanceIds = {},
handInstanceIds = {},
discardInstanceIds = {},
rng = {
seed = type(state.rng) == "table" and state.rng.seed or nil,
cursor = type(state.rng) == "table" and state.rng.cursor or nil,
},
}
local grouped = {
deck = {},
hand = {},
discard = {},
}
for _, instance in ipairs(type(state.cardInstances) == "table" and state.cardInstances or {}) do
if type(instance) == "table"
and instance.owner == owner
and grouped[instance.zone] ~= nil then
grouped[instance.zone][#grouped[instance.zone] + 1] = instance
end
end
for _, zone in ipairs({ "deck", "hand", "discard" }) do
table.sort(grouped[zone], function(left, right)
if left.position ~= right.position then
return left.position < right.position
end
return left.instanceId < right.instanceId
end)
local output = receipt[zone .. "InstanceIds"]
for _, instance in ipairs(grouped[zone]) do
output[#output + 1] = instance.instanceId
end
end
return receipt
end
local function applyCommands(staticData, working, commands, options)
local _, optionsErrors = validateOptions(options)
if optionsErrors then
return failure(optionsErrors)
end
local normalizedStaticData, staticErrors = validateRuntimeStaticData(staticData, false)
if staticErrors then
return failure(staticErrors)
end
local commandReport = validateCommands(normalizedStaticData, commands)
if not commandReport.ok then
return commandReport
end
if type(working) ~= "table" or getmetatable(working) ~= nil then
return failure({
makeError("invalid_working", "$.working", "효과 working 값은 일반 테이블이어야 합니다."),
})
end
if type(working.state) ~= "table" then
return failure({
makeError("invalid_working_state", "$.working.state", "효과를 적용할 전투 상태가 없습니다."),
})
end
if working.transient ~= nil and type(working.transient) ~= "table" then
return failure({
makeError("invalid_transient", "$.working.transient", "효과 transient 값은 테이블이어야 합니다."),
})
end
local state, cloneError = cloneData(working.state, "$.working.state")
if cloneError then
return failure({ cloneError })
end
local transient
transient, cloneError = cloneData(working.transient or {}, "$.working.transient")
if cloneError then
return failure({ cloneError })
end
local applied = {}
for index, command in ipairs(commandReport.commands) do
local entry = {
index = index,
op = command.op,
target = command.target,
cause = command.cause,
changed = false,
}
local resource = RESOURCE_COMMANDS[command.op]
if resource then
local ownerState = state[resource.owner]
local before = type(ownerState) == "table" and ownerState[resource.field] or nil
if not isFinite(before) then
return failure({
makeError(
"invalid_resource_state",
"$.working.state." .. resource.owner .. "." .. resource.field,
"효과 대상 자원이 유한한 숫자가 아닙니다."
),
})
end
local after = before + resource.direction * command.amount
if not isFinite(after) then
return failure({
makeError("non_finite_result", "$.commands[" .. index .. "]", "효과 결과가 유한한 숫자 범위를 벗어났습니다."),
})
end
ownerState[resource.field] = after
entry.amount = command.amount
entry.before = before
entry.after = after
entry.changed = before ~= after
elseif command.op == "draw_cards" then
local before = drawReceipt(state, command.target)
local zoneReport, zoneErrors = callCardZones("draw", state, command.target, command.amount)
if zoneErrors then
return failure(zoneErrors)
end
state = zoneReport.state
entry.amount = command.amount
entry.drawnInstanceIds = zoneReport.drawnInstanceIds or {}
entry.before = before
entry.after = drawReceipt(state, command.target)
entry.changed = #entry.drawnInstanceIds > 0
elseif command.op == "skip_actions" then
if transient.skipRemaining == nil then
transient.skipRemaining = { player = false, character = false }
elseif type(transient.skipRemaining) ~= "table" then
return failure({
makeError("invalid_skip_state", "$.working.transient.skipRemaining", "남은 행동 생략 상태가 테이블이 아닙니다."),
})
end
local before = transient.skipRemaining[command.target] == true
transient.skipRemaining[command.target] = true
entry.scope = command.scope
entry.before = before
entry.after = true
entry.changed = not before
elseif command.op == "add_mood_token" or command.op == "remove_mood_token" then
if type(state.character) ~= "table" then
return failure({
makeError("invalid_mood_state", "$.working.state.character", "캐릭터 무드 상태가 없습니다."),
})
end
if state.character.moodTokens == nil then
state.character.moodTokens = {}
end
if type(state.character.moodTokens) ~= "table" then
return failure({
makeError("invalid_mood_tokens", "$.working.state.character.moodTokens", "무드 토큰 상태가 테이블이 아닙니다."),
})
end
for moodId in pairs(normalizedStaticData.registry.moods) do
local count = state.character.moodTokens[moodId]
if count == nil then
state.character.moodTokens[moodId] = 0
elseif not isInteger(count, 0) then
return failure({
makeError("invalid_mood_token_count", "$.working.state.character.moodTokens." .. moodId, "무드 토큰 수가 0 이상의 정수가 아닙니다."),
})
end
end
local before = state.character.moodTokens[command.mood] or 0
if not isInteger(before, 0) then
return failure({
makeError("invalid_mood_token_count", "$.working.state.character.moodTokens." .. command.mood, "무드 토큰 수가 0 이상의 정수가 아닙니다."),
})
end
-- Unpaid removals expire with this turn's transient state.
transient.moodTokenDebt = transient.moodTokenDebt or {}
if type(transient.moodTokenDebt) ~= "table" then
return failure({ makeError("invalid_mood_token_debt", "$.working.transient.moodTokenDebt", "무드 토큰 감소 잔액이 올바르지 않습니다.") })
end
local debt = transient.moodTokenDebt[command.mood] or 0
if not isInteger(debt, 0) or debt > 9007199254740991 then
return failure({ makeError("invalid_mood_token_debt", "$.working.transient.moodTokenDebt", "무드 토큰 감소 잔액이 올바르지 않습니다.") })
end
local balance = before - debt + (command.op == "add_mood_token" and command.amount or -command.amount)
local after = math.max(0, balance)
if math.abs(balance) > 9007199254740991 then
return failure({
makeError("mood_token_overflow", "$.commands[" .. index .. "].amount", "무드 토큰 수가 안전한 정수 범위를 벗어났습니다."),
})
end
entry.mood = command.mood
entry.amount = command.amount
entry.before = before
entry.after = after
entry.changed = before ~= after
entry.moodTokenDebtBefore = debt
transient.moodTokenDebt[command.mood] = math.max(0, -balance)
state.character.moodTokens[command.mood] = after
elseif command.op == "force_mood" then
if transient.forcedMoodRequests == nil then
transient.forcedMoodRequests = {}
elseif not isDenseArray(transient.forcedMoodRequests) then
return failure({
makeError("invalid_forced_mood_requests", "$.working.transient.forcedMoodRequests", "무드 강제 변경 요청이 연속 배열이 아닙니다."),
})
end
entry.mood = command.mood
entry.before = #transient.forcedMoodRequests
transient.forcedMoodRequests[#transient.forcedMoodRequests + 1] = {
mood = command.mood,
cause = command.cause,
}
entry.after = #transient.forcedMoodRequests
entry.changed = true
end
applied[index] = entry
end
return reportSuccess({
state = state,
transient = transient,
commands = commandReport.commands,
applied = applied,
})
end
local arguments = { ... }
local actions = {
evaluateSelectionPreview = evaluateSelectionPreview,
evaluateCanPlay = evaluateCanPlay,
evaluateNarrationCondition = evaluateNarrationCondition,
evaluateEffectChoice = evaluateEffectChoice,
evaluateCardResolve = evaluateCardResolve,
evaluateMoodEffect = evaluateMoodEffect,
evaluateTriggerCondition = evaluateTriggerCondition,
evaluateTriggerResolve = evaluateTriggerResolve,
evaluateTrigger = evaluateTrigger,
projectMood = projectMood,
validateCommands = validateCommands,
validateModifiers = validateModifiers,
applyCommands = applyCommands,
}
local handler = actions[action]
if not handler then
return failure({
makeError(
"unknown_action",
"$.action",
"지원하지 않는 효과 엔진 작업입니다: " .. tostring(action)
),
})
end
return handler(arguments[1], arguments[2], arguments[3], arguments[4], arguments[5])
end)
#37gameSetup.lua
Keys:
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local KIND = "gameSetupV1"
local TOTAL_DRAFTS = 10
local OFFER_SIZE = 3
local MINIMUM_POOL_SIZE = 7
local RARITY_WEIGHTS = { common = 80, rare = 10, legendary = 1 }
local RARITY_ORDER = { "common", "rare", "legendary" }
local CHARACTER_OFFER_SIZE = 3
local MINIMUM_CHARACTER_POOL_SIZE = 3
local BATTLE_SEED_MODULUS = 2147483646
local BATTLE_SEED_DOMAIN_OFFSET = 104729
local MAX_SAFE_INTEGER = 9007199254740991
local function makeError(code, path, message)
return {
code = code,
path = path,
message = message,
}
end
local function failure(errors)
return {
ok = false,
schemaVersion = SCHEMA_VERSION,
errors = errors,
}
end
local function success(state, applied, stale)
local report = {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
state = state,
}
if applied ~= nil then
report.applied = applied
end
if stale ~= nil then
report.stale = stale
end
return report
end
local function isFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function isSafeInteger(value, minimum)
return isFinite(value)
and value % 1 == 0
and math.abs(value) <= MAX_SAFE_INTEGER
and (minimum == nil or value >= minimum)
end
local function isAsciiId(value)
return type(value) == "string"
and string.match(value, "^[a-z][a-z0-9_]*$") ~= nil
end
local function isRuntimeId(value)
return type(value) == "string"
and string.match(value, "^[A-Za-z0-9][A-Za-z0-9_-]*$") ~= nil
end
local function isInteractionToken(value)
return type(value) == "string"
and string.match(value, "^game%-setup%-draft%-v1:%d+:%d+:%d+$") ~= nil
end
local function isCharacterInteractionToken(value)
return type(value) == "string"
and string.match(value, "^game%-setup%-character%-v1:%d+:%d+:%d+$") ~= nil
end
local function appendError(errors, code, path, message)
errors[#errors + 1] = makeError(code, path, message)
end
local function appendNestedErrors(errors, nested, fallbackPath)
if type(nested) ~= "table" then
appendError(errors, "invalid_nested_errors", fallbackPath, "하위 모듈의 오류 목록이 올바르지 않습니다.")
return
end
for _, item in ipairs(nested) do
errors[#errors + 1] = {
code = tostring(type(item) == "table" and item.code or "nested_error"),
path = tostring(type(item) == "table" and item.path or fallbackPath),
message = tostring(type(item) == "table" and item.message or "하위 모듈 작업이 실패했습니다."),
}
end
end
local function pathForKey(path, key)
if type(key) == "string" and string.match(key, "^[A-Za-z_][A-Za-z0-9_]*$") then
return path .. "." .. key
end
if type(key) == "string" or type(key) == "number" or type(key) == "boolean" then
return path .. "[" .. string.format("%q", tostring(key)) .. "]"
end
return path .. "[<" .. type(key) .. ">]"
end
local function inspectJsonTable(value, path, errors)
if type(value) ~= "table" then
appendError(errors, "expected_table", path, "테이블이어야 합니다.")
return nil, nil
end
if getmetatable(value) ~= nil then
appendError(errors, "metatable_not_allowed", path, "JSON 값에는 메타테이블을 사용할 수 없습니다.")
return nil, nil
end
local numericCount = 0
local maximum = 0
local hasNumeric = false
local hasString = false
local stringKeys = {}
for key in pairs(value) do
if type(key) == "number" then
hasNumeric = true
numericCount = numericCount + 1
if not isSafeInteger(key, 1) then
appendError(errors, "invalid_array_index", path, "배열 인덱스는 1 이상의 연속된 정수여야 합니다.")
return nil, nil
end
if key > maximum then
maximum = key
end
elseif type(key) == "string" then
hasString = true
stringKeys[#stringKeys + 1] = key
else
appendError(errors, "invalid_object_key", path, "JSON 객체 키는 문자열이어야 합니다.")
return nil, nil
end
end
if hasNumeric and hasString then
appendError(errors, "mixed_table", path, "배열 인덱스와 객체 키를 함께 사용할 수 없습니다.")
return nil, nil
end
if hasNumeric then
if numericCount ~= maximum then
appendError(errors, "sparse_array", path, "배열 인덱스는 1부터 빈틈없이 이어져야 합니다.")
return nil, nil
end
return "array", maximum
end
table.sort(stringKeys)
return "object", stringKeys
end
local function validateJson(value, path, errors, active)
local valueType = type(value)
if valueType == "string" or valueType == "boolean" then
return
end
if valueType == "number" then
if not isFinite(value) then
appendError(errors, "non_finite_number", path, "NaN과 무한대는 JSON 상태에 저장할 수 없습니다.")
end
return
end
if valueType ~= "table" then
appendError(errors, "unsupported_type", path, "JSON 상태에 저장할 수 없는 자료형입니다: " .. valueType)
return
end
if getmetatable(value) ~= nil then
appendError(errors, "metatable_not_allowed", path, "JSON 값에는 메타테이블을 사용할 수 없습니다.")
return
end
active = active or {}
if active[value] then
appendError(errors, "circular_reference", path, "순환 참조가 있는 JSON 값은 사용할 수 없습니다.")
return
end
active[value] = true
local kind, shape = inspectJsonTable(value, path, errors)
if kind == "array" then
for index = 1, shape do
validateJson(value[index], path .. "[" .. index .. "]", errors, active)
end
elseif kind == "object" then
for _, key in ipairs(shape) do
validateJson(value[key], pathForKey(path, key), errors, active)
end
end
active[value] = nil
end
local function checkAllowedKeys(value, allowed, path, errors)
if type(value) ~= "table" or getmetatable(value) ~= nil then
return
end
for key in pairs(value) do
if type(key) ~= "string" or not allowed[key] then
appendError(errors, "unknown_field", pathForKey(path, key), "허용되지 않은 필드입니다.")
end
end
end
local function denseArrayLength(value, path, errors)
local kind, length = inspectJsonTable(value, path, errors)
-- Lua의 빈 테이블은 빈 객체와 빈 배열을 구분할 수 없으므로,
-- 배열을 요구하는 이 문맥에서는 빈 테이블을 길이 0으로 해석한다.
if kind == "object" and type(length) == "table" and #length == 0 then
return 0
end
if kind ~= "array" then
if kind ~= nil then
appendError(errors, "expected_array", path, "1부터 시작하는 연속 배열이어야 합니다.")
end
return nil
end
return length
end
local function cloneJson(value, path, active)
local valueType = type(value)
if valueType ~= "table" then
return value
end
active = active or {}
if active[value] then
error(makeError("circular_reference", path, "순환 참조가 있는 값을 복제할 수 없습니다."), 0)
end
active[value] = true
local copy = {}
for key, item in pairs(value) do
copy[key] = cloneJson(item, pathForKey(path, key), active)
end
active[value] = nil
return copy
end
local function cloneChecked(value, path)
local ok, copy = pcall(cloneJson, value, path or "$", {})
if not ok then
if type(copy) == "table" and copy.code then
return nil, copy
end
return nil, makeError("clone_failed", path or "$", "JSON 값 복제에 실패했습니다: " .. tostring(copy))
end
return copy, nil
end
local function deepEqual(left, right, seen)
if type(left) ~= type(right) then
return false
end
if type(left) ~= "table" then
return left == right
end
seen = seen or {}
seen[left] = seen[left] or {}
if seen[left][right] then
return true
end
seen[left][right] = true
for key, item in pairs(left) do
if not deepEqual(item, right[key], seen) then
return false
end
end
for key in pairs(right) do
if left[key] == nil then
return false
end
end
return true
end
local function normalizeStaticData(staticData)
if type(staticData) == "table"
and getmetatable(staticData) == nil
and type(rawget(staticData, "data")) == "table" then
return rawget(staticData, "data")
end
return staticData
end
local function buildPlayerPool(staticInput)
local errors = {}
local staticData = normalizeStaticData(staticInput)
if type(staticData) ~= "table" or getmetatable(staticData) ~= nil then
appendError(errors, "invalid_static_data", "$.staticData", "정적 데이터는 메타테이블이 없는 테이블이어야 합니다.")
return nil, errors
end
local cards = rawget(staticData, "cards")
if type(cards) ~= "table" or getmetatable(cards) ~= nil then
appendError(errors, "invalid_card_database", "$.staticData.cards", "cards는 메타테이블이 없는 카드 맵이어야 합니다.")
return nil, errors
end
local cardIds = {}
local cardsById = {}
for cardId, card in pairs(cards) do
local cardPath = pathForKey("$.staticData.cards", cardId)
if type(cardId) ~= "string" then
appendError(errors, "invalid_card_key", "$.staticData.cards", "카드 맵 키는 ASCII ID 문자열이어야 합니다.")
elseif type(card) ~= "table" or getmetatable(card) ~= nil then
appendError(errors, "invalid_card_record", cardPath, "카드 레코드는 메타테이블이 없는 테이블이어야 합니다.")
elseif rawget(card, "owner") == "player" then
if not isAsciiId(cardId) then
appendError(errors, "invalid_player_card_id", cardPath, "플레이어 카드 키는 ASCII cardId여야 합니다.")
elseif RARITY_WEIGHTS[card.rarity] == nil then
appendError(errors, "invalid_player_card_rarity", cardPath .. ".rarity", "플레이어 카드 희귀도는 common, rare 또는 legendary여야 합니다.")
elseif not isAsciiId(card.draftStyle) then
appendError(errors, "invalid_player_card_style", cardPath .. ".draftStyle", "플레이어 카드에는 ASCII draftStyle이 필요합니다.")
else
cardIds[#cardIds + 1] = cardId
cardsById[cardId] = {
rarity = card.rarity,
draftStyle = card.draftStyle,
maxCopies = card.rarity == "legendary" and 1 or 2,
}
end
end
end
table.sort(cardIds)
if #cardIds < MINIMUM_POOL_SIZE then
appendError(
errors,
"insufficient_player_card_pool",
"$.staticData.cards",
"10회 드래프트에서 항상 3장을 제시하려면 플레이어 카드가 최소 7종 필요합니다."
)
end
if #errors > 0 then
return nil, errors
end
return { cardIds = cardIds, cardsById = cardsById }, nil
end
local function buildCharacterPool(staticInput)
local errors = {}
local staticData = normalizeStaticData(staticInput)
if type(staticData) ~= "table" or getmetatable(staticData) ~= nil then
appendError(errors, "invalid_static_data", "$.staticData", "정적 데이터는 메타테이블이 없는 테이블이어야 합니다.")
return nil, errors
end
local characters = rawget(staticData, "characters")
if type(characters) ~= "table" or getmetatable(characters) ~= nil then
appendError(errors, "invalid_character_database", "$.staticData.characters", "characters는 메타테이블이 없는 캐릭터 맵이어야 합니다.")
return nil, errors
end
local pool = {}
for characterId, character in pairs(characters) do
local characterPath = pathForKey("$.staticData.characters", characterId)
if type(characterId) ~= "string" or not isAsciiId(characterId) then
appendError(errors, "invalid_character_id", characterPath, "캐릭터 맵 키는 lower_snake_case ASCII ID여야 합니다.")
elseif type(character) ~= "table" or getmetatable(character) ~= nil then
appendError(errors, "invalid_character_record", characterPath, "캐릭터 레코드는 메타테이블이 없는 테이블이어야 합니다.")
else
pool[#pool + 1] = characterId
end
end
table.sort(pool)
if #pool < MINIMUM_CHARACTER_POOL_SIZE then
appendError(
errors,
"insufficient_character_pool",
"$.staticData.characters",
"캐릭터 선택에서는 서로 다른 후보가 최소 3명 필요합니다."
)
end
if #errors > 0 then
return nil, errors
end
return pool, nil
end
local function callNextIntegers(rng, ranges)
if type(runScript) ~= "function" then
return nil, nil, {
makeError("runtime_unavailable", "$.runtime.deterministicRng", "deterministicRng를 호출할 runScript가 없습니다."),
}
end
local ok, report = pcall(
runScript,
triggerId,
"deterministicRng",
"nextIntegers",
rng,
ranges
)
if not ok then
return nil, nil, {
makeError("module_call_failed", "$.runtime.deterministicRng", "deterministicRng.nextIntegers 호출에 실패했습니다: " .. tostring(report)),
}
end
if type(report) ~= "table" then
return nil, nil, {
makeError("invalid_module_result", "$.runtime.deterministicRng", "deterministicRng가 테이블 결과를 반환하지 않았습니다."),
}
end
if report.ok ~= true then
local errors = {}
appendNestedErrors(errors, report.errors, "$.runtime.deterministicRng")
return nil, nil, errors
end
local errors = {}
local valueCount = denseArrayLength(report.value, "$.runtime.deterministicRng.value", errors)
if valueCount ~= #ranges then
appendError(
errors,
"invalid_rng_batch_size",
"$.runtime.deterministicRng.value",
"deterministicRng의 batch 결과 개수가 요청 개수와 다릅니다."
)
elseif valueCount ~= nil then
for index = 1, valueCount do
local value = report.value[index]
local range = ranges[index]
if not isSafeInteger(value, range.minimum) or value > range.maximum then
appendError(
errors,
"invalid_rng_batch_value",
"$.runtime.deterministicRng.value[" .. index .. "]",
"deterministicRng의 batch 결과가 요청 범위를 벗어났습니다."
)
end
end
end
if type(report.rng) ~= "table"
or not isSafeInteger(report.rng.seed, 0)
or not isSafeInteger(report.rng.cursor, 0)
or report.rng.seed ~= rng.seed
or report.rng.cursor <= rng.cursor then
appendError(errors, "invalid_rng_result", "$.runtime.deterministicRng", "deterministicRng의 결과 계약이 올바르지 않습니다.")
end
if #errors > 0 then
return nil, nil, errors
end
local values = {}
for index = 1, valueCount do
values[index] = report.value[index]
end
return values, {
seed = report.rng.seed,
cursor = report.rng.cursor,
}, nil
end
local function buildToken(setupId, round, rng, selectedCardIds, offerCardIds)
local parts = {
"setupId=", tostring(#setupId), ":", setupId,
"|round=", tostring(round),
"|cursor=", tostring(rng.cursor),
"|selected=", tostring(#selectedCardIds), ":",
}
for _, cardId in ipairs(selectedCardIds) do
parts[#parts + 1] = tostring(#cardId)
parts[#parts + 1] = ":"
parts[#parts + 1] = cardId
parts[#parts + 1] = ";"
end
parts[#parts + 1] = "|offer="
for _, cardId in ipairs(offerCardIds) do
parts[#parts + 1] = tostring(#cardId)
parts[#parts + 1] = ":"
parts[#parts + 1] = cardId
parts[#parts + 1] = ";"
end
local canonical = table.concat(parts)
local hashA = 0
local hashB = 0
for index = 1, #canonical do
local byte = string.byte(canonical, index)
hashA = (hashA * 131 + byte) % 2147483647
hashB = (hashB * 137 + byte) % 2147483629
end
return "game-setup-draft-v1:" .. tostring(#canonical) .. ":" .. tostring(hashA) .. ":" .. tostring(hashB)
end
local function copyArray(array)
local copy = {}
for index, item in ipairs(array) do
copy[index] = item
end
return copy
end
local function buildCharacterToken(setupId, rng, characterIds)
local parts = {
"setupId=", tostring(#setupId), ":", setupId,
"|cursor=", tostring(rng.cursor),
"|characters=", tostring(#characterIds), ":",
}
for _, characterId in ipairs(characterIds) do
parts[#parts + 1] = tostring(#characterId)
parts[#parts + 1] = ":"
parts[#parts + 1] = characterId
parts[#parts + 1] = ";"
end
local canonical = table.concat(parts)
local hashA = 0
local hashB = 0
for index = 1, #canonical do
local byte = string.byte(canonical, index)
hashA = (hashA * 131 + byte) % 2147483647
hashB = (hashB * 137 + byte) % 2147483629
end
return "game-setup-character-v1:" .. tostring(#canonical) .. ":" .. tostring(hashA) .. ":" .. tostring(hashB)
end
local function generateCharacterOffer(setupId, rng, characterPool)
local candidates = copyArray(characterPool)
local ranges = {}
for pick = 1, CHARACTER_OFFER_SIZE do
ranges[pick] = {
minimum = 1,
maximum = #candidates - pick + 1,
}
end
local selectedIndices, nextRng, rngErrors = callNextIntegers(rng, ranges)
if rngErrors then
return nil, nil, rngErrors
end
local selected = {}
for pick = 1, CHARACTER_OFFER_SIZE do
local selectedIndex = selectedIndices[pick]
selected[pick] = candidates[selectedIndex]
table.remove(candidates, selectedIndex)
end
return {
characterIds = selected,
interactionToken = buildCharacterToken(setupId, nextRng, selected),
}, nextRng, nil
end
local function deriveBattleSeed(setupSeed)
-- 1-based seed 공간 안에서 고정 domain offset만큼 순환한다.
-- setup RNG cursor와 드래프트/캐릭터 선택 경로는 결과에 관여하지 않는다.
-- 큰 IEEE-754 안전 정수도 offset 덧셈 전에 범위를 줄여 중간 계산이
-- MAX_SAFE_INTEGER를 넘지 않게 한다.
local normalized = (setupSeed - 1) % BATTLE_SEED_MODULUS
return ((normalized + BATTLE_SEED_DOMAIN_OFFSET) % BATTLE_SEED_MODULUS) + 1
end
local function buildBattleSpec(setupId, setupSeed)
return {
battleId = "battle-" .. setupId,
seed = deriveBattleSeed(setupSeed),
}
end
local function chooseOne(rng, candidates)
local values, nextRng, errors = callNextIntegers(rng, {
{ minimum = 1, maximum = #candidates },
})
if errors then return nil, nil, errors end
return candidates[values[1]], nextRng, nil
end
local function chooseRarity(rng)
local total = 0
for _, rarity in ipairs(RARITY_ORDER) do total = total + RARITY_WEIGHTS[rarity] end
local values, nextRng, errors = callNextIntegers(rng, {
{ minimum = 1, maximum = total },
})
if errors then return nil, nil, errors end
local cumulative = 0
for _, rarity in ipairs(RARITY_ORDER) do
cumulative = cumulative + RARITY_WEIGHTS[rarity]
if values[1] <= cumulative then return rarity, nextRng, nil end
end
end
local function eligibleCards(pool, counts, excluded, rarity, style)
local candidates = {}
for _, cardId in ipairs(pool.cardIds) do
local card = pool.cardsById[cardId]
if card.rarity == rarity
and (style == nil or card.draftStyle == style)
and excluded[cardId] ~= true
and (counts[cardId] or 0) < card.maxCopies then
candidates[#candidates + 1] = cardId
end
end
return candidates
end
local function rarityFallbacks(rarity)
if rarity == "legendary" then return { "legendary", "rare", "common" } end
if rarity == "rare" then return { "rare", "common" } end
return { "common", "rare", "legendary" }
end
local function generateOffer(setupId, round, rng, selectedCardIds, counts, pool)
local totalEligible = 0
for _, cardId in ipairs(pool.cardIds) do
local card = pool.cardsById[cardId]
if (counts[cardId] or 0) < card.maxCopies then totalEligible = totalEligible + 1 end
end
if totalEligible < OFFER_SIZE then
return nil, nil, {
makeError("insufficient_eligible_cards", "$.selectedCardIds", "복제 제한을 지키며 3장을 제시할 수 없습니다."),
}
end
local offered = {}
local excluded = {}
local currentRng = rng
local anchorStyle = nil
if round > 1 then
local anchorId = selectedCardIds[#selectedCardIds]
anchorStyle = pool.cardsById[anchorId].draftStyle
end
for pick = 1, OFFER_SIZE do
local rarity, rngErrors
rarity, currentRng, rngErrors = chooseRarity(currentRng)
if rngErrors then return nil, nil, rngErrors end
local requestedStyle = pick == 1 and anchorStyle or nil
local candidates = {}
for _, fallbackRarity in ipairs(rarityFallbacks(rarity)) do
candidates = eligibleCards(pool, counts, excluded, fallbackRarity, requestedStyle)
if #candidates > 0 then break end
end
if #candidates == 0 and requestedStyle ~= nil then
for _, fallbackRarity in ipairs(rarityFallbacks(rarity)) do
candidates = eligibleCards(pool, counts, excluded, fallbackRarity, nil)
if #candidates > 0 then break end
end
end
local selectedId
selectedId, currentRng, rngErrors = chooseOne(currentRng, candidates)
if rngErrors then return nil, nil, rngErrors end
offered[pick] = selectedId
excluded[selectedId] = true
end
if anchorStyle ~= nil then
-- 스타일 우선 카드를 확보한 뒤 표시 위치만 무작위로 바꿉니다.
local positions, positionErrors
positions, currentRng, positionErrors = callNextIntegers(currentRng, {
{ minimum = 1, maximum = OFFER_SIZE },
})
if positionErrors then return nil, nil, positionErrors end
local position = positions[1]
offered[1], offered[position] = offered[position], offered[1]
end
return {
round = round,
cardIds = offered,
interactionToken = buildToken(setupId, round, currentRng, selectedCardIds, offered),
}, currentRng, nil
end
local function contains(array, target)
for _, value in ipairs(array) do
if value == target then
return true
end
end
return false
end
local function replay(setupId, seed, selectedCardIds, pool)
-- 저장/복구 경계의 기준 구현이다. seed와 전체 선택 이력만으로
-- authority를 처음부터 다시 만들며 validate는 항상 이 경로를 쓴다.
-- 버튼 처리의 다음 상태 생성은 아래 advanceValidatedState에서 현재
-- 검증이 끝난 RNG cursor부터 이어 가되, 이 구현은 삭제하지 않는다.
local counts = {}
local rng = { seed = seed, cursor = 0 }
for round = 1, TOTAL_DRAFTS do
local history = {}
for index = 1, round - 1 do
history[index] = selectedCardIds[index]
end
local offer, nextRng, offerErrors = generateOffer(setupId, round, rng, history, counts, pool)
if offerErrors then
return nil, offerErrors
end
rng = nextRng
if round <= #selectedCardIds then
local selectedId = selectedCardIds[round]
if not contains(offer.cardIds, selectedId) then
return nil, {
makeError(
"selection_not_in_replayed_offer",
"$.selectedCardIds[" .. round .. "]",
"선택 이력이 결정적 드래프트 제안과 일치하지 않습니다."
),
}
end
counts[selectedId] = (counts[selectedId] or 0) + 1
if counts[selectedId] > pool.cardsById[selectedId].maxCopies then
return nil, {
makeError("card_copy_limit_exceeded", "$.selectedCardIds[" .. round .. "]", "카드별 보유 제한을 초과했습니다."),
}
end
else
return {
schemaVersion = SCHEMA_VERSION,
kind = KIND,
setupId = setupId,
phase = "deckDraft",
rng = rng,
selectedCardIds = copyArray(selectedCardIds),
offer = offer,
}, nil
end
end
return {
schemaVersion = SCHEMA_VERSION,
kind = KIND,
setupId = setupId,
phase = "deckComplete",
rng = rng,
selectedCardIds = copyArray(selectedCardIds),
}, nil
end
local function replayForPhase(setupId, seed, selectedCardIds, pool, phase, characterPool, selectedCharacterId)
local deckState, deckErrors = replay(setupId, seed, selectedCardIds, pool)
if deckErrors then
return nil, deckErrors
end
if phase == "deckDraft" or phase == "deckComplete" then
return deckState, nil
end
if deckState.phase ~= "deckComplete" then
return nil, {
makeError("character_selection_before_deck_complete", "$.state.phase", "캐릭터 선택은 초기 덱 10장을 완성한 뒤에만 시작할 수 있습니다."),
}
end
if type(characterPool) ~= "table" then
return nil, {
makeError("character_pool_unavailable", "$.staticData.characters", "캐릭터 선택을 재생할 캐릭터 풀이 없습니다."),
}
end
local characterOffer, nextRng, offerErrors = generateCharacterOffer(
setupId,
deckState.rng,
characterPool
)
if offerErrors then
return nil, offerErrors
end
if phase == "characterSelect" then
return {
schemaVersion = SCHEMA_VERSION,
kind = KIND,
setupId = setupId,
phase = "characterSelect",
rng = nextRng,
selectedCardIds = copyArray(selectedCardIds),
characterOffer = characterOffer,
}, nil
end
if phase ~= "battleReady" then
return nil, {
makeError("invalid_setup_phase", "$.state.phase", "지원하지 않는 게임 설정 phase입니다."),
}
end
if not contains(characterOffer.characterIds, selectedCharacterId) then
return nil, {
makeError("selection_not_in_replayed_character_offer", "$.state.selectedCharacterId", "선택 캐릭터가 결정적으로 재생한 후보에 포함되지 않습니다."),
}
end
return {
schemaVersion = SCHEMA_VERSION,
kind = KIND,
setupId = setupId,
phase = "battleReady",
rng = nextRng,
selectedCardIds = copyArray(selectedCardIds),
selectedCharacterId = selectedCharacterId,
battleSpec = buildBattleSpec(setupId, seed),
}, nil
end
local function advanceValidatedState(current, selectedCardId, pool)
-- current는 같은 choose 호출에서 validateAndReplay를 통과해 얻은
-- canonical snapshot이다. 외부/저장 값을 이 함수에 직접 넣지 않는다.
local selected = copyArray(current.selectedCardIds)
selected[#selected + 1] = selectedCardId
local counts = {}
for _, cardId in ipairs(selected) do
counts[cardId] = (counts[cardId] or 0) + 1
if counts[cardId] > pool.cardsById[cardId].maxCopies then
return nil, {
makeError(
"card_copy_limit_exceeded",
"$.selectedCardIds[" .. #selected .. "]",
"카드별 보유 제한을 초과했습니다."
),
}
end
end
if #selected == TOTAL_DRAFTS then
return {
schemaVersion = SCHEMA_VERSION,
kind = KIND,
setupId = current.setupId,
phase = "deckComplete",
rng = {
seed = current.rng.seed,
cursor = current.rng.cursor,
},
selectedCardIds = selected,
}, nil
end
local nextRound = #selected + 1
local offer, nextRng, offerErrors = generateOffer(
current.setupId,
nextRound,
current.rng,
selected,
counts,
pool
)
if offerErrors then
return nil, offerErrors
end
return {
schemaVersion = SCHEMA_VERSION,
kind = KIND,
setupId = current.setupId,
phase = "deckDraft",
rng = nextRng,
selectedCardIds = selected,
offer = offer,
}, nil
end
local function validateStateShape(state, pool, characterPool)
local errors = {}
validateJson(state, "$.state", errors, {})
if type(state) ~= "table" or getmetatable(state) ~= nil then
return nil, errors
end
checkAllowedKeys(state, {
schemaVersion = true,
kind = true,
setupId = true,
phase = true,
rng = true,
selectedCardIds = true,
offer = true,
characterOffer = true,
selectedCharacterId = true,
battleSpec = true,
}, "$.state", errors)
if state.schemaVersion ~= SCHEMA_VERSION then
appendError(errors, "unsupported_schema_version", "$.state.schemaVersion", "지원하지 않는 게임 설정 스키마입니다.")
end
if state.kind ~= KIND then
appendError(errors, "invalid_state_kind", "$.state.kind", "게임 설정 상태 kind가 올바르지 않습니다.")
end
if not isRuntimeId(state.setupId) then
appendError(errors, "invalid_setup_id", "$.state.setupId", "setupId는 ASCII 런타임 ID여야 합니다.")
end
if state.phase ~= "deckDraft"
and state.phase ~= "deckComplete"
and state.phase ~= "characterSelect"
and state.phase ~= "battleReady" then
appendError(errors, "invalid_setup_phase", "$.state.phase", "지원하지 않는 게임 설정 phase입니다.")
end
if type(state.rng) ~= "table" or getmetatable(state.rng) ~= nil then
appendError(errors, "invalid_rng", "$.state.rng", "rng는 메타테이블이 없는 테이블이어야 합니다.")
else
checkAllowedKeys(state.rng, { seed = true, cursor = true }, "$.state.rng", errors)
if not isSafeInteger(state.rng.seed, 0) then
appendError(errors, "invalid_rng_seed", "$.state.rng.seed", "seed는 0 이상의 IEEE-754 안전 정수여야 합니다.")
end
if not isSafeInteger(state.rng.cursor, 0) then
appendError(errors, "invalid_rng_cursor", "$.state.rng.cursor", "cursor는 0 이상의 IEEE-754 안전 정수여야 합니다.")
end
end
local selectedLength = denseArrayLength(state.selectedCardIds, "$.state.selectedCardIds", errors)
local poolSet = {}
for _, cardId in ipairs(pool.cardIds) do
poolSet[cardId] = true
end
if selectedLength ~= nil then
if selectedLength > TOTAL_DRAFTS then
appendError(errors, "too_many_selected_cards", "$.state.selectedCardIds", "초기 덱은 10장을 초과할 수 없습니다.")
end
local counts = {}
for index = 1, selectedLength do
local cardId = state.selectedCardIds[index]
if not isAsciiId(cardId) then
appendError(errors, "invalid_selected_card_id", "$.state.selectedCardIds[" .. index .. "]", "선택한 카드 ID가 올바르지 않습니다.")
elseif not poolSet[cardId] then
appendError(errors, "unknown_selected_card", "$.state.selectedCardIds[" .. index .. "]", "현재 플레이어 카드 풀에 없는 카드입니다.")
else
counts[cardId] = (counts[cardId] or 0) + 1
if counts[cardId] > pool.cardsById[cardId].maxCopies then
appendError(errors, "card_copy_limit_exceeded", "$.state.selectedCardIds[" .. index .. "]", "카드별 보유 제한을 초과했습니다.")
end
end
end
end
local characterPoolSet = {}
for _, characterId in ipairs(characterPool or {}) do
characterPoolSet[characterId] = true
end
if state.phase == "deckDraft" then
if selectedLength ~= nil and selectedLength >= TOTAL_DRAFTS then
appendError(errors, "invalid_draft_progress", "$.state.phase", "10장을 모두 선택한 상태는 deckComplete이어야 합니다.")
end
if type(state.offer) ~= "table" or getmetatable(state.offer) ~= nil then
appendError(errors, "missing_draft_offer", "$.state.offer", "deckDraft 상태에는 현재 제안이 필요합니다.")
else
checkAllowedKeys(state.offer, {
round = true,
cardIds = true,
interactionToken = true,
}, "$.state.offer", errors)
if not isSafeInteger(state.offer.round, 1) or state.offer.round > TOTAL_DRAFTS then
appendError(errors, "invalid_offer_round", "$.state.offer.round", "제안 라운드는 1부터 10 사이의 정수여야 합니다.")
end
if selectedLength ~= nil and state.offer.round ~= selectedLength + 1 then
appendError(errors, "offer_round_mismatch", "$.state.offer.round", "제안 라운드가 선택 진행도와 일치하지 않습니다.")
end
local offerLength = denseArrayLength(state.offer.cardIds, "$.state.offer.cardIds", errors)
if offerLength ~= nil then
if offerLength ~= OFFER_SIZE then
appendError(errors, "invalid_offer_size", "$.state.offer.cardIds", "드래프트 제안은 서로 다른 카드 3장이어야 합니다.")
end
local seen = {}
for index = 1, offerLength do
local cardId = state.offer.cardIds[index]
if not isAsciiId(cardId) or not poolSet[cardId] then
appendError(errors, "invalid_offer_card", "$.state.offer.cardIds[" .. index .. "]", "제안 카드가 현재 플레이어 카드 풀에 없습니다.")
elseif seen[cardId] then
appendError(errors, "duplicate_offer_card", "$.state.offer.cardIds[" .. index .. "]", "한 제안에 같은 카드를 두 번 넣을 수 없습니다.")
end
seen[cardId] = true
end
end
if not isInteractionToken(state.offer.interactionToken) then
appendError(errors, "invalid_interaction_token", "$.state.offer.interactionToken", "interactionToken 형식이 올바르지 않습니다.")
end
end
if rawget(state, "characterOffer") ~= nil
or rawget(state, "selectedCharacterId") ~= nil
or rawget(state, "battleSpec") ~= nil then
appendError(errors, "character_fields_not_allowed", "$.state", "deckDraft 상태에는 캐릭터 선택 필드를 저장하지 않습니다.")
end
elseif state.phase == "deckComplete" then
if selectedLength ~= nil and selectedLength ~= TOTAL_DRAFTS then
appendError(errors, "invalid_complete_progress", "$.state.selectedCardIds", "deckComplete 상태에는 카드가 정확히 10장 있어야 합니다.")
end
if rawget(state, "offer") ~= nil then
appendError(errors, "offer_not_allowed", "$.state.offer", "deckComplete 상태에는 제안을 저장하지 않습니다.")
end
if rawget(state, "characterOffer") ~= nil
or rawget(state, "selectedCharacterId") ~= nil
or rawget(state, "battleSpec") ~= nil then
appendError(errors, "character_fields_not_allowed", "$.state", "deckComplete 상태에는 캐릭터 선택 결과를 저장하지 않습니다.")
end
elseif state.phase == "characterSelect" then
if selectedLength ~= nil and selectedLength ~= TOTAL_DRAFTS then
appendError(errors, "invalid_character_select_progress", "$.state.selectedCardIds", "characterSelect 상태에는 카드가 정확히 10장 있어야 합니다.")
end
if rawget(state, "offer") ~= nil then
appendError(errors, "offer_not_allowed", "$.state.offer", "characterSelect 상태에는 카드 제안을 저장하지 않습니다.")
end
if rawget(state, "selectedCharacterId") ~= nil or rawget(state, "battleSpec") ~= nil then
appendError(errors, "battle_fields_not_allowed", "$.state", "characterSelect 상태에는 전투 준비 결과를 저장하지 않습니다.")
end
if type(state.characterOffer) ~= "table" or getmetatable(state.characterOffer) ~= nil then
appendError(errors, "missing_character_offer", "$.state.characterOffer", "characterSelect 상태에는 캐릭터 후보가 필요합니다.")
else
checkAllowedKeys(state.characterOffer, {
characterIds = true,
interactionToken = true,
}, "$.state.characterOffer", errors)
local characterLength = denseArrayLength(
state.characterOffer.characterIds,
"$.state.characterOffer.characterIds",
errors
)
if characterLength ~= nil then
if characterLength ~= CHARACTER_OFFER_SIZE then
appendError(errors, "invalid_character_offer_size", "$.state.characterOffer.characterIds", "캐릭터 후보는 서로 다른 3명이어야 합니다.")
end
local seen = {}
for index = 1, characterLength do
local characterId = state.characterOffer.characterIds[index]
if not isAsciiId(characterId) or not characterPoolSet[characterId] then
appendError(errors, "invalid_offered_character", "$.state.characterOffer.characterIds[" .. index .. "]", "후보가 현재 캐릭터 풀에 없습니다.")
elseif seen[characterId] then
appendError(errors, "duplicate_offered_character", "$.state.characterOffer.characterIds[" .. index .. "]", "한 제안에 같은 캐릭터를 두 번 넣을 수 없습니다.")
end
seen[characterId] = true
end
end
if not isCharacterInteractionToken(state.characterOffer.interactionToken) then
appendError(errors, "invalid_character_interaction_token", "$.state.characterOffer.interactionToken", "캐릭터 interactionToken 형식이 올바르지 않습니다.")
end
end
elseif state.phase == "battleReady" then
if selectedLength ~= nil and selectedLength ~= TOTAL_DRAFTS then
appendError(errors, "invalid_battle_ready_progress", "$.state.selectedCardIds", "battleReady 상태에는 카드가 정확히 10장 있어야 합니다.")
end
if rawget(state, "offer") ~= nil or rawget(state, "characterOffer") ~= nil then
appendError(errors, "offer_not_allowed", "$.state", "battleReady 상태에는 제안을 저장하지 않습니다.")
end
if not isAsciiId(state.selectedCharacterId) or not characterPoolSet[state.selectedCharacterId] then
appendError(errors, "invalid_selected_character", "$.state.selectedCharacterId", "선택 캐릭터가 현재 캐릭터 풀에 없습니다.")
end
if type(state.battleSpec) ~= "table" or getmetatable(state.battleSpec) ~= nil then
appendError(errors, "invalid_battle_spec", "$.state.battleSpec", "battleSpec은 메타테이블이 없는 객체여야 합니다.")
else
checkAllowedKeys(state.battleSpec, {
battleId = true,
seed = true,
}, "$.state.battleSpec", errors)
if not isRuntimeId(state.battleSpec.battleId) then
appendError(errors, "invalid_battle_id", "$.state.battleSpec.battleId", "battleId는 ASCII 런타임 ID여야 합니다.")
end
if not isSafeInteger(state.battleSpec.seed, 1) or state.battleSpec.seed > BATTLE_SEED_MODULUS then
appendError(errors, "invalid_battle_seed", "$.state.battleSpec.seed", "전투 seed는 1부터 2147483646 사이의 정수여야 합니다.")
end
end
end
if #errors > 0 then
return nil, errors
end
return selectedLength, nil
end
local function validateAndReplay(state, staticInput)
local pool, poolErrors = buildPlayerPool(staticInput)
if poolErrors then
return nil, poolErrors
end
local characterPool = nil
if type(state) == "table"
and (state.phase == "characterSelect" or state.phase == "battleReady") then
local characterErrors
characterPool, characterErrors = buildCharacterPool(staticInput)
if characterErrors then
return nil, characterErrors
end
end
local _, shapeErrors = validateStateShape(state, pool, characterPool)
if shapeErrors then
return nil, shapeErrors
end
local expected, replayErrors = replayForPhase(
state.setupId,
state.rng.seed,
state.selectedCardIds,
pool,
state.phase,
characterPool,
state.selectedCharacterId
)
if replayErrors then
return nil, replayErrors
end
if not deepEqual(state, expected) then
return nil, {
makeError("setup_state_replay_mismatch", "$.state", "저장된 상태가 seed와 선택 이력으로 재생성한 RNG·제안·토큰과 일치하지 않습니다."),
}
end
return expected, nil, pool, characterPool
end
local function validateSpec(spec)
local errors = {}
validateJson(spec, "$.spec", errors, {})
if type(spec) ~= "table" or getmetatable(spec) ~= nil then
return errors
end
checkAllowedKeys(spec, { setupId = true, seed = true }, "$.spec", errors)
if not isRuntimeId(spec.setupId) then
appendError(errors, "invalid_setup_id", "$.spec.setupId", "setupId는 ASCII 런타임 ID여야 합니다.")
end
if not isSafeInteger(spec.seed, 0) then
appendError(errors, "invalid_seed", "$.spec.seed", "seed는 0 이상의 IEEE-754 안전 정수여야 합니다.")
end
return errors
end
local function validateCommand(command)
local errors = {}
validateJson(command, "$.command", errors, {})
if type(command) ~= "table" or getmetatable(command) ~= nil then
return errors
end
checkAllowedKeys(command, { cardId = true, interactionToken = true }, "$.command", errors)
if not isAsciiId(command.cardId) then
appendError(errors, "invalid_command_card_id", "$.command.cardId", "cardId는 ASCII 카드 ID여야 합니다.")
end
if not isInteractionToken(command.interactionToken) then
appendError(errors, "invalid_command_token", "$.command.interactionToken", "interactionToken 형식이 올바르지 않습니다.")
end
return errors
end
local function validateCharacterCommand(command)
local errors = {}
validateJson(command, "$.command", errors, {})
if type(command) ~= "table" or getmetatable(command) ~= nil then
return errors
end
checkAllowedKeys(command, { characterId = true, interactionToken = true }, "$.command", errors)
if not isAsciiId(command.characterId) then
appendError(errors, "invalid_command_character_id", "$.command.characterId", "characterId는 ASCII 캐릭터 ID여야 합니다.")
end
if not isCharacterInteractionToken(command.interactionToken) then
appendError(errors, "invalid_command_token", "$.command.interactionToken", "캐릭터 interactionToken 형식이 올바르지 않습니다.")
end
return errors
end
local function startSetup(spec, staticInput)
local specErrors = validateSpec(spec)
if #specErrors > 0 then
return failure(specErrors)
end
local pool, poolErrors = buildPlayerPool(staticInput)
if poolErrors then
return failure(poolErrors)
end
local state, replayErrors = replay(spec.setupId, spec.seed, {}, pool)
if replayErrors then
return failure(replayErrors)
end
return success(state)
end
local function validateSetup(state, staticInput)
local expected, errors = validateAndReplay(state, staticInput)
if errors then
return failure(errors)
end
return success(expected)
end
local function chooseCard(state, command, staticInput)
local commandErrors = validateCommand(command)
if #commandErrors > 0 then
return failure(commandErrors)
end
local current, stateErrors, pool = validateAndReplay(state, staticInput)
if stateErrors then
return failure(stateErrors)
end
if current.phase ~= "deckDraft" then
local stateCopy, cloneError = cloneChecked(state, "$.state")
if cloneError then
return failure({ cloneError })
end
return success(stateCopy, false, true)
end
if command.interactionToken ~= current.offer.interactionToken then
local stateCopy, cloneError = cloneChecked(state, "$.state")
if cloneError then
return failure({ cloneError })
end
return success(stateCopy, false, true)
end
if not contains(current.offer.cardIds, command.cardId) then
return failure({
makeError("card_not_in_current_offer", "$.command.cardId", "현재 드래프트 제안에 없는 카드입니다."),
})
end
local nextState, advanceErrors = advanceValidatedState(current, command.cardId, pool)
if advanceErrors then
return failure(advanceErrors)
end
return success(nextState, true, false)
end
local function beginCharacterSelect(state, staticInput)
local current, stateErrors = validateAndReplay(state, staticInput)
if stateErrors then
return failure(stateErrors)
end
if current.phase ~= "deckComplete" then
return failure({
makeError("deck_not_complete", "$.state.phase", "캐릭터 선택은 deckComplete 상태에서만 시작할 수 있습니다."),
})
end
local characterPool, characterErrors = buildCharacterPool(staticInput)
if characterErrors then
return failure(characterErrors)
end
local characterOffer, nextRng, offerErrors = generateCharacterOffer(
current.setupId,
current.rng,
characterPool
)
if offerErrors then
return failure(offerErrors)
end
return success({
schemaVersion = SCHEMA_VERSION,
kind = KIND,
setupId = current.setupId,
phase = "characterSelect",
rng = nextRng,
selectedCardIds = copyArray(current.selectedCardIds),
characterOffer = characterOffer,
}, true, false)
end
local function chooseCharacter(state, command, staticInput)
local commandErrors = validateCharacterCommand(command)
if #commandErrors > 0 then
return failure(commandErrors)
end
local current, stateErrors = validateAndReplay(state, staticInput)
if stateErrors then
return failure(stateErrors)
end
if current.phase == "battleReady" then
return success(current, false, true)
end
if current.phase ~= "characterSelect" then
return failure({
makeError("character_selection_not_started", "$.state.phase", "현재 상태에서는 캐릭터를 선택할 수 없습니다."),
})
end
if command.interactionToken ~= current.characterOffer.interactionToken then
return success(current, false, true)
end
if not contains(current.characterOffer.characterIds, command.characterId) then
return failure({
makeError("character_not_in_current_offer", "$.command.characterId", "현재 제안에 없는 캐릭터입니다."),
})
end
return success({
schemaVersion = SCHEMA_VERSION,
kind = KIND,
setupId = current.setupId,
phase = "battleReady",
rng = {
seed = current.rng.seed,
cursor = current.rng.cursor,
},
selectedCardIds = copyArray(current.selectedCardIds),
selectedCharacterId = command.characterId,
battleSpec = buildBattleSpec(current.setupId, current.rng.seed),
}, true, false)
end
local arguments = { ... }
local actions = {
start = startSetup,
choose = chooseCard,
beginCharacterSelect = beginCharacterSelect,
chooseCharacter = chooseCharacter,
validate = validateSetup,
}
local handler = actions[action]
if not handler then
return failure({
makeError("unknown_action", "$.action", "지원하지 않는 게임 설정 작업입니다: " .. tostring(action)),
})
end
return handler(arguments[1], arguments[2], arguments[3])
end)
#38gameSetupController.lua
Keys:
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local MAX_SAFE_INTEGER = 9007199254740991
local AUTHORITY_KEY = "gameSetupV1.authority"
local VIEW_NAME = "gameSetupView"
local RUN_AUTHORITY_KEY = "runProgressionV1.authority"
local RUN_VIEW_NAME = "runProgressionView"
local READY_NAME = "gameSetupReady"
local UI_NAME = "🔯🔯🔯"
local UI_SHELL_NAME = "helltrainUiShellV1"
local UI_SHELL_REVISION_NAME = "helltrainUiShellRevision"
local UI_SHELL_REVISION = "sidebar-e3f104ae8f3037cd"
local DIAGNOSTIC_SCOPE = "helltrain.gameSetupController"
local arguments = { ... }
local argumentCount = select("#", ...)
local function diagnosticText(value)
return tostring(value):gsub("[\r\n]+", " ")
end
local function emitDiagnostic(depth, event, fields)
if type(DEBUG) ~= "number" or depth > DEBUG then
return
end
if type(print) ~= "function" then
return
end
local parts = {
"[" .. DIAGNOSTIC_SCOPE .. "]",
"depth=" .. tostring(depth),
"event=" .. diagnosticText(event),
}
for _, key in ipairs({ "action", "errorCount", "code", "path", "message" }) do
local value = type(fields) == "table" and fields[key] or nil
if value ~= nil then
parts[#parts + 1] = key .. "=" .. diagnosticText(value)
end
end
pcall(print, table.concat(parts, " | "))
for index, item in ipairs(type(fields) == "table" and type(fields.errors) == "table" and fields.errors or {}) do
local errorParts = {
"[" .. DIAGNOSTIC_SCOPE .. "]",
"depth=" .. tostring(depth),
"event=request_error",
"index=" .. tostring(index),
}
for _, key in ipairs({ "code", "path", "message" }) do
if type(item) == "table" and item[key] ~= nil then
errorParts[#errorParts + 1] = key .. "=" .. diagnosticText(item[key])
end
end
pcall(print, table.concat(errorParts, " | "))
end
end
local function makeError(code, path, message)
return {
code = code,
path = path,
message = message,
}
end
local function failure(errors)
return {
ok = false,
schemaVersion = SCHEMA_VERSION,
errors = errors,
}
end
local function success(fields)
local report = {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
}
for key, value in pairs(fields or {}) do
report[key] = value
end
return report
end
local function isFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function isSafeInteger(value, minimum)
return isFinite(value)
and value % 1 == 0
and math.abs(value) <= MAX_SAFE_INTEGER
and (minimum == nil or value >= minimum)
end
local function objectPath(path, key)
if type(key) == "string" and string.match(key, "^[A-Za-z_][A-Za-z0-9_]*$") then
return path .. "." .. key
end
return path .. "[" .. string.format("%q", tostring(key)) .. "]"
end
local function cloneJson(value, path, active)
local valueType = type(value)
if valueType == "nil" or valueType == "string" or valueType == "boolean" then
return value, nil
end
if valueType == "number" then
if not isFinite(value) then
return nil, makeError("non_finite_number", path, "유한하지 않은 숫자는 컨트롤러 데이터에 사용할 수 없습니다.")
end
return value, nil
end
if valueType ~= "table" then
return nil, makeError(
"unsupported_type",
path,
"JSON 컨트롤러 데이터에 사용할 수 없는 자료형입니다: " .. valueType
)
end
if getmetatable(value) ~= nil then
return nil, makeError("metatable_not_allowed", path, "컨트롤러 데이터에는 메타테이블을 사용할 수 없습니다.")
end
active = active or {}
if active[value] then
return nil, makeError("circular_reference", path, "순환 참조는 컨트롤러 데이터에 사용할 수 없습니다.")
end
active[value] = true
local hasNumeric = false
local hasString = false
local numericCount = 0
local maximum = 0
for key in pairs(value) do
if type(key) == "number" then
hasNumeric = true
if not isSafeInteger(key, 1) then
active[value] = nil
return nil, makeError("invalid_array_index", path, "배열 인덱스는 1 이상의 정수여야 합니다.")
end
numericCount = numericCount + 1
if key > maximum then
maximum = key
end
elseif type(key) == "string" then
hasString = true
else
active[value] = nil
return nil, makeError("invalid_object_key", path, "객체 키는 문자열이어야 합니다.")
end
end
if hasNumeric and hasString then
active[value] = nil
return nil, makeError("mixed_table", path, "숫자 인덱스와 문자열 키를 함께 사용할 수 없습니다.")
end
if hasNumeric and numericCount ~= maximum then
active[value] = nil
return nil, makeError("sparse_array", path, "배열 인덱스는 1부터 빈틈없이 이어져야 합니다.")
end
local copy = {}
if hasNumeric then
for index = 1, maximum do
local itemCopy, itemError = cloneJson(value[index], path .. "[" .. index .. "]", active)
if itemError then
active[value] = nil
return nil, itemError
end
copy[index] = itemCopy
end
else
for key, item in pairs(value) do
local itemCopy, itemError = cloneJson(item, objectPath(path, key), active)
if itemError then
active[value] = nil
return nil, itemError
end
copy[key] = itemCopy
end
end
active[value] = nil
return copy, nil
end
local function deepEqual(left, right, active)
if type(left) ~= type(right) then
return false
end
if type(left) ~= "table" then
return left == right
end
if getmetatable(left) ~= nil or getmetatable(right) ~= nil then
return false
end
active = active or {}
if active[left] ~= nil then
return active[left] == right
end
active[left] = right
for key, value in pairs(left) do
if not deepEqual(value, right[key], active) then
active[left] = nil
return false
end
end
for key in pairs(right) do
if left[key] == nil then
active[left] = nil
return false
end
end
active[left] = nil
return true
end
local function appendNestedErrors(target, moduleName, report)
if type(report) == "table" and type(report.errors) == "table" then
for index, item in ipairs(report.errors) do
if type(item) == "table"
and type(item.code) == "string"
and type(item.path) == "string"
and type(item.message) == "string" then
target[#target + 1] = makeError(item.code, item.path, item.message)
else
target[#target + 1] = makeError(
"invalid_nested_error",
"$.runtime." .. moduleName .. ".errors[" .. index .. "]",
"하위 모듈 오류 항목이 올바른 구조가 아닙니다."
)
end
end
end
if #target == 0 then
target[1] = makeError(
"module_failed_without_errors",
"$.runtime." .. moduleName,
moduleName .. "이 오류 상세 없이 실패했습니다."
)
end
end
local function validateErrorArray(moduleName, errors)
if type(errors) ~= "table" or getmetatable(errors) ~= nil then
return false
end
local count = 0
local maximum = 0
for key, item in pairs(errors) do
if type(key) ~= "number" or not isSafeInteger(key, 1) then
return false
end
count = count + 1
if key > maximum then maximum = key end
if type(item) ~= "table"
or getmetatable(item) ~= nil
or type(item.code) ~= "string"
or type(item.path) ~= "string"
or type(item.message) ~= "string" then
return false
end
end
return count == maximum
end
local function callModule(moduleName, moduleAction, ...)
if type(runScript) ~= "function" then
return nil, {
makeError("runtime_unavailable", "$.runtime", "runScript 실행기를 찾을 수 없습니다."),
}
end
local ok, report = pcall(runScript, triggerId, moduleName, moduleAction, ...)
if not ok then
return nil, {
makeError(
"module_call_error",
"$.runtime." .. moduleName,
moduleName .. "." .. moduleAction .. " 호출 중 오류가 발생했습니다: " .. tostring(report)
),
}
end
if type(report) ~= "table" or getmetatable(report) ~= nil then
return nil, {
makeError(
"invalid_module_result",
"$.runtime." .. moduleName,
moduleName .. "." .. moduleAction .. "이 일반 테이블 결과를 반환하지 않았습니다."
),
}
end
local isBridge = moduleName == "dataBridge"
local versionOk = report.schemaVersion == SCHEMA_VERSION
or (isBridge and report.schemaVersion == nil and report.wireFormat == "cbs-json-nodes-v1")
local errorsOk = validateErrorArray(moduleName, report.errors)
or (isBridge and report.ok == true and report.errors == nil)
if (report.ok ~= true and report.ok ~= false) or not versionOk or not errorsOk then
return nil, {
makeError(
"invalid_module_envelope",
"$.runtime." .. moduleName,
moduleName .. "." .. moduleAction .. " 결과 envelope가 올바르지 않습니다."
),
}
end
if report.ok ~= true then
local errors = {}
appendNestedErrors(errors, moduleName, report)
return nil, errors
end
if type(report.errors) == "table" and #report.errors ~= 0 then
return nil, {
makeError(
"success_with_errors",
"$.runtime." .. moduleName .. ".errors",
"성공한 하위 모듈 결과에 오류가 포함되어 있습니다."
),
}
end
return report, nil
end
local function loadStaticData()
local report, errors = callModule("staticData", "loadAll")
if errors then return nil, errors end
if type(report.data) ~= "table" or getmetatable(report.data) ~= nil then
return nil, {
makeError("missing_static_data", "$.runtime.staticData.data", "검증된 전체 정적 데이터가 없습니다."),
}
end
return report.data, nil
end
local function readAuthority(required)
if type(HostCompat) ~= "table" or type(HostCompat.readState) ~= "function" then
return nil, {
makeError("state_read_unavailable", "$.host.getState", "상태 읽기 호환 함수를 찾을 수 없습니다."),
}
end
local ok, value = pcall(HostCompat.readState, triggerId, AUTHORITY_KEY)
if not ok then
return nil, {
makeError("state_read_failed", "$.state.authority", "게임 설정 상태를 읽지 못했습니다: " .. tostring(value)),
}
end
if value == nil then
if required then
return nil, {
makeError("missing_authority", "$.state.authority", "먼저 게임 설정을 시작해야 합니다."),
}
end
return nil, nil
end
local copy, copyError = cloneJson(value, "$.state.authority")
if copyError then return nil, { copyError } end
return copy, nil
end
local function readRunAuthority(required)
if type(HostCompat) ~= "table" or type(HostCompat.readState) ~= "function" then
return nil, {
makeError("state_read_unavailable", "$.host.getState", "상태 읽기 호환 함수를 찾을 수 없습니다."),
}
end
local ok, value = pcall(HostCompat.readState, triggerId, RUN_AUTHORITY_KEY)
if not ok then
return nil, {
makeError("state_read_failed", "$.state.runAuthority", "진행 상태를 읽지 못했습니다: " .. tostring(value)),
}
end
if value == nil then
if required then
return nil, {
makeError("missing_run_authority", "$.state.runAuthority", "전투 후 진행 상태가 없습니다."),
}
end
return nil, nil
end
local copy, copyError = cloneJson(value, "$.state.runAuthority")
if copyError then return nil, { copyError } end
return copy, nil
end
local function generateSetupSeed()
if type(cbs) ~= "function" then
return nil, {
makeError("cbs_unavailable", "$.host.cbs", "초기 seed를 만들 CBS 함수를 찾을 수 없습니다."),
}
end
-- getLoreBooks가 Lua 로어를 반환하기 전에 CBS를 평가하므로,
-- 소스에 완성된 동적 매크로를 두면 컴파일 캐시가 첫 seed를
-- 고정할 수 있다. 호스트 cbs 호출 직전에만 문자열을 조립한다.
local seedMacro = string.rep("{", 2)
.. "randint::1::2147483646"
.. string.rep("}", 2)
local ok, rendered = pcall(cbs, seedMacro)
if not ok then
return nil, {
makeError("seed_generation_failed", "$.host.cbs", "초기 seed 생성에 실패했습니다: " .. tostring(rendered)),
}
end
if type(rendered) ~= "string" or string.match(rendered, "^[1-9][0-9]*$") == nil then
return nil, {
makeError(
"invalid_generated_seed",
"$.host.cbs.result",
"CBS randint 결과는 앞뒤 문자가 없는 양의 십진 정수여야 합니다."
),
}
end
local seed = tonumber(rendered)
if not isSafeInteger(seed, 1) or seed > 2147483646 then
return nil, {
makeError(
"generated_seed_out_of_range",
"$.host.cbs.result",
"초기 seed는 1부터 2147483646 사이의 정수여야 합니다."
),
}
end
return seed, nil
end
local function loadSetupUi(phase)
if type(loadLores) ~= "function" then
return nil, {
makeError("lore_loader_unavailable", "$.host.loadLores", "UI 로어북을 읽을 loadLores 함수를 찾을 수 없습니다."),
}
end
local loreName
local lorePath
if phase == "deckDraft" or phase == "deckComplete" then
loreName = "cardDraft.html"
lorePath = "$.lore.cardDraft"
elseif phase == "characterSelect" then
loreName = "characterSelect.html"
lorePath = "$.lore.characterSelect"
else
return nil, {
makeError("invalid_setup_ui_phase", "$.state.phase", "이 설정 phase에는 setup UI를 게시할 수 없습니다."),
}
end
local loadOk, setupUi = pcall(loadLores, triggerId, loreName)
if not loadOk then
return nil, {
makeError("lore_load_failed", lorePath, loreName .. "을 읽지 못했습니다: " .. tostring(setupUi)),
}
end
if type(setupUi) ~= "string" or setupUi == "" then
return nil, {
makeError("missing_lore", lorePath, loreName .. " 로어북 내용이 없습니다."),
}
end
return setupUi, nil
end
local function loadRunUi()
if type(loadLores) ~= "function" then
return nil, {
makeError("lore_loader_unavailable", "$.host.loadLores", "UI 로어북을 읽을 loadLores 함수를 찾을 수 없습니다."),
}
end
local loadOk, runUi = pcall(loadLores, triggerId, "postBattle.html")
if not loadOk then
return nil, {
makeError("lore_load_failed", "$.lore.postBattle", "postBattle.html을 읽지 못했습니다: " .. tostring(runUi)),
}
end
if type(runUi) ~= "string" or runUi == "" then
return nil, {
makeError("missing_lore", "$.lore.postBattle", "postBattle.html 로어북 내용이 없습니다."),
}
end
return runUi, nil
end
local function permitCanonicalOperation(purpose, viewName)
if purpose == "gameSetupViewCanonicalV1" then
return true
end
if purpose == "runProgressionViewCanonicalV1" then
return true
end
if purpose == "battleControllerCanonicalSetupV1"
or purpose == "battleControllerCanonicalRunV1" then
return true
end
return purpose == "dataBridgeCanonicalV1"
and (viewName == VIEW_NAME or viewName == RUN_VIEW_NAME)
end
local function buildTarget(state, staticData)
local stateCopy, stateCopyError = cloneJson(state, "$.target.state")
if stateCopyError then return nil, { stateCopyError } end
-- stateCopy는 이 controller transaction에서 gameSetup.start/choose/validate가
-- 반환한 canonical state이다. 버튼 문자열로 위조할 수 없는
-- 함수 capability를 넘겨 View의 전체 authority replay만 중복 제거한다.
local viewReport, viewErrors = callModule(
"gameSetupView",
"_buildCanonical",
stateCopy,
staticData,
permitCanonicalOperation
)
if viewErrors then return nil, viewErrors end
if type(viewReport.view) ~= "table" or getmetatable(viewReport.view) ~= nil then
return nil, {
makeError("missing_setup_view", "$.runtime.gameSetupView.view", "gameSetupView 생성 결과에 View가 없습니다."),
}
end
local viewCopy, viewCopyError = cloneJson(viewReport.view, "$.target.view")
if viewCopyError then return nil, { viewCopyError } end
return {
state = stateCopy,
view = viewCopy,
}, nil
end
local function buildRunTarget(runState, setupState, staticData)
local runCopy, runCopyError = cloneJson(runState, "$.target.runState")
if runCopyError then return nil, { runCopyError } end
local setupCopy, setupCopyError = cloneJson(setupState, "$.target.setupState")
if setupCopyError then return nil, { setupCopyError } end
local viewReport, viewErrors = callModule(
"runProgressionView",
"_buildCanonical",
runCopy,
setupCopy,
staticData,
permitCanonicalOperation
)
if viewErrors then return nil, viewErrors end
if type(viewReport.view) ~= "table" or getmetatable(viewReport.view) ~= nil then
return nil, {
makeError(
"missing_run_progression_view",
"$.runtime.runProgressionView.view",
"runProgressionView 생성 결과에 View가 없습니다."
),
}
end
local viewCopy, viewCopyError = cloneJson(viewReport.view, "$.target.runView")
if viewCopyError then return nil, { viewCopyError } end
return {
state = runCopy,
setupState = setupCopy,
view = viewCopy,
}, nil
end
local function preflightHost(writeAuthority)
local required = {
{ name = "writeChatVar", value = type(HostCompat) == "table" and HostCompat.writeChatVar or nil },
{ name = "getChatVar", value = getChatVar },
}
if writeAuthority then
required[#required + 1] = { name = "writeState", value = type(HostCompat) == "table" and HostCompat.writeState or nil }
required[#required + 1] = { name = "readState", value = type(HostCompat) == "table" and HostCompat.readState or nil }
end
local errors = {}
for _, entry in ipairs(required) do
if type(entry.value) ~= "function" then
errors[#errors + 1] = makeError(
"host_function_unavailable",
"$.host." .. entry.name,
entry.name .. " 호스트 함수를 찾을 수 없습니다."
)
end
end
if #errors > 0 then return errors end
return nil
end
local function writeChatVarStored(name, value, path)
local writeOk, writeError = pcall(HostCompat.writeChatVar, triggerId, name, value)
if not writeOk then
return {
makeError("chat_var_write_failed", path, "채팅 변수 쓰기에 실패했습니다: " .. tostring(writeError)),
}
end
return nil
end
local function ensureUiShell()
local revisionOk, currentRevision = pcall(getChatVar, triggerId, UI_SHELL_REVISION_NAME)
if not revisionOk then
return {
makeError("chat_var_verify_failed", "$.chatVar.uiShellRevision", "UI shell revision을 읽지 못했습니다: " .. tostring(currentRevision)),
}
end
local shellOk, currentShell = pcall(getChatVar, triggerId, UI_SHELL_NAME)
if not shellOk then
return {
makeError("chat_var_verify_failed", "$.chatVar.uiShell", "UI shell을 읽지 못했습니다: " .. tostring(currentShell)),
}
end
if currentRevision == UI_SHELL_REVISION
and type(currentShell) == "string"
and currentShell ~= "" then
return nil
end
local loadOk, sideBar = pcall(loadLores, triggerId, "sideBar.html")
if not loadOk then
return {
makeError("lore_load_failed", "$.lore.sideBar", "sideBar.html을 읽지 못했습니다: " .. tostring(sideBar)),
}
end
if type(sideBar) ~= "string" or sideBar == "" then
return {
makeError("missing_lore", "$.lore.sideBar", "sideBar.html 로어북 내용이 없습니다."),
}
end
local shellErrors = writeChatVarStored(UI_SHELL_NAME, sideBar, "$.chatVar.uiShell")
if shellErrors then return shellErrors end
return writeChatVarStored(
UI_SHELL_REVISION_NAME,
UI_SHELL_REVISION,
"$.chatVar.uiShellRevision"
)
end
local function verifyExpectedAuthority(expectedAuthority, expectMissing)
local beforeOk, before = pcall(HostCompat.readState, triggerId, AUTHORITY_KEY)
if not beforeOk then
return {
makeError(
"state_verify_read_failed",
"$.state.authority",
"권위 상태 쓰기 직전 현재 값을 읽지 못했습니다: " .. tostring(before)
),
}
end
if expectMissing == true then
if before ~= nil then
return {
makeError(
"authority_concurrent_change",
"$.state.authority",
"새 설정을 저장하기 전에 다른 요청이 권위 상태를 만들었습니다."
),
}
end
elseif type(expectedAuthority) ~= "table" or not deepEqual(before, expectedAuthority) then
return {
makeError(
"authority_concurrent_change",
"$.state.authority",
"설정 전이를 저장하기 전에 권위 상태가 다른 요청에 의해 변경되었습니다."
),
}
end
return nil
end
local function writeAuthorityVerified(state, expectedAuthority, expectMissing)
local concurrentErrors = verifyExpectedAuthority(expectedAuthority, expectMissing)
if concurrentErrors then return concurrentErrors end
local storedCopy, copyError = cloneJson(state, "$.state.authority")
if copyError then return { copyError } end
local writeOk, writeError = pcall(HostCompat.writeState, triggerId, AUTHORITY_KEY, storedCopy)
if not writeOk then
return {
makeError("state_write_failed", "$.state.authority", "게임 설정 상태 저장에 실패했습니다: " .. tostring(writeError)),
}
end
local readOk, stored = pcall(HostCompat.readState, triggerId, AUTHORITY_KEY)
if not readOk then
return {
makeError("state_verify_read_failed", "$.state.authority", "쓰기 뒤 게임 설정 상태를 읽지 못했습니다: " .. tostring(stored)),
}
end
if not deepEqual(storedCopy, stored) then
return {
makeError("state_write_not_persisted", "$.state.authority", "쓰기 뒤 읽은 상태가 저장하려던 상태와 다릅니다."),
}
end
-- 동일 transaction에서 gameSetup이 만든 canonical snapshot과
-- host readback이 exact-equal이므로 또 전체 replay할 필요는 없다.
-- 다음 이벤트에서 저장소를 다시 읽을 때는 다시 검증한다.
return nil
end
local function verifyExpectedRunAuthority(expectedAuthority, expectMissing)
local beforeOk, before = pcall(HostCompat.readState, triggerId, RUN_AUTHORITY_KEY)
if not beforeOk then
return {
makeError(
"state_verify_read_failed",
"$.state.runAuthority",
"진행 상태 쓰기 직전 현재 값을 읽지 못했습니다: " .. tostring(before)
),
}
end
if expectMissing == true then
if before ~= nil then
return {
makeError(
"run_authority_concurrent_change",
"$.state.runAuthority",
"첫 전투 정산을 저장하기 전에 다른 요청이 진행 상태를 만들었습니다."
),
}
end
elseif type(expectedAuthority) ~= "table" or not deepEqual(before, expectedAuthority) then
return {
makeError(
"run_authority_concurrent_change",
"$.state.runAuthority",
"진행 전이를 저장하기 전에 상태가 다른 요청에 의해 변경되었습니다."
),
}
end
return nil
end
local function writeRunAuthorityVerified(state, expectedAuthority, expectMissing)
local concurrentErrors = verifyExpectedRunAuthority(expectedAuthority, expectMissing)
if concurrentErrors then return concurrentErrors end
local storedCopy, copyError = cloneJson(state, "$.state.runAuthority")
if copyError then return { copyError } end
local writeOk, writeError = pcall(HostCompat.writeState, triggerId, RUN_AUTHORITY_KEY, storedCopy)
if not writeOk then
return {
makeError("state_write_failed", "$.state.runAuthority", "진행 상태 저장에 실패했습니다: " .. tostring(writeError)),
}
end
local readOk, stored = pcall(HostCompat.readState, triggerId, RUN_AUTHORITY_KEY)
if not readOk then
return {
makeError("state_verify_read_failed", "$.state.runAuthority", "쓰기 뒤 진행 상태를 읽지 못했습니다: " .. tostring(stored)),
}
end
if not deepEqual(storedCopy, stored) then
return {
makeError("state_write_not_persisted", "$.state.runAuthority", "쓰기 뒤 읽은 진행 상태가 저장하려던 상태와 다릅니다."),
}
end
return nil
end
local function beginPublish(writeAuthority, expectedAuthority, expectMissing)
local hostErrors = preflightHost(writeAuthority)
if hostErrors then return failure(hostErrors) end
if writeAuthority then
local concurrentErrors = verifyExpectedAuthority(expectedAuthority, expectMissing)
if concurrentErrors then return failure(concurrentErrors) end
end
local updatingErrors = writeChatVarStored(READY_NAME, "updating", "$.chatVar.gameSetupReady")
if updatingErrors then return failure(updatingErrors) end
return nil
end
local function beginRunPublish(writeAuthority, expectedAuthority, expectMissing)
local hostErrors = preflightHost(writeAuthority)
if hostErrors then return failure(hostErrors) end
if writeAuthority then
local concurrentErrors = verifyExpectedRunAuthority(expectedAuthority, expectMissing)
if concurrentErrors then return failure(concurrentErrors) end
end
local updatingErrors = writeChatVarStored(READY_NAME, "updating", "$.chatVar.gameSetupReady")
if updatingErrors then return failure(updatingErrors) end
return nil
end
local function publishState(
state,
writeAuthority,
actionName,
applied,
stale,
staticData,
expectedAuthority,
expectMissing
)
if writeAuthority then
local authorityErrors = writeAuthorityVerified(
state,
expectedAuthority,
expectMissing
)
if authorityErrors then return failure(authorityErrors) end
end
local target, targetErrors = buildTarget(state, staticData)
if targetErrors then return failure(targetErrors) end
local published, publishErrors = callModule(
"dataBridge",
"_publishCanonical",
VIEW_NAME,
target.view,
permitCanonicalOperation
)
if publishErrors then return failure(publishErrors) end
if type(published.encoded) ~= "string" or published.encoded == "" then
return failure({
makeError("missing_published_view", "$.runtime.dataBridge.encoded", "게시 결과에 gameSetupView 문자열이 없습니다."),
})
end
local shellErrors = ensureUiShell()
if shellErrors then return failure(shellErrors) end
-- getLoreBooks는 로어 내용을 반환하기 전에 CBS를 평가하므로
-- gameSetupView를 먼저 쓴 뒤 setup HTML을 로드한다.
local ui, loadUiErrors = loadSetupUi(state.phase)
if loadUiErrors then return failure(loadUiErrors) end
local uiErrors = writeChatVarStored(UI_NAME, ui, "$.chatVar.ui")
if uiErrors then return failure(uiErrors) end
local readyErrors = writeChatVarStored(READY_NAME, "ready", "$.chatVar.gameSetupReady")
if readyErrors then return failure(readyErrors) end
-- start/choose는 risu-btn 호출 전용이다. RisuAI가 button trigger
-- 완료 직후 클릭된 message pointer를 한 번 remount하므로 여기서
-- 또 reload하면 같은 HTML/CBS를 두 번 파싱하게 된다.
local returnState, stateError = cloneJson(target.state, "$.result.state")
if stateError then return failure({ stateError }) end
local returnView, viewError = cloneJson(target.view, "$.result.view")
if viewError then return failure({ viewError }) end
return success({
action = actionName,
applied = applied,
stale = stale,
state = returnState,
view = returnView,
})
end
local function publishRunState(
runState,
setupState,
writeAuthority,
actionName,
applied,
stale,
staticData,
expectedAuthority,
expectMissing
)
local beginErrors = beginRunPublish(
writeAuthority,
expectedAuthority,
expectMissing
)
if beginErrors then return beginErrors end
if writeAuthority then
local authorityErrors = writeRunAuthorityVerified(
runState,
expectedAuthority,
expectMissing
)
if authorityErrors then return failure(authorityErrors) end
end
local target, targetErrors = buildRunTarget(runState, setupState, staticData)
if targetErrors then return failure(targetErrors) end
local published, publishErrors = callModule(
"dataBridge",
"_publishCanonical",
RUN_VIEW_NAME,
target.view,
permitCanonicalOperation
)
if publishErrors then return failure(publishErrors) end
if type(published.encoded) ~= "string" or published.encoded == "" then
return failure({
makeError(
"missing_published_view",
"$.runtime.dataBridge.encoded",
"게시 결과에 runProgressionView 문자열이 없습니다."
),
})
end
local shellErrors = ensureUiShell()
if shellErrors then return failure(shellErrors) end
local ui, loadUiErrors = loadRunUi()
if loadUiErrors then return failure(loadUiErrors) end
local uiErrors = writeChatVarStored(UI_NAME, ui, "$.chatVar.ui")
if uiErrors then return failure(uiErrors) end
local readyErrors = writeChatVarStored(READY_NAME, "ready", "$.chatVar.gameSetupReady")
if readyErrors then return failure(readyErrors) end
local returnState, stateError = cloneJson(target.state, "$.result.state")
if stateError then return failure({ stateError }) end
local returnView, viewError = cloneJson(target.view, "$.result.view")
if viewError then return failure({ viewError }) end
return success({
action = actionName,
applied = applied,
stale = stale,
state = returnState,
view = returnView,
})
end
local function validateTransitionResult(report, previousState, moduleAction)
if type(report) ~= "table"
or type(report.state) ~= "table"
or type(report.applied) ~= "boolean"
or type(report.stale) ~= "boolean" then
return nil, {
makeError(
"invalid_transition_result",
"$.runtime.gameSetup." .. tostring(moduleAction),
"설정 전이 결과에 state/applied/stale가 올바르게 포함되지 않았습니다."
),
}
end
if report.stale == true and report.applied ~= false then
return nil, {
makeError(
"invalid_stale_result",
"$.runtime.gameSetup." .. tostring(moduleAction),
"stale 설정 전이는 적용 상태일 수 없습니다."
),
}
end
if report.stale == true and not deepEqual(report.state, previousState) then
return nil, {
makeError(
"stale_state_changed",
"$.runtime.gameSetup." .. tostring(moduleAction) .. ".state",
"stale 설정 전이가 권위 상태를 변경했습니다."
),
}
end
return report, nil
end
local function validateRunTransitionResult(report, previousState, moduleAction)
if type(report) ~= "table"
or type(report.state) ~= "table"
or type(report.applied) ~= "boolean"
or type(report.stale) ~= "boolean" then
return nil, {
makeError(
"invalid_transition_result",
"$.runtime.runProgression." .. tostring(moduleAction),
"진행 전이 결과에 state/applied/stale가 올바르게 포함되지 않았습니다."
),
}
end
if report.stale == true and report.applied ~= false then
return nil, {
makeError(
"invalid_stale_result",
"$.runtime.runProgression." .. tostring(moduleAction),
"stale 진행 전이는 적용 상태일 수 없습니다."
),
}
end
if report.stale == true
and (type(previousState) ~= "table" or not deepEqual(report.state, previousState)) then
return nil, {
makeError(
"stale_state_changed",
"$.runtime.runProgression." .. tostring(moduleAction) .. ".state",
"stale 진행 전이가 권위 상태를 변경했습니다."
),
}
end
return report, nil
end
local function advanceDeckComplete(state, staticData)
if state.phase ~= "deckComplete" then
return state, false, nil
end
local advanced, advanceErrors = callModule(
"gameSetup",
"beginCharacterSelect",
state,
staticData
)
if advanceErrors then return nil, false, advanceErrors end
local checked, checkedErrors = validateTransitionResult(
advanced,
state,
"beginCharacterSelect"
)
if checkedErrors then return nil, false, checkedErrors end
if checked.applied ~= true
or checked.stale ~= false
or checked.state.phase ~= "characterSelect" then
return nil, false, {
makeError(
"invalid_character_select_transition",
"$.runtime.gameSetup.beginCharacterSelect",
"deckComplete는 적용된 characterSelect 상태로 정확히 한 번 전환되어야 합니다."
),
}
end
return checked.state, true, nil
end
local function handoffBattle(
state,
writeAuthority,
actionName,
applied,
stale,
staticData,
expectedAuthority,
expectMissing
)
local target, targetErrors = buildTarget(state, staticData)
if targetErrors then return failure(targetErrors) end
if target.state.phase ~= "battleReady" then
return failure({
makeError("setup_not_battle_ready", "$.state.phase", "battleReady 설정만 전투로 인계할 수 있습니다."),
})
end
local beginErrors = beginPublish(
writeAuthority,
expectedAuthority,
expectMissing
)
if beginErrors then return beginErrors end
if writeAuthority then
local authorityErrors = writeAuthorityVerified(
target.state,
expectedAuthority,
expectMissing
)
if authorityErrors then return failure(authorityErrors) end
end
-- 저장된 battleReady 복구에서 UI chatVar만 사라졌을 수도 있으므로
-- 전투 body를 게시하기 전에 shell을 항상 보장한다.
local shellErrors = ensureUiShell()
if shellErrors then return failure(shellErrors) end
local battle, battleErrors = callModule(
"battleController",
"_startFromCanonicalSetup",
target.state,
permitCanonicalOperation
)
if battleErrors then return failure(battleErrors) end
if type(battle.applied) ~= "boolean"
or type(battle.reused) ~= "boolean"
or type(battle.recovered) ~= "boolean"
or battle.applied == battle.reused
or battle.battleId ~= target.state.battleSpec.battleId
or battle.setupId ~= target.state.setupId
or not isSafeInteger(battle.turnNumber, 1)
or type(battle.view) ~= "table" then
return failure({
makeError(
"invalid_battle_handoff_result",
"$.runtime.battleController.startFromSetup",
"전투 인계 결과가 setup identity와 필수 결과 계약을 만족하지 않습니다."
),
})
end
local readyErrors = writeChatVarStored(READY_NAME, "ready", "$.chatVar.gameSetupReady")
if readyErrors then return failure(readyErrors) end
local returnState, stateError = cloneJson(target.state, "$.result.state")
if stateError then return failure({ stateError }) end
local returnView, viewError = cloneJson(target.view, "$.result.view")
if viewError then return failure({ viewError }) end
local returnBattle, battleError = cloneJson(battle, "$.result.battle")
if battleError then return failure({ battleError }) end
local returnBattleView, battleViewError = cloneJson(battle.view, "$.result.battleView")
if battleViewError then return failure({ battleViewError }) end
return success({
action = actionName,
applied = applied,
stale = stale,
state = returnState,
view = returnView,
battle = returnBattle,
battleView = returnBattleView,
})
end
local function handoffRunBattle(
runState,
setupState,
writeAuthority,
actionName,
applied,
stale,
staticData,
expectedAuthority,
expectMissing
)
local target, targetErrors = buildRunTarget(runState, setupState, staticData)
if targetErrors then return failure(targetErrors) end
if target.state.phase ~= "battleReady" then
return failure({
makeError(
"run_not_battle_ready",
"$.state.runAuthority.phase",
"다음 상대 선택까지 끝난 battleReady 진행 상태만 전투로 인계할 수 있습니다."
),
})
end
local beginErrors = beginRunPublish(
writeAuthority,
expectedAuthority,
expectMissing
)
if beginErrors then return beginErrors end
if writeAuthority then
local authorityErrors = writeRunAuthorityVerified(
target.state,
expectedAuthority,
expectMissing
)
if authorityErrors then return failure(authorityErrors) end
end
local shellErrors = ensureUiShell()
if shellErrors then return failure(shellErrors) end
local battle, battleErrors = callModule(
"battleController",
"_startFromCanonicalRun",
target.state,
target.setupState,
permitCanonicalOperation
)
if battleErrors then return failure(battleErrors) end
local battleSpec = target.state.battleSpec
if type(battleSpec) ~= "table"
or type(battle.applied) ~= "boolean"
or type(battle.reused) ~= "boolean"
or type(battle.recovered) ~= "boolean"
or battle.applied == battle.reused
or battle.battleId ~= battleSpec.battleId
or battle.setupId ~= target.setupState.setupId
or not isSafeInteger(battle.turnNumber, 1)
or type(battle.view) ~= "table" then
return failure({
makeError(
"invalid_battle_handoff_result",
"$.runtime.battleController.startFromRun",
"다음 전투 인계 결과가 진행 상태 identity와 필수 결과 계약을 만족하지 않습니다."
),
})
end
local readyErrors = writeChatVarStored(READY_NAME, "ready", "$.chatVar.gameSetupReady")
if readyErrors then return failure(readyErrors) end
local returnState, stateError = cloneJson(target.state, "$.result.state")
if stateError then return failure({ stateError }) end
local returnView, viewError = cloneJson(target.view, "$.result.view")
if viewError then return failure({ viewError }) end
local returnBattle, battleError = cloneJson(battle, "$.result.battle")
if battleError then return failure({ battleError }) end
local returnBattleView, battleViewError = cloneJson(battle.view, "$.result.battleView")
if battleViewError then return failure({ battleViewError }) end
return success({
action = actionName,
applied = applied,
stale = stale,
state = returnState,
view = returnView,
battle = returnBattle,
battleView = returnBattleView,
})
end
local function settleProgression(setupState, currentRun, summary, staticData, actionName)
local settled, settleErrors = callModule(
"runProgression",
"settle",
currentRun,
setupState,
summary,
staticData
)
if settleErrors then return failure(settleErrors) end
local checked, checkedErrors = validateRunTransitionResult(
settled,
currentRun,
"settle"
)
if checkedErrors then return failure(checkedErrors) end
return publishRunState(
checked.state,
setupState,
checked.applied == true,
actionName,
checked.applied,
checked.stale,
staticData,
currentRun,
currentRun == nil
)
end
local function inspectTerminalBattle()
local inspected, inspectErrors = callModule(
"battleController",
"getTerminalSummary"
)
if inspectErrors then return nil, inspectErrors end
if type(inspected.terminal) ~= "boolean" then
return nil, {
makeError(
"invalid_terminal_inspection",
"$.runtime.battleController.getTerminalSummary",
"전투 종료 점검 결과에 terminal 불리언이 없습니다."
),
}
end
if type(inspected.settlementAvailable) ~= "boolean" then
return nil, {
makeError(
"invalid_terminal_inspection",
"$.runtime.battleController.getTerminalSummary.settlementAvailable",
"전투 종료 점검 결과에 settlementAvailable 불리언이 없습니다."
),
}
end
if inspected.terminal == true
and inspected.settlementAvailable == true
and (type(inspected.summary) ~= "table" or getmetatable(inspected.summary) ~= nil) then
return nil, {
makeError(
"missing_terminal_summary",
"$.runtime.battleController.getTerminalSummary.summary",
"종료된 전투 점검 결과에 정산 요약이 없습니다."
),
}
end
if inspected.terminal == true
and (type(inspected.battleId) ~= "string"
or type(inspected.status) ~= "string") then
return nil, {
makeError(
"invalid_terminal_identity",
"$.runtime.battleController.getTerminalSummary",
"종료된 전투 점검 결과에 battleId와 status가 없습니다."
),
}
end
return inspected, nil
end
local function validateInvocation()
if action == "completeBattle" then
if argumentCount ~= 1 then
return nil, {
makeError(
"invalid_argument_count",
"$.arguments",
"completeBattle 작업에는 종료 요약 하나가 필요합니다."
),
}
end
if type(arguments[1]) ~= "table" or getmetatable(arguments[1]) ~= nil then
return nil, {
makeError(
"invalid_battle_summary",
"$.arguments[1]",
"종료 요약은 메타테이블 없는 객체여야 합니다."
),
}
end
local summaryCopy, summaryError = cloneJson(arguments[1], "$.arguments[1]")
if summaryError then return nil, { summaryError } end
return { summary = summaryCopy }, nil
end
if action == "start" then
if argumentCount ~= 0 then
return nil, {
makeError("unexpected_arguments", "$.arguments", "start 작업은 인자를 받지 않습니다."),
}
end
return {}, nil
end
if action == "choose" then
if argumentCount ~= 2 then
return nil, {
makeError("invalid_argument_count", "$.arguments", "choose 작업에는 cardId와 interactionToken이 필요합니다."),
}
end
local cardId = arguments[1]
local interactionToken = arguments[2]
if type(cardId) ~= "string" or type(interactionToken) ~= "string" then
return nil, {
makeError("invalid_choose_arguments", "$.arguments", "cardId와 interactionToken은 문자열이어야 합니다."),
}
end
return { cardId = cardId, interactionToken = interactionToken }, nil
end
if action == "chooseCharacter" then
if argumentCount ~= 2 then
return nil, {
makeError(
"invalid_argument_count",
"$.arguments",
"chooseCharacter 작업에는 characterId와 interactionToken이 필요합니다."
),
}
end
local characterId = arguments[1]
local interactionToken = arguments[2]
if type(characterId) ~= "string" or type(interactionToken) ~= "string" then
return nil, {
makeError(
"invalid_choose_character_arguments",
"$.arguments",
"characterId와 interactionToken은 문자열이어야 합니다."
),
}
end
return { characterId = characterId, interactionToken = interactionToken }, nil
end
return nil, {
makeError("unknown_action", "$.action", "지원하지 않는 게임 설정 컨트롤러 작업입니다: " .. tostring(action)),
}
end
local function execute()
local command, invocationErrors = validateInvocation()
if invocationErrors then return failure(invocationErrors) end
local staticData, staticErrors = loadStaticData()
if staticErrors then return failure(staticErrors) end
if action == "completeBattle" then
local setupState, setupErrors = readAuthority(true)
if setupErrors then return failure(setupErrors) end
local currentRun, runErrors = readRunAuthority(false)
if runErrors then return failure(runErrors) end
return settleProgression(
setupState,
currentRun,
command.summary,
staticData,
"completeBattle"
)
end
if action == "start" then
local currentRun, runReadErrors = readRunAuthority(false)
if runReadErrors then return failure(runReadErrors) end
if currentRun ~= nil then
local setupState, setupReadErrors = readAuthority(true)
if setupReadErrors then return failure(setupReadErrors) end
local validatedRun, validationErrors = callModule(
"runProgression",
"validate",
currentRun,
setupState,
staticData
)
if validationErrors then return failure(validationErrors) end
if type(validatedRun.state) ~= "table"
or not deepEqual(currentRun, validatedRun.state) then
return failure({
makeError(
"run_authority_validation_mismatch",
"$.state.runAuthority",
"저장된 진행 상태의 정규 검증 결과가 원본과 일치하지 않습니다."
),
})
end
currentRun = validatedRun.state
if currentRun.phase == "battleReady" then
local inspected, inspectErrors = inspectTerminalBattle()
if inspectErrors then return failure(inspectErrors) end
if inspected.terminal == true
and type(currentRun.battleSpec) == "table"
and inspected.battleId == currentRun.battleSpec.battleId then
if inspected.settlementAvailable ~= true then
return failure({
makeError(
"missing_terminal_settlement_receipt",
"$.state.battleRuntime",
"현재 종료 전투를 정산할 마지막 확정 턴 영수증이 없습니다."
),
})
end
return settleProgression(
setupState,
currentRun,
inspected.summary,
staticData,
"start"
)
end
return handoffRunBattle(
currentRun,
setupState,
false,
"start",
false,
false,
staticData,
currentRun,
false
)
end
return publishRunState(
currentRun,
setupState,
false,
"start",
false,
false,
staticData,
currentRun,
false
)
end
local stored, readErrors = readAuthority(false)
if readErrors then return failure(readErrors) end
local expectedAuthority = stored
local expectMissing = stored == nil
local state
local writeAuthority = false
local applied = false
local publishBegun = false
if stored ~= nil then
local validated, validationErrors = callModule("gameSetup", "validate", stored, staticData)
if validationErrors then return failure(validationErrors) end
if type(validated.state) ~= "table" or not deepEqual(stored, validated.state) then
return failure({
makeError("authority_validation_mismatch", "$.state.authority", "저장된 설정 상태의 정규 검증 결과가 원본과 일치하지 않습니다."),
})
end
state = validated.state
else
local beginErrors = beginPublish(true, expectedAuthority, expectMissing)
if beginErrors then return beginErrors end
publishBegun = true
local seed, seedErrors = generateSetupSeed()
if seedErrors then return failure(seedErrors) end
local setupId = "setup-" .. string.format("%.0f", seed)
local started, startErrors = callModule(
"gameSetup",
"start",
{ setupId = setupId, seed = seed },
staticData
)
if startErrors then return failure(startErrors) end
if type(started.state) ~= "table" then
return failure({
makeError("missing_started_state", "$.runtime.gameSetup.state", "새 게임 설정 상태가 반환되지 않았습니다."),
})
end
state = started.state
writeAuthority = true
applied = true
end
local advancedState, advanced, advanceErrors = advanceDeckComplete(state, staticData)
if advanceErrors then return failure(advanceErrors) end
state = advancedState
if advanced then
writeAuthority = true
applied = true
end
if state.phase == "battleReady" then
local inspected, inspectErrors = inspectTerminalBattle()
if inspectErrors then return failure(inspectErrors) end
if inspected.terminal == true
and type(state.battleSpec) == "table"
and inspected.battleId == state.battleSpec.battleId then
if inspected.settlementAvailable ~= true then
return failure({
makeError(
"missing_terminal_settlement_receipt",
"$.state.battleRuntime",
"현재 종료 전투를 정산할 마지막 확정 턴 영수증이 없습니다."
),
})
end
if writeAuthority then
local authorityErrors = writeAuthorityVerified(
state,
expectedAuthority,
expectMissing
)
if authorityErrors then return failure(authorityErrors) end
writeAuthority = false
end
return settleProgression(
state,
nil,
inspected.summary,
staticData,
"start"
)
end
return handoffBattle(
state,
writeAuthority,
"start",
applied,
false,
staticData,
expectedAuthority,
expectMissing
)
end
if not publishBegun then
local beginErrors = beginPublish(
writeAuthority,
expectedAuthority,
expectMissing
)
if beginErrors then return beginErrors end
end
return publishState(
state,
writeAuthority,
"start",
applied,
false,
staticData,
expectedAuthority,
expectMissing
)
end
local stored, readErrors = readAuthority(true)
if readErrors then return failure(readErrors) end
local currentRun, runReadErrors = readRunAuthority(false)
if runReadErrors then return failure(runReadErrors) end
if currentRun ~= nil then
local runAction = action == "chooseCharacter"
and "chooseCharacter"
or "claimReward"
local transitioned, transitionErrors = callModule(
"runProgression",
runAction,
currentRun,
stored,
command,
staticData
)
if transitionErrors then return failure(transitionErrors) end
local checked, checkedErrors = validateRunTransitionResult(
transitioned,
currentRun,
runAction
)
if checkedErrors then return failure(checkedErrors) end
local runState = checked.state
local writeRun = checked.applied == true
if runState.phase == "battleReady" then
return handoffRunBattle(
runState,
stored,
writeRun,
action,
checked.applied,
checked.stale,
staticData,
currentRun,
false
)
end
return publishRunState(
runState,
stored,
writeRun,
action,
checked.applied,
checked.stale,
staticData,
currentRun,
false
)
end
local moduleAction = action == "chooseCharacter" and "chooseCharacter" or "choose"
-- 저장소에서 읽은 authority를 gameSetup이 처음부터 재생 검증한 뒤
-- 현재 카드 또는 캐릭터 interaction token만 적용한다.
local transitioned, transitionErrors = callModule(
"gameSetup",
moduleAction,
stored,
command,
staticData
)
if transitionErrors then return failure(transitionErrors) end
local checked, checkedErrors = validateTransitionResult(
transitioned,
stored,
moduleAction
)
if checkedErrors then return failure(checkedErrors) end
local state = checked.state
local applied = checked.applied
local stale = checked.stale
local advancedState, advanced, advanceErrors = advanceDeckComplete(state, staticData)
if advanceErrors then return failure(advanceErrors) end
if advanced then
state = advancedState
applied = true
stale = false
end
local writeAuthority = applied == true
if state.phase == "battleReady" then
return handoffBattle(
state,
writeAuthority,
action,
applied,
stale,
staticData,
stored,
false
)
end
local beginErrors = beginPublish(writeAuthority, stored, false)
if beginErrors then return beginErrors end
return publishState(
state,
writeAuthority,
action,
applied,
stale,
staticData,
stored,
false
)
end
local callOk, result = pcall(execute)
if not callOk then
result = failure({
makeError("controller_error", "$", "게임 설정 컨트롤러 실행 중 오류가 발생했습니다: " .. tostring(result)),
})
elseif type(result) ~= "table" or (result.ok ~= true and result.ok ~= false) then
result = failure({
makeError("invalid_controller_result", "$", "게임 설정 컨트롤러가 올바른 결과를 반환하지 않았습니다."),
})
end
if result.ok ~= true then
local first = type(result.errors) == "table" and result.errors[1] or nil
local diagnosticErrors = {}
for index, item in ipairs(type(result.errors) == "table" and result.errors or {}) do
diagnosticErrors[index] = {
code = type(item) == "table" and tostring(item.code) or "invalid_error",
path = type(item) == "table" and tostring(item.path) or "$",
message = type(item) == "table" and tostring(item.message) or tostring(item),
}
end
emitDiagnostic(1, "request_failed", {
action = tostring(action),
errorCount = #diagnosticErrors,
errors = diagnosticErrors,
})
local message = "게임 설정을 처리하지 못했습니다."
if type(first) == "table" then
message = message
.. "\n[" .. tostring(first.code) .. "] "
.. tostring(first.message)
.. "\n경로: " .. tostring(first.path)
if #diagnosticErrors > 1 then
message = message .. "\n전체 오류 수: " .. tostring(#diagnosticErrors)
end
end
if type(alertError) == "function" then
pcall(alertError, triggerId, message)
end
end
return result
end)
#39gameSetupView.lua
Keys:
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local TOTAL_ROUNDS = 10
local OFFER_SIZE = 3
local CHARACTER_OFFER_SIZE = 3
local COPY_LIMIT = 2
local function addError(errors, code, path, message)
table.insert(errors, {
code = code,
path = path,
message = message,
})
end
local function failure(errors)
return {
ok = false,
schemaVersion = SCHEMA_VERSION,
errors = errors,
}
end
local function success(key, value)
local result = {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
}
if key ~= nil then
result[key] = value
end
return result
end
local function isFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function isInteger(value, minimum, maximum)
return isFinite(value)
and value % 1 == 0
and (minimum == nil or value >= minimum)
and (maximum == nil or value <= maximum)
end
local function isAsciiId(value)
return type(value) == "string"
and string.match(value, "^[a-z][a-z0-9_]*$") ~= nil
end
local function objectPath(path, key)
if type(key) == "string" and string.match(key, "^[A-Za-z_][A-Za-z0-9_]*$") then
return path .. "." .. key
end
return path .. "[" .. string.format("%q", tostring(key)) .. "]"
end
local function inspectTable(value, path, errors)
if type(value) ~= "table" then
addError(errors, "expected_table", path, "테이블이어야 합니다.")
return nil
end
local numericCount = 0
local maximum = 0
local hasNumeric = false
local hasString = false
local stringKeys = {}
for key in pairs(value) do
if type(key) == "number" then
hasNumeric = true
numericCount = numericCount + 1
if not isInteger(key, 1) then
addError(errors, "invalid_array_index", path, "배열 인덱스는 1 이상의 정수여야 합니다.")
return nil
end
if key > maximum then
maximum = key
end
elseif type(key) == "string" then
hasString = true
table.insert(stringKeys, key)
else
addError(errors, "invalid_object_key", path, "객체 키는 문자열이어야 합니다.")
return nil
end
end
if hasNumeric and hasString then
addError(errors, "mixed_table", path, "숫자 인덱스와 문자열 키를 함께 사용할 수 없습니다.")
return nil
end
if hasNumeric then
if numericCount ~= maximum then
addError(errors, "sparse_array", path, "배열 인덱스는 1부터 빈틈없이 이어져야 합니다.")
return nil
end
return "array", maximum
end
if hasString then
table.sort(stringKeys)
return "object", stringKeys
end
-- Lua의 빈 테이블은 JSON 배열로 취급한다. View에서 빈 객체는 없다.
return "array", 0
end
local function validateJsonSafe(value, path, errors, active)
local valueType = type(value)
if valueType == "string" or valueType == "boolean" then
return
end
if valueType == "number" then
if not isFinite(value) then
addError(errors, "non_finite_number", path, "NaN과 무한대는 View에 넣을 수 없습니다.")
end
return
end
if valueType ~= "table" then
addError(errors, "unsupported_type", path, "View에 넣을 수 없는 자료형입니다: " .. valueType)
return
end
if getmetatable(value) ~= nil then
addError(errors, "metatable_not_allowed", path, "View에는 메타테이블을 사용할 수 없습니다.")
return
end
active = active or {}
if active[value] then
addError(errors, "circular_reference", path, "순환 참조가 있는 View는 허용하지 않습니다.")
return
end
active[value] = true
local kind, shape = inspectTable(value, path, errors)
if kind == "array" then
for index = 1, shape do
validateJsonSafe(value[index], path .. "[" .. index .. "]", errors, active)
end
elseif kind == "object" then
for _, key in ipairs(shape) do
validateJsonSafe(value[key], objectPath(path, key), errors, active)
end
end
active[value] = nil
end
local function checkAllowedKeys(value, allowed, path, errors)
if type(value) ~= "table" then
return
end
for key in pairs(value) do
if type(key) ~= "string" or not allowed[key] then
addError(errors, "unknown_field", objectPath(path, key), "gameSetupView에 허용되지 않은 필드입니다.")
end
end
end
local function getArrayLength(value, path, errors)
local kind, length = inspectTable(value, path, errors)
if kind ~= "array" then
if kind ~= nil then
addError(errors, "expected_array", path, "연속 배열이어야 합니다.")
end
return nil
end
return length
end
local function normalizeStaticData(staticData)
if type(staticData) == "table" and type(staticData.data) == "table" then
return staticData.data
end
return staticData
end
local function appendNestedErrors(target, prefix, report)
if type(report) ~= "table" or type(report.errors) ~= "table" then
addError(target, "validation_failed", prefix, "하위 검증 결과를 읽을 수 없습니다.")
return
end
for _, item in ipairs(report.errors) do
local suffix = tostring(type(item) == "table" and item.path or "$.")
if string.sub(suffix, 1, 1) == "$" then
suffix = string.sub(suffix, 2)
end
addError(
target,
tostring(type(item) == "table" and item.code or "validation_failed"),
prefix .. suffix,
tostring(type(item) == "table" and item.message or "하위 검증에 실패했습니다.")
)
end
if #report.errors == 0 then
addError(target, "validation_failed", prefix, "하위 검증이 실패했지만 오류 내용이 없습니다.")
end
end
local function callRuntime(moduleName, moduleAction, ...)
if type(runScript) ~= "function" then
return nil, {
code = "runtime_unavailable",
path = "$.runtime." .. moduleName,
message = "스크립트 실행기를 찾을 수 없습니다.",
}
end
local ok, report = pcall(runScript, triggerId, moduleName, moduleAction, ...)
if not ok then
return nil, {
code = "runtime_call_error",
path = "$.runtime." .. moduleName,
message = moduleName .. "." .. moduleAction .. " 실행에 실패했습니다: " .. tostring(report),
}
end
if type(report) ~= "table" then
return nil, {
code = "invalid_runtime_result",
path = "$.runtime." .. moduleName,
message = "하위 모듈 결과가 테이블이 아닙니다.",
}
end
return report, nil
end
local function buildOfferCard(slot, cardId, ownedCopies, data, errors, basePath)
local path = (basePath or "$.offer.cards") .. "[" .. slot .. "]"
local card = data.cards[cardId]
if type(card) ~= "table" or card.owner ~= "player" then
addError(errors, "missing_player_card", path .. ".cardId", "제안된 플레이어 카드를 찾을 수 없습니다: " .. tostring(cardId))
return nil
end
if card.id ~= cardId then
addError(errors, "card_identity_mismatch", path .. ".cardId", "제안 카드의 DB 키와 내부 ID가 일치하지 않습니다.")
return nil
end
local presentation, presentationError = callRuntime(
"viewBuilder",
"buildCardPresentation",
card,
data.registry,
path
)
if presentationError then
table.insert(errors, presentationError)
return nil
end
if presentation.ok ~= true or type(presentation.card) ~= "table" then
appendNestedErrors(errors, path, presentation)
return nil
end
if type(card.base) ~= "table" then
addError(errors, "missing_card_base", path, "카드 기본 수치를 찾을 수 없습니다.")
return nil
end
return {
slot = slot,
cardId = presentation.card.cardId,
name = presentation.card.name,
rarity = card.rarity,
draftStyle = card.draftStyle,
maxCopies = card.rarity == "legendary" and 1 or 2,
descriptionSegments = presentation.card.descriptionSegments,
ruleLines = presentation.card.ruleLines,
cardType = presentation.card.cardType,
roles = presentation.card.roles,
mechanisms = presentation.card.mechanisms,
terms = presentation.card.terms,
baseStealthCost = card.base.stealthCost,
baseResistanceDamage = card.base.resistanceDamage,
ownedCopies = ownedCopies,
}
end
local function buildAppearanceSummary(profile, path, errors)
if type(profile) ~= "table" or type(profile.appearance) ~= "table" then
addError(errors, "missing_public_appearance", path, "공개 외형 정보를 찾을 수 없습니다.")
return nil
end
local appearance = profile.appearance
local parts = {}
local function appendText(value, suffix)
if type(value) == "string" and value ~= "" then
parts[#parts + 1] = value .. (suffix or "")
end
end
local function appendNumber(value, suffix)
if isFinite(value) then
parts[#parts + 1] = tostring(value) .. suffix
end
end
appendText(appearance.hairColor, " 머리")
appendText(appearance.eyeColor, " 눈")
appendText(appearance.skin)
appendNumber(appearance.height, "cm")
appendNumber(appearance.weight, "kg")
appendText(appearance.threeSize, "")
appendText(appearance.style)
if #parts == 0 then
addError(errors, "empty_public_appearance", path, "표시할 수 있는 공개 외형 요약이 없습니다.")
return nil
end
return table.concat(parts, " · ")
end
local function buildCharacterOfferItem(slot, characterId, data, errors)
local path = "$.characterOffer.characters[" .. slot .. "]"
local character = data.characters[characterId]
if type(character) ~= "table" or character.id ~= characterId then
addError(errors, "missing_character", path .. ".characterId", "제안된 캐릭터를 찾을 수 없습니다: " .. tostring(characterId))
return nil
end
if type(character.name) ~= "string" or character.name == "" then
addError(errors, "invalid_character_name", path .. ".name", "캐릭터 이름이 필요합니다.")
return nil
end
local profile = character.publicProfile
if type(profile) ~= "table" then
addError(errors, "missing_public_profile", path, "캐릭터 공개 프로필을 찾을 수 없습니다.")
return nil
end
if not isInteger(profile.age, 1) then
addError(errors, "invalid_character_age", path .. ".age", "공개 나이는 1 이상의 정수여야 합니다.")
end
if type(profile.occupation) ~= "string" or profile.occupation == "" then
addError(errors, "invalid_character_occupation", path .. ".occupation", "공개 직업이 필요합니다.")
end
local appearanceSummary = buildAppearanceSummary(profile, path .. ".appearanceSummary", errors)
local battle = character.battle
if type(battle) ~= "table" then
addError(errors, "missing_character_battle", path, "캐릭터 전투 정보를 찾을 수 없습니다.")
return nil
end
local mood = type(data.registry.moods) == "table" and data.registry.moods[battle.startingMood] or nil
if type(mood) ~= "table"
or mood.id ~= battle.startingMood
or type(mood.label) ~= "string"
or mood.label == "" then
addError(errors, "missing_starting_mood", path .. ".startingMood", "공개 시작 무드를 찾을 수 없습니다.")
return nil
end
local traits = {}
if type(battle.traitIds) ~= "table" then
addError(errors, "invalid_character_traits", path .. ".traits", "캐릭터 특징 목록을 찾을 수 없습니다.")
else
for index, traitId in ipairs(battle.traitIds) do
local trait = data.traits[traitId]
local traitPath = path .. ".traits[" .. index .. "]"
if type(trait) ~= "table"
or trait.id ~= traitId
or trait.owner ~= "character"
or trait.visibility ~= "public"
or type(trait.name) ~= "string"
or trait.name == ""
or type(trait.description) ~= "string"
or trait.description == "" then
addError(errors, "invalid_public_trait", traitPath, "공개 캐릭터 특징을 표시할 수 없습니다.")
else
traits[#traits + 1] = {
id = trait.id,
name = trait.name,
description = trait.description,
}
end
end
end
return {
slot = slot,
characterId = character.id,
name = character.name,
age = profile.age,
occupation = profile.occupation,
appearanceSummary = appearanceSummary,
startingResistance = battle.startingResistance,
turnLimit = battle.turnLimit,
startingMood = {
id = mood.id,
label = mood.label,
},
baseDrawCount = battle.baseDrawCount,
maxHandSize = battle.maxHandSize,
traits = traits,
}
end
local function validateTagView(value, path, errors, expectedTagKind)
if type(value) ~= "table" then
addError(errors, "invalid_tag_view", path, "태그 View가 테이블이 아닙니다.")
return
end
checkAllowedKeys(value, {
kind = true,
id = true,
label = true,
tagKind = true,
tooltip = true,
}, path, errors)
if value.kind ~= "tag" then
addError(errors, "invalid_tag_kind", path .. ".kind", "태그 조각의 kind는 tag여야 합니다.")
end
if not isAsciiId(value.id) then
addError(errors, "invalid_tag_id", path .. ".id", "태그 ID가 올바르지 않습니다.")
end
if type(value.label) ~= "string" or value.label == "" then
addError(errors, "invalid_tag_label", path .. ".label", "태그 표시명이 필요합니다.")
end
if value.tagKind ~= "type" and value.tagKind ~= "role" and value.tagKind ~= "mechanism" and value.tagKind ~= "term" then
addError(errors, "invalid_tag_type", path .. ".tagKind", "tagKind가 올바르지 않습니다.")
elseif expectedTagKind ~= nil and value.tagKind ~= expectedTagKind then
addError(errors, "tag_role_mismatch", path .. ".tagKind", "이 위치의 태그 종류가 올바르지 않습니다.")
end
if type(value.tooltip) ~= "string" or value.tooltip == "" then
addError(errors, "invalid_tag_tooltip", path .. ".tooltip", "태그 툴팁이 필요합니다.")
end
end
local function validateSegments(value, path, errors)
local length = getArrayLength(value, path, errors)
if length == nil then
return
end
for index = 1, length do
local segment = value[index]
local segmentPath = path .. "[" .. index .. "]"
if type(segment) ~= "table" then
addError(errors, "invalid_segment", segmentPath, "문장 조각이 테이블이 아닙니다.")
elseif segment.kind == "text" then
checkAllowedKeys(segment, { kind = true, value = true }, segmentPath, errors)
if type(segment.value) ~= "string" or segment.value == "" then
addError(errors, "invalid_text_segment", segmentPath .. ".value", "빈 텍스트 조각은 허용하지 않습니다.")
end
elseif segment.kind == "tag" then
validateTagView(segment, segmentPath, errors)
else
addError(errors, "invalid_segment_kind", segmentPath .. ".kind", "알 수 없는 문장 조각입니다.")
end
end
end
local function validateRuleLines(value, path, errors)
local length = getArrayLength(value, path, errors)
if length == nil then
return
end
if length < 1 then
addError(errors, "empty_rule_lines", path, "카드 규칙은 한 줄 이상이어야 합니다.")
end
for index = 1, length do
local line = value[index]
local linePath = path .. "[" .. index .. "]"
if type(line) ~= "table" then
addError(errors, "invalid_rule_line", linePath, "규칙 줄이 테이블이 아닙니다.")
else
checkAllowedKeys(line, { segments = true }, linePath, errors)
validateSegments(line.segments, linePath .. ".segments", errors)
end
end
end
local function validateMechanisms(value, path, errors)
local length = getArrayLength(value, path, errors)
if length == nil then
return
end
local seen = {}
for index = 1, length do
local tag = value[index]
validateTagView(tag, path .. "[" .. index .. "]", errors, "mechanism")
if type(tag) == "table" and type(tag.id) == "string" then
if seen[tag.id] then
addError(errors, "duplicate_mechanism", path .. "[" .. index .. "].id", "메커니즘 태그가 중복되었습니다.")
end
seen[tag.id] = true
end
end
end
local function validateTerms(value, path, errors)
local length = getArrayLength(value, path, errors)
if length == nil then return end
local seen = {}
for index = 1, length do
local tag = value[index]
validateTagView(tag, path .. "[" .. index .. "]", errors, "term")
if type(tag) == "table" and type(tag.id) == "string" then
if seen[tag.id] then
addError(errors, "duplicate_term", path .. "[" .. index .. "].id", "규칙 용어가 중복되었습니다.")
end
seen[tag.id] = true
end
end
end
local function validateOfferCard(
card,
path,
expectedSlot,
deckCopies,
seenCards,
errors,
allowFullCopies
)
if type(card) ~= "table" then
addError(errors, "invalid_offer_card", path, "제안 카드가 테이블이 아닙니다.")
return
end
checkAllowedKeys(card, {
slot = true,
cardId = true,
name = true,
rarity = true,
draftStyle = true,
maxCopies = true,
descriptionSegments = true,
ruleLines = true,
cardType = true,
roles = true,
mechanisms = true,
terms = true,
baseStealthCost = true,
baseResistanceDamage = true,
ownedCopies = true,
copies = true,
}, path, errors)
if card.slot ~= expectedSlot then
addError(errors, "invalid_offer_slot", path .. ".slot", "제안 카드 슬롯은 배열 순서와 같아야 합니다.")
end
if not isAsciiId(card.cardId) then
addError(errors, "invalid_card_id", path .. ".cardId", "카드 ID가 올바르지 않습니다.")
elseif seenCards[card.cardId] then
addError(errors, "duplicate_offer_card", path .. ".cardId", "같은 카드가 한 제안에 중복되었습니다.")
else
seenCards[card.cardId] = true
end
if type(card.name) ~= "string" or card.name == "" then
addError(errors, "invalid_card_name", path .. ".name", "카드 이름이 필요합니다.")
end
if card.rarity ~= "common" and card.rarity ~= "rare" and card.rarity ~= "legendary" then
addError(errors, "invalid_card_rarity", path .. ".rarity", "카드 희귀도는 common, rare 또는 legendary여야 합니다.")
end
if card.draftStyle ~= "predator"
and card.draftStyle ~= "harmonizer"
and card.draftStyle ~= "glutton"
and card.draftStyle ~= "deceiver" then
addError(errors, "invalid_draft_style", path .. ".draftStyle", "카드 드래프트 스타일이 올바르지 않습니다.")
end
local expectedMaxCopies = card.rarity == "legendary" and 1 or 2
if card.maxCopies ~= expectedMaxCopies then
addError(errors, "invalid_max_copies", path .. ".maxCopies", "희귀도에 따른 카드 보유 제한이 올바르지 않습니다.")
end
validateSegments(card.descriptionSegments, path .. ".descriptionSegments", errors)
validateRuleLines(card.ruleLines, path .. ".ruleLines", errors)
validateTagView(card.cardType, path .. ".cardType", errors, "type")
local roleCount = getArrayLength(card.roles, path .. ".roles", errors)
if roleCount ~= nil then
if roleCount < 1 or roleCount > 2 then
addError(errors, "invalid_card_roles", path .. ".roles", "플레이어 카드는 역할 태그를 하나 또는 둘 가져야 합니다.")
end
for index = 1, roleCount do
validateTagView(card.roles[index], path .. ".roles[" .. index .. "]", errors, "role")
end
end
validateMechanisms(card.mechanisms, path .. ".mechanisms", errors)
validateTerms(card.terms, path .. ".terms", errors)
if not isFinite(card.baseStealthCost) or card.baseStealthCost < 0 then
addError(errors, "invalid_stealth_cost", path .. ".baseStealthCost", "기본 은폐 비용은 0 이상의 유한한 숫자여야 합니다.")
end
if not isFinite(card.baseResistanceDamage) or card.baseResistanceDamage < 0 then
addError(errors, "invalid_resistance_damage", path .. ".baseResistanceDamage", "기본 저항 피해는 0 이상의 유한한 숫자여야 합니다.")
end
local ownedMaximum = allowFullCopies and expectedMaxCopies or expectedMaxCopies - 1
if not isInteger(card.ownedCopies, allowFullCopies and 1 or 0, ownedMaximum) then
addError(errors, "invalid_owned_copies", path .. ".ownedCopies", "카드 보유 수가 카드별 제한 범위를 벗어났습니다.")
elseif isAsciiId(card.cardId) and card.ownedCopies ~= (deckCopies[card.cardId] or 0) then
addError(errors, "owned_copies_mismatch", path .. ".ownedCopies", "카드 보유 수가 덱 요약과 다릅니다.")
end
if allowFullCopies then
if card.copies ~= card.ownedCopies then
addError(errors, "deck_copies_mismatch", path .. ".copies", "덱 표시 장수가 카드 보유 수와 다릅니다.")
end
elseif card.copies ~= nil then
addError(errors, "unexpected_offer_copies", path .. ".copies", "제안 카드에는 덱 표시 장수를 둘 수 없습니다.")
end
end
local function validateCharacterTrait(trait, path, seenTraits, errors)
if type(trait) ~= "table" then
addError(errors, "invalid_character_trait", path, "캐릭터 특징이 테이블이 아닙니다.")
return
end
checkAllowedKeys(trait, {
id = true,
name = true,
description = true,
}, path, errors)
if not isAsciiId(trait.id) then
addError(errors, "invalid_trait_id", path .. ".id", "특징 ID가 올바르지 않습니다.")
elseif seenTraits[trait.id] then
addError(errors, "duplicate_trait", path .. ".id", "같은 특징을 중복 표시할 수 없습니다.")
else
seenTraits[trait.id] = true
end
if type(trait.name) ~= "string" or trait.name == "" then
addError(errors, "invalid_trait_name", path .. ".name", "특징 이름이 필요합니다.")
end
if type(trait.description) ~= "string" or trait.description == "" then
addError(errors, "invalid_trait_description", path .. ".description", "특징 설명이 필요합니다.")
end
end
local function validateCharacterOfferItem(character, path, expectedSlot, seenCharacters, errors)
if type(character) ~= "table" then
addError(errors, "invalid_character_offer", path, "캐릭터 제안이 테이블이 아닙니다.")
return
end
checkAllowedKeys(character, {
slot = true,
characterId = true,
name = true,
age = true,
occupation = true,
appearanceSummary = true,
startingResistance = true,
turnLimit = true,
startingMood = true,
baseDrawCount = true,
maxHandSize = true,
traits = true,
}, path, errors)
if character.slot ~= expectedSlot then
addError(errors, "invalid_character_slot", path .. ".slot", "캐릭터 슬롯은 배열 순서와 같아야 합니다.")
end
if not isAsciiId(character.characterId) then
addError(errors, "invalid_character_id", path .. ".characterId", "캐릭터 ID가 올바르지 않습니다.")
elseif seenCharacters[character.characterId] then
addError(errors, "duplicate_offer_character", path .. ".characterId", "같은 캐릭터가 한 제안에 중복되었습니다.")
else
seenCharacters[character.characterId] = true
end
if type(character.name) ~= "string" or character.name == "" then
addError(errors, "invalid_character_name", path .. ".name", "캐릭터 이름이 필요합니다.")
end
if not isInteger(character.age, 1) then
addError(errors, "invalid_character_age", path .. ".age", "캐릭터 나이는 1 이상의 정수여야 합니다.")
end
if type(character.occupation) ~= "string" or character.occupation == "" then
addError(errors, "invalid_character_occupation", path .. ".occupation", "캐릭터 직업이 필요합니다.")
end
if type(character.appearanceSummary) ~= "string" or character.appearanceSummary == "" then
addError(errors, "invalid_appearance_summary", path .. ".appearanceSummary", "공개 외형 요약이 필요합니다.")
end
if not isFinite(character.startingResistance) or character.startingResistance <= 0 then
addError(errors, "invalid_starting_resistance", path .. ".startingResistance", "시작 저항은 양수의 유한한 숫자여야 합니다.")
end
if not isInteger(character.turnLimit, 7, 12) then
addError(errors, "invalid_turn_limit", path .. ".turnLimit", "제한 턴은 7 이상 12 이하의 정수여야 합니다.")
end
if type(character.startingMood) ~= "table" then
addError(errors, "invalid_starting_mood", path .. ".startingMood", "시작 무드가 테이블이 아닙니다.")
else
checkAllowedKeys(character.startingMood, { id = true, label = true }, path .. ".startingMood", errors)
if not isAsciiId(character.startingMood.id) then
addError(errors, "invalid_mood_id", path .. ".startingMood.id", "시작 무드 ID가 올바르지 않습니다.")
end
if type(character.startingMood.label) ~= "string" or character.startingMood.label == "" then
addError(errors, "invalid_mood_label", path .. ".startingMood.label", "시작 무드 표시명이 필요합니다.")
end
end
if not isInteger(character.baseDrawCount, 1) then
addError(errors, "invalid_base_draw_count", path .. ".baseDrawCount", "기본 드로우 수는 1 이상의 정수여야 합니다.")
end
if not isInteger(character.maxHandSize, 1) then
addError(errors, "invalid_max_hand_size", path .. ".maxHandSize", "최대 손패는 1 이상의 정수여야 합니다.")
elseif isInteger(character.baseDrawCount, 1) and character.baseDrawCount > character.maxHandSize then
addError(errors, "draw_exceeds_hand_limit", path .. ".baseDrawCount", "기본 드로우 수는 최대 손패보다 클 수 없습니다.")
end
local traitCount = getArrayLength(character.traits, path .. ".traits", errors)
if traitCount ~= nil then
local seenTraits = {}
for index = 1, traitCount do
validateCharacterTrait(
character.traits[index],
path .. ".traits[" .. index .. "]",
seenTraits,
errors
)
end
end
end
local function validateGameSetupView(view)
local errors = {}
validateJsonSafe(view, "$", errors)
if #errors > 0 then
if type(view) ~= "table" then
addError(errors, "invalid_view_root", "$", "gameSetupView 최상위 값은 테이블이어야 합니다.")
end
return failure(errors)
end
if type(view) ~= "table" or getmetatable(view) ~= nil then
if type(view) ~= "table" then
addError(errors, "invalid_view_root", "$", "gameSetupView 최상위 값은 테이블이어야 합니다.")
end
return failure(errors)
end
checkAllowedKeys(view, {
schemaVersion = true,
kind = true,
phase = true,
locked = true,
progress = true,
deck = true,
offer = true,
characterOffer = true,
selectedCharacter = true,
}, "$", errors)
if view.schemaVersion ~= SCHEMA_VERSION then
addError(errors, "unsupported_schema", "$.schemaVersion", "지원하지 않는 gameSetupView 스키마입니다.")
end
if view.kind ~= "gameSetupView" then
addError(errors, "unexpected_kind", "$.kind", "View 종류가 gameSetupView가 아닙니다.")
end
if view.phase ~= "deckDraft"
and view.phase ~= "deckComplete"
and view.phase ~= "characterSelect"
and view.phase ~= "battleReady" then
addError(errors, "invalid_phase", "$.phase", "게임 준비 단계가 올바르지 않습니다.")
end
if type(view.locked) ~= "boolean" then
addError(errors, "invalid_locked", "$.locked", "locked는 불리언이어야 합니다.")
elseif (view.phase == "deckComplete" or view.phase == "battleReady") ~= view.locked then
addError(errors, "locked_phase_mismatch", "$.locked", "완료 단계와 잠금 상태가 일치하지 않습니다.")
end
local selectedCount = nil
if type(view.progress) ~= "table" then
addError(errors, "invalid_progress", "$.progress", "progress가 테이블이 아닙니다.")
else
checkAllowedKeys(view.progress, {
selectedCount = true,
totalRounds = true,
currentRound = true,
remainingRounds = true,
}, "$.progress", errors)
selectedCount = view.progress.selectedCount
if not isInteger(selectedCount, 0, TOTAL_ROUNDS) then
addError(errors, "invalid_selected_count", "$.progress.selectedCount", "선택 수가 올바르지 않습니다.")
end
if view.progress.totalRounds ~= TOTAL_ROUNDS then
addError(errors, "invalid_total_rounds", "$.progress.totalRounds", "초기 덱 드래프트는 10회여야 합니다.")
end
local expectedRound = view.phase ~= "deckDraft"
and TOTAL_ROUNDS
or (isInteger(selectedCount, 0, TOTAL_ROUNDS - 1) and selectedCount + 1 or nil)
if expectedRound == nil or view.progress.currentRound ~= expectedRound then
addError(errors, "invalid_current_round", "$.progress.currentRound", "현재 드래프트 회차가 올바르지 않습니다.")
end
local expectedRemaining = isInteger(selectedCount, 0, TOTAL_ROUNDS)
and TOTAL_ROUNDS - selectedCount
or nil
if expectedRemaining == nil or view.progress.remainingRounds ~= expectedRemaining then
addError(errors, "invalid_remaining_rounds", "$.progress.remainingRounds", "남은 드래프트 횟수가 올바르지 않습니다.")
end
if view.phase == "deckDraft" and selectedCount == TOTAL_ROUNDS then
addError(errors, "draft_count_mismatch", "$.progress.selectedCount", "진행 중인 드래프트는 아직 10장을 선택할 수 없습니다.")
elseif view.phase ~= "deckDraft" and selectedCount ~= TOTAL_ROUNDS then
addError(errors, "complete_count_mismatch", "$.progress.selectedCount", "캐릭터 선택 이후에는 초기 덱이 정확히 10장이어야 합니다.")
end
end
local deckCopies = {}
local seenDeckCards = {}
local deckSum = 0
if type(view.deck) ~= "table" then
addError(errors, "invalid_deck", "$.deck", "deck이 테이블이 아닙니다.")
else
checkAllowedKeys(view.deck, { count = true, limit = true, items = true }, "$.deck", errors)
if not isInteger(view.deck.count, 0, TOTAL_ROUNDS) then
addError(errors, "invalid_deck_count", "$.deck.count", "덱 카드 수가 올바르지 않습니다.")
elseif isInteger(selectedCount, 0, TOTAL_ROUNDS) and view.deck.count ~= selectedCount then
addError(errors, "deck_count_mismatch", "$.deck.count", "덱 카드 수와 선택 수가 다릅니다.")
end
if view.deck.limit ~= TOTAL_ROUNDS then
addError(errors, "invalid_deck_limit", "$.deck.limit", "초기 덱 한도는 10장이어야 합니다.")
end
local itemCount = getArrayLength(view.deck.items, "$.deck.items", errors)
if itemCount then
for index = 1, itemCount do
local item = view.deck.items[index]
local path = "$.deck.items[" .. index .. "]"
if type(item) == "table" and isAsciiId(item.cardId) then
deckCopies[item.cardId] = item.copies
end
validateOfferCard(
item,
path,
index,
deckCopies,
seenDeckCards,
errors,
true
)
if type(item) == "table" and isInteger(item.copies, 1, COPY_LIMIT) then
deckSum = deckSum + item.copies
end
end
end
if isInteger(view.deck.count, 0, TOTAL_ROUNDS) and deckSum ~= view.deck.count then
addError(errors, "deck_item_sum_mismatch", "$.deck.items", "덱 요약의 장수 합계가 덱 카드 수와 다릅니다.")
end
end
if view.phase == "deckDraft" then
if type(view.offer) ~= "table" then
addError(errors, "missing_offer", "$.offer", "진행 중인 드래프트에는 카드 제안이 필요합니다.")
else
checkAllowedKeys(view.offer, { interactionToken = true, cards = true }, "$.offer", errors)
if type(view.offer.interactionToken) ~= "string" or view.offer.interactionToken == "" then
addError(errors, "invalid_interaction_token", "$.offer.interactionToken", "상호작용 토큰이 필요합니다.")
end
local cardCount = getArrayLength(view.offer.cards, "$.offer.cards", errors)
if cardCount ~= nil then
if cardCount ~= OFFER_SIZE then
addError(errors, "invalid_offer_size", "$.offer.cards", "카드 제안은 정확히 3장이어야 합니다.")
end
local seenCards = {}
for index = 1, cardCount do
validateOfferCard(
view.offer.cards[index],
"$.offer.cards[" .. index .. "]",
index,
deckCopies,
seenCards,
errors
)
end
end
end
elseif view.offer ~= nil then
addError(errors, "unexpected_offer", "$.offer", "카드 드래프트 이후에는 카드 제안이 없어야 합니다.")
end
if view.phase == "characterSelect" then
if type(view.characterOffer) ~= "table" then
addError(errors, "missing_character_offer", "$.characterOffer", "캐릭터 선택 단계에는 세 명의 제안이 필요합니다.")
else
checkAllowedKeys(view.characterOffer, { interactionToken = true, characters = true }, "$.characterOffer", errors)
if type(view.characterOffer.interactionToken) ~= "string"
or view.characterOffer.interactionToken == "" then
addError(errors, "invalid_interaction_token", "$.characterOffer.interactionToken", "캐릭터 선택 상호작용 토큰이 필요합니다.")
end
local characterCount = getArrayLength(view.characterOffer.characters, "$.characterOffer.characters", errors)
if characterCount ~= nil then
if characterCount ~= CHARACTER_OFFER_SIZE then
addError(errors, "invalid_character_offer_size", "$.characterOffer.characters", "캐릭터 제안은 정확히 3명이어야 합니다.")
end
local seenCharacters = {}
for index = 1, characterCount do
validateCharacterOfferItem(
view.characterOffer.characters[index],
"$.characterOffer.characters[" .. index .. "]",
index,
seenCharacters,
errors
)
end
end
end
elseif view.characterOffer ~= nil then
addError(errors, "unexpected_character_offer", "$.characterOffer", "캐릭터 선택 단계 밖에는 캐릭터 제안이 없어야 합니다.")
end
if view.phase == "battleReady" then
if type(view.selectedCharacter) ~= "table" then
addError(errors, "missing_selected_character", "$.selectedCharacter", "전투 준비 상태에는 선택한 캐릭터가 필요합니다.")
else
checkAllowedKeys(view.selectedCharacter, { characterId = true, name = true }, "$.selectedCharacter", errors)
if not isAsciiId(view.selectedCharacter.characterId) then
addError(errors, "invalid_character_id", "$.selectedCharacter.characterId", "선택한 캐릭터 ID가 올바르지 않습니다.")
end
if type(view.selectedCharacter.name) ~= "string" or view.selectedCharacter.name == "" then
addError(errors, "invalid_character_name", "$.selectedCharacter.name", "선택한 캐릭터 이름이 필요합니다.")
end
end
elseif view.selectedCharacter ~= nil then
addError(errors, "unexpected_selected_character", "$.selectedCharacter", "전투 준비 전에는 선택 결과를 표시할 수 없습니다.")
end
if #errors > 0 then
return failure(errors)
end
return success("valid", true)
end
local function buildGameSetupView(state, staticData, canonicalInput)
local errors = {}
local canonicalState = state
if canonicalInput ~= true then
local authorityValidation, authorityCallError = callRuntime("gameSetup", "validate", state, staticData)
if authorityCallError then
table.insert(errors, authorityCallError)
return failure(errors)
end
if authorityValidation.ok ~= true then
appendNestedErrors(errors, "$.state", authorityValidation)
return failure(errors)
end
canonicalState = authorityValidation.state
if type(canonicalState) ~= "table" then
addError(errors, "invalid_authority_result", "$.state", "gameSetup.validate가 정규화된 권위 상태를 반환하지 않았습니다.")
return failure(errors)
end
elseif type(canonicalState) ~= "table" then
addError(errors, "invalid_canonical_authority", "$.state", "내부 canonical authority가 테이블이 아닙니다.")
return failure(errors)
end
local data = normalizeStaticData(staticData)
if type(data) ~= "table"
or type(data.cards) ~= "table"
or type(data.characters) ~= "table"
or type(data.traits) ~= "table"
or type(data.registry) ~= "table"
or type(data.registry.cardTypes) ~= "table"
or type(data.registry.roles) ~= "table"
or type(data.registry.mechanisms) ~= "table"
or type(data.registry.moods) ~= "table" then
addError(errors, "missing_static_data", "$.staticData", "gameSetupView 생성에는 검증된 카드·캐릭터·태그·무드 데이터가 필요합니다.")
return failure(errors)
end
local selectedCardIds = canonicalState.selectedCardIds
local copies = {}
local firstSeen = {}
for _, cardId in ipairs(selectedCardIds) do
if copies[cardId] == nil then
copies[cardId] = 0
table.insert(firstSeen, cardId)
end
copies[cardId] = copies[cardId] + 1
end
local deckItems = {}
for index, cardId in ipairs(firstSeen) do
local card = data.cards[cardId]
if type(card) ~= "table" or card.owner ~= "player" then
addError(errors, "missing_player_card", "$.state.selectedCardIds[" .. index .. "]", "선택한 플레이어 카드를 찾을 수 없습니다.")
elseif card.id ~= cardId then
addError(errors, "card_identity_mismatch", "$.state.selectedCardIds[" .. index .. "]", "선택 카드의 DB 키와 내부 ID가 일치하지 않습니다.")
else
local deckCard = buildOfferCard(
index,
cardId,
copies[cardId],
data,
errors,
"$.deck.items"
)
if deckCard then
deckCard.copies = deckCard.ownedCopies
table.insert(deckItems, deckCard)
end
end
end
local selectedCount = #selectedCardIds
local view = {
schemaVersion = SCHEMA_VERSION,
kind = "gameSetupView",
phase = canonicalState.phase,
locked = canonicalState.phase == "deckComplete" or canonicalState.phase == "battleReady",
progress = {
selectedCount = selectedCount,
totalRounds = TOTAL_ROUNDS,
currentRound = canonicalState.phase ~= "deckDraft" and TOTAL_ROUNDS or selectedCount + 1,
remainingRounds = TOTAL_ROUNDS - selectedCount,
},
deck = {
count = selectedCount,
limit = TOTAL_ROUNDS,
items = deckItems,
},
}
if canonicalState.phase == "deckDraft" then
local offerCards = {}
for slot, cardId in ipairs(canonicalState.offer.cardIds) do
local cardView = buildOfferCard(slot, cardId, copies[cardId] or 0, data, errors)
if cardView then
table.insert(offerCards, cardView)
end
end
view.offer = {
interactionToken = canonicalState.offer.interactionToken,
cards = offerCards,
}
elseif canonicalState.phase == "characterSelect" then
local characters = {}
for slot, characterId in ipairs(canonicalState.characterOffer.characterIds) do
local characterView = buildCharacterOfferItem(slot, characterId, data, errors)
if characterView then
characters[#characters + 1] = characterView
end
end
view.characterOffer = {
interactionToken = canonicalState.characterOffer.interactionToken,
characters = characters,
}
elseif canonicalState.phase == "battleReady" then
local selectedCharacter = data.characters[canonicalState.selectedCharacterId]
if type(selectedCharacter) ~= "table"
or selectedCharacter.id ~= canonicalState.selectedCharacterId
or type(selectedCharacter.name) ~= "string"
or selectedCharacter.name == "" then
addError(errors, "missing_selected_character", "$.state.selectedCharacterId", "선택한 캐릭터 공개 정보를 찾을 수 없습니다.")
else
view.selectedCharacter = {
characterId = selectedCharacter.id,
name = selectedCharacter.name,
}
end
end
if #errors > 0 then
return failure(errors)
end
local validation = validateGameSetupView(view)
if validation.ok ~= true then
return validation
end
return success("view", view)
end
local arguments = { ... }
if action == "build" then
return buildGameSetupView(arguments[1], arguments[2])
elseif action == "_buildCanonical" then
-- 버튼 dispatcher는 문자열 인자만 전달할 수 있다. 이 경로는
-- 동일 Lua transaction에서 authority를 이미 검증한 controller가
-- 함수 capability를 전달한 경우에만 열린다.
local permit = arguments[3]
local permitOk = false
if type(permit) == "function" then
local callOk, permitted = pcall(permit, "gameSetupViewCanonicalV1")
permitOk = callOk and permitted == true
end
if not permitOk then
local errors = {}
addError(errors, "internal_action_denied", "$.action", "내부 canonical View 작업에 접근할 수 없습니다.")
return failure(errors)
end
return buildGameSetupView(arguments[1], arguments[2], true)
elseif action == "validate" then
return validateGameSetupView(arguments[1])
end
local errors = {}
addError(errors, "unknown_action", "$", "지원하지 않는 gameSetupView 작업입니다: " .. tostring(action))
return failure(errors)
end)
#40hostCompat.lua
Keys:
(function()
local function requireHostFunction(name, value)
if type(value) ~= "function" then
error(name .. " host function is unavailable")
end
return value
end
local function install()
HostCompat = {
readState = function(triggerId, name)
return requireHostFunction("getState", getState)(triggerId, name)
end,
writeState = function(triggerId, name, value)
local writer = type(setStateChanged) == "function" and setStateChanged or setState
return requireHostFunction("setStateChanged/setState", writer)(triggerId, name, value)
end,
writeChatVar = function(triggerId, name, value)
local writer = type(setChatVarChanged) == "function" and setChatVarChanged or setChatVar
return requireHostFunction("setChatVarChanged/setChatVar", writer)(triggerId, name, value)
end,
recentChats = function(triggerId, count)
count = math.max(0, math.floor(tonumber(count) or 0))
if type(getRecentChats) == "function" then
return getRecentChats(triggerId, count)
end
local chat = requireHostFunction("getFullChat", getFullChat)(triggerId)
local recent = {}
local first = math.max(1, #chat - count + 1)
for index = first, #chat do
recent[#recent + 1] = chat[index]
end
return recent
end,
chatData = function(triggerId, index)
if type(getChatData) == "function" then
return getChatData(triggerId, index)
end
local message = requireHostFunction("getChat", getChat)(triggerId, index)
return type(message) == "table" and message.data or ""
end,
}
return true
end
return function(_, action)
if action == "install" then
return install()
end
error("unsupported hostCompat action: " .. tostring(action))
end
end)()
#41hostFlow.lua
Keys:
(function()
local function alertTurnFailure(triggerId, detail)
if type(alertError) == "function" then
pcall(
alertError,
triggerId,
"치명적인 오류로 턴을 진행할 수 없습니다.\n\n"
.. detail
.. "\n\n위 오류 내용을 복사하여 개발자에게 제보해 주세요."
)
end
end
local function controllerSucceeded(triggerId, label, report)
if type(report) ~= "table" then
local detail = label .. ": battleController가 결과를 반환하지 않았습니다."
debug(1, detail)
alertTurnFailure(triggerId, detail)
return false
end
if report.ok == true then
return true
end
local errors = type(report.errors) == "table" and report.errors or {}
if #errors == 0 then
local detail = label .. ": battleController가 상세 오류 없이 실패했습니다."
debug(1, detail)
alertTurnFailure(triggerId, detail)
return false
end
local details = {}
for _, item in ipairs(errors) do
local detail = nil
if type(item) == "table" then
detail = label
.. ": [" .. tostring(item.code or "error") .. "] "
.. tostring(item.message or "알 수 없는 오류")
.. " (" .. tostring(item.path or "$") .. ")"
else
detail = label .. ": " .. tostring(item)
end
debug(1, detail)
details[#details + 1] = detail
end
alertTurnFailure(triggerId, table.concat(details, "\n"))
return false
end
local UI_BODY_VAR = "🔯🔯🔯"
local UI_SHELL_VAR = "helltrainUiShellV1"
local UI_POPUP_VAR = "helltrainUiPopupV1"
local UI_INTERACTION_VAR = "helltrainBattleInteractionV1"
local UI_TARGET_INDEX_VAR = "helltrainUiTargetIndexV1"
local UI_READY_VAR = "gameSetupReady"
local APPROACH_RETRY_VAR = "helltrainApproachRetryV1"
local RUN_PROGRESSION_AUTHORITY_KEY = "runProgressionV1.authority"
local APPROACH_REQUEST_ATTEMPTS = 1
local UI_CONTAINER_OPEN = [[
]]
local UI_CONTAINER_EMPTY = UI_CONTAINER_OPEN .. "
"
local UI_INTERACTION_MARKER = ""
-- 리롤이 직전 턴 경계에서 멈추도록 marker 메시지를 숨겨서 유지한다.
local TURN_SUBMIT_MARKER = "@@HELLTRAIN_TURN_SUBMIT_V1@@"
local TURN_SUBMIT_HIDDEN_MARKUP = [[
]]
local SETUP_START_MARKUP = [[
BOARDING PROTOCOL
지옥철에 탑승하시겠습니까?
게임을 시작하면 초기 상태를 만들고, 덱을 구성하기 위한 카드 드래프트를 엽니다.
게임 시작
]]
local APPROACH_PROCESSING_MARKUP = [[
처리중...
{{approachCharacterName}}에게 접근하고 있습니다.
]]
local function readUiFragment(triggerId, name)
if type(getChatVar) ~= "function" then
return ""
end
local ok, value = pcall(getChatVar, triggerId, name)
return ok and type(value) == "string" and value ~= "null" and value or ""
end
local function parseUiTargetIndex(rawIndex)
local index = tonumber(rawIndex)
if index == nil or index % 1 ~= 0 or index < -1 then
return nil
end
return index
end
local function latestCharacterIndex(triggerId)
if type(getFullChat) ~= "function" then
error("getFullChat host function is unavailable")
end
local readOk, chat = pcall(getFullChat, triggerId)
if not readOk or type(chat) ~= "table" then
error("failed to read chat for UI target: " .. tostring(chat))
end
for index = #chat, 1, -1 do
if type(chat[index]) == "table" and chat[index].role == "char" then
return index - 1
end
end
return -1
end
local appendChatVerified
local function reloadGameUiAt(triggerId, index)
if type(reloadChat) == "function" then
local targetedOk, targetedError = pcall(reloadChat, triggerId, index)
if targetedOk then
return true
end
debug(2, "targeted UI reload failed: " .. tostring(targetedError))
end
if type(reloadDisplay) ~= "function" then
error("reloadChat/reloadDisplay host functions are unavailable")
end
reloadDisplay(triggerId)
return true
end
-- 초기 진입 전에는 first message(-1), 이후에는 UI가 붙은 캐릭터 메시지만 다시 그린다.
function refreshGameUi(triggerId)
local rawIndex = readUiFragment(triggerId, UI_TARGET_INDEX_VAR)
local index = parseUiTargetIndex(rawIndex)
if index == nil then
index = -1
if rawIndex ~= "" then
debug(2, "invalid UI target index; falling back to first message: " .. tostring(rawIndex))
end
end
return reloadGameUiAt(triggerId, index)
end
-- UI를 붙일 메시지를 바꾸고 이전/새 대상만 다시 그린다. nil이면 최신 char를 찾는다.
function syncGameUiTarget(triggerId, targetIndex)
if targetIndex == nil then
targetIndex = latestCharacterIndex(triggerId)
end
if type(targetIndex) ~= "number"
or targetIndex % 1 ~= 0
or targetIndex < -1 then
error("invalid UI target index: " .. tostring(targetIndex))
end
if type(HostCompat) ~= "table" or type(HostCompat.writeChatVar) ~= "function" then
error("chat variable write compatibility function is unavailable")
end
local rawPreviousIndex = readUiFragment(triggerId, UI_TARGET_INDEX_VAR)
local previousIndex = parseUiTargetIndex(rawPreviousIndex)
if previousIndex == nil then
previousIndex = -1
end
local encodedTargetIndex = tostring(targetIndex)
if rawPreviousIndex ~= encodedTargetIndex then
HostCompat.writeChatVar(triggerId, UI_TARGET_INDEX_VAR, encodedTargetIndex)
end
-- 새 대상을 먼저 저장해야 이전 메시지의 editDisplay가 UI를 제거한다.
if previousIndex ~= targetIndex and type(reloadChat) == "function" then
local retiredOk, retiredError = pcall(reloadChat, triggerId, previousIndex)
if not retiredOk then
debug(2, "previous UI target reload failed: " .. tostring(retiredError))
end
end
reloadGameUiAt(triggerId, targetIndex)
return targetIndex
end
local function writeUiFragment(triggerId, name, value)
if type(HostCompat) ~= "table" or type(HostCompat.writeChatVar) ~= "function" then
error("chat variable write compatibility function is unavailable")
end
HostCompat.writeChatVar(triggerId, name, value)
end
local function readApproachRetry(triggerId)
if type(getChatVar) ~= "function" then
error("getChatVar host function is unavailable")
end
local readOk, value = pcall(getChatVar, triggerId, APPROACH_RETRY_VAR)
if not readOk then
error("failed to read approach retry state: " .. tostring(value))
end
if value == nil or value == "" or value == "null" then
return nil, nil
end
if type(value) ~= "string" then
error("invalid approach retry state")
end
local separator = string.find(value, "|", 1, true)
local phase = separator and string.sub(value, 1, separator - 1) or nil
local characterId = separator and string.sub(value, separator + 1) or nil
if (phase ~= "pending" and phase ~= "generated")
or type(characterId) ~= "string"
or string.match(characterId, "^[a-z][a-z0-9_]*$") == nil then
error("invalid approach retry state")
end
return phase, characterId
end
local function writeApproachRetryVerified(triggerId, phase, characterId)
local value = ""
if phase ~= nil then
value = phase .. "|" .. characterId
end
writeUiFragment(triggerId, APPROACH_RETRY_VAR, value)
end
local function escapeApproachName(name)
return (name:gsub("&", "&"):gsub("<", "<"):gsub(">", ">"))
end
local function showApproachProcessing(triggerId, characterName)
local markup = APPROACH_PROCESSING_MARKUP:gsub("{{approachCharacterName}}", function()
return escapeApproachName(characterName)
end)
writeUiFragment(triggerId, UI_BODY_VAR, markup)
writeUiFragment(triggerId, UI_POPUP_VAR, "")
writeUiFragment(triggerId, UI_READY_VAR, "ready")
refreshGameUi(triggerId)
end
local function selectedApproachCharacter(triggerId, report, characterId)
local selected = type(report) == "table"
and type(report.view) == "table"
and report.view.selectedCharacter
or nil
local name = type(selected) == "table" and selected.name or nil
local profile = selected
local staticOk, staticReport = pcall(
runScript,
triggerId,
"staticData",
"loadAll"
)
if staticOk
and type(staticReport) == "table"
and staticReport.ok == true
and type(staticReport.data) == "table"
and type(staticReport.data.characters) == "table"
and type(staticReport.data.characters[characterId]) == "table" then
profile = staticReport.data.characters[characterId]
if type(profile.name) == "string" and profile.name ~= "" then
name = profile.name
end
end
if type(name) ~= "string" or name == "" then
name = characterId
end
return name, profile
end
local function pastApproachEncounters(triggerId, report, characterId)
local runState = type(report) == "table"
and type(report.state) == "table"
and report.state.kind == "runProgressionV1"
and report.state
or nil
if runState == nil
and type(HostCompat) == "table"
and type(HostCompat.readState) == "function" then
local readOk, stored = pcall(HostCompat.readState, triggerId, RUN_PROGRESSION_AUTHORITY_KEY)
if readOk and type(stored) == "table" and stored.kind == "runProgressionV1" then
runState = stored
end
end
local encounters = {}
for sessionNumber, session in ipairs(
type(runState) == "table" and type(runState.sessions) == "table" and runState.sessions or {}
) do
if type(session) == "table" and session.characterId == characterId then
encounters[#encounters + 1] = {
sessionNumber = sessionNumber,
result = session.status,
reasonCode = session.reasonCode,
turnNumber = session.turnNumber,
turnLimit = session.turnLimit,
finalStealth = session.finalStealth,
finalResistance = session.finalResistance,
transit = session.transit,
}
end
end
return encounters
end
local function encodeApproachData(value, fallback)
if type(value) == "table" and type(json) == "table" and type(json.encode) == "function" then
local encodeOk, result = pcall(json.encode, value)
if encodeOk and type(result) == "string" then return result end
end
return fallback
end
local function buildApproachPrompt(characterName, profile, encounters)
local encodedProfile = encodeApproachData(profile, "{}")
local encodedEncounters = encodeApproachData(encounters, "[]")
return {
{
role = "system",
content = table.concat({
"당신은 성인용 한국어 다크 픽션 롤플레이의 장면 서술자다.",
"무한히 반복되는 지하철 안에서 플레이어가 선택한 성인 캐릭터에게 다가가는 순간을 2~4문단으로 묘사하라.",
"장면은 플레이어의 시야가 갑자기 검게 끊기는 순간으로 시작하라.",
"시야가 돌아오면 선택한 대상 캐릭터가 바로 눈앞에 나타나 있는 모습을 분명히 묘사하라.",
"암전과 대상의 등장은 이 접근 장면에서 한 번만 묘사하고, 이후 전투 턴에서 반복하지 마라.",
"경찰 연행이나 패배는 이 접근 장면에서 임의로 추론하거나 묘사하지 마라.",
"캐릭터의 성격과 배경을 지키고, 아직 카드·수치·전투 UI나 게임 규칙은 언급하지 마라.",
"플레이어가 입력하지 않은 추가 행동·대사·생각은 만들어내지 마라.",
"선택한 캐릭터의 자연스러운 행동과 반응, 객실의 분위기에 집중하라.",
"과거 조우 정보가 있으면 캐릭터는 플레이어를 분명히 알아보고, 이전 결과에 맞는 기억과 태도를 자연스럽게 드러내라. 정보가 없으면 초면으로 묘사하라.",
"과거 결과의 victory는 플레이어가 캐릭터의 저항을 무너뜨린 경우이고, defeat는 캐릭터가 플레이어를 물리친 경우다.",
"과거 조우 정보의 내부 ID와 수치는 직접 나열하지 말고 관계의 기억으로만 반영하라.",
"대상 캐릭터: " .. characterName,
"캐릭터 자료(JSON): " .. encodedProfile,
"과거 조우 정보(JSON): " .. encodedEncounters,
}, "\n"),
},
{
role = "user",
content = characterName .. "에게 접근한다.",
},
}
end
appendChatVerified = function(triggerId, role, content)
if type(getFullChat) ~= "function" or type(addChat) ~= "function" then
error("getFullChat/addChat host functions are unavailable")
end
local before = getFullChat(triggerId)
if type(before) ~= "table" then
error("failed to read chat before append")
end
addChat(triggerId, role, content)
local after = getFullChat(triggerId)
local appended = type(after) == "table" and after[#after] or nil
if type(after) ~= "table"
or #after ~= #before + 1
or type(appended) ~= "table"
or appended.role ~= role
or appended.data ~= content then
error("chat append was not persisted")
end
end
local function addRequestContext(triggerId, prompt)
local report = runScript(triggerId, "battleController", "getRequestContext")
if not controllerSucceeded(triggerId, "getRequestContext", report) then
error("현재 장면 정보를 구성하지 못했습니다.")
end
local marker = "[현재 주변 정보]"
local normalized = {}
for _, message in ipairs(prompt) do
if not (message.role == "system" and type(message.content) == "string"
and message.content:sub(1, #marker) == marker) then
normalized[#normalized + 1] = message
end
end
table.insert(normalized, math.max(1, #normalized), {
role = "system",
content = marker .. "\n" .. json.encode(report.context)
.. "\n현재 화면과 동일한 배경 정보입니다. scene.time은 시간대이며, 달력 날짜는 제공되지 않았습니다.",
})
return normalized
end
local function generateApproachScene(triggerId, report, characterId)
if type(LLM) ~= "function" then
return nil, "LLM 함수를 사용할 수 없습니다. Lua 스크립트의 low-level access를 활성화해야 합니다."
end
local characterName, profile = selectedApproachCharacter(triggerId, report, characterId)
local chat = getFullChat(triggerId)
local last = type(chat) == "table" and chat[#chat] or nil
if type(last) == "table"
and last.role == "char"
and type(last.data) == "string"
and last.data:match("%S") ~= nil
and last.time == 0 then
return last.data, nil
end
local encounters = pastApproachEncounters(triggerId, report, characterId)
local prompt = addRequestContext(triggerId, buildApproachPrompt(characterName, profile, encounters))
local lastError = "알 수 없는 LLM 오류"
for _ = 1, APPROACH_REQUEST_ATTEMPTS do
local requestOk, response = pcall(LLM, triggerId, prompt, false, { streaming = true })
if requestOk
and type(response) == "table"
and response.success == true
and type(response.result) == "string"
and response.result:match("%S") ~= nil then
appendChatVerified(triggerId, "char", response.result)
return response.result, nil
end
if requestOk and type(response) == "table" and response.result ~= nil then
lastError = tostring(response.result)
elseif not requestOk then
lastError = tostring(response)
end
end
return nil, lastError
end
local function removeApproachRetryFiller(triggerId)
if type(getFullChat) ~= "function" then
error("getFullChat host function is unavailable")
end
local chat = getFullChat(triggerId)
local last = type(chat) == "table" and chat[#chat] or nil
if type(last) ~= "table"
or last.role ~= "user"
or last.data ~= "says nothing" then
return
end
if type(removeChat) ~= "function" then
error("removeChat host function is unavailable")
end
removeChat(triggerId, #chat - 1)
local after = getFullChat(triggerId)
if type(after) ~= "table" or #after ~= #chat - 1 then
error("approach retry filler removal was not persisted")
end
end
local function finishApproachTransition(triggerId)
local report = runScript(triggerId, "init", "start")
if not controllerSucceeded(triggerId, "approach.init.start", report) then
return false
end
local targetOk, targetError = pcall(syncGameUiTarget, triggerId)
if not targetOk then
debug(1, "approach: Battle UI target 갱신 실패: " .. tostring(targetError))
return false
end
return true
end
local function resumeApproachTransition(triggerId, report, characterId, phase)
removeApproachRetryFiller(triggerId)
if phase == "pending" then
showApproachProcessing(triggerId, selectedApproachCharacter(triggerId, report, characterId))
local output, generationError = generateApproachScene(
triggerId,
report,
characterId
)
if output == nil then
return false, generationError
end
writeApproachRetryVerified(triggerId, "generated", characterId)
end
if not finishApproachTransition(triggerId) then
return false, "전투 화면으로 전환하지 못했습니다."
end
writeApproachRetryVerified(triggerId, nil, nil)
return true, nil
end
local function resumeApproachWithAlert(triggerId, report, characterId, phase)
local runOk, completed, detail = pcall(
resumeApproachTransition,
triggerId,
report,
characterId,
phase
)
if runOk and completed then
return true
end
detail = runOk and detail or completed
debug(1, "character approach: 생성 또는 전환 실패: " .. tostring(detail))
local uiOk, uiError = pcall(function()
local characterName = escapeApproachName(selectedApproachCharacter(triggerId, report, characterId))
writeUiFragment(triggerId, UI_BODY_VAR, [[
요청을 완료하지 못했습니다
]] .. characterName .. [[에게 접근하지 못했습니다. 아래 버튼을 눌러 다시 시도하세요.
다시 시도
]])
writeUiFragment(triggerId, UI_READY_VAR, "ready")
refreshGameUi(triggerId)
end)
if not uiOk then
debug(1, "character approach: 재시도 화면 표시 실패: " .. tostring(uiError))
end
if type(alertError) == "function" then
pcall(
alertError,
triggerId,
"요청을 완료하지 못했습니다. 다시 시도 버튼을 누르세요. 전송 버튼으로도 재시도할 수 있습니다.\n"
.. tostring(detail)
)
end
return false
end
-- target 메시지에만 최신 UI를 붙인다. 이전 target은 reloadChat될 때 원문으로 돌아간다.
local function handleEditDisplay(triggerId, data, meta)
if type(data) ~= "string" then
return data
end
if data == TURN_SUBMIT_MARKER then
return TURN_SUBMIT_HIDDEN_MARKUP
end
local index = type(meta) == "table" and meta.index or nil
if type(index) ~= "number" then
return data
end
local activeIndex = parseUiTargetIndex(readUiFragment(triggerId, UI_TARGET_INDEX_VAR)) or -1
if index ~= activeIndex then
return data
end
local rendered = SETUP_START_MARKUP
if readUiFragment(triggerId, UI_READY_VAR) == "ready" then
local body = readUiFragment(triggerId, UI_BODY_VAR)
local markerStart = string.find(body, UI_INTERACTION_MARKER, 1, true)
if markerStart ~= nil then
body = string.sub(body, 1, markerStart - 1)
.. readUiFragment(triggerId, UI_INTERACTION_VAR)
.. string.sub(body, markerStart + #UI_INTERACTION_MARKER)
end
rendered = readUiFragment(triggerId, UI_SHELL_VAR)
.. body
.. readUiFragment(triggerId, UI_POPUP_VAR)
end
if index == -1 then
local containerStart = string.find(data, UI_CONTAINER_EMPTY, 1, true)
if containerStart ~= nil then
local containerEnd = containerStart + #UI_CONTAINER_EMPTY - 1
return string.sub(data, 1, containerStart - 1)
.. UI_CONTAINER_OPEN .. rendered .. "</div>"
.. string.sub(data, containerEnd + 1)
end
return data
end
return data .. "\n" .. UI_CONTAINER_OPEN .. rendered .. "</div>"
local function isAllowedButtonRoute(script, arguments)
local actions = BUTTON_ACTIONS[script]
local action = arguments[1]
if type(actions) ~= "table" or actions[action] ~= true then
return false
end
if script == "hostFlow" then
return #arguments == 1
elseif script == "init" then
return (action == "start" and #arguments == 1)
or (action == "choose" and #arguments == 3)
or (action == "chooseCharacter" and #arguments == 3)
elseif script == "battleController" then
return (action == "selectCardEffect" and #arguments == 4)
or (action == "armSubmission" and #arguments == 2)
or ((action == "clickCard"
or action == "registerCard"
or action == "cancelCard"
or action == "skipAftermath") and #arguments == 3)
elseif action == "back" or action == "close" then
return #arguments == 1
end
return #arguments >= 3 and #arguments <= 5
end
local function handleButtonClick(triggerId, data)
--risu-btn 값을 "스크립트|인자1|인자2" 형식으로 해석
local parts = splitByDelimiter(data, "|")
local script = table.remove(parts, 1)
if not script or script == "" then
debug(1, "button dispatch error: empty script.")
return
end
if not isAllowedButtonRoute(script, parts) then
debug(1, "button dispatch error: disallowed route " .. tostring(script) .. ".")
return
end
debug(3, "Button route: " .. tostring(script) .. "|" .. tostring(parts[1]))
if script == "hostFlow" then
local readOk, phase, characterId = pcall(readApproachRetry, triggerId)
if not readOk then
alertTurnFailure(triggerId, "재시도 상태를 읽지 못했습니다: " .. tostring(phase))
elseif phase ~= nil then
resumeApproachWithAlert(triggerId, nil, characterId, phase)
end
return
end
local report = runScript(triggerId, script, table.unpack(parts))
if script == "init" and parts[1] == "start" then
if controllerSucceeded(triggerId, "onButtonClick.init.start", report) then
local targetOk, targetError = pcall(syncGameUiTarget, triggerId)
if not targetOk then
debug(1, "onButtonClick.init.start: UI target 갱신 실패: " .. tostring(targetError))
end
end
elseif script == "init"
and parts[1] == "chooseCharacter"
and type(report) == "table"
and report.ok == true
and report.applied == true then
local stateOk, stateError = pcall(
writeApproachRetryVerified,
triggerId,
"pending",
parts[2]
)
if not stateOk then
debug(1, "character approach: 재시도 상태 저장 실패: " .. tostring(stateError))
if type(alertError) == "function" then
pcall(alertError, triggerId, "접근 장면의 재시도 상태를 저장하지 못했습니다.")
end
return
end
resumeApproachWithAlert(
triggerId,
report,
parts[2],
"pending"
)
end
end
--정상 요청에 저장된 비공개 턴 사건과 사용자 장면 지시를 request에만 추가
local function handleEditRequest(triggerId, data)
local report = runScript(
triggerId,
"battleController",
"injectRequest",
data
)
if not controllerSucceeded(triggerId, "editRequest", report) then
return data
end
if type(report.promptArray) ~= "table" then
debug(1, "editRequest: 주입된 promptArray가 없습니다.")
return data
end
return addRequestContext(triggerId, report.promptArray)
end
--수동 전송의 턴 준비·실패 복구·commit-only 복구
local function handleStart(triggerId)
local retryReadOk, retryPhase, retryCharacterId = pcall(
readApproachRetry,
triggerId
)
if not retryReadOk then
debug(1, "onStart: 접근 장면 재시도 상태 읽기 실패: " .. tostring(retryPhase))
if type(alertError) == "function" then
pcall(alertError, triggerId, "접근 장면의 재시도 상태가 올바르지 않습니다.")
end
return false
end
if retryPhase ~= nil then
resumeApproachWithAlert(
triggerId,
nil,
retryCharacterId,
retryPhase
)
return false
end
local report = runScript(
triggerId,
"battleController",
"prepareGeneration"
)
if not controllerSucceeded(triggerId, "onStart", report) then
return false
end
if report.commitRecovered == true or report.uiTargetRequired == true then
local targetOk, targetError = pcall(syncGameUiTarget, triggerId, report.uiTargetIndex)
if not targetOk then
debug(1, "onStart: 복구 UI target 갱신 실패: " .. tostring(targetError))
return false
end
end
-- 관측된 출력을 보존하고 commit만 복구한 경우 새 HTTP 요청은 취소한다.
return report.generationReady == true
end
--완성 응답을 관측한 뒤 턴을 한 번만 확정
local function handleOutput(triggerId)
return runScript(
triggerId,
"battleController",
"commitOutput"
)
end
return function(triggerId, action, ...)
if action == "editDisplay" then
return handleEditDisplay(triggerId, ...)
elseif action == "buttonClick" then
return handleButtonClick(triggerId, ...)
elseif action == "editRequest" then
return handleEditRequest(triggerId, ...)
elseif action == "start" then
return handleStart(triggerId, ...)
elseif action == "output" then
return handleOutput(triggerId, ...)
end
error("unsupported hostFlow action: " .. tostring(action))
end
(function(triggerId, action, targetScript, ...)
local POPUP_VAR = "helltrainUiPopupV1"
local POPUP_STATE = "popupState"
local targetArgs = {...}
local ALLOWED_POPUP_HTML = {
["캐릭터 리스트"] = true,
["도감"] = true,
["덱 확인"] = true,
["플레이 가이드"] = true,
["설정"] = true,
}
local function emptyState()
return {
current = nil,
history = {}
}
end
local function getPopupState()
local state = HostCompat.readState(triggerId, POPUP_STATE)
if type(state) ~= "table" then
return emptyState()
end
if type(state.history) ~= "table" then
state.history = {}
end
return state
end
local function setPopupState(state)
HostCompat.writeState(triggerId, POPUP_STATE, state)
local ok, encoded = pcall(json.encode, state)
if ok then
debug(2, "popup state saved: " .. encoded)
end
end
local function clearPopupHtml()
HostCompat.writeChatVar(triggerId, POPUP_VAR, "")
end
local function makeEntry(script, args)
return {
script = script,
args = args or {}
}
end
local function isAllowedEntry(entry)
if type(entry) ~= "table" or type(entry.script) ~= "string" then
return false
end
local args = type(entry.args) == "table" and entry.args or {}
if entry.script == "uiRender" then
return (args[1] == "append" or args[1] == "popup")
and ALLOWED_POPUP_HTML[args[2]] == true
and args[3] == nil
end
if entry.script == "캐릭터 프로필" then
return args[1] == "유지영" and args[2] == nil
end
return false
end
local function argsEqual(left, right)
left = left or {}
right = right or {}
if #left ~= #right then
return false
end
for index, value in ipairs(left) do
if value ~= right[index] then
return false
end
end
return true
end
local function entriesEqual(left, right)
return type(left) == "table"
and type(right) == "table"
and left.script == right.script
and argsEqual(left.args, right.args)
end
local function clearPopupState()
setPopupState(emptyState())
end
local function closePopup()
clearPopupHtml()
clearPopupState()
end
local function renderPopup(entry)
if not entry or not entry.script or entry.script == "" then
debug(1, "popupManage error: empty target script.")
return false
end
if not isAllowedEntry(entry) then
debug(1, "popupManage error: disallowed popup target.")
return false
end
clearPopupHtml()
runScript(triggerId, entry.script, table.unpack(entry.args or {}))
return true
end
local actions = {}
actions.root = function()
local state = getPopupState()
local nextEntry = makeEntry(targetScript, targetArgs)
if entriesEqual(state.current, nextEntry) then
closePopup()
return
end
local nextState = {
current = nextEntry,
history = {}
}
if not renderPopup(nextEntry) then
return
end
setPopupState(nextState)
end
actions.push = function()
local state = getPopupState()
local nextEntry = makeEntry(targetScript, targetArgs)
if state.current and state.current.script then
table.insert(state.history, state.current)
end
state.current = nextEntry
if not renderPopup(nextEntry) then
return
end
setPopupState(state)
end
actions.replace = function()
local state = getPopupState()
local nextEntry = makeEntry(targetScript, targetArgs)
state.current = nextEntry
if not renderPopup(nextEntry) then
return
end
setPopupState(state)
end
actions.back = function()
local state = getPopupState()
local previous = table.remove(state.history)
if not previous then
closePopup()
return
end
state.current = previous
if not renderPopup(previous) then
return
end
setPopupState(state)
end
actions.close = function()
closePopup()
end
local handler = actions[action]
if not handler then
debug(1, "popupManage error: unknown action " .. tostring(action))
return
end
handler()
end)
#44runProgression.lua
Keys:
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local KIND = "runProgressionV1"
local MIN_DECK_SIZE = 10
local MAX_DECK_SIZE = 20
local RARITY_WEIGHTS = { common = 80, rare = 10, legendary = 1 }
local RARITY_ORDER = { "common", "rare", "legendary" }
local REWARD_OFFER_SIZE = 3
local CHARACTER_OFFER_SIZE = 3
local MAX_SESSIONS = 999
local BATTLE_SEED_MAX = 2147483646
local MAX_SAFE_INTEGER = 9007199254740991
local TRANSIT_ALGORITHM = "tokyo_subway_segment_v1"
local function makeError(code, path, message)
return {
code = code,
path = path,
message = message,
}
end
local function failure(errors)
return {
ok = false,
schemaVersion = SCHEMA_VERSION,
errors = errors,
}
end
local function success(state, applied, stale)
return {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
state = state,
applied = applied == true,
stale = stale == true,
}
end
local function isFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function isSafeInteger(value, minimum)
return isFinite(value)
and value % 1 == 0
and math.abs(value) <= MAX_SAFE_INTEGER
and (minimum == nil or value >= minimum)
end
local function isRuntimeId(value)
return type(value) == "string"
and string.match(value, "^[A-Za-z0-9][A-Za-z0-9_-]*$") ~= nil
end
local function isAsciiId(value)
return type(value) == "string"
and string.match(value, "^[a-z][a-z0-9_]*$") ~= nil
end
local function objectPath(path, key)
if type(key) == "string"
and string.match(key, "^[A-Za-z_][A-Za-z0-9_]*$") ~= nil then
return path .. "." .. key
end
return path .. "[" .. string.format("%q", tostring(key)) .. "]"
end
local function appendError(errors, code, path, message)
errors[#errors + 1] = makeError(code, path, message)
end
local function inspectJsonTable(value, path, errors)
if type(value) ~= "table" then
appendError(errors, "expected_table", path, "테이블이어야 합니다.")
return nil, nil
end
if getmetatable(value) ~= nil then
appendError(errors, "metatable_not_allowed", path, "JSON 값에는 메타테이블을 사용할 수 없습니다.")
return nil, nil
end
local numericCount = 0
local maximum = 0
local hasNumeric = false
local hasString = false
local stringKeys = {}
for key in pairs(value) do
if type(key) == "number" then
hasNumeric = true
numericCount = numericCount + 1
if not isSafeInteger(key, 1) then
appendError(errors, "invalid_array_index", path, "배열 인덱스는 1 이상의 연속 정수여야 합니다.")
return nil, nil
end
if key > maximum then
maximum = key
end
elseif type(key) == "string" then
hasString = true
stringKeys[#stringKeys + 1] = key
else
appendError(errors, "invalid_object_key", path, "JSON 객체 키는 문자열이어야 합니다.")
return nil, nil
end
end
if hasNumeric and hasString then
appendError(errors, "mixed_table", path, "배열 인덱스와 객체 키를 함께 사용할 수 없습니다.")
return nil, nil
end
if hasNumeric then
if numericCount ~= maximum then
appendError(errors, "sparse_array", path, "배열 인덱스는 1부터 빈틈없이 이어져야 합니다.")
return nil, nil
end
return "array", maximum
end
table.sort(stringKeys)
return "object", stringKeys
end
local function validateJson(value, path, errors, active)
local valueType = type(value)
if valueType == "string" or valueType == "boolean" or valueType == "nil" then
return
end
if valueType == "number" then
if not isFinite(value) then
appendError(errors, "non_finite_number", path, "유한하지 않은 숫자는 상태에 저장할 수 없습니다.")
end
return
end
if valueType ~= "table" then
appendError(
errors,
"unsupported_type",
path,
"상태에 저장할 수 없는 자료형입니다: " .. valueType
)
return
end
if getmetatable(value) ~= nil then
appendError(errors, "metatable_not_allowed", path, "상태 값에는 메타테이블을 사용할 수 없습니다.")
return
end
active = active or {}
if active[value] then
appendError(errors, "circular_reference", path, "순환 참조가 있는 상태는 사용할 수 없습니다.")
return
end
active[value] = true
local kind, shape = inspectJsonTable(value, path, errors)
if kind == "array" then
for index = 1, shape do
validateJson(value[index], path .. "[" .. index .. "]", errors, active)
end
elseif kind == "object" then
for _, key in ipairs(shape) do
validateJson(value[key], objectPath(path, key), errors, active)
end
end
active[value] = nil
end
local function cloneJson(value, path, active)
local valueType = type(value)
if valueType == "nil" or valueType == "string" or valueType == "boolean" then
return value, nil
end
if valueType == "number" then
if not isFinite(value) then
return nil, makeError("non_finite_number", path, "유한하지 않은 숫자는 상태에 저장할 수 없습니다.")
end
return value, nil
end
if valueType ~= "table" then
return nil, makeError(
"unsupported_type",
path,
"상태에 저장할 수 없는 자료형입니다: " .. valueType
)
end
if getmetatable(value) ~= nil then
return nil, makeError("metatable_not_allowed", path, "상태 값에는 메타테이블을 사용할 수 없습니다.")
end
active = active or {}
if active[value] then
return nil, makeError("circular_reference", path, "순환 참조가 있는 상태는 사용할 수 없습니다.")
end
active[value] = true
local shapeErrors = {}
local kind, shape = inspectJsonTable(value, path, shapeErrors)
if #shapeErrors > 0 then
active[value] = nil
return nil, shapeErrors[1]
end
local copy = {}
if kind == "array" then
for index = 1, shape do
local itemCopy, itemError = cloneJson(value[index], path .. "[" .. index .. "]", active)
if itemError then
active[value] = nil
return nil, itemError
end
copy[index] = itemCopy
end
else
for _, key in ipairs(shape) do
local itemCopy, itemError = cloneJson(value[key], objectPath(path, key), active)
if itemError then
active[value] = nil
return nil, itemError
end
copy[key] = itemCopy
end
end
active[value] = nil
return copy, nil
end
local function deepEqual(left, right, seen)
if type(left) ~= type(right) then
return false
end
if type(left) ~= "table" then
return left == right
end
if getmetatable(left) ~= nil or getmetatable(right) ~= nil then
return false
end
seen = seen or {}
if seen[left] ~= nil then
return seen[left] == right
end
seen[left] = right
for key, value in pairs(left) do
if not deepEqual(value, right[key], seen) then
seen[left] = nil
return false
end
end
for key in pairs(right) do
if left[key] == nil then
seen[left] = nil
return false
end
end
seen[left] = nil
return true
end
local function checkAllowedKeys(value, allowed, path, errors)
if type(value) ~= "table" or getmetatable(value) ~= nil then
return
end
for key in pairs(value) do
if type(key) ~= "string" or allowed[key] ~= true then
appendError(errors, "unknown_field", objectPath(path, key), "허용되지 않은 필드입니다.")
end
end
end
local function denseArrayLength(value, path, errors)
local kind, shape = inspectJsonTable(value, path, errors)
if kind == "object" and type(shape) == "table" and #shape == 0 then
return 0
end
if kind ~= "array" then
if kind ~= nil then
appendError(errors, "expected_array", path, "1부터 시작하는 연속 배열이어야 합니다.")
end
return nil
end
return shape
end
local function copyArray(value)
local copy = {}
for index, item in ipairs(value or {}) do
copy[index] = item
end
return copy
end
local function contains(value, target)
for _, item in ipairs(value or {}) do
if item == target then
return true
end
end
return false
end
local function normalizeStaticData(staticInput)
if type(staticInput) == "table"
and getmetatable(staticInput) == nil
and type(rawget(staticInput, "data")) == "table" then
return rawget(staticInput, "data")
end
return staticInput
end
local function appendNestedErrors(target, moduleName, report)
local nested = type(report) == "table" and report.errors or nil
if type(nested) ~= "table" or #nested == 0 then
target[#target + 1] = makeError(
"module_failed_without_errors",
"$.runtime." .. moduleName,
moduleName .. "이 오류 상세 없이 실패했습니다."
)
return
end
for index, item in ipairs(nested) do
if type(item) == "table" then
target[#target + 1] = makeError(
type(item.code) == "string" and item.code or "nested_error",
type(item.path) == "string" and item.path or ("$.runtime." .. moduleName),
type(item.message) == "string"
and item.message
or (moduleName .. " 오류 " .. index .. "에 설명이 없습니다.")
)
else
target[#target + 1] = makeError(
"invalid_nested_error",
"$.runtime." .. moduleName .. ".errors[" .. index .. "]",
"하위 모듈 오류 항목이 객체가 아닙니다."
)
end
end
end
local function callModule(moduleName, moduleAction, ...)
if type(runScript) ~= "function" then
return nil, {
makeError(
"runtime_unavailable",
"$.runtime." .. moduleName,
moduleName .. "을 호출할 runScript 실행기가 없습니다."
),
}
end
local ok, report = pcall(runScript, triggerId, moduleName, moduleAction, ...)
if not ok then
return nil, {
makeError(
"module_call_error",
"$.runtime." .. moduleName,
moduleName .. "." .. moduleAction .. " 호출 중 오류가 발생했습니다: " .. tostring(report)
),
}
end
if type(report) ~= "table" or getmetatable(report) ~= nil then
return nil, {
makeError(
"invalid_module_result",
"$.runtime." .. moduleName,
moduleName .. "." .. moduleAction .. "이 일반 테이블 결과를 반환하지 않았습니다."
),
}
end
if report.schemaVersion ~= SCHEMA_VERSION
or type(report.errors) ~= "table"
or (report.ok ~= true and report.ok ~= false) then
return nil, {
makeError(
"invalid_module_envelope",
"$.runtime." .. moduleName,
moduleName .. "." .. moduleAction .. " 결과 envelope가 올바르지 않습니다."
),
}
end
if report.ok ~= true then
local errors = {}
appendNestedErrors(errors, moduleName, report)
return nil, errors
end
if #report.errors ~= 0 then
return nil, {
makeError(
"success_with_errors",
"$.runtime." .. moduleName .. ".errors",
"성공한 하위 모듈 결과에 오류가 포함되어 있습니다."
),
}
end
return report, nil
end
local function buildPools(staticInput)
local staticData = normalizeStaticData(staticInput)
local errors = {}
if type(staticData) ~= "table" or getmetatable(staticData) ~= nil then
appendError(errors, "invalid_static_data", "$.staticData", "정적 데이터는 일반 테이블이어야 합니다.")
return nil, nil, nil, errors
end
local cards = rawget(staticData, "cards")
local characters = rawget(staticData, "characters")
if type(cards) ~= "table" or getmetatable(cards) ~= nil then
appendError(errors, "invalid_card_database", "$.staticData.cards", "플레이어 카드 풀을 만들 cards 맵이 필요합니다.")
end
if type(characters) ~= "table" or getmetatable(characters) ~= nil then
appendError(errors, "invalid_character_database", "$.staticData.characters", "대상 후보를 만들 characters 맵이 필요합니다.")
end
if #errors > 0 then
return nil, nil, nil, errors
end
local playerPool = {}
for cardId, card in pairs(cards) do
local path = objectPath("$.staticData.cards", cardId)
if type(cardId) ~= "string" then
appendError(errors, "invalid_card_key", "$.staticData.cards", "카드 맵 키는 문자열이어야 합니다.")
elseif type(card) ~= "table" or getmetatable(card) ~= nil then
appendError(errors, "invalid_card_record", path, "카드 레코드는 일반 테이블이어야 합니다.")
elseif card.owner == "player" then
if not isAsciiId(cardId) or card.id ~= cardId then
appendError(errors, "invalid_player_card", path, "플레이어 카드 키와 내부 ID가 올바르지 않습니다.")
elseif RARITY_WEIGHTS[card.rarity] == nil or not isAsciiId(card.draftStyle) then
appendError(errors, "invalid_player_card_draft_data", path, "플레이어 카드의 희귀도 또는 draftStyle이 올바르지 않습니다.")
else
playerPool[#playerPool + 1] = cardId
playerPool[cardId] = {
rarity = card.rarity,
draftStyle = card.draftStyle,
maxCopies = card.rarity == "legendary" and 1 or 2,
}
end
end
end
table.sort(playerPool)
local characterPool = {}
for characterId, character in pairs(characters) do
local path = objectPath("$.staticData.characters", characterId)
if not isAsciiId(characterId) then
appendError(errors, "invalid_character_id", path, "캐릭터 키는 lower_snake_case ASCII ID여야 합니다.")
elseif type(character) ~= "table"
or getmetatable(character) ~= nil
or character.id ~= characterId then
appendError(errors, "invalid_character_record", path, "캐릭터 키와 내부 ID가 올바르지 않습니다.")
else
characterPool[#characterPool + 1] = characterId
end
end
table.sort(characterPool)
if #playerPool == 0 then
appendError(errors, "empty_player_card_pool", "$.staticData.cards", "카드 보상 후보가 될 플레이어 카드가 없습니다.")
end
if #characterPool < CHARACTER_OFFER_SIZE then
appendError(
errors,
"insufficient_character_pool",
"$.staticData.characters",
"다음 대상 선택에는 서로 다른 캐릭터가 최소 3명 필요합니다."
)
end
if #errors > 0 then
return nil, nil, nil, errors
end
return staticData, playerPool, characterPool, nil
end
local function validateSetup(setupInput, staticInput)
local setupCopy, setupCopyError = cloneJson(setupInput, "$.gameSetup")
if setupCopyError then
return nil, nil, nil, nil, { setupCopyError }
end
local staticData, playerPool, characterPool, poolErrors = buildPools(staticInput)
if poolErrors then
return nil, nil, nil, nil, poolErrors
end
local validated, validationErrors = callModule(
"gameSetup",
"validate",
setupCopy,
staticInput
)
if validationErrors then
return nil, nil, nil, nil, validationErrors
end
if type(validated.state) ~= "table" or getmetatable(validated.state) ~= nil then
return nil, nil, nil, nil, {
makeError(
"missing_validated_setup",
"$.runtime.gameSetup.state",
"gameSetup.validate가 canonical 설정 상태를 반환하지 않았습니다."
),
}
end
if not deepEqual(setupCopy, validated.state) then
return nil, nil, nil, nil, {
makeError(
"setup_validation_mismatch",
"$.gameSetup",
"원본 설정 상태가 seed와 선택 이력으로 재생한 canonical 상태와 다릅니다."
),
}
end
if validated.state.kind ~= "gameSetupV1" or validated.state.phase ~= "battleReady" then
return nil, nil, nil, nil, {
makeError(
"setup_not_battle_ready",
"$.gameSetup.phase",
"runProgression에는 원본 gameSetupV1 battleReady 상태가 필요합니다."
),
}
end
return validated.state, staticData, playerPool, characterPool, nil
end
local function callNextIntegers(rng, ranges)
local report, callErrors = callModule(
"deterministicRng",
"nextIntegers",
rng,
ranges
)
if callErrors then
return nil, nil, callErrors
end
local errors = {}
local valueCount = denseArrayLength(report.value, "$.runtime.deterministicRng.value", errors)
if valueCount ~= #ranges then
appendError(
errors,
"invalid_rng_batch_size",
"$.runtime.deterministicRng.value",
"결정적 RNG 결과 개수가 요청 범위 개수와 다릅니다."
)
elseif valueCount ~= nil then
for index = 1, valueCount do
local value = report.value[index]
local range = ranges[index]
if not isSafeInteger(value, range.minimum) or value > range.maximum then
appendError(
errors,
"invalid_rng_batch_value",
"$.runtime.deterministicRng.value[" .. index .. "]",
"결정적 RNG 결과가 요청 범위를 벗어났습니다."
)
end
end
end
if type(report.rng) ~= "table"
or getmetatable(report.rng) ~= nil
or not isSafeInteger(report.rng.seed, 0)
or not isSafeInteger(report.rng.cursor, 0)
or report.rng.seed ~= rng.seed
or (#ranges > 0 and report.rng.cursor <= rng.cursor)
or (#ranges == 0 and report.rng.cursor ~= rng.cursor) then
appendError(
errors,
"invalid_rng_result",
"$.runtime.deterministicRng.rng",
"결정적 RNG가 올바른 다음 상태를 반환하지 않았습니다."
)
end
if #errors > 0 then
return nil, nil, errors
end
return copyArray(report.value), {
seed = report.rng.seed,
cursor = report.rng.cursor,
}, nil
end
local function pickWithoutReplacement(rng, candidates, count)
local remaining = copyArray(candidates)
local ranges = {}
for pick = 1, count do
ranges[pick] = {
minimum = 1,
maximum = #remaining - pick + 1,
}
end
local selectedIndices, nextRng, rngErrors = callNextIntegers(rng, ranges)
if rngErrors then
return nil, nil, rngErrors
end
local selected = {}
for pick = 1, count do
local selectedIndex = selectedIndices[pick]
selected[pick] = remaining[selectedIndex]
table.remove(remaining, selectedIndex)
end
return selected, nextRng, nil
end
local function hashCanonical(prefix, canonical)
local hashA = 0
local hashB = 0
for index = 1, #canonical do
local byte = string.byte(canonical, index)
hashA = (hashA * 131 + byte) % 2147483647
hashB = (hashB * 137 + byte) % 2147483629
end
return prefix
.. ":" .. tostring(#canonical)
.. ":" .. tostring(hashA)
.. ":" .. tostring(hashB)
end
local function appendCanonicalArray(parts, label, array)
parts[#parts + 1] = "|" .. label .. "=" .. tostring(#array) .. ":"
for _, value in ipairs(array) do
parts[#parts + 1] = tostring(#value)
parts[#parts + 1] = ":"
parts[#parts + 1] = value
parts[#parts + 1] = ";"
end
end
local function buildRewardToken(setupId, sessionNumber, rng, settlement, deck, kind, cardIds)
local parts = {
"setupId=", tostring(#setupId), ":", setupId,
"|session=", tostring(sessionNumber),
"|cursor=", tostring(rng.cursor),
"|battleId=", tostring(#settlement.battleId), ":", settlement.battleId,
"|turnId=", tostring(#settlement.turnId), ":", settlement.turnId,
"|kind=", kind,
}
appendCanonicalArray(parts, "deck", deck)
appendCanonicalArray(parts, "offer", cardIds or {})
return hashCanonical("run-progression-reward-v1", table.concat(parts))
end
local function buildCharacterToken(setupId, sessionNumber, rng, settlement, deck, characterIds)
local parts = {
"setupId=", tostring(#setupId), ":", setupId,
"|session=", tostring(sessionNumber),
"|cursor=", tostring(rng.cursor),
"|battleId=", tostring(#settlement.battleId), ":", settlement.battleId,
"|turnId=", tostring(#settlement.turnId), ":", settlement.turnId,
}
appendCanonicalArray(parts, "deck", deck)
appendCanonicalArray(parts, "characters", characterIds)
return hashCanonical("run-progression-character-v1", table.concat(parts))
end
local function countDeck(deck, playerPool, path)
local errors = {}
local length = denseArrayLength(deck, path, errors)
if length ~= nil and (length < MIN_DECK_SIZE or length > MAX_DECK_SIZE) then
appendError(
errors,
"invalid_deck_size",
path,
"런 덱은 10장 이상 20장 이하여야 합니다."
)
end
local allowed = {}
for _, cardId in ipairs(playerPool) do
allowed[cardId] = true
end
local counts = {}
if length ~= nil then
for index = 1, length do
local cardId = deck[index]
if not isAsciiId(cardId) or allowed[cardId] ~= true then
appendError(
errors,
"unknown_player_card",
path .. "[" .. index .. "]",
"런 덱 카드가 현재 플레이어 카드 풀에 없습니다."
)
else
counts[cardId] = (counts[cardId] or 0) + 1
if counts[cardId] > playerPool[cardId].maxCopies then
appendError(
errors,
"card_copy_limit_exceeded",
path .. "[" .. index .. "]",
"런 덱의 카드별 보유 제한을 초과했습니다."
)
end
end
end
end
if #errors > 0 then
return nil, nil, errors
end
return counts, length, nil
end
local function chooseOne(rng, candidates)
local values, nextRng, errors = callNextIntegers(rng, {
{ minimum = 1, maximum = #candidates },
})
if errors then return nil, nil, errors end
return candidates[values[1]], nextRng, nil
end
local function chooseRarity(rng)
local total = 0
for _, rarity in ipairs(RARITY_ORDER) do total = total + RARITY_WEIGHTS[rarity] end
local values, nextRng, errors = callNextIntegers(rng, {
{ minimum = 1, maximum = total },
})
if errors then return nil, nil, errors end
local cumulative = 0
for _, rarity in ipairs(RARITY_ORDER) do
cumulative = cumulative + RARITY_WEIGHTS[rarity]
if values[1] <= cumulative then return rarity, nextRng, nil end
end
end
local function rarityFallbacks(rarity)
if rarity == "legendary" then return { "legendary", "rare", "common" } end
if rarity == "rare" then return { "rare", "common" } end
return { "common", "rare", "legendary" }
end
local function eligibleRewardCards(playerPool, counts, excluded, rarity, style)
local candidates = {}
for _, cardId in ipairs(playerPool) do
local card = playerPool[cardId]
if card.rarity == rarity
and (style == nil or card.draftStyle == style)
and excluded[cardId] ~= true
and (counts[cardId] or 0) < card.maxCopies then
candidates[#candidates + 1] = cardId
end
end
return candidates
end
local function chooseDominantStyle(rng, deck, playerPool)
local styleCounts = {}
local maximum = 0
for _, cardId in ipairs(deck) do
local style = playerPool[cardId].draftStyle
styleCounts[style] = (styleCounts[style] or 0) + 1
if styleCounts[style] > maximum then maximum = styleCounts[style] end
end
local tied = {}
for style, count in pairs(styleCounts) do
if count == maximum then tied[#tied + 1] = style end
end
table.sort(tied)
return chooseOne(rng, tied)
end
local function generateRewardOffer(
setupId,
sessionNumber,
rng,
settlement,
deck,
playerPool
)
local counts, deckLength, deckErrors = countDeck(deck, playerPool, "$.playerCardIds")
if deckErrors then
return nil, nil, deckErrors
end
local eligibleCount = 0
if deckLength < MAX_DECK_SIZE then
for _, cardId in ipairs(playerPool) do
if (counts[cardId] or 0) < playerPool[cardId].maxCopies then eligibleCount = eligibleCount + 1 end
end
end
if eligibleCount == 0 then
return {
kind = "none",
interactionToken = buildRewardToken(
setupId,
sessionNumber,
rng,
settlement,
deck,
"none",
{}
),
}, {
seed = rng.seed,
cursor = rng.cursor,
}, nil
end
local offerCount = math.min(REWARD_OFFER_SIZE, eligibleCount)
local cardIds = {}
local excluded = {}
local currentRng = rng
local dominantStyle, styleErrors
dominantStyle, currentRng, styleErrors = chooseDominantStyle(currentRng, deck, playerPool)
if styleErrors then return nil, nil, styleErrors end
for slot = 1, offerCount do
local rarity, offerErrors
rarity, currentRng, offerErrors = chooseRarity(currentRng)
if offerErrors then return nil, nil, offerErrors end
local requestedStyle = slot == 1 and dominantStyle or nil
local candidates = {}
for _, fallbackRarity in ipairs(rarityFallbacks(rarity)) do
candidates = eligibleRewardCards(playerPool, counts, excluded, fallbackRarity, requestedStyle)
if #candidates > 0 then break end
end
if #candidates == 0 and requestedStyle ~= nil then
-- 희귀도보다 최다 보유 스타일 보장을 우선합니다.
for _, fallbackRarity in ipairs(RARITY_ORDER) do
candidates = eligibleRewardCards(playerPool, counts, excluded, fallbackRarity, requestedStyle)
if #candidates > 0 then break end
end
end
if #candidates == 0 and requestedStyle ~= nil then
for _, fallbackRarity in ipairs(rarityFallbacks(rarity)) do
candidates = eligibleRewardCards(playerPool, counts, excluded, fallbackRarity, nil)
if #candidates > 0 then break end
end
end
local cardId
cardId, currentRng, offerErrors = chooseOne(currentRng, candidates)
if offerErrors then return nil, nil, offerErrors end
cardIds[slot] = cardId
excluded[cardId] = true
end
-- 확정 스타일 카드를 확보한 뒤 표시 위치만 무작위로 바꿉니다.
local positions, positionErrors
positions, currentRng, positionErrors = callNextIntegers(currentRng, {
{ minimum = 1, maximum = offerCount },
})
if positionErrors then return nil, nil, positionErrors end
local position = positions[1]
cardIds[1], cardIds[position] = cardIds[position], cardIds[1]
return {
kind = "card",
cardIds = cardIds,
interactionToken = buildRewardToken(
setupId,
sessionNumber,
currentRng,
settlement,
deck,
"card",
cardIds
),
}, currentRng, nil
end
local function generateCharacterOffer(
setupId,
sessionNumber,
rng,
settlement,
deck,
characterPool
)
local characterIds, nextRng, offerErrors = pickWithoutReplacement(
rng,
characterPool,
CHARACTER_OFFER_SIZE
)
if offerErrors then
return nil, nil, offerErrors
end
return {
characterIds = characterIds,
interactionToken = buildCharacterToken(
setupId,
sessionNumber,
nextRng,
settlement,
deck,
characterIds
),
}, nextRng, nil
end
local function generateBattleSeed(rng)
local values, nextRng, rngErrors = callNextIntegers(rng, {
{
minimum = 1,
maximum = BATTLE_SEED_MAX,
},
})
if rngErrors then
return nil, nil, rngErrors
end
return values[1], nextRng, nil
end
local function buildJourney(seed, staticInput, turnLimit)
local report, journeyErrors = callModule(
"subwayJourney",
"build",
seed,
staticInput,
turnLimit
)
if journeyErrors then
return nil, journeyErrors
end
local errors = {}
if not isSafeInteger(report.turnLimit, 1) or report.turnLimit ~= turnLimit then
appendError(errors, "invalid_turn_limit", "$.runtime.subwayJourney.turnLimit", "여정 제한 턴이 올바르지 않습니다.")
end
local transit = report.transit
if type(transit) ~= "table" or getmetatable(transit) ~= nil then
appendError(errors, "invalid_transit", "$.runtime.subwayJourney.transit", "여정 이동 구간이 일반 객체가 아닙니다.")
else
checkAllowedKeys(
transit,
{ algorithm = true, lineId = true, stationIds = true },
"$.runtime.subwayJourney.transit",
errors
)
if transit.algorithm ~= TRANSIT_ALGORITHM then
appendError(
errors,
"invalid_transit_algorithm",
"$.runtime.subwayJourney.transit.algorithm",
"지원하지 않는 여정 알고리즘입니다."
)
end
if not isAsciiId(transit.lineId) then
appendError(
errors,
"invalid_transit_line",
"$.runtime.subwayJourney.transit.lineId",
"여정 노선 ID가 올바르지 않습니다."
)
end
local stationCount = denseArrayLength(
transit.stationIds,
"$.runtime.subwayJourney.transit.stationIds",
errors
)
if stationCount ~= nil
and isSafeInteger(report.turnLimit, 1)
and stationCount ~= report.turnLimit + 1 then
appendError(
errors,
"transit_length_mismatch",
"$.runtime.subwayJourney.transit.stationIds",
"여정 역 개수는 제한 턴보다 하나 많아야 합니다."
)
elseif stationCount ~= nil then
for index = 1, stationCount do
if not isAsciiId(transit.stationIds[index]) then
appendError(
errors,
"invalid_station_id",
"$.runtime.subwayJourney.transit.stationIds[" .. index .. "]",
"여정 역 ID가 올바르지 않습니다."
)
end
end
end
end
if #errors > 0 then
return nil, errors
end
return {
turnLimit = report.turnLimit,
transit = {
algorithm = transit.algorithm,
lineId = transit.lineId,
stationIds = copyArray(transit.stationIds),
},
}, nil
end
local function buildBattleSpec(
setupId,
sessionNumber,
seed,
characterId,
deck,
staticInput
)
local staticData = normalizeStaticData(staticInput)
local turnLimit = staticData.characters[characterId].battle.turnLimit
local journey, journeyErrors = buildJourney(seed, staticInput, turnLimit)
if journeyErrors then
return nil, journeyErrors
end
return {
battleId = "battle-" .. setupId .. "-session-" .. string.format("%03d", sessionNumber),
seed = seed,
playerCardIds = copyArray(deck),
characterId = characterId,
perkIds = {},
turnLimit = journey.turnLimit,
lineId = journey.transit.lineId,
stationIds = copyArray(journey.transit.stationIds),
}, nil
end
local function buildInitialBattleSpec(setup, staticInput)
local staticData = normalizeStaticData(staticInput)
local turnLimit = staticData.characters[setup.selectedCharacterId].battle.turnLimit
local journey, journeyErrors = buildJourney(setup.battleSpec.seed, staticInput, turnLimit)
if journeyErrors then
return nil, journeyErrors
end
return {
battleId = setup.battleSpec.battleId,
seed = setup.battleSpec.seed,
playerCardIds = copyArray(setup.selectedCardIds),
characterId = setup.selectedCharacterId,
perkIds = {},
turnLimit = journey.turnLimit,
lineId = journey.transit.lineId,
stationIds = copyArray(journey.transit.stationIds),
}, nil
end
local OUTCOME_REASONS = {
card_checkpoint = true,
turn_end_checkpoint = true,
plan_exit_checkpoint = true,
turn_limit = true,
}
local function normalizeSummary(summaryInput, staticData, path)
path = path or "$.summary"
local summary, cloneError = cloneJson(summaryInput, path)
if cloneError then
return nil, { cloneError }
end
local errors = {}
if type(summary) ~= "table" or getmetatable(summary) ~= nil then
appendError(errors, "invalid_summary", path, "전투 종료 summary는 일반 객체여야 합니다.")
return nil, errors
end
checkAllowedKeys(summary, {
battleId = true,
turnId = true,
characterId = true,
status = true,
reasonCode = true,
turnNumber = true,
turnLimit = true,
finalStealth = true,
finalResistance = true,
transit = true,
}, path, errors)
if not isRuntimeId(summary.battleId) then
appendError(errors, "invalid_battle_id", path .. ".battleId", "summary battleId가 올바르지 않습니다.")
end
if not isRuntimeId(summary.turnId) then
appendError(errors, "invalid_turn_id", path .. ".turnId", "summary turnId가 올바르지 않습니다.")
end
if not isAsciiId(summary.characterId)
or type(staticData.characters[summary.characterId]) ~= "table" then
appendError(errors, "unknown_character", path .. ".characterId", "summary 캐릭터를 정적 데이터에서 찾을 수 없습니다.")
end
if summary.status ~= "victory" and summary.status ~= "defeat" then
appendError(errors, "invalid_status", path .. ".status", "summary status는 victory 또는 defeat여야 합니다.")
end
if OUTCOME_REASONS[summary.reasonCode] ~= true then
appendError(errors, "invalid_reason_code", path .. ".reasonCode", "summary 종료 사유가 올바르지 않습니다.")
end
if not isSafeInteger(summary.turnNumber, 1) then
appendError(errors, "invalid_turn_number", path .. ".turnNumber", "summary 턴 번호는 1 이상의 정수여야 합니다.")
end
if not isSafeInteger(summary.turnLimit, 1)
or (isSafeInteger(summary.turnNumber, 1) and summary.turnNumber > summary.turnLimit) then
appendError(errors, "invalid_turn_limit", path .. ".turnLimit", "summary 제한 턴이 올바르지 않습니다.")
end
if not isFinite(summary.finalStealth) then
appendError(errors, "invalid_final_stealth", path .. ".finalStealth", "최종 은폐는 유한한 숫자여야 합니다.")
end
if not isFinite(summary.finalResistance) then
appendError(errors, "invalid_final_resistance", path .. ".finalResistance", "최종 저항은 유한한 숫자여야 합니다.")
end
local transit = summary.transit
if type(transit) ~= "table" or getmetatable(transit) ~= nil then
appendError(errors, "invalid_transit", path .. ".transit", "summary transit은 일반 객체여야 합니다.")
else
checkAllowedKeys(
transit,
{ algorithm = true, lineId = true, stationIds = true },
path .. ".transit",
errors
)
if transit.algorithm ~= TRANSIT_ALGORITHM then
appendError(
errors,
"invalid_transit_algorithm",
path .. ".transit.algorithm",
"summary transit 알고리즘이 올바르지 않습니다."
)
end
if not isAsciiId(transit.lineId)
or type(staticData.subwayLines) ~= "table"
or type(staticData.subwayLines[transit.lineId]) ~= "table" then
appendError(errors, "unknown_subway_line", path .. ".transit.lineId", "summary 지하철 노선을 찾을 수 없습니다.")
end
local stationCount = denseArrayLength(
transit.stationIds,
path .. ".transit.stationIds",
errors
)
if stationCount ~= nil
and isSafeInteger(summary.turnLimit, 1)
and stationCount ~= summary.turnLimit + 1 then
appendError(
errors,
"transit_length_mismatch",
path .. ".transit.stationIds",
"summary 역 개수는 제한 턴보다 하나 많아야 합니다."
)
elseif stationCount ~= nil then
for index = 1, stationCount do
if not isAsciiId(transit.stationIds[index]) then
appendError(
errors,
"invalid_station_id",
path .. ".transit.stationIds[" .. index .. "]",
"summary 역 ID가 올바르지 않습니다."
)
end
end
end
end
if isRuntimeId(summary.battleId)
and isSafeInteger(summary.turnNumber, 1)
and summary.turnId ~= string.format("%s-turn-%03d", summary.battleId, summary.turnNumber) then
appendError(
errors,
"turn_identity_mismatch",
path .. ".turnId",
"summary turnId가 battleId와 턴 번호에서 결정되는 ID와 다릅니다."
)
end
if isFinite(summary.finalResistance)
and isFinite(summary.finalStealth)
and (summary.status == "victory" or summary.status == "defeat") then
if summary.finalResistance <= 0 and summary.status ~= "victory" then
appendError(errors, "victory_priority", path .. ".status", "저항이 0 이하이면 승리를 우선해야 합니다.")
elseif summary.finalResistance > 0
and summary.finalStealth <= 0
and summary.status ~= "defeat" then
appendError(errors, "defeat_required", path .. ".status", "은폐가 0 이하이면 패배여야 합니다.")
elseif summary.status == "victory" and summary.finalResistance > 0 then
appendError(errors, "invalid_victory", path .. ".status", "저항이 남은 summary는 승리일 수 없습니다.")
elseif summary.status == "defeat"
and summary.finalStealth > 0
and summary.turnNumber < summary.turnLimit then
appendError(errors, "invalid_defeat", path .. ".status", "은폐가 남고 제한 턴 전이면 패배일 수 없습니다.")
end
end
if summary.reasonCode == "turn_limit"
and (summary.status ~= "defeat"
or summary.turnNumber ~= summary.turnLimit
or (isFinite(summary.finalResistance) and summary.finalResistance <= 0)
or (isFinite(summary.finalStealth) and summary.finalStealth <= 0)) then
appendError(
errors,
"invalid_turn_limit_outcome",
path .. ".reasonCode",
"turn_limit 패배는 마지막 턴에 저항과 은폐가 모두 남은 경우여야 합니다."
)
elseif (summary.reasonCode == "card_checkpoint"
or summary.reasonCode == "turn_end_checkpoint"
or summary.reasonCode == "plan_exit_checkpoint")
and isFinite(summary.finalResistance)
and isFinite(summary.finalStealth)
and summary.finalResistance > 0
and summary.finalStealth > 0 then
appendError(
errors,
"invalid_resource_outcome",
path .. ".reasonCode",
"자원 checkpoint 종료에는 저항 또는 은폐가 0 이하여야 합니다."
)
end
if #errors > 0 then
return nil, errors
end
return summary, nil
end
local function summaryMatchesSpec(summary, battleSpec, path)
path = path or "$.summary"
local errors = {}
if type(battleSpec) ~= "table" then
appendError(errors, "missing_battle_spec", "$.battleSpec", "summary와 대조할 현재 전투 사양이 없습니다.")
return errors
end
local comparisons = {
{ field = "battleId", expected = battleSpec.battleId },
{ field = "characterId", expected = battleSpec.characterId },
{ field = "turnLimit", expected = battleSpec.turnLimit },
}
for _, comparison in ipairs(comparisons) do
if summary[comparison.field] ~= comparison.expected then
appendError(
errors,
"settlement_battle_mismatch",
path .. "." .. comparison.field,
"종료 summary가 현재 battleReady 전투 사양과 다릅니다."
)
end
end
if type(summary.transit) == "table" then
if summary.transit.lineId ~= battleSpec.lineId then
appendError(
errors,
"settlement_transit_mismatch",
path .. ".transit.lineId",
"종료 summary 노선이 현재 전투 사양과 다릅니다."
)
end
if not deepEqual(summary.transit.stationIds, battleSpec.stationIds) then
appendError(
errors,
"settlement_transit_mismatch",
path .. ".transit.stationIds",
"종료 summary 이동 구간이 현재 전투 사양과 다릅니다."
)
end
end
return errors
end
local function validateRewardChoice(choiceInput, path)
local choice, cloneError = cloneJson(choiceInput, path)
if cloneError then
return nil, { cloneError }
end
local errors = {}
if type(choice) ~= "table" or getmetatable(choice) ~= nil then
appendError(errors, "invalid_reward_choice", path, "보상 선택은 일반 객체여야 합니다.")
return nil, errors
end
checkAllowedKeys(choice, { kind = true, cardId = true }, path, errors)
if choice.kind == "card" then
if not isAsciiId(choice.cardId) then
appendError(errors, "invalid_reward_card", path .. ".cardId", "카드 보상 선택에는 cardId가 필요합니다.")
end
elseif choice.kind == "none" then
if choice.cardId ~= nil then
appendError(errors, "unexpected_reward_card", path .. ".cardId", "none 보상 선택에는 cardId를 넣을 수 없습니다.")
end
else
appendError(errors, "invalid_reward_kind", path .. ".kind", "보상 선택 kind는 card 또는 none이어야 합니다.")
end
if #errors > 0 then
return nil, errors
end
return choice, nil
end
local function applyRewardChoice(offer, choice, deck, playerPool, path)
local counts, deckLength, deckErrors = countDeck(deck, playerPool, "$.playerCardIds")
if deckErrors then
return nil, deckErrors
end
if choice.kind == "none" then
return copyArray(deck), nil
end
if offer.kind == "none" then
return nil, {
makeError(
"reward_choice_mismatch",
path .. ".kind",
"보상 카드가 없을 때는 continue 선택만 사용할 수 있습니다."
),
}
end
if choice.kind ~= "card" or not contains(offer.cardIds, choice.cardId) then
return nil, {
makeError(
"reward_not_in_offer",
path,
"선택한 카드가 현재 보상 제안에 없습니다."
),
}
end
if deckLength >= MAX_DECK_SIZE
or (counts[choice.cardId] or 0) >= playerPool[choice.cardId].maxCopies then
return nil, {
makeError(
"reward_no_longer_eligible",
path .. ".cardId",
"선택한 카드를 현재 덱에 추가할 수 없습니다."
),
}
end
local nextDeck = copyArray(deck)
nextDeck[#nextDeck + 1] = choice.cardId
return nextDeck, nil
end
local SUMMARY_FIELDS = {
"battleId",
"turnId",
"characterId",
"status",
"reasonCode",
"turnNumber",
"turnLimit",
"finalStealth",
"finalResistance",
"transit",
}
local function copySettlementFromRecord(record, path)
local summaryInput = {}
for _, field in ipairs(SUMMARY_FIELDS) do
local value = record[field]
if field == "transit" then
local transitCopy, transitError = cloneJson(value, path .. ".transit")
if transitError then
return nil, transitError
end
summaryInput.transit = transitCopy
else
summaryInput[field] = value
end
end
return summaryInput, nil
end
local function makeSessionRecord(settlement)
local record = {}
for _, field in ipairs(SUMMARY_FIELDS) do
if field == "transit" then
record.transit = {
algorithm = settlement.transit.algorithm,
lineId = settlement.transit.lineId,
stationIds = copyArray(settlement.transit.stationIds),
}
else
record[field] = settlement[field]
end
end
return record
end
local function buildState(
setupId,
phase,
sessions,
rng,
deck,
stats,
phaseValue
)
local sessionCount = #sessions
local state = {
schemaVersion = SCHEMA_VERSION,
kind = KIND,
setupId = setupId,
phase = phase,
sessionNumber = phase == "battleReady" and sessionCount + 1 or sessionCount,
rng = {
seed = rng.seed,
cursor = rng.cursor,
},
playerCardIds = copyArray(deck),
perkIds = {},
stats = {
completed = stats.completed,
victories = stats.victories,
defeats = stats.defeats,
},
sessions = sessions,
lastSettlement = makeSessionRecord(sessions[sessionCount]),
}
if phase == "reward" then
state.rewardOffer = phaseValue
elseif phase == "characterSelect" then
state.characterOffer = phaseValue
elseif phase == "battleReady" then
state.battleSpec = phaseValue
end
return state
end
local function replaySessions(setup, staticData, staticInput, playerPool, characterPool, sessionInput)
local sessionShapeErrors = {}
local sessionCount = denseArrayLength(sessionInput, "$.state.sessions", sessionShapeErrors)
if sessionCount ~= nil and (sessionCount < 1 or sessionCount > MAX_SESSIONS) then
appendError(
sessionShapeErrors,
"invalid_session_count",
"$.state.sessions",
"runProgression에는 1개 이상 999개 이하의 정산 이력이 필요합니다."
)
end
if #sessionShapeErrors > 0 then
return nil, sessionShapeErrors
end
local initialSpec, initialSpecErrors = buildInitialBattleSpec(setup, staticInput)
if initialSpecErrors then
return nil, initialSpecErrors
end
local _, _, initialDeckErrors = countDeck(
setup.selectedCardIds,
playerPool,
"$.gameSetup.selectedCardIds"
)
if initialDeckErrors then
return nil, initialDeckErrors
end
local rng = {
seed = setup.rng.seed,
cursor = setup.rng.cursor,
}
local deck = copyArray(setup.selectedCardIds)
local currentSpec = initialSpec
local stats = {
completed = 0,
victories = 0,
defeats = 0,
}
local canonicalSessions = {}
for sessionIndex = 1, sessionCount do
local inputRecord = sessionInput[sessionIndex]
local recordPath = "$.state.sessions[" .. sessionIndex .. "]"
if type(inputRecord) ~= "table" or getmetatable(inputRecord) ~= nil then
return nil, {
makeError("invalid_session_record", recordPath, "정산 이력 항목은 일반 객체여야 합니다."),
}
end
local recordErrors = {}
checkAllowedKeys(
inputRecord,
{
battleId = true,
turnId = true,
characterId = true,
status = true,
reasonCode = true,
turnNumber = true,
turnLimit = true,
finalStealth = true,
finalResistance = true,
transit = true,
rewardChoice = true,
nextCharacterId = true,
},
recordPath,
recordErrors
)
if #recordErrors > 0 then
return nil, recordErrors
end
local settlementInput, settlementCopyError = copySettlementFromRecord(
inputRecord,
recordPath
)
if settlementCopyError then
return nil, { settlementCopyError }
end
local settlement, settlementErrors = normalizeSummary(
settlementInput,
staticData,
recordPath
)
if settlementErrors then
return nil, settlementErrors
end
local matchErrors = summaryMatchesSpec(
settlement,
currentSpec,
recordPath
)
if #matchErrors > 0 then
return nil, matchErrors
end
stats.completed = stats.completed + 1
if settlement.status == "victory" then
stats.victories = stats.victories + 1
else
stats.defeats = stats.defeats + 1
end
local canonicalRecord = makeSessionRecord(settlement)
canonicalSessions[sessionIndex] = canonicalRecord
if settlement.status == "victory" then
local rewardOffer, afterRewardRng, rewardErrors = generateRewardOffer(
setup.setupId,
sessionIndex,
rng,
settlement,
deck,
playerPool
)
if rewardErrors then
return nil, rewardErrors
end
rng = afterRewardRng
if inputRecord.rewardChoice == nil then
if sessionIndex ~= sessionCount then
return nil, {
makeError(
"incomplete_historical_session",
recordPath .. ".rewardChoice",
"마지막 항목이 아닌 승리 정산 이력에는 보상 선택이 필요합니다."
),
}
end
return buildState(
setup.setupId,
"reward",
canonicalSessions,
rng,
deck,
stats,
rewardOffer
), nil
end
local rewardChoice, choiceErrors = validateRewardChoice(
inputRecord.rewardChoice,
recordPath .. ".rewardChoice"
)
if choiceErrors then
return nil, choiceErrors
end
local nextDeck, applyErrors = applyRewardChoice(
rewardOffer,
rewardChoice,
deck,
playerPool,
recordPath .. ".rewardChoice"
)
if applyErrors then
return nil, applyErrors
end
deck = nextDeck
canonicalRecord.rewardChoice = rewardChoice
else
if inputRecord.rewardChoice ~= nil then
local rewardChoice, choiceErrors = validateRewardChoice(
inputRecord.rewardChoice,
recordPath .. ".rewardChoice"
)
if choiceErrors then
return nil, choiceErrors
end
if rewardChoice.kind ~= "none" then
return nil, {
makeError(
"reward_not_allowed_after_defeat",
recordPath .. ".rewardChoice",
"패배한 세션에서는 카드 보상을 획득할 수 없습니다."
),
}
end
end
canonicalRecord.rewardChoice = {
kind = "none",
}
end
local characterOffer, afterCharacterRng, characterErrors = generateCharacterOffer(
setup.setupId,
sessionIndex,
rng,
settlement,
deck,
characterPool
)
if characterErrors then
return nil, characterErrors
end
rng = afterCharacterRng
if inputRecord.nextCharacterId == nil then
if sessionIndex ~= sessionCount then
return nil, {
makeError(
"incomplete_historical_session",
recordPath .. ".nextCharacterId",
"마지막 항목이 아닌 정산 이력에는 다음 대상 선택이 필요합니다."
),
}
end
return buildState(
setup.setupId,
"characterSelect",
canonicalSessions,
rng,
deck,
stats,
characterOffer
), nil
end
if not isAsciiId(inputRecord.nextCharacterId)
or not contains(characterOffer.characterIds, inputRecord.nextCharacterId) then
return nil, {
makeError(
"character_not_in_replayed_offer",
recordPath .. ".nextCharacterId",
"다음 대상이 결정적으로 재생한 캐릭터 후보에 포함되지 않습니다."
),
}
end
canonicalRecord.nextCharacterId = inputRecord.nextCharacterId
if sessionIndex >= MAX_SESSIONS then
return nil, {
makeError(
"session_limit_reached",
recordPath .. ".nextCharacterId",
"세션 번호 999 뒤에는 새 전투를 만들 수 없습니다."
),
}
end
local battleSeed, afterSeedRng, seedErrors = generateBattleSeed(rng)
if seedErrors then
return nil, seedErrors
end
rng = afterSeedRng
local nextSpec, specErrors = buildBattleSpec(
setup.setupId,
sessionIndex + 1,
battleSeed,
inputRecord.nextCharacterId,
deck,
staticInput
)
if specErrors then
return nil, specErrors
end
currentSpec = nextSpec
if sessionIndex == sessionCount then
return buildState(
setup.setupId,
"battleReady",
canonicalSessions,
rng,
deck,
stats,
currentSpec
), nil
end
end
return nil, {
makeError("missing_progression_state", "$.state", "정산 이력에서 runProgression 상태를 재생하지 못했습니다."),
}
end
local function validateStateShape(state, setupId)
local errors = {}
validateJson(state, "$.state", errors, {})
if type(state) ~= "table" or getmetatable(state) ~= nil then
return errors
end
checkAllowedKeys(state, {
schemaVersion = true,
kind = true,
setupId = true,
phase = true,
sessionNumber = true,
rng = true,
playerCardIds = true,
perkIds = true,
stats = true,
sessions = true,
lastSettlement = true,
rewardOffer = true,
characterOffer = true,
battleSpec = true,
}, "$.state", errors)
if state.schemaVersion ~= SCHEMA_VERSION then
appendError(errors, "unsupported_schema_version", "$.state.schemaVersion", "지원하지 않는 runProgression 스키마입니다.")
end
if state.kind ~= KIND then
appendError(errors, "invalid_state_kind", "$.state.kind", "상태 kind는 runProgressionV1이어야 합니다.")
end
if state.setupId ~= setupId then
appendError(errors, "setup_identity_mismatch", "$.state.setupId", "상태가 원본 gameSetup에 속하지 않습니다.")
end
if state.phase ~= "reward"
and state.phase ~= "characterSelect"
and state.phase ~= "battleReady" then
appendError(errors, "invalid_phase", "$.state.phase", "지원하지 않는 runProgression phase입니다.")
end
if not isSafeInteger(state.sessionNumber, 1) or state.sessionNumber > MAX_SESSIONS then
appendError(errors, "invalid_session_number", "$.state.sessionNumber", "세션 번호는 1 이상 999 이하여야 합니다.")
end
if type(state.rng) ~= "table" or getmetatable(state.rng) ~= nil then
appendError(errors, "invalid_rng", "$.state.rng", "progression rng는 일반 객체여야 합니다.")
else
checkAllowedKeys(state.rng, { seed = true, cursor = true }, "$.state.rng", errors)
if not isSafeInteger(state.rng.seed, 0) then
appendError(errors, "invalid_rng_seed", "$.state.rng.seed", "progression RNG seed가 올바르지 않습니다.")
end
if not isSafeInteger(state.rng.cursor, 0) then
appendError(errors, "invalid_rng_cursor", "$.state.rng.cursor", "progression RNG cursor가 올바르지 않습니다.")
end
end
local perkCount = denseArrayLength(state.perkIds, "$.state.perkIds", errors)
if perkCount ~= nil and perkCount ~= 0 then
appendError(errors, "unsupported_perks", "$.state.perkIds", "현재 progression 버전의 perkIds는 빈 배열이어야 합니다.")
end
if type(state.stats) ~= "table" or getmetatable(state.stats) ~= nil then
appendError(errors, "invalid_stats", "$.state.stats", "누적 전적은 일반 객체여야 합니다.")
else
checkAllowedKeys(
state.stats,
{ completed = true, victories = true, defeats = true },
"$.state.stats",
errors
)
for _, field in ipairs({ "completed", "victories", "defeats" }) do
if not isSafeInteger(state.stats[field], 0) then
appendError(errors, "invalid_stat", "$.state.stats." .. field, "누적 전적은 0 이상의 정수여야 합니다.")
end
end
if isSafeInteger(state.stats.completed, 0)
and isSafeInteger(state.stats.victories, 0)
and isSafeInteger(state.stats.defeats, 0)
and state.stats.completed ~= state.stats.victories + state.stats.defeats then
appendError(errors, "stats_total_mismatch", "$.state.stats", "완료 세션 수가 승리와 패배 합계와 다릅니다.")
end
end
local sessionCount = denseArrayLength(state.sessions, "$.state.sessions", errors)
if sessionCount ~= nil and (sessionCount < 1 or sessionCount > MAX_SESSIONS) then
appendError(errors, "invalid_session_count", "$.state.sessions", "정산 이력 개수가 올바르지 않습니다.")
end
if state.phase == "reward" then
if state.rewardOffer == nil then
appendError(errors, "missing_reward_offer", "$.state.rewardOffer", "reward phase에는 보상 제안이 필요합니다.")
end
if state.characterOffer ~= nil or state.battleSpec ~= nil then
appendError(errors, "unexpected_phase_field", "$.state", "reward phase에는 다른 phase 자료를 넣을 수 없습니다.")
end
elseif state.phase == "characterSelect" then
if state.characterOffer == nil then
appendError(errors, "missing_character_offer", "$.state.characterOffer", "characterSelect phase에는 대상 후보가 필요합니다.")
end
if state.rewardOffer ~= nil or state.battleSpec ~= nil then
appendError(errors, "unexpected_phase_field", "$.state", "characterSelect phase에는 다른 phase 자료를 넣을 수 없습니다.")
end
elseif state.phase == "battleReady" then
if state.battleSpec == nil then
appendError(errors, "missing_battle_spec", "$.state.battleSpec", "battleReady phase에는 다음 전투 사양이 필요합니다.")
end
if state.rewardOffer ~= nil or state.characterOffer ~= nil then
appendError(errors, "unexpected_phase_field", "$.state", "battleReady phase에는 다른 phase 자료를 넣을 수 없습니다.")
end
end
return errors
end
local function validateAndReplay(
stateInput,
setup,
staticData,
staticInput,
playerPool,
characterPool
)
local state, cloneError = cloneJson(stateInput, "$.state")
if cloneError then
return nil, { cloneError }
end
local shapeErrors = validateStateShape(state, setup.setupId)
if #shapeErrors > 0 then
return nil, shapeErrors
end
local expected, replayErrors = replaySessions(
setup,
staticData,
staticInput,
playerPool,
characterPool,
state.sessions
)
if replayErrors then
return nil, replayErrors
end
if not deepEqual(state, expected) then
return nil, {
makeError(
"progression_state_replay_mismatch",
"$.state",
"저장된 runProgression 상태가 원본 setup과 선택 이력으로 재생한 canonical 상태와 다릅니다."
),
}
end
return expected, nil
end
local function validateClaimCommand(commandInput)
local command, cloneError = cloneJson(commandInput, "$.command")
if cloneError then
return nil, { cloneError }
end
local errors = {}
if type(command) ~= "table" or getmetatable(command) ~= nil then
appendError(errors, "invalid_command", "$.command", "보상 선택 명령은 일반 객체여야 합니다.")
return nil, errors
end
checkAllowedKeys(
command,
{ cardId = true, interactionToken = true },
"$.command",
errors
)
if not isAsciiId(command.cardId) then
appendError(
errors,
"invalid_command_card",
"$.command.cardId",
"보상 선택에는 플레이어 cardId 또는 continue가 필요합니다."
)
end
if type(command.interactionToken) ~= "string"
or string.match(
command.interactionToken,
"^run%-progression%-reward%-v1:%d+:%d+:%d+$"
) == nil then
appendError(errors, "invalid_command_token", "$.command.interactionToken", "보상 interactionToken 형식이 올바르지 않습니다.")
end
if #errors > 0 then
return nil, errors
end
return command, nil
end
local function validateCharacterCommand(commandInput)
local command, cloneError = cloneJson(commandInput, "$.command")
if cloneError then
return nil, { cloneError }
end
local errors = {}
if type(command) ~= "table" or getmetatable(command) ~= nil then
appendError(errors, "invalid_command", "$.command", "대상 선택 명령은 일반 객체여야 합니다.")
return nil, errors
end
checkAllowedKeys(
command,
{ characterId = true, interactionToken = true },
"$.command",
errors
)
if not isAsciiId(command.characterId) then
appendError(errors, "invalid_command_character", "$.command.characterId", "대상 선택에는 characterId가 필요합니다.")
end
if type(command.interactionToken) ~= "string"
or string.match(
command.interactionToken,
"^run%-progression%-character%-v1:%d+:%d+:%d+$"
) == nil then
appendError(errors, "invalid_command_token", "$.command.interactionToken", "대상 interactionToken 형식이 올바르지 않습니다.")
end
if #errors > 0 then
return nil, errors
end
return command, nil
end
local function settle(currentInput, setupInput, summaryInput, staticInput)
local setup, staticData, playerPool, characterPool, setupErrors =
validateSetup(setupInput, staticInput)
if setupErrors then
return failure(setupErrors)
end
local summary, summaryErrors = normalizeSummary(summaryInput, staticData, "$.summary")
if summaryErrors then
return failure(summaryErrors)
end
local sessions
local current
if currentInput == nil then
local initialSpec, specErrors = buildInitialBattleSpec(setup, staticInput)
if specErrors then
return failure(specErrors)
end
local matchErrors = summaryMatchesSpec(summary, initialSpec, "$.summary")
if #matchErrors > 0 then
return failure(matchErrors)
end
sessions = {
makeSessionRecord(summary),
}
else
local currentErrors
current, currentErrors = validateAndReplay(
currentInput,
setup,
staticData,
staticInput,
playerPool,
characterPool
)
if currentErrors then
return failure(currentErrors)
end
if current.lastSettlement.battleId == summary.battleId
and current.lastSettlement.turnId == summary.turnId then
if not deepEqual(current.lastSettlement, summary) then
return failure({
makeError(
"settlement_receipt_conflict",
"$.summary",
"같은 battleId와 turnId의 정산 summary가 이미 저장된 내용과 다릅니다."
),
})
end
return success(current, false, true)
end
if current.phase ~= "battleReady" then
return failure({
makeError(
"different_settlement_while_pending",
"$.summary",
"현재 정산의 보상과 다음 대상 선택을 마치기 전에는 다른 전투를 정산할 수 없습니다."
),
})
end
local matchErrors = summaryMatchesSpec(summary, current.battleSpec, "$.summary")
if #matchErrors > 0 then
return failure(matchErrors)
end
sessions = {}
for index, record in ipairs(current.sessions) do
local recordCopy, recordError = cloneJson(record, "$.state.sessions[" .. index .. "]")
if recordError then
return failure({ recordError })
end
sessions[index] = recordCopy
end
sessions[#sessions + 1] = makeSessionRecord(summary)
end
local nextState, replayErrors = replaySessions(
setup,
staticData,
staticInput,
playerPool,
characterPool,
sessions
)
if replayErrors then
return failure(replayErrors)
end
return success(nextState, true, false)
end
local function claimReward(currentInput, setupInput, commandInput, staticInput)
local command, commandErrors = validateClaimCommand(commandInput)
if commandErrors then
return failure(commandErrors)
end
local setup, staticData, playerPool, characterPool, setupErrors =
validateSetup(setupInput, staticInput)
if setupErrors then
return failure(setupErrors)
end
local current, currentErrors = validateAndReplay(
currentInput,
setup,
staticData,
staticInput,
playerPool,
characterPool
)
if currentErrors then
return failure(currentErrors)
end
if current.phase ~= "reward"
or command.interactionToken ~= current.rewardOffer.interactionToken then
return success(current, false, true)
end
local choice
if command.cardId == "continue" then
choice = {
kind = "none",
}
else
choice = {
kind = "card",
}
choice.cardId = command.cardId
end
local _, applyErrors = applyRewardChoice(
current.rewardOffer,
choice,
current.playerCardIds,
playerPool,
"$.command"
)
if applyErrors then
return failure(applyErrors)
end
local sessions, sessionsError = cloneJson(current.sessions, "$.state.sessions")
if sessionsError then
return failure({ sessionsError })
end
sessions[#sessions].rewardChoice = choice
local nextState, replayErrors = replaySessions(
setup,
staticData,
staticInput,
playerPool,
characterPool,
sessions
)
if replayErrors then
return failure(replayErrors)
end
return success(nextState, true, false)
end
local function chooseCharacter(currentInput, setupInput, commandInput, staticInput)
local command, commandErrors = validateCharacterCommand(commandInput)
if commandErrors then
return failure(commandErrors)
end
local setup, staticData, playerPool, characterPool, setupErrors =
validateSetup(setupInput, staticInput)
if setupErrors then
return failure(setupErrors)
end
local current, currentErrors = validateAndReplay(
currentInput,
setup,
staticData,
staticInput,
playerPool,
characterPool
)
if currentErrors then
return failure(currentErrors)
end
if current.phase ~= "characterSelect"
or command.interactionToken ~= current.characterOffer.interactionToken then
return success(current, false, true)
end
if not contains(current.characterOffer.characterIds, command.characterId) then
return failure({
makeError(
"character_not_in_offer",
"$.command.characterId",
"선택한 캐릭터가 현재 대상 후보에 없습니다."
),
})
end
local sessions, sessionsError = cloneJson(current.sessions, "$.state.sessions")
if sessionsError then
return failure({ sessionsError })
end
sessions[#sessions].nextCharacterId = command.characterId
local nextState, replayErrors = replaySessions(
setup,
staticData,
staticInput,
playerPool,
characterPool,
sessions
)
if replayErrors then
return failure(replayErrors)
end
return success(nextState, true, false)
end
local function validateState(currentInput, setupInput, staticInput)
local setup, staticData, playerPool, characterPool, setupErrors =
validateSetup(setupInput, staticInput)
if setupErrors then
return failure(setupErrors)
end
if currentInput == nil then
return failure({
makeError("missing_progression_state", "$.state", "검증할 runProgression 상태가 필요합니다."),
})
end
local current, currentErrors = validateAndReplay(
currentInput,
setup,
staticData,
staticInput,
playerPool,
characterPool
)
if currentErrors then
return failure(currentErrors)
end
return success(current, false, false)
end
local arguments = { ... }
if action == "settle" then
return settle(arguments[1], arguments[2], arguments[3], arguments[4])
elseif action == "claimReward" then
return claimReward(arguments[1], arguments[2], arguments[3], arguments[4])
elseif action == "chooseCharacter" then
return chooseCharacter(arguments[1], arguments[2], arguments[3], arguments[4])
elseif action == "validate" then
return validateState(arguments[1], arguments[2], arguments[3])
end
return failure({
makeError(
"unknown_action",
"$.action",
"지원하지 않는 runProgression 작업입니다: " .. tostring(action)
),
})
end)
#45runProgressionView.lua
Keys:
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local VIEW_KIND = "runProgressionView"
local STATE_KIND = "runProgressionV1"
local SETUP_KIND = "gameSetupV1"
local DECK_MIN = 10
local DECK_MAX = 20
local CHARACTER_OFFER_SIZE = 3
local REWARD_OFFER_MAX = 3
local VALID_PHASES = {
reward = true,
characterSelect = true,
battleReady = true,
}
local VALID_OUTCOMES = {
victory = true,
defeat = true,
}
local REASON_LABELS = {
card_checkpoint = "카드 해결 중 승패 확정",
turn_end_checkpoint = "턴 종료 판정",
plan_exit_checkpoint = "계획 만료 효과로 승패 확정",
turn_limit = "제한 구간 도착",
}
local function addError(errors, code, path, message)
errors[#errors + 1] = {
code = code,
path = path,
message = message,
}
end
local function failure(errors)
return {
ok = false,
schemaVersion = SCHEMA_VERSION,
errors = errors,
}
end
local function success(key, value)
local result = {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
}
if key ~= nil then
result[key] = value
end
return result
end
local function isFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function isInteger(value, minimum, maximum)
return isFinite(value)
and value % 1 == 0
and (minimum == nil or value >= minimum)
and (maximum == nil or value <= maximum)
end
local function isAsciiId(value)
return type(value) == "string"
and string.match(value, "^[a-z][a-z0-9_]*$") ~= nil
end
local function isRuntimeId(value)
return type(value) == "string"
and string.match(value, "^[A-Za-z0-9][A-Za-z0-9_-]*$") ~= nil
end
local function isInteractionToken(value)
return type(value) == "string"
and value ~= ""
and #value <= 512
and string.find(value, "[%z\1-\31\127]") == nil
end
local function objectPath(path, key)
if type(key) == "string"
and string.match(key, "^[A-Za-z_][A-Za-z0-9_]*$") then
return path .. "." .. key
end
return path .. "[" .. string.format("%q", tostring(key)) .. "]"
end
local function inspectTable(value, path, errors)
if type(value) ~= "table" or getmetatable(value) ~= nil then
addError(errors, "expected_plain_table", path, "메타테이블이 없는 테이블이어야 합니다.")
return nil
end
local numericCount = 0
local maximum = 0
local hasNumeric = false
local hasString = false
local stringKeys = {}
for key in pairs(value) do
if type(key) == "number" then
hasNumeric = true
numericCount = numericCount + 1
if not isInteger(key, 1) then
addError(errors, "invalid_array_index", path, "배열 인덱스는 1 이상의 정수여야 합니다.")
return nil
end
if key > maximum then maximum = key end
elseif type(key) == "string" then
hasString = true
stringKeys[#stringKeys + 1] = key
else
addError(errors, "invalid_object_key", path, "객체 키는 문자열이어야 합니다.")
return nil
end
end
if hasNumeric and hasString then
addError(errors, "mixed_table", path, "배열 인덱스와 객체 키를 함께 사용할 수 없습니다.")
return nil
end
if hasNumeric then
if numericCount ~= maximum then
addError(errors, "sparse_array", path, "배열 인덱스는 1부터 빈틈없이 이어져야 합니다.")
return nil
end
return "array", maximum
end
if hasString then
table.sort(stringKeys)
return "object", stringKeys
end
return "array", 0
end
local function getArrayLength(value, path, errors)
local kind, length = inspectTable(value, path, errors)
if kind ~= "array" then
if kind ~= nil then
addError(errors, "expected_array", path, "1부터 이어지는 연속 배열이어야 합니다.")
end
return nil
end
return length
end
local function validateJsonSafe(value, path, errors, active)
local valueType = type(value)
if valueType == "string" or valueType == "boolean" then return end
if valueType == "number" then
if not isFinite(value) then
addError(errors, "non_finite_number", path, "NaN과 무한대는 View에 넣을 수 없습니다.")
end
return
end
if valueType ~= "table" then
addError(errors, "unsupported_type", path, "View에 넣을 수 없는 자료형입니다: " .. valueType)
return
end
if getmetatable(value) ~= nil then
addError(errors, "metatable_not_allowed", path, "View에는 메타테이블을 사용할 수 없습니다.")
return
end
active = active or {}
if active[value] then
addError(errors, "circular_reference", path, "순환 참조가 있는 값은 사용할 수 없습니다.")
return
end
active[value] = true
local kind, shape = inspectTable(value, path, errors)
if kind == "array" then
for index = 1, shape do
validateJsonSafe(value[index], path .. "[" .. index .. "]", errors, active)
end
elseif kind == "object" then
for _, key in ipairs(shape) do
validateJsonSafe(value[key], objectPath(path, key), errors, active)
end
end
active[value] = nil
end
local function checkAllowedKeys(value, allowed, path, errors)
if type(value) ~= "table" then return end
for key in pairs(value) do
if type(key) ~= "string" or allowed[key] ~= true then
addError(errors, "unknown_field", objectPath(path, key), "허용 목록에 없는 필드입니다.")
end
end
end
local function cloneJson(value, path, active)
if type(value) ~= "table" then return value, nil end
if getmetatable(value) ~= nil then
return nil, {
code = "metatable_not_allowed",
path = path,
message = "복제할 값에는 메타테이블을 사용할 수 없습니다.",
}
end
active = active or {}
if active[value] then
return nil, {
code = "circular_reference",
path = path,
message = "순환 참조가 있는 값을 복제할 수 없습니다.",
}
end
active[value] = true
local copy = {}
for key, item in pairs(value) do
local itemCopy, itemError = cloneJson(item, objectPath(path, key), active)
if itemError then
active[value] = nil
return nil, itemError
end
copy[key] = itemCopy
end
active[value] = nil
return copy, nil
end
local function deepEqual(left, right, active)
if type(left) ~= type(right) then return false end
if type(left) ~= "table" then return left == right end
if getmetatable(left) ~= nil or getmetatable(right) ~= nil then return false end
active = active or {}
if active[left] ~= nil then return active[left] == right end
active[left] = right
for key, value in pairs(left) do
if not deepEqual(value, right[key], active) then
active[left] = nil
return false
end
end
for key in pairs(right) do
if left[key] == nil then
active[left] = nil
return false
end
end
active[left] = nil
return true
end
local function normalizeStaticData(staticData)
if type(staticData) == "table"
and getmetatable(staticData) == nil
and type(rawget(staticData, "data")) == "table" then
return rawget(staticData, "data")
end
return staticData
end
local function appendNestedErrors(target, prefix, report)
if type(report) ~= "table" or type(report.errors) ~= "table" then
addError(target, "validation_failed", prefix, "하위 검증 결과를 읽을 수 없습니다.")
return
end
local appended = false
for _, item in ipairs(report.errors) do
appended = true
local suffix = tostring(type(item) == "table" and item.path or "$")
if string.sub(suffix, 1, 1) == "$" then
suffix = string.sub(suffix, 2)
else
suffix = "." .. suffix
end
addError(
target,
tostring(type(item) == "table" and item.code or "validation_failed"),
prefix .. suffix,
tostring(type(item) == "table" and item.message or "하위 검증에 실패했습니다.")
)
end
if not appended then
addError(target, "validation_failed", prefix, "하위 검증이 상세 오류 없이 실패했습니다.")
end
end
local function callRuntime(moduleName, moduleAction, ...)
if type(runScript) ~= "function" then
return nil, {
code = "runtime_unavailable",
path = "$.runtime." .. moduleName,
message = "runScript 실행기를 찾을 수 없습니다.",
}
end
local ok, report = pcall(runScript, triggerId, moduleName, moduleAction, ...)
if not ok then
return nil, {
code = "runtime_call_error",
path = "$.runtime." .. moduleName,
message = moduleName .. "." .. moduleAction .. " 실행에 실패했습니다: " .. tostring(report),
}
end
if type(report) ~= "table" or getmetatable(report) ~= nil then
return nil, {
code = "invalid_runtime_result",
path = "$.runtime." .. moduleName,
message = "하위 모듈이 일반 테이블 결과를 반환하지 않았습니다.",
}
end
return report, nil
end
local function inspectCanonicalInputs(runState, setupState, staticInput)
local errors = {}
if type(runState) ~= "table" or getmetatable(runState) ~= nil then
addError(errors, "invalid_canonical_run_state", "$.runState", "내부 canonical 진행 상태가 일반 테이블이 아닙니다.")
elseif runState.schemaVersion ~= SCHEMA_VERSION
or runState.kind ~= STATE_KIND
or VALID_PHASES[runState.phase] ~= true
or not isRuntimeId(runState.setupId)
or type(runState.stats) ~= "table"
or type(runState.playerCardIds) ~= "table"
or type(runState.lastSettlement) ~= "table" then
addError(errors, "invalid_canonical_run_contract", "$.runState", "내부 canonical 진행 상태가 필수 postcondition을 만족하지 않습니다.")
elseif (runState.phase == "reward" and type(runState.rewardOffer) ~= "table")
or (runState.phase == "characterSelect" and type(runState.characterOffer) ~= "table")
or (runState.phase == "battleReady" and type(runState.battleSpec) ~= "table") then
addError(errors, "invalid_canonical_run_phase", "$.runState", "내부 canonical 진행 상태와 phase 자료가 일치하지 않습니다.")
end
if type(setupState) ~= "table" or getmetatable(setupState) ~= nil then
addError(errors, "invalid_canonical_setup_state", "$.setupState", "내부 canonical 설정 상태가 일반 테이블이 아닙니다.")
elseif setupState.schemaVersion ~= SCHEMA_VERSION
or setupState.kind ~= SETUP_KIND
or setupState.phase ~= "battleReady"
or not isRuntimeId(setupState.setupId)
or (type(runState) == "table" and runState.setupId ~= setupState.setupId) then
addError(errors, "invalid_canonical_setup_contract", "$.setupState", "내부 canonical 설정 상태가 필수 postcondition을 만족하지 않습니다.")
end
local staticData = normalizeStaticData(staticInput)
if type(staticData) ~= "table"
or getmetatable(staticData) ~= nil
or type(staticData.registry) ~= "table"
or type(staticData.registry.cardTypes) ~= "table"
or type(staticData.registry.roles) ~= "table"
or type(staticData.registry.mechanisms) ~= "table"
or type(staticData.registry.moods) ~= "table"
or type(staticData.cards) ~= "table"
or type(staticData.traits) ~= "table"
or type(staticData.subwayLines) ~= "table"
or type(staticData.characters) ~= "table" then
addError(errors, "missing_static_data", "$.staticData", "검증된 전체 정적 데이터가 필요합니다.")
end
if #errors > 0 then return nil, errors end
return staticData, nil
end
local function lookupStation(line, stationId)
for _, routePath in ipairs(type(line) == "table" and line.paths or {}) do
for _, station in ipairs(type(routePath) == "table" and routePath.stations or {}) do
if type(station) == "table" and station.id == stationId then
return station
end
end
end
return nil
end
local function stationView(station)
return {
id = station.id,
code = station.code,
name = station.name,
}
end
local function buildRouteView(settlement, staticData, errors)
local transit = settlement.transit
local line = staticData.subwayLines[transit.lineId]
if type(line) ~= "table" then
addError(errors, "unknown_line", "$.result.route", "정산 노선을 찾을 수 없습니다.")
return nil
end
local ids = transit.stationIds
local reachedIndex = math.min(#ids, settlement.turnNumber + 1)
local startStation = lookupStation(line, ids[1])
local reachedStation = lookupStation(line, ids[reachedIndex])
local destinationStation = lookupStation(line, ids[#ids])
if type(startStation) ~= "table"
or type(reachedStation) ~= "table"
or type(destinationStation) ~= "table" then
addError(errors, "unknown_route_station", "$.result.route", "정산 이동 구간의 역 정보를 찾을 수 없습니다.")
return nil
end
return {
lineId = line.id,
lineName = line.name,
lineCode = line.code,
lineColor = line.color,
operatorName = line.operatorName,
startStation = stationView(startStation),
reachedStation = stationView(reachedStation),
destinationStation = stationView(destinationStation),
}
end
local function buildResultView(runState, staticData, errors)
local settlement = runState.lastSettlement
local character = staticData.characters[settlement.characterId]
if type(character) ~= "table" then
addError(errors, "missing_result_reference", "$.result", "최근 세션의 공개 참조를 찾을 수 없습니다.")
return nil
end
local route = buildRouteView(settlement, staticData, errors)
if route == nil then return nil end
local statusLabel = settlement.status == "victory" and "승리" or "패배"
local headline = settlement.status == "victory"
and character.name .. "의 저항을 무너뜨렸습니다"
or character.name .. " 공략에 실패했습니다"
return {
sessionNumber = runState.stats.completed,
battleId = settlement.battleId,
status = settlement.status,
statusLabel = statusLabel,
headline = headline,
reasonCode = settlement.reasonCode,
reasonLabel = REASON_LABELS[settlement.reasonCode],
character = {
id = character.id,
name = character.name,
},
turnNumber = settlement.turnNumber,
turnLimit = settlement.turnLimit,
finalStealth = settlement.finalStealth,
finalResistance = settlement.finalResistance,
route = route,
}
end
local function buildCardView(slot, cardId, ownedCopies, staticData, errors, basePath)
local path = (basePath or "$.rewardOffer.cards") .. "[" .. slot .. "]"
local card = staticData.cards[cardId]
if type(card) ~= "table" or card.owner ~= "player" or card.id ~= cardId then
addError(errors, "unknown_player_card", path .. ".cardId", "플레이어 카드 정의를 찾을 수 없습니다.")
return nil
end
local presentation, callError = callRuntime(
"viewBuilder",
"buildCardPresentation",
card,
staticData.registry,
path
)
if callError then
errors[#errors + 1] = callError
return nil
end
if presentation.ok ~= true or type(presentation.card) ~= "table" then
appendNestedErrors(errors, path, presentation)
return nil
end
if type(card.base) ~= "table"
or not isFinite(card.base.stealthCost)
or not isFinite(card.base.resistanceDamage) then
addError(errors, "invalid_card_base", path, "보상 카드의 기본 수치를 표시할 수 없습니다.")
return nil
end
return {
slot = slot,
cardId = presentation.card.cardId,
name = presentation.card.name,
rarity = card.rarity,
draftStyle = card.draftStyle,
descriptionSegments = presentation.card.descriptionSegments,
ruleLines = presentation.card.ruleLines,
cardType = presentation.card.cardType,
roles = presentation.card.roles,
mechanisms = presentation.card.mechanisms,
terms = presentation.card.terms,
baseStealthCost = card.base.stealthCost,
baseResistanceDamage = card.base.resistanceDamage,
ownedCopies = ownedCopies,
maxCopies = card.rarity == "legendary" and 1 or 2,
}
end
local function buildRewardOfferView(runState, staticData, errors)
local offer = runState.rewardOffer
local result = {
kind = offer.kind,
interactionToken = offer.interactionToken,
cards = {},
}
if offer.kind == "card" then
local copies = {}
for _, cardId in ipairs(runState.playerCardIds) do
copies[cardId] = (copies[cardId] or 0) + 1
end
for slot, cardId in ipairs(offer.cardIds) do
local cardView = buildCardView(
slot,
cardId,
copies[cardId] or 0,
staticData,
errors,
"$.rewardOffer.cards"
)
if cardView ~= nil then result.cards[#result.cards + 1] = cardView end
end
end
result.count = #result.cards
return result
end
local function buildDeckView(runState, staticData, errors)
local copies = {}
local cardIds = {}
local totalCost = 0
for _, cardId in ipairs(runState.playerCardIds) do
if copies[cardId] == nil then
copies[cardId] = 0
cardIds[#cardIds + 1] = cardId
end
copies[cardId] = copies[cardId] + 1
local card = staticData.cards[cardId]
if type(card) == "table" and type(card.base) == "table"
and isFinite(card.base.stealthCost) then
totalCost = totalCost + card.base.stealthCost
end
end
local function cardCost(cardId)
local card = staticData.cards[cardId]
local cost = type(card) == "table" and type(card.base) == "table"
and card.base.stealthCost or nil
return isFinite(cost) and cost or math.huge
end
table.sort(cardIds, function(left, right)
local leftCost = cardCost(left)
local rightCost = cardCost(right)
if leftCost ~= rightCost then return leftCost < rightCost end
return left < right
end)
local items = {}
for slot, cardId in ipairs(cardIds) do
local cardView = buildCardView(
slot,
cardId,
copies[cardId],
staticData,
errors,
"$.deck.items"
)
if cardView ~= nil then items[#items + 1] = cardView end
end
return {
count = #runState.playerCardIds,
limit = DECK_MAX,
averageCost = math.floor(totalCost / #runState.playerCardIds * 10 + 0.5) / 10,
items = items,
}
end
local function buildAppearanceSummary(profile, path, errors)
if type(profile) ~= "table" or type(profile.appearance) ~= "table" then
addError(errors, "missing_public_appearance", path, "공개 외형 정보를 찾을 수 없습니다.")
return nil
end
local appearance = profile.appearance
local parts = {}
local function appendText(value, suffix)
if type(value) == "string" and value ~= "" then
parts[#parts + 1] = value .. (suffix or "")
end
end
local function appendNumber(value, suffix)
if isFinite(value) then parts[#parts + 1] = tostring(value) .. suffix end
end
appendText(appearance.hairColor, " 머리")
appendText(appearance.eyeColor, " 눈")
appendText(appearance.skin)
appendNumber(appearance.height, "cm")
appendNumber(appearance.weight, "kg")
appendText(appearance.threeSize)
appendText(appearance.style)
if #parts == 0 then
addError(errors, "empty_public_appearance", path, "표시할 공개 외형 요약이 없습니다.")
return nil
end
return table.concat(parts, " · ")
end
local function buildCharacterView(slot, characterId, staticData, errors)
local path = "$.characterOffer.characters[" .. slot .. "]"
local character = staticData.characters[characterId]
if type(character) ~= "table"
or character.id ~= characterId
or type(character.name) ~= "string"
or character.name == "" then
addError(errors, "unknown_character", path .. ".characterId", "제안 캐릭터를 찾을 수 없습니다.")
return nil
end
local profile = character.publicProfile
local battle = character.battle
if type(profile) ~= "table" or type(battle) ~= "table" then
addError(errors, "missing_character_public_data", path, "캐릭터 공개 정보를 표시할 수 없습니다.")
return nil
end
local appearanceSummary = buildAppearanceSummary(profile, path .. ".appearanceSummary", errors)
local mood = staticData.registry.moods[battle.startingMood]
if type(mood) ~= "table" or type(mood.label) ~= "string" or mood.label == "" then
addError(errors, "unknown_starting_mood", path .. ".startingMood", "시작 무드를 찾을 수 없습니다.")
return nil
end
local traits = {}
for index, traitId in ipairs(type(battle.traitIds) == "table" and battle.traitIds or {}) do
local trait = staticData.traits[traitId]
if type(trait) ~= "table"
or trait.owner ~= "character"
or trait.visibility ~= "public"
or type(trait.name) ~= "string"
or type(trait.description) ~= "string" then
addError(errors, "invalid_public_trait", path .. ".traits[" .. index .. "]", "공개 특징을 표시할 수 없습니다.")
else
traits[#traits + 1] = {
id = trait.id,
name = trait.name,
description = trait.description,
}
end
end
return {
slot = slot,
characterId = character.id,
name = character.name,
age = profile.age,
occupation = profile.occupation,
appearanceSummary = appearanceSummary,
startingResistance = battle.startingResistance,
turnLimit = battle.turnLimit,
startingMood = {
id = mood.id,
label = mood.label,
},
baseDrawCount = battle.baseDrawCount,
maxHandSize = battle.maxHandSize,
traits = traits,
}
end
local function buildCharacterOfferView(runState, staticData, errors)
local characters = {}
for slot, characterId in ipairs(runState.characterOffer.characterIds) do
local characterView = buildCharacterView(slot, characterId, staticData, errors)
if characterView ~= nil then characters[#characters + 1] = characterView end
end
return {
interactionToken = runState.characterOffer.interactionToken,
characters = characters,
}
end
local function validateString(value, path, errors)
if type(value) ~= "string" or value == "" then
addError(errors, "invalid_text", path, "비어 있지 않은 문자열이어야 합니다.")
end
end
local function validateStationView(value, path, errors)
if type(value) ~= "table" then
addError(errors, "invalid_station_view", path, "역 View가 테이블이 아닙니다.")
return
end
checkAllowedKeys(value, { id = true, code = true, name = true }, path, errors)
if not isAsciiId(value.id) then
addError(errors, "invalid_station_id", path .. ".id", "역 ID가 올바르지 않습니다.")
end
validateString(value.code, path .. ".code", errors)
validateString(value.name, path .. ".name", errors)
end
local function validateTagView(value, path, errors, expectedKind)
if type(value) ~= "table" then
addError(errors, "invalid_tag_view", path, "태그 View가 테이블이 아닙니다.")
return
end
checkAllowedKeys(value, {
kind = true,
id = true,
label = true,
tagKind = true,
tooltip = true,
}, path, errors)
if value.kind ~= "tag" or not isAsciiId(value.id) then
addError(errors, "invalid_tag_identity", path, "태그 View 식별자가 올바르지 않습니다.")
end
if value.tagKind ~= "type" and value.tagKind ~= "role" and value.tagKind ~= "mechanism" and value.tagKind ~= "term" then
addError(errors, "invalid_tag_kind", path .. ".tagKind", "태그 종류가 올바르지 않습니다.")
elseif expectedKind ~= nil and value.tagKind ~= expectedKind then
addError(errors, "tag_kind_mismatch", path .. ".tagKind", "이 위치의 태그 종류가 다릅니다.")
end
validateString(value.label, path .. ".label", errors)
validateString(value.tooltip, path .. ".tooltip", errors)
end
local function validateSegments(value, path, errors)
local length = getArrayLength(value, path, errors)
if length == nil then return end
for index = 1, length do
local segment = value[index]
local segmentPath = path .. "[" .. index .. "]"
if type(segment) ~= "table" then
addError(errors, "invalid_segment", segmentPath, "문장 조각이 테이블이 아닙니다.")
elseif segment.kind == "text" then
checkAllowedKeys(segment, { kind = true, value = true }, segmentPath, errors)
validateString(segment.value, segmentPath .. ".value", errors)
elseif segment.kind == "tag" then
validateTagView(segment, segmentPath, errors)
else
addError(errors, "invalid_segment_kind", segmentPath .. ".kind", "문장 조각 종류가 올바르지 않습니다.")
end
end
end
local function validateRuleLines(value, path, errors)
local length = getArrayLength(value, path, errors)
if length == nil then return end
if length < 1 then
addError(errors, "empty_rule_lines", path, "카드 규칙은 한 줄 이상이어야 합니다.")
end
for index = 1, length do
local line = value[index]
local linePath = path .. "[" .. index .. "]"
if type(line) ~= "table" then
addError(errors, "invalid_rule_line", linePath, "규칙 줄이 테이블이 아닙니다.")
else
checkAllowedKeys(line, { segments = true }, linePath, errors)
validateSegments(line.segments, linePath .. ".segments", errors)
end
end
end
local function validateCardView(card, path, expectedSlot, errors, allowFullCopies)
if type(card) ~= "table" then
addError(errors, "invalid_card_view", path, "보상 카드 View가 테이블이 아닙니다.")
return
end
checkAllowedKeys(card, {
slot = true,
cardId = true,
name = true,
rarity = true,
draftStyle = true,
descriptionSegments = true,
ruleLines = true,
cardType = true,
roles = true,
mechanisms = true,
terms = true,
baseStealthCost = true,
baseResistanceDamage = true,
ownedCopies = true,
maxCopies = true,
}, path, errors)
if card.slot ~= expectedSlot then
addError(errors, "card_slot_mismatch", path .. ".slot", "카드 슬롯이 배열 순서와 다릅니다.")
end
if not isAsciiId(card.cardId) then
addError(errors, "invalid_card_id", path .. ".cardId", "카드 ID가 올바르지 않습니다.")
end
validateString(card.name, path .. ".name", errors)
validateSegments(card.descriptionSegments, path .. ".descriptionSegments", errors)
validateRuleLines(card.ruleLines, path .. ".ruleLines", errors)
validateTagView(card.cardType, path .. ".cardType", errors, "type")
local roleCount = getArrayLength(card.roles, path .. ".roles", errors)
if roleCount ~= nil then
if roleCount < 1 or roleCount > 2 then
addError(errors, "invalid_card_roles", path .. ".roles", "플레이어 카드는 역할 태그를 하나 또는 둘 가져야 합니다.")
end
for index = 1, roleCount do
validateTagView(card.roles[index], path .. ".roles[" .. index .. "]", errors, "role")
end
end
local mechanismCount = getArrayLength(card.mechanisms, path .. ".mechanisms", errors)
if mechanismCount ~= nil then
local seen = {}
for index = 1, mechanismCount do
local mechanism = card.mechanisms[index]
validateTagView(mechanism, path .. ".mechanisms[" .. index .. "]", errors, "mechanism")
if type(mechanism) == "table" and type(mechanism.id) == "string" then
if seen[mechanism.id] then
addError(errors, "duplicate_mechanism", path .. ".mechanisms[" .. index .. "]", "메커니즘이 중복되었습니다.")
end
seen[mechanism.id] = true
end
end
end
local termCount = getArrayLength(card.terms, path .. ".terms", errors)
if termCount ~= nil then
local seen = {}
for index = 1, termCount do
local term = card.terms[index]
validateTagView(term, path .. ".terms[" .. index .. "]", errors, "term")
if type(term) == "table" and type(term.id) == "string" then
if seen[term.id] then
addError(errors, "duplicate_term", path .. ".terms[" .. index .. "]", "규칙 용어가 중복되었습니다.")
end
seen[term.id] = true
end
end
end
if not isFinite(card.baseStealthCost) or card.baseStealthCost < 0 then
addError(errors, "invalid_stealth_cost", path .. ".baseStealthCost", "기본 은폐 비용이 올바르지 않습니다.")
end
if not isFinite(card.baseResistanceDamage) or card.baseResistanceDamage < 0 then
addError(errors, "invalid_resistance_damage", path .. ".baseResistanceDamage", "기본 저항 피해가 올바르지 않습니다.")
end
if card.rarity ~= "common" and card.rarity ~= "rare" and card.rarity ~= "legendary" then
addError(errors, "invalid_card_rarity", path .. ".rarity", "카드 희귀도가 올바르지 않습니다.")
end
if card.draftStyle ~= "predator"
and card.draftStyle ~= "harmonizer"
and card.draftStyle ~= "glutton"
and card.draftStyle ~= "deceiver" then
addError(errors, "invalid_draft_style", path .. ".draftStyle", "카드 드래프트 스타일이 올바르지 않습니다.")
end
local expectedMaxCopies = card.rarity == "legendary" and 1 or 2
if card.maxCopies ~= expectedMaxCopies then
addError(errors, "invalid_max_copies", path .. ".maxCopies", "희귀도에 따른 카드 보유 제한이 올바르지 않습니다.")
end
local ownedMaximum = allowFullCopies and expectedMaxCopies or expectedMaxCopies - 1
if not isInteger(card.ownedCopies, allowFullCopies and 1 or 0, ownedMaximum) then
addError(errors, "invalid_owned_copies", path .. ".ownedCopies", "카드 보유 수가 카드별 제한 범위를 벗어났습니다.")
end
end
local function validateCharacterView(character, path, expectedSlot, errors)
if type(character) ~= "table" then
addError(errors, "invalid_character_view", path, "캐릭터 View가 테이블이 아닙니다.")
return
end
checkAllowedKeys(character, {
slot = true,
characterId = true,
name = true,
age = true,
occupation = true,
appearanceSummary = true,
startingResistance = true,
turnLimit = true,
startingMood = true,
baseDrawCount = true,
maxHandSize = true,
traits = true,
}, path, errors)
if character.slot ~= expectedSlot then
addError(errors, "character_slot_mismatch", path .. ".slot", "캐릭터 슬롯이 배열 순서와 다릅니다.")
end
if not isAsciiId(character.characterId) then
addError(errors, "invalid_character_id", path .. ".characterId", "캐릭터 ID가 올바르지 않습니다.")
end
validateString(character.name, path .. ".name", errors)
if not isInteger(character.age, 1) then
addError(errors, "invalid_character_age", path .. ".age", "캐릭터 나이가 올바르지 않습니다.")
end
validateString(character.occupation, path .. ".occupation", errors)
validateString(character.appearanceSummary, path .. ".appearanceSummary", errors)
if not isFinite(character.startingResistance) or character.startingResistance <= 0 then
addError(errors, "invalid_starting_resistance", path .. ".startingResistance", "시작 저항은 양수여야 합니다.")
end
if not isInteger(character.turnLimit, 7, 12) then
addError(errors, "invalid_turn_limit", path .. ".turnLimit", "제한 턴은 7 이상 12 이하의 정수여야 합니다.")
end
if type(character.startingMood) ~= "table" then
addError(errors, "invalid_starting_mood", path .. ".startingMood", "시작 무드 View가 필요합니다.")
else
checkAllowedKeys(character.startingMood, { id = true, label = true }, path .. ".startingMood", errors)
if not isAsciiId(character.startingMood.id) then
addError(errors, "invalid_mood_id", path .. ".startingMood.id", "무드 ID가 올바르지 않습니다.")
end
validateString(character.startingMood.label, path .. ".startingMood.label", errors)
end
if not isInteger(character.baseDrawCount, 1)
or not isInteger(character.maxHandSize, 1)
or (isInteger(character.baseDrawCount, 1)
and isInteger(character.maxHandSize, 1)
and character.baseDrawCount > character.maxHandSize) then
addError(errors, "invalid_character_hand_values", path, "드로우와 손패 상한이 올바르지 않습니다.")
end
local traitCount = getArrayLength(character.traits, path .. ".traits", errors)
if traitCount ~= nil then
local seen = {}
for index = 1, traitCount do
local trait = character.traits[index]
local traitPath = path .. ".traits[" .. index .. "]"
if type(trait) ~= "table" then
addError(errors, "invalid_trait_view", traitPath, "특징 View가 테이블이 아닙니다.")
else
checkAllowedKeys(trait, { id = true, name = true, description = true }, traitPath, errors)
if not isAsciiId(trait.id) then
addError(errors, "invalid_trait_id", traitPath .. ".id", "특징 ID가 올바르지 않습니다.")
elseif seen[trait.id] then
addError(errors, "duplicate_trait", traitPath .. ".id", "특징이 중복되었습니다.")
else
seen[trait.id] = true
end
validateString(trait.name, traitPath .. ".name", errors)
validateString(trait.description, traitPath .. ".description", errors)
end
end
end
end
local function validateRunProgressionView(view)
local errors = {}
validateJsonSafe(view, "$", errors)
if #errors > 0 then return failure(errors) end
if type(view) ~= "table" or getmetatable(view) ~= nil then
addError(errors, "invalid_view_root", "$", "runProgressionView 최상위 값은 일반 테이블이어야 합니다.")
return failure(errors)
end
checkAllowedKeys(view, {
schemaVersion = true,
kind = true,
phase = true,
sessionIndex = true,
stats = true,
deck = true,
result = true,
rewardOffer = true,
characterOffer = true,
selectedCharacter = true,
}, "$", errors)
if view.schemaVersion ~= SCHEMA_VERSION then
addError(errors, "unsupported_schema", "$.schemaVersion", "지원하지 않는 runProgressionView 스키마입니다.")
end
if view.kind ~= VIEW_KIND then
addError(errors, "invalid_view_kind", "$.kind", "View kind가 runProgressionView가 아닙니다.")
end
if VALID_PHASES[view.phase] ~= true then
addError(errors, "invalid_phase", "$.phase", "지원하지 않는 View phase입니다.")
end
if not isInteger(view.sessionIndex, 1) then
addError(errors, "invalid_session_index", "$.sessionIndex", "세션 순번은 1 이상의 정수여야 합니다.")
end
if type(view.stats) ~= "table" then
addError(errors, "invalid_stats", "$.stats", "누적 전적 View가 필요합니다.")
else
checkAllowedKeys(view.stats, {
completed = true,
victories = true,
defeats = true,
}, "$.stats", errors)
for _, field in ipairs({ "completed", "victories", "defeats" }) do
if not isInteger(view.stats[field], 0) then
addError(errors, "invalid_stat", "$.stats." .. field, "누적 전적은 0 이상의 정수여야 합니다.")
end
end
if isInteger(view.stats.completed, 0)
and isInteger(view.stats.victories, 0)
and isInteger(view.stats.defeats, 0)
and view.stats.completed ~= view.stats.victories + view.stats.defeats then
addError(errors, "stats_total_mismatch", "$.stats", "완료 수가 승리와 패배 합과 다릅니다.")
end
end
if type(view.deck) ~= "table" then
addError(errors, "invalid_deck", "$.deck", "덱 요약 View가 필요합니다.")
else
checkAllowedKeys(view.deck, {
count = true,
limit = true,
averageCost = true,
items = true,
}, "$.deck", errors)
if not isInteger(view.deck.count, DECK_MIN, DECK_MAX) then
addError(errors, "invalid_deck_count", "$.deck.count", "덱 수는 10장 이상 20장 이하여야 합니다.")
end
if view.deck.limit ~= DECK_MAX then
addError(errors, "invalid_deck_limit", "$.deck.limit", "덱 상한 표시는 20이어야 합니다.")
end
if not isFinite(view.deck.averageCost) or view.deck.averageCost < 0 then
addError(errors, "invalid_deck_average_cost", "$.deck.averageCost", "덱 평균 은폐 비용이 올바르지 않습니다.")
end
local itemCount = getArrayLength(view.deck.items, "$.deck.items", errors)
if itemCount ~= nil then
local seen = {}
local copies = 0
local totalCost = 0
for index = 1, itemCount do
local card = view.deck.items[index]
validateCardView(card, "$.deck.items[" .. index .. "]", index, errors, true)
if type(card) == "table" and type(card.cardId) == "string" then
if seen[card.cardId] then
addError(errors, "duplicate_deck_card", "$.deck.items[" .. index .. "].cardId", "덱 카드가 중복 집계되었습니다.")
end
seen[card.cardId] = true
end
if type(card) == "table"
and isInteger(card.ownedCopies, 1)
and isFinite(card.baseStealthCost) then
copies = copies + card.ownedCopies
totalCost = totalCost + card.baseStealthCost * card.ownedCopies
end
end
if isInteger(view.deck.count, DECK_MIN, DECK_MAX) and copies ~= view.deck.count then
addError(errors, "deck_copy_sum_mismatch", "$.deck.items", "덱 카드 장수 합계가 덱 수와 다릅니다.")
elseif copies > 0 and isFinite(view.deck.averageCost) then
local expectedAverage = math.floor(totalCost / copies * 10 + 0.5) / 10
if view.deck.averageCost ~= expectedAverage then
addError(errors, "deck_average_cost_mismatch", "$.deck.averageCost", "덱 평균 은폐 비용이 카드 구성과 다릅니다.")
end
end
end
end
if type(view.result) ~= "table" then
addError(errors, "invalid_result", "$.result", "최근 세션 결과 View가 필요합니다.")
else
checkAllowedKeys(view.result, {
sessionNumber = true,
battleId = true,
status = true,
statusLabel = true,
headline = true,
reasonCode = true,
reasonLabel = true,
character = true,
turnNumber = true,
turnLimit = true,
finalStealth = true,
finalResistance = true,
route = true,
}, "$.result", errors)
if not isInteger(view.result.sessionNumber, 1) then
addError(errors, "invalid_result_session", "$.result.sessionNumber", "결과 세션 번호가 올바르지 않습니다.")
elseif type(view.stats) == "table"
and isInteger(view.stats.completed, 0)
and view.result.sessionNumber ~= view.stats.completed then
addError(errors, "result_session_mismatch", "$.result.sessionNumber", "결과 세션 번호와 완료 전적이 다릅니다.")
end
if not isRuntimeId(view.result.battleId) then
addError(errors, "invalid_result_battle", "$.result.battleId", "결과 battleId가 올바르지 않습니다.")
end
if VALID_OUTCOMES[view.result.status] ~= true then
addError(errors, "invalid_result_status", "$.result.status", "결과 상태가 올바르지 않습니다.")
end
validateString(view.result.statusLabel, "$.result.statusLabel", errors)
validateString(view.result.headline, "$.result.headline", errors)
if REASON_LABELS[view.result.reasonCode] == nil then
addError(errors, "invalid_result_reason", "$.result.reasonCode", "결과 종료 사유가 올바르지 않습니다.")
end
validateString(view.result.reasonLabel, "$.result.reasonLabel", errors)
if type(view.result.character) ~= "table" then
addError(errors, "invalid_result_character", "$.result.character", "결과 상대 View가 필요합니다.")
else
checkAllowedKeys(view.result.character, { id = true, name = true }, "$.result.character", errors)
if not isAsciiId(view.result.character.id) then
addError(errors, "invalid_character_id", "$.result.character.id", "결과 상대 ID가 올바르지 않습니다.")
end
validateString(view.result.character.name, "$.result.character.name", errors)
end
if not isInteger(view.result.turnNumber, 1)
or not isInteger(view.result.turnLimit, 1)
or (isInteger(view.result.turnNumber, 1)
and isInteger(view.result.turnLimit, 1)
and view.result.turnNumber > view.result.turnLimit) then
addError(errors, "invalid_result_turn", "$.result", "결과 턴 수치가 올바르지 않습니다.")
end
if not isFinite(view.result.finalStealth)
or not isFinite(view.result.finalResistance) then
addError(errors, "invalid_result_resources", "$.result", "최종 자원 수치가 올바르지 않습니다.")
end
if type(view.result.route) ~= "table" then
addError(errors, "invalid_route_view", "$.result.route", "결과 노선 View가 필요합니다.")
else
checkAllowedKeys(view.result.route, {
lineId = true,
lineName = true,
lineCode = true,
lineColor = true,
operatorName = true,
startStation = true,
reachedStation = true,
destinationStation = true,
}, "$.result.route", errors)
if not isAsciiId(view.result.route.lineId) then
addError(errors, "invalid_line_id", "$.result.route.lineId", "노선 ID가 올바르지 않습니다.")
end
for _, field in ipairs({ "lineName", "lineCode", "lineColor", "operatorName" }) do
validateString(view.result.route[field], "$.result.route." .. field, errors)
end
validateStationView(view.result.route.startStation, "$.result.route.startStation", errors)
validateStationView(view.result.route.reachedStation, "$.result.route.reachedStation", errors)
validateStationView(view.result.route.destinationStation, "$.result.route.destinationStation", errors)
end
end
if view.phase == "reward" then
if type(view.rewardOffer) ~= "table" then
addError(errors, "missing_reward_offer", "$.rewardOffer", "보상 단계에는 보상 제안 View가 필요합니다.")
else
checkAllowedKeys(view.rewardOffer, {
kind = true,
interactionToken = true,
count = true,
cards = true,
}, "$.rewardOffer", errors)
if view.rewardOffer.kind ~= "card" and view.rewardOffer.kind ~= "none" then
addError(errors, "invalid_reward_kind", "$.rewardOffer.kind", "보상 종류가 올바르지 않습니다.")
end
if not isInteractionToken(view.rewardOffer.interactionToken) then
addError(errors, "invalid_interaction_token", "$.rewardOffer.interactionToken", "보상 token이 올바르지 않습니다.")
end
local cardCount = getArrayLength(view.rewardOffer.cards, "$.rewardOffer.cards", errors)
if cardCount ~= nil then
if view.rewardOffer.count ~= cardCount then
addError(errors, "reward_count_mismatch", "$.rewardOffer.count", "보상 카드 수 요약이 배열과 다릅니다.")
end
if view.rewardOffer.kind == "card"
and (cardCount < 1 or cardCount > REWARD_OFFER_MAX) then
addError(errors, "invalid_reward_card_count", "$.rewardOffer.cards", "카드 보상은 한 장 이상 세 장 이하여야 합니다.")
elseif view.rewardOffer.kind == "none" and cardCount ~= 0 then
addError(errors, "unexpected_reward_cards", "$.rewardOffer.cards", "none 보상에는 카드가 없어야 합니다.")
end
local seenCards = {}
for index = 1, cardCount do
local card = view.rewardOffer.cards[index]
validateCardView(card, "$.rewardOffer.cards[" .. index .. "]", index, errors)
if type(card) == "table" and type(card.cardId) == "string" then
if seenCards[card.cardId] then
addError(errors, "duplicate_reward_card", "$.rewardOffer.cards[" .. index .. "]", "보상 카드가 중복되었습니다.")
end
seenCards[card.cardId] = true
end
end
end
end
if view.characterOffer ~= nil or view.selectedCharacter ~= nil then
addError(errors, "unexpected_phase_view", "$", "보상 단계에 상대 선택 View를 둘 수 없습니다.")
end
elseif view.phase == "characterSelect" then
if type(view.characterOffer) ~= "table" then
addError(errors, "missing_character_offer", "$.characterOffer", "상대 선택 View가 필요합니다.")
else
checkAllowedKeys(view.characterOffer, {
interactionToken = true,
characters = true,
}, "$.characterOffer", errors)
if not isInteractionToken(view.characterOffer.interactionToken) then
addError(errors, "invalid_interaction_token", "$.characterOffer.interactionToken", "상대 선택 token이 올바르지 않습니다.")
end
local characterCount = getArrayLength(view.characterOffer.characters, "$.characterOffer.characters", errors)
if characterCount ~= nil then
if characterCount ~= CHARACTER_OFFER_SIZE then
addError(errors, "invalid_character_offer_size", "$.characterOffer.characters", "다음 상대는 정확히 세 명이어야 합니다.")
end
local seenCharacters = {}
for index = 1, characterCount do
local character = view.characterOffer.characters[index]
validateCharacterView(character, "$.characterOffer.characters[" .. index .. "]", index, errors)
if type(character) == "table" and type(character.characterId) == "string" then
if seenCharacters[character.characterId] then
addError(errors, "duplicate_character", "$.characterOffer.characters[" .. index .. "]", "같은 상대가 중복되었습니다.")
end
seenCharacters[character.characterId] = true
end
end
end
end
if view.rewardOffer ~= nil or view.selectedCharacter ~= nil then
addError(errors, "unexpected_phase_view", "$", "상대 선택 단계에 보상 또는 선택 완료 View를 둘 수 없습니다.")
end
elseif view.phase == "battleReady" then
if type(view.selectedCharacter) ~= "table" then
addError(errors, "missing_selected_character", "$.selectedCharacter", "선택 완료 상대 View가 필요합니다.")
else
checkAllowedKeys(view.selectedCharacter, { characterId = true, name = true }, "$.selectedCharacter", errors)
if not isAsciiId(view.selectedCharacter.characterId) then
addError(errors, "invalid_character_id", "$.selectedCharacter.characterId", "선택 상대 ID가 올바르지 않습니다.")
end
validateString(view.selectedCharacter.name, "$.selectedCharacter.name", errors)
end
if view.rewardOffer ~= nil or view.characterOffer ~= nil then
addError(errors, "unexpected_phase_view", "$", "전투 준비 단계에 제안 View를 둘 수 없습니다.")
end
end
if #errors > 0 then return failure(errors) end
return success("valid", true)
end
local function buildCanonicalView(runState, setupState, staticInput)
local staticData, inputErrors = inspectCanonicalInputs(runState, setupState, staticInput)
if inputErrors then return failure(inputErrors) end
local errors = {}
local statsCopy, statsError = cloneJson(runState.stats, "$.stats")
if statsError then return failure({ statsError }) end
local resultView = buildResultView(runState, staticData, errors)
local view = {
schemaVersion = SCHEMA_VERSION,
kind = VIEW_KIND,
phase = runState.phase,
sessionIndex = runState.sessionNumber,
stats = statsCopy,
deck = buildDeckView(runState, staticData, errors),
result = resultView,
}
if runState.phase == "reward" then
view.rewardOffer = buildRewardOfferView(runState, staticData, errors)
elseif runState.phase == "characterSelect" then
view.characterOffer = buildCharacterOfferView(runState, staticData, errors)
elseif runState.phase == "battleReady" then
local characterId = type(runState.battleSpec) == "table"
and runState.battleSpec.characterId
or nil
local character = staticData.characters[characterId]
if type(character) ~= "table" then
addError(errors, "unknown_selected_character", "$.selectedCharacter", "선택한 상대 공개 정보를 찾을 수 없습니다.")
else
view.selectedCharacter = {
characterId = character.id,
name = character.name,
}
end
end
if #errors > 0 then return failure(errors) end
local validation = validateRunProgressionView(view)
if validation.ok ~= true then return validation end
return success("view", view)
end
local function buildPublic(runInput, setupInput, staticInput)
local setupReport, setupCallError = callRuntime(
"gameSetup",
"validate",
setupInput,
staticInput
)
if setupCallError then return failure({ setupCallError }) end
if setupReport.ok ~= true or type(setupReport.state) ~= "table" then
local errors = {}
appendNestedErrors(errors, "$.setupState", setupReport)
return failure(errors)
end
if not deepEqual(setupInput, setupReport.state) then
return failure({
{
code = "setup_validation_mismatch",
path = "$.setupState",
message = "gameSetup.validate의 canonical 상태가 입력과 정확히 일치하지 않습니다.",
},
})
end
local runReport, runCallError = callRuntime(
"runProgression",
"validate",
runInput,
setupReport.state,
staticInput
)
if runCallError then return failure({ runCallError }) end
if runReport.ok ~= true or type(runReport.state) ~= "table" then
local errors = {}
appendNestedErrors(errors, "$.runState", runReport)
return failure(errors)
end
if not deepEqual(runInput, runReport.state) then
return failure({
{
code = "run_validation_mismatch",
path = "$.runState",
message = "runProgression.validate의 canonical 상태가 입력과 정확히 일치하지 않습니다.",
},
})
end
return buildCanonicalView(runReport.state, setupReport.state, staticInput)
end
local function capabilityAllows(capability)
if type(capability) ~= "function" then return false end
local ok, allowed = pcall(capability, "runProgressionViewCanonicalV1")
return ok and allowed == true
end
local arguments = { ... }
if action == "validate" then
return validateRunProgressionView(arguments[1])
elseif action == "build" then
return buildPublic(arguments[1], arguments[2], arguments[3])
elseif action == "_buildCanonical" then
if not capabilityAllows(arguments[4]) then
return failure({
{
code = "internal_action_denied",
path = "$.action",
message = "내부 canonical View 작업에 접근할 수 없습니다.",
},
})
end
return buildCanonicalView(arguments[1], arguments[2], arguments[3])
end
return failure({
{
code = "unknown_action",
path = "$.action",
message = "지원하지 않는 runProgressionView 작업입니다: " .. tostring(action),
},
})
end)
#46runtime.lua
Keys:
(function()
--기본 변수
DEBUG = 2 --디버그 메시지 depth. 숫자가 클수록 덜 중요하고 디테일 한 메시지.
--디버깅
function debug(depth, ...)
if depth <= DEBUG then
print(...)
end
end
--tonumber를 콤마제거후 숫자로 인식하도록 오버라이딩
old_tonumber = tonumber
tonumber = function(str, base)
if type(str) == "string" then
local cleaned_str = string.gsub(str, ",", "")
return old_tonumber(cleaned_str, base)
else
return old_tonumber(str, base)
end
end
--json을 chatVar 형식으로 저장
function toChatVar(triggerId, name, data)
if data == nil then
data = HostCompat.readState(triggerId, name)
end
if type(data) ~= "table" then
HostCompat.writeChatVar(triggerId, name, tostring(data))
return tostring(data)
end
local function encodeString(value)
return json.encode(tostring(value))
end
local function encodeForChatVar(value)
local parts = {}
for k, v in pairs(value) do
local encodedValue
if type(v) == "table" then
encodedValue = encodeString(encodeForChatVar(v))
else
encodedValue = encodeString(v)
end
table.insert(parts, encodeString(k) .. ":" .. encodedValue)
end
return "{" .. table.concat(parts, ",") .. "}"
end
local encoded = encodeForChatVar(data)
HostCompat.writeChatVar(triggerId, name, encoded)
return encoded
end
--chatVar를 state 형식으로 저장
function toState(triggerId, name)
local source = getChatVar(triggerId, name)
if not source or source == "" then
debug(1, "toState error: chat var " .. tostring(name) .. " is empty.")
local empty = {}
HostCompat.writeState(triggerId, name, empty)
return empty
end
local function tryDecode(value)
if type(value) ~= "string" then
return nil
end
local trimmed = value:match("^%s*(.-)%s*$")
local first = trimmed:sub(1, 1)
if first ~= "{" and first ~= "[" then
return nil
end
local ok, decoded = pcall(json.decode, trimmed)
if ok and type(decoded) == "table" then
return decoded
end
return nil
end
local function decodeFromChatVar(value)
if type(value) == "table" then
local decoded = {}
for k, v in pairs(value) do
decoded[k] = decodeFromChatVar(v)
end
return decoded
end
local decoded = tryDecode(value)
if decoded then
return decodeFromChatVar(decoded)
end
return value
end
local root = tryDecode(source)
if not root then
HostCompat.writeState(triggerId, name, source)
return source
end
local decoded = decodeFromChatVar(root)
HostCompat.writeState(triggerId, name, decoded)
return decoded
end
local function stripHtmlLineIndent(source)
source = source:gsub("^[ \t]+", "")
source = source:gsub("\r\n[ \t]+", "\r\n")
source = source:gsub("\n[ \t]+", "\n")
source = source:gsub("\r[ \t]+", "\r")
return source
end
--로어북에서 내용을 불러와 return
function loadLores(triggerId, lore)
local targetLores = getLoreBooks(triggerId, lore)
if type(targetLores) ~= "table" then
return nil
end
local contents = {}
for _, loreEntry in ipairs(targetLores) do
table.insert(contents, loreEntry.content)
end
local returnContents = table.concat(contents)
--주석 제거
returnContents = returnContents
:gsub("%-%-%-[^\r\n]*", "")
if type(lore) == "string" and string.match(lore, "%.html$") then
returnContents = stripHtmlLineIndent(returnContents)
end
if returnContents == "" then
return nil
else
return returnContents
end
end
-- Executable lore entries are complete modules, not mergeable fragments. RisuAI
-- returns matches in local -> global -> module order. This game's authoritative
-- runtime bundle is the module entry, so the last non-empty match must replace
-- stale character/global copies. Concatenating duplicate modules can turn two
-- adjacent anonymous functions into an accidental function call.
local function loadScriptLore(triggerId, script)
local loreName = script .. ".lua"
local targetLores = getLoreBooks(triggerId, loreName)
if type(targetLores) ~= "table" then
return nil
end
local source = nil
local sourceCount = 0
for _, loreEntry in ipairs(targetLores) do
local content = type(loreEntry) == "table" and loreEntry.content or nil
if type(content) == "string" and content ~= "" then
sourceCount = sourceCount + 1
source = content
end
end
if sourceCount > 1 then
debug(2, "runScript warning: duplicate lorebook '" .. loreName
.. "'; using the last match.")
end
if source == nil then
return nil
end
return source:gsub("%-%-%-[^\r\n]*", "")
end
-- 배포 시 executable Lua lore 또는 static DB가 바뀌면 이 revision도 반드시 올린다. production
-- warm path는 이 명시적 계약 덕분에 이벤트 사이에서 getLoreBooks/CBS bridge를
-- 생략한다. 개발 중에는 setRunScriptCacheDevelopmentMode(true)를 사용하면 매
-- 이벤트의 첫 모듈 호출에서 source를 다시 확인한다.
RUNTIME_BUNDLE_REVISION = RUNTIME_BUNDLE_REVISION
or "runtime-bundle-main-split-v1-20260804"
RUNTIME_CACHE_DEVELOPMENT_BYPASS = RUNTIME_CACHE_DEVELOPMENT_BYPASS == true
local RUN_SCRIPT_SOURCE_CACHE_MAX_ENTRIES = 64
local RUN_SCRIPT_WARM_CACHE_MAX_ENTRIES = 128
local RUN_SCRIPT_TRANSACTION_MAX_ENTRIES = 64
local RUN_SCRIPT_NAMESPACE_VAR = "runtimeModuleCacheV1.namespace"
local function fingerprintRunScriptIdentity(source)
local first = 0
local second = 0
for index = 1, #source do
local byte = string.byte(source, index)
first = (first * 131 + byte) % 2147483647
second = (second * 137 + byte + index) % 2147483629
end
return tostring(#source) .. ":" .. tostring(first) .. ":" .. tostring(second)
end
local function runtimeCacheKeyPart(value)
local text = tostring(value or "")
return tostring(#text) .. ":" .. text
end
local function makeRunScriptWarmKey(event, script)
return table.concat({
runtimeCacheKeyPart(event.bundleRevision),
runtimeCacheKeyPart(event.mode),
runtimeCacheKeyPart(event.namespace),
runtimeCacheKeyPart(event.characterIdentity),
runtimeCacheKeyPart(script),
}, "|")
end
local function touchRunScriptCacheEntry(entry)
runScriptCacheClock = runScriptCacheClock + 1
entry.lastUsed = runScriptCacheClock
end
local function currentRunScriptBundleRevision()
local revision = tostring(RUNTIME_BUNDLE_REVISION or "")
if revision == "" then
return "invalid-empty-revision"
end
return revision
end
local function resolveRunScriptNamespace(triggerId)
runScriptCacheStats.namespaceReads = runScriptCacheStats.namespaceReads + 1
if type(getChatVar) == "function" then
local readOk, existing = pcall(getChatVar, triggerId, RUN_SCRIPT_NAMESPACE_VAR)
if readOk
and type(existing) == "string"
and string.match(existing, "^runtime%-ns%-v1:%d+:%d+:%d+$") then
return existing
end
end
local generated = "runtime-ns-v1:" .. fingerprintRunScriptIdentity(tostring(triggerId or ""))
if type(HostCompat) == "table" and type(HostCompat.writeChatVar) == "function" then
local writeOk = pcall(HostCompat.writeChatVar, triggerId, RUN_SCRIPT_NAMESPACE_VAR, generated)
if writeOk then
runScriptCacheStats.namespaceWrites = runScriptCacheStats.namespaceWrites + 1
local readOk, stored = pcall(getChatVar, triggerId, RUN_SCRIPT_NAMESPACE_VAR)
if readOk and stored == generated then
return generated
end
end
runScriptCacheStats.namespaceWriteFailures = runScriptCacheStats.namespaceWriteFailures + 1
end
-- 권한이 없는 mode에서는 event access key fingerprint를 사용한다. access key는
-- top-level 호출마다 달라 warm hit는 포기하지만 다른 채팅과 섞이지 않는다.
runScriptCacheStats.volatileNamespaces = runScriptCacheStats.volatileNamespaces + 1
return "volatile:" .. generated
end
local function resolveRunScriptCharacterIdentity(triggerId)
local name = ""
local firstMessage = ""
if type(getName) == "function" then
local ok, value = pcall(getName, triggerId)
if ok and type(value) == "string" then
name = value
end
end
if type(getCharacterFirstMessage) == "function" then
local ok, value = pcall(getCharacterFirstMessage, triggerId)
if ok and type(value) == "string" then
firstMessage = value
end
end
return fingerprintRunScriptIdentity(name .. "\0" .. firstMessage)
end
-- 모든 host hook의 시작에서 호출한다. namespace/character host read는 실제로
-- runScript가 호출될 때까지 지연하므로 editInput 같은 가벼운 hook에는 비용이 없다.
function beginRunScriptEvent(triggerId, mode)
currentRuntimeMode = type(mode) == "string" and mode ~= "" and mode or "unscoped"
activeRuntimeEvent = {
triggerId = triggerId,
mode = currentRuntimeMode,
bundleRevision = currentRunScriptBundleRevision(),
cacheEpoch = runScriptCacheEpoch,
handlers = {},
handlerCount = 0,
}
runScriptCacheStats.events = runScriptCacheStats.events + 1
return currentRuntimeMode
end
local function ensureRunScriptEvent(triggerId)
local revision = currentRunScriptBundleRevision()
if activeRuntimeEvent == nil
or activeRuntimeEvent.triggerId ~= triggerId
or activeRuntimeEvent.bundleRevision ~= revision
or activeRuntimeEvent.cacheEpoch ~= runScriptCacheEpoch then
beginRunScriptEvent(triggerId, currentRuntimeMode)
end
if activeRuntimeEvent.namespace == nil then
activeRuntimeEvent.namespace = resolveRunScriptNamespace(triggerId)
activeRuntimeEvent.characterIdentity = resolveRunScriptCharacterIdentity(triggerId)
end
return activeRuntimeEvent
end
local function evictOldestRunScriptSourceEntry()
if runScriptSourceCacheSize < RUN_SCRIPT_SOURCE_CACHE_MAX_ENTRIES then
return
end
local oldestScript = nil
local oldestSource = nil
local oldestEntry = nil
for scriptName, bucket in pairs(runScriptSourceBuckets) do
for source, entry in pairs(bucket) do
if oldestEntry == nil or entry.lastUsed < oldestEntry.lastUsed then
oldestScript = scriptName
oldestSource = source
oldestEntry = entry
end
end
end
if oldestEntry ~= nil then
local bucket = runScriptSourceBuckets[oldestScript]
bucket[oldestSource] = nil
if next(bucket) == nil then
runScriptSourceBuckets[oldestScript] = nil
end
runScriptSourceCacheSize = runScriptSourceCacheSize - 1
runScriptCacheStats.sourceEvictions = runScriptCacheStats.sourceEvictions + 1
end
end
local function instantiateRunScriptHandler(script, source)
local bucket = runScriptSourceBuckets[script]
local entry = bucket and bucket[source] or nil
local chunk = nil
if entry ~= nil then
runScriptCacheStats.sourceHits = runScriptCacheStats.sourceHits + 1
entry.hits = entry.hits + 1
touchRunScriptCacheEntry(entry)
chunk = entry.chunk
else
runScriptCacheStats.sourceMisses = runScriptCacheStats.sourceMisses + 1
local functionString = "return" .. source
debug(3, functionString)
local err = nil
chunk, err = load(functionString, "lore_function:" .. tostring(script), "t", _G)
if not chunk then
runScriptCacheStats.compileFailures = runScriptCacheStats.compileFailures + 1
debug(1, "컴파일 오류: " .. (err or "알 수 없음"))
return nil
end
runScriptCacheStats.compiles = runScriptCacheStats.compiles + 1
end
-- compiled chunk는 context 사이에 공유해도 handler closure는 namespace마다 새로
-- 만든다. 모듈이 outer local cache를 가져도 다른 채팅과 mutable state가 섞이지 않는다.
local ok, handler = pcall(chunk)
if not ok then
runScriptCacheStats.loadFailures = runScriptCacheStats.loadFailures + 1
debug(1, "스크립트 로드 오류: " .. tostring(handler))
if entry ~= nil then
bucket[source] = nil
runScriptSourceCacheSize = runScriptSourceCacheSize - 1
end
return nil
end
if type(handler) ~= "function" then
runScriptCacheStats.invalidHandlers = runScriptCacheStats.invalidHandlers + 1
debug(1, "runScript error: lorebook '" .. script .. "' did not return a function.")
if entry ~= nil then
bucket[source] = nil
runScriptSourceCacheSize = runScriptSourceCacheSize - 1
end
return nil
end
if entry == nil then
evictOldestRunScriptSourceEntry()
bucket = runScriptSourceBuckets[script]
if bucket == nil then
bucket = {}
runScriptSourceBuckets[script] = bucket
end
entry = {
chunk = chunk,
sourceLength = #source,
sourceFingerprint = fingerprintRunScriptIdentity(source),
hits = 0,
}
touchRunScriptCacheEntry(entry)
bucket[source] = entry
runScriptSourceCacheSize = runScriptSourceCacheSize + 1
end
return handler, entry.sourceFingerprint
end
local function evictOldestRunScriptWarmEntry()
if runScriptWarmCacheSize < RUN_SCRIPT_WARM_CACHE_MAX_ENTRIES then
return
end
local oldestKey = nil
local oldestEntry = nil
for key, entry in pairs(runScriptWarmCache) do
if oldestEntry == nil or entry.lastUsed < oldestEntry.lastUsed then
oldestKey = key
oldestEntry = entry
end
end
if oldestEntry ~= nil then
runScriptWarmCache[oldestKey] = nil
runScriptWarmCacheSize = runScriptWarmCacheSize - 1
runScriptCacheStats.warmEvictions = runScriptCacheStats.warmEvictions + 1
end
end
function setRunScriptCacheDevelopmentMode(enabled)
local nextValue = enabled == true
if RUNTIME_CACHE_DEVELOPMENT_BYPASS ~= nextValue then
RUNTIME_CACHE_DEVELOPMENT_BYPASS = nextValue
-- dev에서 관측한 source와 기존 production warm handler가 엇갈리지 않도록
-- 모드 전환 시 warm layer만 폐기한다. compiled source cache는 안전하게 재사용한다.
runScriptWarmCache = {}
runScriptWarmCacheSize = 0
runScriptCacheEpoch = runScriptCacheEpoch + 1
activeRuntimeEvent = nil
runScriptCacheStats.developmentModeChanges = runScriptCacheStats.developmentModeChanges + 1
end
return RUNTIME_CACHE_DEVELOPMENT_BYPASS
end
-- 개발 중 로어 교체나 진단 도구에서 명시적으로 캐시를 비울 수 있다.
-- script를 생략하면 전체를, 전달하면 해당 모듈의 compiled/warm entry를 제거한다.
function clearRunScriptCache(script)
if script ~= nil and type(script) ~= "string" then
return 0
end
local removedSources = 0
if script == nil then
removedSources = runScriptSourceCacheSize
runScriptSourceBuckets = {}
runScriptSourceCacheSize = 0
runScriptWarmCache = {}
runScriptWarmCacheSize = 0
else
local bucket = runScriptSourceBuckets[script]
if bucket ~= nil then
for _ in pairs(bucket) do
removedSources = removedSources + 1
end
runScriptSourceBuckets[script] = nil
runScriptSourceCacheSize = runScriptSourceCacheSize - removedSources
end
for key, entry in pairs(runScriptWarmCache) do
if entry.script == script then
runScriptWarmCache[key] = nil
runScriptWarmCacheSize = runScriptWarmCacheSize - 1
end
end
end
runScriptCacheEpoch = runScriptCacheEpoch + 1
activeRuntimeEvent = nil
runScriptCacheStats.clears = runScriptCacheStats.clears + 1
return removedSources
end
local turnInitializationDepth = 0
local function policyIsFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function policyIsInteger(value, minimum)
return policyIsFinite(value)
and value % 1 == 0
and (minimum == nil or value >= minimum)
end
local function copyPolicyTable(value)
local copy = {}
for key, item in pairs(value) do
copy[key] = item
end
return copy
end
-- 완료 이력은 직전 턴의 finish를 기록한다. 다음 턴 초기화 중에는
-- turn_start 효과가 현재 은폐·저항·무드를 합법적으로 바꿀 수 있으므로,
-- battleHistory의 연속성 비교에만 직전 finish를 투영한다. 실제 state는
-- 바꾸지 않으며 stateSchema의 나머지 검증은 원본 state를 계속 검사한다.
local function projectHistoryValidationState(history, state)
if type(history) ~= "table"
or type(history.turns) ~= "table"
or type(state) ~= "table"
or state.status ~= "active"
or not policyIsInteger(state.turnNumber, 1) then
return state, false
end
local turnCount = #history.turns
if turnCount == 0 or state.turnNumber ~= turnCount + 1 then
return state, false
end
local last = history.turns[turnCount]
local finish = type(last) == "table" and last.finish or nil
if type(finish) ~= "table"
or state.lastCommittedTurnId ~= last.turnId
or not policyIsFinite(finish.stealth)
or not policyIsFinite(finish.resistance)
or type(finish.mood) ~= "string"
or finish.status ~= "active"
or type(state.player) ~= "table"
or type(state.character) ~= "table" then
return state, false
end
local receipt = state.turnStartReceipt
if receipt ~= nil then
local baseline = type(receipt) == "table" and receipt.baseline or nil
if type(baseline) ~= "table"
or baseline.stealth ~= finish.stealth
or baseline.resistance ~= finish.resistance
or baseline.mood ~= finish.mood then
return state, false
end
end
local projected = copyPolicyTable(state)
projected.player = copyPolicyTable(state.player)
projected.character = copyPolicyTable(state.character)
projected.player.stealth = finish.stealth
projected.character.resistance = finish.resistance
projected.character.mood = finish.mood
return projected, true
for scriptName, bucket in pairs(runScriptSourceBuckets) do
for _, entry in pairs(bucket) do
table.insert(diagnostics.sources, {
script = scriptName,
sourceLength = entry.sourceLength,
sourceFingerprint = entry.sourceFingerprint,
hits = entry.hits,
lastUsed = entry.lastUsed,
})
end
end
for _, entry in pairs(runScriptWarmCache) do
table.insert(diagnostics.warm, {
script = entry.script,
bundleRevision = entry.bundleRevision,
mode = entry.mode,
namespaceFingerprint = entry.namespaceFingerprint,
characterIdentity = entry.characterIdentity,
sourceFingerprint = entry.sourceFingerprint,
hits = entry.hits,
lastUsed = entry.lastUsed,
})
end
local function sortDiagnostics(left, right)
if left.script == right.script then
return (left.sourceFingerprint or "") < (right.sourceFingerprint or "")
end
return left.script < right.script
end
table.sort(diagnostics.sources, sortDiagnostics)
table.sort(diagnostics.warm, sortDiagnostics)
return diagnostics
end
--로어북에서 스크립트를 호출해 실행
local function invokeRunScriptHandler(handler, triggerId, ...)
local packed = table.pack(pcall(handler, triggerId, ...))
if not packed[1] then
runScriptCacheStats.executionFailures = runScriptCacheStats.executionFailures + 1
debug(1, "스크립트 실행 오류: " .. tostring(packed[2]))
return nil
end
return table.unpack(packed, 2, packed.n)
end
local function invokeRunScriptWithPolicy(handler, triggerId, script, ...)
local arguments = table.pack(...)
local action = arguments[1]
local isTurnInitialization = script == "turnInitializer"
and action == "prepareTurn"
if isTurnInitialization then
turnInitializationDepth = turnInitializationDepth + 1
end
local packed = table.pack(pcall(function()
if turnInitializationDepth > 0
and script == "battleHistory"
and action == "validate" then
local projected, applied = projectHistoryValidationState(
arguments[2],
arguments[3]
)
if applied then
arguments[3] = projected
end
end
return invokeRunScriptHandler(
handler,
triggerId,
table.unpack(arguments, 1, arguments.n)
)
end))
if isTurnInitialization then
turnInitializationDepth = turnInitializationDepth - 1
end
if not packed[1] then
debug(1, "runtime policy execution error: " .. tostring(packed[2]))
return nil
end
return table.unpack(packed, 2, packed.n)
end
function runScript(triggerId, script, ...)
runScriptCacheStats.requests = runScriptCacheStats.requests + 1
local event = ensureRunScriptEvent(triggerId)
local transactionHandler = event.handlers[script]
if transactionHandler ~= nil then
runScriptCacheStats.transactionHits = runScriptCacheStats.transactionHits + 1
return invokeRunScriptWithPolicy(transactionHandler, triggerId, script, ...)
end
local handler = nil
local sourceFingerprint = nil
local warmKey = makeRunScriptWarmKey(event, script)
if not RUNTIME_CACHE_DEVELOPMENT_BYPASS then
local warmEntry = runScriptWarmCache[warmKey]
if warmEntry ~= nil then
runScriptCacheStats.warmHits = runScriptCacheStats.warmHits + 1
warmEntry.hits = warmEntry.hits + 1
touchRunScriptCacheEntry(warmEntry)
handler = warmEntry.handler
else
runScriptCacheStats.warmMisses = runScriptCacheStats.warmMisses + 1
end
end
if handler == nil then
runScriptCacheStats.sourceFetches = runScriptCacheStats.sourceFetches + 1
local source = loadScriptLore(triggerId, script)
if not source then
runScriptCacheStats.missingSources = runScriptCacheStats.missingSources + 1
debug(1, "runScript error: lorebook '" .. script .. "' not found.")
return nil
end
handler, sourceFingerprint = instantiateRunScriptHandler(script, source)
if handler == nil then
return nil
end
if not RUNTIME_CACHE_DEVELOPMENT_BYPASS then
storeRunScriptWarmHandler(warmKey, event, script, handler, sourceFingerprint)
end
end
if event.handlerCount < RUN_SCRIPT_TRANSACTION_MAX_ENTRIES then
event.handlers[script] = handler
event.handlerCount = event.handlerCount + 1
else
runScriptCacheStats.transactionCapacitySkips = runScriptCacheStats.transactionCapacitySkips + 1
end
return invokeRunScriptWithPolicy(handler, triggerId, script, ...)
end
--로어북에서 db를 호출해 return
function loadDB(triggerId, db)
local lores = getLoreBooks(triggerId, db)
if #lores == 0 then
debug(1, "loadDB error: lorebook '" .. db .. "' not found.")
return nil
end
local merged = {}
local loadedCount = 0
for _, lore in ipairs(lores) do
local ok, decoded = pcall(json.decode, lore.content)
if not ok or decoded == nil then
debug(1, "loadDB error: invalid json in lorebook '" .. db .. "'.")
return nil
end
if type(decoded) ~= "table" then
return decoded
end
loadedCount = loadedCount + 1
for k, v in pairs(decoded) do
if type(k) == "number" then
table.insert(merged, v)
else
merged[k] = v
end
end
end
if loadedCount == 0 then
return nil
end
return merged
end
--변수를 로어북으로 저장
function saveDB(triggerId, name, data, ...)
if data == nil then
debug(1, "saveDB error: data is nil.")
return
end
upsertLocalLoreBook(triggerId, name, json.encode(data), ...)
debug(2, "saveDB: "..name.." saved successfully.")
debug(3, name, json.encode(data))
end
--구분자로 문자열을 나누어 return
function splitByDelimiter(text, delimiter)
local result = {}
local source = tostring(text or "")
local startIndex = 1
while true do
local foundStart, foundEnd = string.find(source, delimiter, startIndex, true)
if not foundStart then
table.insert(result, string.sub(source, startIndex))
break
end
table.insert(result, string.sub(source, startIndex, foundStart - 1))
startIndex = foundEnd + 1
end
return result
end
return function(triggerId, action, ...)
if action == "install" then
return true
elseif action == "beginEvent" then
return beginRunScriptEvent(triggerId, ...)
elseif action == "run" then
return runScript(triggerId, ...)
elseif action == "diagnostics" then
return getRunScriptCacheDiagnostics()
elseif action == "clearCache" then
return clearRunScriptCache(...)
elseif action == "setDevelopmentMode" then
return setRunScriptCacheDevelopmentMode(...)
end
error("unsupported runtime action: " .. tostring(action))
end
end)()
#47stateSchema.lua
Keys:
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local MAX_SAFE_INTEGER = 9007199254740991
local MAX_PLAN_CAPACITY = 16
local CHARACTER_SCORE_SCALE = 3
local FINGERPRINT_ALGORITHM = "canonical_poly131_137_receipt_v2"
local DRAFT_FINGERPRINT_ALGORITHM = "canonical_poly131_137_v1"
local PENDING_INTEGRITY_ALGORITHM = "canonical_poly131_137_pending_v1"
local VALID_STATUS = {
active = true,
victory = true,
defeat = true,
}
local VALID_OWNER = {
player = true,
character = true,
}
local VALID_ZONE = {
deck = true,
hand = true,
used = true,
discard = true,
removed = true,
plan = true,
}
local VALID_SCENE_WEEKDAYS = {
["월요일"] = true, ["화요일"] = true, ["수요일"] = true, ["목요일"] = true,
["금요일"] = true, ["토요일"] = true, ["일요일"] = true,
}
local VALID_SCENE_TIMES = {
["아침 출근시간"] = true, ["저녁 퇴근시간"] = true,
["아침 시간"] = true, ["저녁 시간"] = true,
["한낮"] = true, ["심야열차"] = true,
}
local VALID_SCENE_WEATHERS = {
["맑음"] = true, ["흐림"] = true, ["가벼운 비"] = true, ["거센 비"] = true,
}
local function addError(errors, code, path, message)
table.insert(errors, {
code = code,
path = path,
message = message,
})
end
local function result(errors, value)
return {
ok = #errors == 0,
schemaVersion = SCHEMA_VERSION,
errors = errors,
value = #errors == 0 and value or nil,
}
end
local function isFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function isInteger(value, minimum)
return isFinite(value)
and value % 1 == 0
and (minimum == nil or value >= minimum)
end
local function isSafeInteger(value, minimum)
return isInteger(value, minimum)
and math.abs(value) <= MAX_SAFE_INTEGER
end
local function isAsciiId(value)
return type(value) == "string"
and string.match(value, "^[a-z][a-z0-9_]*$") ~= nil
end
local function isRuntimeId(value)
return type(value) == "string"
and string.match(value, "^[A-Za-z0-9][A-Za-z0-9_-]*$") ~= nil
end
local function objectPath(path, key)
if type(key) == "string" and string.match(key, "^[A-Za-z_][A-Za-z0-9_]*$") then
return path .. "." .. key
end
return path .. "[" .. string.format("%q", tostring(key)) .. "]"
end
local function inspectTable(value, path, errors)
if type(value) ~= "table" then
addError(errors, "expected_table", path, "테이블이어야 합니다.")
return nil
end
local numericCount = 0
local maximum = 0
local hasNumeric = false
local hasString = false
local stringKeys = {}
for key in pairs(value) do
if type(key) == "number" then
hasNumeric = true
numericCount = numericCount + 1
if not isInteger(key, 1) then
addError(errors, "invalid_array_index", path, "배열 인덱스는 1 이상의 정수여야 합니다.")
return nil
end
if key > maximum then
maximum = key
end
elseif type(key) == "string" then
hasString = true
table.insert(stringKeys, key)
else
addError(errors, "invalid_object_key", path, "객체 키는 문자열이어야 합니다.")
return nil
end
end
if hasNumeric and hasString then
addError(errors, "mixed_table", path, "숫자 인덱스와 문자열 키를 함께 사용할 수 없습니다.")
return nil
end
if hasNumeric then
if numericCount ~= maximum then
addError(errors, "sparse_array", path, "배열 인덱스는 1부터 빈틈없이 이어져야 합니다.")
return nil
end
return "array", maximum
end
if hasString then
table.sort(stringKeys)
return "object", stringKeys
end
return "array", 0
end
local function validateJsonSafe(value, path, errors, active)
local valueType = type(value)
if valueType == "string" or valueType == "boolean" then
return
end
if valueType == "number" then
if not isFinite(value) then
addError(errors, "non_finite_number", path, "NaN과 무한대는 저장할 수 없습니다.")
end
return
end
if valueType ~= "table" then
addError(errors, "unsupported_type", path, "JSON 상태에 저장할 수 없는 자료형입니다: " .. valueType)
return
end
if getmetatable(value) ~= nil then
addError(errors, "metatable_not_allowed", path, "상태 테이블에는 메타테이블을 사용할 수 없습니다.")
return
end
active = active or {}
if active[value] then
addError(errors, "circular_reference", path, "순환 참조가 있는 테이블은 저장할 수 없습니다.")
return
end
active[value] = true
local kind, shape = inspectTable(value, path, errors)
if kind == "array" then
for index = 1, shape do
validateJsonSafe(value[index], path .. "[" .. index .. "]", errors, active)
end
elseif kind == "object" then
for _, key in ipairs(shape) do
validateJsonSafe(value[key], objectPath(path, key), errors, active)
end
end
active[value] = nil
end
local function checkAllowedKeys(value, allowed, path, errors)
if type(value) ~= "table" then
return
end
for key in pairs(value) do
if type(key) ~= "string" or not allowed[key] then
addError(errors, "unknown_field", objectPath(path, key), "허용되지 않은 필드입니다.")
end
end
end
local function getArrayLength(value, path, errors)
local kind, length = inspectTable(value, path, errors)
if kind ~= "array" then
if kind ~= nil then
addError(errors, "expected_array", path, "연속 배열이어야 합니다.")
end
return nil
end
return length
end
local function validateIdArray(value, path, errors, idValidator)
local length = getArrayLength(value, path, errors)
if length == nil then
return
end
local seen = {}
for index = 1, length do
local item = value[index]
if not idValidator(item) then
addError(errors, "invalid_id", path .. "[" .. index .. "]", "올바른 ID 문자열이 아닙니다.")
else
if seen[item] then
addError(errors, "duplicate_id", path .. "[" .. index .. "]", "같은 ID가 중복되었습니다: " .. item)
end
seen[item] = true
end
end
end
local function normalizeStaticData(staticData)
if type(staticData) ~= "table" or getmetatable(staticData) ~= nil then
return staticData
end
local data = rawget(staticData, "data")
if type(data) == "table" and getmetatable(data) == nil then
return data
end
return staticData
end
local function isPlainTableTree(value, active, seen)
if type(value) ~= "table" then
return true
end
if getmetatable(value) ~= nil then
return false
end
active = active or {}
seen = seen or {}
if active[value] then
return false
end
if seen[value] then
return true
end
active[value] = true
for key, item in pairs(value) do
if not isPlainTableTree(key, active, seen)
or not isPlainTableTree(item, active, seen) then
active[value] = nil
return false
end
end
active[value] = nil
seen[value] = true
return true
end
local function fingerprintFailure(code, path, message)
error({
code = code,
path = path,
message = message,
}, 0)
end
local function inspectCanonicalTable(value, path)
if type(value) ~= "table" or getmetatable(value) ~= nil then
fingerprintFailure("invalid_table", path, "fingerprint 대상은 일반 테이블이어야 합니다.")
end
local numericCount = 0
local maximum = 0
local hasNumeric = false
local hasString = false
local stringKeys = {}
for key in pairs(value) do
if type(key) == "number" then
hasNumeric = true
numericCount = numericCount + 1
if not isInteger(key, 1) then
fingerprintFailure("invalid_array_index", path, "배열 인덱스는 1 이상의 정수여야 합니다.")
end
if key > maximum then
maximum = key
end
elseif type(key) == "string" then
hasString = true
table.insert(stringKeys, key)
else
fingerprintFailure("invalid_object_key", path, "객체 키는 문자열이어야 합니다.")
end
end
if hasNumeric and hasString then
fingerprintFailure("mixed_table", path, "숫자 인덱스와 문자열 키를 함께 사용할 수 없습니다.")
end
if hasNumeric and numericCount ~= maximum then
fingerprintFailure("sparse_array", path, "배열 인덱스는 1부터 빈틈없이 이어져야 합니다.")
end
table.sort(stringKeys)
return hasNumeric, maximum, stringKeys
end
local function canonicalJson(value, path, active)
local valueType = type(value)
if valueType == "nil" then
return "n"
end
if valueType == "boolean" then
return value and "t" or "f"
end
if valueType == "number" then
if not isFinite(value) then
fingerprintFailure("non_finite_number", path, "NaN과 무한대는 fingerprint에 사용할 수 없습니다.")
end
return "d" .. string.format("%.17g", value) .. ";"
end
if valueType == "string" then
return "s" .. tostring(#value) .. ":" .. value
end
if valueType ~= "table" then
fingerprintFailure("unsupported_type", path, "fingerprint에 사용할 수 없는 자료형입니다: " .. valueType)
end
active = active or {}
if active[value] then
fingerprintFailure("circular_reference", path, "순환 참조가 있는 값은 fingerprint에 사용할 수 없습니다.")
end
active[value] = true
local isArray, length, stringKeys = inspectCanonicalTable(value, path)
local parts = {}
if isArray then
parts[1] = "["
for index = 1, length do
parts[#parts + 1] = canonicalJson(value[index], path .. "[" .. index .. "]", active)
end
parts[#parts + 1] = "]"
else
parts[1] = "{"
for _, key in ipairs(stringKeys) do
parts[#parts + 1] = "k" .. tostring(#key) .. ":" .. key
parts[#parts + 1] = canonicalJson(value[key], objectPath(path, key), active)
end
parts[#parts + 1] = "}"
end
active[value] = nil
return table.concat(parts)
end
local function fingerprintAuthorityState(state)
local authorityState = {}
for key, value in pairs(state) do
if key == "turnStartReceipt" and type(value) == "table" then
local receipt = {}
for receiptKey, receiptValue in pairs(value) do
if receiptKey ~= "authorityFingerprint" then
receipt[receiptKey] = receiptValue
end
end
authorityState[key] = receipt
else
authorityState[key] = value
end
end
local ok, canonical = pcall(canonicalJson, authorityState, "$", {})
if not ok then
if type(canonical) == "table" and canonical.code and canonical.path and canonical.message then
return nil, canonical
end
return nil, {
code = "fingerprint_failed",
path = "$",
message = "전투 상태 fingerprint 생성에 실패했습니다: " .. tostring(canonical),
}
end
local hashA = 0
local hashB = 0
for index = 1, #canonical do
local byte = string.byte(canonical, index)
hashA = (hashA * 131 + byte) % 2147483647
hashB = (hashB * 137 + byte) % 2147483629
end
return {
algorithm = FINGERPRINT_ALGORITHM,
length = #canonical,
hashA = hashA,
hashB = hashB,
}, nil
end
local function fingerprintDraftAuthorityState(state)
local ok, canonical = pcall(canonicalJson, state, "$", {})
if not ok then
if type(canonical) == "table" and canonical.code and canonical.path and canonical.message then
return nil, canonical
end
return nil, {
code = "fingerprint_failed",
path = "$",
message = "드래프트 권위 상태 fingerprint 생성에 실패했습니다: " .. tostring(canonical),
}
end
local hashA = 0
local hashB = 0
for index = 1, #canonical do
local byte = string.byte(canonical, index)
hashA = (hashA * 131 + byte) % 2147483647
hashB = (hashB * 137 + byte) % 2147483629
end
return {
algorithm = DRAFT_FINGERPRINT_ALGORITHM,
length = #canonical,
hashA = hashA,
hashB = hashB,
}, nil
end
local function fingerprintPendingTurn(pending)
local payload = {}
for key, value in pairs(pending) do
if key ~= "integrity" then
payload[key] = value
end
end
local ok, canonical = pcall(canonicalJson, payload, "$", {})
if not ok then
if type(canonical) == "table" and canonical.code and canonical.path and canonical.message then
return nil, canonical
end
return nil, {
code = "fingerprint_failed",
path = "$.integrity",
message = "pendingTurn 무결성 fingerprint 생성에 실패했습니다: " .. tostring(canonical),
}
end
local hashA = 0
local hashB = 0
for index = 1, #canonical do
local byte = string.byte(canonical, index)
hashA = (hashA * 131 + byte) % 2147483647
hashB = (hashB * 137 + byte) % 2147483629
end
return {
algorithm = PENDING_INTEGRITY_ALGORITHM,
length = #canonical,
hashA = hashA,
hashB = hashB,
}, nil
end
local function hasCompleteStaticData(staticData)
return type(staticData) == "table"
and getmetatable(staticData) == nil
and type(rawget(staticData, "registry")) == "table"
and type(rawget(staticData, "cards")) == "table"
and type(rawget(staticData, "traits")) == "table"
and type(rawget(staticData, "subwayLines")) == "table"
and type(rawget(staticData, "characters")) == "table"
and isPlainTableTree(staticData)
end
local function appendNestedErrors(target, prefix, nested)
if type(nested) ~= "table" or type(nested.errors) ~= "table" then
addError(target, "validation_failed", prefix, "하위 스키마 검증 결과가 올바르지 않습니다.")
return
end
for _, item in ipairs(nested.errors) do
local suffix = tostring(item.path or "$")
if string.sub(suffix, 1, 1) == "$" then
suffix = string.sub(suffix, 2)
end
addError(
target,
tostring(item.code or "validation_failed"),
prefix .. suffix,
tostring(item.message or "하위 스키마 검증에 실패했습니다.")
)
end
end
local function validatePlanSlot(slot, side, path, errors, instances, staticData, currentTurn)
if type(slot) ~= "table" then
addError(errors, "invalid_plan_slot", path, "계획 슬롯이 테이블이 아닙니다.")
return
end
local occupied = slot.occupied
checkAllowedKeys(slot, {
occupied = true,
cardInstanceId = true,
cardId = true,
placedTurn = true,
durationIncludesPlacementTurn = true,
remainingTurns = true,
remainingCharges = true,
revealed = true,
effectChoiceId = true,
}, path, errors)
if occupied ~= true then
addError(errors, "invalid_plan_occupied", path .. ".occupied", "planSlots에는 occupied = true인 점유 슬롯만 저장할 수 있습니다.")
return
end
if not isRuntimeId(slot.cardInstanceId) then
addError(errors, "invalid_instance_id", path .. ".cardInstanceId", "계획 카드 인스턴스 ID가 올바르지 않습니다.")
end
if not isAsciiId(slot.cardId) then
addError(errors, "invalid_card_id", path .. ".cardId", "계획 카드 ID가 올바르지 않습니다.")
end
if not isInteger(slot.placedTurn, 1) then
addError(errors, "invalid_placed_turn", path .. ".placedTurn", "배치 턴은 1 이상의 정수여야 합니다.")
elseif isInteger(currentTurn, 1) and slot.placedTurn > currentTurn then
addError(errors, "future_placed_turn", path .. ".placedTurn", "계획 배치 턴은 현재 턴보다 클 수 없습니다.")
end
if slot.revealed ~= true and slot.revealed ~= false then
addError(errors, "invalid_revealed", path .. ".revealed", "revealed는 불리언이어야 합니다.")
end
if slot.effectChoiceId ~= nil and not isAsciiId(slot.effectChoiceId) then
addError(errors, "invalid_effect_choice_id", path .. ".effectChoiceId", "계획 효과 선택지 ID가 올바르지 않습니다.")
end
if slot.durationIncludesPlacementTurn ~= nil
and type(slot.durationIncludesPlacementTurn) ~= "boolean" then
addError(
errors,
"invalid_plan_duration_policy",
path .. ".durationIncludesPlacementTurn",
"배치 턴 포함 여부는 불리언이어야 합니다."
)
elseif slot.durationIncludesPlacementTurn == true and slot.remainingTurns == nil then
addError(
errors,
"plan_duration_policy_requires_duration",
path .. ".durationIncludesPlacementTurn",
"배치 턴을 포함하는 계획에는 남은 지속시간이 필요합니다."
)
end
local hasLifetime = false
if slot.remainingTurns ~= nil then
hasLifetime = true
if not isInteger(slot.remainingTurns, 1) then
addError(errors, "invalid_remaining_turns", path .. ".remainingTurns", "점유된 계획의 남은 지속 턴은 1 이상의 정수여야 합니다.")
end
end
if slot.remainingCharges ~= nil then
hasLifetime = true
if not isInteger(slot.remainingCharges, 1) then
addError(errors, "invalid_remaining_charges", path .. ".remainingCharges", "점유된 계획의 남은 충전은 1 이상의 정수여야 합니다.")
end
end
if not hasLifetime then
addError(errors, "missing_plan_lifetime", path, "점유된 계획에는 제한된 수명이 필요합니다.")
end
local instance = instances[slot.cardInstanceId]
if not instance then
addError(errors, "missing_plan_instance", path .. ".cardInstanceId", "계획 카드 인스턴스를 찾을 수 없습니다.")
else
if instance.owner ~= side then
addError(errors, "plan_owner_mismatch", path .. ".cardInstanceId", "계획 슬롯과 카드 소유자가 다릅니다.")
end
if instance.zone ~= "plan" then
addError(errors, "plan_zone_mismatch", path .. ".cardInstanceId", "계획 카드 인스턴스의 zone이 plan이 아닙니다.")
end
if instance.cardId ~= slot.cardId then
addError(errors, "plan_card_mismatch", path .. ".cardId", "계획 슬롯과 카드 인스턴스의 카드 ID가 다릅니다.")
end
end
local cards = type(staticData) == "table" and staticData.cards or nil
local card = type(cards) == "table" and cards[slot.cardId] or nil
if card and card.cardType ~= "plan" then
addError(errors, "plan_type_mismatch", path .. ".cardId", "계획 슬롯의 카드 유형이 plan이 아닙니다.")
elseif card then
local matchedChoice = nil
for _, choice in ipairs(type(card.effectChoices) == "table" and card.effectChoices or {}) do
if choice.id == slot.effectChoiceId then matchedChoice = choice end
end
if type(card.effectChoices) == "table" and matchedChoice == nil then
addError(errors, "missing_plan_effect_choice", path .. ".effectChoiceId", "선택형 계획에 유효한 효과 선택값이 없습니다.")
elseif matchedChoice ~= nil and matchedChoice.placesPlan == false then
addError(errors, "invalid_plan_effect_choice", path .. ".effectChoiceId", "즉시 발동 선택지는 계획 슬롯에 저장할 수 없습니다.")
elseif type(card.effectChoices) ~= "table" and slot.effectChoiceId ~= nil then
addError(errors, "unexpected_plan_effect_choice", path .. ".effectChoiceId", "선택지가 없는 계획에 효과 선택값이 있습니다.")
end
local planData = type(card.mechanismData) == "table" and card.mechanismData.plan or nil
local expectedIncludesPlacementTurn = type(planData) == "table"
and planData.durationIncludesPlacementTurn == true
if (slot.durationIncludesPlacementTurn == true) ~= expectedIncludesPlacementTurn then
addError(
errors,
"plan_duration_policy_mismatch",
path .. ".durationIncludesPlacementTurn",
"계획 슬롯의 배치 턴 포함 정책이 정적 카드 정의와 다릅니다."
)
end
local initialDurationTurns = type(planData) == "table" and planData.durationTurns or nil
if initialDurationTurns ~= nil and slot.remainingTurns == nil then
addError(
errors,
"plan_remaining_turns_missing",
path .. ".remainingTurns",
"정적 카드 정의에 지속시간이 있는 활성 계획에는 remainingTurns가 필요합니다."
)
elseif slot.remainingTurns ~= nil then
if initialDurationTurns == nil then
addError(
errors,
"plan_remaining_turns_undefined",
path .. ".remainingTurns",
"정적 카드 정의에 지속시간이 없는 계획은 remainingTurns를 가질 수 없습니다."
)
end
end
local initialCharges = type(planData) == "table" and planData.charges or nil
if initialCharges ~= nil and slot.remainingCharges == nil then
addError(
errors,
"plan_remaining_charges_missing",
path .. ".remainingCharges",
"정적 카드 정의에 충전이 있는 활성 계획에는 remainingCharges가 필요합니다."
)
elseif slot.remainingCharges ~= nil then
if initialCharges == nil then
addError(
errors,
"plan_remaining_charges_undefined",
path .. ".remainingCharges",
"정적 카드 정의에 충전이 없는 계획은 remainingCharges를 가질 수 없습니다."
)
end
end
end
end
local function validatePlanSlots(
slots,
capacity,
side,
path,
errors,
instances,
staticData,
currentTurn
)
local capacityPath = "$." .. side .. ".planCapacity"
local capacityValid = isSafeInteger(capacity, 1) and capacity <= MAX_PLAN_CAPACITY
if not capacityValid then
addError(errors, "invalid_plan_capacity", capacityPath, "계획 용량은 1 이상 16 이하의 정수여야 합니다.")
end
local slotCount = getArrayLength(slots, path, errors)
if slotCount == nil then
return
end
if capacityValid and slotCount > capacity then
addError(errors, "plan_capacity_exceeded", path, "점유 계획 수가 계획 용량을 초과했습니다.")
end
local seenInstanceIds = {}
for index = 1, slotCount do
local slot = slots[index]
local slotPath = path .. "[" .. index .. "]"
validatePlanSlot(slot, side, slotPath, errors, instances, staticData, currentTurn)
if type(slot) == "table" and isRuntimeId(slot.cardInstanceId) then
if seenInstanceIds[slot.cardInstanceId] then
addError(
errors,
"duplicate_plan_slot",
slotPath .. ".cardInstanceId",
"같은 계획 카드 인스턴스를 둘 이상의 슬롯에 저장할 수 없습니다."
)
else
seenInstanceIds[slot.cardInstanceId] = true
end
local instance = instances[slot.cardInstanceId]
if instance and instance.owner == side and instance.zone == "plan"
and instance.position ~= index then
addError(
errors,
"plan_position_mismatch",
slotPath .. ".cardInstanceId",
"plan 영역 position은 planSlots 배열 인덱스와 일치해야 합니다."
)
end
end
end
end
local function validateTurnStartEventSource(value, path, errors)
if type(value) ~= "table" then
addError(errors, "invalid_event_source", path, "턴 시작 사건의 source가 객체가 아닙니다.")
return
end
checkAllowedKeys(value, {
kind = true,
id = true,
side = true,
instanceId = true,
}, path, errors)
if not isAsciiId(value.kind) then
addError(errors, "invalid_event_source", path .. ".kind", "사건 source.kind는 lower_snake_case여야 합니다.")
end
if not isAsciiId(value.id) then
addError(errors, "invalid_event_source", path .. ".id", "사건 source.id는 lower_snake_case여야 합니다.")
end
if value.side ~= nil and not VALID_OWNER[value.side] then
addError(errors, "invalid_event_side", path .. ".side", "사건 source.side는 player 또는 character여야 합니다.")
end
if value.instanceId ~= nil and not isRuntimeId(value.instanceId) then
addError(errors, "invalid_instance_id", path .. ".instanceId", "사건 source.instanceId가 올바르지 않습니다.")
end
end
local function validateTurnStartEventCause(value, path, errors)
if type(value) ~= "table" then
addError(errors, "invalid_event_cause", path, "턴 시작 사건의 cause가 객체가 아닙니다.")
return
end
checkAllowedKeys(value, {
kind = true,
resolutionId = true,
eventId = true,
}, path, errors)
if not isAsciiId(value.kind) then
addError(errors, "invalid_event_cause", path .. ".kind", "사건 cause.kind는 lower_snake_case여야 합니다.")
end
if value.resolutionId ~= nil and not isRuntimeId(value.resolutionId) then
addError(errors, "invalid_resolution_id", path .. ".resolutionId", "사건 cause.resolutionId가 올바르지 않습니다.")
end
if value.eventId ~= nil and not isRuntimeId(value.eventId) then
addError(errors, "invalid_event_id", path .. ".eventId", "사건 cause.eventId가 올바르지 않습니다.")
end
end
local function validateTurnStartEvents(events, turnId, path, errors)
local eventCount = getArrayLength(events, path, errors)
if eventCount == nil then
return
end
for index = 1, eventCount do
local event = events[index]
local eventPath = path .. "[" .. index .. "]"
if type(event) ~= "table" then
addError(errors, "invalid_turn_start_event", eventPath, "턴 시작 사건이 객체가 아닙니다.")
else
checkAllowedKeys(event, {
eventId = true,
sequence = true,
type = true,
phase = true,
resolutionId = true,
side = true,
source = true,
cause = true,
payload = true,
}, eventPath, errors)
if event.sequence ~= index then
addError(errors, "invalid_event_sequence", eventPath .. ".sequence", "턴 시작 사건 sequence는 배열 순서와 일치해야 합니다.")
end
if isRuntimeId(turnId) then
local expectedEventId = turnId .. "-event-" .. string.format("%03d", index)
if event.eventId ~= expectedEventId then
addError(errors, "invalid_event_id", eventPath .. ".eventId", "턴 시작 사건 ID가 turnId와 순번에 일치하지 않습니다.")
end
elseif not isRuntimeId(event.eventId) then
addError(errors, "invalid_event_id", eventPath .. ".eventId", "턴 시작 사건 ID가 올바르지 않습니다.")
end
if not isAsciiId(event.type) then
addError(errors, "invalid_event_type", eventPath .. ".type", "사건 type은 lower_snake_case여야 합니다.")
end
if event.phase ~= "turn_start" then
addError(errors, "invalid_event_phase", eventPath .. ".phase", "turnStartReceipt 사건 phase는 turn_start여야 합니다.")
end
if event.resolutionId ~= nil and not isRuntimeId(event.resolutionId) then
addError(errors, "invalid_resolution_id", eventPath .. ".resolutionId", "사건 resolutionId가 올바르지 않습니다.")
end
if event.side ~= nil and not VALID_OWNER[event.side] then
addError(errors, "invalid_event_side", eventPath .. ".side", "사건 side는 player 또는 character여야 합니다.")
end
validateTurnStartEventSource(event.source, eventPath .. ".source", errors)
if event.cause ~= nil then
validateTurnStartEventCause(event.cause, eventPath .. ".cause", errors)
end
if event.payload ~= nil then
local payloadKind = inspectTable(event.payload, eventPath .. ".payload", errors)
if payloadKind ~= "object" then
addError(errors, "invalid_event_payload", eventPath .. ".payload", "사건 payload는 비어 있지 않은 JSON 객체여야 합니다.")
end
end
end
end
end
local function rngEqual(left, right)
return type(left) == "table"
and type(right) == "table"
and left.seed == right.seed
and left.cursor == right.cursor
end
local function validateReceiptRng(value, path, errors)
if type(value) ~= "table" then
addError(errors, "invalid_receipt_rng", path, "영수증 RNG가 객체가 아닙니다.")
return false
end
checkAllowedKeys(value, {
seed = true,
cursor = true,
}, path, errors)
local valid = true
if not isSafeInteger(value.seed, 0) then
addError(errors, "invalid_receipt_rng", path .. ".seed", "영수증 RNG seed는 0 이상의 안전한 정수여야 합니다.")
valid = false
end
if not isSafeInteger(value.cursor, 0) then
addError(errors, "invalid_receipt_rng", path .. ".cursor", "영수증 RNG cursor는 0 이상의 안전한 정수여야 합니다.")
valid = false
end
return valid
end
local function validateAuthorityFingerprint(value, path, errors)
if type(value) ~= "table" then
addError(errors, "invalid_authority_fingerprint", path, "권위 상태 fingerprint가 객체가 아닙니다.")
return false
end
checkAllowedKeys(value, {
algorithm = true,
length = true,
hashA = true,
hashB = true,
}, path, errors)
local valid = true
if value.algorithm ~= FINGERPRINT_ALGORITHM then
addError(
errors,
"invalid_fingerprint_algorithm",
path .. ".algorithm",
"지원하지 않는 권위 상태 fingerprint 알고리즘입니다."
)
valid = false
end
for _, field in ipairs({ "length", "hashA", "hashB" }) do
if not isSafeInteger(value[field], 0) then
addError(
errors,
"invalid_authority_fingerprint",
path .. "." .. field,
"권위 상태 fingerprint 수치는 0 이상의 안전한 정수여야 합니다."
)
valid = false
end
end
return valid
end
local function validateDrawReport(report, side, state, path, errors)
if type(report) ~= "table" then
addError(errors, "invalid_draw_receipt", path, "기본 드로우 영수증이 객체가 아닙니다.")
return
end
checkAllowedKeys(report, {
requested = true,
drawnInstanceIds = true,
rngBefore = true,
rngAfter = true,
}, path, errors)
local ownerState = type(state) == "table" and state[side] or nil
local expectedRequested = type(ownerState) == "table" and ownerState.baseDrawCount or nil
if not isInteger(report.requested, 1) then
addError(errors, "invalid_draw_requested", path .. ".requested", "기본 드로우 요청 수는 1 이상의 정수여야 합니다.")
elseif isInteger(expectedRequested, 1) and report.requested ~= expectedRequested then
addError(
errors,
"receipt_draw_count_mismatch",
path .. ".requested",
"기본 드로우 요청 수가 현재 진영의 baseDrawCount와 다릅니다."
)
end
local drawnCount = getArrayLength(report.drawnInstanceIds, path .. ".drawnInstanceIds", errors)
if drawnCount ~= nil then
validateIdArray(report.drawnInstanceIds, path .. ".drawnInstanceIds", errors, isRuntimeId)
if isInteger(report.requested, 1) and drawnCount > report.requested then
addError(errors, "draw_count_exceeded", path .. ".drawnInstanceIds", "실제 드로우 수가 요청 수보다 많습니다.")
end
end
local beforeValid = validateReceiptRng(report.rngBefore, path .. ".rngBefore", errors)
local afterValid = validateReceiptRng(report.rngAfter, path .. ".rngAfter", errors)
if beforeValid and afterValid then
if report.rngAfter.seed ~= report.rngBefore.seed then
addError(errors, "receipt_rng_seed_changed", path .. ".rngAfter.seed", "드로우 중 RNG seed가 바뀔 수 없습니다.")
end
if report.rngAfter.cursor < report.rngBefore.cursor then
addError(errors, "receipt_rng_reversed", path .. ".rngAfter.cursor", "드로우 중 RNG cursor가 이전으로 돌아갈 수 없습니다.")
end
end
end
local function validateDraws(draws, state, path, errors)
if type(draws) ~= "table" then
addError(errors, "invalid_draw_receipts", path, "기본 드로우 영수증 묶음이 객체가 아닙니다.")
return
end
checkAllowedKeys(draws, {
player = true,
character = true,
}, path, errors)
validateDrawReport(draws.player, "player", state, path .. ".player", errors)
validateDrawReport(draws.character, "character", state, path .. ".character", errors)
local playerAfter = type(draws.player) == "table" and draws.player.rngAfter or nil
local characterBefore = type(draws.character) == "table" and draws.character.rngBefore or nil
if type(playerAfter) == "table"
and type(characterBefore) == "table"
and not rngEqual(playerAfter, characterBefore) then
addError(
errors,
"receipt_rng_discontinuity",
path .. ".character.rngBefore",
"캐릭터 드로우 RNG 시작점이 플레이어 드로우 종료점과 다릅니다."
)
end
end
local function validateCandidateTotals(totals, path, errors)
if type(totals) ~= "table" then
addError(errors, "invalid_selection_totals", path, "후보 효과 합계가 객체가 아닙니다.")
return
end
local fields = {
"recoverResistance",
"loseStealth",
"damageResistance",
"recoverStealth",
}
checkAllowedKeys(totals, {
recoverResistance = true,
loseStealth = true,
damageResistance = true,
recoverStealth = true,
}, path, errors)
for _, field in ipairs(fields) do
if not isFinite(totals[field]) or totals[field] < 0 then
addError(
errors,
"invalid_selection_total",
path .. "." .. field,
"후보 효과 합계는 0 이상의 유한한 숫자여야 합니다."
)
end
end
end
local function projectHistoryContext(history)
if type(runScript) ~= "function" then return nil end
local ok, report = pcall(runScript, triggerId, "battleHistory", "context", history)
if not ok or type(report) ~= "table" or report.ok ~= true or type(report.context) ~= "table" then
return nil
end
return report.context
end
local function validateHistoryContext(value, path, errors)
if type(runScript) ~= "function" then
addError(errors, "history_context_validation_unavailable", path, "전투 이력 컨텍스트 검증기를 찾을 수 없습니다.")
return
end
local ok, report = pcall(runScript, triggerId, "battleHistory", "validateContext", value)
if not ok or type(report) ~= "table" then
addError(errors, "history_context_validation_failed", path, "전투 이력 컨텍스트 검증 호출에 실패했습니다.")
elseif report.ok ~= true then
appendNestedErrors(errors, path, report)
end
end
local function validateSelectionContext(context, path, errors, staticData)
if type(context) ~= "table" then
addError(errors, "invalid_selection_context", path, "선택 시점 컨텍스트가 객체가 아닙니다.")
return nil
end
checkAllowedKeys(context, {
turnNumber = true,
player = true,
character = true,
characterHand = true,
history = true,
}, path, errors)
if not isInteger(context.turnNumber, 1) then
addError(errors, "invalid_turn_number", path .. ".turnNumber", "선택 시점 턴 번호는 1 이상의 정수여야 합니다.")
end
validateHistoryContext(context.history, path .. ".history", errors)
if type(context.player) ~= "table" then
addError(errors, "invalid_selection_context", path .. ".player", "선택 시점 플레이어 컨텍스트가 객체가 아닙니다.")
else
checkAllowedKeys(context.player, {
stealth = true,
handCount = true,
}, path .. ".player", errors)
if not isFinite(context.player.stealth) then
addError(errors, "invalid_selection_context", path .. ".player.stealth", "선택 시점 은폐가 유한한 숫자가 아닙니다.")
end
if not isSafeInteger(context.player.handCount, 0) then
addError(errors, "invalid_selection_context", path .. ".player.handCount", "선택 시점 플레이어 손패 수가 안전한 비음수 정수가 아닙니다.")
end
end
if type(context.character) ~= "table" then
addError(errors, "invalid_selection_context", path .. ".character", "선택 시점 캐릭터 컨텍스트가 객체가 아닙니다.")
else
checkAllowedKeys(context.character, {
resistance = true,
mood = true,
moodTokens = true,
}, path .. ".character", errors)
if not isFinite(context.character.resistance) then
addError(errors, "invalid_selection_context", path .. ".character.resistance", "선택 시점 저항이 유한한 숫자가 아닙니다.")
end
if not isAsciiId(context.character.mood) then
addError(errors, "invalid_selection_context", path .. ".character.mood", "선택 시점 무드 ID가 올바르지 않습니다.")
end
local moodTokens = context.character.moodTokens
local moods = type(staticData) == "table"
and type(staticData.registry) == "table"
and type(staticData.registry.moods) == "table"
and staticData.registry.moods
or nil
if type(moodTokens) ~= "table" or getmetatable(moodTokens) ~= nil then
addError(errors, "invalid_selection_context", path .. ".character.moodTokens", "선택 시점 무드 토큰이 객체가 아닙니다.")
else
for moodId in pairs(moods or {}) do
if moodTokens[moodId] == nil then
addError(errors, "invalid_mood_token_count", path .. ".character.moodTokens." .. moodId, "선택 시점 무드 토큰 수가 올바르지 않습니다.")
end
end
for moodId, count in pairs(moodTokens) do
if not isAsciiId(moodId) then
addError(errors, "invalid_mood", path .. ".character.moodTokens." .. tostring(moodId), "선택 시점 무드 토큰 ID가 올바르지 않습니다.")
elseif moods ~= nil and moods[moodId] == nil then
addError(errors, "unknown_mood", path .. ".character.moodTokens." .. tostring(moodId), "선택 시점에 등록되지 않은 무드 토큰이 있습니다.")
elseif not isSafeInteger(count, 0) then
addError(errors, "invalid_mood_token_count", path .. ".character.moodTokens." .. moodId, "선택 시점 무드 토큰 수가 올바르지 않습니다.")
end
end
end
end
local handCount = getArrayLength(context.characterHand, path .. ".characterHand", errors)
local seen = {}
if handCount ~= nil then
for index = 1, handCount do
local entry = context.characterHand[index]
local entryPath = path .. ".characterHand[" .. index .. "]"
if type(entry) ~= "table" then
addError(errors, "invalid_selection_hand_entry", entryPath, "선택 시점 손패 항목이 객체가 아닙니다.")
else
checkAllowedKeys(entry, {
instanceId = true,
cardId = true,
role = true,
handPosition = true,
}, entryPath, errors)
if not isRuntimeId(entry.instanceId) then
addError(errors, "invalid_instance_id", entryPath .. ".instanceId", "선택 시점 손패 인스턴스 ID가 올바르지 않습니다.")
elseif seen[entry.instanceId] then
addError(errors, "duplicate_id", entryPath .. ".instanceId", "선택 시점 손패 인스턴스 ID가 중복되었습니다.")
else
seen[entry.instanceId] = true
end
if not isAsciiId(entry.cardId) then
addError(errors, "invalid_card_id", entryPath .. ".cardId", "선택 시점 손패 카드 ID가 올바르지 않습니다.")
end
if not isAsciiId(entry.role) then
addError(errors, "invalid_role", entryPath .. ".role", "선택 시점 손패 역할이 올바르지 않습니다.")
end
if entry.handPosition ~= index then
addError(errors, "invalid_hand_position", entryPath .. ".handPosition", "선택 시점 캐릭터 손패 위치는 안정 순서의 1부터 연속되어야 합니다.")
end
end
end
end
return handCount
end
local function validateSelectionCandidate(candidate, path, errors)
if type(candidate) ~= "table" then
addError(errors, "invalid_selection_candidate", path, "캐릭터 선택 후보가 객체가 아닙니다.")
return
end
checkAllowedKeys(candidate, {
instanceId = true,
cardId = true,
role = true,
handPosition = true,
score = true,
projectedPlayerStealth = true,
lethal = true,
weight = true,
moodScore = true,
totals = true,
planChargesEvaluated = true,
}, path, errors)
if not isRuntimeId(candidate.instanceId) then
addError(errors, "invalid_instance_id", path .. ".instanceId", "후보 카드 인스턴스 ID가 올바르지 않습니다.")
end
if not isAsciiId(candidate.cardId) then
addError(errors, "invalid_card_id", path .. ".cardId", "후보 카드 ID가 올바르지 않습니다.")
end
if not isAsciiId(candidate.role) then
addError(errors, "invalid_role", path .. ".role", "후보 역할이 올바르지 않습니다.")
end
if not isInteger(candidate.handPosition, 1) then
addError(errors, "invalid_hand_position", path .. ".handPosition", "후보 손패 위치는 1 이상의 정수여야 합니다.")
end
if not isSafeInteger(candidate.score) then
addError(errors, "invalid_selection_score", path .. ".score", "후보 점수는 안전한 정수여야 합니다.")
end
if not isFinite(candidate.projectedPlayerStealth) then
addError(errors, "invalid_projected_stealth", path .. ".projectedPlayerStealth", "예상 플레이어 은폐가 유한한 숫자가 아닙니다.")
end
if candidate.lethal ~= true and candidate.lethal ~= false then
addError(errors, "invalid_lethal_flag", path .. ".lethal", "lethal은 불리언이어야 합니다.")
elseif isFinite(candidate.projectedPlayerStealth)
and candidate.lethal ~= (candidate.projectedPlayerStealth <= 0) then
addError(errors, "lethal_projection_mismatch", path .. ".lethal", "lethal 값이 예상 플레이어 은폐와 다릅니다.")
end
if not isSafeInteger(candidate.weight, 0) then
addError(errors, "invalid_selection_weight", path .. ".weight", "후보 가중치는 0 이상의 안전한 정수여야 합니다.")
end
if not isSafeInteger(candidate.moodScore) then
addError(errors, "invalid_mood_score", path .. ".moodScore", "후보 무드 점수는 안전한 정수여야 합니다.")
end
validateCandidateTotals(candidate.totals, path .. ".totals", errors)
if not isSafeInteger(candidate.planChargesEvaluated, 0) then
addError(
errors,
"invalid_plan_charge_count",
path .. ".planChargesEvaluated",
"평가한 계획 충전 수는 0 이상의 안전한 정수여야 합니다."
)
end
end
local function validateSelectionDraw(draw, path, errors)
if type(draw) ~= "table" then
addError(errors, "invalid_selection_draw", path, "선택 추첨 영수증이 객체가 아닙니다.")
return
end
if draw.kind == "pass" then
checkAllowedKeys(draw, { kind = true }, path, errors)
elseif draw.kind == "single" then
checkAllowedKeys(draw, { kind = true, totalWeight = true }, path, errors)
if not isSafeInteger(draw.totalWeight, 1) then
addError(errors, "invalid_draw_weight", path .. ".totalWeight", "단독 후보 가중치는 1 이상의 안전한 정수여야 합니다.")
end
elseif draw.kind == "weighted" then
checkAllowedKeys(draw, {
kind = true,
totalWeight = true,
roll = true,
}, path, errors)
if not isSafeInteger(draw.totalWeight, 1) then
addError(errors, "invalid_draw_weight", path .. ".totalWeight", "가중 추첨의 총 가중치는 1 이상의 안전한 정수여야 합니다.")
end
if not isSafeInteger(draw.roll, 1) then
addError(errors, "invalid_draw_roll", path .. ".roll", "가중 추첨 roll은 1 이상의 안전한 정수여야 합니다.")
elseif isSafeInteger(draw.totalWeight, 1) and draw.roll > draw.totalWeight then
addError(errors, "invalid_draw_roll", path .. ".roll", "가중 추첨 roll이 총 가중치를 초과합니다.")
end
else
checkAllowedKeys(draw, {
kind = true,
totalWeight = true,
roll = true,
}, path, errors)
addError(errors, "invalid_selection_draw", path .. ".kind", "알 수 없는 선택 추첨 방식입니다.")
end
end
local function findStateInstance(state, instanceId)
if type(state) ~= "table" or type(state.cardInstances) ~= "table" then
return nil
end
for _, instance in ipairs(state.cardInstances) do
if type(instance) == "table" and instance.instanceId == instanceId then
return instance
end
end
return nil
end
local function countStateZone(state, owner, zone)
local count = 0
for _, instance in ipairs(type(state) == "table" and type(state.cardInstances) == "table" and state.cardInstances or {}) do
if type(instance) == "table" and instance.owner == owner and instance.zone == zone then
count = count + 1
end
end
return count
end
local function buildExpectedSelectionContext(state, events, staticData)
local revealEventIds = {}
for _, event in ipairs(type(events) == "table" and events or {}) do
if type(event) == "table" and event.type == "role_revealed" and isRuntimeId(event.eventId) then
revealEventIds[event.eventId] = true
end
end
local playerStealth = type(state.player) == "table" and state.player.stealth or nil
local playerHandCount = countStateZone(state, "player", "hand")
local characterResistance = type(state.character) == "table" and state.character.resistance or nil
local characterMood = type(state.character) == "table" and state.character.mood or nil
local characterMoodTokens = {}
local stateMoodTokens = type(state.character) == "table" and type(state.character.moodTokens) == "table"
and state.character.moodTokens
or {}
local registryMoods = type(staticData) == "table"
and type(staticData.registry) == "table"
and type(staticData.registry.moods) == "table"
and staticData.registry.moods
or {}
for moodId in pairs(registryMoods) do
characterMoodTokens[moodId] = stateMoodTokens[moodId] or 0
end
local postSelectionCharacterDraws = {}
if type(events) == "table" then
for index = #events, 1, -1 do
local event = events[index]
local causedByReveal = type(event) == "table"
and event.type == "effect_applied"
and type(event.cause) == "table"
and revealEventIds[event.cause.eventId] == true
local payload = causedByReveal and event.payload or nil
if type(payload) == "table" then
if (payload.op == "lose_stealth" or payload.op == "recover_stealth")
and payload.target == "player"
and isFinite(payload.before) then
playerStealth = payload.before
elseif (payload.op == "recover_resistance" or payload.op == "damage_resistance")
and payload.target == "character"
and isFinite(payload.before) then
characterResistance = payload.before
elseif payload.op == "draw_cards" and payload.target == "player" then
local drawnCount = type(payload.drawnInstanceIds) == "table" and #payload.drawnInstanceIds or 0
playerHandCount = playerHandCount - drawnCount
elseif payload.op == "draw_cards" and payload.target == "character" then
for _, instanceId in ipairs(type(payload.drawnInstanceIds) == "table" and payload.drawnInstanceIds or {}) do
postSelectionCharacterDraws[instanceId] = true
end
elseif (payload.op == "add_mood_token" or payload.op == "remove_mood_token")
and payload.target == "character"
and isAsciiId(payload.mood)
and isSafeInteger(payload.before, 0) then
characterMoodTokens[payload.mood] = payload.before
end
end
end
end
local hand = {}
for sourceIndex, instance in ipairs(type(state.cardInstances) == "table" and state.cardInstances or {}) do
if type(instance) == "table"
and instance.owner == "character"
and instance.zone == "hand"
and not postSelectionCharacterDraws[instance.instanceId] then
hand[#hand + 1] = {
instance = instance,
sourceIndex = sourceIndex,
}
end
end
table.sort(hand, function(left, right)
if left.instance.position ~= right.instance.position then
return left.instance.position < right.instance.position
end
if left.instance.instanceId ~= right.instance.instanceId then
return left.instance.instanceId < right.instance.instanceId
end
return left.sourceIndex < right.sourceIndex
end)
local characterHand = {}
for index, entry in ipairs(hand) do
local instance = entry.instance
local card = type(staticData) == "table" and type(staticData.cards) == "table" and staticData.cards[instance.cardId] or nil
characterHand[index] = {
instanceId = instance.instanceId,
cardId = instance.cardId,
role = type(card) == "table" and card.roles[1] or nil,
handPosition = instance.position,
}
end
return {
turnNumber = state.turnNumber,
player = {
stealth = playerStealth,
handCount = playerHandCount,
},
character = {
resistance = characterResistance,
mood = characterMood,
moodTokens = characterMoodTokens,
},
characterHand = characterHand,
history = projectHistoryContext(state.history),
}
end
local function historyContextEqual(left, right, seen)
if type(left) ~= type(right) then return false end
if type(left) ~= "table" then return left == right end
seen = seen or {}
if seen[left] ~= nil then return seen[left] == right end
seen[left] = right
for key, value in pairs(left) do
if not historyContextEqual(value, right[key], seen) then return false end
end
for key in pairs(right) do
if left[key] == nil then return false end
end
return true
end
local function selectionContextEqual(left, right)
if type(left) ~= "table" or type(right) ~= "table"
or left.turnNumber ~= right.turnNumber
or type(left.player) ~= "table" or type(right.player) ~= "table"
or left.player.stealth ~= right.player.stealth
or left.player.handCount ~= right.player.handCount
or type(left.character) ~= "table" or type(right.character) ~= "table"
or left.character.resistance ~= right.character.resistance
or left.character.mood ~= right.character.mood
or not historyContextEqual(left.character.moodTokens, right.character.moodTokens)
or not historyContextEqual(left.history, right.history)
or type(left.characterHand) ~= "table" or type(right.characterHand) ~= "table"
or #left.characterHand ~= #right.characterHand then
return false
end
for index, expected in ipairs(right.characterHand) do
local actual = left.characterHand[index]
if type(actual) ~= "table"
or actual.instanceId ~= expected.instanceId
or actual.cardId ~= expected.cardId
or actual.role ~= expected.role
or actual.handPosition ~= expected.handPosition then
return false
end
end
return true
end
local function callReceiptValidator(moduleName, moduleAction, ...)
if type(runScript) ~= "function" then
return nil, "스크립트 실행기를 찾을 수 없습니다."
end
local ok, report = pcall(runScript, triggerId, moduleName, moduleAction, ...)
if not ok then
return nil, tostring(report)
end
if type(report) ~= "table" then
return nil, "하위 검증기가 테이블 결과를 반환하지 않았습니다."
end
return report, nil
end
local function validateCharacterSelection(selection, state, staticData, referencesValidated, events, path, errors)
if type(selection) ~= "table" then
addError(errors, "invalid_character_selection_receipt", path, "캐릭터 선택 영수증이 객체가 아닙니다.")
return
end
checkAllowedKeys(selection, {
schemaVersion = true,
kind = true,
battleId = true,
turnNumber = true,
characterId = true,
selectionContext = true,
candidates = true,
weightedPoolInstanceIds = true,
lethalPriorityApplied = true,
weightOffset = true,
rngBefore = true,
rngAfter = true,
draw = true,
selectedInstanceId = true,
selectedCardId = true,
publicRole = true,
}, path, errors)
if selection.schemaVersion ~= SCHEMA_VERSION then
addError(errors, "invalid_selection_schema", path .. ".schemaVersion", "지원하지 않는 캐릭터 선택 영수증 스키마입니다.")
end
if selection.kind ~= "characterIntentSelection" then
addError(errors, "invalid_selection_kind", path .. ".kind", "kind는 characterIntentSelection이어야 합니다.")
end
if not isRuntimeId(selection.battleId) then
addError(errors, "invalid_battle_id", path .. ".battleId", "선택 영수증 battleId가 올바르지 않습니다.")
elseif selection.battleId ~= state.battleId then
addError(errors, "selection_battle_mismatch", path .. ".battleId", "선택 영수증 battleId가 현재 전투와 다릅니다.")
end
if not isInteger(selection.turnNumber, 1) then
addError(errors, "invalid_turn_number", path .. ".turnNumber", "선택 영수증 턴 번호는 1 이상의 정수여야 합니다.")
elseif selection.turnNumber ~= state.turnNumber then
addError(errors, "selection_turn_mismatch", path .. ".turnNumber", "선택 영수증 턴 번호가 현재 전투와 다릅니다.")
end
if not isAsciiId(selection.characterId) then
addError(errors, "invalid_character_id", path .. ".characterId", "선택 영수증 캐릭터 ID가 올바르지 않습니다.")
elseif type(state.character) == "table" and selection.characterId ~= state.character.characterId then
addError(errors, "selection_character_mismatch", path .. ".characterId", "선택 영수증 캐릭터 ID가 현재 전투와 다릅니다.")
end
local contextPath = path .. ".selectionContext"
local contextHandCount = validateSelectionContext(selection.selectionContext, contextPath, errors, staticData)
if type(selection.selectionContext) == "table" then
if selection.selectionContext.turnNumber ~= selection.turnNumber then
addError(errors, "selection_context_turn_mismatch", contextPath .. ".turnNumber", "선택 시점 컨텍스트의 턴 번호가 선택 영수증과 다릅니다.")
end
local contextMood = type(selection.selectionContext.character) == "table"
and selection.selectionContext.character.mood
or nil
if referencesValidated and isAsciiId(contextMood) then
local moods = type(staticData.registry) == "table" and staticData.registry.moods or nil
if type(moods) ~= "table" or moods[contextMood] == nil then
addError(errors, "unknown_mood", contextPath .. ".character.mood", "선택 시점 무드가 정적 레지스트리에 없습니다.")
end
end
local expectedContext = referencesValidated and buildExpectedSelectionContext(state, events, staticData) or nil
if expectedContext ~= nil and not selectionContextEqual(selection.selectionContext, expectedContext) then
addError(
errors,
"selection_context_state_mismatch",
contextPath,
"선택 시점 컨텍스트가 현재 상태와 역할 공개 이후 효과를 역산한 결과와 다릅니다."
)
end
end
local candidateCount = getArrayLength(selection.candidates, path .. ".candidates", errors)
local candidateById = {}
local positionSeen = {}
if candidateCount ~= nil then
for index = 1, candidateCount do
local candidate = selection.candidates[index]
local candidatePath = path .. ".candidates[" .. index .. "]"
validateSelectionCandidate(candidate, candidatePath, errors)
if type(candidate) == "table" then
if isRuntimeId(candidate.instanceId) then
if candidateById[candidate.instanceId] then
addError(errors, "duplicate_selection_candidate", candidatePath .. ".instanceId", "후보 인스턴스 ID가 중복되었습니다.")
else
candidateById[candidate.instanceId] = candidate
end
end
if isInteger(candidate.handPosition, 1) then
if positionSeen[candidate.handPosition] then
addError(errors, "duplicate_hand_position", candidatePath .. ".handPosition", "후보 손패 위치가 중복되었습니다.")
end
positionSeen[candidate.handPosition] = true
end
end
end
end
if candidateCount ~= nil and contextHandCount ~= nil then
if candidateCount ~= contextHandCount then
addError(errors, "selection_candidate_count_mismatch", path .. ".candidates", "후보 목록이 선택 시점 캐릭터 손패 전체와 장수가 다릅니다.")
end
local comparisonCount = math.min(candidateCount, contextHandCount)
for index = 1, comparisonCount do
local candidate = selection.candidates[index]
local handEntry = selection.selectionContext.characterHand[index]
local candidatePath = path .. ".candidates[" .. index .. "]"
if type(candidate) == "table" and type(handEntry) == "table" then
if candidate.instanceId ~= handEntry.instanceId
or candidate.cardId ~= handEntry.cardId
or candidate.role ~= handEntry.role
or candidate.handPosition ~= handEntry.handPosition then
addError(errors, "selection_candidate_hand_mismatch", candidatePath, "후보의 순서·인스턴스·카드·역할·위치가 선택 시점 손패와 다릅니다.")
end
local totals = candidate.totals
if type(totals) == "table"
and isFinite(totals.recoverResistance)
and isFinite(totals.loseStealth)
and isFinite(totals.damageResistance)
and isFinite(totals.recoverStealth)
and isSafeInteger(candidate.moodScore) then
local directScore = totals.recoverResistance
+ totals.loseStealth
- totals.damageResistance
- totals.recoverStealth
local expectedScore = directScore * CHARACTER_SCORE_SCALE + candidate.moodScore
if candidate.score ~= expectedScore then
addError(errors, "selection_score_mismatch", candidatePath .. ".score", "후보 점수가 직접 효과와 무드 평가 합계와 다릅니다.")
end
local contextStealth = type(selection.selectionContext.player) == "table"
and selection.selectionContext.player.stealth
or nil
if isFinite(contextStealth) then
local expectedStealth = contextStealth
- totals.loseStealth
+ totals.recoverStealth
if candidate.projectedPlayerStealth ~= expectedStealth then
addError(errors, "selection_projection_mismatch", candidatePath .. ".projectedPlayerStealth", "예상 플레이어 은폐가 선택 시점 효과 합계와 다릅니다.")
end
end
end
if referencesValidated and isAsciiId(candidate.cardId) then
local card = staticData.cards[candidate.cardId]
local expectedCharges = 0
if type(card) == "table" and card.cardType == "plan" then
local plan = type(card.mechanismData) == "table" and card.mechanismData.plan or nil
expectedCharges = type(plan) == "table" and plan.charges or nil
end
if candidate.planChargesEvaluated ~= expectedCharges then
addError(errors, "selection_plan_charges_mismatch", candidatePath .. ".planChargesEvaluated", "평가한 계획 충전 수가 정적 카드 정의와 다릅니다.")
end
end
end
end
end
if referencesValidated and type(selection.selectionContext) == "table" then
local replayReport, replayCallError = callReceiptValidator(
"characterSelector",
"validateReceipt",
staticData,
selection
)
if replayCallError ~= nil then
addError(errors, "selection_replay_unavailable", path, "캐릭터 선택 효과 재생 검증을 실행할 수 없습니다: " .. replayCallError)
elseif replayReport.ok ~= true then
local nestedErrors = type(replayReport.errors) == "table" and replayReport.errors or {}
if #nestedErrors == 0 then
addError(errors, "selection_replay_failed", path, "캐릭터 선택 효과 재생 검증이 실패했습니다.")
else
for _, nested in ipairs(nestedErrors) do
local nestedPath = type(nested) == "table" and nested.path or "$"
if type(nestedPath) == "string" and string.sub(nestedPath, 1, 9) == "$.receipt" then
nestedPath = path .. string.sub(nestedPath, 10)
else
nestedPath = path
end
addError(
errors,
type(nested) == "table" and tostring(nested.code) or "selection_replay_failed",
nestedPath,
type(nested) == "table" and tostring(nested.message) or "캐릭터 선택 효과 재생 검증이 실패했습니다."
)
end
end
elseif replayReport.valid ~= true then
addError(errors, "selection_replay_failed", path, "캐릭터 선택 효과 재생 검증기가 valid 결과를 반환하지 않았습니다.")
end
end
validateIdArray(selection.weightedPoolInstanceIds, path .. ".weightedPoolInstanceIds", errors, isRuntimeId)
local poolCount = type(selection.weightedPoolInstanceIds) == "table" and #selection.weightedPoolInstanceIds or 0
local poolIdSet = {}
for index, instanceId in ipairs(type(selection.weightedPoolInstanceIds) == "table" and selection.weightedPoolInstanceIds or {}) do
if candidateById[instanceId] == nil then
addError(errors, "unknown_selection_pool_candidate", path .. ".weightedPoolInstanceIds[" .. index .. "]", "가중 추첨 후보가 candidates에 없습니다.")
elseif poolIdSet[instanceId] then
addError(errors, "duplicate_selection_pool_candidate", path .. ".weightedPoolInstanceIds[" .. index .. "]", "가중 추첨 후보가 중복되었습니다.")
else
poolIdSet[instanceId] = true
end
end
if selection.lethalPriorityApplied ~= true and selection.lethalPriorityApplied ~= false then
addError(errors, "invalid_lethal_priority", path .. ".lethalPriorityApplied", "lethalPriorityApplied는 불리언이어야 합니다.")
end
local beforeValid = validateReceiptRng(selection.rngBefore, path .. ".rngBefore", errors)
local afterValid = validateReceiptRng(selection.rngAfter, path .. ".rngAfter", errors)
if beforeValid and afterValid then
if selection.rngAfter.seed ~= selection.rngBefore.seed then
addError(errors, "receipt_rng_seed_changed", path .. ".rngAfter.seed", "캐릭터 선택 중 RNG seed가 바뀔 수 없습니다.")
end
if selection.rngAfter.cursor < selection.rngBefore.cursor then
addError(errors, "receipt_rng_reversed", path .. ".rngAfter.cursor", "캐릭터 선택 중 RNG cursor가 이전으로 돌아갈 수 없습니다.")
end
end
validateSelectionDraw(selection.draw, path .. ".draw", errors)
local intent = type(state) == "table" and state.characterIntent or nil
local intentIds = type(intent) == "table" and intent.cardInstanceIds or nil
local selected = selection.selectedInstanceId ~= nil
if not selected then
if selection.selectedCardId ~= nil
or selection.publicRole ~= nil
or selection.weightOffset ~= nil then
addError(errors, "selection_pass_field_conflict", path, "패스 영수증에는 선택 카드 필드를 둘 수 없습니다.")
end
if type(selection.draw) ~= "table" or selection.draw.kind ~= "pass" then
addError(errors, "selection_pass_draw_mismatch", path .. ".draw", "패스 영수증의 draw.kind는 pass여야 합니다.")
end
if candidateCount ~= nil and candidateCount ~= 0 then
addError(errors, "selection_pass_has_candidates", path .. ".candidates", "패스 영수증에는 후보가 없어야 합니다.")
end
if poolCount ~= 0 then
addError(errors, "selection_pass_has_pool", path .. ".weightedPoolInstanceIds", "패스 영수증에는 가중 추첨 후보가 없어야 합니다.")
end
if selection.lethalPriorityApplied ~= false then
addError(errors, "selection_pass_lethal_priority", path .. ".lethalPriorityApplied", "패스에는 치명 우선순위를 적용할 수 없습니다.")
end
if beforeValid and afterValid and not rngEqual(selection.rngBefore, selection.rngAfter) then
addError(errors, "selection_pass_consumed_rng", path .. ".rngAfter", "패스는 RNG를 소비할 수 없습니다.")
end
if type(intentIds) ~= "table" or #intentIds ~= 0 or (type(intent) == "table" and intent.publicRole ~= nil) then
addError(errors, "character_selection_intent_mismatch", "$.characterIntent", "패스 영수증과 현재 characterIntent가 다릅니다.")
end
return
end
if not isRuntimeId(selection.selectedInstanceId) then
addError(errors, "invalid_instance_id", path .. ".selectedInstanceId", "선택한 카드 인스턴스 ID가 올바르지 않습니다.")
end
if not isAsciiId(selection.selectedCardId) then
addError(errors, "invalid_card_id", path .. ".selectedCardId", "선택한 카드 ID가 올바르지 않습니다.")
end
if not isAsciiId(selection.publicRole) then
addError(errors, "invalid_role", path .. ".publicRole", "선택한 공개 역할이 올바르지 않습니다.")
end
if not isSafeInteger(selection.weightOffset, 0) then
addError(errors, "invalid_selection_weight_offset", path .. ".weightOffset", "점수 가중치 평행이동 값은 0 이상의 안전한 정수여야 합니다.")
end
if type(selection.draw) ~= "table"
or (selection.draw.kind ~= "single" and selection.draw.kind ~= "weighted") then
addError(errors, "selection_selected_draw_mismatch", path .. ".draw", "선택 영수증은 single 또는 weighted 추첨을 사용해야 합니다.")
end
if candidateCount == 0 then
addError(errors, "selection_missing_candidates", path .. ".candidates", "선택 영수증에는 후보가 필요합니다.")
end
if poolCount == 0 then
addError(errors, "selection_missing_weighted_pool", path .. ".weightedPoolInstanceIds", "선택 영수증에는 가중 추첨 후보가 필요합니다.")
end
local selectedCandidate = candidateById[selection.selectedInstanceId]
if selectedCandidate == nil then
addError(errors, "selected_candidate_missing", path .. ".selectedInstanceId", "선택한 인스턴스가 candidates에 없습니다.")
else
if selectedCandidate.cardId ~= selection.selectedCardId then
addError(errors, "selected_card_mismatch", path .. ".selectedCardId", "선택 카드 ID가 후보와 다릅니다.")
end
if selectedCandidate.role ~= selection.publicRole then
addError(errors, "selected_role_mismatch", path .. ".publicRole", "선택 역할이 후보와 다릅니다.")
end
end
local anyLethal = false
if type(selection.candidates) == "table" then
for _, candidate in ipairs(selection.candidates) do
if type(candidate) == "table" and candidate.lethal == true then
anyLethal = true
break
end
end
end
if (selection.lethalPriorityApplied == true) ~= anyLethal then
addError(errors, "lethal_priority_mismatch", path .. ".lethalPriorityApplied", "치명 우선순위가 후보의 lethal 값과 다릅니다.")
end
local expectedPool = {}
local expectedPoolSet = {}
local minimumPoolScore = nil
local anyPositivePoolScore = false
if type(selection.candidates) == "table" then
for _, candidate in ipairs(selection.candidates) do
if type(candidate) == "table"
and isRuntimeId(candidate.instanceId)
and isSafeInteger(candidate.score)
and (not anyLethal or candidate.lethal == true) then
expectedPool[#expectedPool + 1] = candidate.instanceId
expectedPoolSet[candidate.instanceId] = true
if minimumPoolScore == nil or candidate.score < minimumPoolScore then
minimumPoolScore = candidate.score
end
if candidate.score > 0 then
anyPositivePoolScore = true
end
end
end
end
local poolMatches = #expectedPool == poolCount
if poolMatches then
for index = 1, poolCount do
if expectedPool[index] ~= selection.weightedPoolInstanceIds[index] then
poolMatches = false
break
end
end
end
if not poolMatches then
addError(errors, "selection_weighted_pool_mismatch", path .. ".weightedPoolInstanceIds", "가중 추첨 후보 배열이 치명 우선순위 결과와 다릅니다.")
end
local expectedOffset = nil
if minimumPoolScore ~= nil then
expectedOffset = minimumPoolScore <= 0 and (1 - minimumPoolScore) or 0
if not isSafeInteger(expectedOffset, 0) then
addError(errors, "invalid_selection_weight_offset", path .. ".weightOffset", "후보 점수에서 안전한 평행이동 값을 계산할 수 없습니다.")
elseif selection.weightOffset ~= expectedOffset then
addError(errors, "selection_weight_offset_mismatch", path .. ".weightOffset", "점수 가중치 평행이동 값이 후보 점수와 다릅니다.")
end
end
local totalWeight = 0
if type(selection.candidates) == "table" then
for index, candidate in ipairs(selection.candidates) do
if type(candidate) == "table" and isSafeInteger(candidate.score) then
local expectedWeight = 0
if expectedPoolSet[candidate.instanceId] and isSafeInteger(expectedOffset, 0) then
local adjusted = candidate.score + expectedOffset
if isSafeInteger(adjusted) and adjusted > 0 then
expectedWeight = adjusted
end
end
if candidate.weight ~= expectedWeight then
addError(errors, "selection_weight_mismatch", path .. ".candidates[" .. index .. "].weight", "후보 가중치가 총효과 점수 정책과 다릅니다.")
end
if expectedPoolSet[candidate.instanceId] and isSafeInteger(expectedWeight, 0) then
if isSafeInteger(totalWeight + expectedWeight, 0) then
totalWeight = totalWeight + expectedWeight
else
addError(errors, "selection_total_weight_overflow", path .. ".candidates", "가중 추첨 총합이 안전한 정수 범위를 벗어났습니다.")
end
end
end
end
end
if totalWeight <= 0 and poolCount > 0 then
addError(errors, "selection_zero_total_weight", path .. ".candidates", "가중 추첨 후보의 총 가중치는 1 이상이어야 합니다.")
end
if selectedCandidate ~= nil and not expectedPoolSet[selection.selectedInstanceId] then
addError(errors, "selected_candidate_outside_pool", path .. ".selectedInstanceId", "선택된 카드는 가중 추첨 후보에 포함되어야 합니다.")
end
local draw = selection.draw
if type(draw) == "table" and draw.kind == "single" then
if poolCount ~= 1 or selection.weightedPoolInstanceIds[1] ~= selection.selectedInstanceId then
addError(errors, "single_draw_mismatch", path .. ".draw", "single 추첨은 유일한 가중 추첨 후보를 선택해야 합니다.")
elseif draw.totalWeight ~= totalWeight then
addError(errors, "draw_weight_mismatch", path .. ".draw.totalWeight", "single 총 가중치가 후보 가중치와 다릅니다.")
end
if beforeValid and afterValid and not rngEqual(selection.rngBefore, selection.rngAfter) then
addError(errors, "single_selection_consumed_rng", path .. ".rngAfter", "single 선택은 RNG를 소비할 수 없습니다.")
end
elseif type(draw) == "table" and draw.kind == "weighted" then
if poolCount < 2 then
addError(errors, "weighted_draw_missing_candidates", path .. ".weightedPoolInstanceIds", "weighted 추첨에는 후보가 둘 이상 필요합니다.")
end
if draw.totalWeight ~= totalWeight then
addError(errors, "draw_weight_mismatch", path .. ".draw.totalWeight", "weighted 총 가중치가 추첨 후보 가중치 합과 다릅니다.")
end
if isSafeInteger(draw.roll, 1) then
local cumulative = 0
local rolledInstanceId = nil
for _, instanceId in ipairs(type(selection.weightedPoolInstanceIds) == "table" and selection.weightedPoolInstanceIds or {}) do
local candidate = candidateById[instanceId]
if candidate and isSafeInteger(candidate.weight, 0) then
cumulative = cumulative + candidate.weight
if candidate.weight > 0 and draw.roll <= cumulative then
rolledInstanceId = instanceId
break
end
end
end
if rolledInstanceId ~= selection.selectedInstanceId then
addError(errors, "weighted_result_mismatch", path .. ".selectedInstanceId", "weighted roll 결과와 선택 인스턴스가 다릅니다.")
end
end
if beforeValid and isSafeInteger(totalWeight, 1) then
local rngReplay, rngReplayCallError = callReceiptValidator(
"deterministicRng",
"nextInteger",
selection.rngBefore,
1,
totalWeight
)
if rngReplayCallError ~= nil then
addError(errors, "selection_rng_replay_unavailable", path .. ".draw", "선택 RNG를 재생할 수 없습니다: " .. rngReplayCallError)
elseif rngReplay.ok ~= true then
addError(errors, "selection_rng_replay_failed", path .. ".draw", "결정적 선택 RNG 재생이 실패했습니다.")
else
if rngReplay.value ~= draw.roll then
addError(errors, "selection_roll_replay_mismatch", path .. ".draw.roll", "기록된 roll이 rngBefore와 총 가중치의 결정적 재생 결과와 다릅니다.")
end
if afterValid and not rngEqual(rngReplay.rng, selection.rngAfter) then
addError(errors, "selection_rng_after_replay_mismatch", path .. ".rngAfter", "기록된 rngAfter가 결정적 가중 추첨 재생 결과와 다릅니다.")
end
end
end
if beforeValid and afterValid and selection.rngAfter.cursor <= selection.rngBefore.cursor then
addError(errors, "weighted_selection_rng_missing", path .. ".rngAfter.cursor", "weighted 선택은 RNG cursor를 전진시켜야 합니다.")
end
end
if type(intentIds) ~= "table"
or #intentIds ~= 1
or intentIds[1] ~= selection.selectedInstanceId
or type(intent) ~= "table"
or intent.publicRole ~= selection.publicRole then
addError(errors, "character_selection_intent_mismatch", "$.characterIntent", "선택 영수증과 현재 characterIntent가 다릅니다.")
end
local instance = findStateInstance(state, selection.selectedInstanceId)
if instance == nil
or instance.owner ~= "character"
or instance.zone ~= "hand"
or instance.cardId ~= selection.selectedCardId then
addError(errors, "selected_instance_mismatch", path .. ".selectedInstanceId", "선택 인스턴스가 현재 캐릭터 손패·카드와 일치하지 않습니다.")
end
if referencesValidated and isAsciiId(selection.selectedCardId) then
local card = staticData.cards[selection.selectedCardId]
if type(card) ~= "table"
or card.owner ~= "character"
or card.roles[1] ~= selection.publicRole then
addError(errors, "selected_static_card_mismatch", path .. ".selectedCardId", "선택 카드와 정적 카드 역할이 일치하지 않습니다.")
end
end
end
local function validateTurnStartReceipt(receipt, state, staticData, referencesValidated, errors)
local path = "$.turnStartReceipt"
if type(receipt) ~= "table" then
addError(errors, "invalid_turn_start_receipt", path, "turnStartReceipt가 객체가 아닙니다.")
return
end
checkAllowedKeys(receipt, {
schemaVersion = true,
kind = true,
turnId = true,
turnNumber = true,
authorityFingerprint = true,
draws = true,
characterSelection = true,
baseline = true,
transient = true,
events = true,
}, path, errors)
if receipt.schemaVersion ~= SCHEMA_VERSION then
addError(errors, "invalid_receipt_schema", path .. ".schemaVersion", "지원하지 않는 turnStartReceipt 스키마입니다.")
end
if receipt.kind ~= "turnStartReceipt" then
addError(errors, "invalid_receipt_kind", path .. ".kind", "kind는 turnStartReceipt여야 합니다.")
end
if not isRuntimeId(receipt.turnId) then
addError(errors, "invalid_turn_id", path .. ".turnId", "turnStartReceipt turnId가 올바르지 않습니다.")
elseif state.lastCommittedTurnId == receipt.turnId then
addError(errors, "turn_already_committed", path .. ".turnId", "이미 확정한 turnId를 현재 턴 초기화에 사용할 수 없습니다.")
end
if not isInteger(receipt.turnNumber, 1) then
addError(errors, "invalid_turn_number", path .. ".turnNumber", "turnStartReceipt 턴 번호는 1 이상의 정수여야 합니다.")
elseif receipt.turnNumber ~= state.turnNumber then
addError(errors, "receipt_turn_mismatch", path .. ".turnNumber", "turnStartReceipt 턴 번호가 현재 전투 턴과 다릅니다.")
end
if state.status ~= "active" then
addError(errors, "receipt_requires_active", path, "turnStartReceipt는 active 전투 상태에만 존재할 수 있습니다.")
end
local fingerprintPath = path .. ".authorityFingerprint"
local fingerprintValid = validateAuthorityFingerprint(receipt.authorityFingerprint, fingerprintPath, errors)
if fingerprintValid then
local expectedFingerprint, fingerprintError = fingerprintAuthorityState(state)
if fingerprintError then
addError(errors, fingerprintError.code, fingerprintError.path, fingerprintError.message)
elseif receipt.authorityFingerprint.algorithm ~= expectedFingerprint.algorithm
or receipt.authorityFingerprint.length ~= expectedFingerprint.length
or receipt.authorityFingerprint.hashA ~= expectedFingerprint.hashA
or receipt.authorityFingerprint.hashB ~= expectedFingerprint.hashB then
addError(
errors,
"receipt_authority_mismatch",
fingerprintPath,
"turnStartReceipt가 현재 권위 battleState와 일치하지 않습니다."
)
end
end
validateDraws(receipt.draws, state, path .. ".draws", errors)
validateCharacterSelection(
receipt.characterSelection,
state,
staticData,
referencesValidated,
receipt.events,
path .. ".characterSelection",
errors
)
local characterDrawAfter = type(receipt.draws) == "table"
and type(receipt.draws.character) == "table"
and receipt.draws.character.rngAfter
or nil
local selectionRngBefore = type(receipt.characterSelection) == "table"
and receipt.characterSelection.rngBefore
or nil
if type(characterDrawAfter) == "table"
and type(selectionRngBefore) == "table"
and not rngEqual(characterDrawAfter, selectionRngBefore) then
addError(
errors,
"receipt_rng_discontinuity",
path .. ".characterSelection.rngBefore",
"캐릭터 선택 RNG 시작점이 캐릭터 드로우 종료점과 다릅니다."
)
end
local baseline = receipt.baseline
if type(baseline) ~= "table" then
addError(errors, "invalid_receipt_baseline", path .. ".baseline", "turnStartReceipt baseline이 객체가 아닙니다.")
else
checkAllowedKeys(baseline, {
stealth = true,
resistance = true,
mood = true,
moodTokens = true,
}, path .. ".baseline", errors)
if not isFinite(baseline.stealth) then
addError(errors, "invalid_receipt_baseline", path .. ".baseline.stealth", "baseline 은폐가 유한한 숫자가 아닙니다.")
end
if not isFinite(baseline.resistance) then
addError(errors, "invalid_receipt_baseline", path .. ".baseline.resistance", "baseline 저항이 유한한 숫자가 아닙니다.")
end
if not isAsciiId(baseline.mood) then
addError(errors, "invalid_receipt_baseline", path .. ".baseline.mood", "baseline 무드 ID가 올바르지 않습니다.")
elseif referencesValidated then
local moods = type(staticData.registry) == "table" and staticData.registry.moods or nil
if type(moods) ~= "table" or not moods[baseline.mood] then
addError(errors, "unknown_mood", path .. ".baseline.mood", "baseline 무드가 레지스트리에 없습니다.")
end
end
if type(baseline.moodTokens) ~= "table" then
addError(errors, "invalid_receipt_baseline", path .. ".baseline.moodTokens", "baseline 무드 토큰이 객체가 아닙니다.")
elseif referencesValidated then
local moods = staticData.registry.moods
for moodId in pairs(moods) do
if not isSafeInteger(baseline.moodTokens[moodId], 0) then
addError(errors, "invalid_mood_token_count", path .. ".baseline.moodTokens." .. moodId, "무드 토큰 수는 0 이상의 안전한 정수여야 합니다.")
end
end
for moodId in pairs(baseline.moodTokens) do
if not moods[moodId] then
addError(errors, "unknown_mood", path .. ".baseline.moodTokens." .. tostring(moodId), "등록되지 않은 무드의 토큰입니다.")
end
end
end
end
local transient = receipt.transient
if type(transient) ~= "table" then
addError(errors, "invalid_receipt_transient", path .. ".transient", "turnStartReceipt transient가 객체가 아닙니다.")
else
checkAllowedKeys(transient, {
skipRemaining = true,
forcedMoodRequests = true,
moodTokenDebt = true,
}, path .. ".transient", errors)
if transient.moodTokenDebt ~= nil then
if type(transient.moodTokenDebt) ~= "table" then
addError(errors, "invalid_mood_token_debt", path .. ".transient.moodTokenDebt", "무드 토큰 감소 잔액이 올바르지 않습니다.")
else
for moodId, count in pairs(transient.moodTokenDebt) do
if not isAsciiId(moodId) or not isSafeInteger(count, 0)
or (referencesValidated and not staticData.registry.moods[moodId]) then
addError(errors, "invalid_mood_token_debt", path .. ".transient.moodTokenDebt", "무드 토큰 감소 잔액이 올바르지 않습니다.")
end
end
end
end
local skipRemaining = transient.skipRemaining
if type(skipRemaining) ~= "table" then
addError(errors, "invalid_skip_state", path .. ".transient.skipRemaining", "skipRemaining이 객체가 아닙니다.")
else
checkAllowedKeys(skipRemaining, {
player = true,
character = true,
}, path .. ".transient.skipRemaining", errors)
for _, side in ipairs({ "player", "character" }) do
if skipRemaining[side] ~= true and skipRemaining[side] ~= false then
addError(errors, "invalid_skip_state", path .. ".transient.skipRemaining." .. side, "skipRemaining 값은 불리언이어야 합니다.")
end
end
end
local forcedRequestCount = getArrayLength(
transient.forcedMoodRequests,
path .. ".transient.forcedMoodRequests",
errors
)
if forcedRequestCount then
for index = 1, forcedRequestCount do
local request = transient.forcedMoodRequests[index]
local requestPath = path .. ".transient.forcedMoodRequests[" .. index .. "]"
if type(request) ~= "table" then
addError(errors, "invalid_forced_mood_request", requestPath, "무드 강제 변경 요청이 객체가 아닙니다.")
else
checkAllowedKeys(request, {
mood = true,
cause = true,
}, requestPath, errors)
if not isAsciiId(request.mood) then
addError(errors, "invalid_forced_mood_request", requestPath .. ".mood", "강제 변경 무드 ID가 올바르지 않습니다.")
elseif referencesValidated and not staticData.registry.moods[request.mood] then
addError(errors, "unknown_mood", requestPath .. ".mood", "강제 변경 무드가 레지스트리에 없습니다.")
end
if not isAsciiId(request.cause) then
addError(errors, "invalid_forced_mood_cause", requestPath .. ".cause", "강제 변경 cause는 lower_snake_case여야 합니다.")
end
end
end
end
end
validateTurnStartEvents(receipt.events, receipt.turnId, path .. ".events", errors)
end
local function subwayStationsAdjacent(line, leftId, rightId)
for _, routePath in ipairs(type(line) == "table" and line.paths or {}) do
local stations = routePath.stations
for index = 1, #stations - 1 do
local left = stations[index].id
local right = stations[index + 1].id
if (left == leftId and right == rightId)
or (left == rightId and right == leftId) then
return true
end
end
if routePath.circular == true and #stations > 1 then
local first = stations[1].id
local last = stations[#stations].id
if (first == leftId and last == rightId)
or (first == rightId and last == leftId) then
return true
end
end
end
return false
end
local function subwayStationExists(line, stationId)
for _, routePath in ipairs(type(line) == "table" and line.paths or {}) do
for _, station in ipairs(routePath.stations or {}) do
if station.id == stationId then
return true
end
end
end
return false
end
local function transitEqual(left, right)
if type(left) ~= "table" or type(right) ~= "table"
or left.algorithm ~= right.algorithm
or left.lineId ~= right.lineId
or type(left.stationIds) ~= "table"
or type(right.stationIds) ~= "table"
or #left.stationIds ~= #right.stationIds then
return false
end
for index = 1, #left.stationIds do
if left.stationIds[index] ~= right.stationIds[index] then
return false
end
end
return true
end
local function sceneContextEqual(left, right)
return type(left) == "table"
and type(right) == "table"
and left.weekday == right.weekday
and left.time == right.time
and left.weather == right.weather
end
local function validateSceneContext(sceneContext, errors)
local path = "$.sceneContext"
if type(sceneContext) ~= "table" then
addError(errors, "invalid_scene_context", path, "전투 배경 정보가 테이블이 아닙니다.")
return
end
checkAllowedKeys(sceneContext, { weekday = true, time = true, weather = true }, path, errors)
if VALID_SCENE_WEEKDAYS[sceneContext.weekday] ~= true then
addError(errors, "invalid_scene_weekday", path .. ".weekday", "전투 배경 요일이 올바르지 않습니다.")
end
if VALID_SCENE_TIMES[sceneContext.time] ~= true then
addError(errors, "invalid_scene_time", path .. ".time", "전투 배경 시간대가 올바르지 않습니다.")
end
if VALID_SCENE_WEATHERS[sceneContext.weather] ~= true then
addError(errors, "invalid_scene_weather", path .. ".weather", "전투 배경 날씨가 올바르지 않습니다.")
end
local weekdayIsWeekend = sceneContext.weekday == "토요일" or sceneContext.weekday == "일요일"
local timeIsWeekend = sceneContext.time == "아침 시간" or sceneContext.time == "저녁 시간"
if weekdayIsWeekend ~= timeIsWeekend
and sceneContext.time ~= "한낮"
and sceneContext.time ~= "심야열차" then
addError(errors, "scene_schedule_mismatch", path .. ".time", "요일과 시간대 구분이 서로 맞지 않습니다.")
end
end
local function validateTransit(transit, turnLimit, staticData, errors)
local path = "$.transit"
if type(transit) ~= "table" then
addError(errors, "invalid_transit", path, "전투 이동 구간이 테이블이 아닙니다.")
return
end
checkAllowedKeys(transit, {
algorithm = true,
lineId = true,
stationIds = true,
}, path, errors)
if transit.algorithm ~= "tokyo_subway_segment_v1" then
addError(errors, "invalid_transit_algorithm", path .. ".algorithm", "지원하지 않는 지하철 여정 알고리즘입니다.")
end
if not isAsciiId(transit.lineId) then
addError(errors, "invalid_transit_line_id", path .. ".lineId", "지하철 노선 ID가 올바르지 않습니다.")
end
local stationCount = getArrayLength(transit.stationIds, path .. ".stationIds", errors)
if stationCount ~= nil then
if isInteger(turnLimit, 1) and stationCount ~= turnLimit + 1 then
addError(errors, "transit_length_mismatch", path .. ".stationIds", "이동 역 수는 제한 턴보다 하나 많아야 합니다.")
end
local seen = {}
for index = 1, stationCount do
local stationId = transit.stationIds[index]
if not isAsciiId(stationId) then
addError(errors, "invalid_transit_station_id", path .. ".stationIds[" .. index .. "]", "이동 역 ID가 올바르지 않습니다.")
elseif seen[stationId] then
addError(errors, "duplicate_transit_station", path .. ".stationIds[" .. index .. "]", "한 여정에서 같은 역을 두 번 지날 수 없습니다.")
else
seen[stationId] = true
end
end
end
if type(staticData) == "table" and type(staticData.subwayLines) == "table" then
local line = staticData.subwayLines[transit.lineId]
if type(line) ~= "table" then
addError(errors, "unknown_transit_line", path .. ".lineId", "정적 DB에서 지하철 노선을 찾을 수 없습니다.")
elseif stationCount ~= nil then
for index = 1, stationCount do
local stationId = transit.stationIds[index]
if isAsciiId(stationId) and not subwayStationExists(line, stationId) then
addError(errors, "unknown_transit_station", path .. ".stationIds[" .. index .. "]", "선택 노선에서 이동 역을 찾을 수 없습니다.")
end
if index > 1 then
local previousId = transit.stationIds[index - 1]
if isAsciiId(previousId)
and isAsciiId(stationId)
and not subwayStationsAdjacent(line, previousId, stationId) then
addError(errors, "non_adjacent_transit_station", path .. ".stationIds[" .. index .. "]", "이동 구간에 서로 인접하지 않은 역이 있습니다.")
end
end
end
end
end
end
local function historyStateForValidation(state, baseline, staticData, errors)
if baseline == nil then return state end
local path = "$.validationContext.historyBaseline"
local errorCount = #errors
if type(baseline) ~= "table" or getmetatable(baseline) ~= nil then
addError(errors, "invalid_history_baseline", path, "이력 검증 기준값이 일반 객체가 아닙니다.")
return state
end
checkAllowedKeys(baseline, {
stealth = true,
resistance = true,
mood = true,
}, path, errors)
if not isFinite(baseline.stealth) then
addError(errors, "invalid_history_baseline", path .. ".stealth", "이력 검증 기준 은폐가 유한한 숫자가 아닙니다.")
end
if not isFinite(baseline.resistance) then
addError(errors, "invalid_history_baseline", path .. ".resistance", "이력 검증 기준 저항이 유한한 숫자가 아닙니다.")
end
if not isAsciiId(baseline.mood) then
addError(errors, "invalid_history_baseline", path .. ".mood", "이력 검증 기준 무드 ID가 올바르지 않습니다.")
elseif type(staticData) == "table"
and type(staticData.registry) == "table"
and type(staticData.registry.moods) == "table"
and not staticData.registry.moods[baseline.mood] then
addError(errors, "unknown_mood", path .. ".mood", "이력 검증 기준 무드가 레지스트리에 없습니다.")
end
if type(state) == "table" and state.turnStartReceipt ~= nil then
addError(errors, "history_baseline_with_receipt", path, "턴 시작 영수증이 있는 상태에는 별도 이력 기준값을 사용할 수 없습니다.")
end
if #errors > errorCount
or type(state) ~= "table"
or type(state.player) ~= "table"
or type(state.character) ~= "table" then
return state
end
local historyState = {}
for key, value in pairs(state) do historyState[key] = value end
historyState.player = {}
for key, value in pairs(state.player) do historyState.player[key] = value end
historyState.character = {}
for key, value in pairs(state.character) do historyState.character[key] = value end
historyState.player.stealth = baseline.stealth
historyState.character.resistance = baseline.resistance
historyState.character.mood = baseline.mood
return historyState
end
local function validateBattleState(state, staticData, historyBaseline)
local errors = {}
local staticDataProvided = staticData ~= nil
staticData = normalizeStaticData(staticData)
local referencesValidated = hasCompleteStaticData(staticData)
if staticDataProvided and not referencesValidated then
addError(errors, "invalid_static_data", "$", "전달한 정적 데이터가 전체 참조 검증에 필요한 컬렉션을 갖추지 못했습니다.")
end
if not referencesValidated then
staticData = nil
end
if type(state) ~= "table" then
addError(errors, "invalid_state", "$", "battleState가 테이블이 아닙니다.")
return result(errors)
end
validateJsonSafe(state, "$", errors)
if #errors > 0 then
local report = result(errors)
report.referencesValidated = referencesValidated
return report
end
checkAllowedKeys(state, {
schemaVersion = true,
kind = true,
battleId = true,
status = true,
turnNumber = true,
turnLimit = true,
transit = true,
sceneContext = true,
lastCommittedTurnId = true,
rng = true,
player = true,
character = true,
cardInstances = true,
selection = true,
characterIntent = true,
history = true,
turnStartReceipt = true,
turnStartOutcome = true,
}, "$", errors)
if state.schemaVersion ~= SCHEMA_VERSION then
addError(errors, "unsupported_schema", "$.schemaVersion", "지원하지 않는 battleState 스키마 버전입니다.")
end
if state.kind ~= "battleState" then
addError(errors, "invalid_kind", "$.kind", "kind는 battleState여야 합니다.")
end
if not isRuntimeId(state.battleId) then
addError(errors, "invalid_battle_id", "$.battleId", "battleId가 올바르지 않습니다.")
end
if not VALID_STATUS[state.status] then
addError(errors, "invalid_status", "$.status", "알 수 없는 전투 상태입니다.")
end
if not isInteger(state.turnNumber, 1) then
addError(errors, "invalid_turn_number", "$.turnNumber", "현재 턴은 1 이상의 정수여야 합니다.")
end
if not isInteger(state.turnLimit, 7) or state.turnLimit > 12 then
addError(errors, "invalid_turn_limit", "$.turnLimit", "제한 턴은 7 이상 12 이하의 정수여야 합니다.")
elseif isInteger(state.turnNumber, 1) and state.turnNumber > state.turnLimit then
addError(errors, "turn_over_limit", "$.turnNumber", "현재 턴이 제한 턴을 초과했습니다.")
end
validateTransit(state.transit, state.turnLimit, staticData, errors)
validateSceneContext(state.sceneContext, errors)
if state.lastCommittedTurnId ~= nil and not isRuntimeId(state.lastCommittedTurnId) then
addError(errors, "invalid_turn_id", "$.lastCommittedTurnId", "마지막 확정 턴 ID가 올바르지 않습니다.")
end
if state.turnStartOutcome ~= nil
and state.turnStartOutcome ~= "victory"
and state.turnStartOutcome ~= "defeat" then
addError(errors, "invalid_turn_start_outcome", "$.turnStartOutcome", "턴 시작 승패 대기값이 올바르지 않습니다.")
elseif state.turnStartOutcome ~= nil and state.status ~= "active" then
addError(errors, "terminal_turn_start_outcome", "$.turnStartOutcome", "종료 상태에는 턴 시작 승패 대기값을 남길 수 없습니다.")
end
if type(state.rng) ~= "table" then
addError(errors, "invalid_rng", "$.rng", "rng가 테이블이 아닙니다.")
else
checkAllowedKeys(state.rng, { seed = true, cursor = true }, "$.rng", errors)
if not isSafeInteger(state.rng.seed, 0) then
addError(errors, "invalid_rng_seed", "$.rng.seed", "난수 시드는 0 이상이고 안전한 숫자 범위 안의 정수여야 합니다.")
end
if not isSafeInteger(state.rng.cursor, 0) then
addError(errors, "invalid_rng_cursor", "$.rng.cursor", "난수 커서는 0 이상이고 안전한 숫자 범위 안의 정수여야 합니다.")
end
end
if type(state.player) ~= "table" then
addError(errors, "invalid_player", "$.player", "player가 테이블이 아닙니다.")
else
checkAllowedKeys(state.player, {
stealth = true,
baseDrawCount = true,
maxHandSize = true,
perkIds = true,
planCapacity = true,
planSlots = true,
}, "$.player", errors)
if not isFinite(state.player.stealth) then
addError(errors, "invalid_stealth", "$.player.stealth", "은폐는 유한한 숫자여야 합니다.")
end
if not isInteger(state.player.baseDrawCount, 1) then
addError(errors, "invalid_base_draw_count", "$.player.baseDrawCount", "기본 드로우 수는 1 이상의 정수여야 합니다.")
end
if not isInteger(state.player.maxHandSize, 1) then
addError(errors, "invalid_hand_size", "$.player.maxHandSize", "최대 손패는 1 이상의 정수여야 합니다.")
end
if isInteger(state.player.baseDrawCount, 1)
and isInteger(state.player.maxHandSize, 1)
and state.player.baseDrawCount > state.player.maxHandSize then
addError(errors, "draw_exceeds_hand_limit", "$.player.baseDrawCount", "기본 드로우 수는 최대 손패보다 클 수 없습니다.")
end
validateIdArray(state.player.perkIds, "$.player.perkIds", errors, isAsciiId)
end
if type(state.character) ~= "table" then
addError(errors, "invalid_character", "$.character", "character가 테이블이 아닙니다.")
else
checkAllowedKeys(state.character, {
characterId = true,
resistance = true,
mood = true,
moodTokens = true,
traitIds = true,
baseDrawCount = true,
maxHandSize = true,
planCapacity = true,
planSlots = true,
}, "$.character", errors)
if not isAsciiId(state.character.characterId) then
addError(errors, "invalid_character_id", "$.character.characterId", "캐릭터 ID가 올바르지 않습니다.")
end
if not isFinite(state.character.resistance) then
addError(errors, "invalid_resistance", "$.character.resistance", "저항은 유한한 숫자여야 합니다.")
end
if not isAsciiId(state.character.mood) then
addError(errors, "invalid_mood", "$.character.mood", "무드 ID가 올바르지 않습니다.")
end
if state.character.moodTokens ~= nil then
if type(state.character.moodTokens) ~= "table" then
addError(errors, "invalid_mood_tokens", "$.character.moodTokens", "무드 토큰이 객체가 아닙니다.")
elseif referencesValidated then
local moods = staticData.registry.moods
for moodId in pairs(moods) do
if not isSafeInteger(state.character.moodTokens[moodId], 0) then
addError(errors, "invalid_mood_token_count", "$.character.moodTokens." .. moodId, "무드 토큰 수는 0 이상의 안전한 정수여야 합니다.")
end
end
for moodId in pairs(state.character.moodTokens) do
if not moods[moodId] then
addError(errors, "unknown_mood", "$.character.moodTokens." .. tostring(moodId), "등록되지 않은 무드의 토큰입니다.")
end
end
end
end
if not isInteger(state.character.baseDrawCount, 1) then
addError(errors, "invalid_base_draw_count", "$.character.baseDrawCount", "기본 드로우 수는 1 이상의 정수여야 합니다.")
end
if not isInteger(state.character.maxHandSize, 1) then
addError(errors, "invalid_hand_size", "$.character.maxHandSize", "최대 손패는 1 이상의 정수여야 합니다.")
end
if isInteger(state.character.baseDrawCount, 1)
and isInteger(state.character.maxHandSize, 1)
and state.character.baseDrawCount > state.character.maxHandSize then
addError(errors, "draw_exceeds_hand_limit", "$.character.baseDrawCount", "기본 드로우 수는 최대 손패보다 클 수 없습니다.")
end
validateIdArray(state.character.traitIds, "$.character.traitIds", errors, isAsciiId)
end
local instances = {}
local positions = {}
local instanceCount = getArrayLength(state.cardInstances, "$.cardInstances", errors)
if instanceCount then
for index = 1, instanceCount do
local item = state.cardInstances[index]
local path = "$.cardInstances[" .. index .. "]"
if type(item) ~= "table" then
addError(errors, "invalid_card_instance", path, "카드 인스턴스가 테이블이 아닙니다.")
else
checkAllowedKeys(item, {
instanceId = true,
cardId = true,
owner = true,
zone = true,
position = true,
temporaryModifiers = true,
}, path, errors)
if not isRuntimeId(item.instanceId) then
addError(errors, "invalid_instance_id", path .. ".instanceId", "카드 인스턴스 ID가 올바르지 않습니다.")
elseif instances[item.instanceId] then
addError(errors, "duplicate_instance_id", path .. ".instanceId", "카드 인스턴스 ID가 중복되었습니다.")
else
instances[item.instanceId] = item
end
if not isAsciiId(item.cardId) then
addError(errors, "invalid_card_id", path .. ".cardId", "카드 ID가 올바르지 않습니다.")
end
if not VALID_OWNER[item.owner] then
addError(errors, "invalid_owner", path .. ".owner", "카드 소유자가 올바르지 않습니다.")
end
if not VALID_ZONE[item.zone] then
addError(errors, "invalid_zone", path .. ".zone", "카드 영역이 올바르지 않습니다.")
end
if not isInteger(item.position, 1) then
addError(errors, "invalid_position", path .. ".position", "카드 위치는 1 이상의 정수여야 합니다.")
elseif VALID_OWNER[item.owner] and VALID_ZONE[item.zone] then
local group = item.owner .. ":" .. item.zone
positions[group] = positions[group] or {}
positions[group][item.position] = (positions[group][item.position] or 0) + 1
end
if item.temporaryModifiers ~= nil then
local modifierCount = getArrayLength(item.temporaryModifiers, path .. ".temporaryModifiers", errors)
if modifierCount and modifierCount > 0 then
addError(
errors,
"temporary_modifier_schema_pending",
path .. ".temporaryModifiers",
"임시 카드 보정 스키마가 확정되기 전에는 빈 배열만 허용합니다."
)
end
end
local cards = type(staticData) == "table" and staticData.cards or nil
local card = type(cards) == "table" and cards[item.cardId] or nil
if type(cards) == "table" and not card then
addError(errors, "unknown_card", path .. ".cardId", "정적 DB에서 카드를 찾을 수 없습니다.")
elseif card and card.owner ~= item.owner then
addError(errors, "card_owner_mismatch", path .. ".owner", "정적 카드와 인스턴스의 소유자가 다릅니다.")
end
end
end
end
for group, groupPositions in pairs(positions) do
local count = 0
local maximum = 0
for position, occurrence in pairs(groupPositions) do
count = count + occurrence
if position > maximum then
maximum = position
end
if occurrence > 1 then
addError(errors, "duplicate_position", "$.cardInstances", group .. " 영역의 position이 중복되었습니다: " .. position)
end
end
if count ~= maximum then
addError(errors, "non_contiguous_positions", "$.cardInstances", group .. " 영역의 position이 1부터 이어지지 않습니다.")
end
if group == "player:hand"
and type(state.player) == "table"
and isInteger(state.player.maxHandSize, 1)
and count > state.player.maxHandSize then
addError(errors, "hand_limit_exceeded", "$.cardInstances", "플레이어 손패가 최대 손패를 초과했습니다.")
elseif group == "character:hand"
and type(state.character) == "table"
and isInteger(state.character.maxHandSize, 1)
and count > state.character.maxHandSize then
addError(errors, "hand_limit_exceeded", "$.cardInstances", "캐릭터 손패가 최대 손패를 초과했습니다.")
end
end
if type(state.player) == "table" then
validatePlanSlots(
state.player.planSlots,
state.player.planCapacity,
"player",
"$.player.planSlots",
errors,
instances,
staticData,
state.turnNumber
)
end
if type(state.character) == "table" then
validatePlanSlots(
state.character.planSlots,
state.character.planCapacity,
"character",
"$.character.planSlots",
errors,
instances,
staticData,
state.turnNumber
)
end
for instanceId, instance in pairs(instances) do
if instance.zone == "plan" and VALID_OWNER[instance.owner] then
local ownerState = instance.owner == "player" and state.player or state.character
local slots = type(ownerState) == "table" and ownerState.planSlots or nil
local slot = type(slots) == "table" and slots[instance.position] or nil
if type(slot) ~= "table"
or slot.occupied ~= true
or slot.cardInstanceId ~= instanceId then
addError(
errors,
"orphan_plan_instance",
"$.cardInstances",
"plan 영역의 카드 인스턴스는 같은 진영의 점유 슬롯과 정확히 연결되어야 합니다: " .. instanceId
)
end
end
end
if type(state.selection) ~= "table" then
addError(errors, "invalid_selection", "$.selection", "selection이 테이블이 아닙니다.")
else
checkAllowedKeys(state.selection, { playerCardInstanceIds = true }, "$.selection", errors)
validateIdArray(state.selection.playerCardInstanceIds, "$.selection.playerCardInstanceIds", errors, isRuntimeId)
if type(state.selection.playerCardInstanceIds) == "table" then
local mainActionCount = 0
local mainActionIndex = nil
for index, instanceId in ipairs(state.selection.playerCardInstanceIds) do
local instance = instances[instanceId]
if not instance or instance.owner ~= "player" or instance.zone ~= "hand" then
addError(errors, "invalid_selected_card", "$.selection.playerCardInstanceIds[" .. index .. "]", "선택 카드는 플레이어 손패에 있어야 합니다.")
elseif referencesValidated then
local card = staticData.cards[instance.cardId]
if card and card.cardType ~= "chain" then
mainActionCount = mainActionCount + 1
mainActionIndex = index
end
end
end
if mainActionCount > 1 then
addError(errors, "multiple_player_main_actions", "$.selection.playerCardInstanceIds", "플레이어 선택에는 주 행동을 둘 이상 넣을 수 없습니다.")
elseif mainActionIndex and mainActionIndex ~= #state.selection.playerCardInstanceIds then
addError(errors, "player_main_action_not_last", "$.selection.playerCardInstanceIds", "연계 카드는 주 행동보다 앞에 있어야 합니다.")
end
end
end
if type(state.characterIntent) ~= "table" then
addError(errors, "invalid_character_intent", "$.characterIntent", "characterIntent가 테이블이 아닙니다.")
else
checkAllowedKeys(state.characterIntent, {
cardInstanceIds = true,
publicRole = true,
}, "$.characterIntent", errors)
validateIdArray(state.characterIntent.cardInstanceIds, "$.characterIntent.cardInstanceIds", errors, isRuntimeId)
local intentCount = type(state.characterIntent.cardInstanceIds) == "table"
and #state.characterIntent.cardInstanceIds
or 0
if intentCount == 0 then
if state.characterIntent.publicRole ~= nil then
addError(errors, "orphan_public_role", "$.characterIntent.publicRole", "선택 카드가 없으면 공개 역할도 없어야 합니다.")
end
elseif not isAsciiId(state.characterIntent.publicRole) then
addError(errors, "missing_public_role", "$.characterIntent.publicRole", "캐릭터 선택의 공개 역할이 필요합니다.")
end
local mainCards = {}
local mainCardIndex = nil
if type(state.characterIntent.cardInstanceIds) == "table" then
for index, instanceId in ipairs(state.characterIntent.cardInstanceIds) do
local instance = instances[instanceId]
if not instance or instance.owner ~= "character" or instance.zone ~= "hand" then
addError(errors, "invalid_intent_card", "$.characterIntent.cardInstanceIds[" .. index .. "]", "캐릭터 선택 카드는 캐릭터 손패에 있어야 합니다.")
else
local cards = type(staticData) == "table" and staticData.cards or nil
local card = type(cards) == "table" and cards[instance.cardId] or nil
if card and card.cardType ~= "chain" then
table.insert(mainCards, card)
mainCardIndex = index
end
end
end
end
if type(staticData) == "table" and intentCount > 0 then
if #mainCards ~= 1 then
addError(errors, "invalid_character_main_action", "$.characterIntent.cardInstanceIds", "캐릭터 선택에는 주 행동 카드가 정확히 하나 있어야 합니다.")
elseif mainCardIndex ~= intentCount then
addError(errors, "character_main_action_not_last", "$.characterIntent.cardInstanceIds", "캐릭터 연계 카드는 주 행동보다 앞에 있어야 합니다.")
elseif mainCards[1].roles[1] ~= state.characterIntent.publicRole then
addError(errors, "public_role_mismatch", "$.characterIntent.publicRole", "공개 역할이 실제 주 행동과 다릅니다.")
end
end
local registry = type(staticData) == "table" and staticData.registry or nil
local roles = type(registry) == "table" and registry.roles or nil
local publicRole = type(roles) == "table" and roles[state.characterIntent.publicRole] or nil
if state.characterIntent.publicRole ~= nil and type(roles) == "table" then
if not publicRole then
addError(errors, "unknown_public_role", "$.characterIntent.publicRole", "등록되지 않은 역할입니다.")
elseif publicRole.owner ~= "character" then
addError(errors, "public_role_owner_mismatch", "$.characterIntent.publicRole", "캐릭터 역할이 아닙니다.")
end
end
end
if type(staticData) == "table" then
if type(state.character) == "table" then
if type(staticData.characters) == "table" and not staticData.characters[state.character.characterId] then
addError(errors, "unknown_character", "$.character.characterId", "정적 DB에서 캐릭터를 찾을 수 없습니다.")
end
if type(staticData.registry) == "table"
and type(staticData.registry.moods) == "table"
and not staticData.registry.moods[state.character.mood] then
addError(errors, "unknown_mood", "$.character.mood", "등록되지 않은 무드입니다.")
end
if type(staticData.traits) == "table" and type(state.character.traitIds) == "table" then
for index, traitId in ipairs(state.character.traitIds) do
if not staticData.traits[traitId] then
addError(errors, "unknown_trait", "$.character.traitIds[" .. index .. "]", "정적 DB에서 특징을 찾을 수 없습니다.")
end
end
end
end
end
local historyState = historyStateForValidation(state, historyBaseline, staticData, errors)
local historyReport, historyCallError = callReceiptValidator(
"battleHistory",
"validate",
state.history,
historyState,
staticData
)
if historyCallError ~= nil then
addError(errors, "history_validation_unavailable", "$.history", "전투 이력 검증을 실행할 수 없습니다: " .. historyCallError)
elseif historyReport.ok ~= true then
appendNestedErrors(errors, "$.history", historyReport)
end
if state.turnStartReceipt ~= nil then
validateTurnStartReceipt(state.turnStartReceipt, state, staticData, referencesValidated, errors)
end
if type(state.player) == "table" and type(state.character) == "table"
and isFinite(state.player.stealth) and isFinite(state.character.resistance) then
local resourceOutcome = state.character.resistance <= 0 and "victory"
or (state.player.stealth <= 0 and "defeat" or nil)
if state.turnStartOutcome ~= nil and state.turnStartOutcome ~= resourceOutcome then
addError(errors, "turn_start_outcome_mismatch", "$.turnStartOutcome", "턴 시작 승패 대기값이 현재 자원 수치와 일치하지 않습니다.")
elseif state.turnStartOutcome == nil
and state.character.resistance <= 0
and state.status ~= "victory" then
addError(errors, "victory_priority", "$.status", "저항이 0 이하이면 동시 은폐 소진보다 승리를 우선해야 합니다.")
elseif state.turnStartOutcome == nil
and state.character.resistance > 0
and state.player.stealth <= 0
and state.status ~= "defeat" then
addError(errors, "defeat_required", "$.status", "은폐가 0 이하이면 패배 상태여야 합니다.")
elseif state.turnStartOutcome == nil
and state.status == "active"
and (state.character.resistance <= 0 or state.player.stealth <= 0) then
addError(errors, "active_outcome_conflict", "$.status", "종료 수치에서 active 상태를 유지할 수 없습니다.")
elseif state.status == "victory" and state.character.resistance > 0 then
addError(errors, "invalid_victory", "$.status", "저항이 남아 있으면 승리 상태일 수 없습니다.")
elseif state.status == "defeat"
and state.player.stealth > 0
and isInteger(state.turnNumber, 1)
and isInteger(state.turnLimit, 1)
and state.turnNumber < state.turnLimit then
addError(errors, "invalid_defeat", "$.status", "은폐가 남고 제한 턴 전이면 패배 상태일 수 없습니다.")
end
end
local report = result(errors, state)
report.referencesValidated = referencesValidated
return report
end
local function fingerprintBattleState(state, staticData)
local validation = validateBattleState(state, staticData)
if not validation.ok then
return validation
end
if validation.referencesValidated ~= true then
local errors = {}
addError(
errors,
"static_references_not_validated",
"$.staticData",
"battleState fingerprint에는 전체 정적 데이터 참조 검증이 필요합니다."
)
local report = result(errors)
report.referencesValidated = false
return report
end
local authorityFingerprint, fingerprintError = fingerprintAuthorityState(state)
if fingerprintError then
local errors = {}
addError(errors, fingerprintError.code, fingerprintError.path, fingerprintError.message)
local report = result(errors)
report.referencesValidated = true
return report
end
return {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
referencesValidated = true,
fingerprint = authorityFingerprint,
}
end
local function sealTurnStartReceipt(state, staticData)
local errors = {}
if type(state) ~= "table" or type(state.turnStartReceipt) ~= "table" then
addError(errors, "missing_unsealed_turn_receipt", "$.turnStartReceipt", "봉인할 turnStartReceipt가 없습니다.")
return result(errors)
end
if state.turnStartReceipt.authorityFingerprint ~= nil then
addError(errors, "turn_receipt_already_sealed", "$.turnStartReceipt.authorityFingerprint", "이미 authorityFingerprint가 있는 영수증은 다시 봉인할 수 없습니다.")
return result(errors)
end
local authorityFingerprint, fingerprintError = fingerprintAuthorityState(state)
if fingerprintError then
addError(errors, fingerprintError.code, fingerprintError.path, fingerprintError.message)
return result(errors)
end
local function cloneValue(value, path, active)
local valueType = type(value)
if valueType == "nil" or valueType == "string" or valueType == "boolean" then
return value, nil
end
if valueType == "number" then
if not isFinite(value) then
return nil, { code = "non_finite_number", path = path, message = "NaN과 무한대는 봉인 상태에 사용할 수 없습니다." }
end
return value, nil
end
if valueType ~= "table" or getmetatable(value) ~= nil then
return nil, { code = "unsupported_type", path = path, message = "봉인 상태에 사용할 수 없는 값입니다." }
end
active = active or {}
if active[value] then
return nil, { code = "circular_reference", path = path, message = "순환 참조가 있는 상태는 봉인할 수 없습니다." }
end
active[value] = true
local copy = {}
for key, item in pairs(value) do
local itemCopy, itemError = cloneValue(item, objectPath(path, key), active)
if itemError then
active[value] = nil
return nil, itemError
end
copy[key] = itemCopy
end
active[value] = nil
return copy, nil
end
local sealedState, cloneError = cloneValue(state, "$", {})
if cloneError then
addError(errors, cloneError.code, cloneError.path, cloneError.message)
return result(errors)
end
sealedState.turnStartReceipt.authorityFingerprint = authorityFingerprint
local reportFingerprint, reportFingerprintError = cloneValue(
authorityFingerprint,
"$.fingerprint",
{}
)
if reportFingerprintError then
addError(
errors,
reportFingerprintError.code,
reportFingerprintError.path,
reportFingerprintError.message
)
return result(errors)
end
local validation = validateBattleState(sealedState, staticData)
if not validation.ok then
return validation
end
if validation.referencesValidated ~= true then
addError(errors, "static_references_not_validated", "$.staticData", "turnStartReceipt 봉인에는 전체 정적 데이터 참조 검증이 필요합니다.")
local report = result(errors)
report.referencesValidated = false
return report
end
return {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
referencesValidated = true,
state = sealedState,
fingerprint = reportFingerprint,
}
end
local function validateEventEnvelope(value, path, errors)
if type(value) ~= "table" then
addError(errors, "invalid_event_envelope", path, "사건 묶음이 테이블이 아닙니다.")
return
end
checkAllowedKeys(value, { schemaVersion = true, events = true }, path, errors)
if value.schemaVersion ~= SCHEMA_VERSION then
addError(errors, "unsupported_schema", path .. ".schemaVersion", "지원하지 않는 사건 묶음 스키마입니다.")
end
getArrayLength(value.events, path .. ".events", errors)
end
local function arraysEqual(left, right)
if type(left) ~= "table" or type(right) ~= "table" or #left ~= #right then
return false
end
for index = 1, #left do
if left[index] ~= right[index] then
return false
end
end
return true
end
local function dataEqual(left, right, seen)
if type(left) ~= type(right) then return false end
if type(left) ~= "table" then return left == right end
if getmetatable(left) ~= nil or getmetatable(right) ~= nil then return false end
seen = seen or {}
if seen[left] ~= nil then return seen[left] == right end
seen[left] = right
for key, value in pairs(left) do
if not dataEqual(value, right[key], seen) then return false end
end
for key in pairs(right) do
if left[key] == nil then return false end
end
return true
end
local function fingerprintsEqual(left, right)
return type(left) == "table"
and type(right) == "table"
and left.algorithm == right.algorithm
and left.length == right.length
and left.hashA == right.hashA
and left.hashB == right.hashB
end
local function validateDraftFingerprint(value, path, errors)
if type(value) ~= "table" then
addError(errors, "invalid_projection_fingerprint", path, "projection 원본 fingerprint가 객체가 아닙니다.")
return false
end
checkAllowedKeys(value, {
algorithm = true,
length = true,
hashA = true,
hashB = true,
}, path, errors)
local valid = true
if value.algorithm ~= DRAFT_FINGERPRINT_ALGORITHM then
addError(errors, "invalid_projection_fingerprint_algorithm", path .. ".algorithm", "지원하지 않는 projection 원본 fingerprint 알고리즘입니다.")
valid = false
end
for _, field in ipairs({ "length", "hashA", "hashB" }) do
if not isSafeInteger(value[field], 0) then
addError(errors, "invalid_projection_fingerprint", path .. "." .. field, "projection 원본 fingerprint 수치는 0 이상의 안전한 정수여야 합니다.")
valid = false
end
end
return valid
end
local function validatePendingIntegrity(pending, errors)
local path = "$.integrity"
local value = pending.integrity
if type(value) ~= "table" then
addError(errors, "missing_pending_integrity", path, "pendingTurn에는 전체 저장값 무결성 영수증이 필요합니다.")
return
end
checkAllowedKeys(value, {
algorithm = true,
length = true,
hashA = true,
hashB = true,
}, path, errors)
local valid = true
if value.algorithm ~= PENDING_INTEGRITY_ALGORITHM then
addError(errors, "invalid_pending_integrity_algorithm", path .. ".algorithm", "지원하지 않는 pendingTurn 무결성 알고리즘입니다.")
valid = false
end
for _, field in ipairs({ "length", "hashA", "hashB" }) do
if not isSafeInteger(value[field], 0) then
addError(errors, "invalid_pending_integrity", path .. "." .. field, "pendingTurn 무결성 수치는 0 이상의 안전한 정수여야 합니다.")
valid = false
end
end
if not valid then
return
end
local expected, fingerprintError = fingerprintPendingTurn(pending)
if fingerprintError then
addError(errors, fingerprintError.code, fingerprintError.path, fingerprintError.message)
elseif not fingerprintsEqual(value, expected) then
addError(errors, "pending_integrity_mismatch", path, "pendingTurn 저장값이 생성 뒤 변경되었습니다.")
end
end
local function validateProjectionReceiptShape(receipt, path, errors)
if type(receipt) ~= "table" then
addError(errors, "invalid_projection_receipt", path, "projectionReceipt가 객체가 아닙니다.")
return
end
checkAllowedKeys(receipt, {
schemaVersion = true,
kind = true,
mode = true,
selectedCardInstanceIds = true,
effectChoiceByInstanceId = true,
source = true,
projectedRng = true,
}, path, errors)
if receipt.schemaVersion ~= SCHEMA_VERSION then
addError(errors, "unsupported_projection_receipt_schema", path .. ".schemaVersion", "지원하지 않는 projectionReceipt 스키마입니다.")
end
if receipt.kind ~= "turnDraftProjectionReceipt" then
addError(errors, "invalid_projection_receipt_kind", path .. ".kind", "kind는 turnDraftProjectionReceipt여야 합니다.")
end
if receipt.mode ~= "pass" and receipt.mode ~= "chain_pass" and receipt.mode ~= "action" then
addError(errors, "invalid_projection_mode", path .. ".mode", "알 수 없는 projection mode입니다.")
end
validateIdArray(receipt.selectedCardInstanceIds, path .. ".selectedCardInstanceIds", errors, isRuntimeId)
if receipt.effectChoiceByInstanceId ~= nil and type(receipt.effectChoiceByInstanceId) ~= "table" then
addError(errors, "invalid_effect_choice_map", path .. ".effectChoiceByInstanceId", "효과 선택값은 객체여야 합니다.")
else
local selected = {}
for _, instanceId in ipairs(type(receipt.selectedCardInstanceIds) == "table" and receipt.selectedCardInstanceIds or {}) do
selected[instanceId] = true
end
for instanceId, choiceId in pairs(receipt.effectChoiceByInstanceId or {}) do
if not isRuntimeId(instanceId) or not selected[instanceId]
or not isAsciiId(choiceId) then
addError(errors, "invalid_effect_choice", path .. ".effectChoiceByInstanceId." .. tostring(instanceId), "봉인된 효과 선택값이 올바르지 않습니다.")
end
end
end
local selectedCount = type(receipt.selectedCardInstanceIds) == "table" and #receipt.selectedCardInstanceIds or 0
if receipt.mode == "pass" and selectedCount ~= 0 then
addError(errors, "projection_pass_has_selection", path .. ".selectedCardInstanceIds", "pass projection에는 등록 카드가 없어야 합니다.")
elseif (receipt.mode == "chain_pass" or receipt.mode == "action") and selectedCount == 0 then
addError(errors, "projection_mode_missing_selection", path .. ".selectedCardInstanceIds", "카드가 있는 projection mode에는 등록 카드가 필요합니다.")
end
local source = receipt.source
if type(source) ~= "table" then
addError(errors, "invalid_projection_source", path .. ".source", "projection 원본 표식이 객체가 아닙니다.")
else
checkAllowedKeys(source, {
battleId = true,
status = true,
turnNumber = true,
lastCommittedTurnId = true,
rng = true,
fingerprint = true,
}, path .. ".source", errors)
if not isRuntimeId(source.battleId) then
addError(errors, "invalid_battle_id", path .. ".source.battleId", "projection 원본 battleId가 올바르지 않습니다.")
end
if source.status ~= "active" then
addError(errors, "invalid_projection_source_status", path .. ".source.status", "projection 원본 상태는 active여야 합니다.")
end
if not isInteger(source.turnNumber, 1) then
addError(errors, "invalid_turn_number", path .. ".source.turnNumber", "projection 원본 턴 번호가 올바르지 않습니다.")
end
if source.lastCommittedTurnId ~= nil and not isRuntimeId(source.lastCommittedTurnId) then
addError(errors, "invalid_turn_id", path .. ".source.lastCommittedTurnId", "projection 원본 마지막 확정 턴 ID가 올바르지 않습니다.")
end
validateReceiptRng(source.rng, path .. ".source.rng", errors)
validateDraftFingerprint(source.fingerprint, path .. ".source.fingerprint", errors)
end
validateReceiptRng(receipt.projectedRng, path .. ".projectedRng", errors)
if type(source) == "table" and type(source.rng) == "table" and type(receipt.projectedRng) == "table" then
if receipt.projectedRng.seed ~= source.rng.seed then
addError(errors, "projection_rng_seed_changed", path .. ".projectedRng.seed", "projection 중 RNG seed가 바뀔 수 없습니다.")
end
if isInteger(source.rng.cursor, 0)
and isInteger(receipt.projectedRng.cursor, 0)
and receipt.projectedRng.cursor < source.rng.cursor then
addError(errors, "projection_rng_reversed", path .. ".projectedRng.cursor", "projection RNG cursor가 이전으로 돌아갈 수 없습니다.")
end
end
end
local function validatePendingTurn(pending, staticData)
local errors = {}
local staticDataProvided = staticData ~= nil
staticData = normalizeStaticData(staticData)
local referencesValidated = hasCompleteStaticData(staticData)
if staticDataProvided and not referencesValidated then
addError(errors, "invalid_static_data", "$", "전달한 정적 데이터가 전체 참조 검증에 필요한 컬렉션을 갖추지 못했습니다.")
end
if not referencesValidated then
staticData = nil
end
if type(pending) ~= "table" then
addError(errors, "invalid_pending_turn", "$", "pendingTurn이 테이블이 아닙니다.")
return result(errors)
end
validateJsonSafe(pending, "$", errors)
if #errors > 0 then
local report = result(errors)
report.referencesValidated = referencesValidated
return report
end
checkAllowedKeys(pending, {
schemaVersion = true,
kind = true,
battleId = true,
turnId = true,
status = true,
beforeState = true,
projectionReceipt = true,
selectedCards = true,
turnResult = true,
afterState = true,
integrity = true,
}, "$", errors)
if pending.schemaVersion ~= SCHEMA_VERSION then
addError(errors, "unsupported_schema", "$.schemaVersion", "지원하지 않는 pendingTurn 스키마 버전입니다.")
end
if pending.kind ~= "pendingTurn" then
addError(errors, "invalid_kind", "$.kind", "kind는 pendingTurn이어야 합니다.")
end
if not isRuntimeId(pending.battleId) then
addError(errors, "invalid_battle_id", "$.battleId", "battleId가 올바르지 않습니다.")
end
if not isRuntimeId(pending.turnId) then
addError(errors, "invalid_turn_id", "$.turnId", "turnId가 올바르지 않습니다.")
end
if pending.status ~= "awaitingOutput" then
addError(errors, "invalid_pending_status", "$.status", "대기 트랜잭션 상태는 awaitingOutput이어야 합니다.")
end
local beforeResult = validateBattleState(pending.beforeState, staticData)
if not beforeResult.ok then
appendNestedErrors(errors, "$.beforeState", beforeResult)
end
local afterResult = validateBattleState(pending.afterState, staticData)
if not afterResult.ok then
appendNestedErrors(errors, "$.afterState", afterResult)
end
validateProjectionReceiptShape(pending.projectionReceipt, "$.projectionReceipt", errors)
if type(pending.selectedCards) ~= "table" then
addError(errors, "invalid_selected_cards", "$.selectedCards", "selectedCards가 테이블이 아닙니다.")
else
checkAllowedKeys(pending.selectedCards, { player = true, character = true }, "$.selectedCards", errors)
validateIdArray(pending.selectedCards.player, "$.selectedCards.player", errors, isRuntimeId)
validateIdArray(pending.selectedCards.character, "$.selectedCards.character", errors, isRuntimeId)
end
if type(pending.turnResult) ~= "table" then
addError(errors, "invalid_turn_result", "$.turnResult", "turnResult가 테이블이 아닙니다.")
else
checkAllowedKeys(pending.turnResult, {
events = true,
publicResult = true,
llmEvent = true,
}, "$.turnResult", errors)
getArrayLength(pending.turnResult.events, "$.turnResult.events", errors)
validateEventEnvelope(pending.turnResult.publicResult, "$.turnResult.publicResult", errors)
validateEventEnvelope(pending.turnResult.llmEvent, "$.turnResult.llmEvent", errors)
end
if type(pending.turnResult) == "table" and type(pending.afterState) == "table" then
local history = pending.afterState.history
local turns = type(history) == "table" and history.turns or nil
local lastEntry = type(turns) == "table" and turns[#turns] or nil
if type(lastEntry) ~= "table" or lastEntry.turnId ~= pending.turnId then
addError(errors, "pending_history_turn_mismatch", "$.afterState.history.turns", "afterState 전투 이력의 마지막 턴이 pendingTurn과 다릅니다.")
elseif not dataEqual(lastEntry.publicResult, pending.turnResult.publicResult) then
addError(errors, "pending_history_public_result_mismatch", "$.afterState.history.turns", "전투 이력의 공개 로그와 pendingTurn 공개 결과가 다릅니다.")
end
end
if type(pending.beforeState) == "table" and type(pending.afterState) == "table" then
if pending.beforeState.battleId ~= pending.battleId then
addError(errors, "before_battle_mismatch", "$.beforeState.battleId", "beforeState의 전투 ID가 다릅니다.")
end
if pending.afterState.battleId ~= pending.battleId then
addError(errors, "after_battle_mismatch", "$.afterState.battleId", "afterState의 전투 ID가 다릅니다.")
end
if pending.beforeState.lastCommittedTurnId == pending.turnId then
addError(errors, "turn_already_committed", "$.beforeState.lastCommittedTurnId", "beforeState에 이미 같은 턴이 반영되었습니다.")
end
if pending.afterState.lastCommittedTurnId ~= pending.turnId then
addError(errors, "after_turn_not_marked", "$.afterState.lastCommittedTurnId", "afterState에 대기 턴 ID가 기록되어야 합니다.")
end
if pending.beforeState.status ~= "active" then
addError(errors, "before_state_not_active", "$.beforeState.status", "종료된 전투에서 새 대기 턴을 만들 수 없습니다.")
end
local beforeSelection = type(pending.beforeState.selection) == "table"
and pending.beforeState.selection.playerCardInstanceIds
or nil
if type(beforeSelection) ~= "table" or #beforeSelection ~= 0 then
addError(errors, "pending_authority_selection_not_empty", "$.beforeState.selection.playerCardInstanceIds", "pendingTurn의 권위 beforeState에는 플레이어 드래프트 선택을 저장할 수 없습니다.")
end
local startReceipt = pending.beforeState.turnStartReceipt
if type(startReceipt) ~= "table" then
addError(errors, "pending_missing_turn_start_receipt", "$.beforeState.turnStartReceipt", "pendingTurn beforeState에는 봉인된 turnStartReceipt가 필요합니다.")
elseif startReceipt.turnId ~= pending.turnId then
addError(errors, "pending_turn_id_mismatch", "$.turnId", "pendingTurn turnId가 beforeState.turnStartReceipt와 다릅니다.")
end
if pending.afterState.turnStartReceipt ~= nil then
addError(errors, "pending_after_turn_receipt_present", "$.afterState.turnStartReceipt", "해결된 afterState에는 turnStartReceipt를 남길 수 없습니다.")
end
local afterSelection = type(pending.afterState.selection) == "table"
and pending.afterState.selection.playerCardInstanceIds
or nil
if type(afterSelection) ~= "table" or #afterSelection ~= 0 then
addError(errors, "pending_after_selection_not_empty", "$.afterState.selection.playerCardInstanceIds", "해결된 afterState에는 플레이어 선택을 남길 수 없습니다.")
end
local afterIntent = pending.afterState.characterIntent
local afterIntentIds = type(afterIntent) == "table" and afterIntent.cardInstanceIds or nil
if type(afterIntentIds) ~= "table" or #afterIntentIds ~= 0 then
addError(errors, "pending_after_character_intent_not_empty", "$.afterState.characterIntent.cardInstanceIds", "해결된 afterState에는 캐릭터 선택을 남길 수 없습니다.")
end
if type(afterIntent) == "table" and afterIntent.publicRole ~= nil then
addError(errors, "pending_after_public_role_present", "$.afterState.characterIntent.publicRole", "해결된 afterState에는 공개 역할을 남길 수 없습니다.")
end
if isInteger(pending.beforeState.turnNumber, 1)
and isInteger(pending.afterState.turnNumber, 1)
and pending.afterState.turnNumber < pending.beforeState.turnNumber then
addError(errors, "turn_number_reversed", "$.afterState.turnNumber", "afterState의 턴 번호가 이전으로 돌아갈 수 없습니다.")
elseif isInteger(pending.beforeState.turnNumber, 1)
and isInteger(pending.afterState.turnNumber, 1)
and pending.afterState.turnNumber > pending.beforeState.turnNumber + 1 then
addError(errors, "turn_number_skipped", "$.afterState.turnNumber", "한 번의 대기 트랜잭션에서 턴을 둘 이상 건너뛸 수 없습니다.")
end
if pending.afterState.turnLimit ~= pending.beforeState.turnLimit then
addError(errors, "turn_limit_changed", "$.afterState.turnLimit", "한 턴 판정 중 제한 턴을 바꿀 수 없습니다.")
end
if not sceneContextEqual(pending.afterState.sceneContext, pending.beforeState.sceneContext) then
addError(errors, "scene_context_changed", "$.afterState.sceneContext", "한 턴 판정 중 배경 정보를 바꿀 수 없습니다.")
end
if not transitEqual(pending.afterState.transit, pending.beforeState.transit) then
addError(errors, "transit_changed", "$.afterState.transit", "한 턴 판정 중 지하철 이동 구간을 바꿀 수 없습니다.")
end
local beforeCharacter = type(pending.beforeState.character) == "table" and pending.beforeState.character.characterId or nil
local afterCharacter = type(pending.afterState.character) == "table" and pending.afterState.character.characterId or nil
if afterCharacter ~= beforeCharacter then
addError(errors, "character_changed", "$.afterState.character.characterId", "한 전투의 캐릭터를 턴 판정 중 바꿀 수 없습니다.")
end
local beforeRng = pending.beforeState.rng
local afterRng = pending.afterState.rng
if type(beforeRng) == "table" and type(afterRng) == "table" then
if afterRng.seed ~= beforeRng.seed then
addError(errors, "rng_seed_changed", "$.afterState.rng.seed", "한 전투의 난수 시드를 턴 판정 중 바꿀 수 없습니다.")
end
if isInteger(beforeRng.cursor, 0)
and isInteger(afterRng.cursor, 0)
and afterRng.cursor < beforeRng.cursor then
addError(errors, "rng_cursor_reversed", "$.afterState.rng.cursor", "난수 커서는 이전으로 돌아갈 수 없습니다.")
end
end
local projectionReceipt = pending.projectionReceipt
if type(projectionReceipt) == "table" then
local source = projectionReceipt.source
if type(source) == "table" then
if source.battleId ~= pending.battleId
or source.battleId ~= pending.beforeState.battleId then
addError(errors, "projection_battle_mismatch", "$.projectionReceipt.source.battleId", "projectionReceipt battleId가 pendingTurn 권위 상태와 다릅니다.")
end
if source.status ~= pending.beforeState.status then
addError(errors, "projection_status_mismatch", "$.projectionReceipt.source.status", "projectionReceipt 상태가 beforeState와 다릅니다.")
end
if source.turnNumber ~= pending.beforeState.turnNumber then
addError(errors, "projection_turn_mismatch", "$.projectionReceipt.source.turnNumber", "projectionReceipt 턴 번호가 beforeState와 다릅니다.")
end
if source.lastCommittedTurnId ~= pending.beforeState.lastCommittedTurnId then
addError(errors, "projection_commit_mismatch", "$.projectionReceipt.source.lastCommittedTurnId", "projectionReceipt 마지막 확정 턴 ID가 beforeState와 다릅니다.")
end
if not rngEqual(source.rng, pending.beforeState.rng) then
addError(errors, "projection_rng_mismatch", "$.projectionReceipt.source.rng", "projectionReceipt 시작 RNG가 beforeState와 다릅니다.")
end
local expectedFingerprint, fingerprintError = fingerprintDraftAuthorityState(pending.beforeState)
if fingerprintError then
addError(errors, fingerprintError.code, fingerprintError.path, fingerprintError.message)
elseif not fingerprintsEqual(source.fingerprint, expectedFingerprint) then
addError(errors, "projection_fingerprint_mismatch", "$.projectionReceipt.source.fingerprint", "projectionReceipt fingerprint가 beforeState 전체와 다릅니다.")
end
end
local projectedRng = projectionReceipt.projectedRng
if type(projectedRng) == "table"
and type(afterRng) == "table"
and isInteger(projectedRng.cursor, 0)
and isInteger(afterRng.cursor, 0)
and afterRng.cursor < projectedRng.cursor then
addError(errors, "after_rng_before_projection", "$.afterState.rng.cursor", "afterState RNG cursor는 선택 projection이 소비한 위치보다 이전일 수 없습니다.")
end
end
if type(pending.selectedCards) == "table" then
local selected = type(projectionReceipt) == "table"
and projectionReceipt.selectedCardInstanceIds
or nil
local intent = type(pending.beforeState.characterIntent) == "table"
and pending.beforeState.characterIntent.cardInstanceIds
or nil
if not arraysEqual(pending.selectedCards.player, selected) then
addError(errors, "player_selection_mismatch", "$.selectedCards.player", "projectionReceipt의 플레이어 선택과 다릅니다.")
end
if not arraysEqual(pending.selectedCards.character, intent) then
addError(errors, "character_selection_mismatch", "$.selectedCards.character", "beforeState의 캐릭터 선택과 다릅니다.")
end
end
end
validatePendingIntegrity(pending, errors)
local report = result(errors, pending)
report.referencesValidated = referencesValidated
report.projectionReplayValidated = false
return report
end
local function cloneJson(value, active)
local valueType = type(value)
if valueType ~= "table" then
if valueType == "string" or valueType == "number" or valueType == "boolean" or valueType == "nil" then
return value
end
error("unsupported type: " .. valueType)
end
if getmetatable(value) ~= nil then
error("metatable is not allowed")
end
active = active or {}
if active[value] then
error("circular reference")
end
active[value] = true
local copy = {}
for key, item in pairs(value) do
copy[cloneJson(key, active)] = cloneJson(item, active)
end
active[value] = nil
return copy
end
local function constructBattleState(options, staticData)
if type(options) ~= "table" then
local errors = {}
addError(errors, "invalid_options", "$", "battleState 생성 사양이 테이블이 아닙니다.")
return result(errors)
end
local ok, state = pcall(function()
local value = cloneJson(options)
value.schemaVersion = SCHEMA_VERSION
value.kind = "battleState"
local normalizedStaticData = normalizeStaticData(staticData)
if type(value.character) == "table" and value.character.moodTokens == nil
and type(normalizedStaticData) == "table"
and type(normalizedStaticData.registry) == "table"
and type(normalizedStaticData.registry.moods) == "table" then
value.character.moodTokens = {}
for moodId in pairs(normalizedStaticData.registry.moods) do
value.character.moodTokens[moodId] = 0
end
end
if value.history == nil then
value.history = {
schemaVersion = SCHEMA_VERSION,
kind = "battleHistory",
turns = {},
}
end
return value
end)
if not ok then
local errors = {}
addError(errors, "construct_failed", "$", "battleState 생성에 실패했습니다: " .. tostring(state))
return result(errors)
end
local validation = validateBattleState(state, staticData)
if not validation.ok then
return validation
end
local report = result({}, state)
report.referencesValidated = validation.referencesValidated
return report
end
local function constructPendingTurn(spec, staticData)
if type(spec) ~= "table" then
local errors = {}
addError(errors, "invalid_spec", "$", "pendingTurn 생성 사양이 테이블이 아닙니다.")
return result(errors)
end
local ok, pending = pcall(function()
local value = cloneJson(spec)
value.schemaVersion = SCHEMA_VERSION
value.kind = "pendingTurn"
value.status = "awaitingOutput"
value.integrity = nil
return value
end)
if not ok then
local errors = {}
addError(errors, "construct_failed", "$", "pendingTurn 생성에 실패했습니다: " .. tostring(pending))
return result(errors)
end
local integrity, integrityError = fingerprintPendingTurn(pending)
if integrityError then
local errors = {}
addError(errors, integrityError.code, integrityError.path, integrityError.message)
return result(errors)
end
pending.integrity = integrity
local validation = validatePendingTurn(pending, staticData)
if not validation.ok then
return validation
end
local report = result({}, pending)
report.referencesValidated = validation.referencesValidated
report.projectionReplayValidated = false
return report
end
local arguments = { ... }
if action == "newBattleState" then
return constructBattleState(arguments[1], arguments[2])
elseif action == "validateBattleState" then
return validateBattleState(arguments[1], arguments[2], arguments[3])
elseif action == "fingerprintBattleState" then
return fingerprintBattleState(arguments[1], arguments[2])
elseif action == "sealTurnStartReceipt" then
return sealTurnStartReceipt(arguments[1], arguments[2])
elseif action == "newPendingTurn" then
return constructPendingTurn(arguments[1], arguments[2])
elseif action == "validatePendingTurn" then
return validatePendingTurn(arguments[1], arguments[2])
end
local errors = {}
addError(errors, "unknown_action", "$", "지원하지 않는 상태 스키마 작업입니다: " .. tostring(action))
return result(errors)
end)
#48staticData.lua
Keys:
(function()
local STATIC_CACHE_MAX_ENTRIES = 4
local MAX_PLAN_CAPACITY = 16
local DIAGNOSTIC_SCOPE = "helltrain.staticData"
local STATIC_BASE_LORE_ORDER = {
"GameRegistry.db",
"PlayerCards.db",
"CharacterCards.db",
"CharTraits.db",
"TokyoSubwayLines.db",
"CharacterList.db",
}
local staticCacheEntries = {}
local staticCacheClock = 0
local staticCacheStats = {
requests = 0,
captures = 0,
fastHits = 0,
hits = 0,
misses = 0,
validations = 0,
failedValidations = 0,
evictions = 0,
clears = 0,
}
-- 호스트 진단 출력은 print 한 줄로 통일한다. DB 본문이나 프로필은 남기지
-- 않고 로어 이름, 개수, 헤더와 오류 경로만 기록한다.
local function diagnosticsEnabled(depth)
return type(DEBUG) == "number" and depth <= DEBUG
end
local function diagnosticText(value)
return tostring(value):gsub("[\r\n]+", " ")
end
local function emitDiagnostic(depth, event, fields)
if not diagnosticsEnabled(depth) then
return
end
if type(print) ~= "function" then
return
end
local parts = {
"[" .. DIAGNOSTIC_SCOPE .. "]",
"depth=" .. tostring(depth),
"event=" .. diagnosticText(event),
}
local fieldOrder = {
"action", "forceRefresh", "cachedEntries", "cache", "ok",
"lore", "status", "entryCount", "error", "entryIndex",
"schemaVersion", "kindType", "kind", "code", "path", "message",
"expectedKind", "actualKindType", "actualKind", "errorCount",
"cards", "traits", "subwayLines", "characters",
}
for _, key in ipairs(fieldOrder) do
local value = type(fields) == "table" and fields[key] or nil
if value ~= nil then
parts[#parts + 1] = key .. "=" .. diagnosticText(value)
end
end
pcall(print, table.concat(parts, " | "))
end
-- 캐시의 canonical snapshot을 호출자에게 직접 노출하지 않는다. 함수는 정적
-- DB callback이므로 identity를 유지하고, 모든 table은 alias가 없도록 복제한다.
local function cloneStaticValue(value, seen)
if type(value) ~= "table" then
return value
end
seen = seen or {}
if seen[value] ~= nil then
return seen[value]
end
local copy = {}
seen[value] = copy
for key, item in pairs(value) do
copy[cloneStaticValue(key, seen)] = cloneStaticValue(item, seen)
end
return copy
end
-- getLoreBooks 결과의 metadata는 DB 판정에 사용하지 않는다. 개발/강제 refresh
-- 경로에서는 content와 순서 전체를 비교해 context 오염과 stale hit를 막는다.
-- production fast path의 배포 무효화는 main의 RUNTIME_BUNDLE_REVISION 계약이다.
local function captureStaticLore(triggerId, captured, loreName)
if captured[loreName] ~= nil then
return
end
local ok, lores = pcall(getLoreBooks, triggerId, loreName)
local source = {
status = ok and type(lores) or "read_error",
entries = {},
}
if not ok then
source.error = tostring(lores)
elseif type(lores) == "table" then
for _, lore in ipairs(lores) do
if type(lore) == "table" and type(lore.content) == "string" then
table.insert(source.entries, {
valid = true,
content = lore.content,
})
else
table.insert(source.entries, {
valid = false,
loreType = type(lore),
contentType = type(lore) == "table" and type(lore.content) or "none",
})
end
end
end
captured[loreName] = source
table.insert(captured.order, loreName)
emitDiagnostic(source.status == "read_error" and 1 or 2, "lore_capture", {
lore = loreName,
status = source.status,
entryCount = #source.entries,
error = source.error,
})
end
local function captureBaseStaticLores(triggerId)
staticCacheStats.captures = staticCacheStats.captures + 1
local captured = {
order = {},
}
for _, loreName in ipairs(STATIC_BASE_LORE_ORDER) do
captureStaticLore(triggerId, captured, loreName)
end
return captured
end
local function sameStaticLoreSource(leftSource, rightSource)
if leftSource == nil
or rightSource == nil
or leftSource.status ~= rightSource.status
or leftSource.error ~= rightSource.error
or #leftSource.entries ~= #rightSource.entries then
return false
end
for index, leftEntry in ipairs(leftSource.entries) do
local rightEntry = rightSource.entries[index]
if rightEntry == nil
or leftEntry.valid ~= rightEntry.valid
or leftEntry.content ~= rightEntry.content
or leftEntry.loreType ~= rightEntry.loreType
or leftEntry.contentType ~= rightEntry.contentType then
return false
end
end
return true
end
local function sameStaticLoreCapture(left, right)
if type(left.order) ~= "table"
or type(right.order) ~= "table"
or #left.order ~= #right.order then
return false
end
for index, loreName in ipairs(left.order) do
if right.order[index] ~= loreName
or not sameStaticLoreSource(left[loreName], right[loreName]) then
return false
end
end
return true
end
local function findCachedDynamicLoreOrder(captured)
for _, entry in ipairs(staticCacheEntries) do
local sameBase = true
for _, loreName in ipairs(STATIC_BASE_LORE_ORDER) do
if not sameStaticLoreSource(entry.sources[loreName], captured[loreName]) then
sameBase = false
break
end
end
if sameBase then
local dynamicOrder = {}
for index = #STATIC_BASE_LORE_ORDER + 1, #entry.sources.order do
table.insert(dynamicOrder, entry.sources.order[index])
end
return dynamicOrder
end
end
return nil
end
local function findStaticCacheEntry(captured)
for _, entry in ipairs(staticCacheEntries) do
if sameStaticLoreCapture(entry.sources, captured) then
staticCacheClock = staticCacheClock + 1
entry.lastUsed = staticCacheClock
entry.hits = entry.hits + 1
return entry
end
end
return nil
end
local function storeStaticCacheEntry(captured, report)
if #staticCacheEntries >= STATIC_CACHE_MAX_ENTRIES then
local oldestIndex = 1
for index = 2, #staticCacheEntries do
if staticCacheEntries[index].lastUsed < staticCacheEntries[oldestIndex].lastUsed then
oldestIndex = index
end
end
table.remove(staticCacheEntries, oldestIndex)
staticCacheStats.evictions = staticCacheStats.evictions + 1
end
staticCacheClock = staticCacheClock + 1
table.insert(staticCacheEntries, {
sources = captured,
report = report,
lastUsed = staticCacheClock,
hits = 0,
})
end
local function clearStaticCache()
local removed = #staticCacheEntries
staticCacheEntries = {}
staticCacheStats.clears = staticCacheStats.clears + 1
return removed
end
local function getStaticCacheDiagnostics()
local diagnostics = {
maxEntries = STATIC_CACHE_MAX_ENTRIES,
entries = #staticCacheEntries,
requests = staticCacheStats.requests,
captures = staticCacheStats.captures,
fastHits = staticCacheStats.fastHits,
hits = staticCacheStats.hits,
misses = staticCacheStats.misses,
validations = staticCacheStats.validations,
failedValidations = staticCacheStats.failedValidations,
evictions = staticCacheStats.evictions,
clears = staticCacheStats.clears,
cached = {},
}
for _, entry in ipairs(staticCacheEntries) do
table.insert(diagnostics.cached, {
hits = entry.hits,
lastUsed = entry.lastUsed,
counts = cloneStaticValue(entry.report.counts),
})
end
return diagnostics
end
return function(triggerId, action)
local SUPPORTED_SCHEMA_VERSION = 1
local SOURCES = {
registry = {
kind = "gameRegistry",
collection = nil,
lores = { "GameRegistry.db" },
},
cards = {
kind = "cardDatabase",
collection = "cards",
lores = { "PlayerCards.db", "CharacterCards.db" },
},
traits = {
kind = "traitDatabase",
collection = "traits",
lores = { "CharTraits.db" },
},
subwayLines = {
kind = "subwayLineDatabase",
collection = "subwayLines",
lores = { "TokyoSubwayLines.db" },
},
characterList = {
kind = "characterList",
collection = "characters",
lores = { "CharacterList.db" },
},
}
local RESERVED_CHARACTER_DATABASES = {
["GameRegistry.db"] = true,
["PlayerCards.db"] = true,
["CharacterCards.db"] = true,
["CharTraits.db"] = true,
["TokyoSubwayLines.db"] = true,
["CharacterList.db"] = true,
}
local function addError(errors, code, path, message)
table.insert(errors, {
code = code,
path = path,
message = message,
})
emitDiagnostic(1, "validation_error", {
code = code,
path = path,
message = message,
})
end
local function countEntries(value)
if type(value) ~= "table" then
return 0
end
local count = 0
for _ in pairs(value) do
count = count + 1
end
return count
end
local function isArray(value)
if type(value) ~= "table" then
return false
end
local count = 0
local maximum = 0
for key in pairs(value) do
if type(key) ~= "number" or key < 1 or key % 1 ~= 0 then
return false
end
count = count + 1
if key > maximum then
maximum = key
end
end
return count == maximum
end
local function isFiniteNonNegative(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
and value >= 0
end
local function isPositiveInteger(value)
return isFiniteNonNegative(value)
and value >= 1
and value % 1 == 0
end
local function isFiniteInteger(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
and value % 1 == 0
end
local function isPlanCapacity(value)
return isPositiveInteger(value) and value <= MAX_PLAN_CAPACITY
end
local function isAsciiId(value)
return type(value) == "string"
and string.match(value, "^[a-z][a-z0-9_]*$") ~= nil
end
local function isCharacterDatabaseName(value)
return type(value) == "string"
and string.match(value, "^[A-Za-z][A-Za-z0-9_]*%.db$") ~= nil
end
local function makeDatabaseEnvironment()
return {
ipairs = ipairs,
next = next,
pairs = pairs,
tonumber = tonumber,
tostring = tostring,
type = type,
}
end
local function loadLoreModules(loreName, errors, captured)
local source = captured[loreName]
if source == nil or source.status == "read_error" then
addError(
errors,
"lore_read_error",
loreName,
source and source.error or "정적 DB 로어북을 읽을 수 없습니다."
)
return {}
end
if source.status ~= "table" or #source.entries == 0 then
addError(errors, "missing_lore", loreName, "정적 DB 로어북을 찾을 수 없습니다.")
return {}
end
local modules = {}
for index, lore in ipairs(source.entries) do
if lore.valid ~= true then
addError(errors, "invalid_lore", loreName .. "[" .. index .. "]", "로어북 내용이 문자열이 아닙니다.")
else
local chunk, compileError = load(
lore.content,
"static_db:" .. loreName .. ":" .. index,
"t",
makeDatabaseEnvironment()
)
if not chunk then
addError(errors, "compile_error", loreName .. "[" .. index .. "]", tostring(compileError))
else
local ok, result = pcall(chunk)
if not ok then
addError(errors, "load_error", loreName .. "[" .. index .. "]", tostring(result))
elseif type(result) ~= "table" then
addError(errors, "invalid_module", loreName .. "[" .. index .. "]", "DB 청크가 테이블을 반환하지 않았습니다.")
else
table.insert(modules, result)
emitDiagnostic(2, "module_loaded", {
lore = loreName,
entryIndex = index,
schemaVersion = tostring(result.schemaVersion),
kindType = type(result.kind),
kind = type(result.kind) == "string" and result.kind or tostring(result.kind),
})
end
end
end
end
return modules
end
local function validateModuleHeader(module, expectedKind, path, errors)
if module.schemaVersion ~= SUPPORTED_SCHEMA_VERSION then
addError(errors, "unsupported_schema", path .. ".schemaVersion", "지원하지 않는 스키마 버전입니다.")
end
if module.kind ~= expectedKind then
local actualKind = type(module.kind) == "string" and module.kind or tostring(module.kind)
emitDiagnostic(1, "module_header_mismatch", {
path = path .. ".kind",
expectedKind = expectedKind,
actualKindType = type(module.kind),
actualKind = actualKind,
})
addError(
errors,
"unexpected_kind",
path .. ".kind",
"예상한 DB 종류와 다릅니다. (expected="
.. tostring(expectedKind)
.. ", actual="
.. actualKind
.. ")"
)
end
end
local function loadSingleModule(source, errors, captured)
local loaded = nil
for _, loreName in ipairs(source.lores) do
local modules = loadLoreModules(loreName, errors, captured)
for index, module in ipairs(modules) do
local path = loreName .. "[" .. index .. "]"
validateModuleHeader(module, source.kind, path, errors)
if loaded then
addError(errors, "duplicate_module", path, "단일 DB가 여러 번 등록되었습니다.")
else
loaded = module
end
end
end
return loaded
end
local function loadMergedCollection(source, errors, captured)
local merged = {}
local origins = {}
for _, loreName in ipairs(source.lores) do
local modules = loadLoreModules(loreName, errors, captured)
for index, module in ipairs(modules) do
local modulePath = loreName .. "[" .. index .. "]"
validateModuleHeader(module, source.kind, modulePath, errors)
local collection = module[source.collection]
if type(collection) ~= "table" then
addError(errors, "missing_collection", modulePath .. "." .. source.collection, "DB 컬렉션이 없습니다.")
else
for id, definition in pairs(collection) do
local itemPath = modulePath .. "." .. source.collection .. "." .. tostring(id)
if merged[id] ~= nil then
addError(
errors,
"duplicate_id",
itemPath,
"이미 " .. tostring(origins[id]) .. "에서 정의된 ID입니다."
)
else
merged[id] = definition
origins[id] = itemPath
end
end
end
end
end
return merged
end
local function sortedAsciiKeys(collection)
local keys = {}
if type(collection) == "table" then
for key in pairs(collection) do
if isAsciiId(key) then
table.insert(keys, key)
end
end
end
table.sort(keys)
return keys
end
local function collectCharacterDatabaseNames(characterList)
local names = {}
local seen = {}
for _, characterId in ipairs(sortedAsciiKeys(characterList)) do
local entry = characterList[characterId]
local database = type(entry) == "table" and entry.database or nil
if isCharacterDatabaseName(database)
and RESERVED_CHARACTER_DATABASES[database] ~= true
and seen[database] ~= true then
seen[database] = true
table.insert(names, database)
end
end
return names
end
local function validateCharacterList(characterList, errors)
if type(characterList) ~= "table" then
addError(errors, "missing_character_list", "characterList", "캐릭터 목록이 없습니다.")
return
end
if next(characterList) == nil then
addError(errors, "empty_character_list", "characterList", "캐릭터 목록이 비어 있습니다.")
return
end
local firstCharacterByDatabase = {}
for key, entry in pairs(characterList) do
local path = "characterList." .. tostring(key)
if not isAsciiId(key) or type(entry) ~= "table" or entry.id ~= key then
addError(errors, "invalid_character_list_id", path, "캐릭터 목록 키와 내부 ID가 올바르지 않습니다.")
else
for field in pairs(entry) do
if field ~= "id" and field ~= "database" then
addError(
errors,
"unexpected_character_list_field",
path .. "." .. tostring(field),
"캐릭터 목록에는 id와 database만 사용할 수 있습니다."
)
end
end
if not isCharacterDatabaseName(entry.database) then
addError(
errors,
"invalid_character_database_name",
path .. ".database",
"개별 캐릭터 DB 이름은 영문자로 시작하고 영문자, 숫자, 밑줄만 사용한 .db 파일명이어야 합니다."
)
elseif RESERVED_CHARACTER_DATABASES[entry.database] == true then
addError(
errors,
"reserved_character_database_name",
path .. ".database",
"공용 정적 DB 이름은 개별 캐릭터 DB로 사용할 수 없습니다."
)
else
local firstId = firstCharacterByDatabase[entry.database]
if firstId ~= nil then
addError(
errors,
"duplicate_character_database",
path .. ".database",
"개별 캐릭터 DB '" .. entry.database .. "'는 이미 characterList."
.. firstId .. ".database에서 사용되었습니다."
)
else
firstCharacterByDatabase[entry.database] = key
end
end
end
end
end
local function loadCharacterDefinitions(characterList, errors, captured)
local characters = {}
for _, characterId in ipairs(sortedAsciiKeys(characterList)) do
local entry = characterList[characterId]
local database = type(entry) == "table" and entry.database or nil
if isCharacterDatabaseName(database)
and RESERVED_CHARACTER_DATABASES[database] ~= true then
local modules = loadLoreModules(database, errors, captured)
if #modules > 1 then
addError(
errors,
"duplicate_character_module",
database,
"개별 캐릭터 DB는 하나의 로어 엔트리만 등록할 수 있습니다."
)
end
for index, module in ipairs(modules) do
local modulePath = database .. "[" .. index .. "]"
validateModuleHeader(module, "characterDatabase", modulePath, errors)
local collection = module.characters
if type(collection) ~= "table" then
addError(errors, "missing_collection", modulePath .. ".characters", "캐릭터 DB 컬렉션이 없습니다.")
else
local definition = collection[characterId]
if definition == nil then
addError(
errors,
"missing_listed_character",
modulePath .. ".characters." .. characterId,
"캐릭터 목록에 등록된 ID의 정의가 개별 DB에 없습니다."
)
elseif characters[characterId] == nil then
characters[characterId] = definition
end
for definedId in pairs(collection) do
if definedId ~= characterId then
addError(
errors,
"unlisted_character_definition",
modulePath .. ".characters." .. tostring(definedId),
"개별 캐릭터 DB에는 목록에서 연결한 캐릭터 한 명만 정의할 수 있습니다."
)
end
end
end
end
end
end
return characters
end
local function validateRegistryCollection(collection, path, errors, ownerRequired)
if type(collection) ~= "table" then
addError(errors, "missing_registry", path, "레지스트리 컬렉션이 없습니다.")
return
end
for key, entry in pairs(collection) do
local entryPath = path .. "." .. tostring(key)
if not isAsciiId(key) then
addError(errors, "invalid_id", entryPath, "레지스트리 키는 ASCII ID여야 합니다.")
end
if type(entry) ~= "table" or entry.id ~= key then
addError(errors, "id_mismatch", entryPath, "레지스트리 키와 내부 ID가 다릅니다.")
elseif ownerRequired and entry.owner ~= "player" and entry.owner ~= "character" then
addError(errors, "invalid_owner", entryPath .. ".owner", "역할 소유자가 올바르지 않습니다.")
end
end
end
local function validateRegistry(registry, errors)
if type(registry) ~= "table" then
addError(errors, "missing_registry", "registry", "중앙 게임 레지스트리가 없습니다.")
return
end
validateRegistryCollection(registry.cardTypes, "registry.cardTypes", errors, false)
validateRegistryCollection(registry.roles, "registry.roles", errors, true)
validateRegistryCollection(registry.mechanisms, "registry.mechanisms", errors, false)
validateRegistryCollection(registry.ruleTerms, "registry.ruleTerms", errors, false)
validateRegistryCollection(registry.moods, "registry.moods", errors, false)
validateRegistryCollection(registry.events, "registry.events", errors, false)
validateRegistryCollection(registry.effectOps, "registry.effectOps", errors, false)
local registryIds = {}
for _, collectionName in ipairs({ "cardTypes", "roles", "mechanisms", "ruleTerms" }) do
local collection = type(registry[collectionName]) == "table" and registry[collectionName] or {}
for id in pairs(collection) do
if registryIds[id] then
addError(errors, "registry_id_collision", "registry." .. id, "태그와 규칙 용어 ID가 중복됩니다.")
else
registryIds[id] = collectionName
end
end
end
end
local function validateTagTokens(text, path, registry, errors)
if type(text) ~= "string" then
return
end
local remainder = string.gsub(text, "::tag%[[a-z][a-z0-9_]*%]::", "")
if string.find(remainder, "::tag[", 1, true) then
addError(errors, "malformed_tag_token", path, "형식이 잘못된 태그 토큰이 있습니다.")
end
for tagId in string.gmatch(text, "::tag%[([a-z][a-z0-9_]*)%]::") do
local knownCardType = type(registry) == "table"
and type(registry.cardTypes) == "table"
and registry.cardTypes[tagId]
local knownRole = type(registry) == "table"
and type(registry.roles) == "table"
and registry.roles[tagId]
local knownMechanism = type(registry) == "table"
and type(registry.mechanisms) == "table"
and registry.mechanisms[tagId]
local knownRuleTerm = type(registry) == "table"
and type(registry.ruleTerms) == "table"
and registry.ruleTerms[tagId]
if not knownCardType and not knownRole and not knownMechanism and not knownRuleTerm then
addError(errors, "unknown_tag_token", path, "등록되지 않은 태그 토큰입니다: " .. tagId)
end
end
end
local function validateNarration(card, path, isPlan, errors)
if type(card.narration) ~= "table" then
addError(errors, "missing_narration", path .. ".narration", "카드 묘사가 없습니다.")
return
end
if isPlan then
if type(card.narration.planPlaced) ~= "table"
or type(card.narration.planPlaced.actorAction) ~= "string"
or card.narration.planPlaced.actorAction == "" then
addError(errors, "missing_plan_placed_narration", path .. ".narration.planPlaced", "계획 배치 묘사가 없습니다.")
end
if type(card.narration.planTriggered) ~= "table"
or type(card.narration.planTriggered.actorAction) ~= "string"
or card.narration.planTriggered.actorAction == "" then
addError(errors, "missing_plan_triggered_narration", path .. ".narration.planTriggered", "계획 발동 묘사가 없습니다.")
end
elseif type(card.narration.play) ~= "table"
or type(card.narration.play.actorAction) ~= "string"
or card.narration.play.actorAction == "" then
addError(errors, "missing_play_narration", path .. ".narration.play", "카드 사용 묘사가 없습니다.")
end
local play = type(card.narration.play) == "table" and card.narration.play or nil
local conditionMet = play and play.conditionMet or nil
if card.narrationCondition ~= nil then
if card.owner ~= "player" or isPlan then
addError(errors, "invalid_narration_condition_owner", path .. ".narrationCondition", "조건부 사용 묘사는 플레이어의 비계획 카드에만 사용할 수 있습니다.")
end
if type(card.narrationCondition) ~= "function" then
addError(errors, "invalid_narration_condition", path .. ".narrationCondition", "조건부 사용 묘사의 판정식이 함수가 아닙니다.")
end
if type(conditionMet) ~= "table"
or type(conditionMet.actorAction) ~= "string"
or conditionMet.actorAction == "" then
addError(errors, "missing_condition_met_narration", path .. ".narration.play.conditionMet", "조건 충족 시 카드 사용 묘사가 없습니다.")
end
elseif conditionMet ~= nil then
addError(errors, "missing_narration_condition", path .. ".narrationCondition", "조건 충족 묘사에 대응하는 판정식이 없습니다.")
end
end
local function validatePlanSelectionAssumption(card, plan, path, registry, errors)
local assumption = plan.selectionAssumption
if card.owner == "character" and assumption == nil then
addError(
errors,
"missing_plan_selection_assumption",
path .. ".selectionAssumption",
"캐릭터 계획에는 선택 점수용 발동 가정이 필요합니다."
)
return
end
if assumption == nil then
return
end
if card.owner ~= "character" then
addError(
errors,
"unexpected_plan_selection_assumption",
path .. ".selectionAssumption",
"선택 점수용 계획 발동 가정은 캐릭터 카드에만 사용할 수 있습니다."
)
end
if type(assumption) ~= "table" then
addError(
errors,
"invalid_plan_selection_assumption",
path .. ".selectionAssumption",
"계획 선택 가정이 테이블이 아닙니다."
)
return
end
for field in pairs(assumption) do
if field ~= "event" and field ~= "chargePolicy" then
addError(
errors,
"unexpected_plan_selection_assumption_field",
path .. ".selectionAssumption." .. tostring(field),
"계획 선택 가정에 허용되지 않은 필드가 있습니다."
)
end
end
local event = assumption.event
local eventPath = path .. ".selectionAssumption.event"
if type(event) ~= "table" then
addError(errors, "invalid_plan_selection_event", eventPath, "계획 선택 가정 사건이 테이블이 아닙니다.")
else
for field in pairs(event) do
if field ~= "type" and field ~= "side" and field ~= "roles" then
addError(
errors,
"unexpected_plan_selection_event_field",
eventPath .. "." .. tostring(field),
"계획 선택 가정 사건에는 type, side와 roles만 사용할 수 있습니다."
)
end
end
if type(registry) ~= "table"
or type(registry.events) ~= "table"
or type(event.type) ~= "string"
or not registry.events[event.type] then
addError(errors, "unknown_plan_selection_event", eventPath .. ".type", "등록되지 않은 계획 선택 가정 사건입니다.")
end
if event.side ~= "player" and event.side ~= "character" then
addError(errors, "invalid_plan_selection_side", eventPath .. ".side", "계획 선택 가정 진영이 올바르지 않습니다.")
end
if not isArray(event.roles) then
addError(errors, "invalid_plan_selection_roles", eventPath .. ".roles", "계획 선택 가정 역할은 배열이어야 합니다.")
else
local seenRoles = {}
for index, roleId in ipairs(event.roles) do
local role = type(registry) == "table"
and type(registry.roles) == "table"
and registry.roles[roleId]
or nil
if type(role) ~= "table" or role.owner ~= event.side or seenRoles[roleId] then
addError(errors, "invalid_plan_selection_role", eventPath .. ".roles[" .. index .. "]", "계획 선택 가정 역할이 진영과 맞지 않거나 중복되었습니다.")
end
seenRoles[roleId] = true
end
end
end
if assumption.chargePolicy ~= "all" then
addError(
errors,
"invalid_plan_selection_charge_policy",
path .. ".selectionAssumption.chargePolicy",
"캐릭터 계획 선택 점수는 모든 충전을 합산해야 합니다."
)
end
if not isPositiveInteger(plan.charges) then
addError(
errors,
"plan_selection_requires_charges",
path .. ".charges",
"캐릭터 계획 선택 점수에는 양의 충전 수가 필요합니다."
)
end
end
local function validateCards(cards, registry, errors)
if type(cards) ~= "table" then
addError(errors, "missing_cards", "cards", "카드 컬렉션이 없습니다.")
return
end
for key, card in pairs(cards) do
local path = "cards." .. tostring(key)
if not isAsciiId(key) then
addError(errors, "invalid_id", path, "카드 키는 ASCII ID여야 합니다.")
end
if type(card) ~= "table" then
addError(errors, "invalid_card", path, "카드 정의가 테이블이 아닙니다.")
else
if card.id ~= key then
addError(errors, "id_mismatch", path .. ".id", "카드 키와 내부 ID가 다릅니다.")
end
if card.owner ~= "player" and card.owner ~= "character" then
addError(errors, "invalid_owner", path .. ".owner", "카드 소유자가 올바르지 않습니다.")
end
if type(card.name) ~= "string" or card.name == "" then
addError(errors, "missing_name", path .. ".name", "카드 이름이 없습니다.")
end
if card.owner == "player"
and card.rarity ~= "common"
and card.rarity ~= "rare"
and card.rarity ~= "legendary" then
addError(errors, "invalid_rarity", path .. ".rarity", "플레이어 카드 희귀도는 common, rare 또는 legendary여야 합니다.")
elseif card.owner == "character" and card.rarity ~= nil then
addError(errors, "unexpected_rarity", path .. ".rarity", "캐릭터 카드에는 희귀도를 사용하지 않습니다.")
end
if card.owner == "player"
and card.draftStyle ~= "predator"
and card.draftStyle ~= "glutton"
and card.draftStyle ~= "deceiver"
and card.draftStyle ~= "harmonizer" then
addError(errors, "invalid_draft_style", path .. ".draftStyle", "플레이어 카드에는 정확히 하나의 유효한 draftStyle이 필요합니다.")
elseif card.owner == "character" and card.draftStyle ~= nil then
addError(errors, "unexpected_draft_style", path .. ".draftStyle", "캐릭터 카드에는 draftStyle을 사용하지 않습니다.")
end
if type(card.description) ~= "string" or card.description == "" then
addError(errors, "missing_description", path .. ".description", "카드 설명이 없습니다.")
end
validateTagTokens(card.description, path .. ".description", registry, errors)
local cardType = type(registry) == "table"
and type(registry.cardTypes) == "table"
and registry.cardTypes[card.cardType]
or nil
if not cardType then
addError(errors, "unknown_card_type", path .. ".cardType", "등록되지 않은 카드 유형입니다.")
end
if not isArray(card.roles) then
addError(errors, "invalid_roles", path .. ".roles", "카드 역할이 배열이 아닙니다.")
else
local maximum = card.owner == "player" and 2 or 1
if #card.roles < 1 or #card.roles > maximum then
addError(errors, "invalid_role_count", path .. ".roles", "카드 역할 수가 소유자 규칙과 맞지 않습니다.")
end
local seenRoles = {}
for index, roleId in ipairs(card.roles) do
local rolePath = path .. ".roles[" .. index .. "]"
local role = type(registry) == "table"
and type(registry.roles) == "table"
and registry.roles[roleId]
or nil
if not role then
addError(errors, "unknown_role", rolePath, "등록되지 않은 카드 역할입니다.")
elseif role.owner ~= card.owner then
addError(errors, "role_owner_mismatch", rolePath, "카드 역할 소유자와 카드 소유자가 다릅니다.")
end
if seenRoles[roleId] then
addError(errors, "duplicate_role", rolePath, "같은 카드 역할이 중복되었습니다.")
end
seenRoles[roleId] = true
end
end
if not isArray(card.mechanisms) then
addError(errors, "invalid_mechanisms", path .. ".mechanisms", "메커니즘 목록이 배열이 아닙니다.")
else
local seenMechanisms = {}
for index, mechanismId in ipairs(card.mechanisms) do
local mechanismPath = path .. ".mechanisms[" .. index .. "]"
if type(registry) ~= "table"
or type(registry.mechanisms) ~= "table"
or not registry.mechanisms[mechanismId] then
addError(errors, "unknown_mechanism", mechanismPath, "등록되지 않은 메커니즘입니다.")
end
if seenMechanisms[mechanismId] then
addError(errors, "duplicate_mechanism", mechanismPath, "같은 메커니즘이 중복되었습니다.")
end
seenMechanisms[mechanismId] = true
end
if type(card.mechanismData) == "table" then
for mechanismId in pairs(card.mechanismData) do
if mechanismId ~= "plan" or card.cardType ~= "plan" then
addError(errors, "orphan_mechanism_data", path .. ".mechanismData." .. tostring(mechanismId), "보유하지 않은 메커니즘의 설정입니다.")
end
end
end
local hasPlan = card.cardType == "plan"
local plan = type(card.mechanismData) == "table" and card.mechanismData.plan or nil
if hasPlan then
if type(plan) ~= "table" then
addError(errors, "missing_plan_data", path .. ".mechanismData.plan", "계획 설정이 없습니다.")
else
if plan.durationTurns ~= nil and not isPositiveInteger(plan.durationTurns) then
addError(errors, "invalid_plan_duration", path .. ".mechanismData.plan.durationTurns", "계획 지속 턴은 1 이상의 정수여야 합니다.")
end
if plan.durationIncludesPlacementTurn ~= nil
and type(plan.durationIncludesPlacementTurn) ~= "boolean" then
addError(
errors,
"invalid_plan_duration_policy",
path .. ".mechanismData.plan.durationIncludesPlacementTurn",
"배치 턴 포함 여부는 불리언이어야 합니다."
)
elseif plan.durationIncludesPlacementTurn == true
and not isPositiveInteger(plan.durationTurns) then
addError(
errors,
"plan_duration_policy_requires_duration",
path .. ".mechanismData.plan.durationIncludesPlacementTurn",
"배치 턴을 포함하려면 양의 durationTurns가 필요합니다."
)
end
if plan.charges ~= nil and not isPositiveInteger(plan.charges) then
addError(errors, "invalid_plan_charges", path .. ".mechanismData.plan.charges", "계획 충전은 1 이상의 정수여야 합니다.")
end
local hasLifetime = isPositiveInteger(plan.durationTurns)
or isPositiveInteger(plan.charges)
or type(plan.expires) == "function"
if not hasLifetime then
addError(errors, "unlimited_plan", path .. ".mechanismData.plan", "계획 수명이 제한되지 않았습니다.")
end
if type(plan.trigger) ~= "function" then
addError(errors, "invalid_plan_trigger", path .. ".mechanismData.plan.trigger", "계획 조건이 함수가 아닙니다.")
end
if type(plan.resolve) ~= "function" then
addError(errors, "invalid_plan_resolve", path .. ".mechanismData.plan.resolve", "계획 효과가 함수가 아닙니다.")
end
validatePlanSelectionAssumption(
card,
plan,
path .. ".mechanismData.plan",
registry,
errors
)
end
elseif plan ~= nil then
addError(errors, "unexpected_plan_data", path .. ".mechanismData.plan", "계획 메커니즘이 없는 카드에 계획 설정이 있습니다.")
end
local selectionPreview = card.selectionPreview
if selectionPreview ~= nil then
local previewPath = path .. ".selectionPreview"
if card.owner ~= "player" or card.cardType ~= "chain" then
addError(errors, "preview_requires_player_chain", previewPath, "선택 단계 효과는 플레이어 연계 카드에만 선언할 수 있습니다.")
end
if card.resolve ~= nil then
addError(errors, "preview_with_resolve", path .. ".resolve", "선택 단계 효과 카드에는 v1 resolve를 함께 둘 수 없습니다.")
end
if type(selectionPreview) ~= "table" then
addError(errors, "invalid_selection_preview", previewPath, "선택 단계 효과 정책이 테이블이 아닙니다.")
else
for field in pairs(selectionPreview) do
if field ~= "effects" and field ~= "when" then
addError(errors, "unexpected_preview_field", previewPath .. "." .. tostring(field), "선택 단계 효과 정책에 허용되지 않은 필드가 있습니다.")
end
end
if selectionPreview.when ~= nil and type(selectionPreview.when) ~= "function" then
addError(errors, "invalid_preview_condition", previewPath .. ".when", "선택 단계 조건은 함수여야 합니다.")
end
if not isArray(selectionPreview.effects) or #selectionPreview.effects == 0 then
addError(errors, "invalid_preview_effects", previewPath .. ".effects", "선택 단계 효과는 비어 있지 않은 배열이어야 합니다.")
else
local seenEffectIds = {}
for effectIndex, effect in ipairs(selectionPreview.effects) do
local effectPath = previewPath .. ".effects[" .. effectIndex .. "]"
if type(effect) ~= "table" then
addError(errors, "invalid_preview_effect", effectPath, "선택 단계 효과가 테이블이 아닙니다.")
else
for field in pairs(effect) do
if field ~= "id" and field ~= "op" and field ~= "target" and field ~= "amount" then
addError(errors, "unexpected_preview_effect_field", effectPath .. "." .. tostring(field), "선택 단계 효과에 허용되지 않은 필드가 있습니다.")
end
end
if not isAsciiId(effect.id) then
addError(errors, "invalid_preview_effect_id", effectPath .. ".id", "선택 단계 효과 ID는 ASCII ID여야 합니다.")
elseif seenEffectIds[effect.id] then
addError(errors, "duplicate_preview_effect_id", effectPath .. ".id", "선택 단계 효과 ID가 중복되었습니다.")
else
seenEffectIds[effect.id] = true
end
local registeredOp = type(registry) == "table"
and type(registry.effectOps) == "table"
and registry.effectOps[effect.op]
or nil
if not registeredOp then
addError(errors, "unknown_preview_op", effectPath .. ".op", "등록되지 않은 선택 단계 효과 작업입니다.")
elseif effect.op ~= "draw_cards" then
addError(errors, "unsupported_preview_op", effectPath .. ".op", "선택 단계 효과 v1은 draw_cards만 지원합니다.")
end
if effect.target ~= "player" then
addError(errors, "invalid_preview_target", effectPath .. ".target", "선택 단계 드로우 대상은 player여야 합니다.")
end
if not isPositiveInteger(effect.amount) then
addError(errors, "invalid_preview_amount", effectPath .. ".amount", "선택 단계 드로우 수량은 1 이상의 정수여야 합니다.")
end
end
end
end
end
end
validateNarration(card, path, hasPlan, errors)
if hasPlan and type(card.effectChoices) == "table" then
local hasImmediateChoice = false
for _, choice in ipairs(card.effectChoices) do
if type(choice) == "table" and choice.placesPlan == false then
hasImmediateChoice = true
end
end
if hasImmediateChoice
and (type(card.narration) ~= "table"
or type(card.narration.play) ~= "table"
or type(card.narration.play.actorAction) ~= "string"
or card.narration.play.actorAction == "") then
addError(errors, "missing_immediate_choice_narration", path .. ".narration.play", "즉시 발동 선택지가 있는 계획 카드에는 사용 묘사가 필요합니다.")
end
end
end
if type(card.base) ~= "table" then
addError(errors, "missing_base", path .. ".base", "카드 기본 수치가 없습니다.")
else
if not isFiniteNonNegative(card.base.stealthCost) then
addError(errors, "invalid_stealth_cost", path .. ".base.stealthCost", "기본 은폐 비용이 0 이상의 유한한 숫자가 아닙니다.")
end
if not isFiniteNonNegative(card.base.resistanceDamage) then
addError(errors, "invalid_resistance_damage", path .. ".base.resistanceDamage", "기본 저항 피해가 0 이상의 유한한 숫자가 아닙니다.")
end
end
if card.stealthCostByMood ~= nil then
if card.owner ~= "player" or type(card.stealthCostByMood) ~= "table" then
addError(errors, "invalid_mood_stealth_costs", path .. ".stealthCostByMood", "플레이어 카드의 무드별 은폐 비용은 테이블이어야 합니다.")
else
for moodId, cost in pairs(card.stealthCostByMood) do
if type(registry) ~= "table"
or type(registry.moods) ~= "table"
or registry.moods[moodId] == nil then
addError(errors, "unknown_mood_stealth_cost", path .. ".stealthCostByMood." .. tostring(moodId), "등록되지 않은 무드의 은폐 비용입니다.")
elseif not isFiniteNonNegative(cost) then
addError(errors, "invalid_mood_stealth_cost", path .. ".stealthCostByMood." .. moodId, "무드별 은폐 비용이 0 이상의 유한한 숫자가 아닙니다.")
end
end
end
end
if not isArray(card.rules) or #card.rules == 0 then
addError(errors, "invalid_rules", path .. ".rules", "카드 규칙 문장이 비어 있습니다.")
else
for index, rule in ipairs(card.rules) do
if type(rule) ~= "string" or rule == "" then
addError(errors, "invalid_rule", path .. ".rules[" .. index .. "]", "카드 규칙이 빈 문자열이거나 문자열이 아닙니다.")
else
validateTagTokens(rule, path .. ".rules[" .. index .. "]", registry, errors)
end
end
end
if card.canPlay ~= nil and type(card.canPlay) ~= "function" then
addError(errors, "invalid_can_play", path .. ".canPlay", "사용 조건이 함수가 아닙니다.")
end
if card.resolve ~= nil and type(card.resolve) ~= "function" then
addError(errors, "invalid_resolve", path .. ".resolve", "카드 효과가 함수가 아닙니다.")
end
if card.effectChoices ~= nil then
local choicesPath = path .. ".effectChoices"
if card.owner ~= "player" then
addError(errors, "choice_requires_player", choicesPath, "효과 선택지는 플레이어 카드에만 선언할 수 있습니다.")
end
if not isArray(card.effectChoices) or #card.effectChoices < 2 then
addError(errors, "invalid_effect_choices", choicesPath, "효과 선택지는 2개 이상의 배열이어야 합니다.")
else
local seenChoiceIds = {}
for choiceIndex, choice in ipairs(card.effectChoices) do
local choicePath = choicesPath .. "[" .. choiceIndex .. "]"
if type(choice) ~= "table" then
addError(errors, "invalid_effect_choice", choicePath, "효과 선택지가 테이블이 아닙니다.")
else
for field in pairs(choice) do
if field ~= "id"
and field ~= "label"
and field ~= "description"
and field ~= "actorAction"
and field ~= "unavailableText"
and field ~= "canSelect"
and field ~= "placesPlan" then
addError(errors, "unexpected_effect_choice_field", choicePath .. "." .. tostring(field), "효과 선택지에 허용되지 않은 필드가 있습니다.")
end
end
if not isAsciiId(choice.id) then
addError(errors, "invalid_effect_choice_id", choicePath .. ".id", "효과 선택지 ID는 ASCII ID여야 합니다.")
elseif seenChoiceIds[choice.id] then
addError(errors, "duplicate_effect_choice_id", choicePath .. ".id", "효과 선택지 ID가 중복되었습니다.")
else
seenChoiceIds[choice.id] = true
end
if type(choice.label) ~= "string" or choice.label == "" then
addError(errors, "invalid_effect_choice_label", choicePath .. ".label", "효과 선택지 표시명이 필요합니다.")
end
if type(choice.description) ~= "string" or choice.description == "" then
addError(errors, "invalid_effect_choice_description", choicePath .. ".description", "효과 선택지 설명이 필요합니다.")
else
validateTagTokens(choice.description, choicePath .. ".description", registry, errors)
end
if choice.actorAction ~= nil
and (type(choice.actorAction) ~= "string" or choice.actorAction == "") then
addError(errors, "invalid_effect_choice_actor_action", choicePath .. ".actorAction", "선택지 행동 묘사는 비어 있지 않은 문자열이어야 합니다.")
end
if choice.unavailableText ~= nil
and (type(choice.unavailableText) ~= "string" or choice.unavailableText == "") then
addError(errors, "invalid_effect_choice_unavailable_text", choicePath .. ".unavailableText", "비활성 안내는 비어 있지 않은 문자열이어야 합니다.")
end
if choice.canSelect ~= nil and type(choice.canSelect) ~= "function" then
addError(errors, "invalid_effect_choice_predicate", choicePath .. ".canSelect", "효과 선택 가능 조건이 함수가 아닙니다.")
end
if choice.placesPlan ~= nil then
if type(choice.placesPlan) ~= "boolean" then
addError(errors, "invalid_effect_choice_plan_flag", choicePath .. ".placesPlan", "계획 배치 여부는 불리언이어야 합니다.")
elseif card.cardType ~= "plan" then
addError(errors, "effect_choice_plan_without_type", choicePath .. ".placesPlan", "계획 카드가 아닌 카드에는 계획 배치 선택을 선언할 수 없습니다.")
end
end
end
end
end
end
if card.moodEffects ~= nil then
if type(card.moodEffects) ~= "table" then
addError(errors, "invalid_mood_effects", path .. ".moodEffects", "무드 효과가 테이블이 아닙니다.")
else
for moodId, callback in pairs(card.moodEffects) do
if type(registry) ~= "table"
or type(registry.moods) ~= "table"
or not registry.moods[moodId] then
addError(errors, "unknown_mood", path .. ".moodEffects." .. tostring(moodId), "등록되지 않은 무드입니다.")
end
if type(callback) ~= "function" then
addError(errors, "invalid_mood_callback", path .. ".moodEffects." .. tostring(moodId), "무드 효과가 함수가 아닙니다.")
end
end
end
end
end
end
end
local function validateTraits(traits, errors)
if type(traits) ~= "table" then
addError(errors, "missing_traits", "traits", "특징 컬렉션이 없습니다.")
return
end
for key, trait in pairs(traits) do
local path = "traits." .. tostring(key)
if not isAsciiId(key) or type(trait) ~= "table" or trait.id ~= key then
addError(errors, "invalid_trait_id", path, "특징 키와 내부 ID가 올바르지 않습니다.")
else
if trait.owner ~= "player" and trait.owner ~= "character" then
addError(errors, "invalid_owner", path .. ".owner", "특징 소유자가 올바르지 않습니다.")
end
if trait.visibility ~= "public" and trait.visibility ~= "hidden" then
addError(errors, "invalid_visibility", path .. ".visibility", "특징 공개 범위가 올바르지 않습니다.")
end
if type(trait.name) ~= "string" or trait.name == "" then
addError(errors, "missing_name", path .. ".name", "특징 이름이 없습니다.")
end
if type(trait.description) ~= "string" or trait.description == "" then
addError(errors, "missing_description", path .. ".description", "특징 설명이 없습니다.")
end
if not isArray(trait.rules) or #trait.rules == 0 then
addError(errors, "invalid_rules", path .. ".rules", "특징 규칙 문장이 비어 있습니다.")
end
if trait.modifiers ~= nil then
local modifiersPath = path .. ".modifiers"
if not isArray(trait.modifiers) then
addError(errors, "invalid_trait_modifiers", modifiersPath, "특징 보정은 연속 배열이어야 합니다.")
else
for index, modifier in ipairs(trait.modifiers) do
local modifierPath = modifiersPath .. "[" .. index .. "]"
if type(modifier) ~= "table" then
addError(
errors,
"invalid_trait_modifier",
modifierPath,
"특징 보정 항목은 객체여야 합니다."
)
else
local allowed = {
stat = true,
operation = true,
amount = true,
}
for field in pairs(modifier) do
if not allowed[field] then
addError(
errors,
"unknown_trait_modifier_field",
modifierPath .. "." .. tostring(field),
"특징 보정에 허용되지 않은 필드가 있습니다."
)
end
end
if modifier.stat ~= "planCapacity" then
addError(
errors,
"unsupported_trait_modifier_stat",
modifierPath .. ".stat",
"현재 특징 보정은 planCapacity만 지원합니다."
)
end
if modifier.operation ~= "add" then
addError(
errors,
"unsupported_trait_modifier_operation",
modifierPath .. ".operation",
"planCapacity 특징 보정은 add 연산만 지원합니다."
)
end
if not isFiniteInteger(modifier.amount) then
addError(
errors,
"invalid_trait_modifier_amount",
modifierPath .. ".amount",
"planCapacity 특징 보정량은 유한한 정수여야 합니다."
)
end
end
end
end
end
end
end
end
local function validateSubwayLines(subwayLines, errors)
if type(subwayLines) ~= "table" then
addError(errors, "missing_subway_lines", "subwayLines", "지하철 노선 컬렉션이 없습니다.")
return
end
if next(subwayLines) == nil then
addError(errors, "empty_subway_lines", "subwayLines", "지하철 노선 컬렉션이 비어 있습니다.")
return
end
for key, line in pairs(subwayLines) do
local linePath = "subwayLines." .. tostring(key)
if not isAsciiId(key) or type(line) ~= "table" or line.id ~= key then
addError(errors, "invalid_subway_line_id", linePath, "노선 키와 내부 ID가 올바르지 않습니다.")
else
if not isAsciiId(line.operatorId) then
addError(errors, "invalid_subway_operator_id", linePath .. ".operatorId", "운영사 ID가 올바르지 않습니다.")
end
if type(line.operatorName) ~= "string" or line.operatorName == "" then
addError(errors, "missing_subway_operator_name", linePath .. ".operatorName", "운영사 표시명이 없습니다.")
end
if type(line.name) ~= "string" or line.name == "" then
addError(errors, "missing_subway_line_name", linePath .. ".name", "노선 표시명이 없습니다.")
end
if type(line.code) ~= "string"
or string.match(line.code, "^[A-Z]$") == nil then
addError(errors, "invalid_subway_line_code", linePath .. ".code", "노선 코드는 영문 대문자 한 글자여야 합니다.")
end
if type(line.color) ~= "string"
or string.match(line.color, "^#%x%x%x%x%x%x$") == nil then
addError(errors, "invalid_subway_line_color", linePath .. ".color", "노선 색상은 #RRGGBB 형식이어야 합니다.")
end
if not isArray(line.paths) or #line.paths == 0 then
addError(errors, "invalid_subway_paths", linePath .. ".paths", "노선 경로 목록이 비어 있습니다.")
else
local pathIds = {}
local stationDefinitions = {}
local supportsMinimum = false
local supportsMaximum = false
for pathIndex, routePath in ipairs(line.paths) do
local pathPath = linePath .. ".paths[" .. pathIndex .. "]"
if type(routePath) ~= "table" then
addError(errors, "invalid_subway_path", pathPath, "노선 경로가 테이블이 아닙니다.")
else
if not isAsciiId(routePath.id) then
addError(errors, "invalid_subway_path_id", pathPath .. ".id", "노선 경로 ID가 올바르지 않습니다.")
elseif pathIds[routePath.id] then
addError(errors, "duplicate_subway_path_id", pathPath .. ".id", "노선 경로 ID가 중복되었습니다.")
else
pathIds[routePath.id] = true
end
if type(routePath.circular) ~= "boolean" then
addError(errors, "invalid_subway_path_circular", pathPath .. ".circular", "순환 경로 여부는 불리언이어야 합니다.")
end
if not isArray(routePath.stations) or #routePath.stations < 2 then
addError(errors, "invalid_subway_stations", pathPath .. ".stations", "경로에는 두 개 이상의 역이 필요합니다.")
else
if routePath.circular == true or #routePath.stations >= 8 then
supportsMinimum = true
end
if routePath.circular == true or #routePath.stations >= 13 then
supportsMaximum = true
end
local stationIds = {}
for stationIndex, station in ipairs(routePath.stations) do
local stationPath = pathPath .. ".stations[" .. stationIndex .. "]"
if type(station) ~= "table" then
addError(errors, "invalid_subway_station", stationPath, "역 정의가 테이블이 아닙니다.")
else
if not isAsciiId(station.id) then
addError(errors, "invalid_subway_station_id", stationPath .. ".id", "역 ID가 올바르지 않습니다.")
elseif stationIds[station.id] then
addError(errors, "duplicate_subway_station_id", stationPath .. ".id", "한 경로 안에서 역 ID가 중복되었습니다.")
else
stationIds[station.id] = true
end
if type(station.code) ~= "string"
or string.match(station.code, "^[A-Za-z]+[0-9][0-9]$") == nil then
addError(errors, "invalid_subway_station_code", stationPath .. ".code", "역 코드는 영문자와 두 자리 숫자로 구성해야 합니다.")
end
if type(station.name) ~= "string" or station.name == "" then
addError(errors, "missing_subway_station_name", stationPath .. ".name", "역 표시명이 없습니다.")
end
local previous = stationDefinitions[station.id]
if previous ~= nil
and (previous.code ~= station.code or previous.name ~= station.name) then
addError(errors, "subway_station_definition_conflict", stationPath, "같은 역 ID의 코드나 표시명이 경로마다 다릅니다.")
elseif previous == nil and isAsciiId(station.id) then
stationDefinitions[station.id] = {
code = station.code,
name = station.name,
}
end
end
end
end
end
end
if not supportsMinimum then
addError(errors, "subway_line_too_short", linePath .. ".paths", "이 노선에는 7턴 여정을 만들 수 있는 경로가 없습니다.")
end
if not supportsMaximum then
addError(errors, "subway_line_missing_maximum_route", linePath .. ".paths", "이 노선에는 12턴 여정을 만들 수 있는 경로가 없습니다.")
end
end
end
end
end
local function validateCharacters(characters, cards, traits, registry, errors)
if type(characters) ~= "table" then
addError(errors, "missing_characters", "characters", "캐릭터 컬렉션이 없습니다.")
return
end
local namedCharacters = {}
for key, character in pairs(characters) do
local path = "characters." .. tostring(key)
if not isAsciiId(key) or type(character) ~= "table" or character.id ~= key then
addError(errors, "invalid_character_id", path, "캐릭터 키와 내부 ID가 올바르지 않습니다.")
else
if type(character.name) ~= "string" or character.name == "" then
addError(errors, "missing_name", path .. ".name", "캐릭터 이름이 없습니다.")
else
table.insert(namedCharacters, {
id = key,
name = character.name,
})
end
if type(character.publicProfile) ~= "table" then
addError(errors, "missing_public_profile", path .. ".publicProfile", "공개 프로필이 없습니다.")
end
if character.privateProfile ~= nil and type(character.privateProfile) ~= "table" then
addError(errors, "invalid_private_profile", path .. ".privateProfile", "비공개 프로필이 테이블이 아닙니다.")
end
local battle = character.battle
if type(battle) ~= "table" then
addError(errors, "missing_battle", path .. ".battle", "전투 정의가 없습니다.")
else
if not isFiniteNonNegative(battle.startingResistance) or battle.startingResistance == 0 then
addError(errors, "invalid_starting_resistance", path .. ".battle.startingResistance", "시작 저항이 양수의 유한한 숫자가 아닙니다.")
end
if not isPositiveInteger(battle.turnLimit) or battle.turnLimit < 7 or battle.turnLimit > 12 then
addError(errors, "invalid_turn_limit", path .. ".battle.turnLimit", "캐릭터 제한 턴은 7 이상 12 이하의 정수여야 합니다.")
end
if not isPositiveInteger(battle.baseDrawCount) then
addError(errors, "invalid_base_draw_count", path .. ".battle.baseDrawCount", "기본 드로우 수는 1 이상의 정수여야 합니다.")
end
if not isPositiveInteger(battle.maxHandSize) then
addError(errors, "invalid_hand_size", path .. ".battle.maxHandSize", "최대 손패는 1 이상의 정수여야 합니다.")
end
if not isPlanCapacity(battle.planCapacity) then
addError(errors, "invalid_plan_capacity", path .. ".battle.planCapacity", "기본 계획 용량은 1 이상 16 이하의 정수여야 합니다.")
end
if isPositiveInteger(battle.baseDrawCount)
and isPositiveInteger(battle.maxHandSize)
and battle.baseDrawCount > battle.maxHandSize then
addError(errors, "draw_exceeds_hand_limit", path .. ".battle.baseDrawCount", "기본 드로우 수는 최대 손패보다 클 수 없습니다.")
end
if type(registry) ~= "table"
or type(registry.moods) ~= "table"
or not registry.moods[battle.startingMood] then
addError(errors, "unknown_starting_mood", path .. ".battle.startingMood", "등록되지 않은 시작 무드입니다.")
end
if not isArray(battle.traitIds) then
addError(errors, "invalid_trait_ids", path .. ".battle.traitIds", "특징 ID 목록이 배열이 아닙니다.")
else
local effectivePlanCapacity = battle.planCapacity
for index, traitId in ipairs(battle.traitIds) do
local trait = traits[traitId]
if not trait or trait.owner ~= "character" then
addError(errors, "unknown_character_trait", path .. ".battle.traitIds[" .. index .. "]", "캐릭터 특징을 찾을 수 없습니다.")
elseif isFiniteInteger(effectivePlanCapacity) and isArray(trait.modifiers) then
for _, modifier in ipairs(trait.modifiers) do
if type(modifier) == "table"
and modifier.stat == "planCapacity"
and modifier.operation == "add"
and isFiniteInteger(modifier.amount) then
effectivePlanCapacity = effectivePlanCapacity + modifier.amount
end
end
end
end
if isPlanCapacity(battle.planCapacity)
and not isPlanCapacity(effectivePlanCapacity) then
addError(
errors,
"invalid_effective_plan_capacity",
path .. ".battle.planCapacity",
"기본 계획 용량과 특징 보정의 합은 1 이상 16 이하여야 합니다."
)
end
end
if not isArray(battle.deck) or #battle.deck == 0 then
addError(errors, "invalid_character_deck", path .. ".battle.deck", "캐릭터 덱이 비어 있거나 배열이 아닙니다.")
else
for index, cardId in ipairs(battle.deck) do
local card = cards[cardId]
if not card or card.owner ~= "character" then
addError(errors, "invalid_character_card", path .. ".battle.deck[" .. index .. "]", "캐릭터 카드를 찾을 수 없습니다.")
end
end
end
end
end
end
-- pairs 순서에 따라 중복 오류의 위치가 달라지지 않도록 내부 ID 순으로
-- 검사한다. 같은 표시 이름은 선택 화면에서 구분할 수 없으므로 정적 데이터
-- 로딩 자체를 실패시킨다.
table.sort(namedCharacters, function(left, right)
return left.id < right.id
end)
local firstCharacterByName = {}
for _, entry in ipairs(namedCharacters) do
local firstId = firstCharacterByName[entry.name]
if firstId ~= nil then
addError(
errors,
"duplicate_character_name",
"characters." .. entry.id .. ".name",
"캐릭터 이름 '" .. entry.name .. "'은 이미 characters."
.. firstId .. ".name에서 사용되었습니다. 캐릭터 이름은 중복될 수 없습니다."
)
else
firstCharacterByName[entry.name] = entry.id
end
end
end
local function validateCapturedStaticData(captured, discoveredCharacterList, discoveryErrors)
local errors = {}
for _, item in ipairs(discoveryErrors or {}) do
table.insert(errors, item)
end
local registry = loadSingleModule(SOURCES.registry, errors, captured)
local cards = loadMergedCollection(SOURCES.cards, errors, captured)
local traits = loadMergedCollection(SOURCES.traits, errors, captured)
local subwayLines = loadMergedCollection(SOURCES.subwayLines, errors, captured)
local characterList = discoveredCharacterList
if characterList == nil then
characterList = loadMergedCollection(SOURCES.characterList, errors, captured)
end
validateCharacterList(characterList, errors)
local characters = loadCharacterDefinitions(characterList, errors, captured)
validateRegistry(registry, errors)
validateCards(cards, registry, errors)
validateTraits(traits, errors)
validateSubwayLines(subwayLines, errors)
validateCharacters(characters, cards, traits, registry, errors)
return {
ok = #errors == 0,
schemaVersion = SUPPORTED_SCHEMA_VERSION,
errors = errors,
counts = {
cards = countEntries(cards),
traits = countEntries(traits),
subwayLines = countEntries(subwayLines),
characters = countEntries(characters),
},
data = #errors == 0 and {
registry = registry,
cards = cards,
traits = traits,
subwayLines = subwayLines,
characters = characters,
} or nil,
}
end
local function loadAndValidateAll(forceRefresh)
staticCacheStats.requests = staticCacheStats.requests + 1
emitDiagnostic(2, "validation_requested", {
forceRefresh = forceRefresh == true,
cachedEntries = #staticCacheEntries,
})
-- main production warm cache는 bundle revision + mode + chat + character별로
-- handler closure를 분리한다. 따라서 같은 handler의 성공 snapshot은 source를
-- 다시 읽지 않고 안전하게 재사용할 수 있다. main 없이 직접 실행되는 로컬
-- 계약 검사는 global이 nil이므로 기존처럼 매번 source identity를 확인한다.
if forceRefresh ~= true
and RUNTIME_CACHE_DEVELOPMENT_BYPASS == false
and #staticCacheEntries > 0 then
local newest = staticCacheEntries[1]
for index = 2, #staticCacheEntries do
if staticCacheEntries[index].lastUsed > newest.lastUsed then
newest = staticCacheEntries[index]
end
end
staticCacheClock = staticCacheClock + 1
newest.lastUsed = staticCacheClock
newest.hits = newest.hits + 1
staticCacheStats.fastHits = staticCacheStats.fastHits + 1
staticCacheStats.hits = staticCacheStats.hits + 1
emitDiagnostic(2, "validation_cache_hit", {
cache = "production_fast",
ok = newest.report.ok == true,
})
return cloneStaticValue(newest.report)
end
local captured = captureBaseStaticLores(triggerId)
local discoveredCharacterList = nil
local discoveryErrors = nil
local dynamicLoreOrder = findCachedDynamicLoreOrder(captured)
if dynamicLoreOrder == nil then
discoveryErrors = {}
discoveredCharacterList = loadMergedCollection(SOURCES.characterList, discoveryErrors, captured)
dynamicLoreOrder = collectCharacterDatabaseNames(discoveredCharacterList)
end
for _, database in ipairs(dynamicLoreOrder) do
captureStaticLore(triggerId, captured, database)
end
local cached = findStaticCacheEntry(captured)
if cached ~= nil then
staticCacheStats.hits = staticCacheStats.hits + 1
emitDiagnostic(2, "validation_cache_hit", {
cache = "source_identity",
ok = cached.report.ok == true,
})
return cloneStaticValue(cached.report)
end
staticCacheStats.misses = staticCacheStats.misses + 1
staticCacheStats.validations = staticCacheStats.validations + 1
local report = validateCapturedStaticData(captured, discoveredCharacterList, discoveryErrors)
emitDiagnostic(report.ok == true and 2 or 1, "validation_completed", {
ok = report.ok == true,
errorCount = #report.errors,
cards = report.counts.cards,
traits = report.counts.traits,
subwayLines = report.counts.subwayLines,
characters = report.counts.characters,
})
if report.ok == true then
-- canonical report는 cache 내부에만 남기고 호출자에게는 별도 snapshot을 준다.
storeStaticCacheEntry(captured, report)
return cloneStaticValue(report)
end
-- 실패한 compile/validation 결과는 수정 후 즉시 다시 검사할 수 있도록 캐시하지 않는다.
staticCacheStats.failedValidations = staticCacheStats.failedValidations + 1
return report
end
local actions = {
loadAll = loadAndValidateAll,
validateAll = function()
local result = loadAndValidateAll()
result.data = nil
return result
end,
reloadAll = function()
return loadAndValidateAll(true)
end,
cacheStats = function()
return {
ok = true,
schemaVersion = SUPPORTED_SCHEMA_VERSION,
errors = {},
cache = getStaticCacheDiagnostics(),
}
end,
clearCache = function()
return {
ok = true,
schemaVersion = SUPPORTED_SCHEMA_VERSION,
errors = {},
removed = clearStaticCache(),
}
end,
}
emitDiagnostic(2, "request", {
action = tostring(action),
})
local handler = actions[action]
if not handler then
return {
ok = false,
schemaVersion = SUPPORTED_SCHEMA_VERSION,
errors = {
{
code = "unknown_action",
path = "staticData",
message = "지원하지 않는 정적 데이터 작업입니다: " .. tostring(action),
},
},
}
end
return handler()
end
end)()
#49subwayJourney.lua
Keys:
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local ALGORITHM = "tokyo_subway_segment_v1"
local MIN_TURNS = 7
local MAX_TURNS = 12
local SEED_MODULUS = 2147483646
local ROUTE_DOMAIN_OFFSET = 130363
local SCENE_DOMAIN_OFFSET = 425033
local MAX_SAFE_INTEGER = 9007199254740991
local WEEKDAYS = { "월요일", "화요일", "수요일", "목요일", "금요일", "토요일", "일요일" }
local WEEKDAY_TIMES = { "아침 출근시간", "한낮", "저녁 퇴근시간", "심야열차" }
local WEEKEND_TIMES = { "아침 시간", "한낮", "저녁 시간", "심야열차" }
local WEATHER_POOL = { "맑음", "맑음", "맑음", "흐림", "흐림", "가벼운 비", "가벼운 비", "거센 비" }
local function makeError(code, path, message)
return {
code = code,
path = path,
message = message,
}
end
local function failure(errors)
return {
ok = false,
schemaVersion = SCHEMA_VERSION,
algorithm = ALGORITHM,
errors = errors,
}
end
local function success(value)
value.ok = true
value.schemaVersion = SCHEMA_VERSION
value.algorithm = ALGORITHM
value.errors = {}
return value
end
local function isSafeInteger(value, minimum)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
and value % 1 == 0
and math.abs(value) <= MAX_SAFE_INTEGER
and (minimum == nil or value >= minimum)
end
local function normalizeStaticData(staticData)
if type(staticData) == "table" and type(staticData.data) == "table" then
return staticData.data
end
return staticData
end
local function deriveRouteSeed(seed)
local normalized = seed % SEED_MODULUS
return ((normalized + ROUTE_DOMAIN_OFFSET) % SEED_MODULUS) + 1
end
local function deriveSceneSeed(seed)
local normalized = seed % SEED_MODULUS
return ((normalized + SCENE_DOMAIN_OFFSET) % SEED_MODULUS) + 1
end
local function sortedKeys(collection)
local keys = {}
for key in pairs(type(collection) == "table" and collection or {}) do
keys[#keys + 1] = key
end
table.sort(keys)
return keys
end
local function copyArray(source)
local copy = {}
for index, value in ipairs(source or {}) do
copy[index] = value
end
return copy
end
local function nextInteger(rng, minimum, maximum, path)
if type(runScript) ~= "function" then
return nil, nil, makeError(
"runtime_unavailable",
"$.runtime.deterministicRng",
"여정 추첨에 필요한 결정적 RNG를 호출할 수 없습니다."
)
end
local ok, report = pcall(
runScript,
triggerId,
"deterministicRng",
"nextInteger",
rng,
minimum,
maximum
)
if not ok then
return nil, nil, makeError(
"rng_call_failed",
"$.runtime.deterministicRng",
"여정 추첨 RNG 호출에 실패했습니다: " .. tostring(report)
)
end
if type(report) ~= "table" or report.ok ~= true
or not isSafeInteger(report.value, minimum)
or report.value > maximum
or type(report.rng) ~= "table"
or report.rng.seed ~= rng.seed
or not isSafeInteger(report.rng.cursor, rng.cursor + 1) then
return nil, nil, makeError(
"invalid_rng_result",
path,
"여정 추첨 RNG가 올바른 값과 다음 상태를 반환하지 않았습니다."
)
end
return report.value, report.rng, nil
end
local function linearCandidates(routePath, turnLimit)
local candidates = {}
local stations = routePath.stations
local lastStart = #stations - turnLimit
if lastStart < 1 then
return candidates
end
for startIndex = 1, lastStart do
local forward = {}
local reverse = {}
for offset = 0, turnLimit do
forward[#forward + 1] = stations[startIndex + offset].id
reverse[#reverse + 1] = stations[startIndex + turnLimit - offset].id
end
candidates[#candidates + 1] = forward
candidates[#candidates + 1] = reverse
end
return candidates
end
local function circularCandidates(routePath, turnLimit)
local candidates = {}
local stations = routePath.stations
local stationCount = #stations
if stationCount < turnLimit + 1 then
return candidates
end
for startIndex = 1, stationCount do
for _, direction in ipairs({ 1, -1 }) do
local stationIds = {}
local cursor = startIndex
for _ = 0, turnLimit do
stationIds[#stationIds + 1] = stations[cursor].id
cursor = ((cursor - 1 + direction) % stationCount) + 1
end
candidates[#candidates + 1] = stationIds
end
end
return candidates
end
local function collectLineCandidates(line, turnLimit)
local candidates = {}
for _, routePath in ipairs(type(line) == "table" and line.paths or {}) do
local pathCandidates
if routePath.circular == true then
pathCandidates = circularCandidates(routePath, turnLimit)
else
pathCandidates = linearCandidates(routePath, turnLimit)
end
for _, stationIds in ipairs(pathCandidates) do
candidates[#candidates + 1] = {
pathId = routePath.id,
stationIds = stationIds,
}
end
end
return candidates
end
local function buildSceneContext(seed)
local rng = { seed = deriveSceneSeed(seed), cursor = 0 }
local weekdayIndex, nextRng, rngError
repeat
weekdayIndex, nextRng, rngError = nextInteger(rng, 1, 8, "$.sceneContext.weekday")
if rngError then return nil, rngError end
rng = nextRng
until weekdayIndex <= #WEEKDAYS
local times = weekdayIndex <= 5 and WEEKDAY_TIMES or WEEKEND_TIMES
local timeIndex
timeIndex, nextRng, rngError = nextInteger(rng, 1, #times, "$.sceneContext.time")
if rngError then return nil, rngError end
rng = nextRng
local weatherIndex
weatherIndex, _, rngError = nextInteger(rng, 1, #WEATHER_POOL, "$.sceneContext.weather")
if rngError then return nil, rngError end
return {
weekday = WEEKDAYS[weekdayIndex],
time = times[timeIndex],
weather = WEATHER_POOL[weatherIndex],
}, nil
end
local function build(seed, staticInput, requestedTurnLimit)
if not isSafeInteger(seed, 0) then
return failure({
makeError("invalid_seed", "$.seed", "여정 생성 seed는 0 이상의 안전 정수여야 합니다."),
})
end
if not isSafeInteger(requestedTurnLimit, MIN_TURNS) or requestedTurnLimit > MAX_TURNS then
return failure({
makeError("invalid_turn_limit", "$.turnLimit", "제한 턴은 7 이상 12 이하의 정수여야 합니다."),
})
end
local staticData = normalizeStaticData(staticInput)
local subwayLines = type(staticData) == "table" and staticData.subwayLines or nil
if type(subwayLines) ~= "table" or next(subwayLines) == nil then
return failure({
makeError("missing_subway_lines", "$.staticData.subwayLines", "여정 생성에 필요한 지하철 노선 DB가 없습니다."),
})
end
local rng = {
seed = deriveRouteSeed(seed),
cursor = 0,
}
local turnLimit, nextRng, rngError = nextInteger(
rng,
requestedTurnLimit,
requestedTurnLimit,
"$.turnLimit"
)
if rngError then
return failure({ rngError })
end
rng = nextRng
local eligible = {}
for _, lineId in ipairs(sortedKeys(subwayLines)) do
local candidates = collectLineCandidates(subwayLines[lineId], turnLimit)
if #candidates > 0 then
eligible[#eligible + 1] = {
lineId = lineId,
candidates = candidates,
}
end
end
if #eligible == 0 then
return failure({
makeError("no_eligible_subway_line", "$.staticData.subwayLines", "추첨된 턴 수에 맞는 지하철 노선이 없습니다."),
})
end
local lineIndex
lineIndex, nextRng, rngError = nextInteger(
rng,
1,
#eligible,
"$.lineIndex"
)
if rngError then
return failure({ rngError })
end
rng = nextRng
local selectedLine = eligible[lineIndex]
local candidateIndex
candidateIndex, nextRng, rngError = nextInteger(
rng,
1,
#selectedLine.candidates,
"$.candidateIndex"
)
if rngError then
return failure({ rngError })
end
rng = nextRng
local selected = selectedLine.candidates[candidateIndex]
local sceneContext, sceneError = buildSceneContext(seed)
if sceneError then
return failure({ sceneError })
end
return success({
turnLimit = turnLimit,
sceneContext = sceneContext,
transit = {
algorithm = ALGORITHM,
lineId = selectedLine.lineId,
stationIds = copyArray(selected.stationIds),
},
receipt = {
routeSeed = rng.seed,
rngCursor = rng.cursor,
pathId = selected.pathId,
eligibleLineCount = #eligible,
candidateCount = #selectedLine.candidates,
},
})
end
local arguments = { ... }
if action == "build" then
return build(arguments[1], arguments[2], arguments[3])
end
return failure({
makeError("unknown_action", "$.action", "지원하지 않는 지하철 여정 작업입니다: " .. tostring(action)),
})
end)
#50triggerPipeline.lua
Keys:
(function(triggerId, action, ...)
local SCHEMA_VERSION = 1
local CATEGORY_ORDER = {
plan = 1,
trait = 2,
perk = 3,
}
local function makeError(code, path, message)
return {
code = code,
path = path,
message = message,
}
end
local function failure(errors)
return {
ok = false,
schemaVersion = SCHEMA_VERSION,
errors = errors,
}
end
local function success(state, transient, records)
return {
ok = true,
schemaVersion = SCHEMA_VERSION,
errors = {},
state = state,
transient = transient,
records = records,
}
end
local function isFinite(value)
return type(value) == "number"
and value == value
and value ~= math.huge
and value ~= -math.huge
end
local function isInteger(value, minimum)
return isFinite(value)
and value % 1 == 0
and (minimum == nil or value >= minimum)
end
local function isDenseArray(value)
if type(value) ~= "table" or getmetatable(value) ~= nil then
return false
end
local count = 0
local maximum = 0
for key in pairs(value) do
if not isInteger(key, 1) then
return false
end
count = count + 1
maximum = math.max(maximum, key)
end
return count == maximum
end
local function cloneData(value, path, active)
local valueType = type(value)
if valueType ~= "table" then
if valueType == "nil"
or valueType == "string"
or valueType == "number"
or valueType == "boolean" then
if valueType == "number" and not isFinite(value) then
return nil, makeError(
"non_finite_number",
path,
"유한하지 않은 숫자는 트리거 파이프라인 데이터에 복제할 수 없습니다."
)
end
return value, nil
end
return nil, makeError(
"unsupported_type",
path,
"트리거 파이프라인 데이터에 복제할 수 없는 자료형입니다: " .. valueType
)
end
if getmetatable(value) ~= nil then
return nil, makeError(
"metatable_not_allowed",
path,
"메타테이블이 있는 값은 트리거 파이프라인 데이터에 복제할 수 없습니다."
)
end
active = active or {}
if active[value] then
return nil, makeError(
"circular_reference",
path,
"순환 참조는 트리거 파이프라인 데이터에 복제할 수 없습니다."
)
end
active[value] = true
local copy = {}
for key, item in pairs(value) do
local keyCopy, keyError = cloneData(key, path .. ".<key>", active)
if keyError then
active[value] = nil
return nil, keyError
end
local itemCopy, itemError = cloneData(item, path .. "." .. tostring(key), active)
if itemError then
active[value] = nil
return nil, itemError
end
copy[keyCopy] = itemCopy
end
active[value] = nil
return copy, nil
end
local function normalizeStaticData(staticData)
if type(staticData) == "table" and type(staticData.data) == "table" then
return staticData.data
end
return staticData
end
local function appendErrors(target, nested)
if type(nested) ~= "table" then
target[#target + 1] = makeError(
"invalid_nested_error",
"$",
"하위 모듈 오류 목록이 올바르지 않습니다."
)
return
end
for _, item in ipairs(nested) do
target[#target + 1] = {
code = tostring(type(item) == "table" and item.code or "nested_error"),
path = tostring(type(item) == "table" and item.path or "$"),
message = tostring(
type(item) == "table" and item.message
or "하위 모듈 작업이 실패했습니다."
),
}
end
end
local function callModule(moduleName, moduleAction, ...)
if type(runScript) ~= "function" then
return nil, {
makeError(
"runtime_unavailable",
"$.runtime." .. moduleName,
"스크립트 실행기를 찾을 수 없습니다."
),
}
end
local ok, report = pcall(runScript, triggerId, moduleName, moduleAction, ...)
if not ok then
return nil, {
makeError(
"module_call_error",
"$.runtime." .. moduleName,
moduleName .. "." .. moduleAction .. " 실행에 실패했습니다: " .. tostring(report)
),
}
end
if type(report) ~= "table" then
return nil, {
makeError(
"invalid_module_result",
"$.runtime." .. moduleName,
"하위 모듈이 테이블 결과를 반환하지 않았습니다."
),
}
end
if report.ok ~= true then
local errors = {}
appendErrors(errors, report.errors)
return nil, errors
end
return report, nil
end
local function isSide(value)
return value == "player" or value == "character"
end
local function normalizeOptions(options, inputEvent)
if options == nil then
options = {}
end
if type(options) ~= "table" or getmetatable(options) ~= nil then
return nil, {
makeError("invalid_options", "$.options", "트리거 파이프라인 옵션은 일반 테이블이어야 합니다."),
}
end
local errors = {}
local allowed = {
phase = true,
currentCard = true,
insightSide = true,
allowGameplayCommands = true,
}
for key in pairs(options) do
if type(key) ~= "string" or not allowed[key] then
errors[#errors + 1] = makeError(
"unexpected_option",
"$.options." .. tostring(key),
"지원하지 않는 트리거 파이프라인 옵션입니다."
)
end
end
local phase = options.phase
if phase == nil and type(inputEvent) == "table" then
phase = inputEvent.type
end
if type(phase) ~= "string" or string.match(phase, "^[a-z][a-z0-9_]*$") == nil then
errors[#errors + 1] = makeError(
"invalid_phase",
"$.options.phase",
"phase는 lower_snake_case 문자열이어야 합니다."
)
end
if options.insightSide ~= nil and not isSide(options.insightSide) then
errors[#errors + 1] = makeError(
"invalid_insight_side",
"$.options.insightSide",
"insightSide는 player 또는 character여야 합니다."
)
end
if options.allowGameplayCommands ~= nil and type(options.allowGameplayCommands) ~= "boolean" then
errors[#errors + 1] = makeError(
"invalid_allow_gameplay_commands",
"$.options.allowGameplayCommands",
"allowGameplayCommands는 불리언이어야 합니다."
)
end
local currentCard = nil
if options.currentCard ~= nil then
local value = options.currentCard
if type(value) ~= "table" or getmetatable(value) ~= nil then
errors[#errors + 1] = makeError(
"invalid_current_card",
"$.options.currentCard",
"currentCard는 일반 테이블이어야 합니다."
)
else
local cardAllowed = {
id = true,
instanceId = true,
owner = true,
roles = true,
effectChoiceId = true,
}
for key in pairs(value) do
if type(key) ~= "string" or not cardAllowed[key] then
errors[#errors + 1] = makeError(
"unexpected_current_card_field",
"$.options.currentCard." .. tostring(key),
"currentCard에 허용되지 않은 필드가 있습니다."
)
end
end
if type(value.id) ~= "string" or value.id == "" then
errors[#errors + 1] = makeError(
"invalid_current_card_id",
"$.options.currentCard.id",
"현재 카드 ID가 없습니다."
)
end
if type(value.instanceId) ~= "string" or value.instanceId == "" then
errors[#errors + 1] = makeError(
"invalid_current_instance_id",
"$.options.currentCard.instanceId",
"현재 카드 인스턴스 ID가 없습니다."
)
end
if not isSide(value.owner) then
errors[#errors + 1] = makeError(
"invalid_current_card_owner",
"$.options.currentCard.owner",
"현재 카드 소유자는 player 또는 character여야 합니다."
)
end
if not isDenseArray(value.roles) or #value.roles < 1 then
errors[#errors + 1] = makeError(
"invalid_current_roles",
"$.options.currentCard.roles",
"현재 카드 역할이 올바르지 않습니다."
)
end
if value.effectChoiceId ~= nil
and (type(value.effectChoiceId) ~= "string"
or string.match(value.effectChoiceId, "^[a-z][a-z0-9_]*$") == nil) then
errors[#errors + 1] = makeError("invalid_effect_choice_id", "$.options.currentCard.effectChoiceId", "현재 카드 효과 선택값이 올바르지 않습니다.")
end
currentCard = {
id = value.id,
instanceId = value.instanceId,
owner = value.owner,
roles = value.roles,
effectChoiceId = value.effectChoiceId,
}
end
end
if #errors > 0 then
return nil, errors
end
return {
phase = phase,
currentCard = currentCard,
insightSide = options.insightSide,
allowGameplayCommands = options.allowGameplayCommands ~= false,
}, nil
end
local function validateInputs(staticData, working, inputEvent)
local errors = {}
staticData = normalizeStaticData(staticData)
if type(staticData) ~= "table"
or getmetatable(staticData) ~= nil
or type(staticData.registry) ~= "table"
or type(staticData.registry.events) ~= "table"
or type(staticData.cards) ~= "table"
or type(staticData.traits) ~= "table" then
errors[#errors + 1] = makeError(
"invalid_static_data",
"$.staticData",
"트리거 파이프라인에는 전체 정적 데이터가 필요합니다."
)
end
if type(working) ~= "table" or getmetatable(working) ~= nil then
errors[#errors + 1] = makeError(
"invalid_working",
"$.working",
"트리거 파이프라인 working 값은 일반 테이블이어야 합니다."
)
elseif type(working.state) ~= "table"
or getmetatable(working.state) ~= nil
or type(working.state.player) ~= "table"
or type(working.state.character) ~= "table"
or type(working.state.cardInstances) ~= "table" then
errors[#errors + 1] = makeError(
"invalid_working_state",
"$.working.state",
"트리거를 적용할 전투 상태가 올바르지 않습니다."
)
elseif working.transient ~= nil
and (type(working.transient) ~= "table" or getmetatable(working.transient) ~= nil) then
errors[#errors + 1] = makeError(
"invalid_transient",
"$.working.transient",
"트리거 transient 값은 일반 테이블이어야 합니다."
)
end
if type(inputEvent) ~= "table" or getmetatable(inputEvent) ~= nil then
errors[#errors + 1] = makeError(
"invalid_trigger_event",
"$.inputEvent",
"트리거 입력 사건은 일반 테이블이어야 합니다."
)
elseif type(staticData) == "table" and type(staticData.registry) == "table"
and type(staticData.registry.events) == "table" then
if type(inputEvent.type) ~= "string" or not staticData.registry.events[inputEvent.type] then
errors[#errors + 1] = makeError(
"unknown_trigger_event",
"$.inputEvent.type",
"등록되지 않은 트리거 입력 사건입니다."
)
end
if inputEvent.side ~= nil and not isSide(inputEvent.side) then
errors[#errors + 1] = makeError(
"invalid_event_side",
"$.inputEvent.side",
"입력 사건 진영은 player 또는 character여야 합니다."
)
end
end
if #errors > 0 then
return nil, errors
end
return staticData, nil
end
local function countZone(state, owner, zone)
local count = 0
for _, instance in ipairs(state.cardInstances) do
if type(instance) == "table" and instance.owner == owner and instance.zone == zone then
count = count + 1
end
end
return count
end
local function buildHistoryContext(history)
if type(runScript) ~= "function" then
error("battleHistory.context runtime is unavailable", 0)
end
local ok, report = pcall(runScript, triggerId, "battleHistory", "context", history)
if not ok or type(report) ~= "table" or report.ok ~= true or type(report.context) ~= "table" then
error("battleHistory.context failed", 0)
end
return report.context
end
local function buildContext(state, options, planState)
local intent = type(state.characterIntent) == "table" and state.characterIntent or {}
local context = {
turn = state.turnNumber,
turnLimit = state.turnLimit,
remainingTurns = math.max(0, state.turnLimit - state.turnNumber + 1),
phase = options.phase,
mood = state.character.mood,
history = buildHistoryContext(state.history),
player = {
stealth = state.player.stealth,
handCount = countZone(state, "player", "hand"),
planCount = #(state.player.planSlots or {}),
},
character = {
resistance = state.character.resistance,
moodTokens = state.character.moodTokens,
publicRole = intent.publicRole,
planCount = #(state.character.planSlots or {}),
},
}
if options.currentCard ~= nil then
context.card = {
id = options.currentCard.id,
instanceId = options.currentCard.instanceId,
owner = options.currentCard.owner,
roles = options.currentCard.roles,
}
if options.currentCard.effectChoiceId ~= nil then
context.effectChoiceId = options.currentCard.effectChoiceId
end
end
if planState ~= nil then
context.plan = {
cardId = planState.cardId,
cardInstanceId = planState.cardInstanceId,
side = planState.side,
revealed = planState.revealed,
slotIndex = planState.slotIndex,
}
if planState.remainingTurns ~= nil then
context.plan.remainingTurns = planState.remainingTurns
end
if planState.remainingCharges ~= nil then
context.plan.remainingCharges = planState.remainingCharges
end
if planState.effectChoiceId ~= nil then context.effectChoiceId = planState.effectChoiceId end
end
return context
end
local function sideRank(side, actingSide)
if actingSide ~= nil and side == actingSide then
return 1
end
if actingSide ~= nil and isSide(side) then
return 2
end
if actingSide == nil and side == "player" then
return 1
end
if actingSide == nil and side == "character" then
return 2
end
return 3
end
local function candidateSource(candidate)
local value = {
kind = candidate.kind,
id = candidate.sourceId,
}
if candidate.side ~= nil then
value.side = candidate.side
end
if candidate.planState ~= nil then
value.instanceId = candidate.planState.cardInstanceId
end
return value
end
local function appendRecord(records, recordType, candidate, payload)
local record = {
type = recordType,
source = candidateSource(candidate),
}
if candidate.side ~= nil then
record.side = candidate.side
end
if payload ~= nil then
record.payload = payload
end
records[#records + 1] = record
end
local function collectCandidates(staticData, snapshot, inputEvent, options)
local candidates = {}
local nextOrdinal = 1
local function addCandidate(kind, sourceId, ownerSide, declarationIndex, spec, planState, path)
if type(sourceId) ~= "string" or sourceId == "" then
return false, {
makeError("invalid_trigger_source", path, "트리거 source ID가 올바르지 않습니다."),
}
end
if ownerSide ~= nil and not isSide(ownerSide) then
return false, {
makeError("invalid_trigger_owner", path, "트리거 소유 진영이 올바르지 않습니다."),
}
end
if type(spec) ~= "table" or getmetatable(spec) ~= nil or type(spec.resolve) ~= "function" then
return false, {
makeError("invalid_trigger", path, "트리거 정의가 올바르지 않습니다: " .. sourceId),
}
end
candidates[#candidates + 1] = {
kind = kind,
categoryOrder = CATEGORY_ORDER[kind],
sourceId = sourceId,
side = ownerSide,
declarationIndex = declarationIndex or 1,
ordinal = nextOrdinal,
spec = spec,
planState = planState,
path = path,
}
nextOrdinal = nextOrdinal + 1
return true, nil
end
for _, planSide in ipairs({ "player", "character" }) do
local ownerState = snapshot[planSide]
local slots = type(ownerState) == "table" and ownerState.planSlots or nil
if not isDenseArray(slots) then
return nil, {
makeError(
"invalid_plan_slots",
"$.working.state." .. planSide .. ".planSlots",
"계획 슬롯 목록이 올바르지 않습니다."
),
}
end
for slotIndex, slot in ipairs(slots) do
if type(slot) ~= "table" or slot.occupied ~= true then
return nil, {
makeError(
"invalid_plan_slot",
"$.working.state." .. planSide .. ".planSlots[" .. slotIndex .. "]",
"점유 계획 슬롯이 올바르지 않습니다."
),
}
end
local card = staticData.cards[slot.cardId]
local planData = type(card) == "table"
and type(card.mechanismData) == "table"
and card.mechanismData.plan
or nil
local path = "$.staticData.cards." .. tostring(slot.cardId) .. ".mechanismData.plan"
if type(planData) ~= "table" then
return nil, {
makeError("missing_plan_definition", path, "계획 정의를 찾을 수 없습니다."),
}
end
local planState = {
side = planSide,
cardId = slot.cardId,
cardInstanceId = slot.cardInstanceId,
revealed = slot.revealed == true,
slotIndex = slotIndex,
}
if slot.remainingTurns ~= nil then
planState.remainingTurns = slot.remainingTurns
end
if slot.remainingCharges ~= nil then
planState.remainingCharges = slot.remainingCharges
end
if slot.effectChoiceId ~= nil then
planState.effectChoiceId = slot.effectChoiceId
end
local added, addErrors = addCandidate(
"plan",
slot.cardId,
planSide,
slotIndex,
planData,
planState,
path
)
if not added then
return nil, addErrors
end
end
end
local traitIds = snapshot.character.traitIds or {}
if not isDenseArray(traitIds) then
return nil, {
makeError("invalid_trait_ids", "$.working.state.character.traitIds", "특징 ID 목록이 배열이 아닙니다."),
}
end
for _, traitId in ipairs(traitIds) do
local trait = staticData.traits[traitId]
if type(trait) ~= "table" then
return nil, {
makeError("unknown_trait", "$.working.state.character.traitIds", "특징을 찾을 수 없습니다: " .. tostring(traitId)),
}
end
if trait.triggers ~= nil then
local path = "$.staticData.traits." .. tostring(traitId) .. ".triggers"
if not isDenseArray(trait.triggers) then
return nil, {
makeError("invalid_triggers", path, "특징 트리거가 배열이 아닙니다."),
}
end
for index, spec in ipairs(trait.triggers) do
local added, addErrors = addCandidate(
"trait",
traitId,
trait.owner,
index,
spec,
nil,
path .. "[" .. index .. "]"
)
if not added then
return nil, addErrors
end
end
end
end
local perkIds = snapshot.player.perkIds or {}
if not isDenseArray(perkIds) then
return nil, {
makeError("invalid_perk_ids", "$.working.state.player.perkIds", "퍽 ID 목록이 배열이 아닙니다."),
}
end
for _, perkId in ipairs(perkIds) do
local perk = type(staticData.perks) == "table" and staticData.perks[perkId] or nil
if type(perk) ~= "table" then
return nil, {
makeError("unknown_perk", "$.working.state.player.perkIds", "퍽을 찾을 수 없습니다: " .. tostring(perkId)),
}
end
if perk.triggers ~= nil then
local path = "$.staticData.perks." .. tostring(perkId) .. ".triggers"
if not isDenseArray(perk.triggers) then
return nil, {
makeError("invalid_triggers", path, "퍽 트리거가 배열이 아닙니다."),
}
end
for index, spec in ipairs(perk.triggers) do
local added, addErrors = addCandidate(
"perk",
perkId,
perk.owner or "player",
index,
spec,
nil,
path .. "[" .. index .. "]"
)
if not added then
return nil, addErrors
end
end
end
end
table.sort(candidates, function(left, right)
if left.categoryOrder ~= right.categoryOrder then
return left.categoryOrder < right.categoryOrder
end
local leftSide = sideRank(left.side, inputEvent.side)
local rightSide = sideRank(right.side, inputEvent.side)
if leftSide ~= rightSide then
return leftSide < rightSide
end
if left.sourceId ~= right.sourceId then
return left.sourceId < right.sourceId
end
if left.declarationIndex ~= right.declarationIndex then
return left.declarationIndex < right.declarationIndex
end
return left.ordinal < right.ordinal
end)
local matched = {}
for _, candidate in ipairs(candidates) do
local context = buildContext(snapshot, options, candidate.planState)
local conditionReport, conditionErrors = callModule(
"effectEngine",
"evaluateTriggerCondition",
staticData,
candidate.spec,
context,
inputEvent
)
if conditionErrors then
return nil, conditionErrors
end
if conditionReport.matched == true then
candidate.context = context
matched[#matched + 1] = candidate
end
end
return matched, nil
end
local function runPipeline(staticData, working, inputEvent, options)
local normalizedStaticData, inputErrors = validateInputs(staticData, working, inputEvent)
if inputErrors then
return failure(inputErrors)
end
local normalizedOptions, optionErrors = normalizeOptions(options, inputEvent)
if optionErrors then
return failure(optionErrors)
end
local state, cloneError = cloneData(working.state, "$.working.state")
if cloneError then
return failure({ cloneError })
end
local transient
transient, cloneError = cloneData(working.transient or {}, "$.working.transient")
if cloneError then
return failure({ cloneError })
end
local eventSnapshot
eventSnapshot, cloneError = cloneData(inputEvent, "$.inputEvent")
if cloneError then
return failure({ cloneError })
end
local stateSnapshot
stateSnapshot, cloneError = cloneData(state, "$.triggerSnapshot")
if cloneError then
return failure({ cloneError })
end
local candidates, candidateErrors = collectCandidates(
normalizedStaticData,
stateSnapshot,
eventSnapshot,
normalizedOptions
)
if candidateErrors then
return failure(candidateErrors)
end
local records = {}
for _, candidate in ipairs(candidates) do
local suppressed = normalizedOptions.insightSide ~= nil
and candidate.kind == "plan"
and candidate.side ~= normalizedOptions.insightSide
if suppressed then
appendRecord(records, "trigger_suppressed", candidate, {
inputEventType = eventSnapshot.type,
reasonCode = "insight",
hidden = candidate.planState.revealed ~= true,
})
else
local resolveReport, resolveErrors = callModule(
"effectEngine",
"evaluateTriggerResolve",
normalizedStaticData,
candidate.spec,
candidate.context,
eventSnapshot
)
if resolveErrors then
return failure(resolveErrors)
end
if not normalizedOptions.allowGameplayCommands and #resolveReport.commands > 0 then
return failure({
makeError(
"unsupported_session_end_commands",
candidate.path,
"게임플레이 명령이 금지된 트리거 batch에서 명령을 반환했습니다."
),
})
end
local beforePlanSlots = nil
if candidate.kind == "plan" then
beforePlanSlots, cloneError = cloneData(
state[candidate.side].planSlots,
"$.plan.before"
)
if cloneError then
return failure({ cloneError })
end
end
if #resolveReport.commands > 0 then
local applyReport, applyErrors = callModule(
"effectEngine",
"applyCommands",
normalizedStaticData,
{ state = state, transient = transient },
resolveReport.commands
)
if applyErrors then
return failure(applyErrors)
end
state = applyReport.state
transient = applyReport.transient
for _, applied in ipairs(applyReport.applied or {}) do
local payload
payload, cloneError = cloneData(applied, "$.records.effect_applied.payload")
if cloneError then
return failure({ cloneError })
end
appendRecord(records, "effect_applied", candidate, payload)
end
end
if candidate.kind == "plan" then
local zoneReport, zoneErrors = callModule(
"cardZones",
"consumePlanCharge",
state,
candidate.side,
candidate.planState.cardInstanceId
)
if zoneErrors then
return failure(zoneErrors)
end
state = zoneReport.state
local afterPlanSlots
afterPlanSlots, cloneError = cloneData(
state[candidate.side].planSlots,
"$.plan.after"
)
if cloneError then
return failure({ cloneError })
end
local movedInstanceIds
movedInstanceIds, cloneError = cloneData(
zoneReport.movedInstanceIds or {},
"$.plan.movedInstanceIds"
)
if cloneError then
return failure({ cloneError })
end
appendRecord(records, "plan_changed", candidate, {
action = "triggered",
before = beforePlanSlots,
after = afterPlanSlots,
discarded = #movedInstanceIds > 0,
movedInstanceIds = movedInstanceIds,
})
end
appendRecord(records, "trigger_resolved", candidate, {
inputEventType = eventSnapshot.type,
commandCount = #resolveReport.commands,
})
end
end
return success(state, transient, records)
end
local arguments = { ... }
local actions = {
run = runPipeline,
}
local handler = actions[action]
if not handler then
return failure({
makeError(
"unknown_action",
"$.action",
"지원하지 않는 트리거 파이프라인 작업입니다: " .. tostring(action)
),
})
end
return handler(arguments[1], arguments[2], arguments[3], arguments[4])
end)
Showing 50 of 59
Extensions: risuai (their contents are in the Raw tab)