The 2D Field

The BPT law

BPT Part 8.8's Pixel Quantization Principle, "One Pixel = One Zinf ⟹ Minimal boundary cell extent = ℓ_z", makes each boundary cell an indivisible pixel that "must undergo 1 → 0 recollapse each frame unless actively re-excited"; the book calls the universe "a recursive display". BPT Part 1.8 (The Zinf ℨ Quantum, Reality's Pixel) gives the pixel's clock, ℨ ≈ 2.283 × 10⁻¹⁰⁶ s. The game's field is that display: one canvas pixel a cell, and the same canvas is the torus's skin. Its states are Chapter 2's: a lit pulser, a dark pulser, a null cell with its exposure toward bifurcation, and a fold.

BPT Part 3.1 (From Binary Transition to Physical Energy) gives Data Energy: "Each binary transition generates energy: E⊶ = ℏ × ω₁ × n○ ... Energy is not imposed on data but arises from data." BPT Part 3.6 makes the data within the Pulsecore radiation with energy density u = n·k_B·T, each datum carrying "the Data Energy E = k_B·T of one substrate pulse", and its skin "as hot as the data it holds". The game reads the filling Pulsecore as a heating body on that ground (the code's comment, app.js:375: E = k_B·T); BPT does not give it a color, which is a game method.

The established physics

A body at temperature T glows with Planck's spectrum (Planck 1900). The game's color for T is the fitted approximation of Tanner Helland to the blackbody's sRGB color, which the code names (blackbody() app.js:423); its coefficients are that fit's.

The game's math

The texture (drawFieldTexture() app.js:310). Each cell is one pixel of the field canvas, which is the torus's skin in 3D. Its brightness comes from cellIntensity() app.js:3850: 1 for a fold or a lit pulser, 0.3 for a dark pulser, min(0.22, 0.22·exposure) for a null cell; under 0.01 a cell is drawn near black, (8, 7, 10). Its color is its lineage color, or its phase color (hue 180°·phase, getPhaseColor() app.js:3820, phase 1 lit, 0.5 dark, exposure for a null cell), or the matter's motion (hue its direction, lightness 0.12 + 0.5·speed/c) or density (hue 0.66 − 0.55·ρ). Then by epoch:

pinpoint:   p = min(1, data within / nova capacity)
            color = (1 − m)·data color + m·blackbody(1,200 + 8,800·p K),  m = 0.15 + 0.45·p
            k = min(1, intensity·(0.75 + 0.5·p))
physical:   with stars drawn:  k = intensity·(base + (0.8 − base)·glow),  base = 0.35, or 0.08 from the 4th harmonic
            without:            k = intensity·(0.32 + 0.68·matter.glow(r, c))
decay:      k ·= 1 − decayFade

The glow round clusters (app.js:334–347) brightens the data within each heavy body's swirl as w = √(1/max(1, d))·(1 − d/reach) at d cells, reach = max(2, min(24, floor(min(rows, cols)/4))), for the 24 heaviest bodies of mass at least 16; CLUSTER_GLOW = 0.8 is its brightest. In 3D the skin is painted in the data's moving frame (row R holds field row R + flow.offR) and the scene scrolls it (Part 8.9); without 3D a fast flow is smeared along its run with a two-pass exponential trail, q = e^(−2/streak). Without stars the strings, the bodies (dust grey, a body above matter.full pale blue, above three times it orange, one or two cells wide) and the crystals are painted into the pixels. Folds are white, or dim (90, or 24 from the 4th harmonic) behind the stars.

dataColour(r, c) app.js:1185 returns a cell's lineage color as RGB in 0 to 1, falling back to the first lit pulser of the middle row, so a star takes the color of the data it was (Part 8.7). tintHexColor(hex, phase) app.js:3790 scales a color toward black by phase in 0 to 1.

The flat view (drawGrid() app.js:4003). In 3D it paints no grid: it repaints the texture (every other step once stars carry the picture) and calls scene.render(). Without 3D it fills the canvas purple-black (#08070a, or #1a181e behind grid lines), draws each cell as a square of cellSize (less 0.5 px with grid lines) at alpha min(1, intensity) in white for a fold, its phase color, or its lineage color tinted by max(intensity, 0.6), with the throat's line at the middle row, the gravity rings (alpha max(0.05, 0.35 − R/max(rows, cols))), the strings, the crystals and the spin overlay (spin.js, Chapter 2).

In the game

The 2D field is the skin seen flat. The "View" control's "2D · the field" (index.php:141) shows it; in 3D the same picture is wrapped on the torus, and every view control here changes both. While the Pulsecore fills, the player watches it heat: the field is tinted from a dull red glow toward white-hot as the data within nears the nova's capacity, the Data Energy of every transition read as heat. Painted cells keep their color as the rule spreads them, because each new cell takes the color of the data that lit it; with "Flow colours (at Start)" checked, "At Start the Pulsecore's data is painted as a colour wheel round its centre, and every new cell takes the colour of the data that lit it, so the spin, the flow and the wells' swirl show as moving colour" (index.php:214). Once there is matter, "Colour by" (index.php:188) offers "Data lineage", "Motion" (hue the direction the matter moves, brightness its speed against light) and "Density".

The 2D view adds its own overlays: the throat as a line across the middle row, the wells' gravity rings ("Show the wells' rings"), the strings and nodes, and the spin overlay ("Show spin and axis"). "Grid lines" draws the cell grid, "Phase Colors" (index.php:215) colors each cell by its phase in the pulse, "Phase Mode" draws those phases in "Color" or "Grayscale", "Debug numbers (phase, exposure)" (index.php:213) writes each cell's numbers on it, "Center View" keeps the field centered, and "Zoom" sets the size of a cell. Every one of these is the field itself, one pixel a Zinf cell of the model level, drawn without a stand-in.

The scale model

One pixel is one cell of the model level Lm. What a cell stands for at the true level is shown in the readout (Part 8.13). The colors are the data's own lineage colors, so the picture is the data, not a rendering of it; only brightness is chosen.

Where the game and the theory differ

• BPT Part 3.6 makes the Pulsecore's skin as hot as its data, u = n·k_B·T. The drawn glow is not computed from that temperature: it maps the share filled, p = data within / nova capacity, onto 1,200 K to 10,000 K at every level, then colors it by the blackbody fit.
• drawGrid()'s last two lines repeat the 3D path and are never reached, since the 3D branch returns first.

Fixed numbers