Sprout68k 作例集

#include "x68.h"

void main(void) {
  printf("HELLO X68000");
}

// Sprout68k 作例: いろいろな形を描く
//
// 絵を描くときの決まりごとは3つだけ。
//   1. x68_screen_open() で画面を開く（最初に1回だけ）
//   2. 描画関数で描く
//   3. x68_screen_flip() で画面に出す
// 3 を忘れると、いくら描いても画面は変わらない。絵が出ないときは
// まずこの3段のどれかが抜けていないかを確かめる。
//
// 座標は左上が (0, 0)、右下が (511, 511)。y は下へ行くほど大きくなる。
// 画面からはみ出した分は自動で切り取られるので、はみ出しを気にしなくてよい。

#include "x68.h"

void main(void) {
  int black = x68_rgb(0, 0, 0);
  int white = x68_rgb(255, 255, 255);
  int i;

  x68_screen_open();
  x68_cls(black);

  // 塗りつぶした四角。左から右へ色を変えていく。
  for (i = 0; i < 8; i++) {
    x68_box_fill(24 + i * 58, 40, 48, 48, x68_rgb(255 - i * 30, i * 30, 180));
  }

  // 枠だけの四角。中は塗られない。
  x68_box(24, 112, 464, 72, white);

  // 1 点から放射状に線を引く。
  for (i = 0; i < 512; i += 32) {
    x68_line(256, 296, i, 200, x68_rgb(0, 200, 255));
  }

  // 同心円。円は輪郭だけで、塗りつぶす関数は無い。
  for (i = 24; i <= 96; i += 24) {
    x68_circle(256, 384, i, x68_rgb(255, 220, 0));
  }

  // 点を 1 つずつ打って線にする。まとまった面は box_fill のほうが速い。
  for (i = 0; i < 120; i++) {
    x68_pset(24 + i, 470 + i / 8, white);
  }

  // 文字はグラフィックとは別の画面に出るので、絵の上に重なって見える。
  x68_locate(0, 0);
  printf("SHAPES");

  x68_screen_flip();
}

#include "x68.h"

enum {
  kNoKey = 0,
  kLeftKey,
  kUpKey,
  kRightKey,
  kDownKey,
  kSpaceKey,
  kEnterKey,
  kEscapeKey,
  kAKey,
  kOneKey,
};

static int ReadPressedKey(void) {
  if (x68_key_down(X68_KEY_LEFT)) return kLeftKey;
  if (x68_key_down(X68_KEY_UP)) return kUpKey;
  if (x68_key_down(X68_KEY_RIGHT)) return kRightKey;
  if (x68_key_down(X68_KEY_DOWN)) return kDownKey;
  if (x68_key_down(X68_KEY_SPACE)) return kSpaceKey;
  if (x68_key_down(X68_KEY_ENTER)) return kEnterKey;
  if (x68_key_down(X68_KEY_ESC)) return kEscapeKey;
  if (x68_key_down(X68_KEY_A)) return kAKey;
  if (x68_key_down(X68_KEY_1)) return kOneKey;
  return kNoKey;
}

static void PrintKeyName(int key) {
  switch (key) {
    case kNoKey:
      printf("\n[RELEASE]");
      break;
    case kLeftKey:
      printf("\n[LEFT]");
      break;
    case kUpKey:
      printf("\n[UP]");
      break;
    case kRightKey:
      printf("\n[RIGHT]");
      break;
    case kDownKey:
      printf("\n[DOWN]");
      break;
    case kSpaceKey:
      printf("\n[SPACE]");
      break;
    case kEnterKey:
      printf("\n[ENTER]");
      break;
    case kEscapeKey:
      printf("\n[ESC]");
      break;
    case kAKey:
      printf("\n[A]");
      break;
    default:
      printf("\n[1]");
      break;
  }
}

void main(void) {
  int previous = kNoKey;

  x68_screen_open();
  printf("[READY]");
  for (;;) {
    int current = ReadPressedKey();
    if (current != previous) {
      PrintKeyName(current);
      previous = current;
    }
  }
}

