sounds
This commit is contained in:
parent
c6ba3e38a2
commit
37087d08a7
189 changed files with 12864 additions and 9589 deletions
748
js/world_family_social.js
Normal file
748
js/world_family_social.js
Normal file
|
|
@ -0,0 +1,748 @@
|
|||
"use strict";
|
||||
|
||||
(function (global) {
|
||||
const World = global.World;
|
||||
if (!World) throw new Error("World is not available for mixin: world_family_social.js");
|
||||
Object.defineProperties(World.prototype, Object.getOwnPropertyDescriptors({
|
||||
reset(seedPopulation = null, fieldType = this.fieldType || "garden") {
|
||||
const field = FIELD_TYPES?.[fieldType] || FIELD_TYPES.garden;
|
||||
this.fieldType = field.id;
|
||||
this.fieldZoom = 1;
|
||||
this.setViewportSize(this.viewportW, this.viewportH);
|
||||
this.time = 0;
|
||||
this.day = 1;
|
||||
this.paused = false;
|
||||
this.speed = 1;
|
||||
this.toolSize = this.toolSize || "medium";
|
||||
this.toolSizes = this.toolSizes || {};
|
||||
this.tarinai = [];
|
||||
this.items = [];
|
||||
this.ants = [];
|
||||
this.effects = [];
|
||||
this.logs = [];
|
||||
this.events = window.TarinaiEvents || null;
|
||||
this.eventCounters = {};
|
||||
this.countsTimer = 0;
|
||||
this.compactTimer = 0;
|
||||
this.drawSortTimer = 0;
|
||||
this.drawListDirty = true;
|
||||
this.antUpdatePhase = 0;
|
||||
this.selected = null;
|
||||
this.deadCount = 0;
|
||||
this.liveIdNext = 1;
|
||||
this.liveIdFree = [];
|
||||
this.liveIdSerial = 0;
|
||||
this.liveTarinai = new Map();
|
||||
this.lastBirthAt = -999;
|
||||
this.maxGeneration = 1;
|
||||
this.family = {};
|
||||
this.familyVersion = 0;
|
||||
this.relationNotices = {};
|
||||
this.resolvedFightIds = {};
|
||||
this.foodSpoilagePenalty = 0;
|
||||
this.foodSpoilageEvents = 0;
|
||||
this.pointer = { x: this.w / 2, y: this.h / 2, inside: false, motion: 0, movedAt: 0 };
|
||||
this.cameraX = Math.max(0, (this.w - (this.viewportW || this.w)) / 2);
|
||||
this.cameraY = Math.max(0, (this.h - (this.viewportH || this.h)) / 2);
|
||||
this.shakeTimer = 0;
|
||||
this.shakeDuration = 0;
|
||||
this.shakeStrength = 0;
|
||||
this.clampCamera();
|
||||
this.lastPhase = this.phaseName();
|
||||
this.weather = "sunny";
|
||||
this.nextWeatherChange = rand(CONFIG.weatherChangeMin, CONFIG.weatherChangeMax);
|
||||
seedPopulation = seedPopulation ?? field.population ?? CONFIG.initialPopulation;
|
||||
const grassCount = field.grass ?? 18;
|
||||
const types = spawnableSprites().map(s => s.id);
|
||||
for (let i = 0; i < seedPopulation; i++) {
|
||||
this.addTarinai({
|
||||
type: types[i % types.length],
|
||||
x: rand(80, this.w - 80),
|
||||
y: rand(80, this.h - 80),
|
||||
generation: 1,
|
||||
});
|
||||
}
|
||||
for (let i = 0; i < grassCount; i++) this.items.push(new Item("grass", rand(70, this.w - 70), rand(70, this.h - 70)));
|
||||
this.items.push(new Item("stone", this.w * 0.68, this.h * 0.32));
|
||||
this.items.push(new Item("bed", this.w * 0.82, this.h * 0.22));
|
||||
this.items.push(new Item("bed", this.w * 0.18, this.h * 0.78));
|
||||
this.updateItemCounts();
|
||||
this.updateEffectCounts();
|
||||
this.markTerrainDirty?.("reset");
|
||||
this.rebuildSpatial(true);
|
||||
this.log("\u305f\u308a\u306a\u3044\u3092\u89b3\u5bdf\u7bb1\u306b\u914d\u7f6e\u3057\u307e\u3057\u305f\u3002");
|
||||
showToast("\u65b0\u3057\u3044\u89b3\u5bdf\u3092\u958b\u59cb\u3057\u307e\u3057\u305f\u3002");
|
||||
syncTopButtons();
|
||||
},
|
||||
|
||||
tarinaiFamilyKey(t) {
|
||||
return t?.familyKey || t?.archiveKey || t?.id || "";
|
||||
},
|
||||
|
||||
assignTarinaiLiveId(t) {
|
||||
if (!t) return "";
|
||||
if (!this.liveTarinai) this.liveTarinai = new Map();
|
||||
// Live IDs are never recycled. Relationships and transient targets are keyed by
|
||||
// live ID, so reuse can make dead friends/enemies leak onto new individuals.
|
||||
this.liveIdFree = [];
|
||||
if (!Number.isFinite(this.liveIdNext)) this.liveIdNext = 1;
|
||||
if (!Number.isFinite(this.liveIdSerial)) this.liveIdSerial = 0;
|
||||
const id = `t${this.liveIdNext++}`;
|
||||
t.id = id;
|
||||
t.liveToken = ++this.liveIdSerial;
|
||||
this.liveTarinai.set(id, { token: t.liveToken, target: t });
|
||||
return id;
|
||||
},
|
||||
|
||||
releaseTarinaiLiveId(t) {
|
||||
if (!t?.id || !this.liveTarinai) return false;
|
||||
const current = this.liveTarinai.get(t.id);
|
||||
if (!current || current.target !== t || current.token !== t.liveToken) return false;
|
||||
const id = t.id;
|
||||
this.liveTarinai.delete(id);
|
||||
// Do not recycle live IDs. Relationships are keyed by live ID; recycling can
|
||||
// make a dead friend's/enemy's relationship appear on a newly spawned individual.
|
||||
t.releasedLiveId = id;
|
||||
t.id = "";
|
||||
t.liveToken = 0;
|
||||
return true;
|
||||
},
|
||||
|
||||
liveTarinaiById(id, token = null) {
|
||||
if (!id || !this.liveTarinai) return null;
|
||||
const entry = this.liveTarinai.get(id);
|
||||
if (!entry || (token !== null && entry.token !== token)) return null;
|
||||
const t = entry.target;
|
||||
return t && !t.dead ? t : null;
|
||||
},
|
||||
|
||||
recordFamily(t) {
|
||||
if (!this.family) this.family = {};
|
||||
const familyKey = this.tarinaiFamilyKey(t);
|
||||
if (!familyKey) return;
|
||||
const uniqueIds = (list) => Array.from(new Set((list || []).filter(Boolean)));
|
||||
const sameList = (a, b) => {
|
||||
const aa = uniqueIds(a);
|
||||
const bb = uniqueIds(b);
|
||||
return aa.length === bb.length && aa.every((id, i) => id === bb[i]);
|
||||
};
|
||||
let changed = false;
|
||||
const nextParents = uniqueIds(t.parents || []);
|
||||
const nextChildren = uniqueIds(t.children || []);
|
||||
const nextPersonalityTags = getPersonalityTraitTags(t);
|
||||
if (!this.family[familyKey]) {
|
||||
this.family[familyKey] = {
|
||||
id: familyKey,
|
||||
name: t.name,
|
||||
type: t.type,
|
||||
personalityTags: nextPersonalityTags,
|
||||
generation: t.generation,
|
||||
hasPaired: !!t.hasPaired,
|
||||
parents: nextParents,
|
||||
parentNames: [...(t.parentNames || [])],
|
||||
children: nextChildren,
|
||||
birthTime: t.birthTime,
|
||||
alive: !t.dead,
|
||||
deathReason: t.deathReason || "",
|
||||
};
|
||||
changed = true;
|
||||
} else {
|
||||
const entry = this.family[familyKey];
|
||||
const nextAlive = !t.dead;
|
||||
if (entry.name !== t.name) changed = true;
|
||||
if (entry.type !== t.type) changed = true;
|
||||
if (!sameList(entry.personalityTags, nextPersonalityTags)) changed = true;
|
||||
if (entry.hasPaired !== !!t.hasPaired) changed = true;
|
||||
if (entry.generation !== t.generation) changed = true;
|
||||
if ((entry.deathReason || "") !== (t.deathReason || entry.deathReason || "")) changed = true;
|
||||
if (entry.alive !== nextAlive) changed = true;
|
||||
if (!sameList(entry.parents, nextParents)) changed = true;
|
||||
if (!sameList(entry.children, nextChildren)) changed = true;
|
||||
entry.name = t.name;
|
||||
entry.type = t.type;
|
||||
delete entry.personality;
|
||||
entry.personalityTags = nextPersonalityTags;
|
||||
entry.alive = nextAlive;
|
||||
entry.generation = t.generation;
|
||||
entry.hasPaired = !!t.hasPaired;
|
||||
entry.deathReason = t.deathReason || entry.deathReason || "";
|
||||
entry.parents = nextParents;
|
||||
entry.parentNames = [...(t.parentNames || entry.parentNames || [])];
|
||||
entry.children = nextChildren;
|
||||
}
|
||||
if (changed) {
|
||||
this.familyVersion = (this.familyVersion || 0) + 1;
|
||||
this.markFamilyTreeDirty("family-record");
|
||||
}
|
||||
},
|
||||
|
||||
markFamilyTreeDirty(reason = "family") {
|
||||
this.familyTreeDirty = true;
|
||||
this.familyTreeDirtyReason = reason;
|
||||
this.familyTreeDirtyAt = this.time || 0;
|
||||
},
|
||||
|
||||
normalizeFamily() {
|
||||
if (!this.family) this.family = {};
|
||||
if (this.familyCleanVersion === (this.familyVersion || 0)) return false;
|
||||
const family = this.family;
|
||||
const liveById = new Map((this.tarinai || []).map(t => [this.tarinaiFamilyKey(t), t]).filter(([id]) => id));
|
||||
let changed = false;
|
||||
const uniqueIds = (list, allow) => Array.from(new Set((list || []).filter(id => id && (!allow || allow.has(id)))));
|
||||
const sameList = (a, b) => a.length === b.length && a.every((id, i) => id === b[i]);
|
||||
for (const t of this.tarinai || []) {
|
||||
const familyKey = this.tarinaiFamilyKey(t);
|
||||
if (!familyKey || (!this.family[familyKey] && !(t.hasPaired || (t.parents || []).length || (t.children || []).length))) continue;
|
||||
const before = this.familyVersion || 0;
|
||||
this.recordFamily(t);
|
||||
changed = changed || before !== (this.familyVersion || 0);
|
||||
}
|
||||
const known = new Set(Object.keys(family));
|
||||
for (const id of Object.keys(family)) {
|
||||
const n = family[id] || {};
|
||||
const live = liveById.get(id);
|
||||
const parents = uniqueIds(n.parents, known);
|
||||
const children = uniqueIds(n.children, known);
|
||||
if (live) {
|
||||
const liveParents = uniqueIds(live.parents, known);
|
||||
const liveChildren = uniqueIds(live.children, known);
|
||||
for (const p of liveParents) if (!parents.includes(p)) parents.push(p);
|
||||
for (const c of liveChildren) if (!children.includes(c)) children.push(c);
|
||||
}
|
||||
const next = {
|
||||
id,
|
||||
name: live?.name || n.name || id,
|
||||
type: live?.type || n.type || "smile",
|
||||
personalityTags: live ? getPersonalityTraitTags(live) : [...(n.personalityTags || [])],
|
||||
generation: Math.max(1, live?.generation || n.generation || 1),
|
||||
hasPaired: !!(live?.hasPaired || n.hasPaired),
|
||||
parents,
|
||||
parentNames: live?.parentNames ? [...live.parentNames] : [...(n.parentNames || [])],
|
||||
children,
|
||||
birthTime: live?.birthTime ?? n.birthTime ?? 0,
|
||||
alive: live ? !live.dead : n.alive !== false,
|
||||
deathReason: live?.deathReason || n.deathReason || "",
|
||||
};
|
||||
for (const key of Object.keys(next)) {
|
||||
const a = family[id]?.[key];
|
||||
const b = next[key];
|
||||
const equal = Array.isArray(a) && Array.isArray(b) ? sameList(a, b) : a === b;
|
||||
if (!equal) changed = true;
|
||||
}
|
||||
family[id] = next;
|
||||
}
|
||||
for (const child of Object.values(family)) {
|
||||
for (const parentId of child.parents || []) {
|
||||
const parent = family[parentId];
|
||||
if (!parent) continue;
|
||||
if (!parent.children.includes(child.id)) {
|
||||
parent.children.push(child.id);
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const parent of Object.values(family)) {
|
||||
const nextChildren = uniqueIds(parent.children, known).filter(childId => family[childId]?.parents?.includes(parent.id));
|
||||
if (!sameList(parent.children || [], nextChildren)) {
|
||||
parent.children = nextChildren;
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
for (const id of Object.keys(family)) {
|
||||
const n = family[id];
|
||||
if (!n?.hasPaired && !(n?.parents || []).length && !(n?.children || []).length) {
|
||||
delete family[id];
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
for (const [id, live] of liveById.entries()) {
|
||||
const n = family[id];
|
||||
if (!n) continue;
|
||||
if (!sameList(live.parents || [], n.parents || [])) {
|
||||
live.parents = [...(n.parents || [])];
|
||||
changed = true;
|
||||
}
|
||||
if (!sameList(live.children || [], n.children || [])) {
|
||||
live.children = [...(n.children || [])];
|
||||
changed = true;
|
||||
}
|
||||
if (live.hasPaired !== !!n.hasPaired) {
|
||||
live.hasPaired = !!n.hasPaired;
|
||||
changed = true;
|
||||
}
|
||||
if (live.generation !== n.generation) {
|
||||
live.generation = n.generation;
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
if (changed) {
|
||||
this.familyVersion = (this.familyVersion || 0) + 1;
|
||||
this.markFamilyTreeDirty("family-normalize");
|
||||
}
|
||||
this.familyCleanVersion = this.familyVersion || 0;
|
||||
return changed;
|
||||
},
|
||||
|
||||
resetFamilyTree() {
|
||||
this.family = {};
|
||||
this.familyCleanVersion = 0;
|
||||
this.familyVersion = (this.familyVersion || 0) + 1;
|
||||
this.markFamilyTreeDirty("family-reset");
|
||||
this.maxGeneration = 1;
|
||||
for (const t of this.tarinai || []) {
|
||||
t.parents = [];
|
||||
t.parentNames = [];
|
||||
t.children = [];
|
||||
t.generation = 1;
|
||||
t.hasPaired = false;
|
||||
}
|
||||
},
|
||||
|
||||
validateFamily() {
|
||||
this.normalizeFamily();
|
||||
const family = this.family || {};
|
||||
const issues = [];
|
||||
const seenRenderIds = new Set();
|
||||
for (const n of Object.values(family)) {
|
||||
if (!n?.id) continue;
|
||||
const childSeen = new Set();
|
||||
for (const p of n.parents || []) {
|
||||
if (!family[p]) issues.push({ type: "missing-parent", id: n.id, parent: p });
|
||||
else if (!family[p].children?.includes(n.id)) issues.push({ type: "missing-reciprocal-child", id: n.id, parent: p });
|
||||
}
|
||||
for (const c of n.children || []) {
|
||||
if (childSeen.has(c)) issues.push({ type: "duplicate-child", id: n.id, child: c });
|
||||
childSeen.add(c);
|
||||
if (!family[c]) issues.push({ type: "missing-child", id: n.id, child: c });
|
||||
else if (!family[c].parents?.includes(n.id)) issues.push({ type: "missing-reciprocal-parent", id: n.id, child: c });
|
||||
}
|
||||
if (seenRenderIds.has(n.id)) issues.push({ type: "duplicate-render-node", id: n.id });
|
||||
seenRenderIds.add(n.id);
|
||||
}
|
||||
return issues;
|
||||
},
|
||||
|
||||
clearLiveReferencesTo(dead) {
|
||||
const deadId = dead?.id || dead?.releasedLiveId || "";
|
||||
if (!deadId) return false;
|
||||
let changed = false;
|
||||
for (const other of this.tarinai || []) {
|
||||
if (!other || other === dead || other.dead) continue;
|
||||
if (other.target === dead || other.target?.id === deadId) {
|
||||
other.target = null;
|
||||
if (["seek_friend", "panic", "fight", "intimidate"].includes(other.state)) other.state = "idle";
|
||||
changed = true;
|
||||
}
|
||||
if (other.panicTarget === dead || other.panicTarget?.id === deadId) { other.panicTarget = null; changed = true; }
|
||||
if (other.fightTargetId === deadId) { other.fightTargetId = null; changed = true; }
|
||||
if (Array.isArray(other.fightTargetIds) && other.fightTargetIds.includes(deadId)) {
|
||||
other.fightTargetIds = other.fightTargetIds.filter(id => id !== deadId);
|
||||
changed = true;
|
||||
}
|
||||
for (const key of ["defeatedById", "fightWinnerId", "intimidateTargetId", "birthPartnerId"]) {
|
||||
if (other[key] === deadId) { other[key] = null; changed = true; }
|
||||
}
|
||||
}
|
||||
return changed;
|
||||
},
|
||||
|
||||
markDead(t, reason) {
|
||||
this.clearLiveReferencesTo(t);
|
||||
if (!this.family) this.family = {};
|
||||
const finalReason = t?.normalizeDeathReason ? t.normalizeDeathReason(reason) : reason;
|
||||
const familyKey = this.tarinaiFamilyKey(t);
|
||||
if (familyKey && this.family[familyKey]) {
|
||||
if (this.family[familyKey].alive !== false || this.family[familyKey].deathReason !== finalReason) {
|
||||
this.family[familyKey].alive = false;
|
||||
this.family[familyKey].deathReason = finalReason;
|
||||
delete this.family[familyKey].personality;
|
||||
this.familyVersion = (this.familyVersion || 0) + 1;
|
||||
this.markFamilyTreeDirty("death");
|
||||
}
|
||||
}
|
||||
this.familyPrunePending = true;
|
||||
},
|
||||
|
||||
pruneExtinctFamilies(opts = {}) {
|
||||
if (opts.normalize !== false) this.normalizeFamily();
|
||||
const family = this.family || {};
|
||||
const nodes = Object.values(family).filter(Boolean).filter(n => n.hasPaired || (n.parents || []).length || (n.children || []).length);
|
||||
if (!nodes.length) return;
|
||||
const ids = new Set(nodes.map(n => n.id));
|
||||
const graph = new Map();
|
||||
const add = (id) => { if (!graph.has(id)) graph.set(id, new Set()); };
|
||||
const link = (a, b) => {
|
||||
if (!a || !b || !ids.has(a) || !ids.has(b)) return;
|
||||
add(a); add(b);
|
||||
graph.get(a).add(b);
|
||||
graph.get(b).add(a);
|
||||
};
|
||||
for (const n of nodes) {
|
||||
add(n.id);
|
||||
for (const p of n.parents || []) link(n.id, p);
|
||||
for (const c of n.children || []) link(n.id, c);
|
||||
}
|
||||
const seen = new Set();
|
||||
const remove = [];
|
||||
for (const n of nodes) {
|
||||
if (seen.has(n.id)) continue;
|
||||
const stack = [n.id];
|
||||
const comp = [];
|
||||
seen.add(n.id);
|
||||
while (stack.length) {
|
||||
const id = stack.pop();
|
||||
comp.push(id);
|
||||
for (const next of graph.get(id) || []) {
|
||||
if (seen.has(next)) continue;
|
||||
seen.add(next);
|
||||
stack.push(next);
|
||||
}
|
||||
}
|
||||
if (!comp.some(id => family[id]?.alive)) remove.push(...comp);
|
||||
}
|
||||
if (!remove.length) return;
|
||||
for (const id of remove) delete family[id];
|
||||
this.familyVersion = (this.familyVersion || 0) + 1;
|
||||
this.markFamilyTreeDirty("family-prune");
|
||||
this.familyCleanVersion = this.familyVersion || 0;
|
||||
},
|
||||
|
||||
addTarinai(opts = {}) {
|
||||
const t = new Tarinai(this, opts);
|
||||
this.assignTarinaiLiveId(t);
|
||||
this.tarinai.push(t);
|
||||
this.drawListDirty = true;
|
||||
if (t.hasPaired || (t.parents || []).length || (t.children || []).length) this.recordFamily(t);
|
||||
this.maxGeneration = Math.max(this.maxGeneration, t.generation);
|
||||
return t;
|
||||
},
|
||||
|
||||
startBirthRitual(a, b) {
|
||||
if (!a || !b || a.dead || b.dead) return false;
|
||||
if (a.isZunchiSlave || b.isZunchiSlave) return false;
|
||||
if (this.areParentChild(a, b)) return false;
|
||||
if (a.sleepDisease || b.sleepDisease || a.fightDisease || b.fightDisease) return false;
|
||||
if (a.birthRitualTimer > 0.04 || b.birthRitualTimer > 0.04) return false;
|
||||
const aJoined = a.familyJoined ? a.familyJoined() : Boolean((a.parents || []).length || (a.children || []).length);
|
||||
const bJoined = b.familyJoined ? b.familyJoined() : Boolean((b.parents || []).length || (b.children || []).length);
|
||||
if (aJoined && !bJoined) b.generation = a.generation;
|
||||
else if (bJoined && !aJoined) a.generation = b.generation;
|
||||
else if (!aJoined && !bJoined) { a.generation = 1; b.generation = 1; }
|
||||
// Do not mark either parent as part of a family during the ritual.
|
||||
// The archive should only gain nodes after a child has actually been created;
|
||||
// otherwise childless ritual participants appear as isolated family trees.
|
||||
const duration = 10.0;
|
||||
a.birthRitualTimer = b.birthRitualTimer = duration;
|
||||
a.birthRitualMax = b.birthRitualMax = duration;
|
||||
a.birthPartnerId = b.id;
|
||||
b.birthPartnerId = a.id;
|
||||
a.birthRitualRole = -1;
|
||||
b.birthRitualRole = 1;
|
||||
a.birthRitualLeader = true;
|
||||
b.birthRitualLeader = false;
|
||||
a.state = b.state = "birth_ritual";
|
||||
a.target = b;
|
||||
b.target = a;
|
||||
a.reproductionTimer = CONFIG.reproductionCooldown + rand(2, 10);
|
||||
b.reproductionTimer = CONFIG.reproductionCooldown + rand(2, 10);
|
||||
a.surpriseTimer = Math.max(a.surpriseTimer, 0.35);
|
||||
b.surpriseTimer = Math.max(b.surpriseTimer, 0.35);
|
||||
return true;
|
||||
},
|
||||
|
||||
finishBirthRitual(a, b) {
|
||||
if (!a || !b || a.dead || b.dead) return null;
|
||||
const reproductionBlockedByDisease = a.sleepDisease || b.sleepDisease || a.fightDisease || b.fightDisease;
|
||||
a.birthRitualTimer = b.birthRitualTimer = 0;
|
||||
a.birthPartnerId = b.birthPartnerId = null;
|
||||
a.birthRitualLeader = b.birthRitualLeader = false;
|
||||
a.state = b.state = "idle";
|
||||
if (reproductionBlockedByDisease) {
|
||||
a.birthRitualRole = b.birthRitualRole = 0;
|
||||
return null;
|
||||
}
|
||||
a.fightTimer = b.fightTimer = 0;
|
||||
a.fightTargetIds = []; b.fightTargetIds = [];
|
||||
a.fightTargetId = b.fightTargetId = null;
|
||||
a.defeatedById = b.defeatedById = null;
|
||||
a.postBirthPeaceTimer = b.postBirthPeaceTimer = 18;
|
||||
a.fightCooldown = b.fightCooldown = Math.max(CONFIG.fightCooldown + 8, a.fightCooldown || 0, b.fightCooldown || 0);
|
||||
const children = [];
|
||||
const countRoll = Math.random();
|
||||
const childCount = countRoll < 0.08 ? 3 : (countRoll < 0.36 ? 2 : 1);
|
||||
for (let i = 0; i < childCount; i++) {
|
||||
const child = this.spawnChild(a, b, i, childCount);
|
||||
if (child) { child.postBirthPeaceTimer = 18; children.push(child); }
|
||||
}
|
||||
if (children.length > 0) this.lastBirthAt = this.time;
|
||||
if (children.length > 1) this.log(`${a.name}\u3068${b.name}\u306e\u5b50\u304c${children.length}\u5339\u751f\u307e\u308c\u305f\u3002`, "birth", { participants: [a, b, ...children] });
|
||||
return children[0] || null;
|
||||
},
|
||||
|
||||
areParentChild(a, b) {
|
||||
if (!a || !b) return false;
|
||||
const aId = this.tarinaiFamilyKey(a) || a;
|
||||
const bId = this.tarinaiFamilyKey(b) || b;
|
||||
if (!aId || !bId) return false;
|
||||
return Boolean((a.parents || []).includes(bId) || (a.children || []).includes(bId) || (b.parents || []).includes(aId) || (b.children || []).includes(aId));
|
||||
},
|
||||
|
||||
areCoParents(a, b) {
|
||||
if (!a || !b) return false;
|
||||
const aLiveId = a.id || a;
|
||||
const bLiveId = b.id || b;
|
||||
if (!aLiveId || !bLiveId || aLiveId === bLiveId) return false;
|
||||
if (a.birthPartnerId && a.birthPartnerId === bLiveId) return true;
|
||||
if (b.birthPartnerId && b.birthPartnerId === aLiveId) return true;
|
||||
const aId = this.tarinaiFamilyKey(a) || aLiveId;
|
||||
const bId = this.tarinaiFamilyKey(b) || bLiveId;
|
||||
if (!aId || !bId || aId === bId) return false;
|
||||
const aChildren = new Set((a.children || []).filter(Boolean));
|
||||
if (!aChildren.size) return false;
|
||||
for (const id of (b.children || [])) {
|
||||
if (aChildren.has(id)) return true;
|
||||
}
|
||||
return false;
|
||||
},
|
||||
|
||||
canStartFight(t) {
|
||||
if (!t || t.dead) return false;
|
||||
if (t.sleepDisease) return false;
|
||||
// Disease fight rule: explosion, zunchi, and fight disease can lash out;
|
||||
// sleep disease cannot fight or be challenged, and other diseases cannot start fights.
|
||||
if (t.explosionDisease || t.zunchiDisease || t.fightDisease) return true;
|
||||
const flag = (value) => typeof value === "function" ? Boolean(value.call(t)) : Boolean(value);
|
||||
const hasOtherDisease = flag(t.disease) || flag(t.sick) || flag(t.infection) || flag(t.hasDisease);
|
||||
if (hasOtherDisease) return false;
|
||||
return true;
|
||||
},
|
||||
|
||||
canBeFightTarget(t) {
|
||||
return Boolean(t && !t.dead && !t.sleepDisease);
|
||||
},
|
||||
|
||||
canFightPair(actor, target) {
|
||||
return this.canStartFight(actor) && this.canBeFightTarget(target);
|
||||
},
|
||||
|
||||
spawnChild(a, b, index = 0, total = 1) {
|
||||
const inherited = Math.random() < 0.56 ? a.type : b.type;
|
||||
const mutation = Math.random() < 0.18 ? baseSpriteId() : inherited;
|
||||
const childBirthPersonality = personalityFromParents(a, b);
|
||||
const child = this.addTarinai({
|
||||
type: mutation,
|
||||
birthPersonality: childBirthPersonality,
|
||||
currentPersonality: childBirthPersonality,
|
||||
name: makeName(),
|
||||
age: 0,
|
||||
x: (a.x + b.x) / 2 + rand(-14, 14) + (index - (total - 1) / 2) * 18,
|
||||
y: (a.y + b.y) / 2 + rand(-14, 14) + (total > 1 ? rand(-10, 10) : 0),
|
||||
scale: rand(0.17, 0.23),
|
||||
hunger: rand(20, 40),
|
||||
loneliness: rand(30, 56),
|
||||
energy: rand(55, 95),
|
||||
stress: rand(0, 14),
|
||||
need: Math.random() < 0.6 ? pick([a.need, b.need]) : pick(NEEDS),
|
||||
generation: Math.max(a.generation, b.generation) + 1,
|
||||
lifeSpan: rand(1500, 2400),
|
||||
parents: [this.tarinaiFamilyKey(a), this.tarinaiFamilyKey(b)],
|
||||
parentNames: [a.name, b.name],
|
||||
birthTime: this.time,
|
||||
});
|
||||
this.maxGeneration = Math.max(this.maxGeneration, child.generation);
|
||||
a.hasPaired = true;
|
||||
b.hasPaired = true;
|
||||
a.affection = 0; b.affection = 0;
|
||||
a.loneliness *= 0.65; b.loneliness *= 0.65;
|
||||
a.adjustRelation?.(b, 0.65, -0.20, "co_parent");
|
||||
b.adjustRelation?.(a, 0.65, -0.20, "co_parent");
|
||||
a.postBirthPeaceTimer = Math.max(a.postBirthPeaceTimer || 0, 28);
|
||||
b.postBirthPeaceTimer = Math.max(b.postBirthPeaceTimer || 0, 28);
|
||||
const childKey = this.tarinaiFamilyKey(child);
|
||||
const aKey = this.tarinaiFamilyKey(a);
|
||||
const bKey = this.tarinaiFamilyKey(b);
|
||||
a.children.push(childKey);
|
||||
b.children.push(childKey);
|
||||
this.recordFamily(a);
|
||||
this.recordFamily(b);
|
||||
this.recordFamily(child);
|
||||
if (this.family[aKey] && !this.family[aKey].children.includes(childKey)) this.family[aKey].children.push(childKey);
|
||||
if (this.family[bKey] && !this.family[bKey].children.includes(childKey)) this.family[bKey].children.push(childKey);
|
||||
this.familyCleanVersion = null;
|
||||
audio.birth();
|
||||
this.lastBirthAt = this.time;
|
||||
if (total <= 1) this.log(`${child.name}\u304c${a.name}\u3068${b.name}\u306e\u5b50\u3068\u3057\u3066\u751f\u307e\u308c\u305f\u3002`, "birth", { participants: [child, a, b] });
|
||||
return child;
|
||||
},
|
||||
|
||||
startForcedFight(a, b) {
|
||||
if (!a || !b || a === b || a.dead || b.dead) return false;
|
||||
if (!this.canFightPair(a, b)) return false;
|
||||
const alreadyFighting = a.fightTimer > 0.04 && b.fightTimer > 0.04 && ((a.fightTargetIds || []).includes(b.id) || a.fightTargetId === b.id);
|
||||
if (alreadyFighting) return true;
|
||||
for (const t of [a, b]) {
|
||||
t.birthRitualTimer = 0;
|
||||
t.birthRitualMax = 0;
|
||||
t.birthPartnerId = null;
|
||||
t.birthRitualLeader = false;
|
||||
t.birthRitualRole = 0;
|
||||
t.postBirthPeaceTimer = 0;
|
||||
t.fightCooldown = 0;
|
||||
t.intimidateTimer = 0;
|
||||
t.intimidateTargetId = null;
|
||||
t.intimidatedTimer = 0;
|
||||
t.defeatedTimer = 0;
|
||||
t.defeatedById = null;
|
||||
t.fightWinnerId = null;
|
||||
t.target = null;
|
||||
t.state = "idle";
|
||||
}
|
||||
this.startFightMochiIntimidation(a, b);
|
||||
this.startFight(a, b);
|
||||
return true;
|
||||
},
|
||||
|
||||
startFightMochiIntimidation(a, b) {
|
||||
if (!a || !b || a.dead || b.dead) return false;
|
||||
const aDrug = (a.fightMochiTimer || 0) > 0.04;
|
||||
const bDrug = (b.fightMochiTimer || 0) > 0.04;
|
||||
const actor = aDrug && !bDrug ? a : (!aDrug && bDrug ? b : (a.energy + a.stress * 0.36 >= b.energy + b.stress * 0.36 ? a : b));
|
||||
const target = actor === a ? b : a;
|
||||
if (!this.canFightPair(actor, target)) return false;
|
||||
actor.intimidateTimer = Math.max(actor.intimidateTimer || 0, rand(0.85, 1.35));
|
||||
actor.intimidateTargetId = target.id;
|
||||
actor.surpriseTimer = Math.max(actor.surpriseTimer || 0, 0.28);
|
||||
target.intimidatedTimer = Math.max(target.intimidatedTimer || 0, rand(0.75, 1.25));
|
||||
target.fearTimer = Math.max(target.fearTimer || 0, 0.72 * target.personalityProfile().fear);
|
||||
actor.adjustRelation(target, -0.05, 0.06, "intimidate");
|
||||
target.adjustRelation(actor, -0.12, 0.30 * target.personalityProfile().fear, "intimidate");
|
||||
this.effects.push(new Effect("ring", actor.x, actor.y - actor.radius * 0.65, {
|
||||
life: 0.34,
|
||||
size: actor.radius * 0.62,
|
||||
color: "rgba(154, 88, 42, 0.74)",
|
||||
}));
|
||||
this.spawnBubble(actor.x, actor.y - actor.radius * 1.30, "!", "rgba(120,62,38,0.82)");
|
||||
return true;
|
||||
},
|
||||
|
||||
startConflict(a, b) {
|
||||
if (!a || !b || a.dead || b.dead) return;
|
||||
if ((a.fightMochiTimer || 0) > 0.04 || (b.fightMochiTimer || 0) > 0.04) { this.startForcedFight(a, b); return; }
|
||||
if (this.areParentChild(a, b) || this.areCoParents?.(a, b)) return;
|
||||
if ((a.postBirthPeaceTimer || 0) > 0 || (b.postBirthPeaceTimer || 0) > 0) return;
|
||||
if (a.fightTimer > 0.04 || b.fightTimer > 0.04 || a.intimidateTimer > 0.04 || b.intimidateTimer > 0.04) return;
|
||||
const aAggressiveIntent = a.shouldApplyPersonalityBehavior?.("aggression", 1) ? 1 : 0;
|
||||
const bAggressiveIntent = b.shouldApplyPersonalityBehavior?.("aggression", 1) ? 1 : 0;
|
||||
const scoreA = a.energy * 0.38 + a.mood * 0.18 + a.stress * 0.12 + (a.type === "angry" ? 12 : 0) + aAggressiveIntent * 8 + ((b.relationTo(a.id).fear || 0) * 0.65) + (a.isZunchiSlave ? -10 : 0) + ((a.fightMochiTimer || 0) > 0.04 ? 9 : 0) + rand(-5, 5);
|
||||
const scoreB = b.energy * 0.38 + b.mood * 0.18 + b.stress * 0.12 + (b.type === "angry" ? 12 : 0) + bAggressiveIntent * 8 + ((a.relationTo(b.id).fear || 0) * 0.65) + (b.isZunchiSlave ? -10 : 0) + ((b.fightMochiTimer || 0) > 0.04 ? 9 : 0) + rand(-5, 5);
|
||||
const actor = scoreA >= scoreB ? a : b;
|
||||
const target = actor === a ? b : a;
|
||||
if (!this.canFightPair(actor, target)) return;
|
||||
const actorScore = actor === a ? scoreA : scoreB;
|
||||
const targetScore = actor === a ? scoreB : scoreA;
|
||||
const canIntimidate = !actor.lowHealthSprite || !actor.lowHealthSprite();
|
||||
const battleDrug = (actor.fightMochiTimer || 0) > 0.04 || (target.fightMochiTimer || 0) > 0.04;
|
||||
const intimidationChance = clamp(0.40 + (battleDrug ? 0.24 : 0) + (target.isZunchiSlave ? 0.18 : 0), 0.24, 0.90);
|
||||
if (canIntimidate && Math.random() < intimidationChance) {
|
||||
this.startIntimidation(actor, target, actorScore, targetScore);
|
||||
return;
|
||||
}
|
||||
this.startFight(a, b);
|
||||
},
|
||||
|
||||
startIntimidation(actor, target, actorScore = 0, targetScore = 0) {
|
||||
if (!actor || !target || actor.dead || target.dead) return false;
|
||||
if (actor.lowHealthSprite && actor.lowHealthSprite()) return false;
|
||||
const fearLoad = (target.relationTo(actor.id).fear || 0) * 0.72 + target.personalityProfile().fear * 8;
|
||||
const resistance = target.energy * 0.30 + target.mood * 0.16 + (target.shouldApplyPersonalityBehavior?.("aggression", 1) ? 5 : 0) + rand(-5, 5);
|
||||
const successChance = clamp(0.62 + (actorScore - targetScore + fearLoad - resistance) / 76, 0.50, 0.96);
|
||||
actor.surpriseTimer = Math.max(actor.surpriseTimer, 0.20);
|
||||
target.surpriseTimer = Math.max(target.surpriseTimer, 0.32);
|
||||
actor.fightCooldown = CONFIG.fightCooldown + rand(1, 4);
|
||||
target.fightCooldown = CONFIG.fightCooldown + rand(1, 4);
|
||||
actor.intimidateTimer = Math.max(actor.intimidateTimer, rand(2.45, 3.35));
|
||||
actor.intimidateTargetId = target.id;
|
||||
actor.state = "intimidate";
|
||||
this.effects.push(new Effect("ring", actor.x, actor.y - actor.radius * 0.65, {
|
||||
life: 0.42,
|
||||
size: actor.radius * 0.55,
|
||||
color: "rgba(145, 106, 55, 0.70)",
|
||||
}));
|
||||
this.spawnBubble(actor.x, actor.y - actor.radius * 1.30, "\u306f\u3046\u30fc\uff01", "rgba(92,62,34,0.82)");
|
||||
target.intimidatedTimer = Math.max(target.intimidatedTimer || 0, rand(1.65, 2.45));
|
||||
target.fearTimer = Math.max(target.fearTimer, 0.65 * target.personalityProfile().fear);
|
||||
if (Math.random() >= successChance) {
|
||||
target.adjustRelation(actor, -0.08, 0.22 * target.personalityProfile().fear, "intimidate");
|
||||
return true;
|
||||
}
|
||||
target.defeatedById = actor.id;
|
||||
target.fightWinnerId = actor.id;
|
||||
target.defeatedTimer = Math.max(target.defeatedTimer, rand(2.8, 4.2));
|
||||
target.fearTimer = Math.max(target.fearTimer, 1.35 * target.personalityProfile().fear);
|
||||
target.intimidatedTimer = Math.max(target.intimidatedTimer || 0, rand(2.4, 3.4));
|
||||
target.state = "panic";
|
||||
target.target = actor;
|
||||
this.spawnBubble(target.x, target.y - target.radius * 1.28, "\u306f\u3041\u3041\u3041\uff01", "rgba(84,66,86,0.80)");
|
||||
target.vx += (target.x < actor.x ? -1 : 1) * rand(26, 54);
|
||||
target.vy += rand(-18, 18);
|
||||
actor.adjustRelation(target, -0.08, 0.06, "intimidate");
|
||||
target.adjustRelation(actor, -0.22, 0.85 * target.personalityProfile().fear, "intimidate");
|
||||
if (this.time - Math.max(actor.lastLog, target.lastLog) > 5.5) {
|
||||
this.log(`${actor.name}\u306f${target.name}\u3092\u5a01\u5687\u3057\u3066\u8ffd\u3044\u6255\u3063\u305f\u3002`, "fight", { participants: [actor, target] });
|
||||
actor.lastLog = target.lastLog = this.time;
|
||||
}
|
||||
return true;
|
||||
},
|
||||
|
||||
startFight(a, b) {
|
||||
if (!a || !b || a.dead || b.dead) return;
|
||||
if (!this.canFightPair(a, b) && !this.canFightPair(b, a)) return;
|
||||
if ((a.postBirthPeaceTimer || 0) > 0 || (b.postBirthPeaceTimer || 0) > 0) return;
|
||||
a.state = "fight"; b.state = "fight";
|
||||
a.fightTimer = Math.max(a.fightTimer, rand(4.5, 7.0));
|
||||
b.fightTimer = Math.max(b.fightTimer, rand(4.5, 7.0));
|
||||
a.nextHeadbutt = this.time + rand(0.08, 0.18);
|
||||
b.nextHeadbutt = a.nextHeadbutt;
|
||||
a.fightCooldown = CONFIG.fightCooldown + rand(1, 5);
|
||||
b.fightCooldown = CONFIG.fightCooldown + rand(1, 5);
|
||||
if (!a.fightTargetIds) a.fightTargetIds = [];
|
||||
if (!b.fightTargetIds) b.fightTargetIds = [];
|
||||
if (!a.fightTargetIds.includes(b.id)) a.fightTargetIds.push(b.id);
|
||||
if (!b.fightTargetIds.includes(a.id)) b.fightTargetIds.push(a.id);
|
||||
a.fightTargetIds = a.fightTargetIds.slice(-4);
|
||||
b.fightTargetIds = b.fightTargetIds.slice(-4);
|
||||
a.fightTargetId = a.fightTargetIds[0];
|
||||
b.fightTargetId = b.fightTargetIds[0];
|
||||
const aAggressiveIntent = a.shouldApplyPersonalityBehavior?.("aggression", 1) ? 1 : 0;
|
||||
const bAggressiveIntent = b.shouldApplyPersonalityBehavior?.("aggression", 1) ? 1 : 0;
|
||||
const aScore = a.energy * 0.52 + a.mood * 0.30 + (a.type === "angry" ? 10 : 0) + aAggressiveIntent * 5 + ((a.fightMochiTimer || 0) > 0.04 ? 12 : 0) + (a.isZunchiSlave ? -14 : 0) + rand(-7, 7);
|
||||
const bScore = b.energy * 0.52 + b.mood * 0.30 + (b.type === "angry" ? 10 : 0) + bAggressiveIntent * 5 + ((b.fightMochiTimer || 0) > 0.04 ? 12 : 0) + (b.isZunchiSlave ? -14 : 0) + rand(-7, 7);
|
||||
const loser = aScore <= bScore ? a : b;
|
||||
const winner = loser === a ? b : a;
|
||||
loser.defeatedById = winner.id;
|
||||
loser.fightWinnerId = winner.id;
|
||||
winner.fightWinnerId = winner.id;
|
||||
winner.defeatedById = null;
|
||||
winner.defeatedTimer = 0;
|
||||
a.addStress ? a.addStress(rand(8, 18), { threshold: 8 }) : (a.stress = clamp(a.stress + rand(8, 18), 0, 130));
|
||||
b.addStress ? b.addStress(rand(8, 18), { threshold: 8 }) : (b.stress = clamp(b.stress + rand(8, 18), 0, 130));
|
||||
a.damage(b.outgoingDamage ? b.outgoingDamage(rand(2, 7)) : rand(2, 7), "\u55a7\u5629");
|
||||
b.damage(a.outgoingDamage ? a.outgoingDamage(rand(2, 7)) : rand(2, 7), "\u55a7\u5629");
|
||||
const dx = b.x - a.x, dy = b.y - a.y;
|
||||
const d = Math.hypot(dx, dy) || 1;
|
||||
a.vx -= dx / d * rand(32, 62); a.vy -= dy / d * rand(32, 62);
|
||||
b.vx += dx / d * rand(32, 62); b.vy += dy / d * rand(32, 62);
|
||||
a.surpriseTimer = 0.24; b.surpriseTimer = 0.24;
|
||||
this.effects.push(new Effect("fight", (a.x + b.x) / 2, (a.y + b.y) / 2 - 8, {
|
||||
size: rand(12, 20),
|
||||
life: rand(0.32, 0.52),
|
||||
color: "rgba(116, 73, 38, 0.82)",
|
||||
}));
|
||||
audio.fight();
|
||||
if (this.time - Math.max(a.lastLog, b.lastLog) > 6) {
|
||||
this.log(`${a.name}\u3068${b.name}\u304c\u5c0f\u3055\u306a\u55a7\u5629\u3092\u3057\u305f\u3002`, "fight", { participants: [a, b] });
|
||||
a.lastLog = b.lastLog = this.time;
|
||||
}
|
||||
}
|
||||
}));
|
||||
})(typeof window !== "undefined" ? window : globalThis);
|
||||
Loading…
Add table
Add a link
Reference in a new issue