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:
1 parent
8a4b44bc73
commit
d412e35c4e
79 files changed
+4187
-16
No files matched your search
@@ -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
|
||||
@@ -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;}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;}
|
||||
@@ -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;
|
||||
}
|
||||
Reference in new issue
Block a user