当サイトはアフィリエイト広告(PR)を利用しています

作り方

canvasでドット絵を描く方法|小さく描いて、ぼかさずに拡大する【JavaScript】

canvasでドット絵を描く方法|小さく描いて、ぼかさずに拡大する【JavaScript】

※この記事にはプロモーション(広告)が含まれます。

この記事の結論

  • ドット絵は、小さな canvas に描いて、整数倍に拡大して表示する。1マスが1ドットになる
  • ぼかさない設定は2つ。imageSmoothingEnabled = false(canvas 上で拡大するとき)と、CSS の image-rendering: pixelated(表示サイズを変えるとき。整数倍ならドットのまま)
  • 座標は整数にそろえる(Math.round や Math.floor)
  • 色は暗い → 明るい の段階から選ぶ。光が左上から当たるとして、場所ごとに段階を決める
  • 段階の境目は、4×4 の表を使うディザで、2色を混ぜてなじませる
  • 輪郭は黒ではなく暗くした色で。作った絵は保存して使い回す

canvas に絵を描いて大きく表示したら、ドット絵のはずが、ぼやけてしまった。そんな経験はありませんか。ドット絵風のゲームを作るときは、小さな canvas に描いて、ぼかさずに拡大するのが基本の形です。

この記事では、kakapo studio の熱闘天敵バスターズ(スーファミ風のバッティングゲーム)で実際に使っているコードを引用しながら、ドット絵を canvas で描くしくみを順番に解説します。

この記事の前提

コードは、熱闘天敵バスターズの pixel.js・script.js・style.css から引用しています(読みやすいように、一部を省いたところがあります)。imageSmoothingEnabled などの canvas・CSS の説明は、2026年10月時点の MDN(公式の資料)をもとにまとめました。デモは、同じ考え方を小さくして動かせるようにした、この記事用のものです。

完成するもの

32×32 ドットの小さな canvas に、光の当たった丸い球を描いて、10倍に拡大して表示するデモです。ボタンで「ぼかす/ぼかさない」を切りかえると、拡大したときの違いがわかります。

デモで試す

「ぼかさない」のときは、ドットの四角がくっきり見えます。「ぼかす」のときは、同じ絵がにじんで見えます。球の色が少しずつ変わるところには市松もようのドットが混ざっていて、足もとの影も市松もようです。この記事は、このデモを作るために必要なことを、順番に説明します。

熱闘天敵バスターズの画面も、同じ方法で描いています。ゲームは /games/tenteki-busters/ で遊べます。文字には、ドット風の日本語フォント「DotGothic16」(Google Fonts・SIL Open Font License 1.1)を使っています。

なぜ「小さく描いて拡大」するのか

ドット絵の「1ドット」は、画面の中でぜんぶ同じ大きさの四角です。この大きさをそろえる近道が、最初から小さな canvas に描いて、あとで拡大することです。小さな canvas の1マスが、そのまま1ドットになるからです。

熱闘天敵バスターズでは、画面を 160×214 ドットの小さな canvas に描いて、3倍にして表示しています。

tenteki-busters/pixel.js(小さな canvas)

const LS = 3;    // 1ドット = ゲームの座標の 3
const LW = 160;  // ドット絵の画面の横幅
const LH = 214;  // ドット絵の画面の高さ
const low = document.createElement("canvas");
low.width = LW;
low.height = LH;
const lg = low.getContext("2d");

low が小さな canvas で、絵はぜんぶここに描きます。ゲームの座標は、LS(3)で割るとドットの座標になります。流れは、次の3つです。

  1. 小さな canvas に描く160×214 ドット。1マスが1ドット
  2. 3倍に拡大して、画面用の canvas に写すdrawImage で、ぼかさずに拡大
  3. CSS でも、ぼかさない設定にする表示サイズを変えるときのため

拡大してもぼかさない2つの設定

canvas の絵を大きく表示すると、ふつうはブラウザが「なめらかになるように」まわりの色を混ぜてくれます。写真には便利ですが、ドット絵ではドットの四角がにじんでしまいます。これを止める設定が2つあります。

1. JavaScript:imageSmoothingEnabled = false

imageSmoothingEnabled は、canvas 上で画像を拡大・縮小するときに、平滑化(なめらかにする)を行うかどうかを決める設定です(MDN の説明より)。初期値は true で、false にすると、拡大したときにぼけず、輪郭が保たれます。MDN にも「ピクセルアートを使うゲームなどで有用」と書かれています。2017年4月以降、すべてのブラウザーで使えます。

