@7ots/cli 0.1.6 → 0.1.8

package/src/character3d/model.js

@@ -0,0 +1,367 @@
+/**
+ * Mod de cuerpo completo: un modelo 3D (VRM o GLB) en lugar del cuerpo procedural del ot.
+ *
+ * El modelo vive dentro del mismo `rig` de Character3D, así que gestos sin animación propia,
+ * efectos, ánimos y el encuadre siguen funcionando. Lo que el modelo traiga se aprovecha:
+ *   - VRM (0.x y 1.0): expresiones estándar (aa/ih/ou/ee/oh, blink, happy, angry, sad,
+ *     relaxed, surprised) y el hueso de la cabeza para mirar.
+ *   - GLB: morph targets por nombre (blink, jawOpen/mouthOpen, happy/smile, sad, angry,
+ *     surprised) y un hueso «head» si lo hay.
+ *   - Animaciones: «idle» en bucle; las que se llamen como un gesto (wave, dance, yes, no,
+ *     jump, thumbsup…) sustituyen a la pose procedural de ese gesto.
+ * Unidades: el modelo se escala a la altura de un ot (su caja), con y hacia arriba y de frente a +z
+ * (los VRM 0.x miran a -z y se giran solos).
+ */
+
+import * as THREE from 'three';
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+import { layout } from '../character/Character.js';
+import { EASE, clamp, approach } from '../character/motion.js';
+import { U } from './body.js';
+import { shadowTexture } from './materials.js';
+
+const DEG = Math.PI / 180;
+const TAU = Math.PI * 2;
+
+/** Animación del modelo para cada gesto de 7ots (por nombre del clip). */
+const CLIP_FOR = {
+  wave: /wave|hello|greet|hi\b/i,
+  dance: /dance/i,
+  celebrate: /victory|celebrat|cheer|dance/i,
+  jump: /jump/i,
+  bounce: /jump|hop/i,
+  nod: /\byes\b|nod/i,
+  shake: /^no$|\bno\b|shake_?head/i,
+  thumbsup: /thumbs?_?up|\byes\b/i,
+  thumbsdown: /thumbs?_?down|\bno\b/i,
+  bow: /bow/i,
+  think: /think/i,
+  clap: /clap/i,
+  point: /point/i,
+  laugh: /laugh/i,
+  stomp: /stomp|punch/i,
+  shrug: /shrug/i,
+  dizzy: /dizz|death|die/i,
+  yawn: /yawn|sit/i,
+  fly: /fly/i,
+};
+const IDLE = /idle|breath|stand/i;
+
+/** Nombre de expresión VRM 0.x → VRM 1.0. */
+const VRM0 = { a: 'aa', i: 'ih', u: 'ou', e: 'ee', o: 'oh', joy: 'happy', sorrow: 'sad', fun: 'relaxed', angry: 'angry', blink: 'blink', surprised: 'surprised' };
+/** Morph targets de un GLB cualquiera → expresión. */
+const MORPH_NAMES = [
+  ['aa', /jaw_?open|mouth_?open|viseme_?aa|^v_?aa$|^aa$|^a$/i],
+  ['oh', /viseme_?(oh|o|ou)$|^oh$|^o$|mouth_?(funnel|pucker)/i],
+  ['blink', /^blink$|blink_?both|eyes?_?clos|^eyeblink$|^blink/i],
+  ['happy', /happy|joy|smile/i],
+  ['sad', /sad|sorrow/i],
+  ['angry', /angry|anger|\bmad\b/i],
+  ['surprised', /surpris|shock/i],
+];
+/** Ánimo de 7ots → expresiones del modelo (con su peso). */
+const MOOD_EXPR = {
+  happy: { happy: 0.8 },
+  love: { happy: 0.7, relaxed: 0.3 },
+  angry: { angry: 0.85 },
+  disgust: { angry: 0.5 },
+  sad: { sad: 0.85 },
+  fear: { surprised: 0.5, sad: 0.3 },
+  surprised: { surprised: 0.9 },
+  sleep: { relaxed: 0.6 },
+};
+
+function loadGltf(url) {
+  return new Promise((res, rej) => {
+    const loader = new GLTFLoader();
+    if (url.startsWith('data:')) {
+      const bin = atob(url.slice(url.indexOf(',') + 1));
+      const buf = new Uint8Array(bin.length);
+      for (let i = 0; i < bin.length; i++) buf[i] = bin.charCodeAt(i);
+      loader.parse(buf.buffer, '', res, rej);
+    } else loader.load(url, res, undefined, rej);
+  });
+}
+
+const meshesUnder = (obj) => {
+  const out = [];
+  obj.traverse((o) => { if (o.isMesh && o.morphTargetInfluences) out.push(o); });
+  return out;
+};
+
+/** Expresiones del modelo: { nombre: [{ mesh, index, w }] }. */
+async function expressionsOf(gltf) {
+  const ex = {};
+  const add = (name, mesh, index, w) => { if (Number.isInteger(index)) (ex[name] ||= []).push({ mesh, index, w }); };
+  const { parser } = gltf;
+  const ext = parser.json.extensions || {};
+  if (ext.VRMC_vrm) {
+    const all = { ...ext.VRMC_vrm.expressions?.preset, ...ext.VRMC_vrm.expressions?.custom };
+    for (const [name, e] of Object.entries(all)) {
+      for (const b of e?.morphTargetBinds || []) {
+        const node = await parser.getDependency('node', b.node).catch(() => null);
+        if (node) for (const m of meshesUnder(node)) add(name, m, b.index, b.weight ?? 1);
+      }
+    }
+  } else if (ext.VRM) {
+    const byMesh = new Map();
+    gltf.scene.traverse((o) => {
+      const a = parser.associations.get(o);
+      if (o.isMesh && a?.meshes != null) (byMesh.get(a.meshes) || byMesh.set(a.meshes, []).get(a.meshes)).push(o);
+    });
+    for (const g of ext.VRM.blendShapeMaster?.blendShapeGroups || []) {
+      const name = VRM0[String(g.presetName || '').toLowerCase()];
+      if (!name) continue;
+      for (const b of g.binds || []) for (const m of byMesh.get(b.mesh) || []) add(name, m, b.index, (b.weight ?? 100) / 100);
+    }
+  } else {
+    gltf.scene.traverse((o) => {
+      if (!o.isMesh || !o.morphTargetDictionary) return;
+      for (const [key, index] of Object.entries(o.morphTargetDictionary)) {
+        const hit = MORPH_NAMES.find(([, re]) => re.test(key));
+        if (hit) add(hit[0], o, index, 1);
+      }
+    });
+  }
+  return ex;
+}
+
+/** Hueso de la cabeza (VRM humanoid, o el primer hueso «head»). */
+async function headOf(gltf) {
+  const { parser } = gltf;
+  const ext = parser.json.extensions || {};
+  const idx = ext.VRMC_vrm?.humanoid?.humanBones?.head?.node ?? ext.VRM?.humanoid?.humanBones?.find((b) => b.bone === 'head')?.node;
+  if (idx != null) return parser.getDependency('node', idx).catch(() => null);
+  let head = null;
+  const re = /^(mixamorig:?)?head$|^head[_\d]*$/i;
+  gltf.scene.traverse((o) => { if (!head && o.isBone && re.test(o.name)) head = o; });
+  // sin esqueleto: un nodo «head» rígido (modelos hechos por partes) también sirve
+  if (!head) gltf.scene.traverse((o) => { if (!head && !o.isMesh && re.test(o.name)) head = o; });
+  return head;
+}
+
+/**
+ * Construye el ot como modelo (llamado desde Character3D.build con la ficha ya resuelta).
+ * `this` es la instancia de Character3D.
+ */
+export function buildModel(s) {
+  const m = s._model;
+  const L = (this.L = layout(s));
+  const W = (this.W = L.box.w * U);
+  const H = (this.H = Math.max(L.box.h * U, W) * 1.2);
+  this.modelMode = true;
+  this.kk = Math.sqrt(W * H) / 1.25;
+  this.depth = W * 0.6;
+  this.furLen = 0;
+  this.plush = false;
+  this.maxShells = 0;
+  this.pal = { body: s.body.color };
+  this.furs = [];
+  this.parts = [];
+  this.anims = [];
+  this.bodyMeshes = [];
+  this.eyes = [];
+  this.brows = [];
+  this.hands = [];
+  this.eyeY = H * 0.86;
+  this.r3 = W * 0.07;
+  this.model = { ex: {}, w: {}, head: null, q0: null, mixer: null, clips: [], idle: null, act: null, ready: false };
+  this.fxc = { W, H, D: this.depth, eyeY: this.eyeY, r: this.r3, sp: W * 0.12, mouth: new THREE.Vector3(0, H * 0.78, this.depth * 0.5), low: this.quality === 'low', tears: [] };
+
+  const sh = new THREE.Mesh(new THREE.PlaneGeometry(1, 1), new THREE.MeshBasicMaterial({ map: shadowTexture(), transparent: true, depthWrite: false, toneMapped: false }));
+  sh.rotation.x = -Math.PI / 2;
+  sh.position.y = 0.002;
+  sh.scale.set(W * 1.2, this.depth * 2, 1);
+  sh.renderOrder = -1;
+  this.shadow = sh;
+  this.root.add(sh);
+
+  // caja provisional mientras carga (el encuadre se rehace al llegar el modelo)
+  this.bounds = new THREE.Box3(new THREE.Vector3(-W / 2, 0, -this.depth / 2), new THREE.Vector3(W / 2, H, this.depth / 2));
+  this.boundsRev = (this.boundsRev || 0) + 1;
+
+  const tok = (this.modelTok = {});
+  loadGltf(m.url)
+    .then(async (gltf) => {
+      if (this.modelTok !== tok) return;
+      const scene = gltf.scene;
+      const ext = gltf.parser.json.extensions || {};
+      if (ext.VRM) scene.rotation.y = Math.PI; // VRM 0.x mira a -z
+      scene.traverse((o) => {
+        if (!o.isMesh) return;
+        o.frustumCulled = false;
+        if (!Array.isArray(o.material)) o.userData.ownMaterial = true;
+      });
+      scene.updateMatrixWorld(true);
+      const box = new THREE.Box3().setFromObject(scene);
+      const size = box.getSize(new THREE.Vector3());
+      const c = box.getCenter(new THREE.Vector3());
+      if (!(size.y > 0)) throw new Error('empty model');
+      scene.position.set(-c.x, -box.min.y, -c.z);
+      const holder = new THREE.Group();
+      holder.add(scene);
+      const k = (H / size.y) * m.scale;
+      holder.scale.setScalar(k);
+      holder.rotation.y = m.rot * DEG;
+      holder.position.y = m.y * H;
+      this.rig.add(holder);
+
+      const md = this.model;
+      md.ex = await expressionsOf(gltf);
+      md.head = await headOf(gltf);
+      if (this.modelTok !== tok) return;
+      if (md.head) md.q0 = md.head.quaternion.clone();
+      if (gltf.animations.length) {
+        md.mixer = new THREE.AnimationMixer(scene);
+        md.clips = gltf.animations;
+        const idle = md.clips.find((a) => IDLE.test(a.name));
+        if (idle) {
+          md.idle = md.mixer.clipAction(idle);
+          md.idle.play();
+        }
+        md.mixer.addEventListener('finished', (e) => {
+          if (e.action !== md.act) return;
+          md.act = null;
+          e.action.fadeOut(0.25);
+          md.idle?.reset().fadeIn(0.25).play();
+        });
+      }
+      md.ready = true;
+
+      // encuadre y puntos de los efectos con el modelo real
+      this.rig.updateMatrixWorld(true);
+      const rb = new THREE.Box3().setFromObject(holder);
+      this.bounds = rb;
+      this.depth = Math.max(0.05, rb.max.z - rb.min.z);
+      this.W = Math.max(0.05, rb.max.x - rb.min.x);
+      this.shadow.scale.set(this.W * 1.1, this.depth * 1.6, 1);
+      if (md.head) {
+        const hp = md.head.getWorldPosition(new THREE.Vector3());
+        this.rig.worldToLocal(hp);
+        this.eyeY = this.fxc.eyeY = hp.y + H * 0.04;
+        this.fxc.mouth.set(hp.x, hp.y - H * 0.01, rb.max.z * 0.6);
+      }
+      this.fxc.W = this.W;
+      this.fxc.D = this.depth;
+      this.boundsRev++;
+    })
+    .catch((e) => {
+      if (this.modelTok !== tok) return;
+      console.warn('[7ots] modelo 3D del mod no disponible:', e?.message || e);
+      // sin modelo: un ot normal (la ficha sin el modelo)
+      const { _model, ...rest } = s;
+      this.modelFailed = m.url;
+      this.build({ ...rest, mods: (rest.mods || []).filter((x) => !x.model) });
+    });
+}
+
+/** Gesto con la animación propia del modelo, si la trae. Devuelve true si la usó. */
+export function modelGesture(name) {
+  const md = this.model;
+  if (!md?.mixer) return false;
+  const re = CLIP_FOR[name];
+  const clip = re && md.clips.find((a) => re.test(a.name) && !IDLE.test(a.name));
+  if (!clip) return false;
+  const a = md.mixer.clipAction(clip);
+  if (md.act && md.act !== a) md.act.fadeOut(0.2);
+  a.reset();
+  a.setLoop(THREE.LoopOnce, 1);
+  a.clampWhenFinished = false;
+  a.fadeIn(0.2).play();
+  md.idle?.fadeOut(0.2);
+  md.act = a;
+  return true;
+}
+
+/** Un frame del ot-modelo (equivale a Character3D.tick). */
+export function tickModel(t, dt) {
+  const rm = typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches;
+  const idle = this.opts.idle !== false;
+  const md = this.model;
+  if (idle && t >= this.nextBlink) {
+    if (this.moodName !== 'sleep' && !rm) {
+      this.blinkAt = t;
+      if (t - this.look.at > 3000 && Math.random() < 0.45) {
+        this.look.tx = Math.random() < 0.5 ? 0 : (Math.random() - 0.5) * 0.9;
+        this.look.ty = Math.random() < 0.5 ? 0 : (Math.random() - 0.5) * 0.5;
+      }
+    }
+    this.nextBlink = t + 1800 + Math.random() * 3600;
+  }
+  if (this.speech && !this.speech.tick(t)) this.endSpeech();
+  const mo = this.mo;
+  mo.open = approach(mo.open, mo.target, dt, mo.target > mo.open ? 35 : 70);
+  mo.msx = approach(mo.msx, mo.tmsx, dt, 60);
+  const look = this.look;
+  look.x = rm ? look.tx : approach(look.x, look.tx, dt, 70);
+  look.y = rm ? look.ty : approach(look.y, look.ty, dt, 70);
+  this.sleepK = approach(this.sleepK, this.moodName === 'sleep' ? 1 : 0, dt, rm ? 1 : 260);
+
+  // gesto: la animación del modelo, o la pose procedural sobre todo el cuerpo
+  const pose = { x: 0, y: 0, r: 0, sx: 1, sy: 1, blink: 0 };
+  let spin = 0;
+  const gest = this.gest;
+  if (gest) {
+    const age = t - gest.start;
+    const tt = clamp(age / gest.ms);
+    if (gest.clip === undefined) gest.clip = md.ready && this.modelGesture(gest.name);
+    if (!gest.clip) {
+      Object.assign(pose, gest.def.pose(tt, rm ? 0 : age, gest));
+      if (gest.dir < 0) { pose.x = -pose.x; pose.r = -pose.r; }
+      pose.sx = 1 + (pose.sx - 1) * 0.4; // un muñeco se aplasta menos que un ot
+      pose.sy = 1 + (pose.sy - 1) * 0.4;
+      if (gest.name === 'spin') spin = EASE.inOut(clamp((tt - 0.12) / 0.76)) * TAU;
+    }
+    for (const f of gest.def.fx || []) {
+      if (tt >= f[0] && !gest.fired.has(f)) {
+        gest.fired.add(f);
+        this.effect(f[1], { dir: gest.dir, ...(f[2] || {}) });
+      }
+    }
+    if (tt >= 1) this.endGesture();
+  }
+  if (rm) Object.assign(pose, { x: 0, y: 0, r: 0, sx: 1, sy: 1 });
+  const { ksx, ksy } = this.tickMorphs(t, rm);
+
+  const W = this.W;
+  const H = this.H;
+  const sec = t / 1000;
+  const breath = rm || !idle || md.idle ? 0 : Math.sin(sec * TAU / 3.4 + this.phase);
+  const rig = this.rig;
+  rig.position.set(pose.x * W, -pose.y * H, 0);
+  rig.rotation.set(md.head ? 0 : look.y * 0.1, this.yaw + look.x * (md.head ? 0.12 : 0.3) + spin + (rm || !idle ? 0 : Math.sin(sec * 0.7 + this.phase) * 0.03), -(pose.r + look.x * 1.5) * DEG);
+  rig.scale.set(pose.sx * ksx * (1 - 0.004 * breath), pose.sy * ksy * (1 + 0.01 * breath), pose.sx * ksx);
+  const air = Math.max(0, -pose.y);
+  this.shadow.material.opacity = 1 - air * 1.5;
+
+  // animaciones y cabeza
+  if (md.head && md.q0) md.head.quaternion.copy(md.q0);
+  md.mixer?.update(rm ? 0 : dt / 1000);
+  if (md.head && md.head.parent) {
+    const pw = md.head.parent.getWorldQuaternion(new THREE.Quaternion());
+    const rw = rig.getWorldQuaternion(new THREE.Quaternion());
+    const d = new THREE.Quaternion().setFromEuler(new THREE.Euler(look.y * 0.35, look.x * 0.55, 0, 'YXZ'));
+    d.premultiply(rw).multiply(rw.clone().invert()); // giro en el espacio del ot
+    md.head.quaternion.premultiply(pw.clone().invert().multiply(d).multiply(pw));
+  }
+
+  // expresiones
+  const blink = Math.max(this.blinkValue(t), pose.blink, this.sleepK > 0.02 ? Math.min(1, this.sleepK * 1.1) : 0);
+  const round = clamp((1 - mo.msx) / 0.35);
+  const want = { ...(MOOD_EXPR[this.moodName] || {}) };
+  for (const k in md.w) if (!(k in want)) want[k] = 0;
+  for (const k in want) md.w[k] = rm ? want[k] : approach(md.w[k] || 0, want[k], dt, 120);
+  const val = { ...md.w, blink: Math.max(blink, md.w.blink || 0), aa: mo.open * (md.ex.oh ? 1 - round : 1), oh: mo.open * round };
+  if (val.happy > 0.3) val.blink = Math.max(val.blink * (1 - val.happy), 0); // VRM: happy ya entrecierra los ojos
+  const touched = new Set();
+  for (const name in md.ex) for (const b of md.ex[name]) if (!touched.has(b)) { b.mesh.morphTargetInfluences[b.index] = 0; touched.add(b); }
+  for (const name in md.ex) {
+    const v = val[name] || 0;
+    if (!v) continue;
+    for (const b of md.ex[name]) b.mesh.morphTargetInfluences[b.index] = Math.min(1, b.mesh.morphTargetInfluences[b.index] + v * b.w);
+  }
+
+  this.tickEffects(t, rm);
+  this.fxg.position.copy(rig.position);
+  this.fxg.rotation.y = this.yaw;
+}

