827 lines
21 KiB
TypeScript
827 lines
21 KiB
TypeScript
"use strict";
|
|
|
|
import { Platform, Base6502Platform, BaseMAMEPlatform, getOpcodeMetadata_6502, getToolForFilename_6502 } from "../baseplatform";
|
|
import { PLATFORMS, RAM, newAddressDecoder, padBytes, noise, setKeyboardFromMap, AnimationTimer, RasterVideo, Keys, makeKeycodeMap, dumpRAM, getMousePos } from "../emu";
|
|
import { hex, lzgmini, stringToByteArray, lpad, rpad, rgb2bgr } from "../util";
|
|
import { MasterAudio, POKEYDeviceChannel } from "../audio";
|
|
|
|
declare var jt; // for 6502
|
|
|
|
var Atari8_PRESETS = [
|
|
{id:'hello.a', name:'Hello World (ASM)'},
|
|
{id:'hellopm.a', name:'Hello Sprites (ASM)'},
|
|
];
|
|
|
|
const ATARI8_KEYCODE_MAP = makeKeycodeMap([
|
|
[Keys.VK_SPACE, 0, 0],
|
|
[Keys.VK_ENTER, 0, 0],
|
|
]);
|
|
|
|
function newPOKEYAudio() {
|
|
var pokey1 = new POKEYDeviceChannel();
|
|
var audio = new MasterAudio();
|
|
audio['pokey1'] = pokey1; // TODO: cheezy
|
|
audio.master.addChannel(pokey1);
|
|
return audio;
|
|
}
|
|
|
|
// ANTIC
|
|
|
|
// https://www.atarimax.com/jindroush.atari.org/atanttim.html
|
|
// http://www.virtualdub.org/blog/pivot/entry.php?id=243
|
|
// http://www.beipmu.com/Antic_Timings.txt
|
|
// https://user.xmission.com/~trevin/atari/antic_regs.html
|
|
// https://user.xmission.com/~trevin/atari/antic_insns.html
|
|
// http://www.atarimuseum.com/videogames/consoles/5200/conv_to_5200.html
|
|
|
|
const PF_LEFT = [999,64,48,32];
|
|
const PF_RIGHT = [999,192,208,224];
|
|
|
|
const DMACTL = 0;
|
|
const CHACTL = 1;
|
|
const DLISTL = 2;
|
|
const DLISTH = 3;
|
|
const HSCROL = 4;
|
|
const VSCROL = 5;
|
|
const PMBASE = 7;
|
|
const CHBASE = 9;
|
|
const WSYNC = 10;
|
|
const VCOUNT = 11;
|
|
const PENH = 12;
|
|
const PENV = 13;
|
|
const NMIEN = 14;
|
|
const NMIRES = 15;
|
|
const NMIST = 15;
|
|
|
|
const PFNONE = 0;
|
|
const PFNARROW = 1;
|
|
const PFNORMAL = 2;
|
|
const PFWIDE = 3;
|
|
|
|
const NMIST_CYCLE = 12;
|
|
const NMI_CYCLE = 24;
|
|
const WSYNC_CYCLE = 212;
|
|
|
|
const MODE_LINES = [ 0, 0, 7, 9, 7, 15, 7, 15, 7, 3, 3, 1, 0, 1, 0, 0 ];
|
|
const MODE_PERIOD = [ 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 1, 1, 1, 0, 0, 0 ];
|
|
const MODE_YPERIOD = [ 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 2, 1, 0, 0, 0, 0 ];
|
|
|
|
class ANTIC {
|
|
regs = new Uint8Array(0x10); // registers
|
|
gtia : GTIA; // GTIA link
|
|
read : (address:number) => number; // bus read function
|
|
nmiPending : boolean = false;
|
|
|
|
// derived by registers
|
|
pfwidth : number; // playfield width
|
|
left : number;
|
|
right : number; // left/right clocks for mode
|
|
|
|
// a la minute
|
|
mode : number = 0; // current mode
|
|
period : number = 0; // current mode period bitmask
|
|
scanaddr : number = 0; // Scan Address (via LMS)
|
|
startaddr: number = 0; // Start of line Address
|
|
pfbyte : number = 0; // playfield byte fetched
|
|
ch : number = 0; // char read
|
|
linesleft : number = 0; // # of lines left in mode
|
|
yofs : number = 0; // yofs fine
|
|
v : number = 0; // vertical scanline #
|
|
h : number = 0; // horizontal color clock
|
|
|
|
constructor(readfn) {
|
|
this.read = readfn; // bus read function
|
|
}
|
|
reset() {
|
|
this.regs[NMIEN] = 0x00;
|
|
this.regs[NMIST] = 0x1f;
|
|
this.setReg(DMACTL, 0x0);
|
|
}
|
|
saveState() {
|
|
return {
|
|
regs: this.regs.slice(0),
|
|
mode: this.mode,
|
|
period: this.period,
|
|
scanaddr: this.scanaddr,
|
|
startaddr: this.startaddr,
|
|
pfbyte: this.pfbyte,
|
|
ch: this.ch,
|
|
linesleft: this.linesleft,
|
|
yofs: this.yofs,
|
|
v: this.v,
|
|
h: this.h,
|
|
};
|
|
}
|
|
loadState(s) {
|
|
for (let i=0; i<16; i++)
|
|
if (i != NMIRES)
|
|
this.setReg(i, s.regs[i]);
|
|
this.mode = s.mode;
|
|
this.period = s.period;
|
|
this.scanaddr = s.scanaddr;
|
|
this.startaddr = s.startaddr;
|
|
this.pfbyte = s.pfbyte;
|
|
this.ch = s.ch;
|
|
this.linesleft = s.linesleft;
|
|
this.yofs = s.yofs;
|
|
this.v = s.v;
|
|
this.h = s.h;
|
|
}
|
|
static stateToLongString(state) : string {
|
|
let s = "";
|
|
s += "H: " + lpad(state.h,3) + " V: " + lpad(state.v,3) + " Linesleft: " + state.linesleft + "\n";
|
|
s += "Mode: " + hex(state.mode,2) + " Period: " + (state.period+1) + "\n";
|
|
s += "Addr: " + hex(state.scanaddr,4) + "\n";
|
|
s += dumpRAM(state.regs, 0, 16).replace('$00', 'Regs');
|
|
return s;
|
|
}
|
|
setReg(a:number, v:number) {
|
|
this.regs[a] = v;
|
|
switch (a) {
|
|
case DMACTL:
|
|
this.pfwidth = this.regs[DMACTL] & 3;
|
|
this.setLeftRight();
|
|
break;
|
|
case NMIRES:
|
|
this.regs[NMIST] = 0x1f;
|
|
break;
|
|
}
|
|
}
|
|
setLeftRight() {
|
|
let offset = 4 << MODE_PERIOD[this.mode & 0xf];
|
|
this.left = PF_LEFT[this.pfwidth];
|
|
this.right = PF_RIGHT[this.pfwidth];
|
|
}
|
|
readReg(a:number) {
|
|
switch (a) {
|
|
case NMIST: return this.regs[NMIST];
|
|
default: return 0;
|
|
}
|
|
}
|
|
startline1() {
|
|
let stolen = 0;
|
|
if (this.linesleft) {
|
|
this.linesleft--;
|
|
if ((this.linesleft & MODE_YPERIOD[this.mode&0xf]) == 0) // use Y period
|
|
this.yofs++;
|
|
}
|
|
if (!this.linesleft) {
|
|
if (this.mode & 0x80) {
|
|
this.triggerInterrupt(0x80); // Display List Interrupt (DLI)
|
|
}
|
|
this.mode = this.nextInsn();
|
|
this.setLeftRight();
|
|
stolen++;
|
|
if ((this.mode & 0xf) == 0) { // N Blank Lines
|
|
this.linesleft = (this.mode >> 4) + 1;
|
|
} else {
|
|
this.linesleft = MODE_LINES[this.mode & 0xf];
|
|
this.period = (1<<MODE_PERIOD[this.mode & 0xf])-1;
|
|
// TODO: this is actually at cclock 9-10
|
|
if ((this.mode & ~0x40) == 0x01) { // JMP insn
|
|
let lo = this.nextInsn();
|
|
let hi = this.nextInsn();
|
|
this.regs[DLISTL] = lo;
|
|
this.regs[DLISTH] = hi;
|
|
// JVB (Jump and wait for Vertical Blank)
|
|
if (this.mode & 0x40) {
|
|
this.mode = 0;
|
|
this.linesleft = 240 - this.v;
|
|
}
|
|
stolen += 2;
|
|
} else if ((this.mode & 0x40) && (this.mode & 0xf)) { // Load Memory Scan bit
|
|
let lo = this.nextInsn();
|
|
let hi = this.nextInsn();
|
|
this.scanaddr = lo + (hi<<8);
|
|
//console.log('scanaddr', hex(this.scanaddr));
|
|
stolen += 2;
|
|
}
|
|
this.startaddr = this.scanaddr;
|
|
this.yofs = 0;
|
|
}
|
|
} else {
|
|
if ((this.mode & 0xf) < 8) // character mode?
|
|
this.scanaddr = this.startaddr; // reset line addr
|
|
}
|
|
return stolen;
|
|
}
|
|
|
|
startline2() {
|
|
return 0; // TODO
|
|
}
|
|
|
|
startline3() {
|
|
return 0; // TODO
|
|
}
|
|
|
|
startline4() {
|
|
let stolen = 0;
|
|
return stolen;
|
|
}
|
|
|
|
triggerInterrupt(mask : number) {
|
|
if (this.regs[NMIEN] & mask) {
|
|
this.nmiPending = true;
|
|
this.regs[NMIST] |= mask;
|
|
}
|
|
}
|
|
|
|
nextInsn() : number {
|
|
let pc = this.regs[DLISTL] + (this.regs[DLISTH]<<8);
|
|
let b = this.read(pc);
|
|
//console.log('nextInsn', hex(pc), hex(b), this.v);
|
|
pc = ((pc+1) & 0x3ff) | (pc & ~0x3ff);
|
|
this.regs[DLISTL] = pc & 0xff;
|
|
this.regs[DLISTH] = pc >> 8;
|
|
return b;
|
|
}
|
|
|
|
nextScreen() : number {
|
|
let b = this.read(this.scanaddr);
|
|
this.scanaddr = ((this.scanaddr+1) & 0xfff) | (this.scanaddr & ~0xfff);
|
|
return b;
|
|
}
|
|
|
|
clockPulse4() : number {
|
|
let nc = 4; // number of cycles not stolen by DMA
|
|
let h = this.h;
|
|
// in overscan region?
|
|
if (this.v >= 240) {
|
|
// interrupts on last scanline of frame
|
|
if (this.v == 240) {
|
|
if (h == NMIST_CYCLE)
|
|
this.regs[NMIST] = 0x5f;
|
|
else if (h == NMI_CYCLE)
|
|
this.triggerInterrupt(0x40);
|
|
}
|
|
}
|
|
// DMA enabled?
|
|
else if (this.regs[DMACTL] & 0x20) {
|
|
// read line data?
|
|
switch (h) {
|
|
case 0: nc -= this.startline1(); break;
|
|
case 4: nc -= this.startline2(); break;
|
|
case 8: nc -= this.startline3(); break;
|
|
case 12: nc -= this.startline4(); break;
|
|
default:
|
|
let mode = this.mode & 0xf;
|
|
if (h >= 48 && h < 120) nc--; // steal 1 clock for memory refresh
|
|
if (h >= this.left && h < this.right && mode >= 2) { // fetch screen byte?
|
|
if (((h>>2) & this.period) == 0) { // use period interval
|
|
if (mode < 8) { // character mode
|
|
let ch = this.ch = this.nextScreen();
|
|
let addrofs = this.yofs;
|
|
let chbase = this.regs[CHBASE];
|
|
// modes 6 & 7
|
|
if ((mode & 0xe) == 6) { // or 7
|
|
ch &= 0x3f;
|
|
chbase &= 0xfe;
|
|
} else {
|
|
ch &= 0x7f;
|
|
chbase &= 0xfc;
|
|
}
|
|
let addr = (ch<<3) + (chbase<<8);
|
|
// modes 2 & 3
|
|
if ((mode & 0xe) == 2) { // or 3
|
|
let chactl = this.regs[CHACTL];
|
|
if (mode == 3 && ch >= 0x60) {
|
|
// TODO
|
|
}
|
|
if (chactl & 4)
|
|
this.pfbyte = this.read(addr + (addrofs ^ 7)); // mirror
|
|
else
|
|
this.pfbyte = this.read(addr + addrofs);
|
|
if (this.ch & 0x80) {
|
|
if (chactl & 1)
|
|
this.pfbyte = 0x0; // blank
|
|
if (chactl & 2)
|
|
this.pfbyte ^= 0xff; // invert
|
|
}
|
|
} else {
|
|
this.pfbyte = this.read(addr + addrofs);
|
|
}
|
|
nc -= 2;
|
|
} else { // map mode
|
|
this.pfbyte = this.nextScreen();
|
|
nc -= 1;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
// next scanline?
|
|
this.h += 4;
|
|
if (this.h >= 228) {
|
|
this.h = 0;
|
|
this.v++;
|
|
if (this.v >= 262) {
|
|
this.v = 0;
|
|
}
|
|
}
|
|
return nc;
|
|
}
|
|
}
|
|
|
|
// GTIA
|
|
// https://user.xmission.com/~trevin/atari/gtia_regs.html
|
|
|
|
// write regs
|
|
const HPOSP0 = 0x0;
|
|
const HPOSM0 = 0x4;
|
|
const SIZEP0 = 0x8;
|
|
const SIZEM = 0x0c;
|
|
const GRAFP0 = 0x0d;
|
|
const GRAFM = 0x11;
|
|
const COLPM0 = 0x12;
|
|
const COLPF0 = 0x16;
|
|
const COLPF1 = 0x17;
|
|
const COLPF2 = 0x18;
|
|
const COLPF3 = 0x19;
|
|
const COLBK = 0x1a;
|
|
const PRIOR = 0x1b;
|
|
const VDELAY = 0x1c;
|
|
const GRACTL = 0x1d;
|
|
const HITCLR = 0x1e;
|
|
const CONSPK = 0x1f;
|
|
// read regs
|
|
const M0PF = 0x0;
|
|
const P0PF = 0x4;
|
|
const M0PL = 0x8;
|
|
const P0PL = 0xc;
|
|
const TRIG0 = 0x10;
|
|
const CONSOL = 0x1f;
|
|
|
|
class GTIA {
|
|
regs = new Uint8Array(0x20);
|
|
count : number = 0;
|
|
antic : ANTIC;
|
|
|
|
constructor(antic : ANTIC) {
|
|
this.antic = antic;
|
|
}
|
|
saveState() {
|
|
return {
|
|
regs: this.regs.slice(0),
|
|
count: this.count,
|
|
};
|
|
}
|
|
loadState(s) {
|
|
for (let i=0; i<32; i++)
|
|
this.setReg(i, s.regs[i]);
|
|
this.count = s.count;
|
|
}
|
|
setReg(a:number, v:number) {
|
|
this.regs[a] = v;
|
|
switch (a) {
|
|
}
|
|
}
|
|
clockPulse() : number {
|
|
let pixel = (this.antic.pfbyte & 128) ? 1 : 0;
|
|
let col = 0;
|
|
switch (this.antic.mode & 0xf) {
|
|
// blank line
|
|
case 0:
|
|
case 1:
|
|
col = this.regs[COLBK];
|
|
break;
|
|
// normal text mode
|
|
case 2:
|
|
case 3:
|
|
default:
|
|
if (pixel)
|
|
col = (this.regs[COLPF1] & 0xf) | (this.regs[COLPF2] & 0xf0);
|
|
else
|
|
col = this.regs[COLPF2];
|
|
if ((this.count & this.antic.period) == 0)
|
|
this.antic.pfbyte <<= 1;
|
|
break;
|
|
// 4bpp mode
|
|
case 4:
|
|
case 5:
|
|
col = (this.antic.pfbyte>>6) & 3;
|
|
if ((this.antic.ch & 0x80) && col==3)
|
|
col = 4; // 5th color
|
|
col = col ? this.regs[COLPF0-1+col] : this.regs[COLBK];
|
|
if ((this.count & 1) == 0)
|
|
this.antic.pfbyte <<= 2;
|
|
break;
|
|
// 4 colors per 64 chars mode
|
|
case 6:
|
|
case 7:
|
|
if (pixel)
|
|
col = this.regs[COLPF0 + (this.antic.ch>>6)];
|
|
else
|
|
col = this.regs[COLBK];
|
|
if ((this.count & this.antic.period) == 0)
|
|
this.antic.pfbyte <<= 1;
|
|
break;
|
|
}
|
|
this.count = (this.count + 1) & 0xff;
|
|
return COLORS_RGBA[col];
|
|
}
|
|
static stateToLongString(state) : string {
|
|
let s = "";
|
|
s += dumpRAM(state.regs, 0, 32);
|
|
return s;
|
|
}
|
|
}
|
|
|
|
const _Atari8Platform = function(mainElement) {
|
|
// http://www.ataripreservation.org/websites/freddy.offenga/megazine/ISSUE5-PALNTSC.html
|
|
const cpuFrequency = 1789773;
|
|
const linesPerFrame = 262;
|
|
const colorClocksPerLine = 228;
|
|
// TODO: for 400/800/5200
|
|
const romLength = 0x8000;
|
|
|
|
var cpu;
|
|
var ram : RAM;
|
|
var rom : Uint8Array;
|
|
var bios : Uint8Array;
|
|
var bus;
|
|
var video, audio;
|
|
var timer; // TODO : AnimationTimer;
|
|
var antic : ANTIC;
|
|
var gtia : GTIA;
|
|
var inputs = new Uint8Array(4);
|
|
|
|
class Atari8Platform extends Base6502Platform implements Platform {
|
|
|
|
getPresets() {
|
|
return Atari8_PRESETS;
|
|
}
|
|
start() {
|
|
cpu = new jt.M6502();
|
|
ram = new RAM(0x4000); // TODO
|
|
bios = new Uint8Array(0x800);
|
|
bus = {
|
|
// TODO: https://github.com/dmlloyd/atari800/blob/master/DOC/cart.txt
|
|
// TODO: http://atariage.com/forums/topic/169971-5200-memory-map/
|
|
read: newAddressDecoder([
|
|
[0x0000, 0x3fff, 0x3fff, function(a) { return ram.mem[a]; }],
|
|
[0x4000, 0xbfff, 0xffff, function(a) { return rom ? rom[a-0x4000] : 0; }],
|
|
[0xf000, 0xffff, 0x7ff, function(a) { return bios[a]; }],
|
|
[0xd400, 0xd4ff, 0xf, function(a) { return antic.readReg(a); }],
|
|
]),
|
|
write: newAddressDecoder([
|
|
[0x0000, 0x3fff, 0xffff, function(a,v) { ram.mem[a] = v; }],
|
|
[0xc000, 0xcfff, 0x1f, function(a,v) { gtia.regs[a] = v; }],
|
|
[0xd400, 0xd4ff, 0xf, function(a,v) { antic.setReg(a,v); }],
|
|
[0xe800, 0xefff, 0xf, function(a,v) { audio.pokey1.setRegister(a, v); }],
|
|
]),
|
|
};
|
|
cpu.connectBus(bus);
|
|
// create support chips
|
|
antic = new ANTIC(bus.read);
|
|
gtia = new GTIA(antic);
|
|
// create video/audio
|
|
video = new RasterVideo(mainElement, 352, 192);
|
|
audio = newPOKEYAudio();
|
|
video.create();
|
|
setKeyboardFromMap(video, inputs, ATARI8_KEYCODE_MAP, (o,key,code,flags) => {
|
|
// TODO
|
|
});
|
|
timer = new AnimationTimer(60, this.nextFrame.bind(this));
|
|
// setup mouse events
|
|
var rasterPosBreakFn = (e) => {
|
|
if (e.ctrlKey) {
|
|
var clickpos = getMousePos(e.target, e);
|
|
this.runEval( (c) => {
|
|
var pos = {x:antic.h, y:this.getRasterScanline()};
|
|
return (pos.x == (clickpos.x&~3)) && (pos.y == (clickpos.y|0));
|
|
});
|
|
}
|
|
};
|
|
var jacanvas = $("#emulator").find("canvas");
|
|
jacanvas.mousedown(rasterPosBreakFn);
|
|
}
|
|
|
|
advance(novideo : boolean) {
|
|
var idata = video.getFrameData();
|
|
var iofs = 0;
|
|
var debugCond = this.getDebugCallback();
|
|
var rgb;
|
|
var freeClocks = 0;
|
|
// load controls
|
|
// TODO
|
|
gtia.regs[0x10] = inputs[0] ^ 1;
|
|
// visible lines
|
|
for (var sl=0; sl<linesPerFrame; sl++) {
|
|
for (var i=0; i<colorClocksPerLine; i+=4) {
|
|
// 2 color clocks per CPU cycle = 4 color clocks
|
|
freeClocks += antic.clockPulse4();
|
|
// interrupt?
|
|
if (antic.nmiPending) {
|
|
freeClocks -= cpu.setNMIAndWait(); // steal clocks b/c of interrupt (could be negative)
|
|
antic.nmiPending = false;
|
|
}
|
|
// iterate CPU with free clocks
|
|
while (freeClocks > 0) {
|
|
freeClocks--;
|
|
if (debugCond && debugCond()) {
|
|
debugCond = null;
|
|
i = 999;
|
|
sl = 999;
|
|
break;
|
|
}
|
|
cpu.clockPulse();
|
|
}
|
|
// 4 ANTIC pulses = 8 pixels
|
|
if (antic.v >= 24 && antic.h >= 44 && antic.h < 44+176) { // TODO: const
|
|
for (var j=0; j<8; j++) {
|
|
rgb = gtia.clockPulse();
|
|
idata[iofs++] = rgb;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// update video frame
|
|
if (!novideo) {
|
|
video.updateFrame();
|
|
// set background/border color
|
|
let bkcol = gtia.regs[COLBK];
|
|
$(video.canvas).css('background-color', COLORS_WEB[bkcol]);
|
|
}
|
|
}
|
|
|
|
loadROM(title, data) {
|
|
rom = padBytes(data, romLength);
|
|
rom[rom.length-3] = 0xff; // TODO
|
|
this.reset();
|
|
}
|
|
|
|
loadBIOS(title, data) {
|
|
bios = padBytes(data, 0x800);
|
|
this.reset();
|
|
}
|
|
|
|
isRunning() {
|
|
return timer.isRunning();
|
|
}
|
|
pause() {
|
|
timer.stop();
|
|
audio.stop();
|
|
}
|
|
resume() {
|
|
timer.start();
|
|
audio.start();
|
|
}
|
|
reset() {
|
|
cpu.reset();
|
|
// execute until out of BIOS
|
|
for (var i=0; i<20000; i++) {
|
|
cpu.clockPulse();
|
|
if (this.getCPUState().PC < 0xf000)
|
|
break;
|
|
}
|
|
}
|
|
readAddress(addr : number) {
|
|
return ((addr & 0xf000) != 0xd000) ? bus.read(addr) : null; // ignore I/O space
|
|
}
|
|
|
|
loadState(state) {
|
|
this.unfixPC(state.c);
|
|
cpu.loadState(state.c);
|
|
this.fixPC(state.c);
|
|
ram.mem.set(state.b);
|
|
antic.loadState(state.antic);
|
|
gtia.loadState(state.gtia);
|
|
this.loadControlsState(state);
|
|
}
|
|
saveState() {
|
|
return {
|
|
c:this.getCPUState(),
|
|
b:ram.mem.slice(0),
|
|
antic:antic.saveState(),
|
|
gtia:gtia.saveState(),
|
|
in:inputs.slice(0)
|
|
};
|
|
}
|
|
loadControlsState(state) {
|
|
inputs.set(state.in);
|
|
}
|
|
saveControlsState() {
|
|
return {
|
|
in:inputs.slice(0)
|
|
};
|
|
}
|
|
getCPUState() {
|
|
return this.fixPC(cpu.saveState());
|
|
}
|
|
getRasterScanline() {
|
|
return antic.v;
|
|
}
|
|
getDebugCategories() {
|
|
return super.getDebugCategories().concat(['ANTIC','GTIA']);
|
|
}
|
|
getDebugInfo(category, state) {
|
|
switch (category) {
|
|
case 'ANTIC': return ANTIC.stateToLongString(state.antic);
|
|
case 'GTIA': return GTIA.stateToLongString(state.gtia);
|
|
default: return super.getDebugInfo(category, state);
|
|
}
|
|
}
|
|
}
|
|
|
|
return new Atari8Platform(); // return inner class from constructor
|
|
};
|
|
|
|
// Atari 5200
|
|
const _Atari5200Platform = function(mainElement) {
|
|
this.__proto__ = new (_Atari8Platform as any)(mainElement);
|
|
}
|
|
|
|
|
|
/// MAME support
|
|
|
|
abstract class Atari8MAMEPlatform extends BaseMAMEPlatform {
|
|
loadROM(title, data) {
|
|
this.loadROMFile(data);
|
|
this.loadRegion(":cartleft:cart:rom", data);
|
|
}
|
|
getPresets() { return Atari8_PRESETS; }
|
|
getToolForFilename = getToolForFilename_6502;
|
|
getDefaultExtension() { return ".c"; };
|
|
}
|
|
|
|
class Atari800MAMEPlatform extends Atari8MAMEPlatform implements Platform {
|
|
start() {
|
|
this.startModule(this.mainElement, {
|
|
jsfile:'mameatari400.js',
|
|
biosfile:'a400.zip', // TODO: load multiple files
|
|
//cfgfile:'atari5200.cfg',
|
|
driver:'a400',
|
|
width:336*2,
|
|
height:225*2,
|
|
romfn:'/emulator/cart.rom',
|
|
romsize:0x2000,
|
|
preInit:function(_self) {
|
|
},
|
|
});
|
|
}
|
|
}
|
|
|
|
class Atari5200MAMEPlatform extends Atari8MAMEPlatform implements Platform {
|
|
start() {
|
|
this.startModule(this.mainElement, {
|
|
jsfile:'mameatari400.js',
|
|
biosfile:'a5200/5200.rom',
|
|
//cfgfile:'atari5200.cfg',
|
|
driver:'a5200',
|
|
width:336*2,
|
|
height:225*2,
|
|
romfn:'/emulator/cart.rom',
|
|
romsize:0x2000,
|
|
preInit:function(_self) {
|
|
},
|
|
});
|
|
}
|
|
}
|
|
|
|
///
|
|
|
|
const ATARI_NTSC_RGB = [
|
|
0x000000, // 00
|
|
0x404040, // 02
|
|
0x6c6c6c, // 04
|
|
0x909090, // 06
|
|
0xb0b0b0, // 08
|
|
0xc8c8c8, // 0A
|
|
0xdcdcdc, // 0C
|
|
0xf4f4f4, // 0E
|
|
0x004444, // 10
|
|
0x106464, // 12
|
|
0x248484, // 14
|
|
0x34a0a0, // 16
|
|
0x40b8b8, // 18
|
|
0x50d0d0, // 1A
|
|
0x5ce8e8, // 1C
|
|
0x68fcfc, // 1E
|
|
0x002870, // 20
|
|
0x144484, // 22
|
|
0x285c98, // 24
|
|
0x3c78ac, // 26
|
|
0x4c8cbc, // 28
|
|
0x5ca0cc, // 2A
|
|
0x68b4dc, // 2C
|
|
0x78c8ec, // 2E
|
|
0x001884, // 30
|
|
0x183498, // 32
|
|
0x3050ac, // 34
|
|
0x4868c0, // 36
|
|
0x5c80d0, // 38
|
|
0x7094e0, // 3A
|
|
0x80a8ec, // 3C
|
|
0x94bcfc, // 3E
|
|
0x000088, // 40
|
|
0x20209c, // 42
|
|
0x3c3cb0, // 44
|
|
0x5858c0, // 46
|
|
0x7070d0, // 48
|
|
0x8888e0, // 4A
|
|
0xa0a0ec, // 4C
|
|
0xb4b4fc, // 4E
|
|
0x5c0078, // 50
|
|
0x74208c, // 52
|
|
0x883ca0, // 54
|
|
0x9c58b0, // 56
|
|
0xb070c0, // 58
|
|
0xc084d0, // 5A
|
|
0xd09cdc, // 5C
|
|
0xe0b0ec, // 5E
|
|
0x780048, // 60
|
|
0x902060, // 62
|
|
0xa43c78, // 64
|
|
0xb8588c, // 66
|
|
0xcc70a0, // 68
|
|
0xdc84b4, // 6A
|
|
0xec9cc4, // 6C
|
|
0xfcb0d4, // 6E
|
|
0x840014, // 70
|
|
0x982030, // 72
|
|
0xac3c4c, // 74
|
|
0xc05868, // 76
|
|
0xd0707c, // 78
|
|
0xe08894, // 7A
|
|
0xeca0a8, // 7C
|
|
0xfcb4bc, // 7E
|
|
0x880000, // 80
|
|
0x9c201c, // 82
|
|
0xb04038, // 84
|
|
0xc05c50, // 86
|
|
0xd07468, // 88
|
|
0xe08c7c, // 8A
|
|
0xeca490, // 8C
|
|
0xfcb8a4, // 8E
|
|
0x7c1800, // 90
|
|
0x90381c, // 92
|
|
0xa85438, // 94
|
|
0xbc7050, // 96
|
|
0xcc8868, // 98
|
|
0xdc9c7c, // 9A
|
|
0xecb490, // 9C
|
|
0xfcc8a4, // 9E
|
|
0x5c2c00, // A0
|
|
0x784c1c, // A2
|
|
0x906838, // A4
|
|
0xac8450, // A6
|
|
0xc09c68, // A8
|
|
0xd4b47c, // AA
|
|
0xe8cc90, // AC
|
|
0xfce0a4, // AE
|
|
0x2c3c00, // B0
|
|
0x485c1c, // B2
|
|
0x647c38, // B4
|
|
0x809c50, // B6
|
|
0x94b468, // B8
|
|
0xacd07c, // BA
|
|
0xc0e490, // BC
|
|
0xd4fca4, // BE
|
|
0x003c00, // C0
|
|
0x205c20, // C2
|
|
0x407c40, // C4
|
|
0x5c9c5c, // C6
|
|
0x74b474, // C8
|
|
0x8cd08c, // CA
|
|
0xa4e4a4, // CC
|
|
0xb8fcb8, // CE
|
|
0x003814, // D0
|
|
0x1c5c34, // D2
|
|
0x387c50, // D4
|
|
0x50986c, // D6
|
|
0x68b484, // D8
|
|
0x7ccc9c, // DA
|
|
0x90e4b4, // DC
|
|
0xa4fcc8, // DE
|
|
0x00302c, // E0
|
|
0x1c504c, // E2
|
|
0x347068, // E4
|
|
0x4c8c84, // E6
|
|
0x64a89c, // E8
|
|
0x78c0b4, // EA
|
|
0x88d4cc, // EC
|
|
0x9cece0, // EE
|
|
0x002844, // F0
|
|
0x184864, // F2
|
|
0x306884, // F4
|
|
0x4484a0, // F6
|
|
0x589cb8, // F8
|
|
0x6cb4d0, // FA
|
|
0x7ccce8, // FC
|
|
0x8ce0fc // FE
|
|
];
|
|
|
|
var COLORS_RGBA = new Uint32Array(256);
|
|
var COLORS_WEB = [];
|
|
for (var i=0; i<256; i++) {
|
|
COLORS_RGBA[i] = ATARI_NTSC_RGB[i>>1] | 0xff000000;
|
|
COLORS_WEB[i] = "#"+hex(rgb2bgr(ATARI_NTSC_RGB[i>>1]),6);
|
|
}
|
|
|
|
///
|
|
|
|
PLATFORMS['atari8-5200'] = _Atari5200Platform;
|
|
PLATFORMS['atari8-800.mame'] = Atari800MAMEPlatform;
|
|
PLATFORMS['atari8-5200.mame'] = Atari5200MAMEPlatform;
|