tenteki-busters/pixel.js(小さな画面を、画面用の canvas に拡大して写す)

// ドット絵の画面を、ぼかさずに大きくして表示する
function present() {
  ctx.imageSmoothingEnabled = false;
  ctx.drawImage(low, 0, 0, LW * LS, LH * LS);
}

ctx は画面に出る canvas の道具、low は小さな canvas です。drawImage の最後の2つの数字で「横 LW × LS、たて LH × LS の大きさで描く」と指定して、3倍に拡大しています。その前に imageSmoothingEnabled = false を入れているのがポイントです。

小さな canvas に描くときの道具 lg にも、1コマの始まり(beginFrame)で同じ設定を入れています。

function beginFrame(ox, oy) {
  lg.setTransform(1, 0, 0, 1, ox, oy);
  lg.imageSmoothingEnabled = false;
}

2. CSS:image-rendering: pixelated

image-rendering は、CSS で画像の表示サイズを変えるときの、拡大縮小のしかたを決める設定です。pixelated を指定すると、MDN の説明では「最も近い整数倍までは最近傍(いちばん近いドットの色をそのまま使う方法)、そこから最終サイズまでは滑らかな補間」になります。つまり、整数倍(このゲームなら3倍)に拡大すると、ドットのままです。2020年1月以降、すべてのブラウザーで使えます。

tenteki-busters/style.css(417〜420行目)

canvas,
.overlay-kakapo {
  image-rendering: pixelated; /* 大きくしても、ぼかさない */
}

このゲームでは、canvas にこの指定を入れて動いています。

2つの違い

imageSmoothingEnabledimage-rendering
書く場所JavaScriptCSS
効くときcanvas 上で、画像を拡大・縮小して描くとき(drawImage など)CSS で表示サイズを変えるとき
デモで見るなら右の canvas左の canvas

デモは、この2つを別々に見られるようにしてあります。「ぼかす」にすると、どちらもにじみます。

座標は整数にそろえる

もうひとつ、ドット絵で気をつけたいのが座標です。MDN の「Canvas の最適化」には、「浮動小数点数値の座標を避けて整数を使用」と書かれています。座標が整数でないと、サブピクセルレンダリング(アンチエイリアス)という、なめらかに見せる処理になり、余計な計算もかかるからです。MDN には、drawImage() の座標を Math.floor() で整数にするとよい、と書かれています。

熱闘天敵バスターズでは、絵を置く位置を Math.round で整数にしています。

tenteki-busters/pixel.js(作った絵を置く)

function put(s, x, y, alpha = 1) {
  lg.globalAlpha = alpha;
  lg.drawImage(s.canvas, Math.round(x / LS - s.ox), Math.round(y / LS - s.oy));
  lg.globalAlpha = 1;
}

ゲームの座標を LS で割るとドットの座標になりますが、割り算の答えは小数になりがちです。Math.round で四捨五入して、ドットのマス目にぴったり置いています。

色は「段階」で選ぶ(パレットと ramp)

ドット絵らしさをつくるもう一つの工夫が、使う色を絞ることです。熱闘天敵バスターズでは、色を「暗い → 明るい」の順に並べた段階(ramp)をいくつも用意しておいて、そこからだけ色を選んでいます。

tenteki-busters/pixel.js(色の段階の作り方と、パレットの一部)

const hex = (c) => {
  const n = parseInt(c.slice(1), 16);
  return [n >> 16, (n >> 8) & 255, n & 255];
};
const ramp = (...colors) => colors.map(hex);

const PAL = {
  // ...
  gold: ramp("#6b4a08", "#a8800f", "#d9a520", "#f2cf6a"),
  moss: ramp("#16260a", "#253f12", "#3a5e1c", "#567f28", "#78a336", "#a0c654", "#c9e07e"),
  // ...
};

hex は "#6b4a08" のような色の文字を、赤・緑・青の3つの数字に直す関数です。ramp は、それを並べて段階にします。PAL(パレット)には、ネズミの毛、カカポの羽、草、石など、段階がまとめて入っています。

光の当たり方で、段階を選ぶ

