HN 日本語サマリー

← 一覧へ戻る
プログラミング

コモドール64でのポングウォーズ

Pong Wars on the Commodore 64 (imrannazar.com)

6 pointsby Two9A3 コメント

要約

この記事は、JavaScriptで作成された「ポングウォーズ」というゲームを、コモドール64のアセンブリ言語で再実装する過程を詳細に解説しています。ゲームのロジック、画面描画、そして当時のハードウェア制約の中で効率的なコードを書くための技術的な課題と解決策が、多くのデモコードと共に説明されています。

全文翻訳

コモドール64でのポン・ウォーズ

記事一覧へ戻る

2026年7月15日

この記事は2024年初頭に約束されたものでしたコモドール64でのポンウォーズ、@Two9A、2024年2月22日。あまりにも長くなったので、目次を追加しました。これは初めてかもしれません…

2024年の初めのある日、マストドンをぼんやりと見ていたところ、Koen van Gilst氏ポンウォーズをJavaScriptで再現によるトゥートを見つけました。2024年1月、@vnglst氏によるものです。

[動画:@vnglst氏のトゥート、議論中の狂気への転落のきっかけとなったもの]

これは、「昼」のボールと「夜」のボールが互いのフィールドの色を反転させるための永遠の戦いを描いたものです。数千もの「いいね!」がついていることから、多くの人が魅了されたようです。私もその一人で、ふと次のような考えが浮かびました。

van Gilst氏がオンラインでこれを見てJavaScriptで再現しなければならなかったなら、そして今私がこれを見てオンラインで知ったのなら、私はコモドール64でこれを再現しなければならない、ということですよね?

そんなこと可能なのか?

「はい、可能です!」まあ、そうあるべきだと思います。これは比較的単純なアニメーションで、ボールが表面に当たって跳ね返る瞬間にランダムな要素が加えられます。「跳ね返る表面」を定義するのが難しい部分のようです。

そこで、計画を立てる必要があります。そして最初のステップとして、定義を行います。

  • ボール(2つ)があり、直線的にスムーズに移動します。
  • ブロックフィールド:ボールが移動する20x20のブロック領域です。
  • ブロックフィールドには境界があり、ボールはその外側を移動できず、境界で跳ね返ります。
  • そして、ボールが跳ね返る原因となる2つのサイドがあり、ブロックが当たるとサイドが反転します。

これらのすべては、コモドール64でアセンブリ言語を長年ハッキングしてきたにもかかわらず、これまで実用的なものを書いたことがなかったという事実によって複雑になっています。学びながら進んでいくことになりそうです。

当時のほとんどのコンピューターでは、ビデオはCRTに出力されていました。これは数年前に書いた1541ディスクドライブに関するメガ・スレッドで説明した通りです「なぜコモドール64のディスクドライブは遅かったのか?」、Imran Nazar、2024年12月。ビデオ出力の各フレームの後には短い垂直ブランキング期間があり、その間、ビデオチップはメモリに何も要求しません。このアニメーションに必要な計算を、ブランキング期間内に完了するように制限し、フレームレンダリング中にマシンで発生している可能性のある他のものに不当に影響を与えないようにします。

コモドール64では、BASICインタプリタがその期間中に実行される主なものであり、この効果に役立つものがいくつかあります。その一つが、各フレームの底でトリガーされるフックです「ラスタ割り込み」、C64 Wiki、2024年3月更新。これにより、BASICを実行し続けながら、各フレームでカスタムコードを呼び出すことができます。そのため、以下のようなコードを計画できます。

[画像:メインループ:初期化、その後各フレーム:ボールの次の位置および/またはバウンスの計算、スコアの計算、フィールド/ボール/スコアのレンダリング]

図2:メインループのフローチャート

始める前に

初期化部分を見てみましょう。ブロックフィールドの状態を内部的に保持しますが、画面上のブロックフィールドも設定する必要があります。コモドール64は、デフォルトのテキストモードで40x25文字の領域(各文字は8x8ピクセルの正方形)を持っており、ここには2つのメモリ領域が関係します。

  • スクリーンRAMはデフォルトで$0400にあり、文字値を格納する千バイトの領域です。
  • $D800のカラーRAMは千ナイブル[A]ナイブルは4ビットであり、8ビットバイトとは対照的です。各場所はコモドール64の16色のうち1色を表すことができます。

スクリーンRAMの直後にスプライトデータのポインタがありますが、まだスプライトは設定していません。そのため、スクリーンに1024バイトを書き込むというショートカットを使います。これはスクリーンの終端を超えて書き込みますが、コードを大幅に簡略化します。

SCRRAM = $0400
BLOCKPTR = $03   ; BASICによって使用されない2バイトのブロック

init:
    subroutine

    ; スクリーンRAMのポインタを設定、左上から開始
    ; 65xx CPUはリトルエンディアンなので、下位バイトが先
    lda #<SCRRAM
    sta BLOCKPTR
    lda #>SCRRAM
    sta BLOCKPTR + 1

    ; 文字0(@)ではなく、SPACE(文字32)を書き込みます
    lda #32

    ; 4回、256バイトずつ、合計1024バイト書き込みます
    ldx #4
    ldy #0

.blank:
    ; 内側のループ:Y=0から255、254、...0まで実行
    sta (BLOCKPTR), y
    dey
    bne .blank

    ; 外側のループ:ポインタを256ずつ進めます
    inc BLOCKPTR + 1
    dex
    bne .blank

(余談ですが、BLOCKPTRは「BASICによって使用されない」値に設定されていますが、どうやってそれを知るのでしょうか? Joe Forster氏(STAデモグループ)によるコモドール64のメモリマップの詳細なマップコモドール64メモリマップによると、BASICとカーネルROMが標準操作で触れない場所があり、プログラムが使用できることが示されています。)

スクリーンが均一なコモドールブルーになったので、20x20の領域としてブロックフィールドを描画できます。コモドール64のディスプレイは、テキストモードで各文字に前景色を設定できますが、背景色は画面全体で共有されます。カラーRAMを使用して、どのブロックが白でどのブロックが黒か(そして私たちはそうしたい)を示したい場合、すべて前景色の穴のない文字を使いたいでしょう。

[画像:C64の文字セット、128文字ずつの2つのブロック]

図3:C64文字セット1、128文字ずつの2セット
ソース:Jodigi、C64 Wikiの管理者「文字セット」、C64 Wiki、2025年8月更新

文字セットの後半には、前半の逆ビデオコピーが含まれているため、SPACE(文字160)の逆ビデオバージョンをすべて前景のブロックとして使用できます。ループは少し複雑になります。画面幅が40文字のところに20文字の行を書き込むには、20文字書き込んで20文字スキップする必要があります。さらに、このブロックを画面中央に配置したいので、1行下から10文字目から開始する必要があります。

結果として得られるポインタは、実際にはスクリーンRAMの開始位置から1行と9文字後になります。なぜなら、20バイトの行を書き込む効果は、0から始めて19まで(20で中止)行くか、20から始めて1まで(0で中止)下がるかのいずれかで達成できるからです。後者の方が比較処理を節約できるため、コードサイズが速く小さくなります。

```assembly
lda #<(SCRRAM + 40 + 9)
sta BLOCKPTR
lda #>(SCRRAM + 40 + 9)
sta BLOCKPTR + 1

; 今回は20行の20文字、文字160を書き込みます
; 通常、Xを行に沿って、Yを下に考えますが、
; 65xxはYをインデックスとする間接アドレッシングしか提供しません
ldx #20

.field:
lda #160
ldy #20
.row:
sta (BLOCKPTR), y
dey
bne .row

; BLOCKPTRに40を加算(16ビット加算)
; Aを破壊するので、.fieldループの先頭で再ロードする必要があります
lda BLOCKPTR
adc #40
sta BLOCKPTR
lda BLOCKPTR + 1
adc #0
sta BLOCKPTR + 1

dex
bne .field
```

スクリーンRAMが完全に設定されたので、次にカラーRAMです。後で(先を読んで)バウンス計算を簡略化するためにダブルバッファリング技術を使用することになります。これは、ブロックフィールド用の400個の連続した黒/白の値の内部バッファがあり、各フレームでカラーRAMにレンダリングされることを意味します。そのため、初期化は内部ブロックフィールドバッファの設定になります。

