levels.js

function empty(rows, cols) {
  return new Array(rows).fill().map(() => new Array(cols).fill());
}

export const levels = [
  {
    text: `
Welcome!

<b>Cellbound</b> is a logic puzzle game that takes place entirely within a spreadsheet.

Your goal is to edit each formula so that the input cell values match the output. Formulas go in the top box within each cell. The computed value is in the bottom box within each cell.

For the first few levels, the formula for the output will be shown. For the actual puzzles, the formulas will be hidden.

You will learn the spreadsheet formula language as you go.

<hr />
Cells can contain numbers.
`,
    level: empty(4, 1),
    solution: [
      [{ formula: "420", hidden: false }],
      [{ formula: "-69", hidden: false }],
      [{ formula: "1.337", hidden: false }],
      ["=256 ** 2"],
    ],
    endText: `
When everything matches, you can proceed to the next level...
`,
  },

  {
    text: `
In addition to numbers, cells may contain formulas. 

Formulas begin with the <code>=</code> symbol. They can contain math, numbers, and functions. Many standard math functions will work.
`,
    level: empty(4, 1),
    solution: [
      [{ formula: "=1 + 1", hidden: false, valueHidden: true }],
      [{ formula: "=2 * 3 + 4", hidden: false, valueHidden: true }],
      [{ formula: "=(1+2) * (3 + 2**2)", hidden: false, valueHidden: true }],
      [{ formula: "=LOG(2 ** 16) / LOG(2)", hidden: false, valueHidden: true }],
    ],
    endText: `
Expand the list below to see all of the available formula functions.
`,
  },

  {
    text: `
Formulas can operate on numbers, booleans, and strings. Strings and booleans must use a formula beginning with <code>=</code>. 
`,
    level: empty(3, 1),
    solution: [
      [
        {
          formula: "=OR(NOT(true), AND(NOT(false), NOT(NOT(true))))",
          hidden: false,
          valueHidden: true,
        },
      ],
      [{ formula: `="Cat " + "hat"`, hidden: false, valueHidden: true }],
      [
        {
          formula: `=IF(!true, "hat", "mat")`,
          hidden: false,
          valueHidden: true,
        },
      ],
    ],
  },

  {
    text: `
Formulas can contain references. References have the form <code>R1C1</code> where <code>1</code> can be replaced with a row or column number. Indices start at 0. Negative indices go from the final row or column.

The row and/or column can be omitted to refer to the current row or column. <code>RC</code> can be used for self-reference.

A variation of this notation is available in other spreadsheets like Microsoft Excel and Google Sheets. (It is typically how formulas are represented internally in these engines, and can optionally be exposed to the user.) It is known as <a href="https://en.wikipedia.org/wiki/Spreadsheet#Cell_reference" target="_blank">R1C1 reference style</a>.
`,
    level: empty(3, 2),
    solution: [
      [
        { formula: "1", hidden: false },
        { formula: "2", hidden: false },
      ],
      [
        { formula: "=R0C-1", hidden: false, valueHidden: true },
        { formula: "=R0C0", hidden: false, valueHidden: true },
      ],
      [
        { formula: "=R0C0 + R0C1", hidden: false, valueHidden: true },
        { formula: "=RC0 * R0C1 + 1", hidden: false, valueHidden: true },
      ],
    ],
  },

  {
    text: `
The previous level introduced absolute references like <code>R10C2</code>. 

Formula references can also be relative, rather than absolute. Relative references are encosed in square brackets. So one cell to the right in the same row is <code>RC[1]</code> and one cell in the current column and row above is <code>R[-1]C</code>.
`,
    level: empty(3, 2),
    solution: [
      [
        { formula: "1", hidden: false },
        { formula: "2", hidden: false },
      ],
      [
        { formula: "=R[-1]C1", hidden: false, valueHidden: true },
        { formula: "=R[-1]C[-1]", hidden: false, valueHidden: true },
      ],
      [
        { formula: "=R[-2]C + R[-2]C[1]", hidden: false, valueHidden: true },
        { formula: "=RC[-1] ** R-1C-2 + 1", hidden: false, valueHidden: true },
      ],
    ],
  },

  {
    text: `
Now that you know how basic formulas and references work, it's time for the first challenge.

Guess the mystery function based on its outputs.

<details><summary>Hint</summary>
Does the shape of the curve remind you of anything? Perhaps a common trigonometric function?
</details>
`,
    level: [
      [{ formula: "=TICK(100) / 10", hidden: true, nocheck: true }],
      [undefined],
      [
        {
          formula: "=SPARKBARS(CACHE(20, R[-1]C))",
          style: "font-family: monospace, monospace",
          hidden: true,
          nocheck: true,
        },
      ],
    ],
    solution: [
      [{ formula: "=TICK(100) / 10", nocheck: true }],
      ["=SIN(R[-1]C)"],
      [
        {
          formula: "=SPARKBARS(CACHE(20, R[-1]C))",
          style: "font-family: monospace, monospace",
          nocheck: true,
        },
      ],
    ],
    endText: `
Amaing job! This one may have been tricky if you don't remember trigonometry.
`,
  },

  {
    text: `
The final spreadsheet formula lanugage feature to introduce is range selection. 

Ranges are designated by a start reference and end reference separated by a colon, like <code>RC0:RC[-1]</code>. The start and end are inclusive.

To complete this level, sum the preceding rows in the final cell.
`,
    level: [
      [{ formula: "=XORSHIFT(TICK(2000) + 1) % 100 + 1", hidden: true }],
      [{ formula: "=XORSHIFT(R[-1]C) % 100 + 1", hidden: true }],
      [{ formula: "=XORSHIFT(R[-1]C) % 100 + 1", hidden: true }],
      [{ formula: "=XORSHIFT(R[-1]C) % 100 + 1", hidden: true }],
      [{ formula: "=XORSHIFT(R[-1]C) % 100 + 1", hidden: true }],
      [{ formula: "=XORSHIFT(R[-1]C) % 100 + 1", hidden: true }],
      [undefined],
    ],
    solution: [
      ["=XORSHIFT(TICK(2000) + 1) % 100 + 1"],
      ["=XORSHIFT(R[-1]C) % 100 + 1"],
      ["=XORSHIFT(R[-1]C) % 100 + 1"],
      ["=XORSHIFT(R[-1]C) % 100 + 1"],
      ["=XORSHIFT(R[-1]C) % 100 + 1"],
      ["=XORSHIFT(R[-1]C) % 100 + 1"],
      ["=SUM(R0C:R[-1]C)"],
    ],
  },

  {
    text: `
Now that you know how formulas work, we can get to more interesting puzzles.

For this and most of the upcoming puzzles, formulas will automatically be copied between some of the cells. Duplicated cells are marked with an asterisk in their top right corner.

You will need to come up with a single formula that will work for <i>all</i> of the duplicate cells.
`,
    level: [
      [undefined],
      [{ reference: { row: 0 } }],
      [{ reference: { row: 0 } }],
      [{ reference: { row: 0 } }],
      [{ reference: { row: 0 } }],
      [{ reference: { row: 0 } }],
      [{ formula: "=SUM(R0C:R[-1]C)", locked: true }],
    ],
    solution: [
      [{ formula: "7", valueHidden: true }],
      [{ formula: "7", valueHidden: true }],
      [{ formula: "7", valueHidden: true }],
      [{ formula: "7", valueHidden: true }],
      [{ formula: "7", valueHidden: true }],
      [{ formula: "7", valueHidden: true }],
      [{ formula: "=SUM(R0C:R[-1]C)", hidden: false }],
    ],
  },

  {
    text: `
Not all of the duplicated cell puzzles will be as easy as the last one.
`,
    level: [
      [undefined],
      [undefined],
      [{ reference: { row: 1 } }],
      [{ reference: { row: 1 } }],
      [{ reference: { row: 1 } }],
      [{ reference: { row: 1 } }],
      [{ reference: { row: 1 } }],
      [{ formula: "=SUM(R0C:R[-1]C)", locked: true }],
    ],
    solution: [
      ["2"],
      ["3"],
      ["4"],
      ["5"],
      ["6"],
      ["7"],
      ["8"],
      [{ formula: "=SUM(R0C:R[-1]C)", hidden: false }],
    ],
  },

  {
    text: `
<details><summary>Hint</summary>
It might be worth reading up on the most famous contributions of the Italian mathematician <a href="https://en.wikipedia.org/wiki/Fibonacci">Fibonacci</a>.
</details>
`,
    level: [
      [undefined],
      [undefined],
      [undefined],
      [{ reference: { row: 2 } }],
      [{ reference: { row: 2 } }],
      [{ reference: { row: 2 } }],
      [{ reference: { row: 2 } }],
      [{ reference: { row: 2 } }],
      [{ reference: { row: 2 } }],
      [{ reference: { row: 2 } }],
    ],
    solution: [
      ["0"],
      ["1"],
      ["=R[-1]C + R[-2]C"],
      ["=R[-1]C + R[-2]C"],
      ["=R[-1]C + R[-2]C"],
      ["=R[-1]C + R[-2]C"],
      ["=R[-1]C + R[-2]C"],
      ["=R[-1]C + R[-2]C"],
      ["=R[-1]C + R[-2]C"],
      ["=R[-1]C + R[-2]C"],
    ],
  },

  {
    level: [
      [undefined],
      [{ reference: { row: 0 } }],
      [{ reference: { row: 0 } }],
      [{ reference: { row: 0 } }],
      [{ reference: { row: 0 } }],
      [{ reference: { row: 0 } }],
      [{ reference: { row: 0 } }],
      [{ formula: "=SUM(R0C:R[-1]C)", locked: true }],
    ],
    solution: [
      ["=ROW() * 2 + 1"],
      ["=ROW() * 2 + 1"],
      ["=ROW() * 2 + 1"],
      ["=ROW() * 2 + 1"],
      ["=ROW() * 2 + 1"],
      ["=ROW() * 2 + 1"],
      ["=ROW() * 2 + 1"],
      [{ formula: "=SUM(R0C:R[-1]C)", hidden: false }],
    ],
  },

  {
    text: `
You may need to refresh the page to restart the sequence after you enter your solution.

<details><summary>Hint</summary>
Cellbound formulas support self-reference.
</details>
`,
    level: [
      [
        {
          formula: "=TICK(1000)",
          hidden: true,
          valueHidden: true,
          nocheck: true,
        },
      ],
      [
        {
          formula:
            "=FLOOR((XORSHIFT(R[-1]C + 1)  % 1000 - 500) * R[-1]C / 1000)",
          hidden: true,
          nocheck: true,
        },
      ],
      [undefined],
      [undefined],
    ],
    solution: [
      [{ formula: "=TICK(1000)", valueHidden: true, nocheck: true }],
      [
        {
          formula:
            "=FLOOR((XORSHIFT(R[-1]C + 1)  % 1000 - 500) * R[-1]C / 1000)",
          nocheck: true,
        },
      ],
      ["=MIN(R1C, RC)"],
      ["=MAX(R1C, RC)"],
    ],
    endText: `
Maybe later I'll add some more levels with <a href="https://en.wikipedia.org/wiki/Semilattice" target="_blank">semilattices</a>.
`,
  },
];