丸いものは、光が左上から当たっていることにして、場所ごとの明るさを計算します。その明るさを、段階の番号に直して色を選びます。

tenteki-busters/pixel.js(球のように光を当てた、だ円の中の計算)

(x, y) => {
  const nx = (x - cx) / rx;
  const ny = (y - cy) / ry;
  const nz = Math.sqrt(Math.max(0, 1 - nx * nx - ny * ny));
  const v = -0.5 * nx - 0.6 * ny + 0.62 * nz; // 左上・手前からの光
  return Math.min(1, Math.max(0, (v + 0.2) / 1.1)) * (r.length - 1);
}
  • nx・ny:球の中心からのずれ(-1〜1)。左上ほどマイナス
  • nz:球の表面が、どれくらい手前を向いているか。まん中が最大、ふちに近いほど 0
  • v:光の当たり具合。左上(nx・ny がマイナス)と、手前(nz)が大きいほど明るい
  • 最後の行:v を 0〜1 におさめて、段階の数(r.length - 1)をかける。つまり暗い段階から明るい段階までの、どこかの番号になる

数式を細かく追わなくても、「左上ほど明るい段階を選ぶ」と読めれば十分です。番号に小数が出ますが、そのはんぱな分は、次の「ディザ」でなじませます。

段階の境目をなじませる「ディザ」

段階の数は少ないので、そのまま色を選ぶと、色の境目が線のようにくっきり出ます。そこで、はんぱな明るさのところには、となりあう2つの色を市松もようのように混ぜるのが「ディザ」です。熱闘天敵バスターズでは、4×4 の表を使って、場所ごとに混ぜ方を変えています。

tenteki-busters/pixel.js(4×4 の表と、色を選ぶ関数)

// ディザ用の表(4×4):ドットの場所ごとに、少しずつちがう「しきい値」
const BAYER = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5].map((v) => (v + 0.5) / 16);
const bayer = (x, y) => BAYER[((y & 3) << 2) + (x & 3)];

function tone(r, level, x, y) {
  const top = r.length - 1;
  const l = Math.min(top, Math.max(0, level));
  const base = Math.floor(l);
  return r[Math.min(top, l - base > bayer(x, y) ? base + 1 : base)];
}
  • bayer(x, y):ドットの場所 (x, y) に対応する、0〜1 の数字(しきい値)。表は4×4なので、x と y を 4 でわったあまり(& 3)で、表のどこを使うかを決める
  • base:段階の番号の整数部分(たとえば 2.3 なら 2)
  • 小数部分(l - base、この例なら 0.3)が、その場所のしきい値より大きければ1つ上の段階、そうでなければそのままの段階を使う

小数部分が 0.3 なら、およそ3割のドットが上の段階の色になります。しきい値は場所ごとにばらけているので、上の段階の色が点々と混ざり、デモの球のような模様になります。同じ場所は、いつも同じ色になります。

地面の影も市松もよう

地面に落ちる球の影は、1つおきにドットを置くことで、半透明のように見せています。

tenteki-busters/pixel.js(drawBallShadow の中)

for (let yy = Math.floor(-ry); yy <= Math.ceil(ry); yy++) {
  for (let xx = Math.floor(-rx); xx <= Math.ceil(rx); xx++) {
    if ((xx / rx) ** 2 + (yy / ry) ** 2 <= 1 && (cx + xx + cy + yy) % 2 === 0) {
      lg.fillRect(cx + xx, cy + yy, 1, 1);
    }
  }
}

(cx + xx + cy + yy) % 2 === 0 は、「x と y の合計が偶数のドットだけ」という意味です。偶数と奇数が交互に並ぶので、市松もようになります。fillRect(…, 1, 1) で、1ドットだけを塗っています。

輪郭は黒ではなく「暗くした色」で

絵のまわりを真っ黒な線でふちどると、絵が浮いて見えることがあります。ドット絵では、そのドットの色を暗くした色でふちどるやり方があります(セルアウトと呼ばれます)。熱闘天敵バスターズの outline() は、これを自動でやります。

tenteki-busters/pixel.js(輪郭)

