fix(campo): el campo se dibujaba como una sola linea y sin heroe

field.render() devuelve una fila por string y compose() espera un string
solo. Al pasarle el array, box() lo convertia con String(), las 22 filas
quedaban unidas por comas en un unico renglon, y el panel mostraba una
franja de pasto con el heroe en ninguna parte. No tiraba ninguna
excepcion y los 33 tests seguian en verde, asi que el campo estuvo roto
en silencio desde que existe.

Aparte el ancho: mapPane divide por CELL_W adentro y despues pinta cada
tile con ese ancho. El campo pinta una columna por celda, porque Y_SCALE
ya paga la relacion 1:2 de una celda de terminal en las distancias.
Dividir tambien aca metia el mundo a media escala en media caja.

Va con un test que mira el frame ya pintado, que es lo unico que podia
agarrar esto: verifica que el pasto cubra varias filas, que el heroe
aparezca, y que el dibujo llegue hasta el borde derecho del panel. Da
rojo contra el codigo viejo, comprobado.

La captura campo.png del README se rehizo. Antes salia repetida con la
del encuentro porque el script de capturas la tomaba en un paso fijo que
la pelea siempre se adelantaba, y caia en un fallback que fotografiaba
lo que hubiera en pantalla.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: Leo Cagliero

docs/screens/campo.png

@@ -762,7 +762,22 @@ class Runa {
         height: this.height,
         title: 'runa',
         mainCaption: snap.zone || 'el campo',
-        main: (w, h) => this.field.render(Math.floor(w / render.CELL_W), h),
+        // Two things this line has to get right, both of which it used to get
+        // wrong and neither of which crashed.
+        //
+        // render() hands back one string per row and compose() wants a single
+        // string. Passing the array straight through meant box() stringified
+        // it, the rows were joined by commas into one line, and the pane showed
+        // a single stripe of terrain with the hero nowhere on it. Nothing
+        // threw. The field was simply invisible, which is exactly the kind of
+        // bug that survives all the way into a demo.
+        //
+        // And the width is the whole pane, not the pane divided by CELL_W.
+        // mapPane does that division itself and then paints each tile that many
+        // columns wide; the field paints one column per cell, because Y_SCALE
+        // already pays for the 1:2 aspect of a terminal cell in the distance
+        // maths. Dividing here too drew the world at half scale into half a box.
+        main: (w, h) => this.field.render(w, h).join('\n'),
         stats: base.stats,
         log: base.log,
         footer: 'flechas mover | < volver a la ciudad | r recargar script | q salir'

lib/game.js

@@ -49,3 +49,53 @@ test('city art remains rectangular and walkable', (t) => {
   t.is(TILES[';'].solid, false)
   t.is(TILES.O.solid, true)
 })
+
+test('the field pane paints the whole field, not one stringified line', (t) => {
+  const game = new Runa()
+  game.update({ type: 'resize', width: 88, height: 26 })
+  game.onKey({ type: 'key', is: (...keys) => keys.includes('x') })
+
+  // Find the gate the map itself declares. Hardcoding its coordinates would let
+  // somebody move the gate and quietly turn this test into a no-op.
+  let gate = null
+  const rows = MAPS.city.rows
+  for (let y = 0; y < rows.length && gate === null; y++) {
+    for (let x = 0; x < rows[y].length; x++) {
+      const tile = TILES[rows[y][x]]
+      if (tile && tile.enter && tile.enter.kind === 'travel') {
+        gate = { x, y }
+        break
+      }
+    }
+  }
+  t.ok(gate !== null, 'the city has a gate out to the field')
+
+  game.walker.placeAt('city', gate.x, gate.y)
+  game.onKey({ type: 'key', is: (...keys) => keys.includes('e') })
+  t.ok(game.field !== null, 'stepping through the gate opens the field')
+
+  const lines = style.stripAnsi(game.view()).split('\n')
+  const pane = lines.map((line) => line.slice(1, 58))
+  const painted = pane.filter((line) => /[.,~#@<]/.test(line))
+
+  // The bug this guards against, in full, because it cost a demo:
+  //
+  // field.render() hands back one string per row and compose() wants a single
+  // string. Passing the array through meant box() stringified it, all 22 rows
+  // were joined by commas into one line, and the pane showed a single stripe of
+  // terrain with the hero nowhere on it. Nothing threw and every other test
+  // stayed green, so only an assertion about the painted frame can see it.
+  t.ok(painted.length > 10, 'terrain covers the pane rather than a single row')
+  t.ok(
+    lines.some((line) => line.includes('@')),
+    'the hero is somewhere on screen'
+  )
+
+  // And the field is drawn at full width. Dividing the pane by CELL_W as well
+  // as letting the field paint one column per cell squeezed the world into the
+  // left half of the box, which reads as a rendering glitch rather than a bug.
+  t.ok(
+    painted.some((line) => /[.,~#]/.test(line.slice(40))),
+    'the field reaches the right hand side of the pane'
+  )
+})