// Sprout68k 作例: 四角を動かす
//
// 動くものを作るときは、この1周をずっと繰り返す。どのゲームでも形は同じ。
//   1. 画面を消す
//   2. キーを読む
//   3. 位置を計算する
//   4. 描く
//   5. 画面に出す
//
// 5 の x68_screen_flip() が画面の書き換えを待つので、この1周は毎秒およそ
// 55〜60回になる。速さを自分で調整する必要はない。

#include "x68.h"

enum {
  kSize = 40,   // 四角の大きさ
  kSpeed = 4,   // 1周で動く距離
};

static int player_x = 236;
static int player_y = 236;

// キーを読んで位置を動かす。
// x68_key_down() は押している間ずっと真になるので、押しっぱなしで動き続ける。
// 上下左右を別々に調べているため、2つ同時に押せば斜めに動く。
static void MovePlayer(void) {
  if (x68_key_down(X68_KEY_LEFT)) player_x -= kSpeed;
  if (x68_key_down(X68_KEY_RIGHT)) player_x += kSpeed;
  if (x68_key_down(X68_KEY_UP)) player_y -= kSpeed;
  if (x68_key_down(X68_KEY_DOWN)) player_y += kSpeed;

  // 動かしたあとで、画面からはみ出していたら引き戻す。
  if (player_x < 0) player_x = 0;
  if (player_y < 0) player_y = 0;
  if (player_x + kSize > X68_SCREEN_W) player_x = X68_SCREEN_W - kSize;
  if (player_y + kSize > X68_SCREEN_H) player_y = X68_SCREEN_H - kSize;
}

void main(void) {
  int background = x68_rgb(0, 0, 48);
  int player_color = x68_rgb(0, 255, 255);

  x68_screen_open();
  for (;;) {
    x68_cls(background);
    MovePlayer();
    x68_box_fill(player_x, player_y, kSize, kSize, player_color);

    // 末尾に空白を入れているのは、桁が減ったときに前の数字を消すため。
    x68_locate(0, 0);
    printf("X=%d Y=%d  ", player_x, player_y);

    x68_screen_flip();
  }
}

// Sprout68k 作例: 落ちてくる四角を受け止める
//
// move.c のゲームの形に「当たり判定」と「点数」を足したもの。
// 当たり判定は難しく見えるが、四角どうしなら4つの辺を比べるだけでよい。

#include "x68.h"

enum {
  kPlayerW = 48,     // 棒の幅
  kPlayerH = 12,     // 棒の高さ
  kPlayerY = 460,    // 棒の縦位置（動かさない）
  kItemSize = 16,    // 落ちてくる四角の大きさ
  kPlayerSpeed = 6,  // 棒が1周で動く距離
  kFallSpeed = 4,    // 四角が1周で落ちる距離
};

static int player_x = 232;
static int item_x = 100;
static int item_y = 0;
static int score = 0;

// 落ちてくる四角を、画面の上のどこかに置き直す。
static void ResetItem(void) {
  item_y = 0;
  item_x = x68_rand_int(X68_SCREEN_W - kItemSize);
}

// キーを読んで棒を動かす。
static void ReadInput(void) {
  if (x68_key_down(X68_KEY_LEFT)) player_x -= kPlayerSpeed;
  if (x68_key_down(X68_KEY_RIGHT)) player_x += kPlayerSpeed;
  if (player_x < 0) player_x = 0;
  if (player_x + kPlayerW > X68_SCREEN_W) player_x = X68_SCREEN_W - kPlayerW;
}

// 四角を落として、受け止めたかどうかを見る。
static void UpdateItem(void) {
  int caught;

  item_y += kFallSpeed;

  // 四角どうしの当たり判定。「重なっている」= 縦も横も重なっている。
  caught = (item_y + kItemSize >= kPlayerY) &&
           (item_x + kItemSize > player_x) &&
           (item_x < player_x + kPlayerW);
  if (caught) score++;

  // 受け止めたときも、下まで落ちきったときも、上に戻す。
  if (caught || item_y > X68_SCREEN_H) ResetItem();
}