outline(outer = 0.5, inner = 0.28) {
  const src = this.c.slice();
  const at = (x, y) => (x < 0 || y < 0 || x >= this.w || y >= this.h ? null : src[y * this.w + x]);
  for (let y = 0; y < this.h; y++) {
    for (let x = 0; x < this.w; x++) {
      const i = y * this.w + x;
      if (!src[i]) continue;
      const near = [[x - 1, y], [x + 1, y], [x, y - 1], [x, y + 1]];
      if (near.some(([nx, ny]) => !at(nx, ny))) {
        this.c[i] = darken(src[i], outer);
      } else if (this.p[i] > 0 && near.some(([nx, ny]) => {
        const pp = this.p[ny * this.w + nx];
        return pp > 0 && pp < this.p[i];
      })) {
        this.c[i] = darken(src[i], inner);
      }
    }
  }
}
  • まず、元の絵を src にコピーしておく(輪郭を塗りながら調べると、塗った色が判定に混ざってしまうため)
  • near:上下左右の4つのとなりのドット
  • となりに何もないドット(=絵のふち)は、outer(0.5)の割合で暗くする。外側は濃く
  • となりが別のパーツのドットで、そのドット自身のパーツのほうが、となりのパーツよりあとから描かれているなら、inner(0.28)の割合で暗くする。パーツの重なりは、うすく(this.p がパーツの番号)

暗くする関数 darken は、赤・緑・青の数字に (1 - 割合) をかけるだけです。デモでも、球のふちが濃い色になっているのが見えます。

毎回描かずに、作った絵をとっておく

ここまでの計算を、毎コマ(1秒に何十回)やり直すのは無駄です。熱闘天敵バスターズでは、一度描いた絵を canvas として保存しておき、あとは貼るだけにしています。

tenteki-busters/pixel.js(絵をとっておく)

const spriteCache = {};

// build(p):Pix に描く関数 ox, oy:足もと(基準点)の位置
function sprite(key, w, h, ox, oy, build, tinted = true) {
  const k = key + (tinted ? "@" + stageNum : "");
  if (!spriteCache[k]) {
    const p = new Pix(w, h);
    build(p);
    p.outline();
    if (tinted) p.tint(light());
    spriteCache[k] = { canvas: p.toCanvas(), ox, oy };
  }
  return spriteCache[k];
}
  • spriteCache:作った絵をしまっておく棚。名前(key)で取り出す
  • 棚になければ、Pix(ドットを置く紙)に描いて(build)、輪郭をつけて(outline)、保存する。あれば、それをそのまま返す
  • tint:昼・夕方・夜のステージごとの光の色を、赤・緑・青にかけ算する。かけたあとの絵を保存するので、名前にステージの番号("@" + stageNum)を足して、ステージごとに別の絵として保存している

最後の p.toCanvas() が、ドットの色を canvas に書きこむところです。ここで createImageData と putImageData を使っています。

tenteki-busters/pixel.js(toCanvas の中:ドットの色を書きこむ)

const g = cv.getContext("2d");
const img = g.createImageData(this.w, this.h);
this.c.forEach((c, i) => {
  if (!c) return;
  img.data[i * 4] = c[0];
  img.data[i * 4 + 1] = c[1];
  img.data[i * 4 + 2] = c[2];
  img.data[i * 4 + 3] = 255;
});
g.putImageData(img, 0, 0);

createImageData で作った img.data には、1ドットあたり赤・緑・青・透明度(0〜255)の4つの数字がこの順に並んでいます。ドット (x, y) の赤は、(y * 幅 + x) * 4 番目です。上のコードは、i(ドットの順番)に 4 をかけて、4つの数字を書きこみ、putImageData で canvas に貼っています。putImageData は、setTransform などの変換の影響を受けずに、そのまま貼られます。

作り直しの話:見た目だけを入れかえられた理由

熱闘天敵バスターズの見た目は、実は3回作り直しています。くわしくは「熱闘天敵バスターズ」ができるまでに書きましたが、3回目のドット絵にするきっかけは、この一言でした。

「ゲームのゲーム性はOKだけど、キャラクターとフィールドの描写が全く納得行っていない。逆にピクセル画で昔っぽくアレンジするのがどうだろう」

ファミコン風・ゲームボーイ風・スーファミ風を比べて、スーファミ風に決めました。そのあとも、「カカポが雪だるまに見える」「模様が横じまで植木みたい」「大ワシの翼がほうきみたい」と、ひとつずつ直していきました。