BLOCKBUF = $CE00   ; 512バイトの未使用RAM、十分な量です

    lda #<BLOCKBUF
    sta BLOCKPTR
    lda #>BLOCKBUF
    sta BLOCKPTR + 1

    ; 初期ブロックフィールドは半分が黒(色0)、半分が白(1)です
    ; 言い換えれば、黒10個と白10個の20行です
    ; さらに言い換えれば、交互に黒と白の40領域です
    lda #0
    ldx #40
.fill:

    ; 内側のループ、10個の領域(黒または白)を書き込みます
    ; 今回は、9から0までをインクルーシブで書き込み、-1で停止します
    ldy #9
.fill_row:
    sta (BLOCKPTR), y
    dey
    bpl .fill_row

    ; BLOCKPTRに10を加算(16ビット加算)
    ; Aを破壊しますが、今回は固定値を新しく書き込むことはできません
    ; なのでAをスタックにプッシュします
    pha
    lda BLOCKPTR
    adc #10
    sta BLOCKPTR
    lda BLOCKPTR + 1
    adc #0
    sta BLOCKPTR + 1

    ; Aをスタックからポップし、XOR 1で0と1を切り替えます
    pla
    eor #1

    dex
    bne .fill

これで初期化ステップはほぼ完了です。残りは2つのこと:スムーズに移動するボール用のスプライトを設定すること、そして毎フレーム実行されるメインルーチン用のフックを接続することです。そのため、ボールの8x8ピクセルの表現をデザインする必要があります。Minecraftのシーンには、オンラインで豊富なピクセル形状ジェネレーターがありますので、8x8に設定された円ジェネレーター「ピクセル円ジェネレーター」、Donat Studios、2025年7月更新を使用できます。

[画像:ピクセル円ジェネレーターのインターフェース、下に円が表示されている]

図4:ピクセル円ジェネレーターを幅8の塗りつぶし円に設定

コモドール64のテキスト文字と同様に、スプライトは設定されたピクセルに対して前景色を持ち、設定されていないピクセルに対しては背景が透過します。これは、スプライトがバイナリで定義できることを意味します。テキスト文字は8x8ピクセルですが、スプライトは24x21で、ビデオチップはスプライト設定時にそのサイズに対応するバイナリデータを期待します。ボール自体は8x8ピクセルなので、残りは0でパディングする必要があります。

24x21ビットのデータは63バイト連続なので、コモドール64のビデオチップは、スプライトデータへのポインタが64バイト境界にアラインされていることを期待します。その結果、スプライト設定中に、ポインタを64で割った値(一種の「データブロックインデックス」)を期待します。前述のように、スプライトへのポインタはデフォルトでスクリーンテキストの直後にRAMにあります。

SPRPTR = SCRRAM + (40 * 25)

    lda #(ballmap / 64)
    sta SPRPTR       ; スプライト0
    sta SPRPTR + 1   ; スプライト1

    ; これはソースコードの末尾、
    ; 「データセクション」に配置されます。今は隣接して表示されています
    align 64
ballmap:
    byte %00111100, %00000000, %00000000
    byte %01111110, %00000000, %00000000
    byte %11111111, %00000000, %00000000
    byte %11111111, %00000000, %00000000
    byte %11111111, %00000000, %00000000
    byte %11111111, %00000000, %00000000
    byte %01111110, %00000000, %00000000
    byte %00111100, %00000000, %00000000
    byte %00000000, %00000000, %00000000
    byte %00000000, %00000000, %00000000
    byte %00000000, %00000000, %00000000
    byte %00000000, %00000000, %00000000
    byte %00000000, %00000000, %00000000
    byte %00000000, %00000000, %00000000
    byte %00000000, %00000000, %00000000
    byte %00000000, %00000000, %00000000
    byte %00000000, %00000000, %00000000
    byte %00000000, %00000000, %00000000
    byte %00000000, %00000000, %00000000
    byte %00000000, %00000000, %00000000
    byte %00000000, %00000000, %00000000
    byte %00000000, %00000000, %00000000

スプライトデータが設定されたので、各スプライトの前景色として希望する色をビデオチップに通知し、スプライトをオンにすることができます。ここではスプライトの画面上の位置を設定していません。これはレンダリングコードによって行われます。デフォルトの位置0x0は画面外の左上にあり、都合よく邪魔にならない場所にあります。

コモドール64では、ハードウェアとの対話はメモリとの対話と同じ方法で行われます。特殊なアドレスへの読み書きです。ドキュメントでは、さまざまなチップの「レジスタ」と呼ばれています。ビデオインターフェイスチップ(VIC)には40以上のレジスタがありますが、ここではスプライト0と1を制御するレジスタに関心があります。

スプライト場所名前詳細
0$D000SPR0XX座標
$D001SPR0YY座標
$D027SPR0COL色
1$D002SPR1XX座標
$D003SPR1YY座標
$D028SPR1COL色
全て$D010SPRXHIX座標、9ビット<br>各スプライトに1ビット
$D015SPRENスプライト有効化<br>各スプライトに1ビット

表1:スプライト0と1のVICスプライト制御レジスタ

ここに興味深いひねりがあります。スプライトをレンダリングする際に、画面が256ピクセルより広いため、X座標が1バイトに収まらないからです。代わりに、SPRXHIというスプライトのX座標の9ビット目を持つビットがあり、画面の右側にあるときに設定する必要があります。今はこれを脇に置いておきます。

```assembly
; スプライト0は黒い側から始まり、白です
lda #1
sta SPR0COL

; スプライト1は白い側から始まり、黒です
lda #0
sta SPR1COL

lda #%00000011
sta SPREN
```

これで設定は完了です。ブロックフィールドは配置され、スプライトは有効化され、残っているのは、毎フレーム実行されるレンダリングコードをどこで見つけるかをコモドール64に伝えることだけです。

IRQ = $0314

    ; セットアップ中に割り込みが発生しないように
    ; 割り込みを無効化します
    sei

    lda #<isr
    sta IRQ
    lda #>isr
    sta IRQ + 1

    cli

; 割り込みサービスルーチン:メインレンダラー
isr:
    subroutine

    ; ISRはレジスタを破壊せずに透過的に実行する必要があるため、
    ; スタックに完全な状態を保存します
    pha
    txa
    pha
    tya
    pha

    ; TODO: ここでレンダリング
    jsr advance_white
    jsr collide_white
    jsr advance_black
    jsr collide_black
    jsr render_field
    jsr render_score

    ; スタックから状態を逆順にプルします
    pla
    tay
    pla
    tax
    pla

    ; コモドール64が通常この割り込みのサービス中に
    ; 行う場所に戻ります
    jmp $EA31

これでプログラム全体ができましたが、まだあまり多くのことはできません。これをアセンブルしてエミュレータにロードするディスクイメージを作成すると[B]ここでは、おそらくこれまで構築された中で最も正確なエミュレーターであるVICEを使用しています。次のようになるかもしれません。

[画像:初期化後のコモドール64画面、中央に空白の20x20領域が表示されている]

図5:初期化後のポンウォーズ実装

余談:C64ディスクイメージの作成

これをハッキングしている間に、エミュレーターは通常、バイナリイメージを受け取ってコモドール64のメモリにドロップして実行させることはできないことに気づきました。プログラムをロードする標準的なユーザーフレンドリーな方法は、ディスク(この場合はディスクイメージ)からロードすることです。そのため、アセンブリで記述したプログラムをディスクイメージに入れる必要があります。

VICEにはディスクイメージを操作するためのツールが用意されています。エミュレーターにディスク接続を提供するために1541ディスクドライブをエミュレートする必要があるため、これらのツールは実装の一部として実質的に無料で入手できます。この場合、ディスクドライブのコマンドラインエミュレーションはc1541として利用可能であり、ディスクイメージを作成するために必要なすべてのステップを実行するように指示できます。

  • フォーマット:イメージにトラックのパターンを配置するためにディスクをフォーマットします。
  • アタッチ:イメージをエミュレーターにアタッチします。
  • 書き込み:プログラムをディスクに書き込み、ディレクトリリストに名前を付けます。
Makefile:アセンブリとイメージ生成
# VICE_ROOTをVICEバイナリを指すように変更してください
#私はM1 Macを使用しているので、これはarm64/osxのコピーです
VICE_ROOT = /Applications/vice-arm64-gtk3-3.7.1/bin
NAME = pongwars

all: $(NAME).d64