static void Draw(void) {
  x68_cls(x68_rgb(0, 0, 48));
  x68_box_fill(player_x, kPlayerY, kPlayerW, kPlayerH, x68_rgb(0, 255, 255));
  x68_box_fill(item_x, item_y, kItemSize, kItemSize, x68_rgb(255, 224, 0));
  x68_locate(0, 0);
  printf("SCORE %d  ", score);
}

void main(void) {
  x68_screen_open();

  // 乱数の出発点。同じ値を渡すと毎回同じ並びになるので、動きを確かめる
  // ときに便利。毎回違う動きにしたいときは、この行を消してみるとよい。
  srand(20260823);
  ResetItem();

  for (;;) {
    ReadInput();
    UpdateItem();
    Draw();
    x68_screen_flip();
  }
}

// Sprout68k 作例: ブロック崩し
//
// 学習用ライブラリのL1と標準名の層だけを使う。
// L0 (x68_iocs_* など) は直接呼ばない。文字列リテラル以外の
// ポインタは使わず、配列と添字で書く。
// 最初にブロックをすべて描く。
// 以後は動いた部分だけ描き直す。

#include "x68.h"

enum {
  kScreenWidth = X68_SCREEN_W,
  kScreenHeight = X68_SCREEN_H,
  kPaddleWidth = 64,
  kPaddleHeight = 8,
  kPaddleY = kScreenHeight - 24,
  kPaddleSpeed = 4,
  kBallSize = 8,
  kBallSpeed = 2,
  kBlockRows = 4,
  kBlockColumns = 8,
  kBlockWidth = 56,
  kBlockHeight = 16,
  kBlockGapX = 4,
  kBlockGapY = 4,
  kBlockStartX = 8,
  kBlockStartY = 40,
  kBlockColorCount = 4,
};

static int block_alive[kBlockRows][kBlockColumns];
static int block_color_index[kBlockRows][kBlockColumns];

static int paddle_x;
static int ball_x;
static int ball_y;
static int ball_dx;
static int ball_dy;
static int score;
static long last_destroyed_index;

static int background_color;
static int paddle_color;
static int ball_color;
static int block_color[kBlockColorCount];

static void ResetBall(void) {
  ball_x = kScreenWidth / 2 - kBallSize / 2;
  ball_y = kScreenHeight / 2;
  ball_dx = kBallSpeed;
  ball_dy = -kBallSpeed;
}