たとえば雪だるまは、コードにも直したあとが残っています。頭と体を別々の丸として光を当てると、2つの玉に見えてしまうので、頭と体を「ひとつの形」として塗り、光も大きなたまご形ひとつで計算するようにしました(pixel.js 478〜479行目のコメント)。

3回の作り直しのあいだ、ゲームのしくみ(球の飛び方や当たり判定)はそのままでした。絵を描くプログラム(pixel.js)と、球や当たり判定を動かすプログラム(script.js)が分かれていたので、絵だけを入れかえることができました。球の動きは変化球と魔球の作り方、操作はスマホとPCの両方で遊べるゲーム操作の作り方にまとめています。

分かれているとどう楽なのかは、script.js の draw() を見るとわかります。球の位置などは script.js が計算して、描くときは drawBall のような「絵を描く関数」を呼ぶだけです。

tenteki-busters/script.js(draw の一部)

const b = ballAt(pitch, t);
if (b.visible) {
  drawBallShadow(b.x, groundY(t), b.r, 0.35);
  // ...
  drawBall(b.x, b.y, b.r);
}

絵の描き方を変えたいときは、drawBall の中身(pixel.js 側)を変えれば、呼ぶ側はそのままで済みます。

完成コード(デモと同じ)

上のデモと同じコードです。メモ帳などに貼り付けて、pixel-demo.html という名前(文字コードは UTF-8)で保存すると動きます。

pixel-demo.html

