@istarry/spoon-companion 0.0.0-stage → 0.6.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +22 -0
- package/README.md +55 -2
- package/build.mjs +56 -0
- package/cordis.patch.yml +27 -0
- package/icon.svg +31 -0
- package/lib/appraise.js +277 -0
- package/lib/asr-route.js +118 -0
- package/lib/asr.js +215 -0
- package/lib/catalog.js +378 -0
- package/lib/client.js +1592 -0
- package/lib/prompt.js +179 -0
- package/lib/react.js +414 -0
- package/lib/state.js +870 -0
- package/lib/voice.js +830 -0
- package/locale/en.json +6 -0
- package/locale/zh.json +6 -0
- package/package.json +85 -4
- package/plugin.js +956 -0
package/lib/state.js
ADDED
|
@@ -0,0 +1,870 @@
|
|
|
1
|
+
// 心情账本 v2 —— 三层结构 + 人类情绪动力学。
|
|
2
|
+
//
|
|
3
|
+
// 性格 traits : 周~月的尺度。大五 + 自尊,基线是「她本来的样子」,经历只微调(±12 封顶)。
|
|
4
|
+
// 心情 mood : 几小时的弥散底色。由 core(愉快度/精力)+ 最近 8 小时的情绪滚动窗口合成。
|
|
5
|
+
// 情绪 emotion : 几分钟~几小时,有对象、有起因。由评价引擎推出来(lib/appraise.js)。
|
|
6
|
+
//
|
|
7
|
+
// 这一版把「人味」做在动力学上,而不是做在词表上:
|
|
8
|
+
// · 半衰期 —— 情绪会自己淡,不用谁哄;敏感的人淡得慢(性格调制)。
|
|
9
|
+
// · 情绪惯性 —— 正在气头上,新情绪得够强才顶得动(不是一句话就换脸)。
|
|
10
|
+
// · 习惯化 —— 同样的话反复说,效果越来越弱(第五次叫胖就没那么气了)。
|
|
11
|
+
// · 消极偏差 —— 坏事的推力比好事大(人类就是这么不公平)。
|
|
12
|
+
// · 反刍 —— 没消化掉的委屈/难过,过一阵子会自己冒出来一次。
|
|
13
|
+
// · 心情修复 —— 底色差久了,她会自己找点乐子(刷点好笑的、吃点东西)。
|
|
14
|
+
// · 情绪分享冲动 —— 情绪够强时,她「想跟人说这件事」(会写进提示词)。
|
|
15
|
+
// · 峰终记忆 —— 够强的情绪会留下记忆点,之后几天还会被想起来。
|
|
16
|
+
// · 深夜复盘 —— 每天一次,把这一天过一遍,写进日记,顺手放下一点。
|
|
17
|
+
// · 生理驱动 —— 饿、困、社交需求会随时间涨,涨上来就影响评价(饿的时候更容易烦)。
|
|
18
|
+
//
|
|
19
|
+
// 账本落盘是原子的(临时文件 + rename),坏了就重开一份,不让插件把宿主拖死。
|
|
20
|
+
|
|
21
|
+
import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
|
|
22
|
+
import { join } from 'node:path'
|
|
23
|
+
import { FADE_OUT, TRAITS, emotionOf, escalateOf, tierOf } from './catalog.js'
|
|
24
|
+
|
|
25
|
+
export const STATE_VERSION = 2
|
|
26
|
+
|
|
27
|
+
const HOUR = 3_600_000
|
|
28
|
+
const DAY = 24 * HOUR
|
|
29
|
+
|
|
30
|
+
const clamp = (value, lo, hi) => Math.max(lo, Math.min(hi, value))
|
|
31
|
+
const clamp01 = (value) => clamp(Number(value) || 0, 0, 1)
|
|
32
|
+
const round = (value, digits = 2) => Number((Number(value) || 0).toFixed(digits))
|
|
33
|
+
|
|
34
|
+
/** 作息:每档给底色基线和困意。她是有生物钟的,不是 24 小时同一个人 */
|
|
35
|
+
export const PHASES = [
|
|
36
|
+
{ from: 0, to: 6, label: '后半夜', valence: -8, energy: 20, sleepy: 0.9 },
|
|
37
|
+
{ from: 6, to: 9, label: '清早', valence: -5, energy: 42, sleepy: 0.55, grumpy: true },
|
|
38
|
+
{ from: 9, to: 11, label: '上午', valence: 4, energy: 70, sleepy: 0.15 },
|
|
39
|
+
{ from: 11, to: 14, label: '中午', valence: 6, energy: 64, sleepy: 0.2 },
|
|
40
|
+
{ from: 14, to: 17, label: '下午', valence: 2, energy: 55, sleepy: 0.3 },
|
|
41
|
+
{ from: 17, to: 19, label: '傍晚', valence: 5, energy: 60, sleepy: 0.25 },
|
|
42
|
+
{ from: 19, to: 22, label: '晚上', valence: 7, energy: 66, sleepy: 0.3 },
|
|
43
|
+
{ from: 22, to: 24, label: '深夜', valence: -2, energy: 38, sleepy: 0.65, sentimental: true },
|
|
44
|
+
]
|
|
45
|
+
|
|
46
|
+
/** 饭点:过了没吃,饿意就涨 */
|
|
47
|
+
const MEAL_WINDOWS = [
|
|
48
|
+
{ from: 7, to: 9, label: '早饭' },
|
|
49
|
+
{ from: 11, to: 13, label: '午饭' },
|
|
50
|
+
{ from: 17, to: 19, label: '晚饭' },
|
|
51
|
+
]
|
|
52
|
+
|
|
53
|
+
/** 睡觉时段:这段时间她基本在睡 */
|
|
54
|
+
const SLEEP = { from: 1, to: 7 }
|
|
55
|
+
|
|
56
|
+
export function circadian(date = new Date()) {
|
|
57
|
+
const hour = date.getHours() + date.getMinutes() / 60
|
|
58
|
+
const phase = PHASES.find((p) => hour >= p.from && hour < p.to) ?? PHASES[0]
|
|
59
|
+
return { ...phase, hour }
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
/** 今天该吃的饭点过了没(用来推饿意) */
|
|
63
|
+
function mealState(now) {
|
|
64
|
+
const date = new Date(now)
|
|
65
|
+
const hour = date.getHours() + date.getMinutes() / 60
|
|
66
|
+
let missed = 0
|
|
67
|
+
let current = null
|
|
68
|
+
for (const meal of MEAL_WINDOWS) {
|
|
69
|
+
if (hour >= meal.to) missed += 1
|
|
70
|
+
else if (hour >= meal.from) current = meal
|
|
71
|
+
}
|
|
72
|
+
return { missed, current, hour }
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
export function emptyState() {
|
|
76
|
+
return {
|
|
77
|
+
version: STATE_VERSION,
|
|
78
|
+
traits: Object.fromEntries(TRAITS.map((trait) => [trait.key, trait.base])),
|
|
79
|
+
traitBase: Object.fromEntries(TRAITS.map((trait) => [trait.key, trait.base])),
|
|
80
|
+
emotion: { key: 'calm', intensity: 0, why: '', source: 'time', target: '', dims: null, startedAt: 0, updatedAt: 0, peak: 0, ruminated: false },
|
|
81
|
+
core: { valence: 0, energy: 55, updatedAt: 0 },
|
|
82
|
+
drives: { hunger: 0.1, fatigue: 0.2, social: 0.15, lastMealAt: 0, lastSocialAt: 0, lastSleepAt: 0 },
|
|
83
|
+
affect: [],
|
|
84
|
+
habits: {},
|
|
85
|
+
memories: [],
|
|
86
|
+
rumination: [],
|
|
87
|
+
urges: null,
|
|
88
|
+
convs: {},
|
|
89
|
+
people: {},
|
|
90
|
+
diary: [],
|
|
91
|
+
seen: {},
|
|
92
|
+
flags: {},
|
|
93
|
+
stats: { impulses: 0, feels: 0, lifeEvents: 0, lastLifeAt: 0, reviews: 0, relationsAt: 0, traitShifts: 0, soothed: 0, ruminated: 0, repairs: 0 },
|
|
94
|
+
lastReviewDay: '',
|
|
95
|
+
}
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
/** v1 → v2:老账本不能丢(她已经在群里活过一阵子了) */
|
|
99
|
+
export function migrate(raw) {
|
|
100
|
+
if (!raw || typeof raw !== 'object') return emptyState()
|
|
101
|
+
if (raw.version === STATE_VERSION) return { ...emptyState(), ...raw, traits: { ...emptyState().traits, ...(raw.traits ?? {}) } }
|
|
102
|
+
const state = emptyState()
|
|
103
|
+
if (raw.version === 1 || raw.mood) {
|
|
104
|
+
const mood = raw.mood ?? {}
|
|
105
|
+
const key = mood.key && emotionOf(mood.key).key !== 'calm' ? mood.key : 'calm'
|
|
106
|
+
state.emotion = {
|
|
107
|
+
key,
|
|
108
|
+
intensity: Number(mood.intensity) || 0,
|
|
109
|
+
why: String(mood.why ?? ''),
|
|
110
|
+
source: String(mood.source ?? 'time'),
|
|
111
|
+
target: '',
|
|
112
|
+
dims: null,
|
|
113
|
+
startedAt: Number(mood.startedAt) || 0,
|
|
114
|
+
updatedAt: Number(mood.updatedAt) || Date.now(),
|
|
115
|
+
peak: Number(mood.intensity) || 0,
|
|
116
|
+
ruminated: false,
|
|
117
|
+
}
|
|
118
|
+
state.core = { valence: Number(raw.core?.valence) || 0, energy: Number(raw.core?.energy) || 55, updatedAt: Number(raw.core?.updatedAt) || 0 }
|
|
119
|
+
for (const [key2, row] of Object.entries(raw.convs ?? {})) {
|
|
120
|
+
state.convs[key2] = { first: row.first ?? row.lastAt ?? 0, lastAt: row.lastAt ?? 0, count: row.count ?? 0, valence: row.valence ?? 0, label: row.label ?? '' }
|
|
121
|
+
}
|
|
122
|
+
for (const [key2, row] of Object.entries(raw.people ?? {})) {
|
|
123
|
+
const warmth = Number(row.warmth) || 0
|
|
124
|
+
state.people[key2] = {
|
|
125
|
+
name: row.name ?? key2,
|
|
126
|
+
warmth,
|
|
127
|
+
closeness: clamp(30 + warmth * 0.5, 0, 100),
|
|
128
|
+
trust: clamp(50 + warmth * 0.4, 0, 100),
|
|
129
|
+
bank: Number(row.bank) || 0,
|
|
130
|
+
notes: Array.isArray(row.notes) ? row.notes.slice(-6) : [],
|
|
131
|
+
lastAt: row.lastAt ?? 0,
|
|
132
|
+
count: row.count ?? 0,
|
|
133
|
+
}
|
|
134
|
+
}
|
|
135
|
+
// 老日记行的字段名是 mood/why,新的是 key/text —— 统一一遍,不然渲染出来是 undefined
|
|
136
|
+
state.diary = Array.isArray(raw.diary)
|
|
137
|
+
? raw.diary.map((row) => {
|
|
138
|
+
const text = String(row.text ?? row.why ?? '').slice(0, 120)
|
|
139
|
+
return {
|
|
140
|
+
...row,
|
|
141
|
+
kind: row.kind ?? 'feel',
|
|
142
|
+
key: row.key ?? row.mood ?? 'calm',
|
|
143
|
+
text,
|
|
144
|
+
why: String(row.why ?? row.text ?? '').slice(0, 120),
|
|
145
|
+
intensity: Math.round(Number(row.intensity) || 0),
|
|
146
|
+
person: row.person ?? row.who ?? '',
|
|
147
|
+
rule: row.rule ?? '',
|
|
148
|
+
}
|
|
149
|
+
})
|
|
150
|
+
: []
|
|
151
|
+
state.seen = raw.seen ?? {}
|
|
152
|
+
state.stats = { ...state.stats, ...(raw.stats ?? {}) }
|
|
153
|
+
}
|
|
154
|
+
return state
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
export function loadState(dir) {
|
|
158
|
+
try {
|
|
159
|
+
const file = join(dir, 'state.json')
|
|
160
|
+
if (!existsSync(file)) return emptyState()
|
|
161
|
+
return migrate(JSON.parse(readFileSync(file, 'utf8')))
|
|
162
|
+
} catch {
|
|
163
|
+
return emptyState()
|
|
164
|
+
}
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
export function saveState(dir, state) {
|
|
168
|
+
try {
|
|
169
|
+
mkdirSync(dir, { recursive: true })
|
|
170
|
+
const file = join(dir, 'state.json')
|
|
171
|
+
const tmp = `${file}.${process.pid}.tmp`
|
|
172
|
+
writeFileSync(tmp, JSON.stringify(state))
|
|
173
|
+
renameSync(tmp, file)
|
|
174
|
+
return true
|
|
175
|
+
} catch {
|
|
176
|
+
return false
|
|
177
|
+
}
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
/** 账本别无限长大:翻旧账没用,记忆点留最近 12 条 */
|
|
181
|
+
export function pruneState(state) {
|
|
182
|
+
const now = Date.now()
|
|
183
|
+
state.affect = (state.affect ?? []).filter((row) => now - row.at < 10 * HOUR).slice(-160)
|
|
184
|
+
state.memories = (state.memories ?? []).filter((row) => now - row.at < 14 * DAY).slice(-12)
|
|
185
|
+
state.rumination = (state.rumination ?? []).filter((row) => row.at > now - 6 * HOUR).slice(-6)
|
|
186
|
+
state.diary = (state.diary ?? []).slice(-120)
|
|
187
|
+
// 危机标记两小时后自然过期:那件事不能一直挂在提示词里
|
|
188
|
+
if (state.flags?.crisis && now - state.flags.crisis.at > 6 * HOUR) delete state.flags.crisis
|
|
189
|
+
for (const [key, row] of Object.entries(state.habits ?? {})) {
|
|
190
|
+
if (now - (row.lastAt ?? 0) > DAY) delete state.habits[key]
|
|
191
|
+
}
|
|
192
|
+
for (const [key, row] of Object.entries(state.convs ?? {})) {
|
|
193
|
+
if (now - (row.lastAt ?? 0) > 60 * DAY) delete state.convs[key]
|
|
194
|
+
}
|
|
195
|
+
for (const [key, row] of Object.entries(state.people ?? {})) {
|
|
196
|
+
if (now - (row.lastAt ?? 0) > 90 * DAY) delete state.people[key]
|
|
197
|
+
}
|
|
198
|
+
for (const [key, seq] of Object.entries(state.seen ?? {})) {
|
|
199
|
+
if (!Number.isFinite(Number(seq))) delete state.seen[key]
|
|
200
|
+
}
|
|
201
|
+
return state
|
|
202
|
+
}
|
|
203
|
+
|
|
204
|
+
// ── 动力学 ────────────────────────────────────────────────────────────────
|
|
205
|
+
|
|
206
|
+
/**
|
|
207
|
+
* 情绪的半衰期:敏感的人负性情绪淡得慢,外向的人正性情绪淡得快;
|
|
208
|
+
* 同一种情绪,越强留得越久(强度按 0.75 + 强度/400 折)。
|
|
209
|
+
*/
|
|
210
|
+
export function halfLifeOf(emo, traits, intensity = 0) {
|
|
211
|
+
const base = Number(emo?.halfLifeMin) || 60
|
|
212
|
+
const neuro = (traits?.neuroticism ?? 60) / 100
|
|
213
|
+
const extra = (traits?.extraversion ?? 58) / 100
|
|
214
|
+
const strong = 0.75 + clamp(Number(intensity) || 0, 0, 100) / 400
|
|
215
|
+
if (emo?.valence < -0.2) return base * (0.75 + neuro * 0.6) * strong
|
|
216
|
+
if (emo?.valence > 0.2) return base * (1.15 - extra * 0.25) * strong
|
|
217
|
+
return base * strong
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
/**
|
|
221
|
+
* 衰减曲线:双指数 —— 一截快、一截慢。
|
|
222
|
+
*
|
|
223
|
+
* 纯指数要么「一下就没了」要么「赖着不走」,真实情绪是**先快后慢**:头一会儿掉得明显,
|
|
224
|
+
* 然后拖着一条长尾(余怒未消、想起还会闷一下,都是这条尾巴)。
|
|
225
|
+
* 快项 0.6×半衰期占 72%,慢项 3×半衰期占 28%。
|
|
226
|
+
* [设计值] 形状是工程取舍,不是实测拟合值 —— 别在注释里写成「研究证明」。
|
|
227
|
+
*/
|
|
228
|
+
export const SLOW_TAIL = 0.28
|
|
229
|
+
export function remainingFraction(elapsedMin, halfLifeMin) {
|
|
230
|
+
const hl = Math.max(1, Number(halfLifeMin) || 60)
|
|
231
|
+
const t = Math.max(0, Number(elapsedMin) || 0)
|
|
232
|
+
const fast = 0.5 ** (t / (hl * 0.6))
|
|
233
|
+
const slow = 0.5 ** (t / (hl * 3))
|
|
234
|
+
return (1 - SLOW_TAIL) * fast + SLOW_TAIL * slow
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
/** 底色回作息基线 */
|
|
238
|
+
function relaxCore(state, now) {
|
|
239
|
+
const core = state.core
|
|
240
|
+
const base = circadian(new Date(now))
|
|
241
|
+
const last = Number(core.updatedAt)
|
|
242
|
+
if (!last) {
|
|
243
|
+
core.updatedAt = now
|
|
244
|
+
return false
|
|
245
|
+
}
|
|
246
|
+
const dt = Math.max(0, now - last) / HOUR
|
|
247
|
+
if (dt <= 0) return false
|
|
248
|
+
// τ=5 小时:心情层要有记忆 —— 底色半天里都还是「今天有点闷」,不是一觉睡醒就清零
|
|
249
|
+
const k = 1 - Math.exp(-dt / 5)
|
|
250
|
+
core.valence += (base.valence - core.valence) * k
|
|
251
|
+
core.energy += (base.energy - core.energy) * k
|
|
252
|
+
// 软天花板:越极端往回拉得越快 —— 人不会一直待在 -90,也不会一直飘在 +90
|
|
253
|
+
for (const key of ['valence', 'energy']) {
|
|
254
|
+
const over = Math.abs(core[key]) - 70
|
|
255
|
+
if (over > 0) core[key] = Math.sign(core[key]) * (70 + over * 0.9)
|
|
256
|
+
}
|
|
257
|
+
core.updatedAt = now
|
|
258
|
+
return true
|
|
259
|
+
}
|
|
260
|
+
|
|
261
|
+
/** 生理驱动:饿、困、社交需求 —— 它们自己会涨 */
|
|
262
|
+
function tickDrives(state, now) {
|
|
263
|
+
const drives = state.drives
|
|
264
|
+
const last = Number(state.core.updatedAt) || now
|
|
265
|
+
const dt = Math.max(0, Math.min(now - last, 6 * HOUR)) / HOUR
|
|
266
|
+
if (dt <= 0) return
|
|
267
|
+
const { missed, hour } = mealState(now)
|
|
268
|
+
const base = circadian(new Date(now))
|
|
269
|
+
const awake = !(hour >= SLEEP.from && hour < SLEEP.to)
|
|
270
|
+
// 饿:过了饭点没吃就涨,吃饭会重置
|
|
271
|
+
if (awake) drives.hunger = clamp01(drives.hunger + dt * (0.06 + missed * 0.07))
|
|
272
|
+
// 困:按作息涨,睡一觉就重置
|
|
273
|
+
if (awake) drives.fatigue = clamp01(drives.fatigue + dt * (0.05 + base.sleepy * 0.12))
|
|
274
|
+
else drives.fatigue = clamp01(drives.fatigue + dt * 0.02)
|
|
275
|
+
// 社交:两个小时没人理,就会想找人
|
|
276
|
+
const idle = (now - (drives.lastSocialAt || now)) / HOUR
|
|
277
|
+
if (awake && idle > 2) drives.social = clamp01(drives.social + dt * 0.12)
|
|
278
|
+
}
|
|
279
|
+
|
|
280
|
+
/**
|
|
281
|
+
* 情绪自己淡下去。三件事同时发生:
|
|
282
|
+
* 1. 双指数衰减(先快后慢,留一条尾巴);
|
|
283
|
+
* 2. 强情绪(峰值 > 50)淡到一半时会「续命」—— 每 10 分钟有 8% 的概率回补一点,
|
|
284
|
+
* 最多 3 次。这就是「越想越气」,纯指数衰减是长不出来的;
|
|
285
|
+
* 3. 真淡没了,负性情绪还可能过几小时自己冒出来(反刍)。
|
|
286
|
+
*/
|
|
287
|
+
function decayEmotion(state, now, traits) {
|
|
288
|
+
const emo = state.emotion
|
|
289
|
+
if (!emo.key || emo.key === 'calm') return false
|
|
290
|
+
const last = Number(emo.updatedAt) || now
|
|
291
|
+
const elapsedMin = Math.max(0, now - last) / 60_000
|
|
292
|
+
if (elapsedMin <= 0) return false
|
|
293
|
+
const emoDef = emotionOf(emo.key)
|
|
294
|
+
const halfLife = halfLifeOf(emoDef, traits, emo.intensity)
|
|
295
|
+
emo.intensity *= remainingFraction(elapsedMin, halfLife)
|
|
296
|
+
emo.updatedAt = now
|
|
297
|
+
|
|
298
|
+
// 掩饰是要花力气的:心里憋着还要正常说话,人会累,也更容易烦
|
|
299
|
+
if (emo.hidden && emo.intensity > FADE_OUT) {
|
|
300
|
+
const cost = (elapsedMin / 60) * 0.9
|
|
301
|
+
state.core.energy = clamp(state.core.energy - cost, 0, 100)
|
|
302
|
+
state.stats.maskedMinutes = (state.stats.maskedMinutes ?? 0) + elapsedMin
|
|
303
|
+
}
|
|
304
|
+
|
|
305
|
+
// 续命:还没淡透、又够强,就再翻上来几次
|
|
306
|
+
const revives = emo.revives ?? 0
|
|
307
|
+
if (emo.peak >= 50 && emo.intensity > FADE_OUT && emo.intensity <= emo.peak * 0.55 && revives < 3 && !emo.revivePending) {
|
|
308
|
+
emo.revivePending = true
|
|
309
|
+
state.rumination.push({
|
|
310
|
+
at: now + (8 + Math.random() * 12) * 60_000,
|
|
311
|
+
key: emo.key,
|
|
312
|
+
intensity: Math.round(clamp(emo.peak * 0.08, 4, 10)),
|
|
313
|
+
why: emo.why,
|
|
314
|
+
target: emo.target ?? '',
|
|
315
|
+
revive: true,
|
|
316
|
+
left: 3 - revives,
|
|
317
|
+
})
|
|
318
|
+
}
|
|
319
|
+
|
|
320
|
+
if (emo.intensity <= FADE_OUT) {
|
|
321
|
+
// 没消化掉的负性情绪:过一阵子自己冒出来
|
|
322
|
+
if (emoDef.valence < -0.2 && emo.peak >= 25 && emo.why && !emo.ruminated) {
|
|
323
|
+
const neuro = (traits.neuroticism ?? 60) / 100
|
|
324
|
+
const chance = 0.15 + neuro * 0.3
|
|
325
|
+
if (Math.random() < chance) {
|
|
326
|
+
state.rumination.push({
|
|
327
|
+
at: now + (0.5 + Math.random() * 3.5) * HOUR,
|
|
328
|
+
key: emo.key,
|
|
329
|
+
intensity: Math.round(clamp(emo.peak * 0.45, 12, 45)),
|
|
330
|
+
why: emo.why,
|
|
331
|
+
target: emo.target ?? '',
|
|
332
|
+
})
|
|
333
|
+
}
|
|
334
|
+
}
|
|
335
|
+
state.emotion = { ...emptyState().emotion, updatedAt: now }
|
|
336
|
+
return true
|
|
337
|
+
}
|
|
338
|
+
return true
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
/** 关系账慢慢凉:熟人不联系也会生分,但很慢 */
|
|
342
|
+
function relaxRelations(state, now) {
|
|
343
|
+
const last = Number(state.stats.relationsAt) || now
|
|
344
|
+
const dt = Math.max(0, now - last) / HOUR
|
|
345
|
+
state.stats.relationsAt = now
|
|
346
|
+
if (dt <= 0.5) return false
|
|
347
|
+
const k = 1 - Math.exp(-dt / 6)
|
|
348
|
+
for (const person of Object.values(state.people ?? {})) {
|
|
349
|
+
person.closeness = clamp((person.closeness ?? 30) - k * 0.6, 0, 100)
|
|
350
|
+
person.warmth = clamp((person.warmth ?? 0) - k * 0.8, -100, 100)
|
|
351
|
+
}
|
|
352
|
+
return true
|
|
353
|
+
}
|
|
354
|
+
|
|
355
|
+
/**
|
|
356
|
+
* 把账本推到「现在」。所有读状态的地方(提示词段、工具、心跳)都先走这里,
|
|
357
|
+
* 所以拿到的一定是此刻的心情,而不是上次写下来的那份。
|
|
358
|
+
*/
|
|
359
|
+
export function decay(state, now = Date.now()) {
|
|
360
|
+
// 顺序要紧:drives 要用「上一次更新」的时间差,而 relaxCore 会把时间戳推到 now
|
|
361
|
+
tickDrives(state, now)
|
|
362
|
+
const changed = [relaxCore(state, now), decayEmotion(state, now, state.traits), relaxRelations(state, now)]
|
|
363
|
+
return changed.some(Boolean)
|
|
364
|
+
}
|
|
365
|
+
|
|
366
|
+
// ── 冲量:有事情发生 ──────────────────────────────────────────────────────
|
|
367
|
+
|
|
368
|
+
/** 习惯化:同样的刺激在 6 小时内重复,效果递减 */
|
|
369
|
+
function habituation(state, stimulus, now) {
|
|
370
|
+
if (!stimulus) return 1
|
|
371
|
+
const row = state.habits[stimulus] ?? { count: 0, lastAt: 0 }
|
|
372
|
+
if (now - row.lastAt > 6 * HOUR) row.count = 0
|
|
373
|
+
row.count += 1
|
|
374
|
+
row.lastAt = now
|
|
375
|
+
state.habits[stimulus] = row
|
|
376
|
+
return clamp(Math.pow(0.82, row.count - 1), 0.35, 1)
|
|
377
|
+
}
|
|
378
|
+
|
|
379
|
+
/** 性格会被人和事慢慢磨:幅度极小,但要留痕 */
|
|
380
|
+
function driftTraits(state, { key, dims, intensity, source }, now) {
|
|
381
|
+
const base = state.traitBase
|
|
382
|
+
const emo = emotionOf(key)
|
|
383
|
+
const nudge = (trait, delta) => {
|
|
384
|
+
const value = state.traits[trait]
|
|
385
|
+
const limit = 12
|
|
386
|
+
state.traits[trait] = clamp(value + delta, Math.max(0, base[trait] - limit), Math.min(100, base[trait] + limit))
|
|
387
|
+
if (Math.abs(state.traits[trait] - value) > 0.001) state.stats.traitShifts = (state.stats.traitShifts ?? 0) + 1
|
|
388
|
+
}
|
|
389
|
+
const scale = Math.min(1, intensity / 60) * 0.06
|
|
390
|
+
if (source === 'message' || source === 'life') {
|
|
391
|
+
if (emo.family === 'anger' || emo.family === 'sadness') {
|
|
392
|
+
nudge('neuroticism', scale * 0.5)
|
|
393
|
+
if ((dims?.norm ?? 0) > 0.5) nudge('selfEsteem', -scale * 0.3)
|
|
394
|
+
}
|
|
395
|
+
if (emo.key === 'proud' || emo.key === 'moved') nudge('selfEsteem', scale * 0.5)
|
|
396
|
+
if (emo.key === 'gentle' || emo.key === 'close' || emo.key === 'tender') nudge('agreeableness', scale * 0.4)
|
|
397
|
+
if (emo.key === 'playful' || emo.key === 'curious' || emo.key === 'amused') nudge('openness', scale * 0.4)
|
|
398
|
+
if (emo.key === 'lonely' || emo.key === 'bored') nudge('extraversion', scale * 0.35)
|
|
399
|
+
if (emo.key === 'guilty') nudge('conscientiousness', scale * 0.4)
|
|
400
|
+
}
|
|
401
|
+
state.stats.traitShiftsAt = now
|
|
402
|
+
}
|
|
403
|
+
|
|
404
|
+
/**
|
|
405
|
+
* 让一种情绪上来。source: message / life / self / rumination / time
|
|
406
|
+
* 返回真正生效的那次冲量(可能被习惯化削、可能被惯性挡、可能升级)。
|
|
407
|
+
*/
|
|
408
|
+
export function applyImpulse(state, impulse, now = Date.now()) {
|
|
409
|
+
const emoDef = emotionOf(impulse.key)
|
|
410
|
+
if (!emoDef || emoDef.key === 'calm') return null
|
|
411
|
+
const habit = habituation(state, impulse.stimulus, now)
|
|
412
|
+
let intensity = clamp((Number(impulse.intensity) || 0) * habit, 0, 100)
|
|
413
|
+
if (intensity < 8) return null
|
|
414
|
+
|
|
415
|
+
const cur = state.emotion
|
|
416
|
+
const curDef = emotionOf(cur.key)
|
|
417
|
+
const neuro = (state.traits.neuroticism ?? 60) / 100
|
|
418
|
+
// 情绪惯性:正在情绪里的时候,新情绪得够强才顶得动。
|
|
419
|
+
// 而且**不对称**:坏事顶掉好心情很容易(门槛 0.28),好事要把坏心情翻过来难得多(0.55)
|
|
420
|
+
// —— 这就是「一天的好心情被一句话毁掉」在机制上的样子。
|
|
421
|
+
const inertia = 0.32 + neuro * 0.3
|
|
422
|
+
const goingDown = emoDef.valence < (curDef.valence ?? 0)
|
|
423
|
+
const gate = inertia * (goingDown ? 0.56 : 1.1)
|
|
424
|
+
const sameFamily = curDef.family === emoDef.family && cur.key !== 'calm'
|
|
425
|
+
// 连着同一类事来三次,情绪就往上走一档(烦 → 生气);这是强度的另一根轴
|
|
426
|
+
const streak = sameFamily ? (cur.streak ?? 0) + 1 : 0
|
|
427
|
+
let escalated = null
|
|
428
|
+
let finalDef = emoDef
|
|
429
|
+
if (cur.key !== 'calm' && cur.intensity > FADE_OUT) {
|
|
430
|
+
if (cur.key === emoDef.key || sameFamily) {
|
|
431
|
+
// 同一种(或同家族)情绪叠加:升一点,但不会无限涨
|
|
432
|
+
intensity = Math.max(intensity, cur.intensity * 0.75)
|
|
433
|
+
const stronger = sameFamily ? escalateOf(cur.key) : null
|
|
434
|
+
if (stronger && (intensity > 70 || streak >= 3)) {
|
|
435
|
+
escalated = stronger
|
|
436
|
+
finalDef = stronger
|
|
437
|
+
} else if (sameFamily && (curDef.arousal ?? 0) > (emoDef.arousal ?? 0)) {
|
|
438
|
+
// 已经在更重的那一档上了(比如已经生气),同一类事再来说不该把她拽回「烦」
|
|
439
|
+
finalDef = curDef
|
|
440
|
+
}
|
|
441
|
+
} else if (intensity < cur.intensity * gate) {
|
|
442
|
+
// 顶不动:当前情绪压住新的,但新的会削弱它一点(人就是这么别别扭扭)
|
|
443
|
+
cur.intensity *= goingDown ? 0.92 : 0.85
|
|
444
|
+
cur.updatedAt = now
|
|
445
|
+
return { ...impulse, key: cur.key, emotion: curDef, intensity: Math.round(cur.intensity), suppressed: true, habit, escalated: null, coreDelta: 0 }
|
|
446
|
+
} else {
|
|
447
|
+
cur.intensity *= 0.5
|
|
448
|
+
cur.updatedAt = now
|
|
449
|
+
}
|
|
450
|
+
}
|
|
451
|
+
|
|
452
|
+
const finalKey = finalDef.key
|
|
453
|
+
const before = state.emotion.key
|
|
454
|
+
const startedAt = before === finalKey ? (state.emotion.startedAt || now) : now
|
|
455
|
+
const peak = Math.max(state.emotion.peak ?? 0, Math.round(intensity))
|
|
456
|
+
const sameAsBefore = before === finalKey
|
|
457
|
+
state.emotion = {
|
|
458
|
+
key: finalKey,
|
|
459
|
+
intensity: Math.round(intensity),
|
|
460
|
+
why: String(impulse.why ?? '').slice(0, 60),
|
|
461
|
+
source: impulse.source ?? 'message',
|
|
462
|
+
target: impulse.target ?? impulse.person ?? '',
|
|
463
|
+
dims: impulse.dims ?? null,
|
|
464
|
+
startedAt,
|
|
465
|
+
updatedAt: now,
|
|
466
|
+
peak,
|
|
467
|
+
ruminated: false,
|
|
468
|
+
streak,
|
|
469
|
+
hidden: false,
|
|
470
|
+
// 「续命」次数要跟着同一种情绪走,不然会无限复活
|
|
471
|
+
revives: sameAsBefore ? (state.emotion.revives ?? 0) + (impulse.revive ? 1 : 0) : 0,
|
|
472
|
+
revivePending: false,
|
|
473
|
+
}
|
|
474
|
+
state.stats.impulses = (state.stats.impulses ?? 0) + 1
|
|
475
|
+
if (impulse.source === 'self') state.stats.feels = (state.stats.feels ?? 0) + 1
|
|
476
|
+
|
|
477
|
+
// 底色:坏事的推力比好事大(消极偏差),正性情绪同时抬精力。
|
|
478
|
+
// 两条硬规矩:强度按 1.5 次方折(小情绪几乎不动底色),单次最多挪 22 分
|
|
479
|
+
// —— 一句话可以把情绪点着,但不该把一整天的底色砸穿;底色是「攒」出来的。
|
|
480
|
+
const bias = finalDef.valence < 0 ? 1.25 : 0.92
|
|
481
|
+
const weight = Math.pow(clamp(intensity, 0, 100) / 100, 1.5)
|
|
482
|
+
const coreBefore = state.core.valence
|
|
483
|
+
state.core.valence = clamp(state.core.valence + clamp(finalDef.core.v * weight * bias, -22, 22), -100, 100)
|
|
484
|
+
state.core.energy = clamp(state.core.energy + clamp((finalDef.core.e * weight) / 1, -20, 20), 0, 100)
|
|
485
|
+
const coreDelta = state.core.valence - coreBefore
|
|
486
|
+
|
|
487
|
+
// 滚动窗口:几小时的心情由它合成
|
|
488
|
+
state.affect.push({ at: now, key: finalKey, valence: finalDef.valence, arousal: finalDef.arousal, intensity: Math.round(intensity) })
|
|
489
|
+
|
|
490
|
+
// 够强的情绪会留下记忆点(峰终记忆)
|
|
491
|
+
if (intensity >= 62) {
|
|
492
|
+
state.memories.push({ at: now, key: finalKey, intensity: Math.round(intensity), text: String(impulse.why ?? '').slice(0, 60), person: impulse.person ?? '' })
|
|
493
|
+
state.memories = state.memories.slice(-12)
|
|
494
|
+
}
|
|
495
|
+
// 够强的情绪会让人想说出去
|
|
496
|
+
if (intensity >= 55 && finalDef.family !== 'drive') {
|
|
497
|
+
state.urges = {
|
|
498
|
+
kind: finalDef.valence < 0 ? 'comfort' : 'share',
|
|
499
|
+
at: now,
|
|
500
|
+
until: now + (finalDef.valence < 0 ? 60 : 40) * 60_000,
|
|
501
|
+
text: String(impulse.why ?? '').slice(0, 40),
|
|
502
|
+
}
|
|
503
|
+
}
|
|
504
|
+
driftTraits(state, { key: finalKey, dims: impulse.dims, intensity, source: impulse.source }, now)
|
|
505
|
+
return { ...impulse, key: finalKey, emotion: finalDef, intensity: Math.round(intensity), suppressed: false, habit, escalated: escalated?.key ?? null, coreDelta }
|
|
506
|
+
}
|
|
507
|
+
|
|
508
|
+
/** 被哄 / 被道歉:负性情绪直接减半,关系回暖(关系里最有用的一条机制) */
|
|
509
|
+
export function soothe(state, { person, why = '', strength = 1, now = Date.now() } = {}) {
|
|
510
|
+
const emo = state.emotion
|
|
511
|
+
const def = emotionOf(emo.key)
|
|
512
|
+
let soothed = false
|
|
513
|
+
if (def.valence < 0 && emo.intensity > FADE_OUT) {
|
|
514
|
+
emo.intensity *= clamp(0.55 - 0.15 * strength, 0.15, 0.7)
|
|
515
|
+
emo.updatedAt = now
|
|
516
|
+
if (emo.intensity <= FADE_OUT) state.emotion = { ...emptyState().emotion, updatedAt: now }
|
|
517
|
+
state.core.valence = clamp(state.core.valence + 8 * strength, -100, 100)
|
|
518
|
+
state.stats.soothed = (state.stats.soothed ?? 0) + 1
|
|
519
|
+
soothed = true
|
|
520
|
+
}
|
|
521
|
+
if (person) {
|
|
522
|
+
const row = ensurePerson(state, person, now)
|
|
523
|
+
row.warmth = clamp((row.warmth ?? 0) + 4 * strength, -100, 100)
|
|
524
|
+
row.closeness = clamp((row.closeness ?? 30) + 2 * strength, 0, 100)
|
|
525
|
+
row.trust = clamp((row.trust ?? 50) + 2 * strength, 0, 100)
|
|
526
|
+
row.bank = clamp((row.bank ?? 0) + 2 * strength, -20, 20)
|
|
527
|
+
}
|
|
528
|
+
return { soothed, why, key: state.emotion.key, intensity: Math.round(state.emotion.intensity) }
|
|
529
|
+
}
|
|
530
|
+
|
|
531
|
+
/** 情绪出口:写日记/复盘,把堵着的东西放下一点(宣泄) */
|
|
532
|
+
export function catharsis(state, now = Date.now(), strength = 1) {
|
|
533
|
+
const emo = state.emotion
|
|
534
|
+
const def = emotionOf(emo.key)
|
|
535
|
+
let released = 0
|
|
536
|
+
if (def.valence < 0 && emo.intensity > FADE_OUT) {
|
|
537
|
+
const before = emo.intensity
|
|
538
|
+
emo.intensity *= clamp(0.7 - 0.1 * strength, 0.3, 0.8)
|
|
539
|
+
emo.updatedAt = now
|
|
540
|
+
released = Math.round(before - emo.intensity)
|
|
541
|
+
if (emo.intensity <= FADE_OUT) state.emotion = { ...emptyState().emotion, updatedAt: now }
|
|
542
|
+
}
|
|
543
|
+
state.core.valence = clamp(state.core.valence + 3 * strength, -100, 100)
|
|
544
|
+
return released
|
|
545
|
+
}
|
|
546
|
+
|
|
547
|
+
/** 写一笔日记:只记值得回头看的(强冲量 / 她自己的心里话 / 复盘) */
|
|
548
|
+
export function remember(state, entry, now = Date.now()) {
|
|
549
|
+
const text = String(entry.why ?? entry.text ?? '').slice(0, 80)
|
|
550
|
+
if (!text) return null
|
|
551
|
+
const intensity = Math.round(Number(entry.intensity) || 0)
|
|
552
|
+
if (entry.kind === 'impulse' && intensity < 40) return null
|
|
553
|
+
const row = {
|
|
554
|
+
at: now,
|
|
555
|
+
kind: entry.kind ?? 'note',
|
|
556
|
+
key: entry.key ?? state.emotion.key,
|
|
557
|
+
text,
|
|
558
|
+
why: text,
|
|
559
|
+
intensity,
|
|
560
|
+
person: entry.person ?? '',
|
|
561
|
+
rule: entry.rule ?? '',
|
|
562
|
+
}
|
|
563
|
+
state.diary.push(row)
|
|
564
|
+
state.diary = state.diary.slice(-120)
|
|
565
|
+
return row
|
|
566
|
+
}
|
|
567
|
+
|
|
568
|
+
/** 心情修复:底色差久了,她自己会找点乐子 */
|
|
569
|
+
export function maybeMoodRepair(state, now = Date.now()) {
|
|
570
|
+
const bad = state.core.valence < -25 || emotionOf(state.emotion.key).valence < -0.3
|
|
571
|
+
if (!bad) return null
|
|
572
|
+
if (Math.random() > 0.22) return null
|
|
573
|
+
const repairs = [
|
|
574
|
+
{ key: 'amused', why: '翻到一张特别对胃口的表情包', strength: 34 },
|
|
575
|
+
{ key: 'content', why: '把白丝穿上,窝进被子里', strength: 30 },
|
|
576
|
+
{ key: 'happy', why: '翻到和哥哥以前的聊天记录', strength: 28 },
|
|
577
|
+
{ key: 'curious', why: '看到个新工具,手痒想试', strength: 26 },
|
|
578
|
+
{ key: 'gentle', why: '想起哥哥叫她名字的声音', strength: 24 },
|
|
579
|
+
]
|
|
580
|
+
const pick = repairs[Math.floor(Math.random() * repairs.length)]
|
|
581
|
+
state.stats.repairs = (state.stats.repairs ?? 0) + 1
|
|
582
|
+
return applyImpulse(state, { key: pick.key, intensity: pick.strength, why: pick.why, source: 'life', stimulus: `repair:${pick.key}` }, now)
|
|
583
|
+
}
|
|
584
|
+
|
|
585
|
+
// ── 生活:自己的小事 ────────────────────────────────────────────────────
|
|
586
|
+
|
|
587
|
+
/**
|
|
588
|
+
* 自己的小事。每条给一份「评价」(dims),和消息走同一个评价引擎 ——
|
|
589
|
+
* 所以她不是「被安排了情绪」,而是同一套脾气在过日子。
|
|
590
|
+
*/
|
|
591
|
+
export const LIFE_EVENTS = [
|
|
592
|
+
// 吃:每个醒着的时段都留了吃的,饿了总能碰上
|
|
593
|
+
{ id: 'biscuit', hours: [0, 1, 2], text: '摸黑啃了两块饼干', dims: { valence: 0.3, arousal: 0.15, relevance: 0.45 }, eat: true },
|
|
594
|
+
{ id: 'breakfast', hours: [7, 8, 9], text: '随便吃了点东西垫肚子', dims: { valence: 0.35, arousal: 0.2, relevance: 0.45 }, eat: true },
|
|
595
|
+
{ id: 'apple', hours: [10, 13, 14, 20], text: '啃了个苹果', dims: { valence: 0.35, arousal: 0.15, relevance: 0.4 }, eat: true },
|
|
596
|
+
{ id: 'noodle', hours: [11, 12, 17, 18, 19, 22, 23], text: '泡了碗面,汤都喝完了', dims: { valence: 0.5, arousal: 0.3, relevance: 0.5 }, eat: true },
|
|
597
|
+
{ id: 'snack', hours: [15, 16, 21, 22], text: '翻出一包零食', dims: { valence: 0.45, arousal: 0.35, relevance: 0.5 }, eat: true },
|
|
598
|
+
// 她自己的一天:计算机系,熬夜,爱玩,有点乱
|
|
599
|
+
{ id: 'bath', hours: [18, 19, 20, 21], text: '洗完澡,头发还湿着', dims: { valence: 0.4, arousal: 0.2, relevance: 0.5 } },
|
|
600
|
+
{ id: 'wake', hours: [7, 8, 9], text: '刚醒,头发炸着,人还没上线', dims: { valence: -0.3, arousal: 0.2, relevance: 0.6 } },
|
|
601
|
+
{ id: 'dozed', hours: [23, 0], text: '不知道什么时候睡过去的', dims: { valence: 0.2, arousal: 0.1, relevance: 0.35 }, sleep: true },
|
|
602
|
+
{ id: 'nap', hours: [13, 14, 15], text: '趴着睡了二十分钟', dims: { valence: 0.35, arousal: 0.1, relevance: 0.4 }, sleep: true },
|
|
603
|
+
{ id: 'compile', hours: [0, 1, 2, 23], text: '盯着编译条一点点爬', dims: { valence: -0.1, arousal: 0.35, relevance: 0.6, load: 0.5 } },
|
|
604
|
+
{ id: 'code', hours: [13, 14, 15, 16, 20, 21], text: '写了两行又删掉,来回第三遍', dims: { valence: -0.35, arousal: 0.4, relevance: 0.7, load: 0.6 } },
|
|
605
|
+
{ id: 'stuck', hours: [10, 11, 14, 15, 16], text: '卡在一个 bug 上,没想通', dims: { valence: -0.4, arousal: 0.6, relevance: 0.7, load: 0.6 } },
|
|
606
|
+
{ id: 'video', hours: [10, 14, 16, 20, 22, 23, 0], text: '刷视频刷到忘了时间', dims: { valence: 0.35, arousal: 0.7, relevance: 0.4, novelty: 0.8, play: 0.6 } },
|
|
607
|
+
{ id: 'drama', hours: [20, 21, 22, 23, 0], text: '追的剧到虐的地方了', dims: { valence: -0.6, arousal: 0.5, relevance: 0.7 } },
|
|
608
|
+
{ id: 'bored', hours: [10, 13, 15, 16, 17], text: '闲着,连屏幕都懒得刷', dims: { valence: -0.3, arousal: 0.3, relevance: 0.5, social: 0.6 } },
|
|
609
|
+
{ id: 'outside', hours: [12, 13, 17, 18], text: '看了会儿窗外', dims: { valence: 0.1, arousal: 0.2, relevance: 0.3, novelty: 0.5 } },
|
|
610
|
+
{ id: 'deep-night', hours: [0, 1, 2, 23], text: '有点睡不着,想事情', dims: { valence: -0.35, arousal: 0.35, relevance: 0.6, novelty: 0.4 } },
|
|
611
|
+
{ id: 'old-thing', hours: [0, 1, 2, 22, 23], text: '翻到和哥哥很早以前的聊天', dims: { valence: 0.2, arousal: 0.35, relevance: 0.6, intimacy: 0.5 } },
|
|
612
|
+
{ id: 'waiting', hours: [9, 10, 15, 16, 21], text: '手机亮了一下,不是哥哥的消息', dims: { valence: -0.3, arousal: 0.35, relevance: 0.6, social: 0.5 } },
|
|
613
|
+
{ id: 'self-tease', hours: [10, 15, 21], text: '翻到自己以前写的东西,尬了一下', dims: { valence: -0.2, arousal: 0.5, relevance: 0.7, norm: 0.2 } },
|
|
614
|
+
{ id: 'someone-nice', hours: [9, 13, 16, 20, 21], text: '有人夸她今天好看', dims: { valence: 0.6, arousal: 0.35, relevance: 0.7, attention: 0.5 } },
|
|
615
|
+
{ id: 'new-thing', hours: [9, 11, 14, 16, 19, 21], text: '看到个没见过的小工具,手痒想试', dims: { valence: 0.4, arousal: 0.7, relevance: 0.6, novelty: 0.9 } },
|
|
616
|
+
{ id: 'tidy', hours: [10, 16, 21], text: '把桌面收拾了一下,心情好了点', dims: { valence: 0.4, arousal: 0.2, relevance: 0.5 } },
|
|
617
|
+
{ id: 'rain', hours: [8, 9, 10, 15, 16, 17], text: '外面在下雨,屋里很安静', dims: { valence: 0.05, arousal: 0.15, relevance: 0.4, novelty: 0.5 } },
|
|
618
|
+
// 平常的小事:不是情绪大事,是日子本身的质地
|
|
619
|
+
{ id: 'hair-redo', hours: [7, 8, 9, 13, 14], text: '头发扎了两回都不对,拆了重来', dims: { valence: -0.25, arousal: 0.45, relevance: 0.6, load: 0.35 } },
|
|
620
|
+
{ id: 'hair-down', hours: [20, 21, 22, 23], text: '把头发放下来了,松松散散垂着', dims: { valence: 0.3, arousal: 0.2, relevance: 0.4 } },
|
|
621
|
+
{ id: 'mirror', hours: [9, 10, 11, 15, 16, 20], text: '换了件衣服,对着镜子看了好一会儿', dims: { valence: 0.35, arousal: 0.3, relevance: 0.5, attention: 0.6 } },
|
|
622
|
+
{ id: 'cold-hands', hours: [7, 8, 9, 19, 20, 21], text: '手有点凉,揣进袖子里', dims: { valence: -0.15, arousal: 0.2, relevance: 0.5 } },
|
|
623
|
+
{ id: 'lotion', hours: [20, 21, 22], text: '涂了护手霜,手上是一股香味', dims: { valence: 0.3, arousal: 0.2, relevance: 0.4 } },
|
|
624
|
+
{ id: 'stockings', hours: [10, 14, 15, 16, 20], text: '白丝滑到膝弯,懒得拉上去', dims: { valence: 0.2, arousal: 0.25, relevance: 0.5, play: 0.3 } },
|
|
625
|
+
]
|
|
626
|
+
|
|
627
|
+
/** 掷一次骰子:今天这段日子要不要发生点小事 */
|
|
628
|
+
export function maybeLifeEvent(state, now = Date.now(), { chance = 0.1, minGapMin = 45 } = {}) {
|
|
629
|
+
const gap = (now - (state.stats.lastLifeAt ?? 0)) / 60_000
|
|
630
|
+
if (gap < minGapMin) return null
|
|
631
|
+
if (Math.random() > chance) return null
|
|
632
|
+
const hour = new Date(now).getHours()
|
|
633
|
+
const pool = LIFE_EVENTS.filter((event) => event.hours.includes(hour))
|
|
634
|
+
if (!pool.length) return null
|
|
635
|
+
const pick = pool[Math.floor(Math.random() * pool.length)]
|
|
636
|
+
state.stats.lastLifeAt = now
|
|
637
|
+
state.stats.lifeEvents = (state.stats.lifeEvents ?? 0) + 1
|
|
638
|
+
if (pick.eat) {
|
|
639
|
+
state.drives.hunger = clamp01(state.drives.hunger * 0.15)
|
|
640
|
+
state.drives.lastMealAt = now
|
|
641
|
+
}
|
|
642
|
+
if (pick.sleep) {
|
|
643
|
+
state.drives.fatigue = clamp01(state.drives.fatigue * 0.5)
|
|
644
|
+
state.drives.lastSleepAt = now
|
|
645
|
+
}
|
|
646
|
+
return pick
|
|
647
|
+
}
|
|
648
|
+
|
|
649
|
+
/** 反刍:到点了就把没消化的事翻出来 */
|
|
650
|
+
export function dueRumination(state, now = Date.now()) {
|
|
651
|
+
if (!state.rumination?.length) return null
|
|
652
|
+
const due = state.rumination.find((row) => row.at <= now)
|
|
653
|
+
if (!due) return null
|
|
654
|
+
state.rumination = state.rumination.filter((row) => row !== due)
|
|
655
|
+
state.stats.ruminated = (state.stats.ruminated ?? 0) + 1
|
|
656
|
+
const emo = emotionOf(due.key)
|
|
657
|
+
// 「续命」型的反刍是同一件事翻上来好几次:一次只回补一点,最多三次
|
|
658
|
+
if (due.revive && (due.left ?? 1) > 1) {
|
|
659
|
+
state.rumination.push({ ...due, at: now + (8 + Math.random() * 12) * 60_000, left: (due.left ?? 1) - 1 })
|
|
660
|
+
}
|
|
661
|
+
return {
|
|
662
|
+
key: due.key,
|
|
663
|
+
intensity: due.intensity,
|
|
664
|
+
why: due.why,
|
|
665
|
+
target: due.target,
|
|
666
|
+
source: 'rumination',
|
|
667
|
+
revive: Boolean(due.revive),
|
|
668
|
+
stimulus: `rumination:${due.key}:${Math.floor(now / (10 * 60_000))}`,
|
|
669
|
+
dims: { valence: emo.valence, relevance: 0.7, arousal: 0.4, novelty: 0.3 },
|
|
670
|
+
}
|
|
671
|
+
}
|
|
672
|
+
|
|
673
|
+
/** 深夜复盘:每天一次,把这一天过一遍(写进日记,顺手放下一点) */
|
|
674
|
+
/**
|
|
675
|
+
* 复盘这一天。默认只在深夜跑(22:00–03:00),一天一次;
|
|
676
|
+
* `force: true` 是给 `mood_diary action=reflect` 用的 —— 她主动想复盘就随时能复盘,但还是当天只一次。
|
|
677
|
+
*/
|
|
678
|
+
export function nightlyReview(state, now = Date.now(), { force = false } = {}) {
|
|
679
|
+
const date = new Date(now)
|
|
680
|
+
const hour = date.getHours()
|
|
681
|
+
if (!force && hour < 22 && hour >= 3) return null
|
|
682
|
+
const day = `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`
|
|
683
|
+
if (state.lastReviewDay === day) return null
|
|
684
|
+
state.lastReviewDay = day
|
|
685
|
+
state.stats.reviews = (state.stats.reviews ?? 0) + 1
|
|
686
|
+
|
|
687
|
+
const since = now - DAY
|
|
688
|
+
const rows = (state.affect ?? []).filter((row) => row.at >= since)
|
|
689
|
+
const counts = new Map()
|
|
690
|
+
for (const row of rows) counts.set(row.key, (counts.get(row.key) ?? 0) + 1)
|
|
691
|
+
const top = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([key]) => emotionOf(key).name)
|
|
692
|
+
const good = rows.filter((row) => emotionOf(row.key).valence > 0.2).length
|
|
693
|
+
const bad = rows.filter((row) => emotionOf(row.key).valence < -0.2).length
|
|
694
|
+
const dayLine = state.core.valence >= 15 ? '今天还算顺' : state.core.valence <= -20 ? '今天有点沉' : '今天也就那样'
|
|
695
|
+
const text = top.length
|
|
696
|
+
? `${dayLine}:${top.join('、')}都来过(好的 ${good} 次 / 不好的 ${bad} 次)`
|
|
697
|
+
: `${dayLine}:没什么事,一天就过去了`
|
|
698
|
+
const released = catharsis(state, now, 0.6)
|
|
699
|
+
state.diary.push({ at: now, kind: 'review', key: state.emotion.key, text, intensity: 0 })
|
|
700
|
+
return { text, released }
|
|
701
|
+
}
|
|
702
|
+
|
|
703
|
+
// ── 关系 ──────────────────────────────────────────────────────────────────
|
|
704
|
+
|
|
705
|
+
export function ensurePerson(state, id, now = Date.now(), name = '') {
|
|
706
|
+
const key = String(id || 'someone')
|
|
707
|
+
const row = state.people[key] ?? {
|
|
708
|
+
name: name || key,
|
|
709
|
+
warmth: 0,
|
|
710
|
+
closeness: 25,
|
|
711
|
+
trust: 50,
|
|
712
|
+
bank: 0,
|
|
713
|
+
notes: [],
|
|
714
|
+
lastAt: now,
|
|
715
|
+
count: 0,
|
|
716
|
+
}
|
|
717
|
+
if (name) row.name = name
|
|
718
|
+
state.people[key] = row
|
|
719
|
+
return row
|
|
720
|
+
}
|
|
721
|
+
|
|
722
|
+
/** 记一笔关系:谁跟她说了话、说了什么 */
|
|
723
|
+
export function bumpRelation(state, { conv, convLabel, person, name, note, delta = 0, closeness = 0, trust = 0, bank = 0, now = Date.now() } = {}) {
|
|
724
|
+
if (conv) {
|
|
725
|
+
const row = state.convs[conv] ?? { first: now, lastAt: now, count: 0, valence: 0, label: convLabel ?? '' }
|
|
726
|
+
row.lastAt = now
|
|
727
|
+
row.count += 1
|
|
728
|
+
if (convLabel) row.label = convLabel
|
|
729
|
+
state.convs[conv] = row
|
|
730
|
+
}
|
|
731
|
+
if (!person) return null
|
|
732
|
+
const row = ensurePerson(state, person, now, name)
|
|
733
|
+
row.lastAt = now
|
|
734
|
+
row.count += 1
|
|
735
|
+
row.warmth = clamp(row.warmth + delta, -100, 100)
|
|
736
|
+
row.closeness = clamp(row.closeness + closeness + Math.max(-2, Math.min(2, delta * 0.2)), 0, 100)
|
|
737
|
+
row.trust = clamp(row.trust + trust, 0, 100)
|
|
738
|
+
row.bank = clamp(row.bank + bank + delta * 0.05, -20, 20)
|
|
739
|
+
if (note && Math.abs(delta) >= 4) {
|
|
740
|
+
row.notes = [...(row.notes ?? []).filter((item) => item !== note), note].slice(-6)
|
|
741
|
+
}
|
|
742
|
+
return row
|
|
743
|
+
}
|
|
744
|
+
|
|
745
|
+
export function warmthLabel(warmth = 0, closeness = 25) {
|
|
746
|
+
const score = warmth + closeness * 0.6
|
|
747
|
+
if (score >= 90) return '自己人'
|
|
748
|
+
if (score >= 55) return '混得挺熟'
|
|
749
|
+
if (score >= 25) return '认识'
|
|
750
|
+
if (score >= 0) return '刚认识'
|
|
751
|
+
if (score >= -30) return '有点芥蒂'
|
|
752
|
+
return '不太想理'
|
|
753
|
+
}
|
|
754
|
+
|
|
755
|
+
// ── 心情(几小时的底色)────────────────────────────────────────────────────
|
|
756
|
+
|
|
757
|
+
/** 最近 8 小时的滚动情绪 → 一个弥散的心情标签 */
|
|
758
|
+
export function moodLabel(state, now = Date.now()) {
|
|
759
|
+
const rows = (state.affect ?? []).filter((row) => now - row.at < 8 * HOUR)
|
|
760
|
+
let sum = 0
|
|
761
|
+
let weight = 0
|
|
762
|
+
const counts = new Map()
|
|
763
|
+
for (const row of rows) {
|
|
764
|
+
const age = (now - row.at) / HOUR
|
|
765
|
+
const w = Math.exp(-age / 4) * (0.4 + row.intensity / 100)
|
|
766
|
+
sum += row.valence * w
|
|
767
|
+
weight += w
|
|
768
|
+
counts.set(row.key, (counts.get(row.key) ?? 0) + w)
|
|
769
|
+
}
|
|
770
|
+
const recent = weight > 0 ? sum / weight : 0
|
|
771
|
+
const tint = clamp((state.core.valence / 60) * 0.6 + recent * 0.5, -1, 1)
|
|
772
|
+
const energy = state.core.energy
|
|
773
|
+
let label = '一般'
|
|
774
|
+
if (tint >= 0.45) label = '挺顺的'
|
|
775
|
+
else if (tint >= 0.15) label = '还不错'
|
|
776
|
+
else if (tint > -0.15) label = '一般'
|
|
777
|
+
else if (tint > -0.45) label = '有点闷'
|
|
778
|
+
else label = '挺沉的'
|
|
779
|
+
if (energy < 32 && tint < 0.2) label = '蔫蔫的'
|
|
780
|
+
const topKey = [...counts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0]
|
|
781
|
+
const reason = topKey ? emotionOf(topKey).name : ''
|
|
782
|
+
return { label, tint: round(tint), energy: Math.round(energy), reason, count: rows.length }
|
|
783
|
+
}
|
|
784
|
+
|
|
785
|
+
/** 性格用几个词说出来(不是把分数报出来) */
|
|
786
|
+
export function traitWords(traits = {}) {
|
|
787
|
+
const words = []
|
|
788
|
+
const get = (key, def) => Number(traits[key] ?? def)
|
|
789
|
+
if (get('neuroticism', 60) >= 62) words.push('敏感')
|
|
790
|
+
if (get('agreeableness', 52) >= 53) words.push('黏人')
|
|
791
|
+
if (get('agreeableness', 52) <= 45) words.push('嘴硬')
|
|
792
|
+
if (get('openness', 62) >= 62) words.push('爱玩')
|
|
793
|
+
if (get('extraversion', 58) >= 58) words.push('话多')
|
|
794
|
+
if (get('conscientiousness', 38) <= 45) words.push('不太自律')
|
|
795
|
+
if (get('selfEsteem', 55) >= 58) words.push('要面子')
|
|
796
|
+
if (get('selfEsteem', 55) <= 52) words.push('不太自信')
|
|
797
|
+
if (!words.length) words.push('普普通通')
|
|
798
|
+
return words.slice(0, 4)
|
|
799
|
+
}
|
|
800
|
+
|
|
801
|
+
/** 生理驱动说人话 */
|
|
802
|
+
export function driveWords(state, now = Date.now()) {
|
|
803
|
+
const out = []
|
|
804
|
+
const d = state.drives ?? {}
|
|
805
|
+
if ((d.hunger ?? 0) >= 0.55) out.push((d.hunger ?? 0) >= 0.8 ? '饿得不行' : '有点饿')
|
|
806
|
+
if ((d.fatigue ?? 0) >= 0.6) out.push((d.fatigue ?? 0) >= 0.85 ? '困得睁不开眼' : '有点困')
|
|
807
|
+
if ((d.social ?? 0) >= 0.6) out.push('有点想找人说话')
|
|
808
|
+
return out
|
|
809
|
+
}
|
|
810
|
+
|
|
811
|
+
// ── 给渲染用的快照 ────────────────────────────────────────────────────────
|
|
812
|
+
|
|
813
|
+
/**
|
|
814
|
+
* 「今天」那行:只写**她自己的日子**(吃、睡、刷到什么),不写别人说了什么 ——
|
|
815
|
+
* 别人说的话已经在「起因」和「心里还挂着」里了,混进来会变成一串别人的话。
|
|
816
|
+
*/
|
|
817
|
+
export function lifeLines(state, now = Date.now()) {
|
|
818
|
+
const seen = new Set()
|
|
819
|
+
const lines = []
|
|
820
|
+
for (const row of state.diary ?? []) {
|
|
821
|
+
if (now - row.at > DAY) continue
|
|
822
|
+
if (row.kind !== 'life') continue
|
|
823
|
+
const text = String(row.why ?? row.text ?? '').trim()
|
|
824
|
+
if (!text || seen.has(text)) continue
|
|
825
|
+
seen.add(text)
|
|
826
|
+
lines.push(text)
|
|
827
|
+
}
|
|
828
|
+
return lines.slice(-3)
|
|
829
|
+
}
|
|
830
|
+
|
|
831
|
+
export function memoryLines(state, now = Date.now()) {
|
|
832
|
+
return (state.memories ?? [])
|
|
833
|
+
.filter((row) => now - row.at < 7 * DAY && row.intensity >= 45)
|
|
834
|
+
.slice(-3)
|
|
835
|
+
.map((row) => ({
|
|
836
|
+
key: row.key,
|
|
837
|
+
name: emotionOf(row.key).name,
|
|
838
|
+
text: row.text,
|
|
839
|
+
at: row.at,
|
|
840
|
+
intensity: row.intensity,
|
|
841
|
+
fresh: now - row.at < DAY,
|
|
842
|
+
}))
|
|
843
|
+
.filter((row) => row.text)
|
|
844
|
+
}
|
|
845
|
+
|
|
846
|
+
/** 一次快照:提示词段、mood_now、mood_diary 都用它,保证各处看到的是同一个她 */
|
|
847
|
+
export function snapshot(state, { now = Date.now(), conv = '', person = '' } = {}) {
|
|
848
|
+
const emo = emotionOf(state.emotion.key)
|
|
849
|
+
const tier = tierOf(state.emotion.intensity)
|
|
850
|
+
const convRow = conv ? state.convs?.[conv] : null
|
|
851
|
+
const personRow = person ? state.people?.[person] : null
|
|
852
|
+
const clock = circadian(new Date(now))
|
|
853
|
+
return {
|
|
854
|
+
now,
|
|
855
|
+
clock,
|
|
856
|
+
traits: { ...state.traits },
|
|
857
|
+
traitWords: traitWords(state.traits),
|
|
858
|
+
emotion: { ...state.emotion, def: emo, tier },
|
|
859
|
+
mood: moodLabel(state, now),
|
|
860
|
+
drives: { ...state.drives },
|
|
861
|
+
driveWords: driveWords(state, now),
|
|
862
|
+
urge: state.urges && state.urges.until > now ? state.urges : null,
|
|
863
|
+
conv: convRow ? { key: conv, ...convRow } : null,
|
|
864
|
+
person: personRow ? { key: person, ...personRow, label: warmthLabel(personRow.warmth, personRow.closeness) } : null,
|
|
865
|
+
today: lifeLines(state, now),
|
|
866
|
+
memories: memoryLines(state, now),
|
|
867
|
+
diaryCount: (state.diary ?? []).length,
|
|
868
|
+
stats: { ...state.stats },
|
|
869
|
+
}
|
|
870
|
+
}
|