void main(void) {
  x68_screen_open();
  srand(1);

  paddle_x = (kScreenWidth - kPaddleWidth) / 2;
  score = 0;
  last_destroyed_index = -1;

  background_color = x68_rgb(0, 0, 0);
  paddle_color = x68_rgb(255, 255, 255);
  ball_color = x68_rgb(255, 255, 0);
  // ブロックの色は4色から乱数で選ぶ。
  // 当たり判定や検証には
  // 影響しない。x68_rand_intの使用例も兼ねている。
  block_color[0] = x68_rgb(255, 64, 64);
  block_color[1] = x68_rgb(64, 255, 64);
  block_color[2] = x68_rgb(64, 64, 255);
  block_color[3] = x68_rgb(255, 255, 64);

  for (int row = 0; row < kBlockRows; ++row) {
    for (int column = 0; column < kBlockColumns; ++column) {
      block_alive[row][column] = 1;
      block_color_index[row][column] = x68_rand_int(kBlockColorCount);
    }
  }

  ResetBall();

  // 動かないブロックは最初に一度だけ描く。
  // 毎回32個を描き直すと
  // 68000ではゲームの動きそのものが遅くなる。
  x68_cls(background_color);
  for (int row = 0; row < kBlockRows; ++row) {
    for (int column = 0; column < kBlockColumns; ++column) {
      int block_x =
          kBlockStartX + column * (kBlockWidth + kBlockGapX);
      int block_y = kBlockStartY + row * (kBlockHeight + kBlockGapY);
      int color = block_color[block_color_index[row][column]];
      x68_box_fill(block_x, block_y, kBlockWidth, kBlockHeight, color);
    }
  }
  x68_box_fill(paddle_x, kPaddleY, kPaddleWidth, kPaddleHeight,
               paddle_color);
  x68_box_fill(ball_x, ball_y, kBallSize, kBallSize, ball_color);
  x68_locate(0, 0);
  printf("SCORE:%d", score);
  x68_screen_flip();

  for (;;) {
    int old_paddle_x = paddle_x;
    int old_ball_x = ball_x;
    int old_ball_y = ball_y;

    // 入力: パドル移動。
    if (x68_key_down(X68_KEY_LEFT)) paddle_x -= kPaddleSpeed;
    if (x68_key_down(X68_KEY_RIGHT)) paddle_x += kPaddleSpeed;
    if (paddle_x < 0) paddle_x = 0;
    if (paddle_x > kScreenWidth - kPaddleWidth) {
      paddle_x = kScreenWidth - kPaddleWidth;
    }

    // ボール移動。
    ball_x += ball_dx;
    ball_y += ball_dy;
    if (ball_x <= 0) {
      ball_x = 0;
      ball_dx = -ball_dx;
    }
    if (ball_x >= kScreenWidth - kBallSize) {
      ball_x = kScreenWidth - kBallSize;
      ball_dx = -ball_dx;
    }
    if (ball_y <= 0) {
      ball_y = 0;
      ball_dy = -ball_dy;
    }

    // 下向きに落ちてきてパドルへ触れたら跳ね返す。
    if (ball_dy > 0 && ball_y + kBallSize >= kPaddleY &&
        ball_y + kBallSize <= kPaddleY + kPaddleHeight &&
        ball_x + kBallSize >= paddle_x &&
        ball_x <= paddle_x + kPaddleWidth) {
      ball_dy = -ball_dy;
    }

    // 画面下に落ちたら中央へ戻す。
    if (ball_y > kScreenHeight) ResetBall();

    // 最初に当たったブロック1個だけ壊す。
    int hit = 0;
    int hit_x = 0;
    int hit_y = 0;
    for (int row = 0; row < kBlockRows && !hit; ++row) {
      for (int column = 0; column < kBlockColumns && !hit; ++column) {
        if (!block_alive[row][column]) continue;
        int block_x =
            kBlockStartX + column * (kBlockWidth + kBlockGapX);
        int block_y = kBlockStartY + row * (kBlockHeight + kBlockGapY);
        if (ball_x + kBallSize > block_x &&
            ball_x < block_x + kBlockWidth &&
            ball_y + kBallSize > block_y &&
            ball_y < block_y + kBlockHeight) {
          block_alive[row][column] = 0;
          ball_dy = -ball_dy;
          score += 10;
          last_destroyed_index =
              (long)(row * kBlockColumns + column);
          hit_x = block_x;
          hit_y = block_y;
          hit = 1;
        }
      }
    }

    // 前の動く物を消し、変わった所だけを描く。
    x68_frame_begin();
    x68_box_fill(old_paddle_x, kPaddleY, kPaddleWidth, kPaddleHeight,
                 background_color);
    x68_box_fill(old_ball_x, old_ball_y, kBallSize, kBallSize,
                 background_color);
    if (hit) {
      x68_box_fill(hit_x, hit_y, kBlockWidth, kBlockHeight,
                   background_color);
    }
    x68_box_fill(paddle_x, kPaddleY, kPaddleWidth, kPaddleHeight,
                 paddle_color);
    x68_box_fill(ball_x, ball_y, kBallSize, kBallSize, ball_color);

    // "SCORE:" と数字4桁程度なので、画面の64桁に収まる。
    if (hit) {
      x68_locate(0, 0);
      printf("SCORE:%d", score);
    }

    x68_screen_flip();
  }
}

// Sprout68k 作例: 星空を流す
//
// 配列を使うと、たくさんの物をまとめて動かせる。ここでは星を220個持ち、
// 1周ごとに全部を少しずつ左へずらしている。
// 星ごとに速さを変えると、遠近感が出る（速い星ほど手前に見える）。

#include "x68.h"

enum {
  kStarCount = 220,
};

static int star_x[kStarCount];
static int star_y[kStarCount];
static int star_speed[kStarCount];