$(NAME).d64: $(NAME).prg
    $(VICE_ROOT)/c1541 \
        -format $(NAME),8 d64 $(NAME).d64 \
        -attach $(NAME).d64 \
        -write $(NAME).prg $(NAME)

$(NAME).prg: $(NAME).asm
    dasm $(NAME).asm -o$(NAME).prg

(また、ここで書かれた6502コードをバイナリイメージにアセンブルするためにdASM[7]「dASMアセンブラ」https://github.com/dasm-assembler/dasm/、最終リリース2020を使用していることにも言及する価値があります。これはその後c1541によってディスクイメージにプッシュできます。)

ゲームループ:移動計算

初期化ステップを設定し終えたプログラムに戻ってきました。今、私たちは空のゲームループを持っており、それを埋める必要があります。図2から、主なステップは2つのボールを進め、衝突をチェックし、更新されたブロックフィールドとスコアをレンダリングすることです。

「ボールを進める」とはどういう意味でしょうか? 図1に戻ると、ボールはフィールドの中央から始まり、フレームごとに固定速度で移動しますが、方向は変化する可能性があります。固定速度が毎フレーム1ピクセルだとすると、三角法によれば、ボールは水平方向と垂直方向に小数ピクセル移動する必要があることを示しています。

[画像:θをラベル付けされた角度とする直角三角形、軸の脚にcos/sin θがある]

図6:単位ベクトルの成分

実際には小数ピクセルでスプライトを移動させることはできませんが、小数部分を追跡し、計算が次の整数位置を超えた場合にスプライトを移動させることができます。例えば、θが35度の場合、ボールの位置は連続するフレームで次のようになります。

フレームX座標Y座標画面座標
0000, 0
10.8190.5740, 0
21.6381.1471, 1
32.4571.7202, 1
43.2772.2943, 2

表2:速度1、方向35°のボールの連続位置

コンピューティングで小数について話すとき、おそらくあなたの心は浮動小数点数に直行するでしょう。これは、遭遇する可能性のあるほとんどの小数数を表すことができます。コモドール64は浮動小数点演算をサポートしていますが、驚くほど遅いです。それらを処理するための専用ハードウェアがないため、BASICインタプリタはテキスト形式で浮動小数点数を扱い、独自のバイナリ形式を使用して内部で計算を実行し、保存のためにテキストに翻訳し直します。

私たちの目的には、別の方法があります:固定小数点数です。これは、数値の整数部分と小数部分が常に一定の長さであり、数値間で変化しないものです。これは複数の理由で機能します。

  • フィールドは20x20ブロック、つまり160x160ピクセルなので、ボールの座標(水平または垂直)の整数部分はバイトに収まり、画面上のボールをプロットするためにそのバイトから直接取得できます。
  • 図6に示すように、ボールの方向は単位ベクトルなので、cos θとsin θは常に1未満です。実際、これらはサイン関数のルックアップテーブルから直接取得できます。

さらに、θを従来の360度ではなく256「度」の範囲で扱うことで、ボールの方向を1バイトに収めることができます。これらすべてをまとめると、ボールの状態の内部表現は、次のような5バイトの構造になります。

[画像:ボールの状態の5バイトデータ構造:theta、X座標、Y座標]

図7:ボール状態のデータ構造

データ構造とともに初期化ステップがあります。これは、以前の初期化コードに追加したいものです。これにより、ブロックフィールド上のボールの初期位置と方向を設定でき、それをレンダラーで使用できます。

; ボールデータは5バイトにまたがります
BALL0 = $D9
BALL1 = $DE

init:
    ; ...
    ; 初期位置データをゼロページにコピーします
    ; 5バイトのセットを連続して両方行うことができます
    ldx #10
.spr_init:
    lda posdata, x
    sta BALL0, x
    dex
    bpl .spr_init

posdata:
    ; 白いボール:角度32(南東)、X 40.0、Y 40.0
    byte 32, 40, 0, 60, 0
    ; 黒いボール:角度160(北西)、X 120.0、Y 120.0
    byte 160, 120, 0, 120, 0

そして、ゲームループに要素を追加し始めることができます。図2から、ボールの位置を進め、新しい位置をレンダリングすることが、最初の目に見えるステップになります。これには、単位ベクトルの水平および垂直成分の加算が含まれます。そのためには、サイン/コサインのルックアップテーブルが必要になります。

コモドール64の6510プロセッサには、インデックス付きアドレッシングモードにバグがあります。256バイト境界にアラインされていない256個の値のテーブルがある場合、インデックスレジスタを加算すると、最終的な位置がテーブルの残りの部分に進むのではなく、境界をラップアラウンドする可能性があります。つまり、インデックスがループバックする前にその部分に到達しないため、ルックアップテーブルの一部がアクセス不能になります。

このバグを回避するために、アセンブラのalignキーワードを使用して、ルックアップテーブルをページ境界にアラインするように注意する必要があります。しかし、これを利用することもできます。コサイン関数は、波形の4分の1だけオフセットされたサイン関数と同じです。そのため、テーブルにインデックスを付けて特定の角度のサイン値を取得し、インデックスに64を加算して同じ角度のコサインを取得できます。64を加算してもテーブルの終端を超えない場合、問題ありません。そのラップアラウンドは、探しているインデックスの近くの開始位置に戻ることを意味します。

これらすべてをまとめると、ボールの位置を進めるためのサブルーチンがペアになり、次のようになります(ここでは黒いボールのルーチンのみを含みます。白いボールも同様です)。

advance_black:
    subroutine

    ; x += cos(theta)
    lda BALL0
    clc
    adc #64
    tax
    lda sindata, x   ; LUTラップアラウンド
    ldy #(BALL0 + 1)
    jsr add_u16_s8

    ; y += sin(theta)
    lda BALL0
    tay
    lda sindata, y
    ldy #(BALL0 + 3)
    jsr add_u16_s8

    ; TODO: 画面上の位置決め

    rts

    ;--------------------------------
    align 256
sindata:
    hex 00 03 06 09 0C 10 13 16 19 1C
    hex 1F 22 25 28 2B 2E 31 33 36 39
    hex 3C 3F 41 44 47 49 4C 4E 51 53
    hex 55 58 5A 5C 5E 60 62 64 66 68
    hex 6A 6B 6D 6F 70 71 73 74 75 76
    hex 78 79 7A 7A 7B 7C 7D 7D 7E 7E
    hex 7E 7F 7F 7F 7F 7F 7F 7F 7E 7E
    hex 7E 7D 7D 7C 7B 7A 7A 79 78 76
    hex 75 74 73 71 70 6F 6D 6B 6A 68
    hex 66 64 62 60 5E 5C 5A 58 55 53
    hex 51 4E 4C 49 47 44 41 3F 3C 39
    hex 36 33 31 2E 2B 28 25 22 1F 1C
    hex 19 16 13 10 0C 09 06 03 00 FD
    hex FA F7 F4 F0 ED EA E7 E4 E1 DE
    hex DB D8 D5 D2 CF CD CA C7 C4 C1
    hex BF BC B9 B7 B4 B2 AF AD AB A8
    hex A6 A4 A2 A0 9E 9C 9A 98 96 95
    hex 93 91 90 8F 8D 8C 8B 8A 88 87
    hex 86 86 85 84 83 83 82 82 82 81
    hex 81 81 81 81 81 81 82 82 82 83
    hex 83 84 85 86 86 87 88 8A 8B 8C
    hex 8D 8F 90 91 93 95 96 98 9A 9C
    hex 9E A0 A2 A4 A6 A8 AB AD AF B2
    hex B4 B7 B9 BC BF C1 C4 C7 CA CD
    hex CF D2 D5 D8 DB DE E1 E4 E7 EA
    hex ED F0 F4 F7 FA FD

しかし、待ってください、このadd_u16_s8は何でしょうか? さて、ボールの位置の各成分は固定小数点数であり、小数点の前後に8ビットがあることを思い出してください。これは、符号なし16ビット数と同等です。この固定小数点数にサインテーブルから値を追加することは、16ビット数に符号付き8ビット数(-128から+127までの範囲の値)を追加することと同じです。

プロセッサには16ビット数のネイティブな処理機能がないため、ルーチンを構築する必要があります。幸いなことに、そのようなルーチンは非常に単純です。8ビット値を下位(この場合は小数部分)に追加し、値が8ビット範囲を超えるとプロセッサのCARRYフラグが設定されます。次に、8ビット値が正か負かに応じて、CARRYを上位(整数部分)に追加または減算します。

プロセッサは、「数値が負かどうか」という部分でも役立ちます。利用可能な他のフラグの1つがNEGATIVEフラグです。これは、計算後の8ビット値の最上位ビットと同じです(最上位ビットは、伝統的に負数を示す方法です)。それに加えて、bpl(「プラスなら分岐」)とbmi(「マイナスなら分岐」)命令があります。

NEGATIVEフラグを設定するが値を変更しない命令と組み合わせてbplを使用することで、これらの2つの分岐を取ることができます。

; add_u16_s8: 8ビット符号付きを16ビット符号なしに追加します
; @param A 8ビット符号付き値
; @param Y 16ビット符号なし値へのゼロページポインタ
; @return Yへの変更された値
; @破壊 A
; @保持 Y
add_u16_s8:
    subroutine
    and #255      ; Nを設定
    bpl .positive

.negative:
    clc
    adc 1, y      ; 小数を加算
    sta 1, y
    lda 0, y
    sbc #0        ; 整数からCを減算
    sta 0, y
    jmp .end

.positive:
    clc
    adc 1, y      ; 小数を加算
    sta 1, y
    lda 0, y
    adc #0        ; 整数にCを加算
    sta 0, y

.end:
    rts

余談その2:負数の表現

鋭い読者は、add_u16_s8の動作の説明で奇妙な点に気づいたかもしれません。

8ビット値を下位(この場合は小数部分)に追加します…次に、Cを上位(整数部分)に追加または減算します。

確かに、数値が負の場合、両方とも減算したいのではないでしょうか? なぜそうしないのかを理解するために、コンピューターでの負数の表現の歴史を簡単に振り返る価値があります。

コンピューターは当初、数学者やバイナリ数の難解な分野に精通した人々だけのものでした。そのため、数値処理は「ブリンケンライツ」から直接バイナリで読み取れるように構築されていました。正数と負数の両方を処理する最も簡単な方法は、数値の1ビットを「負数ビット」としてマークし、残りの数値を値として表すことでした。これは「符号と絶対値」表現と呼ばれていました。例えば:

23と-23:
0 0010111
1 0010111

加算回路しか持たないコンピューターで減算(または負数を加算すること、これは機能的に同等)を実行するには、誤った結果にならないように、事前に計算を実行する必要があります。

[63 - 23]      [63 + -23]
00111111   =   00111111
- 00010111     + 10010111
               --------
               11001100
               -86

減算を実行する際に、符号と絶対値の負数は反転(または数学的な専門用語で1の補数)する必要があります。そうしないと、加算しても値が減るのではなく積み重なってしまうからです。

[63 - 23]      [63 + -23]
00111111   =   00111111
- 00010111     + 11101000
               --------
            [1]00100111
               39(とキャリー)

ただし、補数化しても完全に解決しません。符号と絶対値の数値はゼロ(00000000)と負のゼロ(10000000)を持つことができるため、負のゼロ値をスキップするために、反転後に1を加える必要があります。

[63 - 23]      [63 + -23]
00111111   =   00111111
- 00010111     + 11101001
               --------
            [1]00101000
               40(とキャリー)

要約すると、負数は、バイナリ表示から読み取りやすくするために、負の符号ビットと絶対値として表現されていましたが、コンピューターは加算を実行するために、まず数値を反転してから1を加える必要がありました。

バイナリ読み取り表示がコンピューティングの普及とともに消えていくにつれて、人間がコンピューターを使用する数学者のためではなく、コンピューターの内部操作のために、負数の表現を単純化することが理にかなってきました。コンピューターにとって最良のこと、もちろん、補数化して1を加えるというこの全体のパイプラインを、負数を加算できるようになる前に削除することです。

そして、これが2の補数(1の補数に1を加えるため、2の補数)表現がバイナリ負数の標準として定着した理由です。数値の符号ビットが負に設定されている場合、残りの値はすでに反転されて1が加算されているため、コンピューターは通常の加算を実行するだけで済みます。

これは、バイナリ数値が「通常」読めなくなるため、低レベルで作業するプログラマーの認知負荷を増加させます。

00000000 =    0
00000001 =    1
00000010 =    2
... 
01111110 =  126
01111111 =  127
10000000 = -128 (0ではない)
10000001 = -127 (1ではない)
10000010 = -126 (2ではない)
... 
11111110 =   -2
11111111 =   -1

しかし、80年代のマイクロコンピューター時代に、BASICのような高水準言語が広く利用可能である場合に、2の補数表現について覚えておく必要があるほど低レベルで作業することはいつになるでしょうか? BASICでは得られないパフォーマンスをさらに引き出す必要がある場合、つまりここで必要な場合です。

だからこそ、add_u16_s8は、s8が正か負かにかかわらず、両方の分岐で加算を実行するのです。

移動の次は位置決め

定刻通りの番組に戻りましょう。ボールの位置の内部表現を進めることができるようになりましたが、画面上でボールをまだ見ることができません。それが起こるためには、ビデオチップのレジスタにスプライトの位置を設定する必要があります。ただし、計算された値を単純にコピーすることはできません。プレイフィールドの左上はスプライト座標0,0ではありません。画面の左上さえ0,0ではありません。

[画像:印刷されたページのスキャン:C64画面の図、6つのスプライト位置を示す。位置1には「24,50」と注釈が付いている]

図8:C64でのスプライト位置決め座標。これはプログラマーリファレンスから、Mike Dailly「ラスタ、スプライト、マルチプレキシング」、Mark Dailly、2024年7月経由で取得したものと思われます。

少し前のことから覚えているかもしれませんが、ブロックフィールドは画面の左上から1行と10文字入ったところにあります。これは(各文字が8x8ピクセルであることを考えると)下に8ピクセル、横に80ピクセルです。その結果、ボールスプライトを画面上の目的の位置にプロットするには、X座標に104、Y座標に58を加える必要があります。

そして、以前に言及したひねりが再び現れます。SPRXHIは、各スプライトのX座標の9ビット目を含むビデオチップ制御レジスタです。VICはこれを下位8ビットと組み合わせて最終的な位置を生成するため、ボールの位置を設定するたびにSPRXHIを適切に更新する必要があります。

余談ですが、ボールがプレイフィールドで最も右に行けるのは、右端で跳ね返る前の19ブロック、つまり152ピクセルです。104のオフセットを加えると、最終的な位置は256になります。プレイフィールドが中心からさらに1ピクセル左にあった場合、ゲームループ中にSPRXHIを気にする必要はありませんでした。

これをコードに翻訳するために、advance_blackの残りを埋めましょう。図7から、各ボールはメモリ内に固定小数点数形式で座標を保持するデータ構造を持っていることを思い出してください。そのため、画面上の位置に変換する際には、各座標の整数部分のみが必要です。以前のコードにTODOを残したので、それを上に持ち込みます。

advance_black:
    subroutine

    ; x += cos(theta)
    lda BALL0
    clc
    adc #64
    tax
    lda sindata, x   ; LUTラップアラウンド
    ldy #(BALL0 + 1)
    jsr add_u16_s8

    ; y += sin(theta)
    lda BALL0
    tay
    lda sindata, y
    ldy #(BALL0 + 3)
    jsr add_u16_s8

    ; スプライトを位置決めします
    ; X座標の下位バイトから先に
    lda BALL0 + 2
    adc #104
    sta SPR0X

    ; 次に上位9ビット:加算の結果が
    ; 255を超えた場合、Carryフラグが設定されます
    lda SPRXHI
    and #%11111110
    bcc .xlow
    eor #1
.xlow:
    sta SPRXHI

    ; Y座標は常に1バイトです
    ; (前のCarryをクリアすることに注意)
    lda BALL0 + 4
    clc
    adc #58
    sta SPR0Y

    rts

これを白いボールと黒いボールの両方で行い、advance_whiteとadvance_blackを埋めると、ゲームループの各周回でボールが画面上で1ステップ移動し、次のようになります。

[動画:上記のコードがVICEで実行されている(3倍速)]

図8:上記のコードがVICEで実行されている(3倍速)

これで進歩しました。2つのボールが移動しているのが見えますが、プレイフィールドを脱出して画面の端を回り込み、同じ方向に永遠に移動します。これは、もちろん、プレイフィールドの端に衝突を検出し、ボールが衝突したときに跳ね返らせるコードがまだないためです。これが次に必要になるものです。

ボールがフィールドの端に衝突し、跳ね返る必要がある可能性のある条件は4つあり、それらは2つのグループに分けられます。

  • ボールが上端に当たった場合、上向きに移動していて下向きに跳ね返る必要があります。逆に、ボールが下端に当たった場合、下向きに移動していて上向きに跳ね返る必要があります。
  • ボールが左端に当たった場合、左向きに移動していて右向きに跳ね返る必要があります。同様に、右向きに移動しているボールは右端に当たり、左向きに跳ね返る必要があります。

ボールの座標(より正確には、ボールスプライトの左上の座標)を知っており、フィールドのサイズを知っているので、これは比較的単純な比較セットになります。唯一の注意点は、下端または右端でのヒットをチェックするときは、ボールスプライトの左上ではなく、右下(それぞれ8ピクセルさらに横)と比較することです。

したがって、フィールドが両方向で20ブロック、つまり160ピクセルである場合、ボールの座標がいずれかの方向に152に達すると、端にヒットしたことになります。要約すると、ボールが跳ね返る必要がある4つの条件は次のとおりです。

  • ボールのY座標が0の場合、上端にヒットしました。
  • ボールのY座標が152の場合、下端にヒットしました。
  • ボールのX座標が0の場合、左端にヒットしました。
  • ボールのX座標が152の場合、右端にヒットしました。

ボールが跳ね返るということはどういうことでしょうか? 図6から、ボールの速度は単位ベクトルで記述されていることを思い出してください。常に同じ単位速度で移動していますが、角度を追跡しています。したがって、バウンスは角度の変化です。具体的には、それらは反射によって引き起こされる角度の変化です。

[画像:X軸とY軸でのベクトルの反射、結果の角度変化を示す]

図9:反射とその結果の角度<br>Michael Corral、OpenCurriculum経由Michael Corral、「角度の回転と反射」、2020年9月

図9では、X軸(水平線に当たる)での反射は角度を否定させ、Y軸(垂直線に当たる)での反射は角度θを180° - θに変更させることがわかります。私たちの目的のために、θは256「度」の範囲をカバーすることを思い出してください。そのため、これらの角度の反転を実行するコードを埋め始めることができます。θはメモリ内のボール情報ブロックの最初の部分に格納されていることを覚えておいてください。

flipx_black:
    subroutine
    lda #0       ; NEGを使用しない理由があります
    sec          ; 後で説明します
    sbc BALL0
    sta BALL0
    rts

flipy_black:
    subroutine
    lda #128
    sec
    sbc BALL0
    sta BALL0
    rts

そして、前述のようにフィールドの端との衝突を検出する必要があります。collide_blackを埋めることで、これを実行します。

collide_black:
    subroutine

    ; X座標をチェックします
    lda BALL0 + 2

    ; 左端に到達していない場合はスキップします
    cmp #0
    bpl .nobounce_x

    ; 右端にも到達していない場合はスキップします
    clc
    cmp #152
    bcc .nobounce_x

    ; ここまで到達した場合、反転が必要です
    ; 垂直線に当たったので、Yで反転します
    jsr flipy_black

.nobounce_x:
    ; Y座標をチェックします
    lda BALL0 + 4

    ; 上端に到達していない場合はスキップします
    cmp #0
    bpl .nobounce_y

    ; 下端にも到達していない場合はスキップします
    clc
    cmp #152
    bcc .nobounce_y

    ; ここまで到達した場合、反転が必要です
    ; 今回は水平線です
    jsr flipx_black

.nobounce_y:
    ; TODO: もう一方のサイドとの衝突を検出します
    rts

対応するcollide_whiteルーチンとそのフリップヘルパーを埋めると、これらは各フレームで実行され、次のようになります。

[動画:ボールがプレイフィールド内を跳ね返り、VICEで(3倍速)]

図10:ボールがプレイフィールド内を跳ね返り、VICEで(3倍速)

これで進歩しました。プレイフィールド、その中で跳ね返るボールがあります。しかし、予測可能性の感覚がありません。バウンスは常に完璧で、ボールはよく使われるパスを永遠に移動します。たとえそれらがフィールドの境界に制約されていたとしてもです。

必要なのは…

運の要素

図1の元のPong Warsには、ランダム性の要素があります。各バウンス(フィールドの端か反対色のブロックかに関わらず)は、角度に小さなオフセットが加えられた反射であり、このランダムなオフセットが魅力的な無限の複雑さを導入します。

コモドール64で同じ効果を得るために、BASICのRND関数を使用して疑似乱数を生成できます(予想されるように、これは疑似乱数生成と呼ばれます)。このアプローチには2つの問題があります。疑似乱数であるため、シーケンスは予測可能なので、このコードを実行するたびに同じ結果になります。しかし、私たちの目的のためには、RNDは比較的複雑なPRNG関数を使用するため、数値を生成するのが驚くほど遅いです。

コモドール64では、高速で比較的簡単に操作できる代替手段があります。ハードウェアです。サウンドチップには3つのボイスがあり、各ボイスは調整可能な周波数で、三角波、のこぎり波、パルス波、ノイズの4つの波形のいずれかに設定できます。

[画像:コモドール64 SIDの4つの波形、それぞれ数サイクル]

図11:コモドール64 SIDの4つの波形<br>Philip Nelson、Compute!誌、1985年2月「64での高度なサウンドエフェクト」、Atari Magazinesアーカイブ

私たちの目的のために、SIDのボイスの1つをノイズ生成に設定できますが、ボイスの出力を無効にして、実際にマシンをスクリーチさせないようにします。その後、SIDの内部生成状態を乱数ソースとして使用できます。

SIDの設定は、一般的な初期化ルーチンの一部として行う必要があります。そのため、SIDレジスタを適切に設定するために、再びinitサブルーチンに戻ります「6502アセンブラからの乱数取得」、StackOverflowの「Mike」、2017年7月。

SID_3_FREQ = $D40E
SID_3_CTRL = $D412
SID_3_OUT = $D41B

init:
    ; ...
    ; スプライトデータ初期化後、
    ; ノイズ生成のためにSIDボイス3を設定します

    ; 最大周波数(65535)
    lda #255
    sta SID_3_FREQ
    sta SID_3_FREQ + 1

    ; ノイズ波形、出力無効
    lda #%10000000
    sta SID_3_CTRL

これで、いつでもハードウェア生成のリアルな乱数をSID_3_OUTでポーリングできますが、値は0から255までのフルバイト範囲になります。この範囲を、以前に言及した「小さなオフセット」に制限したいと考えています。これは、上位ビットを切り捨てることでかなり効率的に達成できます。さらに重要なのは、ゼロを中心にしたいということです。これは、新しい範囲の半分を減算することで実現できます。これを独自のサブルーチンに分離し、反射関数を調整して、固定値0と128の代わりにこのランダムオフセットをベースとして使用できるようにします。

rand:
    ; 乱数を生成します
    ; Aで-8から+7の範囲
    subroutine
    lda SID_3_OUT
    and #%00001111
    sec
    sbc #8
    rts
flipx_black:
    subroutine
    jsr rand
    sec
    sbc BALL0
    sta BALL0
    rts

flipy_black:
    subroutine
    jsr rand
    clc
    adc #128
    sec
    sbc BALL0
    sta BALL0
    rts

この調整を適用すると、プレイフィールドでの永遠のバウンスがより面白く見えます。

[動画:わずかにオフセットされた方向で跳ね返るボール、VICEで(3倍速)]

図12:わずかにオフセットされた方向で跳ね返るボール、VICEで(3倍速)

プレイフィールド

(明らかに)7000語の後、私たちはポイントに到達しました。プレイフィールド内で跳ね返ることができるこれらのボールは、それらが自分の色のブロックに衝突しようとしていることを検出する必要があり、そこから跳ね返り、色を反転させる必要があります。また、これまでフィールドを通してクラシックなコモドールブルーを表示するために延期していた、フィールドのブロックをレンダリングする必要があります。

2番目のポイントから見ていきましょう。内部表現から画面にブロックデータを転送します。初期化中にスクリーン文字を20文字の行で設定したときと同様に、レンダリングループの各周回でこれを行う必要がありますが、今回は色(黒または白)を使用します。

ここでは幸運です。コモドール64のカラーパレットでは、黒が色0、白が1です。内部表現の内容を画面上の色に変換する作業は必要ありません。行をコピーするだけです。ただし、データのコピーには作業が必要です。コモドール64には、このコピーをハードウェアで実行できるダイレクトメモリアクセスコントローラーがないため、CPUはソースから各値を取得し、宛先にドロップすることで作業を行う必要があります。

初期化中にBLOCKPTRというポインタを設定し、文字データをレンダリングするために画面を下っていくときに進むようにしました。ブロックフィールドの色をレンダリングするために、このポインタをソースとして再利用し、宛先として機能する新しいCOLORPTRを設定できます。

COLORBUF = $D800 + 40 + 10
COLORPTR = $05    ; ゼロページにさらに2つの未使用バイト

render_field:
    subroutine

    ; まずポインタを設定します、srcとdest
    lda #<BLOCKBUF
    sta BLOCKPTR
    lda #>BLOCKBUF
    sta BLOCKPTR + 1

    lda #<COLORBUF
    sta COLORPTR
    lda #>COLORBUF
    sta COLORPTR + 1

    ; 20行の20ブロックをコピーします
    ; 6502では、間接インデックスモードとポインタを使用したいので、
    ; これは少し混乱します。
    ; Yインデックスでのみ提供されます
    ldx #20       ; XはY座標です
.copy_row:
    ldy #19       ; YはX座標です
.copy_blk:
    lda (BLOCKPTR), y
    sta (COLORPTR), y

    ; Yが負になるまでカウントダウンする前のトリックを使用します、
    ; 比較を節約するため
    dey
    bpl .copy_blk

    ; ブロックフィールドの次の行に進みます
    ; これは16ビット加算です
    clc
    lda BLOCKPTR
    adc #20
    sta BLOCKPTR
    lda BLOCKPTR + 1
    adc #0
    sta BLOCKPTR + 1

    ; カラーRAMも進めます。これは重要で、
    ; 画面上で40バイト下になります
    clc
    lda COLORPTR
    adc #40
    sta COLORPTR
    lda COLORPTR + 1
    adc #0
    sta COLORPTR + 1

    dex
    bne .copy_row

    rts

どう見えますか? まあ、ボールがブロックフィールドを通過しても影響を与えないので、少し奇妙ですが、それは予想通りです。まだ衝突を検出するコードを書いていないからです。以前のTODOはまだ埋められていません。

[動画:ボールが白黒のフィールド上で跳ね返っている]

図13:ボールが白黒のフィールド上で跳ね返っている

フィールドとの衝突を検出する必要があるということは、ボールが到達しようとしている位置にあるブロックが何であるかを見つける必要があるということです。したがって、黒いボールが黒いフィールド領域から跳ね返るべき場合、ボールが次に到達する位置は、現在黒である領域内にある必要があります。そのため、ブロックフィールドのボールの位置にあるものを調べる関数が必要です。

ボールの位置はピクセル座標で格納されているため、必要な場所に到達するにはいくつかのステップが必要です。

  • まず、ピクセル座標をフィールドのブロック座標に変換します。両方向で8で割ります。
  • 次に、Y * 20 + Xを計算して、ブロックフィールドストレージのエントリを取得します。

CPUにはネイティブな「乗算」命令がないため、これは複雑になります。バイナリシフトと加算を実行する必要があります。バイナリシフトの入門については、20年前に書いたビット演算子の紹介「ビット演算子の紹介」、Imran Nazar、2006年9月を参照してください。基本的に、20倍をネイティブに実行できないため、バイナリべき乗で乗算し、それらの結果を加算して結果を生成する必要があります。同様に、8で割ることをネイティブに実行できないため、シフトダウンして同じことを行います。例を挙げると:

   ```
   X = 58   |        Y = 133
   01101010 |        10000111

1 = 00110101 | >> 1 = 01000011
2 = 00011010 | >> 2 = 00100001
3 = 00001101 | >> 3 = 00010000


ブロックレベルの値(この例ではBX=13、BY=16)に座標を変換したら、乗算と加算に進むことができます。ここでの式は`BY * 16 + BY * 4 + BX`であり、バイナリシフトでは`BY << 4 + BY << 2 + BX`になります。

       ```
       X = 58   |        Y = 133
       01101010 |        10000111
>> 1 = 00110101 | >> 1 = 01000011
>> 2 = 00011010 | >> 2 = 00100001
>> 3 = 00001101 | >> 3 = 00010000

                | << 1 = 00100000
                | << 2 = 01000000
                | << 3 = 10000000  ; これを見るべきです
                | << 4 = 00000000

ここで注意すべき点が2つあります。まず、4ビット左シフト(16倍)は、値が255を超えたためキャリーフラグにビットを押し出したので、ここでは以前のワイド加算と同様に扱う必要があります。キャリーフラグを結果の高位バイトに持ち込むことに注意する必要があります。プロセッサはシフトと同様に機能するローテート命令を提供しますが、キャリーフラグを値の一方の端に取り込み、もう一方の端から新しい値をプッシュします。これを使用して、キャリーフラグを結果の値の高位バイトに持ち込むことができます。

もう1つの注意点は、右に3ビットシフトしてから左に3ビットシフトすると、元の値が残りますが、下位3ビットはゼロになります。プロセッサは一度に1ビットのシフト操作しか提供しないため、6回のシフト操作を実行するよりも、ANDでこれらのビットをゼロにすることで多くの時間を節約できます。

これにより、最終的な計算は((Y & $F8) << 1) + ((Y & $F8) >> 1) + (X >> 3)になります。これを6502に変換すると、次のようになります。

SCRATCH = $92   ; 一時保存場所

; get_blk_val: 指定された座標のブロックフィールド値を取得します
; @param X 水平座標
; @param Y 垂直座標
; @return A この座標のブロックの値
; @破壊 A
; @保持 X, Y
get_blk_val:
    subroutine

    lda #0
    sta BLOCKPTR
    sta BLOCKPTR + 1

    ; ((Y & $F8) << 1)
    tya
    and #$F8
    asl
    sta BLOCKPTR
    rol BLOCKPTR + 1

    ; + ((Y & $F8) >> 1)
    tya
    and #$F8
    lsr
    ; BLOCKPTRに既にあるものへの16ビット加算
    clc
    adc BLOCKPTR
    sta BLOCKPTR
    lda BLOCKPTR + 1
    adc #0
    sta BLOCKPTR + 1

    ; + (X >> 3)
    txa
    lsr
    lsr
    lsr
    clc
    adc BLOCKPTR
    sta BLOCKPTR
    lda BLOCKPTR + 1
    adc #0
    sta BLOCKPTR + 1

    ; これをBLOCKBUFへのインデックスとして使用する必要があります
    clc
    lda #<BLOCKBUF
    adc BLOCKPTR
    sta BLOCKPTR
    lda #>BLOCKBUF
    adc BLOCKPTR + 1
    sta BLOCKPTR + 1

    ; 最後に、そこから読み取ります
    ; Yインデックスの間接アクセスしかできないため、
    ; Yをスクラッチメモリに入れる必要があります
    sty SCRATCH
    ldy #0
    lda (BLOCKPTR), y
    ldy SCRATCH

    ; NegativeとZeroフラグを設定します
    and #$FF
    rts

指定された座標のブロックフィールドに格納されている値を確認する方法があるので、ボールが到達しようとしている位置のどの点がチェックされる必要があるかを検討する必要があります。図4によると、ボールスプライトの(0,0)座標は実際には空のスペースであり、バウンスを検出するのに良い点ではありません。必要なのは、各エッジの中央点をチェックすることです。それらは次のとおりです。

  • 左端の場合は(0,4)。
  • 右端の場合は(7,4)。
  • 上端の場合は(4,0)。
  • 下端の場合は(4,7)。

この記事の目的のために、より複雑なオプションの1つ(ボールの右端との衝突)を示します。これは両軸での加算を伴います。他の検出は読者の演習とします。黒いボールと黒いフィールドの衝突をチェックするために、collide_blackの底から拾い上げます。

.nobounce_y:
    ; もう一方のサイドとの衝突:右端
    ; まずXとYを設定します
    clc
    lda BALL0 + 2
    adc #7
    tax

    clc
    lda BALL0 + 4
    adc #4
    tay

    ; 次に、ここにあるブロックをチェックします
    ; 1(白)の場合、まだ移動中です
    ; 白/白の衝突の場合、「beq」で終了します
    jsr get_blk_val
    bne .nohit_r

    ; ここまで到達した場合、衝突しました
    ; 黒いフィールドに当たったので、左に跳ね返ります
    ; (Y軸での反射)
    jsr flipy_black
    ; TODO: 衝突したブロックの状態を変更します
    jsr flipblk

.nohit_r:
    ; その他のエッジ検出

これでほぼ必要なものが揃いました。フィールドに衝突したことを検出でき、そこから跳ね返ることができますが、衝突したブロックの色は変わりません。これはcollide_blackの最後のTODOです。幸いなことに、これはかなり簡単です。どのブロックが関与しているかはすでにわかっています(get_blk_valの処理の一部としてBLOCKPTRを計算しました)。また、色は常に反転すること(白から黒、または黒から白)もわかっているので、これは常にXOR操作です。

; flipblk: BLOCKPTRが指すブロックを反転します
; @破壊 A, Y
flipblk:
    ldy #0
    lda (BLOCKPTR), y
    eor #%00000001
    sta (BLOCKPTR), y
    rts

他のエッジ検出ケースを埋め、白いボールの処理のために一連のコードをコピーすると、スコアのレンダリングだけを考慮に残して、最終的な効果が得られます。

[動画:ボールが跳ね返り、反対側のフィールドに当たり、ブロックを反転させる(4倍速)]

図14:ボールが跳ね返り、反対側のフィールドに当たり、ブロックを反転させる(4倍速)

スコアリング

パズルの最後のピースは、各サイドのスコアを計算し、それらをプレイフィールドの下に画面に表示することです。最初の点は比較的簡単です。ブロックフィールドを内部ストレージからビデオチップのカラーRAMにコピーしてレンダリングしているため、コピー中にブロックを数える機会を利用できます。唯一の複雑さは、一方のサイドが255ブロックを超える可能性があることです。そのため、これらは16ビットカウンターであり、適切に(16ビット加算で)処理する必要があります。

render_fieldのコピー処理の最もタイトなレベルのループの途中で拾い上げます。

CNTBLK = $FB
CNTWHT = $FD

render_field:
    ...
.copy_blk:
    lda (BLOCKPTR), y

    ; Aを破壊するので、保持しておきます
    pha

    ; 1をロードした場合、これは白いフィールドです
    ; Zフラグはクリアされるので、BNEはスキップします
    bne .copy_cntwht

    ; ここに到達した場合、ブロックは0(黒)です
.copy_cntblk:
    inc CNTBLK
    lda CNTBLK + 1
    adc #0
    sta CNTBLK + 1
    jmp .copy_write

    ; ここに着地した場合、1(白)でした
.copy_cntwht:
    inc CNTWHT
    lda CNTWHT + 1
    adc #0
    sta CNTWHT + 1

.copy_write:
    ; カラーRAMへの書き込みに戻ります
    pla
    sta (COLORPTR), y

これにより、ブロックフィールドがレンダリングされるたびに、各サイドのスコアをカウントする方法が得られます。次に必要なのは、これらのカウントを画面に表示する方法です。この旅で出会った他のいくつかのことと同様に、コモドールBASICには数値を印刷できるルーチンがありますが、パフォーマンスに関する注意点があります。この低レベルで作業している間、アセンブリのルーチンを使用して数値を印刷するために何が必要かを見てみましょう。

表示したいスコアの1つが279だとしましょう。これは、メモリ内の16ビット値から画面上の3つの異なる文字("2" "7" "9")に変換する必要があります。数学的な原則は非常に単純で、小学校で誰もが学ぶものです。繰り返し除算で、数字が逆順に得られます。

279 ÷ 10 = 27 余り 9
 27 ÷ 10 =  2 余り 7
  2 ÷ 10 =  0 余り 2

ここには2つの複雑な要因があります。第一に、値2を単純に画面に送信することはできません。図3によると、コモドール64の文字ROMは数字から始まっていないため、この文字コードは文字Bを表します。除算から出てくる各数字に48を加える必要があります。画面に表示できる文字文字列を取得するためです。

2番目の複雑さは、プロセッサがネイティブで除算を提供していないこと(ネイティブ乗算も存在しないことをすでに確認しました)なので、16ビット除算を実行するためのソフトウェアルーチンが必要です。幸いなことに、除算の基本的なアルゴリズムは理解可能であり、基本的に、私たちが数学の授業で苦労した古典的な「筆算」のバイナリバージョンです。

余談その3:バイナリによる長除算

乗算が繰り返し加算であるのと同様に、除算は繰り返し減算と考えることができます。最初の除算を、学校で除算を習う方法で詳しく見てみましょう。

279 ÷ 10:
  2 は 10 に入りますか? いいえ
 27 は 10 に入りますか? はい、2回

27 - (2 x 10) = 7

残りの数値を付け加え、次のように続けます:79

  7 は 10 に入りますか? いいえ [しかし、それは残ったものだとわかっています]
 79 は 10 に入りますか? はい、7回

79 - (7 x 10) = 9

残りの数値を付け加え、次のように続けます: 9

  9 は 10 に入りますか? いいえ [しかし、それは残ったものだとわかっています]
 これ以上数字はありません、終了します。

これにより、最終的に意図した結果が得られます。個々の「入りますか?」という質問を組み合わせると27になり、9が残ります。コンピューターでこれを行う場合、これらの操作をバイナリに分解する必要があります。そのため、各数字を引き込む方法は少し異なります。しかし、バイナリで作業しているという事実は、私たちの「入りますか?」という質問は「いいえ」または「はい、1回」の2つの結果しか得られないことを意味します。そのため、私たちの質問は「以上」になります。

100010111 ÷ 1010:
    1 ≥ 1010? いいえ
   10 ≥ 1010? いいえ
  100 ≥ 1010? いいえ
 1000 ≥ 1010? いいえ
10001 ≥ 1010? はい

10001 - (1 x 1010) = 111

残りの数値を付け加え、次のように続けます:1110111

  111 ≥ 1010? いいえ [わかっています、入りません]
 1110 ≥ 1010? はい

 1110 - (1 x 1010) = 100

残りの数値を付け加え、次のように続けます:100111

  100 ≥ 1010? いいえ [わかっています、入りません]
 1001 ≥ 1010? いいえ
10011 ≥ 1010? はい

10011 - (1 x 1010) = 1001

残りの数値を付け加え、次のように続けます:10011

 1001 ≥ 1010? いいえ [わかっています、入りません]
これ以上数字はありません、終了します。

これはより長い操作のように見えますが、それは低い基数で行われているためです。つまり、各ステップは10ではなく2ずつ進みます。もし「いいえ」と「はい」の答えを数え上げ、前のステップから残った答えである「いいえ」を無視すると、結果は次のようになります:000011011 余り 1001。10進数に戻すと、27 余り 9になります。

これをコモドール64で実装する前に、2つのことを解決する必要があります。まず、「以上」のチェックを段階的に実行するために、各数字をどのように「シフト」するのでしょうか? それを行うための命令があります。「算術左シフト」(asl)は、最上位ビットをキャリーフラグにプッシュします。ただし、最上位ビットをキャリーフラグに到達させたくありません。それをアキュムレータに入れて値を処理できるようにしたいのです。そのため、aslと「左ローテート」(rol)を組み合わせることができます。これはキャリーフラグを値の下部に引き込み、対応するビットをもう一方の端からプッシュします。したがって、16ビット値を処理するには、24ビット左シフトを実行して、値が両方のバイトとアキュムレータを通過するようにします。

DIVIDEND = $1B
DIVISOR  = $19

; 16ビット値を8ビット除数で割ります
; @破壊 A, X
div16_8:
    subroutine
    ldx #16
    lda #0
.loop:
    asl DIVIDEND
    rol DIVIDEND + 1
    rol a

    ; ...ここで何をすべきか?

    dex
    bne .loop
    rts

もう1つの問題は、私たちの≥チェックです。プロセッサのドキュメント「比較命令」、「6502ソフトウェアデザイン」より、Leo Scanlon著、2022年12月更新によると、cmp(「比較」、減算を実行して結果を破棄する)とbcs(「キャリーセットなら分岐」)を使用することで達成できます。この場合、必要ない場合は減算をスキップしたいので、代わりにbccを使用します。
```assembly
cmp DIVISOR
bcc .no_sub
sbc DIVISOR
; ...そして「はい」の結果をどこに置くか?


除算対象をシフトしていくと、ゼロが残ります。このループが終了すると、`DIVIDEND`は完全にゼロになります。逆に、結果をどこかに格納し、除算対象の進行に合わせてそのビットを段階的にシフトする必要があります。これらの2つのステップを組み合わせ、結果を dividend の下部に格納できます。同時に、上部がシフトされます。

これを行うには、dividend の最下位ビットを設定するかしないかのどちらかを行うだけです。

    ```assembly
    cmp DIVISOR
    bcc .no_sub
    sbc DIVISOR
    inc DIVIDEND
.no_sub:
    ; ...そしてループの周回

これには、 dividend の下位ビットを設定またはクリアするだけでよいという追加の微妙な利点があります。これは、 dividend がメモリ内の同じ場所に結果が格納されるため、どこかからコピーする必要なく、別の除算にすぐに使用できるという追加の微妙な利点があります。これはまさに私たちが探していたものであり、スコア表示用の数字を計算するために繰り返し除算を実行したいからです。これらすべてをまとめると、最終的な除算サブルーチンは次のようになります[C]この実装については、私は一切のクレジットを受けません。上記の解剖学のみです。これは、2005年1月、「tepples」によるNESDevフォーラムの投稿から来ています。:

DIVIDEND = $1B
DIVISOR  = $19

; 16ビット値を8ビット除数で割ります
; @param メモリ (DIVIDEND, DIVISOR)
; @return メモリ (DIVIDEND): 結果
; @return A 余り
; @破壊 A, X
div16_8:
    subroutine
    ldx #16
    lda #0
.loop:
    asl DIVIDEND
    rol DIVIDEND + 1
    rol a
    cmp DIVISOR
    bcc .no_sub
    sbc DIVISOR
    inc DIVIDEND
.no_sub:
    dex
    bne .loop
    rts

スコアのレンダリング

これで除算ルーチンができたので、繰り返し10で割ることで、画面に表示するスコア文字列を作成できます。事前に言及したように、各数字に48を加えることで文字列を作成する小さなヘルパーサブルーチンが必要になります。これらが16ビットの数値であり、10進数で65535を超えることはないことを知っているので、結果の文字列を保持するためにメモリに5バイトのブロックを割り当てる必要があります。

もちろん、これにはさらに疑問が生じます。生成された文字列の長さはどうやってわかるのでしょうか?そして、一方のスコアが例えば100から99に減少した場合、どうなるのでしょうか? 99だけを印刷すると、前のスコアの1文字が画面に残ってしまい、(サイドに応じて)990または199という表示スコアになってしまいます。

最初の問題は、文字列に常に5バイトの固定長を使用し、文字列をスペースで事前に埋めることで解決できます。これにより、印刷するときに「空白」文字がディスプレイに影響を与えなくなります。同様に、2番目の問題は、スコアを表示する前に、画面上のスコア領域を常にスペースでクリアすることで解決できます。これにより、ディスプレイは常に新鮮になります。

したがって、最初に必要なのは、スコアを繰り返し除算によって文字列に変換するサブルーチンです。

STROUT = $22

; int2str: 16ビット整数を文字列に変換します
; @param A 数値のゼロページ位置
; @破壊 A, X, Y
int2str:
    subroutine

    ; まず、除算ルーチンを設定します
    tax
    lda 0, x
    sta DIVIDEND
    lda 1, x
    sta DIVIDEND + 1

    lda #10
    sta DIVISOR

    ; 次に文字列ストレージをクリアします
    ; 5バイト、STROUT + 4からSTROUT + 0まで
    ldx #4
    lda #32   ; スペース
.buflp:
    sta STROUT, x
    dex
    bpl .buflp

    ; そして除算を開始します
    ; divがXを破壊するので、ここではYインデックスを使用します
    ldy #4
.divlp:
    jsr div16_8

    ; 余りは印刷する数字です。PETSCII数字にオフセットする必要があります
    clc
    adc #48
    sta STROUT, y
    dey

    ; 5文字すべてを処理したくありません
    ; dividendがゼロなら中止します
    lda DIVIDEND
    ora DIVIDEND + 1
    bne .divlp

    rts

そして、これらの文字列を画面に表示するだけです。前述のブランキング操作を実行して、前のスコアをスペースで上書きします。そして、考慮すべき最後のひねりが1つあります。これらの文字列は左側にスペースでパディングされています(つまり、例えば274というスコアはメモリに   274として保持されます)。しかし、ブロックフィールドの端に揃えてスコアを印刷したい場合、左側は左端からインデントされます。

この場合、スペースを無視して、スペース以外の値のみを印刷する必要があります。右側では、スペースを印刷したいので(そうでなければ反対の問題、右側のインデントが発生します)、render_scoreには関連するが異なる2つのコードセクションがあります。

render_score:
    ; まず、スコアをクリアします
    ; 画面行22、位置10-14および25-29
    ldx #4
    lda #32
.blank:
    sta SCRRAM + 22 * 40 + 14, x
    sta SCRRAM + 22 * 40 + 25, x
    dex
    bpl .blank

    ; 次に黒いスコアを印刷します、スペースは無視します
    ; 注意:Aにはスコアの値ではなく、
    ; スコアのアドレスが必要です
    lda #CNTBLK
    jsr int2str

    ; 後ろ向きにループするトリックは使えません
    ; スコアが逆順に印刷されてしまうためです
    ; なのでXは0から4まで実行し、5で中止します
    ldx #0
    ldy #0

.black_print:
    lda STROUT, x
    cmp #32
    beq .black_skip
    sta SCRRAM + 22 * 40 + 10, y
    iny
.black_skip:
    inx
    cpx #5
    bne .black_print

    ; 白についても同様です
    ; 今回は簡単です、スペースを印刷できます
    lda #CNTWHT
    jsr int2str
    ldy #0
.white_print:
    lda STROUT, y
    sta SCRRAM + 22 * 40 + 25, y
    iny
    cpy #5
    bne .white_print

    rts

レンダリングルーチンの最後の部分が配置されたので、コモドール64のネイティブ60フレーム/秒ではなく、30フレーム/秒で実行されることになります。このスローダウンに加えて、ボールは1周あたり1ピクセル移動し、ブロックフィールドの距離を移動するにはそれ自体が遅い速度です。ボールの初期方向は、最初のブロックに衝突してポンウォーズが始まるまで少なくとも5秒かかるようになっています。

効果を改善できる多くの改善点がありますが、ここでは実行されず、簡単に議論できます。

  • 直接レンダリング:レンダリング時にブロックフィールドをカラーRAMにコピーするのではなく、カラーRAM自体をブロックフィールドストレージとして使用できます。これにより、CPUがパフォーマンスペナルティなしで読み書きできます。唯一の注意点は、get_blk_val(指定された座標の色を取得するルーチン)が、メモリ内の行が連続していないことを考慮して、20ではなく40を掛ける必要があることです。
  • 衝突時のスコアリング:この実装では、カラーRAMにコピーされているブロックの黒と白の数を数えるという単純な方法を使用しています。代わりに、各サイドのスコアは200から始まり、ブロックがフリップされたときにのみ変更されることを知っているので、スコアを追跡できます。これは、ブロックがフリップされたときに一方のサイドに1を加算し、もう一方のサイドから1を減算する16ビット加算を実行するようにflipblkを変更することになります。
  • 衝突時のスコアレンダリング:カウントされたスコアを取得して数字ごとに印刷するために必要な除算もCPU時間に関して重要であり、毎フレーム実行する必要はありません。画面のその領域は衝突が発生したときにのみ変更されるため、スコアキーピングの変更と同時にその作業を実行することが可能です。これにより、レンダリングルーチンを分割し、一部が毎フレーム実行されないようにします。
  • より長いボールベクトル:これらのスピードアップが完了すると、効果はおそらくネイティブの60fpsで実行され、ボールは各フレームでより遠くまで移動できるようになります。長さ2のベクトルでは、レンダリングする前にadvance_blackとcollide_black(およびそれに対応する白い関数)を2回実行するだけで済みます。

しかし、私の最初の本物のコモドール64プログラムとしては、うまくいったと思います。

脚注と引用

以下の注記は、本文中にもインラインで表示されますが、引用を末尾注として好む人のためにここに複製します。