pcface.js

(function () {
  'use strict'

  /**
   * Exported module of PC Face.
   *
   * @exports pcface
   */
  const pcface = {}

  /**
   * Draw a single character on a canvas using the given canvas
   * context. The (x, y) coordinates represent the top-left corner of
   * the glyph. The x-coordinate represents the column index the
   * leftmost edge of the glyph. Similarly, the y-coordinate
   * represents the row index of the topmost edge of the glyph. The
   * character `c` may either be an integer ASCII code of a CP437
   * character or a string containing a single Unicode character that
   * represents a CP437 character.
   *
   * If `c` is an ASCII code, then `bitmaps` must be an array of
   * bitmaps. If `s` is a string containing a single Unicode
   * character, then `bitmaps` must be an object that maps each
   * Unicode character that represents a CP437 character to its
   * bitmap array.
   *
   * @param {Array|Object} bitmaps - An array/object containing bitmap arrays.
   * @param {CanvasRenderingContext2D} ctx - Canvas context.
   * @param {number|string} c - Character to draw on canvas.
   * @param {number} x - X coordinate of the leftmost edge of the glyph.
   * @param {number} y - Y coordinate of the topmost edge of the glyph.
   * @param {number} scale - Scale multiplier.
   */
  pcface.drawChar = function (bitmaps, ctx, w, c, x, y, scale) {
    const bitmap = bitmaps[c]
    for (let i = 0; i < bitmap.length; i++) {
      for (let j = 0; j < w; j++) {
        const mask = 1 << (w - 1 - j)
        if ((bitmap[i] & mask) !== 0) {
          ctx.fillRect(x + scale * j, y + scale * i, scale, scale)
        }
      }
    }
  }

  /**
   * Draw a single string with its top-left corner placed at
   * coordinate (x, y). The string `s` may either be an array of
   * integers where each integer is an ASCII code of a CP437 character
   * of it may be a string of Unicode characters where each Unicode
   * character represents a CP437 character.
   *
   * If `s` is an array of ASCII codes, then `bitmaps` must be an
   * array of bitmaps. If `s` is a string of Unicode characters, then
   * `bitmaps` must be an object that maps each Unicode character that
   * represents a CP437 character to its bitmap array.
   *
   * @param {Array|Object} bitmaps - An array/object containing bitmap arrays.
   * @param {CanvasRenderingContext2D} ctx - Canvas context.
   * @param {Array|string} s - Characers to draw on canvas.
   * @param {number} w - Horizontal width to allocate for each glyph.
   * @param {number} x - X coordinate of the leftmost edge of the glyphs.
   * @param {number} y - Y coordinate of the topmost edge of the glyphs.
   * @param {number} scale - Scale multiplier (should be a positive integer).
   */
  pcface.drawString = function (bitmaps, ctx, w, s, x, y, scale) {
    for (let i = 0; i < s.length; i++) {
      pcface.drawChar(bitmaps, ctx, w, s[i], x + i * scale * w, y, scale)
    }
  }

  /**
   * Draw multiple strings with the top-left corner of the first
   * string placed at coordinate (x, y). Each subsequent string is
   * placed below the previous one. The height `h` specifies the
   * distance between the top edge of one string and the top edge of
   * the next one. The width `w` specifies the distance between the
   * left edge of one glyph and the left edge of the next one.
   *
   * The string `s` may either be an array of array of integers where
   * each integer is an ASCII code of a CP437 character of it may be
   * an array of strings of Unicode characters where each Unicode
   * character represents a CP437 character.
   *
   * If `s` is an array of array of ASCII codes, then `bitmaps` must
   * be an array of bitmaps. If `s` is an array of strings of Unicode
   * characters, then `bitmaps` must be an object that maps each
   * Unicode character that represents a CP437 character to its
   * bitmap.
   *
   * @param {CanvasRenderingContext2D} ctx - Canvas context.
   * @param {Array|Object} bitmaps - An array or an object of bitmap arrays.
   * @param {number} w - Horizontal width to allocate for each glyph.
   * @param {number} h - Horizontal height to allocate for each glyph.
   * @param {Array} ss - An array of array of integers or an array of strings.
   * @param {number} x - X coordinate of the leftmost edge of the glyphs.
   * @param {number} y - Y coordinate of the topmost edge of the glyphs.
   * @param {number} scale - Scale multiplier (should be a positive integer).
   */
  pcface.drawStrings = function (bitmaps, ctx, w, h, ss, x, y, scale) {
    for (let i = 0; i < ss.length; i++) {
      pcface.drawString(bitmaps, ctx, w, ss[i], x, y + i * scale * h, scale)
    }
  }

  /**
   * Create an array of consecutive integers with `start` as the first
   * integer and `stop - 1` as the last integer in the array. This
   * function may be useful for creating a range of CP437 character
   * codes for demos. For example, calling `pcface.range(65, 70)`
   * returns `[65, 66, 67, 68, 69]` which can then be passed to
   * {@linkcode module:pcface.drawString} to draw the glyphs
   * represented by these integers.
   *
   * @param {number} start - Start integer.
   * @param {number} stop - Stop integer.
   */
  pcface.range = function (start, stop) {
    const result = []
    for (let i = start; i < stop; i++) {
      result.push(i)
    }
    return result
  }

  /**
   * Return an array of arrays of integers. This function may be
   * useful for creating ranges of CP437 character codes for demos.
   * All nested arrays together contain consecutive integers from
   * `start` to `stop - 1`. These integers are split into multiple
   * nested arrays such that each nested array contains no more than
   * `chunk` number of integers. For example, calling
   * `pcface.range(65, 78, 5)` returns `[[65, 66, 67, 68, 69], [70,
   * 71, 72, 73, 74], [75, 76, 77]]`. This array of arrays can then be
   * passed to {@linkCode module:pcface.drawStrings} to draw the
   * glyphs represented by these integers.
   *
   * @param {number} start - Start integer.
   * @param {number} stop - Stop integer.
   * @param {number} chunk - Maximum length of each nested array.
   */
  pcface.ranges = function (start, stop, chunk) {
    const result = []
    for (let chunkStart = start; chunkStart < stop; chunkStart += chunk) {
      result.push(pcface.range(chunkStart, Math.min(stop, chunkStart + chunk)))
    }
    return result
  }

  if (typeof window !== 'undefined') {
    window.pcface = pcface
  } else {
    module.exports = pcface
  }
})()