// 星を1つ、指定した横位置に置き直す。縦位置と速さはその都度くじを引く。
static void ResetStar(int index, int x) {
  star_x[index] = x;
  star_y[index] = x68_rand_int(X68_SCREEN_H);
  star_speed[index] = 1 + x68_rand_int(3);
}

void main(void) {
  int background = x68_rgb(0, 0, 0);
  int i;

  x68_screen_open();
  srand(20260823);

  // 最初は画面のあちこちに散らばらせる。
  for (i = 0; i < kStarCount; i++) {
    ResetStar(i, x68_rand_int(X68_SCREEN_W));
  }

  for (;;) {
    x68_cls(background);
    for (i = 0; i < kStarCount; i++) {
      star_x[i] -= star_speed[i];

      // 左端まで来たら右端へ戻す。こうすると星が尽きない。
      if (star_x[i] < 0) ResetStar(i, X68_SCREEN_W - 1);

      // 速い星ほど明るく描くと、手前にあるように見える。
      x68_pset(star_x[i], star_y[i],
               x68_rgb(70 * star_speed[i], 70 * star_speed[i],
                       85 * star_speed[i]));
    }
    x68_screen_flip();
  }
}

// Sprout68k 作例: ライフゲーム
//
// 格子の上のマスが「生きている」か「死んでいる」かを、周りの8マスの数だけで
// 決めていく。規則はこの3つだけ。
//   ・生きているマスは、周りが2つか3つなら生き残る
//   ・生きているマスは、それ以外なら死ぬ
//   ・死んでいるマスは、周りがちょうど3つなら生まれる
// たったこれだけで、模様が動いたり増えたりする。
//
// 2次元配列を2枚使うのが要点。今の世代を見ながら次の世代を別の紙に書き、
// 書き終わってから入れ替える。1枚で書き換えると、まだ見ていないマスが
// 書き換わってしまって規則が崩れる。

#include "x68.h"

enum {
  kCols = 32,   // 横のマス数
  kRows = 32,   // 縦のマス数
  kCell = 16,   // 1マスの大きさ（ドット）
};

static char cells[kRows][kCols];
static char work[kRows][kCols];

// 周りの8マスのうち、生きている数を数える。
// 画面の外は「死んでいる」として数えない。
static int CountNeighbors(int row, int col) {
  int count = 0;
  int dr;
  int dc;

  for (dr = -1; dr <= 1; dr++) {
    for (dc = -1; dc <= 1; dc++) {
      int r = row + dr;
      int c = col + dc;

      if (dr == 0 && dc == 0) continue;
      if (r < 0 || r >= kRows || c < 0 || c >= kCols) continue;
      if (cells[r][c]) count++;
    }
  }
  return count;
}

// 次の世代を work に書き、書き終わってから cells へ移す。
static void StepGeneration(void) {
  int row;
  int col;

  for (row = 0; row < kRows; row++) {
    for (col = 0; col < kCols; col++) {
      int neighbors = CountNeighbors(row, col);

      if (cells[row][col]) {
        work[row][col] = (neighbors == 2 || neighbors == 3);
      } else {
        work[row][col] = (neighbors == 3);
      }
    }
  }
  memcpy(cells, work, sizeof(cells));
}

static void Draw(void) {
  int alive = x68_rgb(0, 255, 128);
  int row;
  int col;

  x68_cls(x68_rgb(0, 0, 32));
  for (row = 0; row < kRows; row++) {
    for (col = 0; col < kCols; col++) {
      if (cells[row][col]) {
        x68_box_fill(col * kCell, row * kCell, kCell - 1, kCell - 1, alive);
      }
    }
  }
}

void main(void) {
  int row;
  int col;

  x68_screen_open();
  srand(20260823);

  // 最初の世代をくじで決める。3回に1回くらい生きているようにする。
  for (row = 0; row < kRows; row++) {
    for (col = 0; col < kCols; col++) {
      cells[row][col] = (x68_rand_int(3) == 0);
    }
  }

  for (;;) {
    Draw();
    x68_screen_flip();
    StepGeneration();
  }
}