package/src/i18n/messages/character.js

@@ -45,6 +45,7 @@ const es = {
       party: 'Fiesta', chef: 'Chef', viking: 'Vikingo', grad: 'Graduación', beret: 'Boina', bow: 'Lazo', flower: 'Flor', halo: 'Aureola', horns: 'Cuernos',
       antenna: 'Antenas', bunny: 'Orejas de conejo', catears: 'Orejas de gato', santa: 'Papá Noel', hardhat: 'Casco de obra', headband: 'Cinta ninja',
       bandana: 'Pañuelo pirata', helmet: 'Casco espacial', headphones: 'Auriculares', hair: 'Tupé', sprout: 'Brote',
+      fedora: 'Fedora', bowler: 'Bombín', propeller: 'Gorra de hélice', witch: 'Sombrero de bruja', fez: 'Fez', sombrero: 'Sombrero mexicano', bucket: 'Gorro pescador', jester: 'Bufón',
       glasses: 'Gafas redondas', square: 'Gafas cuadradas', nerd: 'Gafas empollón', sunglasses: 'Gafas de sol', aviator: 'Aviador', heartglasses: 'Gafas corazón',
       starglasses: 'Gafas estrella', '3d': 'Gafas 3D', monocle: 'Monóculo', eyepatch: 'Parche', goggles: 'Gafas de piloto', visor: 'Visor',
       mustache: 'Bigote', handlebar: 'Bigote manillar', beard: 'Barba', wizardbeard: 'Barba de mago', goatee: 'Perilla', pipe: 'Pipa', lollipop: 'Piruleta',
@@ -73,7 +74,7 @@ const es = {
     },
   },
   editor: {
-    kinds: { label: 'Tipo de avatar', character: 'Personaje 2D', plush: 'Personaje 3D', image: 'Tarjeta' },
+    kinds: { label: 'Tipo de avatar', character: 'Personaje 2D', plush: 'Personaje 3D', image: 'Carta' },
     tabs: { styles: 'Estilos', shape: 'Forma', color: 'Color y acabado', eyes: 'Ojos', mouth: 'Boca', face: 'Cara', acc: 'Accesorios' },
     controls: 'Controles de edición',
     preview: 'Vista previa del avatar',
@@ -101,15 +102,19 @@ const es = {
       unavailable: 'Este navegador no puede mostrar el 3D; ves la vista 2D (el widget hará lo mismo).',
     },
     image: {
-      title: 'Retrato',
-      intro: 'Una imagen fija (PNG, JPG, WebP o SVG). La boca no se anima; al hablar se ilumina el contorno.',
-      url: 'URL de la imagen',
-      placeholder: 'https://…/retrato.png',
+      title: 'Carta coleccionable',
+      intro: 'La carta holográfica de tu ot, con su personaje, nombre, rasgos y rareza. Muévela con el puntero.',
+      foil: 'Lámina',
+      foils: { auto: 'Según rareza', holo: 'Holo', prism: 'Prisma', cosmos: 'Cosmos', gold: 'Oro', none: 'Sin lámina' },
+      url: 'Arte propio (opcional)',
+      hint: 'Si pones una imagen (PNG, JPG, WebP o SVG), reemplaza al personaje en la carta y como avatar.',
+      placeholder: 'https://…/arte.png',
       alt: 'Vista previa del retrato',
     },
     styles: {
-      title: 'Estilos completos',
-      hint: 'Un estilo reemplaza todo el personaje. Después puedes ajustar cada pieza.',
+      title: 'Ots al azar sin dueño',
+      hint: 'Caras que nadie tiene todavía. Elegir una reemplaza el personaje; después puedes ajustar cada pieza.',
+      more: 'Otros',
       keepBody: 'Conservar mi forma y color al cambiar de estilo',
     },
     shape: {
@@ -128,7 +133,7 @@ const es = {
       custom: 'Personalizado',
       finish: 'Acabado',
       outline: 'Contorno',
-      outlines: { auto: 'Automático', none: 'Sin contorno', thin: 'Fino', bold: 'Grueso' },
+      outlines: { auto: 'Automático', none: 'Sin contorno', thin: 'Fino', bold: 'Grueso', tone: 'Tono', sticker: 'Pegatina' },
       pattern: 'Patrón',
       patternColor: 'Color del patrón',
     },
@@ -214,6 +219,7 @@ const en = {
       party: 'Party', chef: 'Chef', viking: 'Viking', grad: 'Graduation', beret: 'Beret', bow: 'Bow', flower: 'Flower', halo: 'Halo', horns: 'Horns',
       antenna: 'Antennae', bunny: 'Bunny ears', catears: 'Cat ears', santa: 'Santa', hardhat: 'Hard hat', headband: 'Ninja headband',
       bandana: 'Pirate bandana', helmet: 'Space helmet', headphones: 'Headphones', hair: 'Quiff', sprout: 'Sprout',
+      fedora: 'Fedora', bowler: 'Bowler hat', propeller: 'Propeller cap', witch: 'Witch hat', fez: 'Fez', sombrero: 'Sombrero', bucket: 'Bucket hat', jester: 'Jester hat',
       glasses: 'Round glasses', square: 'Square glasses', nerd: 'Nerd glasses', sunglasses: 'Sunglasses', aviator: 'Aviator', heartglasses: 'Heart glasses',
       starglasses: 'Star glasses', '3d': '3D glasses', monocle: 'Monocle', eyepatch: 'Eye patch', goggles: 'Pilot goggles', visor: 'Visor',
       mustache: 'Mustache', handlebar: 'Handlebar mustache', beard: 'Beard', wizardbeard: 'Wizard beard', goatee: 'Goatee', pipe: 'Pipe', lollipop: 'Lollipop',
@@ -270,15 +276,19 @@ const en = {
       unavailable: 'This browser can’t show 3D; you see the 2D preview (the widget will do the same).',
     },
     image: {
-      title: 'Portrait',
-      intro: 'A still image (PNG, JPG, WebP or SVG). The mouth isn’t animated; the outline lights up while speaking.',
-      url: 'Image URL',
-      placeholder: 'https://…/portrait.png',
+      title: 'Trading card',
+      intro: 'Your ot’s holographic card, with its character, name, traits and rarity. Move your pointer over it.',
+      foil: 'Foil',
+      foils: { auto: 'By rarity', holo: 'Holo', prism: 'Prism', cosmos: 'Cosmos', gold: 'Gold', none: 'No foil' },
+      url: 'Custom art (optional)',
+      hint: 'An image (PNG, JPG, WebP or SVG) replaces the character on the card and as the avatar.',
+      placeholder: 'https://…/art.png',
       alt: 'Portrait preview',
     },
     styles: {
-      title: 'Complete styles',
-      hint: 'A style replaces the whole character. You can then adjust each part.',
+      title: 'Random unclaimed ots',
+      hint: 'Faces nobody has yet. Picking one replaces the character; you can then adjust each part.',
+      more: 'Shuffle',
       keepBody: 'Keep my shape and color when changing style',
     },
     shape: {
@@ -297,7 +307,7 @@ const en = {
       custom: 'Custom',
       finish: 'Finish',
       outline: 'Outline',
-      outlines: { auto: 'Automatic', none: 'No outline', thin: 'Thin', bold: 'Bold' },
+      outlines: { auto: 'Automatic', none: 'No outline', thin: 'Thin', bold: 'Bold', tone: 'Tone', sticker: 'Sticker' },
       pattern: 'Pattern',
       patternColor: 'Pattern color',
     },
@@ -383,6 +393,7 @@ const pt = {
       party: 'Festa', chef: 'Chef', viking: 'Viking', grad: 'Formatura', beret: 'Boina', bow: 'Laço', flower: 'Flor', halo: 'Auréola', horns: 'Chifres',
       antenna: 'Antenas', bunny: 'Orelhas de coelho', catears: 'Orelhas de gato', santa: 'Papai Noel', hardhat: 'Capacete de obra', headband: 'Faixa ninja',
       bandana: 'Bandana pirata', helmet: 'Capacete espacial', headphones: 'Fones de ouvido', hair: 'Topete', sprout: 'Broto',
+      fedora: 'Fedora', bowler: 'Chapéu-coco', propeller: 'Boné de hélice', witch: 'Chapéu de bruxa', fez: 'Fez', sombrero: 'Sombreiro mexicano', bucket: 'Chapéu de pescador', jester: 'Chapéu de bobo da corte',
       glasses: 'Óculos redondos', square: 'Óculos quadrados', nerd: 'Óculos de nerd', sunglasses: 'Óculos de sol', aviator: 'Aviador', heartglasses: 'Óculos de coração',
       starglasses: 'Óculos de estrela', '3d': 'Óculos 3D', monocle: 'Monóculo', eyepatch: 'Tapa-olho', goggles: 'Óculos de piloto', visor: 'Viseira',
       mustache: 'Bigode', handlebar: 'Bigode guidão', beard: 'Barba', wizardbeard: 'Barba de mago', goatee: 'Cavanhaque', pipe: 'Cachimbo', lollipop: 'Pirulito',
@@ -439,15 +450,19 @@ const pt = {
       unavailable: 'Este navegador não consegue mostrar o 3D; você vê a prévia 2D (o widget fará o mesmo).',
     },
     image: {
-      title: 'Retrato',
-      intro: 'Uma imagem fixa (PNG, JPG, WebP ou SVG). A boca não é animada; ao falar, o contorno se ilumina.',
-      url: 'URL da imagem',
-      placeholder: 'https://…/retrato.png',
+      title: 'Carta colecionável',
+      intro: 'A carta holográfica do seu ot, com personagem, nome, atributos e raridade. Passe o ponteiro sobre ela.',
+      foil: 'Lâmina',
+      foils: { auto: 'Pela raridade', holo: 'Holo', prism: 'Prisma', cosmos: 'Cosmos', gold: 'Ouro', none: 'Sem lâmina' },
+      url: 'Arte própria (opcional)',
+      hint: 'Uma imagem (PNG, JPG, WebP ou SVG) substitui o personagem na carta e como avatar.',
+      placeholder: 'https://…/arte.png',
       alt: 'Prévia do retrato',
     },
     styles: {
-      title: 'Estilos completos',
-      hint: 'Um estilo substitui o personagem inteiro. Depois você pode ajustar cada peça.',
+      title: 'Ots aleatórios sem dono',
+      hint: 'Rostos que ninguém tem ainda. Escolher um substitui o personagem; depois você pode ajustar cada peça.',
+      more: 'Outros',
       keepBody: 'Manter minha forma e cor ao trocar de estilo',
     },
     shape: {
@@ -466,7 +481,7 @@ const pt = {
       custom: 'Personalizada',
       finish: 'Acabamento',
       outline: 'Contorno',
-      outlines: { auto: 'Automático', none: 'Sem contorno', thin: 'Fino', bold: 'Grosso' },
+      outlines: { auto: 'Automático', none: 'Sem contorno', thin: 'Fino', bold: 'Grosso', tone: 'Tom', sticker: 'Adesivo' },
       pattern: 'Padrão',
       patternColor: 'Cor do padrão',
     },

package/src/i18n/messages/platform.js

@@ -74,6 +74,7 @@ const es = {
       busy: 'Ya hay una tarea en marcha ({id}); espera a que acabe',
       noAgent: 'Ese proyecto de Orquesta no tiene agente: configura uno en Orquesta ({url})',
       noProject: 'Ese proyecto de Orquesta no existe o no está compartido con 7ots',
+      notLinked: 'Este ot no está conectado a ese proyecto en Orquesta, o no tiene permiso para ejecutar tareas ahí. Conéctalo en el proyecto → Identidad → Ots conectados: {url}',
       rateLimited: 'Orquesta está recibiendo muchas peticiones; espera un momento',
       submitFailed: 'Orquesta no aceptó la tarea (error {status})',
       agentOffline: 'El agente de este proyecto está desconectado: la tarea queda en cola y empezará cuando vuelva',
@@ -95,6 +96,16 @@ const es = {
       jobGone: 'Ese trabajo ya no existe o ya terminó',
       llmLimit: 'Este trabajo ya usó sus {max} llamadas al modelo',
       paidSoon: 'Los servidores de 7ots llegan pronto; mientras tanto usa tu propio servidor',
+      paidOff: 'Los servidores de 7ots aún no están activados para tu cuenta; mientras tanto usa tu propio servidor',
+      paidUnavailable: 'Los servidores de 7ots no están disponibles ahora mismo; inténtalo más tarde',
+      exists: 'Este ot ya tiene un servidor; elimínalo o revócalo antes de crear otro',
+      accountLimit: 'Tu cuenta ya tiene {max} servidor(es) de 7ots (su límite)',
+      full: 'No quedan servidores de 7ots disponibles por ahora; inténtalo más tarde',
+      badSize: 'Tamaño de servidor no disponible',
+      needsPayment: 'Falta el pago del servidor de 7ots: vuelve a pulsar «Pagar y crear servidor»',
+      userNeedsKey: 'Para crear el servidor en tu cuenta de Orquesta, conéctala con una clave oak_ que tenga los permisos projects:write y vms:write (Orquesta → Ajustes → API keys). La conexión por OAuth no puede crear servidores.',
+      userScopes: 'Tu cuenta de Orquesta no dejó crear el servidor: vuelve a conectarla con una clave oak_ que tenga los permisos projects:write y vms:write (Orquesta → Ajustes → API keys)',
+      subscriptionInUse: 'Elimina antes tus servidores de 7ots; luego puedes cancelar la suscripción',
     },
   },
 };
@@ -167,6 +178,7 @@ const en = {
       busy: 'A task is already running ({id}); wait for it to finish',
       noAgent: 'That Orquesta project has no agent: set up an agent in Orquesta ({url})',
       noProject: 'That Orquesta project does not exist or is not shared with 7ots',
+      notLinked: 'This ot is not connected to that Orquesta project, or may not run tasks there. Connect it in the project → Identity → Connected ots: {url}',
       rateLimited: 'Orquesta is getting too many requests; wait a moment',
       submitFailed: 'Orquesta did not accept the task (error {status})',
       agentOffline: "This project's agent is offline: the task is queued and will start when it is back",
@@ -188,6 +200,16 @@ const en = {
       jobGone: 'That job no longer exists or already finished',
       llmLimit: 'This job already used its {max} model calls',
       paidSoon: '7ots servers are coming soon; meanwhile use your own server',
+      paidOff: '7ots servers are not enabled for your account yet; meanwhile use your own server',
+      paidUnavailable: '7ots servers are not available right now; try again later',
+      exists: 'This ot already has a server; delete or revoke it before creating another',
+      accountLimit: 'Your account already has {max} 7ots server(s) (its limit)',
+      full: 'No 7ots servers are available right now; try again later',
+      badSize: 'That server size is not available',
+      needsPayment: 'The 7ots server has not been paid for yet: click "Pay and create server" again',
+      userNeedsKey: 'To create the server in your Orquesta account, connect it with an oak_ key that has the projects:write and vms:write scopes (Orquesta → Settings → API keys). An OAuth connection cannot create servers.',
+      userScopes: 'Your Orquesta account did not allow creating the server: reconnect it with an oak_ key that has the projects:write and vms:write scopes (Orquesta → Settings → API keys)',
+      subscriptionInUse: 'Delete your 7ots servers first; then you can cancel the subscription',
     },
   },
 };
@@ -260,6 +282,7 @@ const pt = {
       busy: 'Já há uma tarefa em andamento ({id}); espere ela terminar',
       noAgent: 'Esse projeto do Orquesta não tem agente: configure um agente no Orquesta ({url})',
       noProject: 'Esse projeto do Orquesta não existe ou não está compartilhado com o 7ots',
+      notLinked: 'Este ot não está conectado a esse projeto no Orquesta, ou não pode executar tarefas lá. Conecte-o no projeto → Identidade → Ots conectados: {url}',
       rateLimited: 'O Orquesta está recebendo muitas solicitações; espere um momento',
       submitFailed: 'O Orquesta não aceitou a tarefa (erro {status})',
       agentOffline: 'O agente deste projeto está desconectado: a tarefa fica na fila e começa quando ele voltar',
@@ -281,6 +304,16 @@ const pt = {
       jobGone: 'Esse trabalho não existe mais ou já terminou',
       llmLimit: 'Este trabalho já usou suas {max} chamadas ao modelo',
       paidSoon: 'Os servidores do 7ots chegam em breve; enquanto isso use seu próprio servidor',
+      paidOff: 'Os servidores do 7ots ainda não estão ativados para sua conta; enquanto isso use seu próprio servidor',
+      paidUnavailable: 'Os servidores do 7ots não estão disponíveis agora; tente mais tarde',
+      exists: 'Este ot já tem um servidor; exclua ou revogue antes de criar outro',
+      accountLimit: 'Sua conta já tem {max} servidor(es) do 7ots (seu limite)',
+      full: 'Não há servidores do 7ots disponíveis agora; tente mais tarde',
+      badSize: 'Esse tamanho de servidor não está disponível',
+      needsPayment: 'O servidor da 7ots ainda não foi pago: clique de novo em «Pagar e criar servidor»',
+      userNeedsKey: 'Para criar o servidor na sua conta do Orquesta, conecte-a com uma chave oak_ que tenha as permissões projects:write e vms:write (Orquesta → Configurações → API keys). A conexão por OAuth não pode criar servidores.',
+      userScopes: 'Sua conta do Orquesta não permitiu criar o servidor: reconecte-a com uma chave oak_ que tenha as permissões projects:write e vms:write (Orquesta → Configurações → API keys)',
+      subscriptionInUse: 'Exclua antes seus servidores da 7ots; depois você pode cancelar a assinatura',
     },
   },
 };

package/src/identity/random.js

@@ -33,13 +33,27 @@ const TEXT = {
   },
 };
 
-/** Semilla corta y legible (6 caracteres base36). */
+/**
+ * Semilla corta y legible (7 caracteres base36). Las de 7 caracteres sortean entre el catálogo
+ * completo de piezas; cualquier otra longitud (las de 6 de antes de 2026-10, las escritas a mano)
+ * usa solo el catálogo 1, así que sigue dando exactamente el mismo ot que siempre.
+ */
 export function newSeed() {
   let s = '';
-  for (let i = 0; i < 6; i++) s += Math.floor(Math.random() * 36).toString(36);
+  for (let i = 0; i < 7; i++) s += Math.floor(Math.random() * 36).toString(36);
   return s;
 }
 
+/** ¿La semilla usa el catálogo 1 (todas salvo las de 7 caracteres, ver newSeed)? */
+export function isLegacySeed(seed) {
+  return cleanSeed(seed).length !== 7;
+}
+
+/** Personaje de una semilla (el mismo en la web, el CLI, la mascota y el visor 3D). */
+export function seedCharacter(seed) {
+  return randomCharacter(seedNumber(seed), { legacy: isLegacySeed(seed) });
+}
+
 /** Normaliza una semilla escrita por una persona: minúsculas, [a-z0-9-], máx. 32. */
 export function cleanSeed(seed) {
   return String(seed ?? '').toLowerCase().replace(/[^a-z0-9-]/g, '').slice(0, 32);
@@ -78,7 +92,7 @@ export function randomIdentity(seed, { lang = 'en', name } = {}) {
   const L = TEXT[lang] ? lang : 'en';
   const tx = TEXT[L];
   const { rnd, pick } = rng(seedNumber(sd));
-  const character = randomCharacter(seedNumber(sd));
+  const character = seedCharacter(sd);
   const nm = String(name || '').trim().slice(0, 40) || randomName(sd);
   const traits = [];
   while (traits.length < 3) {

package/src/identity/schema.js

@@ -66,6 +66,9 @@ export const IDENTITY_DEFAULTS = Object.freeze({
  * @param {object} input
  * @param {object} [base] identidad sobre la que se aplica (por defecto, los valores de serie)
  */
+/** Campos de la ficha de personaje y su largo máximo. */
+const SHEET = { backstory: 3000, style: 1500, quirks: 1500, scenario: 1500, greeting: 600, examples: 4000 };
+
 export function defineIdentity(input = {}, base = IDENTITY_DEFAULTS) {
   const i = input && typeof input === 'object' ? input : {};
   const b = base;
@@ -87,6 +90,8 @@ export function defineIdentity(input = {}, base = IDENTITY_DEFAULTS) {
       tone: str(personality.tone, 120),
       traits: list(personality.traits, 12).map((t) => str(t, 40)).filter(Boolean),
       instructions: str(personality.instructions, 4000),
+      // ficha de personaje (la misma del pet de escritorio; privada como las instrucciones)
+      sheet: Object.fromEntries(Object.entries(SHEET).map(([k, n]) => [k, str(personality.sheet?.[k], n)]).filter(([, v]) => v)),
     },
     look: {
       kind: LOOK_KINDS.includes(look.kind) ? look.kind : look.image ? 'image' : 'character',
@@ -96,6 +101,7 @@ export function defineIdentity(input = {}, base = IDENTITY_DEFAULTS) {
       accent: color(look.accent) || IDENTITY_DEFAULTS.look.accent,
       emoji: str(look.emoji, 8),
       image: url(look.image),
+      card: { foil: ['holo', 'prism', 'cosmos', 'gold', 'none'].includes(look.card?.foil) ? look.card.foil : '' },
       avatar: {
         url: url(look.avatar?.url),
         body: look.avatar?.body === 'M' ? 'M' : 'F',
@@ -195,6 +201,10 @@ export function identityPrompt(id, locale = id.language) {
     id.bio ? t('identity.prompt.about', { bio: id.bio }) : '',
     p.tone ? t('identity.prompt.tone', { tone: p.tone }) : '',
     p.traits.length ? t('identity.prompt.traits', { traits: p.traits.join(', ') }) : '',
+    p.sheet?.backstory,
+    p.sheet?.style,
+    p.sheet?.quirks,
+    p.sheet?.examples,
     p.instructions,
   ]
     .filter(Boolean)