<!DOCTYPE html>
<html lang="ja">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>小さく描いて、10倍に拡大する(ドット絵デモ)</title>
  <style>
    body { font-family: sans-serif; text-align: center; padding: 24px 12px; background: #eef3e0; color: #333; }
    .row { display: flex; flex-wrap: wrap; justify-content: center; gap: 24px; margin: 16px 0; }
    figure { margin: 0; }
    figcaption { font-size: 14px; margin-top: 6px; max-width: 320px; }
    canvas { width: 320px; height: 320px; background: #d9e6b8; max-width: 100%; }
    /* 「ぼかさない」のとき、CSS で拡大表示するほうに効く */
    #small.crisp { image-rendering: pixelated; }
    button { font-size: 18px; padding: 10px 20px; }
    #state { font-weight: bold; }
  </style>
</head>
<body>
  <h1>小さく描いて、10倍に拡大する</h1>
  <p>いまの設定:<span id="state"></span></p>
  <p><button id="toggle">切りかえる</button></p>

  <div class="row">
    <figure>
      <!-- 本物のサイズは 32×32。CSS で 320×320 に拡大して表示している -->
      <canvas id="small" width="32" height="32"></canvas>
      <figcaption>左:32×32 の canvas を、CSS で10倍の大きさに表示<br>(<code>image-rendering</code> が効く)</figcaption>
    </figure>
    <figure>
      <canvas id="big" width="320" height="320"></canvas>
      <figcaption>右:左の絵を、320×320 の canvas に <code>drawImage</code> で10倍に描く<br>(<code>imageSmoothingEnabled</code> が効く)</figcaption>
    </figure>
  </div>

  <script>
    const W = 32;
    const H = 32;
    const SCALE = 10;

    // ===== 色の段階(暗い → 明るい) =====
    const hex = (c) => {
      const n = parseInt(c.slice(1), 16);
      return [n >> 16, (n >> 8) & 255, n & 255];
    };
    const RAMP = ["#4a1d0e", "#7a3a1c", "#b0602a", "#dd8f3e", "#f5bd62", "#fff0b8"].map(hex);
    const darken = (c, k) => c.map((v) => Math.round(v * (1 - k)));

    // ===== ディザ用の 4×4 の表 =====
    const BAYER = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5].map((v) => (v + 0.5) / 16);
    const bayer = (x, y) => BAYER[((y & 3) << 2) + (x & 3)];

    // 段階(level)から色を選ぶ。はんぱな分は、場所ごとに次の段階と混ぜる
    function tone(level, x, y) {
      const top = RAMP.length - 1;
      const l = Math.min(top, Math.max(0, level));
      const base = Math.floor(l);
      return RAMP[Math.min(top, l - base > bayer(x, y) ? base + 1 : base)];
    }

    // ===== 1ドットずつ、色(と透明度)を決める =====
    const pixels = new Array(W * H).fill(null); // 空なら透明

    // 光の当たった球(左上から光が当たる)
    const cx = 16;
    const cy = 14;
    const rad = 11;
    for (let y = 0; y < H; y++) {
      for (let x = 0; x < W; x++) {
        const nx = (x + 0.5 - cx) / rad;
        const ny = (y + 0.5 - cy) / rad;
        if (nx * nx + ny * ny > 1) continue;
        const nz = Math.sqrt(Math.max(0, 1 - nx * nx - ny * ny));
        const v = -0.5 * nx - 0.6 * ny + 0.62 * nz;
        const level = Math.min(1, Math.max(0, (v + 0.2) / 1.1)) * (RAMP.length - 1);
        pixels[y * W + x] = { c: tone(level, x, y), a: 255 };
      }
    }

    // 輪郭:ふちのドットを、黒ではなく「暗くした色」にする
    const src = pixels.slice();
    const has = (x, y) => x >= 0 && y >= 0 && x < W && y < H && src[y * W + x];
    for (let y = 0; y < H; y++) {
      for (let x = 0; x < W; x++) {
        const p = src[y * W + x];
        if (!p) continue;
        if (!has(x - 1, y) || !has(x + 1, y) || !has(x, y - 1) || !has(x, y + 1)) {
          pixels[y * W + x] = { c: darken(p.c, 0.5), a: 255 };
        }
      }
    }

    // 地面の影:市松もように、1つおきにドットを置く
    for (let y = 25; y <= 29; y++) {
      for (let x = 6; x <= 26; x++) {
        const dx = (x - 16) / 10.5;
        const dy = (y - 27) / 2.5;
        if (dx * dx + dy * dy <= 1 && (x + y) % 2 === 0 && !pixels[y * W + x]) {
          pixels[y * W + x] = { c: [20, 30, 10], a: 140 };
        }
      }
    }

    // ===== 小さな canvas に、1ドットずつ書きこむ =====
    const small = document.getElementById("small");
    const sctx = small.getContext("2d");
    const img = sctx.createImageData(W, H);
    pixels.forEach((p, i) => {
      if (!p) return;
      img.data[i * 4] = p.c[0];
      img.data[i * 4 + 1] = p.c[1];
      img.data[i * 4 + 2] = p.c[2];
      img.data[i * 4 + 3] = p.a;
    });
    sctx.putImageData(img, 0, 0);

    // ===== 拡大して見せる =====
    const big = document.getElementById("big");
    const bctx = big.getContext("2d");
    const stateText = document.getElementById("state");
    let crisp = true; // true なら「ぼかさない」

    function show() {
      // 右:canvas の上で拡大するとき、ぼかすかどうか
      bctx.clearRect(0, 0, big.width, big.height);
      bctx.imageSmoothingEnabled = !crisp;
      bctx.drawImage(small, 0, 0, W * SCALE, H * SCALE);
      // 左:CSS で拡大表示するとき、ドットのままにするかどうか
      small.classList.toggle("crisp", crisp);
      stateText.textContent = crisp
        ? "ぼかさない(imageSmoothingEnabled = false / image-rendering: pixelated)"
        : "ぼかす(既定の設定)";
    }

    document.getElementById("toggle").addEventListener("click", () => {
      crisp = !crisp;
      show();
    });
    show();
  </script>
</body>
</html>

ドットを置く部分(pixels に色を入れるところ)を書きかえると、自分の絵を描けます。球の大きさ(rad)や、色の段階(RAMP)、光の向き(v の式の数字)を変えて、見え方の違いを試してみてください。

まとめ

  • ドット絵は、小さな canvas に描いて、整数倍に拡大して表示する。1マスが1ドットになる
  • ぼかさない設定は2つ。imageSmoothingEnabled = false(canvas 上で拡大するとき)と、CSS の image-rendering: pixelated(表示サイズを変えるとき。整数倍ならドットのまま)
  • 座標は整数にそろえる(Math.round や Math.floor)
  • 色は暗い → 明るい の段階から選ぶ。光が左上から当たるとして、場所ごとに段階を決める
  • 段階の境目は、4×4 の表を使うディザで、2色を混ぜてなじませる
  • 輪郭は黒ではなく暗くした色で。作った絵は保存して使い回す

canvas の基本はcanvasで絵を動かす基本、ゲーム全体のしくみはHTML・CSS・JavaScriptのちがいとは?、ハイスコアの保存はJavaScriptでハイスコアを保存する方法で説明しています。