Implement CoCo 3 Quadrapassel and deliver build 01

Add gameplay, keyboard/joystick controls, disk-backed high scores and settings,
standard CMOC effects, and the approved C graphics renderer. Include the clearer
attributed font, title/credits updates, source-verified Modern and Classic (40.2)
scoring, meaningful regression fixtures, and recorded guest validation.

Deliver QUADPSL01.DSK with fresh high scores. Retain source, licenses and selected
guest evidence; exclude personal disks, private connections and build scratch.

Host rules/input/persistence/video checks and memory guards pass. Official
512 KB playtests pass the recorded checks; actual 128 KB/physical joystick
qualification and the normal-window buzzing retest remain pending.
This commit is contained in:
Brian Holman committed 2026-11-11 03:14:14 -07:00
1 parent 8a4b44bc73
commit d412e35c4e
79 files changed
+4187 -16

No files matched your search

+19
View File
@@ -0,0 +1,19 @@
/* SPDX-License-Identifier: GPL-3.0-or-later */
#ifndef QUAD_TEST_COCO_H
#define QUAD_TEST_COCO_H
#include <string.h>
typedef unsigned char byte;
typedef unsigned short word;
#define TRUE 1
#define FALSE 0
extern byte isCoCo3;
void rgb(void);
void paletteRGB(byte slot,byte r,byte g,byte b);
byte hscreen(byte mode);
void enableInterrupts(void);
void resetPalette(byte reset);
void width(byte columns);
void setHighSpeed(byte speed);
word getTimer(void);
byte hset(word x,word y,byte color);
#endif
+29
View File
@@ -0,0 +1,29 @@
/* SPDX-License-Identifier: GPL-3.0-or-later */
#include <assert.h>
#include <stdio.h>
#include "input.h"
static QInput s;
static QActions step(Q16 keys,Q8 button,Q8 x,Q8 y,Q16 ms,Q8 playing){return q_input_step(&s,keys,button,x,y,31,31,1,ms,playing,0);}
static void reset(void){q_input_reset(&s);step(0,0,31,31,0,1);}
int main(void){QActions a;
reset();a=step(Q_LEFT,0,31,31,0,1);assert(a.move==-1&&a.repeats==1);
a=step(Q_LEFT,0,31,31,199,1);assert(!a.repeats);
a=step(Q_LEFT,0,31,31,1,1);assert(a.move==-1&&a.repeats==1);
a=step(Q_LEFT,0,31,31,39,1);assert(!a.repeats);
a=step(Q_LEFT|Q_RIGHT,0,31,31,1,1);assert(a.move==-1&&a.repeats==1);
a=step(Q_RIGHT,0,31,31,1,1);assert(a.move==1&&a.repeats==1);
reset();a=step(Q_CCW,0,31,31,1,1);assert(a.pressed&Q_CCW);
a=step(Q_CCW,0,31,31,500,1);assert(!(a.pressed&Q_CCW));
reset();step(0,1,31,31,100,1);a=step(0,0,31,31,1,1);assert(a.pressed&Q_CCW);
reset();step(0,1,31,31,399,1);a=step(0,1,31,31,1,1);assert(a.pressed&Q_PAUSE);
a=step(0,0,31,31,1,1);assert(!(a.pressed&Q_CCW));
reset();a=step(0,0,31,10,1,1);assert(a.pressed&Q_HARD);
a=step(0,0,31,10,500,1);assert(!(a.pressed&Q_HARD));
step(0,0,31,31,1,1);a=step(0,0,31,10,1,1);assert(a.pressed&Q_HARD);
reset();a=step(0,0,0,10,1,1);assert(!(a.pressed&Q_HARD));
q_input_reset(&s);step(0,0,0,0,1,1);a=step(Q_LEFT,0,0,0,1,1);assert(a.move==-1);
reset();a=step(0,0,20,31,1,1);assert(a.move==-1);
a=step(0,0,24,31,1,1);assert(a.held&Q_LEFT);
a=step(0,0,25,31,1,1);assert(!(a.held&Q_LEFT));
reset();step(0,1,31,31,100,0);a=step(0,0,31,31,1,0);assert(a.pressed&Q_CONFIRM);
puts("PASS: input repeat, conflicting directions, edges, one-button timing, hysteresis, diagonal guard, disconnected-stick keyboard");return 0;}
+245
View File
@@ -0,0 +1,245 @@
/* SPDX-License-Identifier: GPL-3.0-or-later */
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include "rules.h"
#include "reference_cases.h"
static QOptions defaults = {0,Q_MODERN,0,1};
static QGame game;
static void pieces(void)
{
unsigned t,r,x,y,n;
int minx,maxx,miny;
QPiece p;
QBoard empty = {{{0}}};
for (t=0;t<7;++t) for (r=0;r<4;++r) {
assert(q_masks[t][r]==reference_masks[t][r]);
n=0;minx=miny=4;maxx=-1;
for (y=0;y<4;++y) for (x=0;x<4;++x) if (q_occupied(t,r,x,y)) {
++n;
if ((int)x<minx) minx=x;
if ((int)x>maxx) maxx=x;
if ((int)y<miny) miny=y;
}
assert(n==4);
p=q_spawn(t,r);
assert(p.x+minx==(10-(maxx-minx+1))/2);
assert(p.y+miny==0);
assert(q_fits(&empty,&p));
}
assert(!q_occupied(7,0,0,0));
assert(!q_occupied(0,4,0,0));
assert(!q_occupied(0,0,4,0));
}
static void rotation_kicks(void)
{
static const int expected[5]={0,1,-1,2,-2};
static const unsigned blockers[6][5]={
{99,99,99,99,99},{4,99,99,99,99},{4,5,99,99,99},
{4,5,3,99,99},{4,5,3,6,99},{4,5,3,6,2}
};
unsigned k,i;
QPiece previous;
for (k=0;k<6;++k) {
q_start(&game,&defaults);
memset(&game.board,0,sizeof(game.board));
game.active=q_spawn(5,0);game.active.x=3;game.active.y=5;
for (i=0;i<5;++i) if (blockers[k][i]<10) game.board.cells[5][blockers[k][i]]=1;
previous=game.active;
assert(q_fits(&game.board,&previous));
if (k<5) {
assert(q_rotate(&game,0));
assert(game.active.x==3+expected[k]);
assert(game.active.rotation==1 && game.active.y==5);
} else {
assert(!q_rotate(&game,0));
assert(memcmp(&previous,&game.active,sizeof(previous))==0);
}
}
memset(&game.board,0,sizeof(game.board));
game.active=q_spawn(5,0);assert(game.active.y==-1);
assert(q_rotate(&game,0));assert(game.active.y==0);
game.active=q_spawn(0,0);game.active.y=5;
assert(q_rotate(&game,1));assert(game.active.rotation==3);
}
static void movement_and_lock(void)
{
QPiece p,landed;
QBoard before;
unsigned x,y;
q_start(&game,&defaults);
game.active=q_spawn(5,0);
while(q_move(&game,-1,0)) {}
assert(game.active.x==0);
while(q_move(&game,1,0)) {}
assert(game.active.x==6);
p=game.active;
assert(!q_move(&game,1,0));assert(memcmp(&p,&game.active,sizeof(p))==0);
landed=q_shadow(&game);assert(landed.y==18);
assert(memcmp(&p,&game.active,sizeof(p))==0);
assert(q_drop(&game));assert(game.score==0 && game.lines==0);
for(x=6;x<10;++x) assert(game.board.cells[19][x]==6);
q_start(&game,&defaults);
before=game.board;
game.active=q_spawn(5,1);game.active.y=-2;
assert(q_fits(&game.board,&game.active));
assert(!q_lock(&game) && game.over);
assert(memcmp(&before,&game.board,sizeof(before))==0);
q_start(&game,&defaults);
game.active=q_spawn(6,0);
while(q_move(&game,0,1)) {}
p=game.active;assert(!q_move(&game,0,1));
assert(memcmp(&p,&game.active,sizeof(p))==0);
assert(q_lock(&game));assert(!game.hold_used);
/* A pending preview whose spawn is occupied must block out. */
q_start(&game,&defaults);
game.next.type=5;game.next.rotation=0;
for(x=3;x<=6;++x) game.board.cells[0][x]=2;
game.active=q_spawn(6,0);game.active.x=0;game.active.y=17;
assert(q_lock(&game));assert(game.over);
for(y=0;y<20;++y) for(x=0;x<10;++x) assert(game.board.cells[y][x]<=7);
}
static void simultaneous_rows(void)
{
QBoard b={{{0}}};
unsigned x;Q8 bottom;
for(x=0;x<10;++x) b.cells[19][x]=b.cells[17][x]=1;
b.cells[18][2]=5;b.cells[16][1]=7;b.cells[0][0]=2;
assert(q_compact(&b,&bottom)==2 && bottom);
assert(b.cells[19][2]==5 && b.cells[19][1]==0);
assert(b.cells[18][1]==7 && b.cells[18][2]==0);
assert(b.cells[2][0]==2 && b.cells[0][0]==0 && b.cells[1][0]==0);
memset(&b,0,sizeof(b));
for(x=0;x<10;++x)b.cells[18][x]=1;
b.cells[19][0]=4;
assert(q_compact(&b,&bottom)==1 && !bottom && b.cells[19][0]==4);
}
static void scoring(void)
{
unsigned i;
for(i=0;i<sizeof(score_cases)/sizeof(score_cases[0]);++i) {
const ScoreCase *c=&score_cases[i];
q_start(&game,&defaults);
game.options.difficulty=c->difficulty;game.options.scoring=c->rule;
game.lines=c->prior;game.score=0;
q_score_clear(&game,c->rows,c->bottom);
assert(game.level==c->level && game.score==c->points);
}
game.options.difficulty=0;
game.score=Q_SCORE_MAX-5;game.lines=Q_SCORE_MAX-1;
q_score_clear(&game,4,1);
assert(game.lines==Q_SCORE_MAX && game.score==Q_SCORE_MAX && game.level==65535);
for(i=1;i<=100;++i) assert(q_gravity_ms(i)==reference_gravity[i-1]);
}
/* Adapted from Brian Holman's GPL-3.0-or-later Mac test-scoring.vala:
* drop an actual vertical I piece through one-cell gaps in nearly full rows.
* This also checks bottom-row detection and level changes, not just arithmetic.
*/
static void scoring_through_drop(void)
{
unsigned i,x;int y,bottom;
for(i=0;i<sizeof(score_cases)/sizeof(score_cases[0]);++i){
const ScoreCase *c=&score_cases[i];
q_start(&game,&defaults);
game.options.difficulty=c->difficulty;game.options.scoring=c->rule;
game.lines=c->prior;game.level=q_level(c->difficulty,c->prior);
bottom=c->bottom?19:18;
for(y=bottom-(int)c->rows+1;y<=bottom;++y)
for(x=0;x<10;++x)if(x!=4)game.board.cells[y][x]=1;
if(!c->bottom)game.board.cells[19][4]=1;
game.active=q_spawn(5,1);game.active.x=3;game.active.y=0;
assert(q_drop(&game));
assert(game.last_clear==c->rows);
if(c->rows)assert(game.last_bottom==c->bottom);
assert(game.lines==c->prior+c->rows);
assert(game.level==c->level&&game.score==c->points);
}
}
static void hold(void)
{
QChoice preview;
Q8 original,held;
QRandom random;
q_start(&game,&defaults);
original=game.active.type;preview=game.next;
assert(q_hold(&game));
assert(game.held==original && game.active.type==preview.type && game.active.rotation==0);
random=game.random;preview=game.next;
assert(!q_hold(&game));assert(memcmp(&random,&game.random,sizeof(random))==0);
assert(q_drop(&game));assert(!game.hold_used);
held=game.held;original=game.active.type;preview=game.next;random=game.random;
assert(q_hold(&game));
assert(game.active.type==held && game.active.rotation==0 && game.held==original);
assert(memcmp(&preview,&game.next,sizeof(preview))==0);
assert(memcmp(&random,&game.random,sizeof(random))==0);
assert(!q_hold(&game));
}
static void randomness(void)
{
QRandom a,b;
QOptions options=defaults;
QGame other;
unsigned i,j,x,y;unsigned selected[7]={0};Q16 lo,hi;
q_random_init(&a,1);
assert(q_random_next(&a)==270369UL);
assert(q_random_next(&a)==67634689UL);
assert(q_random_next(&a)==2647435461UL);
q_random_init(&a,0);q_random_init(&b,0);
for(i=0;i<100;++i)assert(q_weighted(&a)==q_weighted(&b));
q_random_init(&a,1234567);
for(i=0;i<20000;++i)++selected[q_weighted(&a)];
lo=hi=selected[0];
for(i=0;i<7;++i){if(selected[i]<lo)lo=selected[i];if(selected[i]>hi)hi=selected[i];}
assert(hi-lo<20);
/* Fixed count vector: underrepresented types must be much likelier. */
memset(selected,0,sizeof(selected));q_random_init(&a,0x12345678UL);
for(i=0;i<20000;++i){for(j=0;j<7;++j)a.counts[j]=0;a.counts[0]=10;++selected[q_weighted(&a)];}
assert(selected[0]>0 && selected[0]<100);
for(i=1;i<7;++i)assert(selected[i]>2500);
for(i=0;i<32;++i) for(j=0;j<=16;++j) {
options.seed=i;options.difficulty=(int)j-1;
q_start(&game,&options);q_start(&other,&options);
assert(memcmp(&game.board,&other.board,sizeof(game.board))==0);
assert(game.active.type==other.active.type && game.next.type==other.next.type);
for(y=0;y<20;++y){unsigned count=0;for(x=0;x<10;++x){assert(game.board.cells[y][x]<=7);count+=game.board.cells[y][x]!=0;}assert(count<10);}
}
}
static void difficult(void)
{
static const int empty_metric[7]={-20,-20,-20,-25,-25,-20,-20};
QBoard b={{{0}}},before;
QRandom a,c;
QChoice choice,other;
unsigned i;
before=b;
for(i=0;i<7;++i)assert(q_best_metric(&b,i)==empty_metric[i]);
assert(memcmp(&b,&before,sizeof(b))==0);
for(i=0;i<10;++i)if(i<3||i>6)b.cells[19][i]=1;
before=b;
assert(q_best_metric(&b,5)==5000);
assert(memcmp(&b,&before,sizeof(b))==0);
q_random_init(&a,47);q_random_init(&c,47);
choice=q_difficult(&b,&a);other=q_difficult(&b,&c);
assert(choice.type<7 && choice.rotation<4);
assert(choice.type==other.type && choice.rotation==other.rotation);
assert(memcmp(&b,&before,sizeof(b))==0);
memset(&b,1,sizeof(b));
for(i=0;i<7;++i)assert(q_best_metric(&b,i)==-30000L);
}
int main(void)
{
pieces();rotation_kicks();movement_and_lock();simultaneous_rows();
scoring();scoring_through_drop();hold();randomness();difficult();
printf("PASS: 28 states, all kicks, bounds/top-out, compaction, %u score fixtures plus actual-drop scoring, gravity, hold, RNG/prefill, difficult metrics\n",(unsigned)(sizeof(score_cases)/sizeof(score_cases[0])));
return 0;
}
+46
View File
@@ -0,0 +1,46 @@
/* SPDX-License-Identifier: GPL-3.0-or-later */
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include "store.h"
static unsigned char disks[2][35][256],backup[2][35][256],present[2],saved_present[2];
static int write_count,fail_after=-1,read_only;
static Q8 open_file(Q8 s,Q8 write){assert(s<2);if(!present[s]){if(!write)return Q_STORE_MISSING;if(read_only)return Q_STORE_IO;present[s]=1;}return 0;}
static Q8 read_file(Q8 s,Q8 n,Q8 *p){assert(s<2&&n<35);memcpy(p,disks[s][n],256);return 0;}
static Q8 write_file(Q8 s,Q8 n,const Q8 *p){assert(s<2&&n<35);if(read_only)return Q_STORE_IO;if(write_count++==fail_after){memcpy(disks[s][n],p,127);return Q_STORE_IO;}memcpy(disks[s][n],p,256);return 0;}
static Q8 close_file(Q8 s){assert(s<2);return 0;}
static const QStoreIO ops={open_file,read_file,write_file,close_file};
static QPreferences prefs,loaded;
static QScore table[10],restored[10];
static void reload(void){q_preferences_default(&loaded);assert(q_store_load(&ops,&loaded)==0);}
static void recoverable_writes(void){int n;Q8 status;
memset(disks,0,sizeof(disks));memset(present,0,sizeof(present));q_preferences_default(&prefs);reload();
memset(table,0,sizeof(table));assert(q_score_insert(table,100,"AAA",Q_MODERN));assert(!q_store_save(&prefs,0,table,0));
memcpy(backup,disks,sizeof(disks));memcpy(saved_present,present,sizeof(present));
for(n=0;n<=36;++n){
memcpy(disks,backup,sizeof(disks));memcpy(present,saved_present,sizeof(present));fail_after=-1;reload();
assert(!q_store_scores(0,table));assert(q_score_insert(table,200,"BBB",Q_CLASSIC));prefs.sound=0;write_count=0;fail_after=n;
status=q_store_save(&prefs,0,table,0);fail_after=-1;
q_preferences_default(&loaded);q_store_load(&ops,&loaded);assert(!q_store_scores(0,restored));
if(n<36){assert(status);assert(loaded.sound==1&&restored[0].score==100);}else{assert(!status);assert(!loaded.sound&&restored[0].score==200);}
}
read_only=1;memcpy(backup,disks,sizeof(disks));prefs.sound=1;assert(q_store_save(&prefs,-1,0,1));assert(!memcmp(backup,disks,sizeof(disks)));read_only=0;
}
static void categories_and_ties(void){unsigned cat,i;Q8 result;
memset(disks,0,sizeof(disks));memset(present,0,sizeof(present));q_preferences_default(&prefs);reload();prefs.game.seed=0xDEADBEEFUL;prefs.custom_seed=1;prefs.game.difficulty=15;
for(cat=0;cat<34;++cat){
memset(table,0,sizeof(table));assert(q_score_insert(table,40000+cat,"AAA",Q_MODERN));assert(q_score_insert(table,40000+cat,"BBB",Q_CLASSIC));
for(i=0;i<9;++i)q_score_insert(table,10000-i,"CCC",Q_MODERN);
assert(!q_store_save(&prefs,(signed char)cat,table,0));
}
reload();assert(loaded.game.seed==0xDEADBEEFUL&&loaded.custom_seed&&loaded.game.difficulty==15);
for(cat=0;cat<34;++cat){assert(!q_store_scores(cat,restored));assert(restored[0].score==40000+cat&&restored[0].initials[0]=='A'&&restored[1].initials[0]=='B');assert(restored[1].rule==Q_CLASSIC);for(i=1;i<10;++i)assert(restored[i-1].score>=restored[i].score);}
/* The most recent slot is 1 after 34 commits. Corrupt it, recover slot 0. */
disks[1][0][12]^=1;q_preferences_default(&loaded);result=q_store_load(&ops,&loaded);assert(result==Q_STORE_RECOVERED);
assert(!q_store_scores(0,restored)&&restored[0].score==40000);
prefs.game.scoring=Q_CLASSIC;assert(!q_store_save(&prefs,-1,0,1));reload();
for(cat=0;cat<34;++cat){assert(!q_store_scores(cat,restored));for(i=0;i<10;++i)assert(!restored[i].score);}
assert(q_score_category(-1,0)==0&&q_score_category(15,1)==33);
assert(q_store_crc((const Q8 *)"123456789",9)==0x29B1);
}
int main(void){recoverable_writes();categories_and_ties();puts("PASS: disk codec, all 34 score categories, stable ties/rule markers, 32-bit values, CRC, read-only reset, every torn-write boundary and recovery");return 0;}
+68
View File
@@ -0,0 +1,68 @@
/* SPDX-License-Identifier: GPL-3.0-or-later */
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include "video.h"
#include "coco3_video.h"
#include "8-bit-wide-font.h"
static Q8 screen[192][320],colors[16][3];
byte isCoCo3=1;
void rgb(void){}
void paletteRGB(byte i,byte r,byte g,byte b){assert(i<16);colors[i][0]=r;colors[i][1]=g;colors[i][2]=b;}
byte hscreen(byte mode){assert(mode<=2);memset(screen,0,sizeof(screen));return 1;}
void enableInterrupts(void){}
void resetPalette(byte reset){(void)reset;}
void width(byte cols){(void)cols;}
void setHighSpeed(byte speed){(void)speed;}
word getTimer(void){return 0;}
byte hset(word x,word y,byte color){assert(x<320&&y<192);screen[y][x]=color;return 1;}
byte c3_fill(word x,byte y,word w,byte h,byte color){word col;byte row;assert(x+w<=320&&y+h<=192);for(row=0;row<h;++row)for(col=0;col<w;++col)screen[y+row][x+col]=color;return 1;}
byte c3_blit(word x,byte y,word w,byte h,const byte *packed){word col;byte row;assert(!(w&1)&&x+w<=320&&y+h<=192);for(row=0;row<h;++row)for(col=0;col<w;++col)screen[y+row][x+col]=(packed[row*(w/2)+col/2]>>((col&1)?0:4))&15;return 1;}
static void check_letter(char c)
{
char s[2];Q8 row,col,expected;int code=c;
s[0]=c;s[1]=0;
/* Render at the last legal cell to cover both screen boundaries. */
memset(screen,11,sizeof(screen));video_text(31,23,s);
if(code>='a'&&code<='z')code-=32;
for(row=0;row<8;++row)for(col=0;col<8;++col){
expected=0;
if(code!=32&&row<7&&(eightBitWideFont[code-32][row]&(0x80>>col)))expected=8;
assert(screen[184+row][280+col]==expected);
}
assert(screen[183][280]==11&&screen[191][288]==11);
}
static void write_ppm(const char *path)
{
FILE *f=fopen(path,"wb");Q16 x,y;Q8 c,channel;
assert(f);fprintf(f,"P6\n320 192\n255\n");
for(y=0;y<192;++y)for(x=0;x<320;++x){c=screen[y][x];for(channel=0;channel<3;++channel)fputc(colors[c][channel]*85,f);}
assert(!fclose(f));
}
int main(int argc,char **argv)
{
const char *p;Q8 x,y,expected,c;
static const Q8 expected_palette[11][3]={
{0,0,0},{3,0,0},{0,3,0},{0,1,3},{2,2,2},{3,3,0},
{2,0,3},{3,1,0},{3,3,3},{0,0,1},{1,1,1}
};
assert(video_open(1));
assert(!memcmp(colors,expected_palette,sizeof(expected_palette)));
for(p="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+.:/>< ?^()&";*p;++p)check_letter(*p);
video_style(1,0);memset(screen,0,sizeof(screen));
for(c=1;c<=7;++c){
video_cell(0,0,c);
for(y=0;y<8;++y)for(x=0;x<8;++x){expected=(x==0||x==7||y==0||y==7)?10:c;assert(screen[y][32+x]==expected);}
}
assert(colors[10][0]==1&&colors[10][1]==1&&colors[10][2]==1);
assert(colors[0][0]==0&&colors[0][1]==0&&colors[0][2]==0);
video_style(0,0);video_cell(0,0,1);assert(screen[0][32]==1);
video_style(2,0);video_cell(0,0,1);assert(screen[0][32]==8&&screen[7][39]==1);
video_style(1,0);video_clear();
video_text(1,1,"QUADRAPASSEL FOR COCO");video_text(1,4,"SCORE 0123456789");
video_text(1,7,"LEVEL 1 LINES 0");video_text(1,10,"HOLD NEXT SETTINGS");
video_text(1,13,"MW O0 I1 BRH CCW");video_text(5,21,"(c) 2026 Brian Holman");
for(x=0;x<7;++x)video_cell(x*32,136,x+1);
if(argc>1)write_ppm(argv[1]);
puts("PASS: font matches Pierre's original row bytes, lowercase mapping, cell boundaries, dark-gray Modern borders, Plain/Clean styles and black background");return 0;
}