Skip to content

UNO v1.0.7 — MEGA65 native mode, 80 columns

Latest
Latest

Choose a tag to compare

View all tags
@jhonnaker1 jhonnaker1 released this 23 Aug 18:31
· 1 commit to main since this release
v1.0.7
7334f3c

Changes since v1.0.6

  • A native-mode 80-column MEGA65 build, alongside the existing one. The MEGA65 is now the only machine here built twice, because one binary cannot reach all of it. uno-mega65.prg is unchanged: a cc65 c64-target program loading at $0801, which puts the machine in C64 mode. uno-mega65-native-80col.prg loads at $2001 with a BASIC 65 header, which is what actually selects C65/MEGA65 native mode.

    That distinction is the whole point. 80 columns were never blocked by the video chip -- VIC-IV is perfectly capable -- but by the mode: the C64 never had 80 columns, so setting VIC-IV's H640 bit from inside C64 mode changes nothing. Colour RAM makes it concrete. An 80x25 screen is 2000 cells each wanting its own colour byte, and a C64-mode program can only reach the 1K window at $D800; there is nowhere to put the other 976. In native mode, mega65-libc reaches the real colour RAM at $FF80000 through the 45GS02's 32-bit addressing, and every cell gets its colour.

    Since cc65 has no MEGA65 target at all, the native build uses llvm-mos. Unlike the TMS9900, vbcc and Open Watcom toolchains this repo needed, it ships prebuilt -- and it generates markedly tighter code: 11,316 bytes against cc65's 26,042 for the same game on the same machine.

  • What the extra width buys. Cards are 5x4 instead of 3x4, which is enough to draw each one as a solid block of the suit colour with the value knocked out of it by the VIC-IV's reverse attribute -- the look the X16, VBXE, F256 and DOS ports build from per-cell foreground+background, done here with a single attribute bit. A full 20-card hand splits 11/9 across the width rather than 10/10, and the opponents row has room to spell out CPU1 CARDS: 7 instead of abbreviating.

  • Native mode simplifies as much as it unlocks. Keyboard input comes from $D610, the MEGA65's ASCII key register: read it for the key waiting, write to pop it. So the native input layer is direct hardware access with no PETSCII translation anywhere -- and no <ascii_charmap.h>, which exists in the cc65 sources purely to stop that compiler applying a charmap to string literals. Joystick is still plain CIA1 at $DC00; the MEGA65 keeps both CIAs. Sound is shared verbatim between the two builds, since the SID is at $D400 either way.

  • One thing did not come across: the sprite card toss. The C64-mode build glides a VIC-II hardware sprite from the played card to the discard pile, which works because a probe confirmed the C64 arrangement survives intact -- screen at $0400, VIC bank 0, sprite pointers at $07F8. Native mode relocates screen RAM and changes sprite pointer handling, which is why the MEGA65 has extended pointer registers at $D06C-$D06E in the first place. Rather than guess, the animation is left out of the native build; cards simply appear on the pile. It remains a known follow-up, along with 80x50, palette-based legal-move dimming, and stereo via the second SID.

