Walk with the arrow keys or D-pad. Tall grass may hide wild microbes. The same seed and route produce the same encounters. START opens your party. SELECT opens the Lineage Dex.방향키 또는 D-패드로 원시 연못을 걷습니다. 키큰풀에 들어서면 야생 미생물과 조우할 수 있습니다. 같은 시드·같은 경로면 늘 같은 곳에서 같은 조우가 재현됩니다. START로 파티를, SELECT로 계통도감을 엽니다.
↑ ↓ ← → move · A(Z) confirm · B(X) cancel or flee · START(Enter) party · SELECT(Shift) Lineage Dex↑ ↓ ← → 이동 · A(Z)로 결정 · B(X)로 취소·도망 · START(Enter) 파티 · SELECT(Shift) 계통도감
// ===== main.tpz =====
// slow.monster 의 진입점입니다. 입력 패킷 하나를 읽어 순수 코어로 다음 상태를 만들고 그 상태와 그리기 목록을 출력합니다.
// 입력은 SM1, STATE:<직전 STATE 또는 빈칸>, EVENT:<init|resume|up|down|left|right|a|b|start|select|auto>, SHELL:<seed=,demo=,intent=,...> 네 줄이고 출력은 SM1, STATE:<새 STATE>, DRAW:<그리기 목록> 세 줄입니다.
// 같은 패킷이면 늘 같은 출력입니다. 시드는 init 에서만 SHELL 을 따르고 그 뒤로는 STATE 안의 월드시드를 씁니다. demo 와 intent 도 입력의 일부라 켠 쪽과 끈 쪽이 각각 결정론입니다.
// 무작위 조우는 없고 마주 본 엔티티에 A 를 눌러야 전투나 휴식이 일어납니다. 읽지 못한 STATE 는 기본 상태로 닫습니다.
// slow.monster entry: one input packet in, the next STATE and its draw list out.
import std.io
import core.state
import core.drawlist { 드로우리스트 }
import core.creature
import core.battle
import core.encounter { 야생크리처 }
import core.genome { 야생계통시드, 진화준비, 진화임계, 드리프트가두기 }
import core.clash
import core.evolution
import data.maps { 맵타일들, 타일에서, 워프에서, 워프, 타일_물, 타일_나무 }
import data.species
import data.entities
import core.auto { 자동결정 }
import core.story { 파생비트, 켜진비트인가, 비트켜기, 비트끄기, 최하위비트, 비트수 }
import core.util { 범위가두기 }
let 기본시드 = "SM-SEED-001"
// 공용 도우미 시작 (줄값 셸값)
// 여러 도구가 같은 원본을 씁니다. 여기서 고치지 않고 원본에서 고친 뒤 다시 생성합니다.
// 같은 접두의 줄이 여럿이면 마지막 줄을 씁니다.
function 줄값(입력: string, 접두: string) -> string {
let 맞는줄들 = 입력.split("\n").map(줄 => 줄.trim()).filter(줄 => 줄.startsWith(접두))
if 맞는줄들.length == 0 { return "" }
let 끝줄 = 맞는줄들[맞는줄들.length - 1]
끝줄.slice(접두.scalars().length, 끝줄.scalars().length).trim()
}
// "키=값,키=값" 에서 = 로 정확히 두 조각인 항만 읽고 키와 값의 앞뒤 공백을 지웁니다. 같은 키가 여럿이면 마지막 값을 씁니다.
function 셸값(셸: string, 키: string) -> string {
let 값들 = 셸.split(",").map(항 => 항.split("=")).filter(조각들 => 조각들.length == 2 && 조각들[0].trim() == 키)
if 값들.length == 0 { "" } else { 값들[값들.length - 1][1].trim() }
}
// 공용 도우미 끝
type 이벤트 = "init" | "resume" | "up" | "down" | "left" | "right" | "a" | "b" | "start" | "select" | "auto" | "unknown"
function 이벤트파싱(토큰: string) -> 이벤트 {
match 토큰.trim() {
case "init" => "init"
case "resume" => "resume"
case "up" => "up"
case "down" => "down"
case "left" => "left"
case "right" => "right"
case "a" => "a"
case "b" => "b"
case "start" => "start"
case "select" => "select"
case "auto" => "auto"
case _ => "unknown"
}
}
function 진행입력인가(이벤트값: 이벤트) -> bool {
match 이벤트값 {
case "a" | "b" => true
case "init" | "resume" | "up" | "down" | "left" | "right" | "start" | "select" | "auto" | "unknown" => false
}
}
function 파티슬롯교체(파티: Array<creature.전투원>, 자리: int, 새것: creature.전투원) -> Array<creature.전투원> {
(0..<파티.length).map(i => if i == 자리 { 새것 } else { 파티[i] })
}
// 물, 나무, 엔티티 칸은 막혀 제자리에서 방향만 바꿉니다. 옮긴 칸에 워프가 있으면 목적 맵의 목적 칸으로 갑니다.
function 이동(현재: state.상태, 방향: state.방향) -> state.상태 {
let 돌아선 = 현재.플레이어{ 방향: 방향 }
let 새x = state.마주x(돌아선)
let 새y = state.마주y(돌아선)
let 타일 = 타일에서(맵타일들(현재.맵아이디), 새x, 새y)
let 막힘 = 타일 == 타일_물 || 타일 == 타일_나무 || entities.활성엔티티칸인가(현재.맵아이디, 새x, 새y, 현재.처치된것들)
let 목적x = if 막힘 { 현재.플레이어.x } else { 새x }
let 목적y = if 막힘 { 현재.플레이어.y } else { 새y }
let 도착 = match 워프에서(현재.맵아이디, 목적x, 목적y) {
case Some(대상) => { 맵아이디: 대상.목적맵, x: 대상.목적x, y: 대상.목적y }
case None => { 맵아이디: 현재.맵아이디, x: 목적x, y: 목적y }
}
현재{
스텝: 현재.스텝 + 1,
플레이어: { x: 도착.x, y: 도착.y, 방향: 방향 },
맵아이디: 도착.맵아이디,
장면: "field",
야생: state.빈야생(),
}
}
// 야생이면 그 종과 레벨로 압력전을 열고, 인물이면 쉬어 파티 전체를 채웁니다.
function 상호작용(현재: state.상태) -> state.상태 {
let 대상 = entities.활성엔티티에서(현재.맵아이디, state.마주x(현재.플레이어), state.마주y(현재.플레이어), 현재.처치된것들)
match 대상.종류 {
case 야생(종아이디, 레벨) => {
let 적종 = species.종찾기(종아이디)
현재{
장면: "battle",
야생: 야생크리처 { 종아이디: 적종.아이디, 이름: 적종.이름, 레벨: 레벨, 체력: 적종.기본체력, 스프라이트: 적종.스프라이트, 속성: 적종.속성 },
배틀: clash.압력전시작(종아이디, 레벨),
}
}
case 인물(_) => state.파티회복(현재)
case 없음 => 현재
}
}
// 전투 중에는 플레이어가 움직이지 않으므로 마주 본 칸이 여전히 그 야생입니다.
function 처치적용(현재: state.상태) -> state.상태 {
let 대상 = entities.활성엔티티에서(현재.맵아이디, state.마주x(현재.플레이어), state.마주y(현재.플레이어), 현재.처치된것들)
if entities.야생인가(대상) { 현재{ 처치된것들: state.처치추가(현재.처치된것들, 대상.아이디) } } else { 현재 }
}
// SELECT 버튼과 Shift 키는 같은 select 이벤트를 보냅니다.
function 필드적용(이벤트값: 이벤트, 직전: state.상태) -> state.상태 {
match 이벤트값 {
case "up" => 이동(직전, "위")
case "down" => 이동(직전, "아래")
case "left" => 이동(직전, "왼쪽")
case "right" => 이동(직전, "오른쪽")
case "a" => 상호작용(직전)
case "start" => 직전{ 장면: "party", 파티커서: 0 }
case "select" => 직전{ 장면: "dex" }
case "init" | "resume" | "b" | "auto" | "unknown" => 직전
}
}
// 복원한 커서는 범위를 벗어날 수 있어 한쪽 끝만 넘어갈 때 반대쪽으로 돕니다.
function 이전커서(커서: int, 길이: int) -> int {
if 커서 - 1 < 0 { 길이 - 1 } else { 커서 - 1 }
}
function 다음커서(커서: int, 길이: int) -> int {
if 커서 + 1 >= 길이 { 0 } else { 커서 + 1 }
}
// A 는 커서의 동료를 초점으로 삼아 이제 그 한 마리가 배틀하고 진화합니다.
function 파티적용(이벤트값: 이벤트, 직전: state.상태) -> state.상태 {
let 길이 = 직전.파티.length
match 이벤트값 {
case "b" | "start" => 직전{ 장면: "field", 파티커서: 0 }
case "up" => if 길이 <= 0 { 직전 } else { 직전{ 장면: "party", 파티커서: 이전커서(직전.파티커서, 길이) } }
case "down" => if 길이 <= 0 { 직전 } else { 직전{ 장면: "party", 파티커서: 다음커서(직전.파티커서, 길이) } }
case "a" => if 길이 <= 0 { 직전 } else { 직전{ 초점: 범위가두기(직전.파티커서, 0, 길이 - 1) } }
case "init" | "resume" | "left" | "right" | "select" | "auto" | "unknown" => 직전
}
}
// 커서는 발견 순서로 돌고 닫았다 열어도 같은 노드를 가리킵니다.
function 도감적용(이벤트값: 이벤트, 직전: state.상태) -> state.상태 {
let 길이 = 직전.계통노드들.length
match 이벤트값 {
case "b" | "select" => 직전{ 장면: "field" }
case "left" | "up" => if 길이 <= 0 { 직전 } else { 직전{ 장면: "dex", 도감커서: 이전커서(직전.도감커서, 길이) } }
case "right" | "down" => if 길이 <= 0 { 직전 } else { 직전{ 장면: "dex", 도감커서: 다음커서(직전.도감커서, 길이) } }
case "init" | "resume" | "a" | "start" | "auto" | "unknown" => 직전
}
}
function 배틀갱신(직전: state.상태, 새배틀: battle.배틀상태, 새활성: creature.전투원) -> state.상태 {
직전{ 장면: "battle", 파티: 파티슬롯교체(직전.파티, 직전.초점, 새활성), 배틀: 새배틀 }
}
// 패배하면 체력을 채우되 계통시드, 드리프트, 진화 형태는 지우지 않습니다.
function 배틀종료(직전: state.상태, 새활성: creature.전투원, 패배: bool) -> state.상태 {
let 남길전투원 = if 패배 { creature.회복(새활성) } else { 새활성 }
직전{ 장면: "field", 야생: state.빈야생(), 파티: 파티슬롯교체(직전.파티, 직전.초점, 남길전투원), 배틀: battle.빈배틀() }
}
// 같은 시드로 같은 스텝, 칸, 종에서 잡으면 같은 계통시드라 같은 게놈입니다.
function 포획성공처리(직전: state.상태, 새볼: int, 새포획카운터: int) -> state.상태 {
let 계통시드 = 야생계통시드(직전.월드시드, 직전.스텝, 직전.플레이어.x, 직전.플레이어.y, 직전.야생.종아이디)
let 잡은것 = creature.종에서전투원(직전.야생.종아이디, 직전.야생.레벨, 계통시드)
let 추가 = state.파티추가(직전.파티, 직전.보관함, 잡은것)
직전{
장면: "field",
야생: state.빈야생(),
스포어볼: 새볼,
포획카운터: 새포획카운터,
파티: 추가.파티,
보관함: 추가.보관함,
계통노드들: state.노드추가(직전.계통노드들, state.시작노드(잡은것, 직전.스텝)),
배틀: battle.빈배틀(),
}
}
// 후보는 저장하지 않고 부모 스냅샷에서 다시 유도합니다. 부모고유번호는 고정한 뒤 자식 노드에 찍혀 계통수의 가지를 잇습니다.
function 진화장면진입(직전: state.상태, 활성: creature.전투원) -> state.상태 {
// 진화 상태 전체에 타입을 달면 인터프리터와 웹 런타임이 게놈 타입의 모듈을 찾지 못해 단계만 좁혀 둡니다. 토파즈 과제 '구조 타입 주석 속 다른 모듈 레코드' 의 우회입니다.
let 고르기: state.진화단계 = "choose"
let 새진화 = {
단계: 고르기,
부모형태: if 활성.형태이름 != "" { 활성.형태이름 } else { species.종찾기(활성.종아이디).이름 },
부모게놈: 활성.게놈,
부모계통시드: 활성.계통시드,
부모진화카운터: 활성.진화카운터,
부모세대: 활성.세대,
부모고유번호: evolution.계통고유번호(활성.계통시드),
선택커서: 0,
잠긴분기: 0,
결과형태: "",
결과게놈: 활성.게놈,
}
직전{ 장면: "evolve", 야생: state.빈야생(), 진화: 새진화, 배틀: battle.빈배틀() }
}
// 메뉴와 고정이 같은 함수로 후보를 보므로 늘 같은 후보입니다.
function 진화후보들(직전: state.상태) -> Array<evolution.후보> {
let 진 = 직전.진화
evolution.후보들유도(진.부모게놈, evolution.계통고유번호(진.부모계통시드), 진.부모계통시드, 진.부모진화카운터)
}
// 계통은 패배에서 배웁니다. 드리프트를 얻고 체력을 채우며, 준비되면 그 자리에서 진화해 더 강해져 다시 붙습니다. 야생은 맵에 남습니다.
// 그래서 약한 옛 저장도 죽음의 반복 대신 적응으로 빠져나옵니다.
function 배틀패배처리(직전: state.상태, 활성: creature.전투원) -> state.상태 {
let 학습 = creature.드리프트설정(활성, 드리프트가두기(활성.드리프트 + 진화임계))
if 진화준비(학습.드리프트) { 진화장면진입(배틀갱신(직전, battle.빈배틀(), 학습), 학습) } else { 배틀종료(직전, 학습, true) }
}
// 진화장면진입은 키운 전투원이 이미 초점 자리에 들어간 상태를 받아야 합니다.
function 배틀결과단계적용(이벤트값: 이벤트, 직전: state.상태, 활성: creature.전투원, 데모: bool) -> state.상태 {
if !진행입력인가(이벤트값) { return 직전 }
match 직전.배틀.결과 {
case "caught" => 처치적용(포획성공처리(직전, 직전.스포어볼 - 1, 직전.포획카운터 + 1))
case "win" => {
let 성장 = battle.경험적용(활성, creature.획득경험(직전.야생.레벨), 데모)
let 키운 = 성장.전투원
if 성장.오른레벨 > 0 && 진화준비(키운.드리프트) {
처치적용(진화장면진입(배틀갱신(직전, battle.빈배틀(), 키운), 키운))
} else {
처치적용(배틀종료(직전, 키운, false))
}
}
case "lose" | "fled" | "" => 배틀패배처리(직전, 활성)
}
}
// 숲의 뿌리가 몇 그루 생길 때까지 파티 세 마리 미만이면 포획을 원하고, 그 뒤로는 쓰러뜨려 초점을 키웁니다.
function 배틀비트단계적용(이벤트값: 이벤트, 직전: state.상태, 활성: creature.전투원) -> state.상태 {
if !진행입력인가(이벤트값) { return 직전 }
let 결과 = clash.비트진행(직전.월드시드, 직전.배틀, 활성, 직전.야생.종아이디, 직전.야생.레벨, 직전.스포어볼, 직전.파티.length < 3)
배틀갱신(직전, 결과.배틀, 결과.플레이어)
}
// 옛 메뉴 전투의 menu, move, message 단계도 압력전 비트로 이어집니다.
function 배틀적용(이벤트값: 이벤트, 직전: state.상태, 데모: bool) -> state.상태 {
let 활성 = state.초점전투원(직전)
match 직전.배틀.단계 {
case "result" => 배틀결과단계적용(이벤트값, 직전, 활성, 데모)
case "clash" | "menu" | "move" | "message" => 배틀비트단계적용(이벤트값, 직전, 활성)
}
}
function 진화커서설정(직전: state.상태, 커서: int) -> state.상태 {
직전{ 장면: "evolve", 진화: 직전.진화{ 선택커서: 커서 } }
}
// 고정은 되돌릴 수 없습니다. 진화 하위 상태를 morph 로 바꿔 한 프레임 동안 페이지가 모핑 장면을 재생하게 합니다.
function 진화고정(직전: state.상태) -> state.상태 {
let 진 = 직전.진화
let 분기 = 범위가두기(진.선택커서, 0, 진화후보들(직전).length - 1)
let 결과 = evolution.분기진화(state.초점전투원(직전), 분기, 진.부모세대, 진.부모진화카운터)
let 모핑: state.진화단계 = "morph"
let 새진화 = 진{
단계: 모핑,
선택커서: 분기,
잠긴분기: 결과.분기,
결과형태: 결과.형태이름,
결과게놈: 결과.전투원.게놈,
}
직전{
장면: "evolve",
야생: state.빈야생(),
파티: 파티슬롯교체(직전.파티, 직전.초점, 결과.전투원),
계통노드들: state.노드추가(직전.계통노드들, evolution.노드빌드(결과, 진.부모고유번호, 직전.스텝)),
진화: 새진화,
배틀: battle.빈배틀(),
}
}
function 진화종료(직전: state.상태) -> state.상태 {
직전{ 장면: "field", 야생: state.빈야생(), 진화: state.빈진화(), 배틀: battle.빈배틀() }
}
// 모핑 프레임 뒤에는 어떤 키든 진화를 끝냅니다. none 은 생기지 않지만 생기면 필드로 돌아갑니다.
function 진화적용(이벤트값: 이벤트, 직전: state.상태) -> state.상태 {
let 진 = 직전.진화
match 진.단계 {
case "morph" | "none" => 진화종료(직전)
case "choose" => {
let 수 = 진화후보들(직전).length
match 이벤트값 {
case "left" | "up" => 진화커서설정(직전, 이전커서(진.선택커서, 수))
case "right" | "down" => 진화커서설정(직전, 다음커서(진.선택커서, 수))
case "a" => 진화고정(직전)
case "init" | "resume" | "b" | "start" | "select" | "auto" | "unknown" => 직전
}
}
}
}
// 도달했지만 아직 보지 않은 이정표를 본것과 대기에 켭니다. 본것은 큐에 넣을 때 켜서 저장과 재유도에서 겹치지 않습니다.
// 필드에서만 이야기 카드로 넘어가고 전투, 진화, 도감 중에는 큐에만 쌓았다가 필드로 돌아올 때 띄웁니다.
function 스토리갱신(현재: state.상태) -> state.상태 {
let 도달 = 파생비트(현재)
let 새비트들 = (0..<비트수).filter(k => 켜진비트인가(도달, k) && !켜진비트인가(현재.스토리.본것, k))
let 새본것 = 새비트들.reduce(현재.스토리.본것, (비트셋, k) => 비트켜기(비트셋, k))
let 새대기 = 새비트들.reduce(현재.스토리.대기, (비트셋, k) => 비트켜기(비트셋, k))
let 새장면: state.장면 = if 현재.장면 == "field" && 새대기 != 0 { "story" } else { 현재.장면 }
현재{ 장면: 새장면, 스토리: { 본것: state.비트가두기(새본것), 대기: state.비트가두기(새대기) } }
}
// 지금 카드를 큐에서 빼고 남은 카드가 없으면 필드로 갑니다.
function 스토리진행(직전: state.상태) -> state.상태 {
let 비트 = 최하위비트(직전.스토리.대기)
let 새대기 = if 비트 >= 0 { 비트끄기(직전.스토리.대기, 비트) } else { 직전.스토리.대기 }
let 새장면: state.장면 = if 새대기 != 0 { "story" } else { "field" }
직전{ 장면: 새장면, 스토리: { 본것: 직전.스토리.본것, 대기: state.비트가두기(새대기) } }
}
// auto 는 코어가 정한 보통 입력 하나를 같은 엔진으로 적용합니다. 정한 입력이 없으면 수동 갈림길처럼 멈춥니다.
function 적용(이벤트값: 이벤트, 직전: state.상태, 데모: bool, 의도: int) -> state.상태 {
if 이벤트값 == "auto" {
let 자동입력 = 이벤트파싱(자동결정(직전, 의도))
if 자동입력 == "unknown" { return 직전 }
return 적용(자동입력, 직전, 데모, 의도)
}
match 직전.장면 {
case "story" => 스토리진행(직전)
case "battle" => 배틀적용(이벤트값, 직전, 데모)
case "party" => 파티적용(이벤트값, 직전)
case "evolve" => 진화적용(이벤트값, 직전)
case "dex" => 도감적용(이벤트값, 직전)
case "field" => 필드적용(이벤트값, 직전)
}
}
function 역직렬화또는기본(문자열: string, 시드: string) -> state.상태 {
match state.역직렬화(문자열) {
case Ok(상태값) => 상태값
case Err(_) => state.기본상태(시드)
}
}
// 의도 0 은 진화 갈림길에서 멈춰 플레이어가 고르고 1 은 첫 가지, 2 는 무작위 가지입니다.
// 모든 경로를 스토리갱신으로 감싸 init 의 첫 조우 비트가 오프닝 카드로 열립니다. resume 은 어떤 장면이든 행동 없이 그대로 다시 그립니다.
function 처리(입력: string) -> string {
let 이벤트값 = 이벤트파싱(줄값(입력, "EVENT:"))
let 셸 = 줄값(입력, "SHELL:")
let 셸시드 = 셸값(셸, "seed")
let 시드 = if 셸시드 != "" { 셸시드 } else { 기본시드 }
let 데모 = 셸값(셸, "demo") == "1"
let 의도 = match 셸값(셸, "intent") {
case "1" => 1
case "2" => 2
case _ => 0
}
let 상태문자열 = 줄값(입력, "STATE:")
let 새상태 = match 이벤트값 {
case "init" => 스토리갱신(state.기본상태(시드))
case "resume" => 스토리갱신(역직렬화또는기본(상태문자열, 시드))
case "up" | "down" | "left" | "right" | "a" | "b" | "start" | "select" | "auto" | "unknown" => 스토리갱신(적용(이벤트값, 역직렬화또는기본(상태문자열, 시드), 데모, 의도))
}
"SM1\nSTATE:{state.직렬화(새상태)}\nDRAW:{드로우리스트(새상태)}"
}
io.readStdin() |> 처리 |> io.writeLine
// ===== core/state.tpz =====
// 게임 상태 레코드와 STATE 문자열의 직렬화, 복원을 둡니다. 게임 전체가 월드시드와 입력 순서의 순수 함수입니다.
// STATE 는 파이프로 나눈 한 줄입니다. v8 순서는 버전, 시드, 스텝, x, y, 방향, 맵, 장면, 야생 여섯 칸, 스포어볼, 포획카운터, 파티(카운트 + 11칸씩), 보관함, 파티커서, 도감커서, 처치 목록(카운트 접두), 초점, "본것:대기", 계통 노드(카운트 + 7칸씩), 진화 11칸, 배틀 9칸이고 배틀 메시지가 맨 끝입니다.
// 시계, 파일, 시드 없는 난수를 쓰지 않아 같은 입력은 늘 같은 상태입니다. 복원한 상태는 늘 v8 로 다시 직렬화됩니다.
// v7 부터 v0 까지 옛 저장을 읽고, 손상되거나 조작된 값은 가두거나 기본값으로 되돌려 아래쪽 정수 계산이 넘치지 않게 합니다. 빈 문자열과 일곱 칸보다 짧은 저장은 오류로 돌려 진입점이 기본 상태로 닫습니다.
// Game state record and the pipe-separated STATE string: serialize, and restore every save version from v0 to v8 with clamping.
import core.encounter { 야생크리처 }
import core.creature
import core.battle
import core.evolution
import core.genome
import core.util { 범위가두기, 복사추가 }
import data.species
import data.items { 시작스포어볼 }
// 차면 잡은 야생은 보관함으로 갑니다.
export let 파티최대 = 6
// 정상 플레이는 닿지 않는 상한이라 범위 안의 값은 그대로 지나갑니다.
// 좌표 9999 는 24x24 맵을 한참 넘고, 그리기의 (x - 카메라) * 16 과 이동의 ±1 이 넘치지 않습니다.
let 좌표상한 = 9999
// 스텝, 경험, 포획과 전투 카운터, 체력의 상한입니다. 하류의 +1 과 + 적레벨 * 14 가 넘치지 않습니다.
let 카운터상한 = 1000000000
function 좌표가두기(값: int) -> int {
범위가두기(값, 0, 좌표상한)
}
function 카운터가두기(값: int) -> int {
범위가두기(값, 0, 카운터상한)
}
// 손상된 저장의 값도 기존과 같이 열여섯 비트 범위의 양 끝으로 가둡니다.
export function 비트가두기(값: int) -> int {
범위가두기(값, 0, 0xFFFF)
}
export type 방향 = "아래" | "위" | "왼쪽" | "오른쪽"
// 저장 문자열과 그리기 목록의 방향 번호는 0 아래, 1 위, 2 왼쪽, 3 오른쪽입니다. 그 밖의 번호는 아래로 읽습니다.
function 방향읽기(번호: int) -> 방향 {
match 번호 {
case 1 => "위"
case 2 => "왼쪽"
case 3 => "오른쪽"
case _ => "아래"
}
}
export function 방향번호(방향값: 방향) -> int {
match 방향값 {
case "아래" => 0
case "위" => 1
case "왼쪽" => 2
case "오른쪽" => 3
}
}
export type 플레이어 = { x: int, y: int, 방향: 방향 }
// 플레이어가 마주 본 칸입니다.
export function 마주x(대상: 플레이어) -> int {
match 대상.방향 {
case "왼쪽" => 대상.x - 1
case "오른쪽" => 대상.x + 1
case "아래" | "위" => 대상.x
}
}
export function 마주y(대상: 플레이어) -> int {
match 대상.방향 {
case "위" => 대상.y - 1
case "아래" => 대상.y + 1
case "왼쪽" | "오른쪽" => 대상.y
}
}
export type 장면 = "field" | "battle" | "party" | "dex" | "story" | "evolve"
function 장면파싱(토큰: string) -> 장면 {
match 토큰 {
case "battle" => "battle"
case "party" => "party"
case "dex" => "dex"
case "story" => "story"
case "evolve" => "evolve"
case _ => "field"
}
}
// 후보는 저장하지 않고 부모 스냅샷에서 다시 유도합니다. 모핑은 고정 직후 한 프레임이며 페이지가 장면을 재생합니다.
export type 진화단계 = "none" | "choose" | "morph"
function 진화단계파싱(토큰: string) -> 진화단계 {
match 토큰 {
case "choose" => "choose"
case "morph" => "morph"
case _ => "none"
}
}
export type 진화상태 = {
단계: 진화단계,
부모형태: string,
부모게놈: genome.게놈,
부모계통시드: string,
부모진화카운터: int,
부모세대: int,
부모고유번호: int,
선택커서: int,
잠긴분기: int,
결과형태: string,
결과게놈: genome.게놈,
}
// 본것은 한 번씩만 띄우는 이정표, 대기는 보여 줄 카드 큐이고 둘 다 비트셋입니다.
export type 스토리상태 = { 본것: int, 대기: int }
// 배틀, 드리프트, 진화는 파티[초점] 한 마리만 합니다. 잡은 동료마다 제 계통의 뿌리라 도감이 숲이 됩니다.
export type 상태 = {
버전: int,
월드시드: string,
스텝: int,
플레이어: 플레이어,
맵아이디: string,
장면: 장면,
야생: 야생크리처,
스포어볼: int,
포획카운터: int,
파티: Array<creature.전투원>,
보관함: Array<creature.전투원>,
파티커서: int,
도감커서: int,
처치된것들: Array<int>,
초점: int,
스토리: 스토리상태,
계통노드들: Array<evolution.계통노드>,
진화: 진화상태,
배틀: battle.배틀상태,
}
// 초점은 복원할 때 가두지만 한 번 더 가둡니다.
export function 초점전투원(현재: 상태) -> creature.전투원 {
현재.파티[범위가두기(현재.초점, 0, 현재.파티.length - 1)]
}
export function 빈진화() -> 진화상태 {
let 영게놈 = genome.게놈만들기(0, 0, 0, 0, 0)
{
단계: "none",
부모형태: "",
부모게놈: 영게놈,
부모계통시드: "",
부모진화카운터: 0,
부모세대: 0,
부모고유번호: 0,
선택커서: 0,
잠긴분기: 0,
결과형태: "",
결과게놈: 영게놈,
}
}
export function 빈야생() -> 야생크리처 {
야생크리처 { 종아이디: 0, 이름: "", 레벨: 0, 체력: 0, 스프라이트: 0, 속성: 0 }
}
export type 추가결과 = { 파티: Array<creature.전투원>, 보관함: Array<creature.전투원> }
// 파티가 차 있으면 보관함에 붙이고 둘이 함께 늘지는 않습니다.
export function 파티추가(파티: Array<creature.전투원>, 보관함: Array<creature.전투원>, 잡은것: creature.전투원) -> 추가결과 {
if 파티.length >= 파티최대 {
{ 파티: 파티, 보관함: 복사추가(보관함, 잡은것) }
} else {
{ 파티: 복사추가(파티, 잡은것), 보관함: 보관함 }
}
}
// 계통수의 뿌리 노드입니다. 미진화면 종 이름을 형태이름으로 씁니다.
export function 시작노드(전투원: creature.전투원, 스텝: int) -> evolution.계통노드 {
let 이름 = if 전투원.형태이름 != "" { 전투원.형태이름 } else { species.종찾기(전투원.종아이디).이름 }
evolution.노드생성(evolution.계통고유번호(전투원.계통시드), 0, 이름, genome.게놈요약(전투원.게놈), 전투원.세대, 스텝, 전투원.계통시드)
}
// 같은 고유번호는 다시 붙이지 않아 여러 번 적용해도 같습니다.
export function 노드추가(원본: Array<evolution.계통노드>, 노드: evolution.계통노드) -> Array<evolution.계통노드> {
if 노드.고유번호 in 원본.map(항목 => 항목.고유번호) { 원본.slice(0, 원본.length) } else { 복사추가(원본, 노드) }
}
// 시작종은 "시드#starter" 계통시드를 받아 게놈이 월드시드의 함수가 되고, 계통 노드는 그 뿌리 하나로 시작합니다.
export function 기본상태(시드: string) -> 상태 {
let 시작전투원 = creature.종에서전투원(species.시작종아이디(), 5, genome.시작계통시드(시드))
{
버전: 8,
월드시드: 시드,
스텝: 0,
플레이어: { x: 3, y: 5, 방향: "아래" },
맵아이디: "pond",
장면: "field",
야생: 빈야생(),
스포어볼: 시작스포어볼(),
포획카운터: 0,
처치된것들: [],
초점: 0,
스토리: { 본것: 0, 대기: 0 },
파티: [시작전투원],
보관함: [],
파티커서: 0,
도감커서: 0,
계통노드들: [시작노드(시작전투원, 0)],
진화: 빈진화(),
배틀: battle.빈배틀(),
}
}
export function 처치추가(목록: Array<int>, 아이디: int) -> Array<int> {
if 아이디 in 목록 { 목록.slice(0, 목록.length) } else { 복사추가(목록, 아이디) }
}
// 인물 앞에서 쉬면 파티 전체를 채워 긴 세션이 체력 소모로 무너지지 않게 합니다.
export function 파티회복(현재: 상태) -> 상태 {
현재{ 파티: 현재.파티.map(creature.회복) }
}
// 콜론으로 이어 파이프 없는 한 칸에 담습니다.
function 게놈직렬(대상: genome.게놈) -> string {
"{대상.색소}:{대상.막}:{대상.크기}:{대상.대사}:{대상.촉수}"
}
function 게놈역직렬(토큰: string) -> genome.게놈 {
let 칸들 = 토큰.split(":")
let 값들 = (0..<5).map(i => if 칸들.length > i { 칸들[i].toInt() ?? 0 } else { 0 })
genome.게놈만들기(값들[0], 값들[1], 값들[2], 값들[3], 값들[4])
}
// 계통시드와 형태이름은 파이프가 없는 문자열이고 형태이름 "" 은 미진화입니다.
function 전투원직렬(전투원: creature.전투원) -> string {
"{전투원.종아이디}|{전투원.레벨}|{전투원.경험}|{전투원.현재체력}|{전투원.계통시드}|{전투원.드리프트}|{게놈직렬(전투원.게놈)}|{전투원.세대}|{전투원.진화카운터}|{전투원.형태이름}|{전투원.스탯부스트}"
}
function 노드직렬(노드: evolution.계통노드) -> string {
"{노드.고유번호}|{노드.부모고유번호}|{노드.형태이름}|{노드.게놈요약}|{노드.세대}|{노드.발견스텝}|{노드.시드지문}"
}
// 개수를 앞에 두어 가변 길이 구획이 스스로 끝을 알립니다.
function 카운트접두(조각들: Array<string>) -> string {
if 조각들.length == 0 { "0" } else { "{조각들.length}|{조각들.join("|")}" }
}
function 진화직렬(진: 진화상태) -> string {
"{진.단계}|{진.부모형태}|{게놈직렬(진.부모게놈)}|{진.부모계통시드}|{진.부모진화카운터}|{진.부모세대}|{진.부모고유번호}|{진.선택커서}|{진.잠긴분기}|{진.결과형태}|{게놈직렬(진.결과게놈)}"
}
// 메시지에는 파이프가 없어 맨 끝에 두면 앞의 가변 구획 길이와 상관없이 읽힙니다.
export function 직렬화(현재: 상태) -> string {
let 야생 = 현재.야생
let 배틀값 = 현재.배틀
let 앞부분 = "v{현재.버전}|{현재.월드시드}|{현재.스텝}|{현재.플레이어.x}|{현재.플레이어.y}|{방향번호(현재.플레이어.방향)}|{현재.맵아이디}|{현재.장면}"
let 야생부 = "{야생.종아이디}|{야생.레벨}|{야생.체력}|{야생.스프라이트}|{야생.속성}|{야생.이름}"
let 파티부 = "{현재.스포어볼}|{현재.포획카운터}|{카운트접두(현재.파티.map(전투원직렬))}|{카운트접두(현재.보관함.map(전투원직렬))}|{현재.파티커서}|{현재.도감커서}"
let 진행부 = "{카운트접두(현재.처치된것들.map(아이디 => "{아이디}"))}|{현재.초점}|{현재.스토리.본것}:{현재.스토리.대기}|{카운트접두(현재.계통노드들.map(노드직렬))}|{진화직렬(현재.진화)}"
let 배틀부 = "{배틀값.단계}|{배틀값.메뉴커서}|{배틀값.기술커서}|{배틀값.전투카운터}|{배틀값.적체력}|{배틀값.메시지커서}|{배틀값.다음단계}|{배틀값.결과}|{배틀값.메시지}"
"{앞부분}|{야생부}|{파티부}|{진행부}|{배틀부}"
}
function 버전파싱(토큰: string) -> int {
(토큰.replace("v", "")).toInt() ?? 3
}
// 보폭 11 은 v5 이후, 6 은 v4, 4 는 v3 입니다. 보폭이 11 보다 작으면 미진화로 옮기고 v3 은 계통시드를 마이그레이션시드로 받습니다.
// 세대 0 이면 전투원가두기가 게놈을 계통시드에서 다시 유도하므로 옛 저장의 게놈 인자는 쓰이지 않습니다.
function 전투원파싱(칸들: Array<string>, 시작: int, 보폭: int, 마이그레이션시드: string) -> creature.전투원 {
let 종 = 칸들[시작].toInt() ?? species.시작종아이디()
let 레벨 = 칸들[시작 + 1].toInt() ?? 5
// 경험적용의 경험 + 얻은경험이 넘치지 않게 가둡니다. 나머지는 전투원가두기가 가둡니다.
let 경험 = 카운터가두기(칸들[시작 + 2].toInt() ?? 0)
let 체력 = 칸들[시작 + 3].toInt() ?? 0
let 계통시드 = if 보폭 >= 6 { 칸들[시작 + 4] } else { 마이그레이션시드 }
let 드리프트 = if 보폭 >= 6 { 칸들[시작 + 5].toInt() ?? 0 } else { 0 }
let 세대 = if 보폭 >= 11 { 칸들[시작 + 7].toInt() ?? 0 } else { 0 }
let 진화카운터 = if 보폭 >= 11 { 칸들[시작 + 8].toInt() ?? 0 } else { 0 }
let 형태이름 = if 보폭 >= 11 { 칸들[시작 + 9] } else { "" }
let 스탯부스트 = if 보폭 >= 11 { 칸들[시작 + 10].toInt() ?? 0 } else { 0 }
let 기준게놈 = if 보폭 >= 11 { 게놈역직렬(칸들[시작 + 6]) } else { genome.게놈유도(계통시드) }
creature.전투원가두기(creature.빈전투원(){
종아이디: 종,
레벨: 레벨,
경험: 경험,
현재체력: 체력,
계통시드: 계통시드,
드리프트: 드리프트,
세대: 세대,
진화카운터: 진화카운터,
형태이름: 형태이름,
스탯부스트: 스탯부스트,
게놈: 기준게놈,
})
}
type 배열파싱결과 = { 목록: Array<creature.전투원>, 다음: int }
// 잘린 저장에서 파티가 칸을 다 쓰면 보관함의 카운트 자리가 끝 너머라 빈 목록으로 돌아갑니다.
// 카운트는 실제로 남은 칸이 받쳐 주는 항목 수로 가두고, 파티는 비면 시작종 한 마리를 받습니다.
function 배열파싱(칸들: Array<string>, 시작: int, 최소항목수: int, 보폭: int, 월드시드: string, 마이그레이션접두: string) -> 배열파싱결과 {
if 시작 < 0 || 시작 >= 칸들.length { return { 목록: [], 다음: 시작 } }
let 가용 = ((칸들.length - (시작 + 1)) / 보폭).atLeast(0)
let 카운트 = (칸들[시작].toInt() ?? 0).atLeast(0).atMost(가용)
let 읽은목록 = (0..<카운트).map(i => 전투원파싱(칸들, 시작 + 1 + i * 보폭, 보폭, "{월드시드}#legacy:{마이그레이션접두}:{i}"))
let 목록 = if 읽은목록.length < 최소항목수 { [creature.종에서전투원(species.시작종아이디(), 5, genome.시작계통시드(월드시드))] } else { 읽은목록 }
{ 목록: 목록, 다음: 시작 + 1 + 카운트 * 보폭 }
}
type 노드배열파싱결과 = { 목록: Array<evolution.계통노드>, 다음: int }
// 도감커서가 끼어든 v5 인지 판정합니다. 계통 구획이 진화 블록 시작에서 정확히 끝나면 도감커서가 있는 배치입니다.
function 계통섹션끝일치(칸들: Array<string>, 시작: int, 예상끝: int) -> bool {
if 시작 < 0 || 시작 >= 칸들.length { return false }
let 카운트 = 칸들[시작].toInt() ?? -1
if 카운트 < 0 { return false }
시작 + 1 + 카운트 * 7 == 예상끝
}
// 배치는 노드마다 목록 전체를 훑어 제곱 시간이므로 여기서 128 개로 묶습니다. 실제 계통수는 끝까지 가도 수십 개입니다.
function 노드배열파싱(칸들: Array<string>, 시작: int, 상한배제: int) -> 노드배열파싱결과 {
if 시작 < 0 || 시작 >= 칸들.length { return { 목록: [], 다음: 시작 } }
let 가용 = ((상한배제 - (시작 + 1)) / 7).atLeast(0)
let 카운트 = (칸들[시작].toInt() ?? 0).atLeast(0).atMost(가용).atMost(128)
let 목록 = (0..<카운트).map(i => 노드파싱(칸들, 시작 + 1 + i * 7))
{ 목록: 목록, 다음: 시작 + 1 + 카운트 * 7 }
}
function 노드파싱(칸들: Array<string>, 시작: int) -> evolution.계통노드 {
let 세대 = creature.세대가두기(칸들[시작 + 4].toInt() ?? 0)
evolution.노드생성(칸들[시작].toInt() ?? 0, 칸들[시작 + 1].toInt() ?? 0, 칸들[시작 + 2], 칸들[시작 + 3], 세대, 칸들[시작 + 5].toInt() ?? 0, 칸들[시작 + 6])
}
type 처치파싱결과 = { 목록: Array<int>, 다음: int }
// 카운트를 엔티티 수보다 한참 큰 64 로 가두고 범위 밖 아이디는 버립니다.
function 처치파싱(칸들: Array<string>, 시작: int, 상한: int) -> 처치파싱결과 {
if 시작 < 0 || 시작 >= 칸들.length { return { 목록: [], 다음: 시작 } }
let 카운트 = (칸들[시작].toInt() ?? 0).atLeast(0).atMost(64)
// 끝에서 센 위치에 진화 구획이 없으면 잘린 저장이므로 실제 남은 칸까지 살립니다.
let 진화있음 = 상한 > 시작 && 상한 < 칸들.length - 10 && (칸들[상한] == "none" || 칸들[상한] == "choose" || 칸들[상한] == "morph")
let 경계 = if 진화있음 { 상한 } else { 칸들.length }
let 끝 = (시작 + 1 + 카운트).atMost(경계)
let 아이디들 = ((시작 + 1)..<끝).map(i => 칸들[i].toInt() ?? -1)
{ 목록: 아이디들.filter(아이디 => 아이디 >= 0 && 아이디 <= 100000), 다음: 끝 }
}
// 진화 블록 11 칸이 다 있을 때만 읽습니다.
function 진화블록파싱(칸들: Array<string>, 시작: int) -> 진화상태 {
if 시작 < 0 || 시작 + 10 >= 칸들.length { return 빈진화() }
{
단계: 진화단계파싱(칸들[시작]),
부모형태: 칸들[시작 + 1],
부모게놈: 게놈역직렬(칸들[시작 + 2]),
부모계통시드: 칸들[시작 + 3],
부모진화카운터: creature.진화카운터가두기(칸들[시작 + 4].toInt() ?? 0),
부모세대: creature.세대가두기(칸들[시작 + 5].toInt() ?? 0),
부모고유번호: 칸들[시작 + 6].toInt() ?? 0,
선택커서: 칸들[시작 + 7].toInt() ?? 0,
잠긴분기: 칸들[시작 + 8].toInt() ?? 0,
결과형태: 칸들[시작 + 9],
결과게놈: 게놈역직렬(칸들[시작 + 10]),
}
}
function 칸정수(칸들: Array<string>, 위치: int) -> int {
if 위치 >= 0 && 위치 < 칸들.length { 칸들[위치].toInt() ?? 0 } else { 0 }
}
// 파티커서 뒤의 진행 구획입니다. 진화 11 칸과 배틀 9 칸은 끝에 고정되고 계통 노드는 진화 블록 앞까지만 읽습니다.
type 진행구획 = {
도감커서: int,
처치된것들: Array<int>,
초점: int,
스토리: 스토리상태,
계통노드들: Array<evolution.계통노드>,
진화: 진화상태,
}
function 계통상한(진화시작: int, 계통시작: int, 배틀끝: int) -> int {
if 진화시작 >= 계통시작 { 진화시작 } else { 배틀끝 }
}
// v6 은 도감커서, 처치 목록, 계통이 차례로 오고 v7 은 처치 목록 뒤에 초점, v8 은 그 뒤에 "본것:대기" 를 더합니다.
function 진행구획v6(칸들: Array<string>, 버전: int, 커서위치: int, 진화시작: int) -> 진행구획 {
let 처치결과 = 처치파싱(칸들, 커서위치 + 2, 진화시작)
let 스토리위치 = 처치결과.다음 + 1
let 스토리조각들 = if 버전 >= 8 && 스토리위치 >= 0 && 스토리위치 < 칸들.length { 칸들[스토리위치].split(":") } else { [] }
let 스토리값 = if 스토리조각들.length >= 2 { { 본것: 비트가두기(스토리조각들[0].toInt() ?? 0), 대기: 비트가두기(스토리조각들[1].toInt() ?? 0) } } else { { 본것: 0, 대기: 0 } }
let 계통시작 = if 버전 >= 8 { 처치결과.다음 + 2 } else if 버전 >= 7 { 처치결과.다음 + 1 } else { 처치결과.다음 }
{
도감커서: 칸정수(칸들, 커서위치 + 1).atLeast(0),
처치된것들: 처치결과.목록,
초점: if 버전 >= 7 { 칸정수(칸들, 처치결과.다음) } else { 0 },
스토리: 스토리값,
계통노드들: 노드배열파싱(칸들, 계통시작, 계통상한(진화시작, 계통시작, 칸들.length)).목록,
진화: 진화블록파싱(칸들, 진화시작),
}
}
// 이전 v5 는 도감커서 없이 파티커서 뒤에 바로 계통 카운트가 옵니다.
function 진행구획v5(칸들: Array<string>, 커서위치: int, 진화시작: int) -> 진행구획 {
let 도감있음 = 커서위치 + 1 < 칸들.length && 계통섹션끝일치(칸들, 커서위치 + 2, 진화시작)
let 계통시작 = if 도감있음 { 커서위치 + 2 } else { 커서위치 + 1 }
{
도감커서: if 도감있음 { 칸정수(칸들, 커서위치 + 1).atLeast(0) } else { 0 },
처치된것들: [],
초점: 0,
스토리: { 본것: 0, 대기: 0 },
계통노드들: 노드배열파싱(칸들, 계통시작, 계통상한(진화시작, 계통시작, 칸들.length)).목록,
진화: 진화블록파싱(칸들, 진화시작),
}
}
function 빈진행구획() -> 진행구획 {
{ 도감커서: 0, 처치된것들: [], 초점: 0, 스토리: { 본것: 0, 대기: 0 }, 계통노드들: [], 진화: 빈진화() }
}
type 본문 = {
스포어볼: int,
포획카운터: int,
파티: Array<creature.전투원>,
보관함: Array<creature.전투원>,
파티커서: int,
진행: 진행구획,
}
// v3 부터는 가변 길이 파티와 보관함이 오고, v2 는 [14..17] 의 한 마리 파티, v1 과 v0 은 파티가 없어 시작종을 줍니다.
function 본문파싱(칸들: Array<string>, 버전: int, 시드: string, 배틀있음: bool) -> 본문 {
if 버전 >= 3 && 칸들.length >= 17 {
let 보폭 = if 버전 >= 5 { 11 } else if 버전 >= 4 { 6 } else { 4 }
let 파티결과 = 배열파싱(칸들, 16, 1, 보폭, 시드, "party")
let 보관결과 = 배열파싱(칸들, 파티결과.다음, 0, 보폭, 시드, "box")
// 파티커서는 보관함 바로 뒤를 앞에서부터 셉니다. v5 이후의 계통 구획이 가변 길이라 끝에서 셀 수 없습니다.
let 커서위치 = 보관결과.다음
let 진화시작 = if 배틀있음 { 칸들.length - 9 - 11 } else { 칸들.length - 11 }
let 진행 = if 버전 >= 6 { 진행구획v6(칸들, 버전, 커서위치, 진화시작) } else if 버전 >= 5 { 진행구획v5(칸들, 커서위치, 진화시작) } else { 빈진행구획() }
return {
스포어볼: (칸들[14].toInt() ?? 시작스포어볼()).atLeast(0),
포획카운터: 카운터가두기(칸들[15].toInt() ?? 0),
파티: 파티결과.목록,
보관함: 보관결과.목록,
파티커서: 범위가두기(칸정수(칸들, 커서위치), 0, 파티결과.목록.length - 1),
진행: 진행,
}
}
let 파티 = if 칸들.length >= 18 { [전투원파싱(칸들, 14, 4, "{시드}#legacy:party:0")] } else { [creature.종에서전투원(species.시작종아이디(), 5, genome.시작계통시드(시드))] }
{ 스포어볼: 시작스포어볼(), 포획카운터: 0, 파티: 파티, 보관함: [], 파티커서: 0, 진행: 빈진행구획() }
}
// 적 레벨 0 은 야생 없음이고 99 로 가둬 피해 계산이 넘치지 않게 합니다.
function 야생파싱(칸들: Array<string>) -> 야생크리처 {
if 칸들.length < 14 { return 빈야생() }
야생크리처 { 종아이디: 칸들[8].toInt() ?? 0, 이름: 칸들[13], 레벨: (칸들[9].toInt() ?? 0).atLeast(0).atMost(99), 체력: 카운터가두기(칸들[10].toInt() ?? 0), 스프라이트: 칸들[11].toInt() ?? 0, 속성: 칸들[12].toInt() ?? 0 }
}
// 배틀은 v2 이후 늘 끝 9 칸입니다.
function 배틀파싱(칸들: Array<string>) -> battle.배틀상태 {
if 칸들.length < 23 { return battle.빈배틀() }
let 시작 = 칸들.length - 9
{
단계: battle.단계파싱(칸들[시작]),
메뉴커서: 칸들[시작 + 1].toInt() ?? 0,
기술커서: 칸들[시작 + 2].toInt() ?? 0,
전투카운터: 카운터가두기(칸들[시작 + 3].toInt() ?? 0),
적체력: 카운터가두기(칸들[시작 + 4].toInt() ?? 0),
메시지커서: 칸들[시작 + 5].toInt() ?? 0,
다음단계: battle.다음단계파싱(칸들[시작 + 6]),
결과: battle.결과파싱(칸들[시작 + 7]),
메시지: 칸들[시작 + 8],
}
}
export type 파싱오류 = "empty" | "short"
// 계통 구획이 없던 옛 저장은 파티와 보관함의 원형 노드로 도감의 뿌리를 채웁니다.
// 복원한 상태는 늘 v8 이라 옮겨 온 옛 저장도 v8 머리와 v8 본문으로 다시 저장됩니다.
export function 역직렬화(문자열: string) -> Result<상태, 파싱오류> {
let 다듬은문자열 = 문자열.trim()
if 다듬은문자열 == "" { return Err("empty") }
let 칸들 = 다듬은문자열.split("|")
if 칸들.length < 7 { return Err("short") }
let 버전 = 버전파싱(칸들[0])
let 시드 = 칸들[1]
let 장면값: 장면 = if 칸들.length >= 8 { 장면파싱(칸들[7]) } else { "field" }
let 야생 = 야생파싱(칸들)
let 배틀값 = 배틀파싱(칸들)
let 읽은본문 = 본문파싱(칸들, 버전, 시드, 칸들.length >= 23)
let 진행 = 읽은본문.진행
let 스텝값 = 카운터가두기(칸들[2].toInt() ?? 0)
let 노드들 = if 진행.계통노드들.length == 0 {
[for 묶음 in [읽은본문.파티, 읽은본문.보관함] for 원 in 묶음 => 시작노드(원, 스텝값)]
} else {
진행.계통노드들
}
Ok({
버전: 8,
월드시드: 시드,
스텝: 스텝값,
플레이어: {
x: 좌표가두기(칸들[3].toInt() ?? 3),
y: 좌표가두기(칸들[4].toInt() ?? 5),
방향: 방향읽기(칸들[5].toInt() ?? 0),
},
맵아이디: 칸들[6],
장면: 장면값,
야생: 야생,
스포어볼: 읽은본문.스포어볼,
포획카운터: 읽은본문.포획카운터,
파티: 읽은본문.파티,
보관함: 읽은본문.보관함,
파티커서: 읽은본문.파티커서,
도감커서: if 노드들.length > 0 { 범위가두기(진행.도감커서, 0, 노드들.length - 1) } else { 0 },
처치된것들: 진행.처치된것들,
초점: 범위가두기(진행.초점, 0, 읽은본문.파티.length - 1),
스토리: 진행.스토리,
계통노드들: 노드들,
진화: 진행.진화,
배틀: 배틀값,
})
}
// ===== core/drawlist.tpz =====
// 상태에서 그리기 목록을 만듭니다. 토파즈는 그리지 않고 무엇을 그릴지만 적고, 페이지가 목록을 읽어 160x144 캔버스에 칠합니다.
// 목록은 DL1 머리 뒤에 한 줄에 지시 하나입니다. 공통 PAL, 필드 BG TILES SPR WARP ENT BOX TXT PROMPT DRIFT OBJECTIVE, 압력전 BATTLEBG CSPR ALLYSPR BOX TXT HPBAR DRIFT PRESSURE BEATFX, 파티 PTITLE PROW DRIFT PCURSOR, 진화 EVOLVE EPARENT ECAND EMENU, 도감 DEXSTAT DEXPATH DEXWIN FHEAD FROW DEXVIEW DEXEDGE DEXNODE DEXCURSOR DEXDETAIL DEXSIBLING, 이야기 STORY 입니다.
// 타일은 16 픽셀이라 화면에 10x9 칸이 보이고 카메라는 플레이어를 가운데 두되 맵 경계에서 멈춥니다. 상태의 순수 함수라 같은 상태는 늘 같은 목록입니다.
// 상태를 바꾸지 않고 픽셀을 칠하지 않습니다. 진화 모핑과 깜빡임 같은 움직임은 페이지가 그립니다.
// Draw-list builder: describes each scene as one directive per line for the page to paint on a 160x144 canvas.
import data.maps { 맵너비, 맵높이, 맵타일들, 타일에서, 워프목록, 워프 }
import data.palettes { 연못팔레트 }
import data.species
import data.entities
import data.types { 속성이름 }
import core.creature
import core.encounter
import core.genome
import core.evolution
import core.lineagedex
import core.auto { 자동목표 }
import core.story { 최하위비트, 비트내레이션, 켜진비트인가, 비트_첫포획, 비트_첫심층, 비트_정복 }
import core.clash { 적게놈유도 }
import core.state
import core.util { 범위가두기 }
let 타일크기 = 16
let 가시너비 = 10
let 가시높이 = 9
let 보스아이디 = 14
// 지시의 켜짐 칸은 1 과 0 입니다.
function 표시값(켜짐: bool) -> int {
if 켜짐 { 1 } else { 0 }
}
// 페이지가 드리프트 막대와 표현형으로 블롭의 외형을 조금 흔듭니다. 주인은 party:<i>, ally, field 입니다.
function 드리프트줄(주인: string, 전투원: creature.전투원) -> string {
let 표현 = genome.표현형(전투원.게놈, 전투원.계통시드, 전투원.드리프트)
"DRIFT|{주인}|{전투원.드리프트}|{genome.드리프트퍼센트(전투원.드리프트)}|{표시값(genome.진화준비(전투원.드리프트))}|{genome.게놈요약(전투원.게놈)}|{genome.게놈요약(표현)}"
}
function 카메라x(플레이어x: int) -> int {
범위가두기(플레이어x - 가시너비 / 2, 0, 맵너비 - 가시너비)
}
function 카메라y(플레이어y: int) -> int {
범위가두기(플레이어y - 가시높이 / 2, 0, 맵높이 - 가시높이)
}
function 화면안인가(x: int, y: int, 왼쪽: int, 위: int) -> bool {
x >= 왼쪽 && x < 왼쪽 + 가시너비 && y >= 위 && y < 위 + 가시높이
}
// 맵 밖은 타일에서가 나무 벽으로 메웁니다.
function 타일윈도(타일들: Array<int>, 왼쪽: int, 위: int) -> string {
[for 행 in 0..<가시높이 for 열 in 0..<가시너비 => "{타일에서(타일들, 왼쪽 + 열, 위 + 행)}"].join(",")
}
// 인물의 한마디는 가장 멀리 간 이야기 이정표를 따라 바뀌고, 이정표 전에는 배치된 대사를 씁니다.
function 인물대사(현재: state.상태, 앞: entities.엔티티) -> string {
if 켜진비트인가(현재.스토리.본것, 비트_정복) {
"숲이 다시 숨을 쉽니다. 당신이 천천히 지켜낸 결과입니다. 푹 쉬어 가십시오."
} else if 켜진비트인가(현재.스토리.본것, 비트_첫심층) {
"깊은 곳을 보셨군요. 그곳은 적의 땅이 아니라, 멈춰 버린 생명입니다. 회복하고 다시 내려가십시오."
} else if 켜진비트인가(현재.스토리.본것, 비트_첫포획) {
"한 가닥의 생명을 돌보기 시작하셨군요. 서두르지 마십시오. A로 회복합니다. 깊은 곳일수록 더 강한 미생물이 기다립니다."
} else {
match 앞.종류 {
case 인물(대사) => 대사
case 없음 | 야생(_, _) => ""
}
}
}
function 엔티티스프라이트(대상: entities.엔티티) -> int {
match 대상.종류 {
case 야생(종아이디, _) => species.종찾기(종아이디).스프라이트
case 없음 | 인물(_) => 0
}
}
// 처치한 야생은 맵에서 사라집니다. 인물을 마주 보면 대화 상자가, 야생을 마주 보면 A 프롬프트가 그 칸 위에 뜹니다.
function 필드줄들(현재: state.상태, 팔레트: string) -> Array<string> {
let 플레이어값 = 현재.플레이어
let 왼쪽 = 카메라x(플레이어값.x)
let 위 = 카메라y(플레이어값.y)
let 머리줄들 = [
"DL1",
"PAL|0|{팔레트}",
"BG|{현재.맵아이디}|{왼쪽}|{위}",
"TILES|{가시너비}|{가시높이}|{타일윈도(맵타일들(현재.맵아이디), 왼쪽, 위)}",
"SPR|0|{state.방향번호(플레이어값.방향)}|{(플레이어값.x - 왼쪽) * 타일크기}|{(플레이어값.y - 위) * 타일크기}|0|0|10",
]
let 워프줄들 = [
for 대상 in 워프목록(현재.맵아이디) if 화면안인가(대상.x, 대상.y, 왼쪽, 위) => "WARP|{(대상.x - 왼쪽) * 타일크기}|{(대상.y - 위) * 타일크기}"
]
let 엔티티줄들 = [
for 대상 in entities.엔티티목록(현재.맵아이디) if 화면안인가(대상.x, 대상.y, 왼쪽, 위) && !entities.처치된것인가(현재.처치된것들, 대상.아이디) => "ENT|{entities.종류코드(대상)}|{엔티티스프라이트(대상)}|{(대상.x - 왼쪽) * 타일크기}|{(대상.y - 위) * 타일크기}"
]
let 앞x = state.마주x(플레이어값)
let 앞y = state.마주y(플레이어값)
let 앞 = entities.활성엔티티에서(현재.맵아이디, 앞x, 앞y, 현재.처치된것들)
let 대화줄들 = if entities.인물인가(앞) { ["BOX|6|104|148|34|0", "TXT|12|112|136|{인물대사(현재, 앞)}"] } else { [] }
let 프롬프트줄들 = if entities.야생인가(앞) { ["PROMPT|{(앞x - 왼쪽) * 타일크기}|{(앞y - 위) * 타일크기}"] } else { [] }
let 드리프트줄들 = if 현재.파티.length > 0 { [드리프트줄("field", state.초점전투원(현재))] } else { [] }
[for 묶음 in [머리줄들, 워프줄들, 엔티티줄들, 대화줄들, 프롬프트줄들, 드리프트줄들, ["OBJECTIVE|{자동목표(현재)}"]] for 줄 in 묶음 => 줄]
}
// 적은 오른쪽 위, 내 세포는 왼쪽 아래에 그리고 체력 막대를 안정도 막대로 씁니다. 야생에는 게놈이 없어 적은 종 색 블롭입니다.
// 이번 비트의 두 사건은 " · " 로 나뉘어 아래 상자에 두 줄로 들어갑니다.
function 배틀드로우(현재: state.상태, 팔레트: string) -> string {
let 야생 = 현재.야생
let 파티 = state.초점전투원(현재)
let 배틀값 = 현재.배틀
let 적최대 = creature.최대체력(species.종찾기(야생.종아이디), 야생.레벨)
let 내형질 = evolution.지배트레이트(genome.표현형(파티.게놈, 파티.계통시드, 파티.드리프트))
let 적형질 = evolution.지배트레이트(적게놈유도(야생.종아이디, 야생.레벨, 현재.월드시드))
let 사건들 = 배틀값.메시지.split(" · ")
let 줄들 = [
"DL1",
"PAL|0|{팔레트}",
"BATTLEBG|0",
"CSPR|{야생.스프라이트}|104|22|0|5",
"ALLYSPR|{파티.스프라이트}|18|72",
"BOX|4|4|92|30|1",
"TXT|8|8|84|{야생.이름}",
"TXT|8|17|84|Lv {야생.레벨} 안정도",
"HPBAR|8|27|80|{배틀값.적체력}|{적최대}",
"BOX|64|62|92|30|1",
"TXT|68|66|84|{species.종찾기(파티.종아이디).이름}",
"TXT|68|75|84|Lv {파티.레벨} 안정도",
"HPBAR|68|85|68|{파티.현재체력}|{파티.최대체력}",
드리프트줄("ally", 파티),
"PRESSURE|{배틀값.메뉴커서}",
"BEATFX|{내형질}|{적형질}",
"BOX|0|104|160|40|0",
]
let 본문줄들 = (0..<사건들.length).map(i => "TXT|8|{114 + i * 12}|148|{사건들[i]}")
[for 묶음 in [줄들, 본문줄들] for 줄 in 묶음 => 줄].join("\n")
}
function 파티행(현재: state.상태, i: int) -> string {
let 원 = 현재.파티[i]
let 행줄 = "PROW|{i}|{표시값(i == 현재.파티커서)}|{원.스프라이트}|{species.종찾기(원.종아이디).이름}|{원.레벨}|{원.현재체력}|{원.최대체력}|{속성이름(원.속성)}|{표시값(i == 현재.초점)}"
"{행줄}\n{드리프트줄("party:{i}", 원)}"
}
function 파티드로우(현재: state.상태, 팔레트: string) -> string {
let 머리 = "DL1\nPAL|0|{팔레트}\nBOX|0|0|160|144|0\nPTITLE|파티 ({현재.파티.length}/{state.파티최대}) 보관함 {현재.보관함.length}"
let 행들 = (0..<현재.파티.length).map(i => "\n{파티행(현재, i)}").join("")
"{머리}{행들}\nPCURSOR|{현재.파티커서}\nTXT|8|132|144|A 키우기(초점) B/START 닫기"
}
// 고르기 단계는 분기진화와 같은 함수로 후보를 다시 유도하므로 메뉴에서 본 후보가 곧 고정될 후보입니다. 이름은 보여 주되 정확한 외형은 모핑에서 드러납니다.
// 모핑 단계는 EVOLVE 한 줄과 확정 문구를 내고 느린 모핑 장면은 페이지가 재생합니다.
function 진화드로우(현재: state.상태, 팔레트: string) -> string {
let 진 = 현재.진화
let 활성 = state.초점전투원(현재)
let 머리 = "DL1\nPAL|0|{팔레트}\nBATTLEBG|0"
match 진.단계 {
case "morph" => {
let 줄들 = [
머리,
"EVOLVE|{진.부모형태}|{진.결과형태}|{genome.게놈요약(진.부모게놈)}|{genome.게놈요약(진.결과게놈)}|{진.잠긴분기}|{활성.스프라이트}",
"CSPR|{활성.스프라이트}|72|48|0|5|{genome.게놈요약(활성.게놈)}",
"BOX|0|104|160|40|0",
"TXT|8|112|144|{진.결과형태}(으)로 진화했습니다",
"TXT|8|124|144|세대 {활성.세대} 게놈 {genome.게놈요약(활성.게놈)}",
]
줄들.join("\n")
}
case "choose" | "none" => {
let 후보들 = evolution.후보들유도(진.부모게놈, evolution.계통고유번호(진.부모계통시드), 진.부모계통시드, 진.부모진화카운터)
let 머리줄들 = [
머리,
"BOX|0|0|160|30|0",
"TXT|8|6|150|진화의 갈림길",
"TXT|8|18|150|{진.부모형태} 게놈 {genome.게놈요약(진.부모게놈)}",
"EPARENT|{genome.게놈요약(진.부모게놈)}",
]
let 후보줄들 = (0..<후보들.length).map(i => "ECAND|{후보들[i].분기}|{표시값(i == 진.선택커서)}|{활성.스프라이트}|{후보들[i].형태이름}|{genome.게놈요약(후보들[i].게놈)}|{후보들[i].스탯부스트}|{evolution.후보힌트(후보들[i])}")
let 끝줄들 = ["EMENU|{진.선택커서}|{후보들.length}", "TXT|8|132|150|←→ 선택 A 진화 확정"]
[for 묶음 in [머리줄들, 후보줄들, 끝줄들] for 줄 in 묶음 => 줄].join("\n")
}
}
}
function 분기문자(분기: int) -> string {
match 분기 {
case 0 => "A"
case 1 => "B"
case 2 => "C"
case _ => "?"
}
}
// 같은 고유번호가 여럿이면 옛 동작대로 마지막 노드를 씁니다.
function 부모노드(노드들: Array<evolution.계통노드>, 자식: evolution.계통노드) -> Option<evolution.계통노드> {
let 일치들 = 노드들.filter(후보 => 후보.고유번호 == 자식.부모고유번호)
if 일치들.length == 0 { None } else { Some(일치들[일치들.length - 1]) }
}
// 가장 깊은 노드에서 부모를 따라 올라가며 진화마다 고른 분기를 모아 뿌리부터 "A-C-B" 로 잇습니다. 같은 시드와 선택이면 같은 코드라 비교하고 공유할 수 있습니다.
// 조작된 목록의 순환도 백 걸음에서 멈춥니다.
function 계통경로코드(노드들: Array<evolution.계통노드>) -> string {
if 노드들.length == 0 { return "" }
let mut 지금노드 = 노드들.reduce(노드들[0], (깊은, 노드) => if 노드.세대 > 깊은.세대 { 노드 } else { 깊은 })
let mut 글자들: Array<string> = []
while 지금노드.세대 > 0 && 글자들.length < 100 {
match 부모노드(노드들, 지금노드) {
case Some(부모) => {
글자들.push(분기문자(evolution.노드분기(genome.게놈요약파싱(부모.게놈요약), 부모.시드지문, 부모.세대, 지금노드.게놈요약)))
지금노드 = 부모
}
case None => { break }
}
}
[for i in (글자들.length - 1)..0 by -1 => 글자들[i]].join("-")
}
// 뿌리에서 첫 자식을 따라 내려가며 분기 글자를 모읍니다. 진화하지 않았으면 "." 이고 분기를 찾지 못하면 추측하지 않고 "?" 입니다.
function 뿌리경로(노드들: Array<evolution.계통노드>, 뿌리: evolution.계통노드) -> string {
let mut 지금노드 = 뿌리
let mut 글자들: Array<string> = []
while 글자들.length < 100 {
let 자식들 = 노드들.filter(후보 => 후보.부모고유번호 == 지금노드.고유번호 && 후보.고유번호 != 지금노드.고유번호)
if 자식들.length == 0 { break }
let 자식 = 자식들[0]
let 분기 = evolution.노드분기(genome.게놈요약파싱(지금노드.게놈요약), 지금노드.시드지문, 지금노드.세대, 자식.게놈요약)
글자들.push(if 분기 >= 0 { 분기문자(분기) } else { "?" })
지금노드 = 자식
}
if 글자들.length == 0 { "." } else { 글자들.join("-") }
}
// 숲 공유 코드는 발견 순서의 뿌리마다 한 줄이라 같은 시드와 선택이면 같은 코드입니다.
function 숲줄들(현재: state.상태) -> Array<string> {
let 뿌리줄들 = [
for 노드 in 현재.계통노드들 if 노드.세대 == 0 => "FROW|{genome.출처키(노드.시드지문)}|{뿌리경로(현재.계통노드들, 노드)}"
]
[for 묶음 in [["FHEAD|F1|{현재.월드시드}|{표시값(entities.처치된것인가(현재.처치된것들, 보스아이디))}"], 뿌리줄들] for 줄 in 묶음 => 줄]
}
// 고른 노드가 진화한 노드면 부모에서 후보를 다시 유도해 가지 않은 길의 힌트를 붙입니다.
function 형제줄들(노드들: Array<evolution.계통노드>, 선택노드: evolution.계통노드) -> Array<string> {
if 선택노드.세대 <= 0 { return [] }
match 부모노드(노드들, 선택노드) {
case Some(부모) => {
let 힌트들 = evolution.형제힌트들(genome.게놈요약파싱(부모.게놈요약), 부모.시드지문, 부모.세대, 선택노드.게놈요약)
if 힌트들 == "" { [] } else { ["DEXSIBLING|{힌트들}"] }
}
case None => []
}
}
// 선은 노드 아래에 깔리도록 노드보다 먼저 냅니다. 상세의 시드 지문이 이 시드가 이 나무를 키웠다는 공유의 열쇠입니다.
function 도감드로우(현재: state.상태, 팔레트: string) -> string {
let 노드들 = 현재.계통노드들
let 레이아웃 = lineagedex.레이아웃계산(노드들)
let 배치들 = 레이아웃.노드들
let 커서 = if 배치들.length > 0 { 범위가두기(현재.도감커서, 0, 배치들.length - 1) } else { 0 }
let 선택인덱스 = if 배치들.length > 0 { 배치들[커서].인덱스 } else { -1 }
let 최고세대 = 노드들.reduce(0, (최고, 노드) => if 노드.세대 > 최고 { 노드.세대 } else { 최고 })
let 경로코드 = 계통경로코드(노드들)
let 머리줄들 = ["DL1", "PAL|0|{팔레트}", "BOX|0|0|160|18|0", "TXT|6|5|90|계통도감", "DEXSTAT|{최고세대}|{노드들.length}|{현재.월드시드}"]
let 경로줄들 = if 경로코드 != "" { ["DEXPATH|{경로코드}|{현재.월드시드}"] } else { [] }
let 승리줄들 = if entities.처치된것인가(현재.처치된것들, 보스아이디) { ["DEXWIN|1"] } else { [] }
let 선줄들 = [
for 노드 in 배치들 if 노드.부모인덱스 >= 0 && 노드.부모인덱스 < 배치들.length => "DEXEDGE|{배치들[노드.부모인덱스].x}|{배치들[노드.부모인덱스].y}|{노드.x}|{노드.y}"
]
let 노드줄들 = [
for 노드 in 배치들 => "DEXNODE|{노드.인덱스}|{노드.부모인덱스}|{노드.x}|{노드.y}|{노드.게놈요약}|{노드.형태이름}|{노드.세대}|{표시값(노드.인덱스 == 선택인덱스)}"
]
let 상세줄 = if 배치들.length > 0 {
let 선택 = 배치들[커서]
"DEXDETAIL|{선택.형태이름}|{선택.세대}|{선택.게놈요약}|{선택.시드지문}|{genome.출처(선택.시드지문)}"
} else {
"TXT|8|72|144|아직 계통이 없습니다"
}
let 형제들 = if 배치들.length > 0 { 형제줄들(노드들, 노드들[선택인덱스]) } else { [] }
let 묶음들 = [
머리줄들,
경로줄들,
승리줄들,
숲줄들(현재),
["DEXVIEW|{레이아웃.너비}|{레이아웃.높이}|{배치들.length}"],
선줄들,
노드줄들,
["DEXCURSOR|{커서}", 상세줄],
형제들,
["TXT|6|136|150|←→↑↓ 선택 B/SEL 닫기"],
]
[for 묶음 in 묶음들 for 줄 in 묶음 => 줄].join("\n")
}
// 내레이션의 줄바꿈은 | 로 바꿔 지시 한 줄로 유지합니다. 페이지는 목록을 줄 단위로 읽습니다.
function 스토리드로우(현재: state.상태, 팔레트: string) -> string {
let 비트 = 최하위비트(현재.스토리.대기)
"{필드줄들(현재, 팔레트).join("\n")}\nSTORY|{비트}|{비트내레이션(비트).replace("\n", "|")}"
}
export function 드로우리스트(현재: state.상태) -> string {
let 팔레트 = 연못팔레트()
match 현재.장면 {
case "battle" => 배틀드로우(현재, 팔레트)
case "party" => 파티드로우(현재, 팔레트)
case "evolve" => 진화드로우(현재, 팔레트)
case "dex" => 도감드로우(현재, 팔레트)
case "story" => 스토리드로우(현재, 팔레트)
case "field" => 필드줄들(현재, 팔레트).join("\n")
}
}
// ===== core/util.tpz =====
// 여러 core 모듈이 쓰는 정수 범위 가두기와 배열 사본 도우미를 둡니다.
// 범위가두기는 정수를 [하한, 상한] 으로 가두고, 복사추가는 원본을 그대로 둔 새 배열에 원소 하나를 붙여 돌려줍니다.
// 순수 함수라 같은 인자는 늘 같은 결과입니다.
// 인자 배열을 바꾸지 않습니다. 한쪽 경계만 가둘 때는 표준 atLeast, atMost 를 씁니다.
// Shared core utilities: integer range clamping and copy-then-append.
// 하한을 먼저 보므로 하한이 상한보다 크면 하한보다 작은 값은 하한, 나머지는 상한이 됩니다.
export function 범위가두기(값: int, 하한: int, 상한: int) -> int {
if 값 < 하한 { 하한 } else { 값.atMost(상한) }
}
// 배열은 참조로 공유되므로 사본에 붙여 호출자의 배열을 건드리지 않습니다.
export function 복사추가<T>(원본: Array<T>, 추가: T) -> Array<T> {
let mut 결과 = 원본.slice(0, 원본.length)
결과.push(추가)
결과
}
// ===== core/rng.tpz =====
// 게임의 모든 무작위를 정하는 결정론 난수입니다. 시드 문자열, 도메인 문자열, 엔티티 번호, 카운터를 섞어 [0, 2^31) 정수를 만듭니다.
// 난수범위는 그 값을 닫힌 구간 [하한, 상한] 으로 줄입니다.
// 같은 네 입력은 늘 같은 값이고, 도메인이 다르면 스트림이 갈려 배틀 굴림이 돌연변이 굴림을 흔들지 않습니다. 전역 상태가 없어 재생과 시드 공유가 그대로 됩니다.
// 비트 연산과 실수를 쓰지 않고 다른 모듈을 가져오지 않습니다.
// Counter-based deterministic RNG over seed, domain, entity and counter, using only integer arithmetic.
// 정수 산술은 넘치면 실행 오류이므로 모든 상태를 2^31 안에 둡니다. 가장 큰 곱 1013904223 * (2^31 - 1) 이 약 2.18e18 로 부호 있는 64비트 한계 9.22e18 아래입니다.
let 모듈러스 = 2147483648
// 증분이 홀수라 선형 합동 생성기의 주기가 2^31 전체가 됩니다.
let 곱수 = 1664525
let 증분 = 1013904223
let 섞기곱수 = 1013904223
// 공용 도우미 시작 (다항31해시)
// 여러 도구가 같은 원본을 씁니다. 여기서 고치지 않고 원본에서 고친 뒤 다시 생성합니다.
// FNV 오프셋 기저에서 시작하는 31 배 다항 해시입니다. 글자마다 2^31 로 줄여 중간값이 2^31 * 31 을 넘지 않습니다.
function 다항31해시(글: string) -> int {
글.scalars().reduce(2166136261 % 2147483648, (해시, 글자) => (해시 * 31 + (글자.codePointAt(0) ?? 0)) % 2147483648)
}
// 공용 도우미 끝
function 선형합동(x: int) -> int {
(곱수 * x + 증분) % 모듈러스
}
// 나머지 연산은 음수에 음수를 돌려주므로 음수 엔티티와 카운터를 [0, 모듈러스) 로 옮깁니다.
function 정규화(값: int) -> int {
((값 % 모듈러스) + 모듈러스) % 모듈러스
}
// 더한 뒤 곱하고 한 걸음 더 가서 이웃한 카운터의 결과가 선형으로 늘어서지 않게 합니다.
function 섞기(상태: int, 값: int) -> int {
선형합동((섞기곱수 * ((상태 + 정규화(값)) % 모듈러스)) % 모듈러스)
}
// 카운터 뒤에 도메인을 한 번 더 섞고, 마지막에 상위 15비트와 하위 16비트를 다시 섞어 작은 구간으로 줄여도 고르게 퍼지게 합니다.
export function 난수(도메인: string, 엔티티: int, 카운터: int, 시드: string) -> int {
let 도메인값 = 다항31해시(도메인)
let 상태 = 다항31해시(시드)
|> 섞기(_, 도메인값)
|> 섞기(_, 엔티티)
|> 섞기(_, 카운터)
|> 섞기(_, 도메인값)
|> 선형합동
let 상위 = 상태 / 65536
let 하위 = 상태 % 65536
선형합동((섞기곱수 * ((상위 + 하위 * 3) % 모듈러스)) % 모듈러스)
}
// 선형 합동의 하위 비트는 규칙적이라 2^31 / 100 에 가까운 21474836 으로 나눠 상위 비트에서 구간을 고릅니다.
export function 난수범위(도메인: string, 엔티티: int, 카운터: int, 시드: string, 하한: int, 상한: int) -> int {
let 폭 = 상한 - 하한 + 1
하한 + ((난수(도메인, 엔티티, 카운터, 시드) / 21474836) % 폭)
}
// ===== core/encounter.tpz =====
// 맞붙는 야생 개체의 레코드를 둡니다. 다른 모듈은 레코드 이름을 골라 가져와 직접 만듭니다.
// 야생 개체는 종 아이디, 이름, 레벨, 체력, 스프라이트, 속성 여섯 값이고 저장의 야생 여섯 칸과 같습니다.
// 받은 값을 그대로 담으므로 같은 인자는 늘 같은 개체입니다.
// 무엇과 맞붙을지 고르거나 굴림을 하지 않습니다. 진입점이 마주 본 엔티티에서 정합니다.
// Wild creature record.
export record 야생크리처 {
종아이디: int,
이름: string,
레벨: int,
체력: int,
스프라이트: int,
속성: int,
}
// ===== core/creature.tpz =====
// 전투원 레코드와 스탯 유도, 레벨과 경험 곡선을 둡니다. 파티와 야생이 같은 타입을 씁니다.
// 스탯은 정수 공식으로 유도합니다. 최대체력 = 기본체력 + 레벨 * 2 + 부스트 * 2, 공격 방어 속도 = 기본치 + 레벨 + 부스트. 다음 레벨까지 레벨 * 8, 처치 경험은 적 레벨 * 14 입니다.
// 실수를 쓰지 않는 순수 함수라 같은 종, 레벨, 저장값은 늘 같은 전투원입니다.
// 저장 문자열을 읽거나 쓰지 않습니다. 복원할 때 모든 저장값을 가둬 손상된 상태가 정수 넘침을 일으키지 않게 합니다.
// Combatant record, integer stat derivation, level and experience curve, and clamped restore.
import data.species
import core.genome
import core.util { 범위가두기 }
// 저장하는 값은 레벨, 경험, 현재체력, 계통시드, 드리프트와 진화 상태이고 나머지 스탯은 그때마다 유도합니다.
// 진화하면 게놈이 더는 계통시드의 함수가 아니므로 돌연변이 게놈을 저장합니다. 형태이름 "" 은 미진화입니다.
export type 전투원 = {
종아이디: int,
레벨: int,
경험: int,
현재체력: int,
최대체력: int,
공격: int,
방어: int,
속도: int,
속성: int,
스프라이트: int,
기술1: int,
기술2: int,
기술3: int,
기술4: int,
계통시드: string,
드리프트: int,
게놈: genome.게놈,
세대: int,
진화카운터: int,
형태이름: string,
스탯부스트: int,
}
export function 최대체력(종정보: species.종, 레벨: int) -> int {
종정보.기본체력 + 레벨 * 2
}
export function 다음레벨필요경험(레벨: int) -> int {
레벨 * 8
}
export function 획득경험(적레벨: int) -> int {
적레벨 * 14
}
// 조작된 저장의 거대한 레벨이 피해 계산의 정수를 넘기지 않게 가둡니다.
export function 레벨가두기(레벨: int) -> int {
범위가두기(레벨, 1, 99)
}
// 시작종과 갓 잡은 야생이 쓰는 생성자입니다. 체력은 가득, 드리프트 0, 미진화로 태어납니다.
export function 종에서전투원(아이디: int, 레벨: int, 계통시드: string) -> 전투원 {
let 종정보 = species.종찾기(아이디)
let 가둔레벨 = 레벨가두기(레벨)
let 체력상한 = 최대체력(종정보, 가둔레벨)
{
종아이디: 종정보.아이디,
레벨: 가둔레벨,
경험: 0,
현재체력: 체력상한,
최대체력: 체력상한,
공격: 종정보.기본공격 + 가둔레벨,
방어: 종정보.기본방어 + 가둔레벨,
속도: 종정보.기본속도 + 가둔레벨,
속성: 종정보.속성,
스프라이트: 종정보.스프라이트,
기술1: 종정보.기술1,
기술2: 종정보.기술2,
기술3: 종정보.기술3,
기술4: 종정보.기술4,
계통시드: 계통시드,
드리프트: 0,
게놈: genome.게놈유도(계통시드),
세대: 0,
진화카운터: 0,
형태이름: "",
스탯부스트: 0,
}
}
export function 세대가두기(세대: int) -> int {
범위가두기(세대, 0, 99)
}
export function 진화카운터가두기(카운터: int) -> int {
범위가두기(카운터, 0, 1000000)
}
// 진화 한 번에 2~5 씩 올라 99 세대면 495 까지 갈 수 있지만 400 으로 가둬 공격이 500 근처를 넘지 않게 합니다.
export function 스탯부스트가두기(부스트: int) -> int {
범위가두기(부스트, 0, 400)
}
// 저장값에서 되살리거나 체력과 드리프트를 바꾼 전투원이 모두 거치는 가두기입니다. 종, 레벨, 부스트에서 스탯을 다시 유도하므로 원의 스탯 칸은 읽지 않습니다.
// 미진화면 게놈을 계통시드에서 다시 유도하고 진화했으면 들고 있는 게놈을 씁니다.
export function 전투원가두기(원: 전투원) -> 전투원 {
let 종정보 = species.종찾기(원.종아이디)
let 가둔레벨 = 레벨가두기(원.레벨)
let 가둔세대 = 세대가두기(원.세대)
let 부스트 = 스탯부스트가두기(원.스탯부스트)
let 체력상한 = 최대체력(종정보, 가둔레벨) + 부스트 * 2
let 기준게놈 = if 가둔세대 <= 0 { genome.게놈유도(원.계통시드) } else { 원.게놈 }
{
종아이디: 종정보.아이디,
레벨: 가둔레벨,
경험: 원.경험,
현재체력: 범위가두기(원.현재체력, 0, 체력상한),
최대체력: 체력상한,
공격: 종정보.기본공격 + 가둔레벨 + 부스트,
방어: 종정보.기본방어 + 가둔레벨 + 부스트,
속도: 종정보.기본속도 + 가둔레벨 + 부스트,
속성: 종정보.속성,
스프라이트: 종정보.스프라이트,
기술1: 종정보.기술1,
기술2: 종정보.기술2,
기술3: 종정보.기술3,
기술4: 종정보.기술4,
계통시드: 원.계통시드,
드리프트: genome.드리프트가두기(원.드리프트),
게놈: 기준게놈,
세대: 가둔세대,
진화카운터: 진화카운터가두기(원.진화카운터),
형태이름: 원.형태이름,
스탯부스트: 부스트,
}
}
// 휴식은 체력만 채우고 레벨, 경험, 드리프트, 진화 형태는 그대로 둡니다.
export function 회복(원: 전투원) -> 전투원 {
전투원가두기(원{ 현재체력: 원.최대체력 })
}
export function 체력설정(원: 전투원, 새체력: int) -> 전투원 {
전투원가두기(원{ 현재체력: 새체력 })
}
// 패배에서 배운 드리프트를 얹고 체력을 채웁니다.
export function 드리프트설정(원: 전투원, 새드리프트: int) -> 전투원 {
전투원가두기(원{ 현재체력: 원.최대체력, 드리프트: genome.드리프트가두기(새드리프트) })
}
// 종아이디 0 은 빈 파티 자리입니다.
export function 빈전투원() -> 전투원 {
{
종아이디: 0,
레벨: 0,
경험: 0,
현재체력: 0,
최대체력: 0,
공격: 0,
방어: 0,
속도: 0,
속성: 0,
스프라이트: 0,
기술1: 0,
기술2: 0,
기술3: 0,
기술4: 0,
계통시드: "",
드리프트: 0,
게놈: genome.게놈유도(""),
세대: 0,
진화카운터: 0,
형태이름: "",
스탯부스트: 0,
}
}
// ===== core/battle.tpz =====
// 전투 하위 상태와 승리 뒤의 경험, 레벨업, 드리프트를 둡니다. 비트 계산은 삼투 압력전 모듈이 합니다.
// 하위 상태는 단계, 메뉴커서, 기술커서, 전투카운터, 적체력, ";;" 로 이은 메시지와 그 커서, 다음단계, 결과이고 저장 문자열 안에 들어갑니다.
// 실수와 난수를 쓰지 않는 순수 함수라 같은 전투원과 경험은 늘 같은 성장입니다.
// 저장 토큰은 닫힌 태그로 좁히고 모르는 값은 메뉴나 진행 중으로 되돌립니다. 레벨은 99, 한 판의 레벨업은 20 에서 멈춰 피해 계산이 넘치지 않게 합니다.
// Battle sub-state tags, the empty battle, message lines and post-win experience, level-up and drift.
import core.creature
import core.genome { 드리프트증가, 드리프트가두기 }
import data.species
// move 와 message 는 옛 메뉴 전투의 단계이며 옛 저장을 읽으려고 남깁니다.
export type 배틀단계 = "menu" | "move" | "message" | "clash" | "result"
export type 배틀다음단계 = "menu" | "field" | "catch" | "evolve" | "clash"
export type 배틀결과 = "" | "win" | "lose" | "fled" | "caught"
export function 단계파싱(토큰: string) -> 배틀단계 {
match 토큰 {
case "move" => "move"
case "message" => "message"
case "clash" => "clash"
case "result" => "result"
case _ => "menu"
}
}
export function 다음단계파싱(토큰: string) -> 배틀다음단계 {
match 토큰 {
case "field" => "field"
case "catch" => "catch"
case "evolve" => "evolve"
case "clash" => "clash"
case _ => "menu"
}
}
export function 결과파싱(토큰: string) -> 배틀결과 {
match 토큰 {
case "win" => "win"
case "lose" => "lose"
case "fled" => "fled"
case "caught" => "caught"
case _ => ""
}
}
// 압력전에서 메뉴커서는 압력이고 전투카운터는 비트 번호입니다.
export type 배틀상태 = {
단계: 배틀단계,
메뉴커서: int,
기술커서: int,
전투카운터: int,
적체력: int,
메시지: string,
메시지커서: int,
다음단계: 배틀다음단계,
결과: 배틀결과,
}
export type 턴결과 = { 배틀: 배틀상태, 플레이어: creature.전투원 }
export type 성장결과 = { 전투원: creature.전투원, 오른레벨: int }
export function 빈배틀() -> 배틀상태 {
{
단계: "menu",
메뉴커서: 0,
기술커서: 0,
전투카운터: 0,
적체력: 0,
메시지: "",
메시지커서: 0,
다음단계: "menu",
결과: "",
}
}
// 커서가 범위 밖이면 빈 줄입니다.
export function 메시지줄(메시지: string, 커서: int) -> string {
if 메시지 == "" { return "" }
let 줄들 = 메시지.split(";;")
if 커서 < 0 || 커서 >= 줄들.length { "" } else { 줄들[커서] }
}
// 레벨이 오를 때마다 늘어난 최대체력만큼 현재체력도 채웁니다. 진화 부스트는 상수라 레벨마다의 체력 증가에 끼지 않습니다.
// 드리프트는 승리 전 값에 이번 승리의 증가를 더합니다. 데모 플래그는 셸에서 여기까지 전해집니다.
export function 경험적용(대상: creature.전투원, 얻은경험: int, 데모: bool) -> 성장결과 {
let 종정보 = species.종찾기(대상.종아이디)
let mut 레벨 = 대상.레벨
let mut 경험 = 대상.경험 + 얻은경험
let mut 체력 = 대상.현재체력
let mut 오른 = 0
while 오른 < 20 && 레벨 < 99 && 경험 >= creature.다음레벨필요경험(레벨) {
경험 -= creature.다음레벨필요경험(레벨)
체력 += creature.최대체력(종정보, 레벨 + 1) - creature.최대체력(종정보, 레벨)
레벨 += 1
오른 += 1
}
let 부스트 = 대상.스탯부스트
let 새최대 = creature.최대체력(종정보, 레벨) + 부스트 * 2
{
전투원: 대상{
레벨: 레벨,
경험: 경험,
현재체력: 체력.atMost(새최대),
최대체력: 새최대,
공격: 종정보.기본공격 + 레벨 + 부스트,
방어: 종정보.기본방어 + 레벨 + 부스트,
속도: 종정보.기본속도 + 레벨 + 부스트,
드리프트: 드리프트가두기(대상.드리프트 + 드리프트증가(오른, true, 데모)),
},
오른레벨: 오른,
}
}
// ===== core/genome.tpz =====
// 크리처의 게놈과 드리프트를 계산합니다. 게놈은 계통시드에서 유도한 다섯 개의 작은 정수이고 드리프트는 성장으로 천천히 쌓이는 카운터입니다.
// 계통시드는 월드시드와 크리처의 기원으로 만든 문자열입니다. 표현형은 원본 게놈에 드리프트 단계만큼 흔들림을 더한 값이고, 드리프트가 진화임계에 닿으면 진화 준비입니다.
// 게놈과 흔들림은 mutation 도메인 난수만 쓰므로 조우와 전투 난수가 게놈을 바꿀 수 없고, 같은 시드와 플레이는 같은 게놈을 만듭니다.
// 상태, 데이터, 전투 모듈을 가져오지 않습니다. 모든 값을 가둬 손상된 저장이 정수 넘침이나 느린 그리기를 일으키지 않게 합니다.
// Genome and drift: a five-trait genome derived from a lineage seed, slow drift, phenotype nudges and evolution readiness.
import core.rng { 난수 }
import core.util { 범위가두기 }
// 색소, 막, 크기, 대사, 촉수는 연못 미생물의 형질이고 값은 [0, 강도상한) 입니다.
export record 게놈 {
색소: int,
막: int,
크기: int,
대사: int,
촉수: int,
}
// 토파즈 과제 '구조 타입 주석 속 다른 모듈 레코드' 때문에 모듈째 가져오며 TPZ3017 때문에 레코드를 따로 가져올 수 없어 이 함수로 만듭니다.
// 5.21 에서 그 과제가 고쳐지면 제거 여부를 다시 봅니다.
export function 게놈만들기(색소: int, 막: int, 크기: int, 대사: int, 촉수: int) -> 게놈 {
게놈 { 색소: 색소, 막: 막, 크기: 크기, 대사: 대사, 촉수: 촉수 }
}
export let 트레이트수 = 5
export let 강도상한 = 8
// 10 이면 유한한 야생을 다 비울 때 3~4 세대까지 진화해 자동 진행이 보스를 이길 수 있습니다.
export let 진화임계 = 10
export let 드리프트상한 = 1000000
// 흔들림 계산이 단계에 비례하므로 단계를 상수로 가둡니다. 진화임계 / 8 = 3 까지만 미리 보여 줍니다.
export let 단계상한 = 3
enum 기원 {
시조,
야생(string),
모름,
}
export function 시작계통시드(월드시드: string) -> string {
"{월드시드}#starter"
}
// 같은 시드에서 같은 스텝, 칸, 종으로 잡으면 같은 계통시드입니다.
export function 야생계통시드(월드시드: string, 스텝: int, x: int, y: int, 종아이디: int) -> string {
"{월드시드}#wild@{스텝}:{x}:{y}:{종아이디}"
}
// 진화는 계통시드 뒤에 ">분기" 를 붙이므로 맨 앞의 기원 표시는 어느 노드에도 남습니다.
function 기원읽기(계통시드: string) -> 기원 {
let 해시조각들 = 계통시드.split("#")
if 해시조각들.length < 2 { return 기원.모름 }
let 핵심 = 해시조각들[1].split(">")[0]
if 핵심 == "starter" { return 기원.시조 }
let 야생조각들 = 핵심.split("@")
if 야생조각들.length < 2 { return 기원.모름 }
기원.야생(야생조각들[1].split(":")[0])
}
export function 출처(계통시드: string) -> string {
match 기원읽기(계통시드) {
case 시조 => "시조"
case 야생(스텝) => "야생 #{스텝}"
case 모름 => "야생"
}
}
// 숲 공유 코드에 쓰는 짧은 기원 키입니다.
export function 출처키(계통시드: string) -> string {
match 기원읽기(계통시드) {
case 시조 => "S"
case 야생(스텝) => "W{스텝}"
case 모름 => "W"
}
}
// 시드 문자열이 크리처마다 게놈 스트림을 가르므로 엔티티 인자는 0 입니다.
export function 계통엔티티(계통시드: string) -> int {
난수("mutation", 0, 0, 계통시드)
}
// 선형합동 난수의 아래 비트는 규칙적이라 작은 폭으로 줄이면 치우치므로 위 비트를 씁니다.
function 트레이트유도(엔티티: int, 트레이트번호: int, 계통시드: string) -> int {
(난수("mutation", 엔티티, 트레이트번호, 계통시드) / 21474836) % 강도상한
}
export function 게놈유도(계통시드: string) -> 게놈 {
let 엔티티 = 계통엔티티(계통시드)
게놈 {
색소: 트레이트유도(엔티티, 0, 계통시드),
막: 트레이트유도(엔티티, 1, 계통시드),
크기: 트레이트유도(엔티티, 2, 계통시드),
대사: 트레이트유도(엔티티, 3, 계통시드),
촉수: 트레이트유도(엔티티, 4, 계통시드),
}
}
// 기본은 레벨업 하나에 3, 레벨업 없는 승리에 2 입니다. 데모는 어떤 승리든 두 번이면 임계를 넘도록 14 와 12 를 씁니다.
export function 드리프트증가(오른레벨: int, 승리: bool, 데모: bool) -> int {
let 레벨당 = if 데모 { 14 } else { 3 }
let 승리몫 = if 데모 { 12 } else { 2 }
if 오른레벨 > 0 { 오른레벨 * 레벨당 } else if 승리 { 승리몫 } else { 0 }
}
export function 드리프트가두기(드리프트: int) -> int {
범위가두기(드리프트, 0, 드리프트상한)
}
// 여덟마다 한 단계라 흔들림이 드물고 느리게 보입니다.
function 드리프트단계(드리프트: int) -> int {
(드리프트가두기(드리프트) / 8).atMost(단계상한)
}
// 단계마다 -1, 0, +1 중 하나를 더합니다. 카운터를 트레이트수만큼 띄워 게놈유도의 카운터 0~4 와 겹치지 않게 합니다.
function 너지(엔티티: int, 트레이트번호: int, 단계: int, 계통시드: string) -> int {
let 방향들 = (1..<(단계 + 1)).map(k => (난수("mutation", 엔티티, 트레이트번호 + k * 트레이트수, 계통시드) / 21474836) % 3 - 1)
방향들.reduce(0, (합, 방향) => 합 + 방향)
}
// 페이지가 표현형으로 블롭의 색조와 모양을 조금 흔들어 다가올 진화를 미리 보여 줍니다.
export function 표현형(원본: 게놈, 계통시드: string, 드리프트: int) -> 게놈 {
let 단계 = 드리프트단계(드리프트)
if 단계 <= 0 { return 원본 }
let 엔티티 = 계통엔티티(계통시드)
게놈 {
색소: 원본.색소 + 너지(엔티티, 0, 단계, 계통시드),
막: 원본.막 + 너지(엔티티, 1, 단계, 계통시드),
크기: 원본.크기 + 너지(엔티티, 2, 단계, 계통시드),
대사: 원본.대사 + 너지(엔티티, 3, 단계, 계통시드),
촉수: 원본.촉수 + 너지(엔티티, 4, 단계, 계통시드),
}
}
export function 진화준비(드리프트: int) -> bool {
드리프트가두기(드리프트) >= 진화임계
}
export function 드리프트퍼센트(드리프트: int) -> int {
범위가두기(드리프트가두기(드리프트) * 100 / 진화임계, 0, 100)
}
export function 게놈요약(대상: 게놈) -> string {
"{대상.색소},{대상.막},{대상.크기},{대상.대사},{대상.촉수}"
}
function 트레이트칸(칸들: Array<string>, i: int) -> int {
범위가두기(if 칸들.length > i { 칸들[i].toInt() ?? 0 } else { 0 }, 0, 강도상한 - 1)
}
// 게놈요약의 역입니다. 도감이 가지 않은 형제 후보를 다시 유도할 때 씁니다.
export function 게놈요약파싱(요약: string) -> 게놈 {
let 칸들 = 요약.split(",")
게놈 {
색소: 트레이트칸(칸들, 0),
막: 트레이트칸(칸들, 1),
크기: 트레이트칸(칸들, 2),
대사: 트레이트칸(칸들, 3),
촉수: 트레이트칸(칸들, 4),
}
}
// ===== core/evolution.tpz =====
// 진화 준비가 된 크리처가 전투에서 레벨업하면 분기 진화합니다. 부모 게놈, 계통시드, 진화카운터에서 후보 돌연변이 2~3 개를 유도하고 고른 분기를 영구 형태로 고정합니다.
// 후보는 분기 번호, 파생 형태이름, 돌연변이 게놈, 스탯부스트, 지배트레이트입니다. 고정 결과는 새 전투원과 계통 노드 재료입니다.
// 모든 진화 난수는 mutation 도메인의 1,000,000 부터 시작하는 카운터 띠에서 뽑아 게놈(0~4)과 흔들림(19 이하) 카운터와 겹치지 않습니다. 같은 시드와 같은 분기 선택은 같은 생명의 나무입니다.
// 형태 이름은 손으로 쓴 진화 사슬이 아니라 게놈에서 유도합니다. 세대, 진화카운터, 분기 번호를 가둬 조작된 저장이 넘침을 일으키지 않게 합니다.
// Branch evolution: derives two or three seeded mutation candidates from the parent and locks the chosen branch.
import core.rng { 난수 }
import core.genome
import core.creature
import core.util { 범위가두기 }
import data.species
// 진화카운터마다 1,000 칸의 띠를 씁니다. 진화카운터 상한 1,000,000 이라 띠의 끝도 2^31 아래입니다.
export let 진화시작 = 1000000
export let 카운터스텝 = 1000
export let 최대후보수 = 3
export let 최소후보수 = 2
export type 후보 = {
분기: int,
형태이름: string,
게놈: genome.게놈,
스탯부스트: int,
지배트레이트: int,
}
// 시드지문은 새 계통시드이며 같은 시드와 분기면 같은 지문이 나오는 재현의 증거입니다.
export type 진화결과 = {
전투원: creature.전투원,
형태이름: string,
분기: int,
세대: int,
게놈요약후: string,
시드지문: string,
}
// 도감에 그릴 발견 기록입니다. 고유번호는 계통시드의 해시입니다.
export record 계통노드 {
고유번호: int,
부모고유번호: int,
형태이름: string,
게놈요약: string,
세대: int,
발견스텝: int,
시드지문: string,
}
// 선형합동 난수의 아래 비트는 규칙적이라 위 비트를 씁니다.
function 진화굴림(엔티티: int, 지역번호: int, 계통시드: string, 진화카운터: int, 폭: int) -> int {
let 띠 = 진화시작 + creature.진화카운터가두기(진화카운터) * 카운터스텝 + 지역번호
(난수("mutation", 엔티티, 띠, 계통시드) / 21474836) % 폭.atLeast(1)
}
export function 후보수(엔티티: int, 계통시드: string, 진화카운터: int) -> int {
최소후보수 + 진화굴림(엔티티, 0, 계통시드, 진화카운터, 최대후보수 - 최소후보수 + 1)
}
function 트레이트가두기(값: int) -> int {
범위가두기(값, 0, genome.강도상한 - 1)
}
function 트레이트들(대상: genome.게놈) -> Array<int> {
[대상.색소, 대상.막, 대상.크기, 대상.대사, 대상.촉수]
}
// 값이 같으면 앞 번호가 이깁니다.
export function 지배트레이트(대상: genome.게놈) -> int {
let 값들 = 트레이트들(대상)
(1..<genome.트레이트수).reduce(0, (최선, i) => if 값들[i] > 값들[최선] { i } else { 최선 })
}
// 진화는 늘 성장으로 보이도록 형질을 위로만 올리고 상한에서 멈춥니다.
function 너지(값: int, 세기: int) -> int {
(값 + 세기).atMost(genome.강도상한 - 1)
}
// 첫째 형질은 (지배 + 1 + 분기) 로 분기마다 다르게 고정해 분기마다 다른 형질이 자랍니다. 둘째 형질은 첫째와 겹치면 하나 옆으로 옮깁니다.
function 돌연변이게놈(부모: genome.게놈, 엔티티: int, 분기: int, 계통시드: string, 진화카운터: int) -> genome.게놈 {
let 기준 = 10 + 분기 * 5
let 첫형질 = (지배트레이트(부모) + 1 + 분기) % genome.트레이트수
let 뽑은형질 = 진화굴림(엔티티, 기준 + 1, 계통시드, 진화카운터, genome.트레이트수)
let 둘째형질 = if 뽑은형질 == 첫형질 { (첫형질 + 1) % genome.트레이트수 } else { 뽑은형질 }
let 첫세기 = 진화굴림(엔티티, 기준 + 2, 계통시드, 진화카운터, 3) + 1
let 둘째세기 = 진화굴림(엔티티, 기준 + 3, 계통시드, 진화카운터, 3) + 1
let 부모값들 = 트레이트들(부모)
let 값들 = [
for i in 0..<genome.트레이트수 => 트레이트가두기(if i == 첫형질 { 너지(부모값들[i], 첫세기) } else if i == 둘째형질 { 너지(부모값들[i], 둘째세기) } else { 부모값들[i] })
]
genome.게놈만들기(값들[0], 값들[1], 값들[2], 값들[3], 값들[4])
}
function 어간(지배: int) -> string {
match 지배 {
case 0 => "빛무리"
case 1 => "갑각"
case 2 => "거대"
case 3 => "열소"
case _ => "촉수"
}
}
// 후보는 2~3 개라 분기 번호로 고른 접미는 늘 서로 달라 어간이 같아도 이름이 겹치지 않습니다.
function 접미(분기: int) -> string {
match 분기 % 6 {
case 0 => "체"
case 1 => "충"
case 2 => "포자"
case 3 => "군체"
case 4 => "정령"
case _ => "변이체"
}
}
// 세대는 노드가 따로 들고 있어 이름에 넣지 않습니다.
function 형태이름(돌연변이: genome.게놈, 분기: int) -> string {
"{어간(지배트레이트(돌연변이))}{접미(분기)}"
}
function 후보유도(부모: genome.게놈, 엔티티: int, 분기: int, 계통시드: string, 진화카운터: int) -> 후보 {
let 돌연변이 = 돌연변이게놈(부모, 엔티티, 분기, 계통시드, 진화카운터)
{
분기: 분기,
형태이름: 형태이름(돌연변이, 분기),
게놈: 돌연변이,
스탯부스트: 진화굴림(엔티티, 40 + 분기, 계통시드, 진화카운터, 4) + 2,
지배트레이트: 지배트레이트(돌연변이),
}
}
export function 후보들유도(부모: genome.게놈, 엔티티: int, 계통시드: string, 진화카운터: int) -> Array<후보> {
(0..<후보수(엔티티, 계통시드, 진화카운터)).map(k => 후보유도(부모, 엔티티, k, 계통시드, 진화카운터))
}
// 정확한 형태와 이름은 고정한 뒤에 보여 주고 고르기 전에는 돌연변이게놈의 첫째 형질만 귀띔합니다.
export function 후보힌트(후보입력: 후보) -> string {
match (후보입력.지배트레이트 + 1 + 후보입력.분기) % genome.트레이트수 {
case 0 => "빛을 머금는 색소가 짙어지는 기운"
case 1 => "막이 단단해지는 기운"
case 2 => "몸집이 불어나는 기운"
case 3 => "대사가 빨라지는 기운"
case _ => "촉수가 뻗어 나가는 기운"
}
}
// 부모에서 후보를 다시 유도해 실제로 고른 게놈을 뺀 나머지, 가지 않은 길의 힌트를 모읍니다.
export function 형제힌트들(부모게놈: genome.게놈, 부모시드: string, 부모세대: int, 선택게놈요약: string) -> string {
let 후보들 = 후보들유도(부모게놈, 계통고유번호(부모시드), 부모시드, 부모세대)
후보들.filter(후 => genome.게놈요약(후.게놈) != 선택게놈요약).map(후보힌트).join(" · ")
}
// 상한에 막힌 형질 때문에 두 분기의 게놈이 같을 수 있어 마지막으로 일치한 분기를 씁니다. 없으면 -1 입니다.
export function 노드분기(부모게놈: genome.게놈, 부모시드: string, 부모세대: int, 자식게놈요약: string) -> int {
let 후보들 = 후보들유도(부모게놈, 계통고유번호(부모시드), 부모시드, 부모세대)
let 일치들 = 후보들.filter(후 => genome.게놈요약(후.게놈) == 자식게놈요약)
if 일치들.length == 0 { -1 } else { 일치들[일치들.length - 1].분기 }
}
// 종아이디, 스프라이트, 속성, 기술은 그대로 두고 돌연변이 게놈이 새 기준 게놈이 됩니다. 진화는 체력을 새 최대로 채우고 드리프트를 0 으로 되돌립니다.
// 범위 밖 분기 선택은 0 번 분기로 돌아갑니다.
export function 분기진화(부모: creature.전투원, 분기선택: int, 부모세대: int, 부모진화카운터: int) -> 진화결과 {
let 카운터 = creature.진화카운터가두기(부모진화카운터)
let 후보들 = 후보들유도(부모.게놈, 계통고유번호(부모.계통시드), 부모.계통시드, 카운터)
let 분기 = 범위가두기(분기선택, 0, 후보들.length - 1)
let 고른후보 = 후보들[분기]
let 시드 = "{부모.계통시드}>{분기}"
let 새세대 = creature.세대가두기(부모세대 + 1)
let 종정보 = species.종찾기(부모.종아이디)
let 부스트 = 고른후보.스탯부스트
let 새최대 = creature.최대체력(종정보, 부모.레벨) + 부스트 * 2
let 새전투원 = 부모{
현재체력: 새최대,
최대체력: 새최대,
공격: 종정보.기본공격 + 부모.레벨 + 부스트,
방어: 종정보.기본방어 + 부모.레벨 + 부스트,
속도: 종정보.기본속도 + 부모.레벨 + 부스트,
계통시드: 시드,
드리프트: 0,
게놈: 고른후보.게놈,
세대: 새세대,
진화카운터: creature.진화카운터가두기(카운터 + 1),
형태이름: 고른후보.형태이름,
스탯부스트: 부모.스탯부스트 + 부스트,
}
{
전투원: 새전투원,
형태이름: 고른후보.형태이름,
분기: 분기,
세대: 새세대,
게놈요약후: genome.게놈요약(고른후보.게놈),
시드지문: 시드,
}
}
export function 진화발사(드리프트: int, 오른레벨: int) -> bool {
genome.진화준비(드리프트) && 오른레벨 > 0
}
// 후보 메뉴가 이 값으로 분기진화와 똑같은 후보를 다시 유도하므로 메뉴에서 본 후보가 곧 고정되는 후보입니다.
export function 계통고유번호(계통시드: string) -> int {
난수("mutation", 0, 0, 계통시드)
}
export function 노드빌드(결과: 진화결과, 부모고유번호: int, 스텝: int) -> 계통노드 {
노드생성(계통고유번호(결과.시드지문), 부모고유번호, 결과.형태이름, 결과.게놈요약후, 결과.세대, 스텝, 결과.시드지문)
}
// 토파즈 과제 '구조 타입 주석 속 다른 모듈 레코드' 때문에 모듈째 가져오며 TPZ3017 때문에 레코드를 따로 가져올 수 없어 이 함수로 만듭니다.
// 5.21 에서 그 과제가 고쳐지면 제거 여부를 다시 봅니다.
export function 노드생성(고유번호: int, 부모고유번호: int, 형태이름: string, 게놈요약: string, 세대: int, 발견스텝: int, 시드지문: string) -> 계통노드 {
계통노드 {
고유번호: 고유번호,
부모고유번호: 부모고유번호,
형태이름: 형태이름,
게놈요약: 게놈요약,
세대: 세대,
발견스텝: 발견스텝,
시드지문: 시드지문,
}
}
// ===== core/lineagedex.tpz =====
// 계통도감의 나무 배치를 계산합니다. 열은 세대이고 뿌리가 왼쪽, 자손이 오른쪽으로 가지를 칩니다.
// 입력은 발견 순서의 계통 노드 목록이고 출력은 노드마다 열, 행, 픽셀 좌표, 부모의 배치 번호와 나무 전체 크기입니다.
// 난수 없이 목록 순서만 쓰므로 같은 목록은 늘 같은 배치입니다.
// 노드 수와 세대를 상수로 가둬 조작된 목록도 멈추지 않거나 넘치지 않고, 가시 영역 160x144 를 넘는 나무는 페이지가 스크롤합니다.
// Lineage dex layout: a bounded, deterministic depth-first tree layout of discovered lineage nodes.
import core.evolution
import core.util { 범위가두기 }
// 형제를 훑는 배치는 노드 수의 제곱에 가까워 조작된 큰 목록을 256 에서 자릅니다. 그 너머 노드는 그리지 않습니다.
export let 노드상한 = 256
export let 세대상한 = 99
export let 열간격 = 34
export let 행간격 = 22
export let 여백x = 14
export let 여백y = 24
// 인덱스는 노드 목록의 발견 순서이고 커서가 가리키는 값입니다. 부모인덱스는 배치 목록 안의 부모 자리이며 뿌리와 고아는 -1 입니다.
export type 배치노드 = {
인덱스: int,
고유번호: int,
부모인덱스: int,
열: int,
행: int,
x: int,
y: int,
형태이름: string,
게놈요약: string,
세대: int,
시드지문: string,
}
export type 계통레이아웃 = {
노드들: Array<배치노드>,
너비: int,
높이: int,
행수: int,
}
// 부모고유번호 0 은 뿌리이고, 목록에 없는 부모를 가리키는 노드는 고아라 뿌리처럼 다룹니다.
function 부모인덱스찾기(노드들: Array<evolution.계통노드>, 부모고유번호: int) -> int {
if 부모고유번호 == 0 { return -1 }
for i in 0..<노드들.length {
if 노드들[i].고유번호 == 부모고유번호 { return i }
}
-1
}
function 자식인가(자식: evolution.계통노드, 부모: evolution.계통노드) -> bool {
자식.부모고유번호 != 0 && 자식.부모고유번호 == 부모.고유번호
}
function 뿌리인가(노드들: Array<evolution.계통노드>, 노드: evolution.계통노드) -> bool {
부모인덱스찾기(노드들, 노드.부모고유번호) < 0
}
function 자식인덱스들(노드들: Array<evolution.계통노드>, 부모인덱스: int) -> Array<int> {
let 부모 = 노드들[부모인덱스]
[for i in 0..<노드들.length if i != 부모인덱스 && 자식인가(노드들[i], 부모) => i]
}
function 배치인덱스찾기(배치들: Array<배치노드>, 노드인덱스: int) -> int {
for i in 0..<배치들.length {
if 배치들[i].인덱스 == 노드인덱스 { return i }
}
-1
}
// 뿌리부터 발견 순서대로 깊이 우선 전위 순회하며 방문 순서대로 행을 줍니다. 자식이 부모 바로 아래에 모입니다.
// 스택에는 역순으로 넣어 꺼내는 순서가 발견 순서가 되게 합니다. 방문 표시가 순환과 중복을 막고 방문 수는 노드상한에서 멈춥니다.
export function 레이아웃계산(노드들: Array<evolution.계통노드>) -> 계통레이아웃 {
let mut 방문 = [for i in 0..<노드들.length => false]
let mut 배치들: Array<배치노드> = []
let mut 최대열 = 0
let mut 스택 = [for i in (노드들.length - 1)..0 by -1 if 뿌리인가(노드들, 노드들[i]) => i]
while 스택.length > 0 && 배치들.length < 노드상한 {
let 인덱스 = 스택[스택.length - 1]
스택 = 스택.slice(0, 스택.length - 1)
if !방문[인덱스] {
방문[인덱스] = true
let 노드 = 노드들[인덱스]
let 열 = 범위가두기(노드.세대, 0, 세대상한)
let 행 = 배치들.length
최대열 = 최대열.atLeast(열)
let 부모인덱스 = 부모인덱스찾기(노드들, 노드.부모고유번호)
배치들.push({
인덱스: 인덱스,
고유번호: 노드.고유번호,
부모인덱스: if 부모인덱스 < 0 { -1 } else { 배치인덱스찾기(배치들, 부모인덱스) },
열: 열,
행: 행,
x: 여백x + 열 * 열간격,
y: 여백y + 행 * 행간격,
형태이름: 노드.형태이름,
게놈요약: 노드.게놈요약,
세대: 노드.세대,
시드지문: 노드.시드지문,
})
let 자식들 = 자식인덱스들(노드들, 인덱스)
for i in (자식들.length - 1)..0 by -1 { 스택.push(자식들[i]) }
}
}
// 노드 카드 30x18 이 들어갈 여유를 더하고 가시 영역보다 작아지지 않게 합니다.
{
노드들: 배치들,
너비: (여백x + 최대열 * 열간격 + 32).atLeast(160),
높이: (여백y + 배치들.length * 행간격 + 18).atLeast(144),
행수: 배치들.length,
}
}
// ===== core/auto.tpz =====
// 자동 진행 정책입니다. 상태를 보고 다음 입력 하나를 정하고, 같은 스텝 엔진이 그 입력을 적용합니다.
// 필드의 우선순위는 위험하면 인물에게 회복, 아니면 가장 가까운 보스 아닌 야생, 다 비우면 연못은 워프로 내려가고 심층은 보스입니다. 이동은 목표 칸에서 퍼지는 너비 우선 거리장으로 정합니다.
// 이웃 순서를 아래, 위, 왼쪽, 오른쪽으로 고정해 같은 상태는 늘 같은 입력입니다.
// 분기 진화는 기본으로 멈춰 플레이어가 고르게 하고, 자동 고르기는 공개된 후보 수만 씁니다. 페이지는 타이머로 auto 를 보내고 그 사이를 그리기만 합니다.
// Auto-play policy: picks the next ordinary input from the state; branch evolution pauses for the player by default.
import data.maps { 맵너비, 맵높이, 맵타일들, 타일에서, 워프목록, 워프, 타일_물, 타일_나무 }
import data.entities
import core.state
import core.creature
import core.evolution { 후보수, 계통고유번호, 진화시작 }
import core.rng { 난수범위 }
import core.util { 범위가두기 }
// 보스는 보통 야생 목표에서 빼고 다른 야생을 다 비운 뒤의 마지막 상대로만 다룹니다.
let 보스아이디 = 14
// 아래, 위, 왼쪽, 오른쪽입니다. 이 순서가 같은 거리의 이웃 중 무엇을 고를지 정합니다.
let 이웃x차 = [0, 0, -1, 1]
let 이웃y차 = [1, -1, 0, 0]
let 이웃방향 = ["down", "up", "left", "right"]
// 목표 칸은 막혀 있어도 거리장의 출발점으로 따로 넣습니다.
function 통행가능한가(타일들: Array<int>, 맵아이디: string, x: int, y: int, 처치된것들: Array<int>) -> bool {
let 타일 = 타일에서(타일들, x, y)
타일 != 타일_물 && 타일 != 타일_나무 && !entities.활성엔티티칸인가(맵아이디, x, y, 처치된것들)
}
function 맵안인가(x: int, y: int) -> bool {
x >= 0 && y >= 0 && x < 맵너비 && y < 맵높이
}
// 목표 칸이 0 이고 닿지 못하는 칸은 -1 입니다.
function 거리장(목표칸들: Array<int>, 타일들: Array<int>, 맵아이디: string, 처치된것들: Array<int>) -> Array<int> {
let 칸수 = 맵너비 * 맵높이
let mut 거리 = [for i in 0..<칸수 => -1]
let mut 대기열: Array<int> = []
for 칸 in 목표칸들 {
if 칸 >= 0 && 칸 < 칸수 && 거리[칸] == -1 {
거리[칸] = 0
대기열.push(칸)
}
}
let mut 머리 = 0
while 머리 < 대기열.length {
let 칸 = 대기열[머리]
머리 += 1
for k in 0..<4 {
let x = 칸 % 맵너비 + 이웃x차[k]
let y = 칸 / 맵너비 + 이웃y차[k]
if 맵안인가(x, y) && 거리[y * 맵너비 + x] == -1 && 통행가능한가(타일들, 맵아이디, x, y, 처치된것들) {
거리[y * 맵너비 + x] = 거리[칸] + 1
대기열.push(y * 맵너비 + x)
}
}
}
거리
}
// 지금 칸보다 확실히 가까운 이웃 중 고정 순서의 첫째로 갑니다. 그런 이웃이 없으면 "" 입니다.
function 다가가기방향(거리: Array<int>, x: int, y: int) -> string {
let 내칸 = y * 맵너비 + x
let mut 최선거리 = if 내칸 >= 0 && 내칸 < 거리.length { 거리[내칸] } else { -1 }
let mut 최선방향 = ""
for k in 0..<4 {
let 이웃x = x + 이웃x차[k]
let 이웃y = y + 이웃y차[k]
if 맵안인가(이웃x, 이웃y) {
let 이웃거리 = 거리[이웃y * 맵너비 + 이웃x]
if 이웃거리 >= 0 && (최선거리 < 0 || 이웃거리 < 최선거리) {
최선거리 = 이웃거리
최선방향 = 이웃방향[k]
}
}
}
최선방향
}
function 엔티티칸(대상: entities.엔티티) -> int {
대상.y * 맵너비 + 대상.x
}
function 야생칸들(맵아이디: string, 처치된것들: Array<int>) -> Array<int> {
entities.엔티티목록(맵아이디).filter(대상 => entities.야생인가(대상) && 대상.아이디 != 보스아이디 && !entities.처치된것인가(처치된것들, 대상.아이디)).map(엔티티칸)
}
function 보스칸(맵아이디: string, 처치된것들: Array<int>) -> Array<int> {
entities.엔티티목록(맵아이디).filter(대상 => 대상.아이디 == 보스아이디 && !entities.처치된것인가(처치된것들, 대상.아이디)).map(엔티티칸)
}
function 인물칸들(맵아이디: string) -> Array<int> {
entities.엔티티목록(맵아이디).filter(entities.인물인가).map(엔티티칸)
}
function 워프칸들(맵아이디: string) -> Array<int> {
워프목록(맵아이디).map(대상 => 대상.y * 맵너비 + 대상.x)
}
function 위험한가(활성: creature.전투원) -> bool {
활성.현재체력 * 3 < 활성.최대체력
}
// 의도 0 은 멈춰 플레이어가 고르고, 1 은 첫 가지, 그 밖은 진화 난수 띠에서 뽑은 가지입니다. 커서를 그 가지로 옮긴 뒤 잠급니다.
function 분기고르기(진: state.진화상태, 의도: int) -> string {
if 의도 == 0 { return "" }
let 엔티티 = 계통고유번호(진.부모계통시드)
let 수 = 후보수(엔티티, 진.부모계통시드, 진.부모진화카운터)
if 수 <= 1 { return "a" }
let 뽑은분기 = if 의도 == 1 { 0 } else { 난수범위("auto_evolve", 엔티티, 진화시작 + 진.부모진화카운터, 진.부모계통시드, 0, 수 - 1) }
let 목표분기 = 범위가두기(뽑은분기, 0, 수 - 1)
if 진.선택커서 < 목표분기 { "right" } else if 진.선택커서 > 목표분기 { "left" } else { "a" }
}
function 진화자동(현재: state.상태, 의도: int) -> string {
match 현재.진화.단계 {
case "morph" => "a"
case "none" => ""
case "choose" => 분기고르기(현재.진화, 의도)
}
}
// 지나가다 보스를 일찍 들이받지 않도록 보스는 다른 야생을 다 비운 뒤에만 A 로 맞붙습니다.
// 목표가 막힌 엔티티면 옆 칸에서 마주 본 뒤 다음 틱에 A 를 누르고, 워프면 그 칸으로 들어갑니다.
function 필드결정(현재: state.상태) -> string {
let 위험 = 위험한가(state.초점전투원(현재))
let 보통야생들 = 야생칸들(현재.맵아이디, 현재.처치된것들)
let 앞 = entities.활성엔티티에서(현재.맵아이디, state.마주x(현재.플레이어), state.마주y(현재.플레이어), 현재.처치된것들)
if entities.야생인가(앞) && 앞.아이디 != 보스아이디 { return "a" }
if 앞.아이디 == 보스아이디 && 보통야생들.length == 0 { return "a" }
if entities.인물인가(앞) && 위험 { return "a" }
let 목표 = if 위험 {
인물칸들(현재.맵아이디)
} else if 보통야생들.length > 0 {
보통야생들
} else if 현재.맵아이디 == "deep" {
보스칸(현재.맵아이디, 현재.처치된것들)
} else {
워프칸들(현재.맵아이디)
}
if 목표.length == 0 { return "" }
let 거리 = 거리장(목표, 맵타일들(현재.맵아이디), 현재.맵아이디, 현재.처치된것들)
다가가기방향(거리, 현재.플레이어.x, 현재.플레이어.y)
}
// 전투는 메뉴 커서 기본값이 싸우기라 A 만으로 끝까지 갑니다. 이야기 카드는 페이지가 읽을 시간을 두고 넘깁니다.
// "" 는 멈춤이며 수동 진화 갈림길처럼 플레이어의 몫입니다.
export function 자동결정(현재: state.상태, 의도: int) -> string {
match 현재.장면 {
case "battle" | "story" => "a"
case "evolve" => 진화자동(현재, 의도)
case "party" => "start"
case "dex" => "select"
case "field" => 필드결정(현재)
}
}
// 자동결정과 같은 우선순위를 글로만 읽어 HUD 가 실제 행동과 어긋나지 않게 합니다.
function 필드목표(현재: state.상태) -> string {
if 위험한가(state.초점전투원(현재)) { return "회복하러 가는 중" }
if 야생칸들(현재.맵아이디, 현재.처치된것들).length > 0 { return "야생을 찾아가는 중" }
if 현재.맵아이디 == "deep" {
return if 보스칸(현재.맵아이디, 현재.처치된것들).length > 0 { "심연군주에게 가는 중" } else { "정복 완료" }
}
if 워프칸들(현재.맵아이디).length > 0 { "더 깊은 곳으로 가는 중" } else { "둘러보는 중" }
}
export function 자동목표(현재: state.상태) -> string {
match 현재.장면 {
case "battle" => "야생과 싸우는 중"
case "evolve" => "진화의 갈림길"
case "party" => "파티를 보는 중"
case "dex" => "계통을 보는 중"
case "story" | "field" => 필드목표(현재)
}
}
// ===== core/story.tpz =====
// 이야기 이정표를 한 번씩만 띄우는 내레이션 비트셋을 다룹니다.
// 비트셋은 정수 하나이고 비트 번호는 첫 조우 0, 첫 포획 1, 첫 초점 2, 첫 심층 7, 정복 10 입니다. 파생비트는 상태에서 도달한 비트셋을, 비트내레이션은 비트의 두 줄 문구를 돌려줍니다.
// 비트셋이 저장 상태에 들어가고 도달 여부가 상태의 순수 함수라 같은 상태는 늘 같은 비트입니다.
// 비트셋은 게임 결과에 영향을 주지 않는 연출입니다.
// Story beats: a bitset of fire-once milestones and their narration.
import data.entities
import core.state
export let 비트수 = 15
export let 비트_첫조우 = 0
export let 비트_첫포획 = 1
export let 비트_첫초점 = 2
export let 비트_첫심층 = 7
export let 비트_정복 = 10
export function 켜진비트인가(n: int, k: int) -> bool {
n.and(1.shift(k.atLeast(0).atMost(30))) != 0
}
export function 비트켜기(n: int, k: int) -> int {
n.or(1.shift(k.atLeast(0).atMost(30)))
}
export function 비트끄기(n: int, k: int) -> int {
n.and(1.shift(k.atLeast(0).atMost(30)).xor(-1))
}
// 대기열에서 다음에 보여 줄 비트입니다. 없으면 -1 입니다.
export function 최하위비트(n: int) -> int {
for k in 0..<비트수 {
if 켜진비트인가(n, k) { return k }
}
-1
}
// 호출자가 이미 본 비트를 빼서 새 비트만 추립니다. 맵에 야생이 늘 있어 첫 조우는 시작부터 켜지고 오프닝 카드가 됩니다.
export function 파생비트(현재: state.상태) -> int {
let mut 비트셋 = 0
if entities.엔티티목록(현재.맵아이디).filter(entities.야생인가).length > 0 { 비트셋 = 비트켜기(비트셋, 비트_첫조우) }
if 현재.파티.length > 1 { 비트셋 = 비트켜기(비트셋, 비트_첫포획) }
if 현재.초점 > 0 { 비트셋 = 비트켜기(비트셋, 비트_첫초점) }
if 현재.맵아이디 == "deep" { 비트셋 = 비트켜기(비트셋, 비트_첫심층) }
// 엔티티 14 는 심연군주입니다.
if entities.처치된것인가(현재.처치된것들, 14) { 비트셋 = 비트켜기(비트셋, 비트_정복) }
비트셋
}
// 두 줄 문구는 \n 으로 나눕니다. 문구가 없는 비트는 빈 문자열입니다.
export function 비트내레이션(비트: int) -> string {
if 비트 == 비트_첫조우 {
"세계가 조금씩 얇아지고 있습니다.\n저 작은 표본은 아직 사라지지 않은 생명의 결입니다."
} else if 비트 == 비트_첫포획 {
"한 표본이 씨앗의 숲에 머물기로 했습니다.\n서두르지 마십시오. 오래 지켜본 생명만이 길을 냅니다."
} else if 비트 == 비트_첫초점 {
"이제 이 표본은 하나의 줄기가 됩니다.\n당신의 보살핌은 계보가 되어 남습니다."
} else if 비트 == 비트_첫심층 {
"깊은 곳이 열렸습니다.\n그곳은 적의 땅이 아니라, 오래전에 멈춘 생명의 뿌리입니다."
} else if 비트 == 비트_정복 {
"숲은 사라지지 않았습니다.\n느리게 자란 계보가, 다시 살아갈 수 있음을 증명했습니다."
} else {
""
}
}
// ===== core/clash.tpz =====
// 삼투 압력전입니다. 두 미생물이 한 주머니에서 서로를 흔들고, 메뉴 없이 키운 게놈이 곧 전투력입니다.
// 형질의 역할은 색소 적응, 막 응집, 크기 부피, 대사 부식, 촉수 템포입니다. 내 안정도는 전투원 현재체력, 적 안정도는 배틀 적체력, 압력 -100~100 은 배틀 메뉴커서, 비트 번호는 전투카운터에 둡니다.
// 비트 하나를 시드, 비트 번호, 양쪽 게놈만으로 계산하므로 같은 상태는 늘 같은 다음 비트입니다.
// 그리기는 하지 않습니다. 페이지가 비트마다 결과를 영화처럼 그립니다.
// Osmosis clash: a deterministic, menu-free battle where the cultivated genome decides each beat.
import core.genome
import core.creature
import core.battle
import core.evolution { 지배트레이트 }
import core.rng { 난수범위 }
import core.util { 범위가두기 }
import data.species
// 비트상한에 닿으면 안정도 비율이 높은 쪽이 이깁니다. 적 안정도가 최대의 30% 이하면 포자 정착을 시도합니다.
export let 비트상한 = 8
let 포획문턱 = 30
function 형질가두기(값: int) -> int {
범위가두기(값, 0, genome.강도상한 - 1)
}
// 야생은 게놈이 없어 유도합니다. 크기는 레벨에 비례해 얕은 연못이 약하고 심연군주가 강하며, 어느 형질이 두드러지는지는 종과 시드가 정합니다.
export function 적게놈유도(종아이디: int, 적레벨: int, 시드: string) -> genome.게놈 {
let 풍미 = genome.게놈유도("{시드}#foe@{종아이디}")
let 단위 = 적레벨 / 3
genome.게놈만들기(형질가두기(단위 + 풍미.색소 % 2), 형질가두기(단위 + 풍미.막 % 2), 형질가두기(단위 + 풍미.크기 % 2), 형질가두기(단위 + 풍미.대사 % 2), 형질가두기(단위 + 풍미.촉수 % 2))
}
// 플레이어 체력과 같은 곡선이라 양쪽이 공정하게 맞섭니다.
export function 적안정도최대(적종: int, 적레벨: int) -> int {
creature.최대체력(species.종찾기(적종), 적레벨)
}
function 형질문구(편: string, 형질: int) -> string {
match 형질 {
case 0 => "{편} 색소가 압력을 휘게 합니다"
case 1 => "{편} 막이 버팁니다"
case 2 => "{편} 부피가 버팁니다"
case 3 => "{편} 대사가 갉아냅니다"
case _ => "{편} 촉수가 파고듭니다"
}
}
// 레벨, 진화 부스트, 세대를 더해 키운 만큼 강해집니다. 보스는 진화하지 않으므로 야생을 다 비운 플레이어가 보스를 이깁니다.
function 공세(대상: genome.게놈, 레벨: int, 부스트: int, 세대: int) -> int {
대상.대사 * 3 + 대상.촉수 * 2 + 대상.크기 + 레벨 * 2 + 부스트 * 3 + 세대 * 3
}
function 방어(대상: genome.게놈, 레벨: int, 부스트: int, 세대: int) -> int {
대상.막 * 3 + 대상.크기 + 레벨 + 부스트 * 2 + 세대 * 2
}
export function 압력전시작(적종: int, 적레벨: int) -> battle.배틀상태 {
{
단계: "clash",
메뉴커서: 0,
기술커서: 0,
전투카운터: 0,
적체력: 적안정도최대(적종, 적레벨),
메시지: "두 세포가 한 주머니에서 맞닿습니다.",
메시지커서: 0,
다음단계: "clash",
결과: "",
}
}
function 포자정착판정(시드: string, 비트: int, 적종: int, 적게놈: genome.게놈, 적안정도: int, 적최대: int, 볼: int, 내색소: int) -> bool {
if 볼 <= 0 { return false }
let 약화 = (적최대 - 적안정도) * 100 / (적최대 + 1)
let 점수 = 볼 * 8 + 약화 + 내색소 * 2 - 적게놈.막 * 3
점수 > 난수범위("spore", 적종, 비트, 시드, 0, 100) + 40
}
function 비트결과(배틀: battle.배틀상태, 플레이어: creature.전투원, 단계: battle.배틀단계, 적체력: int, 메시지: string, 다음단계: battle.배틀다음단계, 결과: battle.배틀결과) -> battle.턴결과 {
{
배틀: 배틀{
단계: 단계,
기술커서: 0,
적체력: 적체력,
메시지: 메시지,
메시지커서: 0,
다음단계: 다음단계,
결과: 결과,
},
플레이어: 플레이어,
}
}
// 패배, 승리, 포자 정착, 비트상한 순으로 판정합니다. 포획은 숲의 뿌리를 몇 그루 심을 때만 원하고, 기본은 쓰러뜨려 경험과 드리프트로 초점을 키웁니다.
export function 비트진행(시드: string, 직전배틀: battle.배틀상태, 활성: creature.전투원, 적종: int, 적레벨: int, 볼: int, 포획원함: bool) -> battle.턴결과 {
let 비트 = 직전배틀.전투카운터
let 적최대 = 적안정도최대(적종, 적레벨)
let 내게놈 = genome.표현형(활성.게놈, 활성.계통시드, 활성.드리프트)
let 적게놈 = 적게놈유도(적종, 적레벨, 시드)
// 4 로 나눠 한 판이 5~8 비트 이어지게 하고 적 피해는 최소 2 로 진행을 보장합니다. 색소는 받는 피해를 줄입니다.
let 적피해 = ((공세(내게놈, 활성.레벨, 활성.스탯부스트, 활성.세대) - 방어(적게놈, 적레벨, 0, 0)) / 4 + 난수범위("clash_p", 적종, 비트, 시드, 0, 2)).atLeast(2)
let 내피해 = ((공세(적게놈, 적레벨, 0, 0) - 방어(내게놈, 활성.레벨, 활성.스탯부스트, 활성.세대)) / 4 + 난수범위("clash_f", 적종, 비트, 시드, 0, 2) - 내게놈.색소 / 2).atLeast(0)
let 새적 = 직전배틀.적체력 - 적피해
let 새체력 = (활성.현재체력 - 내피해).atLeast(0)
let 다음배틀 = 직전배틀{ 메뉴커서: 범위가두기(직전배틀.메뉴커서 + (적피해 - 내피해), -100, 100), 전투카운터: 비트 + 1 }
let 새활성 = creature.체력설정(활성, 새체력)
if 새체력 <= 0 { return 비트결과(다음배틀, 새활성, "result", 새적, "버티지 못하고 흩어집니다.", "field", "lose") }
if 새적 <= 0 { return 비트결과(다음배틀, 새활성, "result", 0, "상대가 더는 응집하지 못합니다.", "field", "win") }
if 포획원함 && 새적 * 100 <= 적최대 * 포획문턱 && 포자정착판정(시드, 비트, 적종, 적게놈, 새적, 적최대, 볼, 내게놈.색소) {
return 비트결과(다음배틀, 새활성, "result", 새적, "포자가 상대를 감싸 정착시킵니다.", "catch", "caught")
}
if 비트 + 1 >= 비트상한 {
let 내비율 = 새체력 * 100 / (활성.최대체력 + 1)
let 적비율 = 새적 * 100 / (적최대 + 1)
if 내비율 >= 적비율 { return 비트결과(다음배틀, 새활성, "result", 새적, "압력이 가라앉고, 당신 쪽이 더 안정적입니다.", "field", "win") }
return 비트결과(다음배틀, 새활성, "result", 새적, "압력이 가라앉고, 당신 쪽이 더 흔들립니다.", "field", "lose")
}
let 메시지 = "{형질문구("내", 지배트레이트(내게놈))} · {형질문구("적", 지배트레이트(적게놈))}"
비트결과(다음배틀, 새활성, "clash", 새적, 메시지, "clash", "")
}
// ===== data/maps.tpz =====
// 연못과 심층 두 맵의 타일 격자, 맵 사이를 잇는 워프, 좌표로 타일을 묻는 함수를 둡니다.
// 격자는 24x22 타일을 행 우선으로 편 정수 배열이며 0 풀, 1 키큰풀, 2 길, 3 물, 4 나무, 5 꽃입니다. 맵 아이디 "deep" 은 심층이고 나머지는 연못입니다.
// 상수 격자라 같은 맵과 좌표는 늘 같은 타일이고, 격자 밖은 나무 벽으로 답합니다.
// 픽셀을 그리지 않습니다. 페이지의 셸이 타일 번호마다 16x16 무늬를 그립니다.
// Map data: two 24x22 tile grids, position-based warps and tile lookup.
// 맵이 화면에 보이는 10x9 보다 커서 카메라가 플레이어를 따라갑니다.
export let 맵너비 = 24
export let 맵높이 = 22
export type 타일종류 = 0 | 1 | 2 | 3 | 4 | 5
export let 타일_풀: 타일종류 = 0
export let 타일_키큰풀: 타일종류 = 1
export let 타일_길: 타일종류 = 2
export let 타일_물: 타일종류 = 3
export let 타일_나무: 타일종류 = 4
export let 타일_꽃: 타일종류 = 5
// 나무 테두리로 둘러싼 연못 분지입니다. 가운데 물웅덩이를 길이 감싸고 곳곳에 키큰풀밭이 있습니다.
function 연못타일들() -> Array<int> {
[
4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
4,0,0,0,5,0,0,1,1,1,1,0,0,0,0,5,0,0,0,0,0,0,0,4,
4,0,0,0,0,0,0,1,1,1,1,0,0,2,2,2,2,2,2,0,0,5,0,4,
4,0,5,0,0,0,0,1,1,1,1,0,0,2,0,0,0,0,2,0,0,0,0,4,
4,0,0,0,0,0,0,0,1,1,0,0,0,2,0,0,0,0,2,0,1,1,0,4,
4,0,0,2,2,2,2,2,2,2,2,2,2,2,0,0,5,0,2,0,1,1,0,4,
4,5,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,4,
4,0,0,2,0,0,3,3,3,3,3,0,0,0,0,0,0,0,2,2,2,2,2,4,
4,0,0,2,0,3,3,3,3,3,3,3,0,0,5,0,0,0,0,0,0,0,2,4,
4,0,0,2,0,3,3,3,3,3,3,3,3,0,0,0,0,1,1,1,0,0,2,4,
4,0,5,2,0,3,3,3,3,3,3,3,3,0,0,0,0,1,1,1,0,0,2,4,
4,0,0,2,0,3,3,3,3,3,3,3,0,0,0,0,0,1,1,1,0,0,2,4,
4,0,0,2,0,0,3,3,3,3,3,0,0,0,5,0,0,0,0,0,0,0,2,4,
4,0,0,2,2,2,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,4,
4,0,5,0,0,2,0,0,5,0,0,0,0,2,0,0,0,0,0,0,0,0,0,4,
4,0,0,0,0,2,2,2,2,2,2,2,2,2,0,0,5,0,0,5,0,0,0,4,
4,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,4,
4,1,1,1,0,0,5,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,4,
4,1,1,1,0,0,0,0,0,0,1,1,1,0,0,5,0,0,0,0,1,1,1,4,
4,0,1,1,0,0,0,5,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,4,
4,0,0,0,0,5,0,0,0,0,0,0,0,0,0,5,0,0,0,5,0,0,0,4,
4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
]
}
// 연못 남쪽 통로 너머의 어둡고 트인 동굴입니다. 같은 격자 크기라 카메라와 그리기를 그대로 씁니다.
function 심층타일들() -> Array<int> {
[
4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,4,
4,0,0,0,0,0,0,0,0,3,3,3,0,0,0,0,0,0,0,1,1,0,0,4,
4,0,0,0,0,0,0,0,3,3,3,3,3,0,0,0,0,0,0,1,0,0,0,4,
4,0,0,0,0,0,0,0,3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,4,
4,0,0,4,0,0,0,0,0,3,3,3,0,0,0,0,4,0,0,0,0,0,0,4,
4,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,4,
4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
4,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
4,0,1,1,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,4,
4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,4,0,4,
4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,4,
4,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
4,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
4,0,0,0,0,0,0,0,0,0,0,0,0,3,3,3,0,0,0,0,0,0,0,4,
4,0,0,0,0,0,0,0,0,0,0,0,3,3,3,3,3,0,0,0,0,0,0,4,
4,0,0,0,0,0,0,0,0,0,0,0,0,3,3,3,0,0,0,5,0,0,0,4,
4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
]
}
export function 맵타일들(맵아이디: string) -> Array<int> {
if 맵아이디 == "deep" { 심층타일들() } else { 연못타일들() }
}
// 워프는 격자에 특수 타일을 박지 않고 엔티티처럼 좌표로 둡니다. 그 칸을 밟으면 목적 맵의 목적 좌표로 옮깁니다.
export record 워프 { x: int, y: int, 목적맵: string, 목적x: int, 목적y: int }
export function 워프목록(맵아이디: string) -> Array<워프> {
if 맵아이디 == "deep" {
[워프 { x: 3, y: 3, 목적맵: "pond", 목적x: 12, 목적y: 17 }]
} else {
[워프 { x: 12, y: 18, 목적맵: "deep", 목적x: 3, 목적y: 4 }]
}
}
export function 워프에서(맵아이디: string, x: int, y: int) -> Option<워프> {
let 일치 = 워프목록(맵아이디).filter(후보 => 후보.x == x && 후보.y == y)
if 일치.length > 0 { Some(일치[0]) } else { None }
}
// 4 와 표 밖의 값은 모두 나무로 읽어 지나갈 수 없게 합니다.
function 타일읽기(값: int) -> 타일종류 {
match 값 {
case 0 => 타일_풀
case 1 => 타일_키큰풀
case 2 => 타일_길
case 3 => 타일_물
case 5 => 타일_꽃
case _ => 타일_나무
}
}
// 격자 밖을 나무 벽으로 답해 카메라 가두기와 이동 경계가 따로 범위를 검사하지 않아도 됩니다.
export function 타일에서(타일들: Array<int>, x: int, y: int) -> 타일종류 {
if x < 0 || y < 0 || x >= 맵너비 || y >= 맵높이 { return 타일_나무 }
타일읽기(타일들[y * 맵너비 + x])
}
// ===== data/palettes.tpz =====
// 연못 화면을 칠하는 네 색 팔레트를 둡니다.
// 출력은 깊은 물과 그림자, 이끼, 밝은 풀, 배경 모래 순으로 어두운 색부터 16진 색 넷을 쉼표로 이은 문자열이며 그리기 목록의 PAL 줄에 그대로 들어갑니다.
// 상수라 늘 같은 값을 돌려줍니다.
// 픽셀을 칠하지 않습니다. 페이지의 셸이 타일과 스프라이트의 점마다 이 넷 중 하나를 고릅니다.
// Pond palette: four hex colors, dark to light, for the draw list PAL line.
export function 연못팔레트() -> string {
"#1B3A2E,#3E6B4F,#8FB97A,#E8E4C9"
}
// ===== data/species.tpz =====
// 연못과 심층에 사는 오리지널 미생물 여덟 종과 플레이어의 시작종을 둡니다.
// 종마다 배틀 스프라이트 번호, 야생 레벨대, 레벨로 자라는 기본 스탯, data.types 의 속성 코드, 저장에 남는 기술 아이디 넷(0 은 빈 칸)이 있습니다.
// 상수 표라 같은 아이디는 늘 같은 종입니다.
// 개체를 만들거나 성장시키지 않습니다. 개체 모듈과 진입점이 맡습니다.
// Species table: eight original microbes with level bands, base stats, type and move ids.
export record 종 {
아이디: int,
이름: string,
스프라이트: int,
최소레벨: int,
최대레벨: int,
기본체력: int,
기본공격: int,
기본방어: int,
기본속도: int,
속성: int,
기술1: int,
기술2: int,
기술3: int,
기술4: int,
}
// 시조 아메바는 새 게임의 파티 첫 자리에만 들어가고 맵에는 나오지 않습니다.
export function 시작종아이디() -> int {
4
}
// 1~4 는 연못, 5~7 은 레벨대가 높은 심층 종이고 8 심연군주는 심층 가장 깊은 곳의 하나뿐인 보스입니다.
// 스프라이트 번호는 페이지 셸의 종별 색표와 맞물립니다.
export function 종목록() -> Array<종> {
[
종 { 아이디: 1, 이름: "또랑이", 스프라이트: 1, 최소레벨: 2, 최대레벨: 4, 기본체력: 16, 기본공격: 7, 기본방어: 6, 기본속도: 5, 속성: 0, 기술1: 1, 기술2: 2, 기술3: 0, 기술4: 0 },
종 { 아이디: 2, 이름: "빛이끼", 스프라이트: 2, 최소레벨: 3, 최대레벨: 5, 기본체력: 18, 기본공격: 6, 기본방어: 7, 기본속도: 4, 속성: 1, 기술1: 1, 기술2: 3, 기술3: 0, 기술4: 0 },
종 { 아이디: 3, 이름: "가시포자", 스프라이트: 3, 최소레벨: 4, 최대레벨: 6, 기본체력: 14, 기본공격: 8, 기본방어: 5, 기본속도: 7, 속성: 2, 기술1: 1, 기술2: 4, 기술3: 8, 기술4: 0 },
종 { 아이디: 4, 이름: "시조 아메바", 스프라이트: 4, 최소레벨: 5, 최대레벨: 5, 기본체력: 20, 기본공격: 8, 기본방어: 6, 기본속도: 6, 속성: 0, 기술1: 1, 기술2: 2, 기술3: 6, 기술4: 0 },
종 { 아이디: 5, 이름: "심해포자", 스프라이트: 5, 최소레벨: 8, 최대레벨: 11, 기본체력: 24, 기본공격: 9, 기본방어: 9, 기본속도: 5, 속성: 1, 기술1: 1, 기술2: 3, 기술3: 8, 기술4: 0 },
종 { 아이디: 6, 이름: "발광충", 스프라이트: 6, 최소레벨: 9, 최대레벨: 12, 기본체력: 19, 기본공격: 11, 기본방어: 6, 기본속도: 9, 속성: 3, 기술1: 1, 기술2: 4, 기술3: 2, 기술4: 0 },
종 { 아이디: 7, 이름: "암각체", 스프라이트: 7, 최소레벨: 10, 최대레벨: 13, 기본체력: 28, 기본공격: 8, 기본방어: 12, 기본속도: 3, 속성: 2, 기술1: 1, 기술2: 2, 기술3: 8, 기술4: 0 },
종 { 아이디: 8, 이름: "심연군주", 스프라이트: 8, 최소레벨: 15, 최대레벨: 15, 기본체력: 44, 기본공격: 13, 기본방어: 11, 기본속도: 8, 속성: 1, 기술1: 1, 기술2: 3, 기술3: 4, 기술4: 8 },
]
}
// 없는 아이디는 첫 종으로 돌려 조작된 저장 값에서도 종 하나가 나오게 합니다.
export function 종찾기(아이디: int) -> 종 {
let 목록 = 종목록()
let 일치 = 목록.filter(항목 => 항목.아이디 == 아이디)
if 일치.length > 0 { 일치[0] } else { 목록[0] }
}
// ===== data/entities.tpz =====
// 맵 위에서 마주 서서 A 로 상호작용하는 대상을 둡니다. 무작위 조우 대신 보이는 대상과 맞붙습니다.
// 대상은 아이디, 타일 좌표 x y, 종류이고 종류는 야생(종 아이디, 레벨) 또는 인물(대사)입니다. 칸으로 찾으면 대상이나 빈 칸 표시를 돌려줍니다.
// 배치가 상수라 같은 맵, 같은 칸, 같은 처치 목록이면 늘 같은 대상입니다.
// 처치 목록을 바꾸지 않습니다. 한 칸에 대상은 하나뿐이고 물, 나무, 시작 칸 위에는 두지 않습니다.
// Map entities: wild microbes and talking characters placed on tiles, looked up by position.
export enum 엔티티종류 {
없음,
야생(int, int),
인물(string)
}
export record 엔티티 {
아이디: int,
x: int,
y: int,
종류: 엔티티종류,
}
// 그리기 목록의 ENT 토큰이 읽는 정수입니다. 페이지 셸과 맞물려 있어 값을 바꾸지 않습니다.
export function 종류코드(대상: 엔티티) -> int {
match 대상.종류 {
case 없음 => -1
case 야생(_, _) => 0
case 인물(_) => 1
}
}
// 종류 필드만 넘기면 다른 모듈에서 타입이 맞지 않아 엔티티를 통째로 받습니다. 토파즈 과제 '다른 모듈 열거형 값을 그 모듈 함수에 넘기기' 의 우회입니다.
export function 야생인가(대상: 엔티티) -> bool {
match 대상.종류 {
case 야생(_, _) => true
case 없음 | 인물(_) => false
}
}
export function 인물인가(대상: 엔티티) -> bool {
match 대상.종류 {
case 인물(_) => true
case 없음 | 야생(_, _) => false
}
}
function 빈칸인가(종류: 엔티티종류) -> bool {
match 종류 {
case 없음 => true
case 야생(_, _) | 인물(_) => false
}
}
export function 없는엔티티() -> 엔티티 {
엔티티 { 아이디: 0, x: -1, y: -1, 종류: 엔티티종류.없음 }
}
// 대사는 그리기 목록의 TXT 토큰으로 나가므로 파이프 문자를 넣지 않습니다.
// 연못은 시작 칸 (3,5) 에서 아래를 보고 시작하므로 바로 아래에 약한 야생을 두어 A 한 번에 첫 배틀이 열립니다.
// 심층은 아이디를 10 부터 써서 맵이 함께 쓰는 처치 목록에서 연못과 겹치지 않고, 입구 (3,4) 에서 멀수록 레벨이 오릅니다.
// 가장 가까운 Lv7 은 덜 자란 파티도 이길 수 있어 진행이 막히지 않습니다.
export function 엔티티목록(맵아이디: string) -> Array<엔티티> {
if 맵아이디 == "deep" {
[
엔티티 { 아이디: 10, x: 5, y: 5, 종류: 엔티티종류.인물("심층입니다. A를 누르면 쉬어 회복합니다. 가장 깊은 곳엔 심연군주가 있습니다 — 충분히 키운 계통이라야 마주할 수 있습니다.") },
엔티티 { 아이디: 11, x: 19, y: 3, 종류: 엔티티종류.야생(5, 11) },
엔티티 { 아이디: 12, x: 2, y: 9, 종류: 엔티티종류.야생(6, 7) },
엔티티 { 아이디: 13, x: 7, y: 14, 종류: 엔티티종류.야생(7, 9) },
엔티티 { 아이디: 14, x: 11, y: 19, 종류: 엔티티종류.야생(8, 15) },
]
} else {
[
엔티티 { 아이디: 1, x: 3, y: 6, 종류: 엔티티종류.야생(1, 3) },
엔티티 { 아이디: 2, x: 5, y: 5, 종류: 엔티티종류.인물("여기서 A를 누르면 동료들이 쉬어 회복합니다. 마주 선 미생물에게 A를 누르면 맞붙습니다.") },
엔티티 { 아이디: 3, x: 6, y: 6, 종류: 엔티티종류.야생(2, 4) },
엔티티 { 아이디: 4, x: 9, y: 6, 종류: 엔티티종류.야생(3, 6) },
엔티티 { 아이디: 5, x: 8, y: 13, 종류: 엔티티종류.야생(1, 5) },
엔티티 { 아이디: 6, x: 2, y: 16, 종류: 엔티티종류.야생(2, 6) },
엔티티 { 아이디: 7, x: 11, y: 17, 종류: 엔티티종류.야생(3, 8) },
엔티티 { 아이디: 8, x: 20, y: 5, 종류: 엔티티종류.야생(1, 7) },
엔티티 { 아이디: 9, x: 13, y: 14, 종류: 엔티티종류.인물("남쪽 통로로 내려가면 더 깊은 심층입니다. 키운 동료가 충분히 자라면 천천히, 그리고 또 진화하며 계통이 깊어집니다.") },
]
}
}
export function 엔티티에서(맵아이디: string, x: int, y: int) -> 엔티티 {
let 일치 = 엔티티목록(맵아이디).filter(대상 => 대상.x == x && 대상.y == y)
if 일치.length > 0 { 일치[0] } else { 없는엔티티() }
}
export function 처치된것인가(처치된것들: Array<int>, 아이디: int) -> bool {
아이디 in 처치된것들
}
// 이동, 상호작용, 그리기가 모두 이 함수로 칸을 보므로 잡거나 이긴 야생은 맵에서 사라집니다.
export function 활성엔티티에서(맵아이디: string, x: int, y: int, 처치된것들: Array<int>) -> 엔티티 {
let 대상 = 엔티티에서(맵아이디, x, y)
if 처치된것인가(처치된것들, 대상.아이디) { 없는엔티티() } else { 대상 }
}
export function 활성엔티티칸인가(맵아이디: string, x: int, y: int, 처치된것들: Array<int>) -> bool {
!빈칸인가(활성엔티티에서(맵아이디, x, y, 처치된것들).종류)
}
// ===== data/types.tpz =====
// 연못 미생물의 네 속성과 공격 상성 표를 둡니다.
// 속성 코드는 0 점액, 1 광합성, 2 포자, 3 결정입니다. 효과배율2 는 실제 배율의 두 배를 정수로 돌려주어 4 는 두 배, 2 는 보통, 1 은 절반입니다.
// 상수 표라 같은 짝은 늘 같은 배율이고, 실수를 쓰지 않아 피해 계산이 엔진마다 같습니다.
// 피해를 계산하지 않습니다. 배틀 모듈이 이 배율로 정수 나눗셈을 합니다.
// Pond microbe types and the x2-scaled integer effectiveness chart.
export function 속성수() -> int {
4
}
// 표 밖 코드는 무속성입니다. 기술의 무속성 코드 99 도 여기에 듭니다.
export function 속성이름(속성: int) -> string {
match 속성 {
case 0 => "점액"
case 1 => "광합성"
case 2 => "포자"
case 3 => "결정"
case _ => "무속성"
}
}
function 상성배율(방어속성: int, 강한상대: int, 약한상대: int) -> int {
if 방어속성 == 강한상대 { 4 } else if 방어속성 == 약한상대 { 1 } else { 2 }
}
// 점액, 광합성, 포자가 가위바위보처럼 돌고 결정은 점액에 강하고 광합성에 약합니다. 표에 없는 짝은 보통입니다.
export function 효과배율2(공격속성: int, 방어속성: int) -> int {
match 공격속성 {
case 0 => 상성배율(방어속성, 1, 2)
case 1 => 상성배율(방어속성, 2, 3)
case 2 => 상성배율(방어속성, 0, 1)
case 3 => 상성배율(방어속성, 0, 2)
case _ => 2
}
}
// ===== data/items.tpz =====
// 야생 미생물을 가두는 포자 캡슐인 스포어볼의 시작 재고와 등급을 둡니다.
// 둘 다 인자 없는 정수 상수입니다. 시작 재고는 새 게임에서 한 번 지급합니다.
// 상수라 늘 같은 값을 돌려줍니다.
// 재고를 세거나 줄이지 않습니다. 상태 모듈과 진입점이 맡습니다.
// Spore-ball item data: starting stock and ball grade.
export function 시작스포어볼() -> int {
8
}
// 등급 0 은 기본 볼이며 포획 보너스가 없습니다.
export function 스포어볼등급() -> int {
0
}