How to run each one

  • uno-c64.prg — Commodore 64. x64sc uno-c64.prg in VICE, or a real C64 + disk/cart tool.
  • uno-c128-40col.prg — Commodore 128, 40-column (VIC-IIe). x128 uno-c128-40col.prg.
  • uno-c128-80col-vdc.prg — Commodore 128, 80-column (VDC chip). x128 uno-c128-80col-vdc.prg.
  • uno-plus4.prg — Commodore Plus/4. xplus4 uno-plus4.prg.
  • uno-pet4032.prg — Commodore PET 4032, 40-column (keyboard only, no joystick port). xpet uno-pet4032.prg.
  • uno-pet8032.prg — Commodore PET 8032, 80-column (same family as the 4032). xpet -model 8032 uno-pet8032.prg.
  • uno-vic20.prg — Commodore VIC-20 + memory expansion. xvic -memory all uno-vic20.prg.
  • uno-atari800xl.xex — Atari 800XL. atari800 -xl -xlxe_rom <your ATARIXL.ROM> -nobasic uno-atari800xl.xex (you need your own Atari XL ROM dump; not included here).
  • uno-atari800xl-vbxe.xex — Atari 800XL + VBXE. In Altirra: configure the machine as an XL with 64K memory (not a RAMBO-style expansion -- the cc65 runtime's XL check fails under those), a real Atari XL OS ROM, and the VBXE device at the default $D6xx base, then boot the .xex. Now with legal-move highlighting (cards you can't play are dimmed in their own darkened suit color so the playable ones stand out; an all-unplayable hand shows a "press UP to draw" hint) and a bolder pulsing selection cursor. Verified in AltirraSDL/AltirraBridge; see atari/README.md for the exact recipe.
  • uno-atari800xl-vbxe-bmp.xex — Atari 800XL + VBXE, bitmap-graphics edition. Same game as uno-atari800xl-vbxe.xex but rendered in the VBXE's 320x192 256-colour framebuffer (pixel-drawn card faces, fanned hand) instead of the text overlay. Same Altirra setup as the text VBXE build above: XL with 64K memory, a real Atari XL OS ROM, and the VBXE device at the default $D6xx base.
  • uno-atariste.tos — Atari ST or STE. In Hatari, put it on an emulated GEMDOS drive and autostart it: hatari --machine ste --tos <your tos.img> --harddrive <folder containing uno-atariste.tos> --auto 'C:\UNO-ATARISTE.TOS' (you need your own TOS ROM, or free EmuTOS; not included here). Or just copy it onto a floppy/hard-drive image and double-click it from the GEM desktop. Runs on a plain ST too -- it detects which machine it's on and drops from the STE's 4096-colour palette to the ST's 512 automatically. Keyboard only (see Controls).
  • uno-apple2e.system — Apple IIe (enhanced), ProDOS .SYSTEM file. This is not a bootable disk image by itself — see the apple/ README section for how to inject it into a ProDOS disk image, then run it in MAME's apple2ee driver.
  • uno-amiga — Commodore Amiga, Kickstart 2.0+. In FS-UAE, put this binary in a folder alongside an s/startup-sequence file whose only line is uno-amiga, then mount that folder as the boot hard drive with a Kickstart 2.0+ ROM — it autostarts on boot, no disk image and no shell typing needed: fs-uae --amiga-model=A1200 --kickstart_file=<your kickstart.rom> --hard_drive_0=<that folder>. (To run it by hand instead, drop the startup-sequence and type uno-amiga at the AmigaDOS shell.)
  • uno-amiga-bmp — Commodore Amiga, Kickstart 2.0+, bitmap-graphics edition. Same game as uno-amiga but rendered as pixel-art cards in a 320x256 16-colour screen instead of colored text. Run it the same way in FS-UAE: put it in a folder with an s/startup-sequence whose only line is uno-amiga-bmp, then mount that folder as the boot hard drive with a Kickstart 2.0+ ROM and it autostarts on boot (fs-uae --amiga-model=A1200 --kickstart_file=<your kickstart.rom> --hard_drive_0=<that folder>). Movement is comma/period and U (see Controls).
  • uno-cbm510.prg — Commodore CBM-II (510/P500). xcbm5x0 uno-cbm510.prg in VICE.
  • uno-f256k.pgz — Foenix F256K. Copy it onto an F256 SD card image (or a real SD card), boot to SuperBASIC, and run /- uno (/- hands off to the pexec chainloader, which loads uno.pgz and its PGZ header names). Renders cards as solid colour tiles via the Vicky video chip, with real SID sound; keyboard only (,/. move, space plays, U draws, 1-9/0/A-J jump to a hand slot). Developed and verified against a f256k MAME driver.
  • uno-ti99-4a.rpk — Texas Instruments TI-99/4A, cartridge image. mame ti99_4a -cart uno-ti99-4a.rpk -ioport peb -ioport:peb:slot2 32kmem — the 32K expansion is required, because the cartridge copies the game into that RAM and runs it there. At the TI title screen press any key, then 2 to pick UNO from the console's selection list. Keyboard only (,/. move, space plays, U draws, 1-9/0/A-J jump to a hand slot) — the TI's arrows are FCTN+S/D/E/X and don't come back as plain ASCII. The .rpk is a zip; uno_b0.bin and uno_b1.bin inside it are the two 8K banks, in that order, for real hardware.
  • uno-msx2.rom — MSX2 (and MSX2+ / turbo R), 16K cartridge image. In openMSX: openmsx -machine Philips_NMS_8250 -carta uno-msx2.rom. It boots straight into the game — no BASIC, no menu, no keypress to get past a selection screen. This is the one asset here that needs no ROM of your own: openMSX ships the free C-BIOS, so -machine C-BIOS_MSX2 runs it too (and boots faster). Cursor keys or a joystick in port 1 move the cursor, space or return plays/confirms, U or cursor-up draws, 1-9/0/A-J jump to a hand slot. Real hardware works too — it's a plain 16K ROM image for a standard cartridge.
  • uno-dos-cga.exe — MS-DOS, CGA. The baseline build: runs on a stock IBM PC or PC/XT and on every PC since. In DOSBox or DOSBox-X, mount a folder containing it and run UNO.EXE; on real hardware or in 86Box (machine = IBM XT, video = CGA), copy it off the floppy image below. Arrow keys or U/space; 1-9/0/A-J jump to a hand slot; ESC quits to DOS.
  • uno-dos-ega.exe — MS-DOS, EGA. 640x350 in 16 colours, pixel-art cards. Needs an EGA card or better (-machine ega in DOSBox-X); same 8088 code as the CGA build, so no faster CPU is required. Same controls.
  • uno-dos-vga.exe — MS-DOS, VGA. 320x200 in 256 colours, with the suits programmed to the real UNO colours. Needs a VGA card (-machine vgaonly in DOSBox-X). Same controls.
  • uno-dos-floppy.img — all three of the above on a 1.44M FAT12 floppy image, which is the easiest way onto an emulated or real PC: attach it as drive A: and run A:\UNO.EXE, A:\UNOEGA.EXE or A:\UNOVGA.EXE depending on your video card.
  • uno-zxspectrum.sna — Sinclair ZX Spectrum 48K, ready-to-run snapshot (no LOAD needed). mame spectrum -snapshot uno-zxspectrum.sna, or drag onto any emulator that accepts .sna files. You need your own ZX Spectrum 48K ROM for MAME; not included here.
  • uno-c64os.zip — C64 OS application bundle (about.t/main.o/menu.m inside a uno_1.0/ folder). This one's different from every other asset here: it's not a standalone binary you hand to an emulator, it's an app you install into an existing C64 OS boot volume. You need C64 OS itself already set up first (real hardware, or VICE x64sc with a CMD HD/SD2IEC image and the C64 OS .dhd -- C64 OS is Greg Naçu's commercial product and isn't included here). To install: unzip so uno_1.0/ lands directly inside /os/applications/ on that volume, then launch it from C64 OS's own file manager or app menu. Full setup walkthrough (VICE device numbers, JiffyDOS test harness, etc.) in c64os/README.md.
  • uno-mega65.prg — MEGA65, C64 mode, 40 columns. In Xemu's xmega65 (with a MEGA65 ROM): xmega65 -rom <mega65-rom.bin> -prg uno-mega65.prg. Renders cards as color-bordered boxes on the VIC-IV with SID sound, and animates a VIC-II hardware sprite from your hand to the discard pile on every play; keyboard or joystick. Real hardware works too.
  • uno-mega65-native-80col.prg — MEGA65, native C65 mode, 80 columns. xmega65 -rom <mega65-rom.bin> -prg uno-mega65-native-80col.prg (Xemu auto-detects native mode from the $2001 load address; -prgmode 65 states it explicitly). Twice the width: 5-wide card tiles with the value knocked out of a solid suit block, and a 20-card hand in an 11/9 split. Keyboard via the $D610 ASCII register, or joystick in port 2. No card-toss animation in this build — see the notes above. Real hardware works too.
  • uno-cx16.prg — Commander X16. In the x16 emulator (with its rom.bin): ./x16emu -prg uno-cx16.prg -run. Renders cards as solid VERA color tiles with legal-move highlighting and a real hardware-sprite card toss; keyboard or joystick. Real hardware works too.
  • uno-cx16-bmp.prg — Commander X16, bitmap-graphics edition. Same game as uno-cx16.prg but rendered in a 320x240 256-colour framebuffer (pixel-drawn card faces, fanned hand) via the KERNAL GRAPH API. ./x16emu -prg uno-cx16-bmp.prg -run.
  • uno-coco3.bin — Tandy Color Computer 3, Disk Basic machine-language file. In XRoar: xroar -machine coco3 -run uno-coco3.bin (needs your own CoCo 3 ROM; XRoar's default ROM search path or -rompath should point at it -- see coco/README.md). -run attaches the file and autotypes LOADM/EXEC for you.

Controls

Joystick (where the hardware has a port) or keyboard: cursor left/right to pick a card, space/return to play or confirm, cursor up to draw, or jump straight to a card with 1-9, 0, A-J. Several machines can't do that, each for its own reason, and all land on the same fallback — ,/. to move and U to draw: the Amiga (its cursor keys didn't work reliably through the console input path), the Foenix F256K (arrow keys arrive through the kernel event queue with no ASCII, so they'd need raw scancodes), and the TI-99/4A (its arrows are FCTN+S/D/E/X and come back as control codes rather than plain ASCII). D would be the obvious draw key, but A-J are already the quick-play keys. The ZX Spectrum uses O/P/Q instead, since a real Spectrum keyboard has no cursor keys at all and 1-9/0 are already spoken for. The Atari ST/STE is keyboard-only (cursor keys and space): the ST's joystick ports sit behind the IKBD, which only reports sticks after being switched out of mouse mode and serviced on an interrupt vector -- and Hatari can map the cursor keys to a joystick anyway.

Full source, per-platform build instructions, and design notes are in the main README.

Assets 31
Loading