[pypy-svn] r52445 - pypy/branch/gameboy-emulator/pypy/lang/gameboy
tverwaes at codespeak.net
tverwaes at codespeak.net
Thu Mar 13 13:57:32 CET 2008
Author: tverwaes
Date: Thu Mar 13 13:57:30 2008
New Revision: 52445
Removed:
pypy/branch/gameboy-emulator/pypy/lang/gameboy/interpreter.py
Modified:
pypy/branch/gameboy-emulator/pypy/lang/gameboy/cartridge.py
pypy/branch/gameboy-emulator/pypy/lang/gameboy/cpu.py
pypy/branch/gameboy-emulator/pypy/lang/gameboy/gameboy.py
pypy/branch/gameboy-emulator/pypy/lang/gameboy/interrupt.py
pypy/branch/gameboy-emulator/pypy/lang/gameboy/joypad.py
pypy/branch/gameboy-emulator/pypy/lang/gameboy/ram.py
pypy/branch/gameboy-emulator/pypy/lang/gameboy/serial.py
pypy/branch/gameboy-emulator/pypy/lang/gameboy/sound.py
pypy/branch/gameboy-emulator/pypy/lang/gameboy/timer.py
pypy/branch/gameboy-emulator/pypy/lang/gameboy/video.py
Log:
Using constants from file
Modified: pypy/branch/gameboy-emulator/pypy/lang/gameboy/cartridge.py
==============================================================================
--- pypy/branch/gameboy-emulator/pypy/lang/gameboy/cartridge.py (original)
+++ pypy/branch/gameboy-emulator/pypy/lang/gameboy/cartridge.py Thu Mar 13 13:57:30 2008
@@ -1,16 +1,17 @@
# CATRIGE TYPES
# ___________________________________________________________________________
+from pypy.lang.gameboy import constants
def hasCartridgeBattery(self, cartridgeType):
- return (cartridgeType == TYPE_MBC1_RAM_BATTERY \
- or cartridgeType == TYPE_MBC2_BATTERY \
- or cartridgeType == TYPE_MBC3_RTC_BATTERY \
- or cartridgeType == TYPE_MBC3_RTC_RAM_BATTERY \
- or cartridgeType == TYPE_MBC3_RAM_BATTERY \
- or cartridgeType == TYPE_MBC5_RAM_BATTERY \
- or cartridgeType == TYPE_MBC5_RUMBLE_RAM_BATTERY \
- or cartridgeType == TYPE_HUC1_RAM_BATTERY);
+ return (cartridgeType == constants.TYPE_MBC1_RAM_BATTERY \
+ or cartridgeType == constants.TYPE_MBC2_BATTERY \
+ or cartridgeType == constants.TYPE_MBC3_RTC_BATTERY \
+ or cartridgeType == constants.TYPE_MBC3_RTC_RAM_BATTERY \
+ or cartridgeType == constants.TYPE_MBC3_RAM_BATTERY \
+ or cartridgeType == constants.TYPE_MBC5_RAM_BATTERY \
+ or cartridgeType == constants.TYPE_MBC5_RUMBLE_RAM_BATTERY \
+ or cartridgeType == constants.TYPE_HUC1_RAM_BATTERY);
def hasCartridgeType(self, catridgeType):
@@ -131,8 +132,8 @@
ramSize = self.getRAMSize()
- if (getCartridgeType() >= CartridgeFactory.TYPE_MBC2
- and getCartridgeType() <= CartridgeFactory.TYPE_MBC2_BATTERY):
+ if (getCartridgeType() >= constants.TYPE_MBC2
+ and getCartridgeType() <= constants.TYPE_MBC2_BATTERY):
ramSize = 512;
self.ram = []
@@ -722,51 +723,13 @@
self.clockTime = now - elapsed;
-TYPE_ROM_ONLY = 0x00
-
-TYPE_MBC1 = 0x01
-TYPE_MBC1_RAM = 0x02
-TYPE_MBC1_RAM_BATTERY = 0x03
-
-TYPE_MBC2 = 0x05
-TYPE_MBC2_BATTERY = 0x06
-
-TYPE_MBC3_RTC_BATTERY = 0x0F
-TYPE_MBC3_RTC_RAM_BATTERY = 0x10
-TYPE_MBC3 = 0x11
-TYPE_MBC3_RAM = 0x12
-TYPE_MBC3_RAM_BATTERY = 0x13
-
-TYPE_MBC5 = 0x19
-TYPE_MBC5_RAM = 0x1A
-TYPE_MBC5_RAM_BATTERY = 0x1B
-
-TYPE_MBC5_RUMBLE = 0x1C
-TYPE_MBC5_RUMBLE_RAM = 0x1D
-TYPE_MBC5_RUMBLE_RAM_BATTERY = 0x1E
-
-TYPE_HUC3_RTC_RAM = 0xFE
-TYPE_HUC1_RAM_BATTERY = 0xFF
-
CATRIDGE_TYPE_RANGES = [
- (TYPE_MBC1, TYPE_MBC1_RAM_BATTERY, MBC1),
- (TYPE_MBC2, TYPE_MBC2_BATTERY, MBC2),
- (TYPE_MBC3_RTC_BATTERY, TYPE_MBC3_RAM_BATTERY, MBC3),
- (TYPE_MBC5, TYPE_MBC5_RUMBLE_RAM_BATTERY, MBC5),
- (TYPE_HUC3_RTC_RAM, HuC3),
- (TYPE_HUC1_RAM_BATTERY, HuC1)
+ (constants.TYPE_MBC1, constants.TYPE_MBC1_RAM_BATTERY, MBC1),
+ (constants.TYPE_MBC2, constants.TYPE_MBC2_BATTERY, MBC2),
+ (constants.TYPE_MBC3_RTC_BATTERY, constants.TYPE_MBC3_RAM_BATTERY, MBC3),
+ (constants.TYPE_MBC5, constants.TYPE_MBC5_RUMBLE_RAM_BATTERY, MBC5),
+ (constants.TYPE_HUC3_RTC_RAM, constants.TYPE_HUC3_RTC_RAM, HuC3),
+ (constants.TYPE_HUC1_RAM_BATTERY, constants.TYPE_HUC1_RAM_BATTERY, HuC1)
]
-def initialize_cartridge_mapping():
- result = [None] * 256
- for entry in BYTECODE_RANGES:
- if len(entry) == 2:
- positions = [entry[0]]
- else:
- positions = range(entry[0], entry[1]+1)
- for pos in positions:
- result[pos] = entry[-1]
- assert None not in result
- return result
-
-CARTRIDGE_TABLE = initialize_cartridge_mapping()
+
Modified: pypy/branch/gameboy-emulator/pypy/lang/gameboy/cpu.py
==============================================================================
--- pypy/branch/gameboy-emulator/pypy/lang/gameboy/cpu.py (original)
+++ pypy/branch/gameboy-emulator/pypy/lang/gameboy/cpu.py Thu Mar 13 13:57:30 2008
@@ -3,13 +3,9 @@
Central Unit ProcessOR (Sharp LR35902 CPU)
"""
+from pypy.lang.gameboy import constants
class CPU(object):
- # Flags
- Z_FLAG = 0x80
- N_FLAG = 0x40
- H_FLAG = 0x20
- C_FLAG = 0x10
# Registers
a = 0
@@ -121,21 +117,21 @@
self.cycles = 0;
if (self.ime):
if (self.interrupt.isPending()):
- if (self.interrupt.isPending(Interrupt.VBLANK)):
+ if (self.interrupt.isPending(constants.VBLANK)):
self.interrupt(0x40);
- self.interrupt.lower(Interrupt.VBLANK);
- elif (self.interrupt.isPending(Interrupt.LCD)):
+ self.interrupt.lower(constants.VBLANK);
+ elif (self.interrupt.isPending(constants.LCD)):
self.interrupt(0x48);
- self.interrupt.lower(Interrupt.LCD);
- elif (self.interrupt.isPending(Interrupt.TIMER)):
+ self.interrupt.lower(constants.LCD);
+ elif (self.interrupt.isPending(constants.TIMER)):
self.interrupt(0x50);
- self.interrupt.lower(Interrupt.TIMER);
- elif (self.interrupt.isPending(Interrupt.SERIAL)):
+ self.interrupt.lower(constants.TIMER);
+ elif (self.interrupt.isPending(constants.SERIAL)):
self.interrupt(0x58);
- self.interrupt.lower(Interrupt.SERIAL);
- elif (self.interrupt.isPending(Interrupt.JOYPAD)):
+ self.interrupt.lower(constants.SERIAL);
+ elif (self.interrupt.isPending(constants.JOYPAD)):
self.interrupt(0x60);
- self.interrupt.lower(Interrupt.JOYPAD);
+ self.interrupt.lower(constants.JOYPAD);
def interrupt(self, address):
@@ -465,48 +461,48 @@
s = (self.a + data) & 0xFF;
self.f = 0
if s == 0:
- self.f = Z_FLAG
+ self.f = constants.Z_FLAG
if s < self.a:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
if (s & 0x0F) < (self.a & 0x0F):
- self.f += H_FLAG
+ self.f += constants.H_FLAG
self.a = s;
def adc(self, data):
- s = self.a + data + ((self.f & C_FLAG) >> 4);
+ s = self.a + data + ((self.f & constants.C_FLAG) >> 4);
self.f = 0
if (s & 0xFF) == 0:
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
if s >= 0x100:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
if ((s ^ self.a ^ data) & 0x10) != 0:
- self.f += H_FLAG
+ self.f += constants.H_FLAG
self.a = s & 0xFF;
def sub(self, data):
s = (self.a - data) & 0xFF;
- self.f = N_FLAG
+ self.f = constants.N_FLAG
if s == 0:
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
if s > self.a:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
if (s & 0x0F) > (self.a & 0x0F):
- self.f += H_FLAG
+ self.f += constants.H_FLAG
self.a = s;
def sbc(self, data):
- s = self.a - data - ((self.f & C_FLAG) >> 4);
- self.f = N_FLAG
+ s = self.a - data - ((self.f & constants.C_FLAG) >> 4);
+ self.f = constants.N_FLAG
if (s & 0xFF) == 0:
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
if (s & 0xFF00) != 0:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
if ((s ^ self.a ^ data) & 0x10) != 0:
- self.f += H_FLAG
+ self.f += constants.H_FLAG
self.a = s & 0xFF;
@@ -514,42 +510,42 @@
self.a &= data;
self.f = 0
if self.a == 0:
- self.f = Z_FLAG
+ self.f = constants.Z_FLAG
def xOR(self, data):
self.a ^= data;
self.f = 0
if self.a == 0:
- self.f = Z_FLAG
+ self.f = constants.Z_FLAG
def cpuOR(self, data):
self.a |= data;
self.f = 0
if self.a == 0:
- self.f = Z_FLAG
+ self.f = constants.Z_FLAG
def cp(self, data):
s = (self.a - data) & 0xFF;
- self.f = N_FLAG
+ self.f = constants.N_FLAG
if s==0:
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
if s > self.a:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
if (s & 0x0F) > (self.a & 0x0F):
- self.f += H_FLAG
+ self.f += constants.H_FLAG
def inc(self, data):
data = (data + 1) & 0xFF;
self.f = 0
if data == 0:
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
if (data & 0x0F) == 0x00:
- self.f += H_FLAG
- self.f += (self.f & C_FLAG);
+ self.f += constants.H_FLAG
+ self.f += (self.f & constants.C_FLAG);
return data;
@@ -557,10 +553,10 @@
data = (data - 1) & 0xFF;
self.f = 0
if data == 0:
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
if (data & 0x0F) == 0x0F:
- self.f += H_FLAG
- self.f += (self.f & C_FLAG) + N_FLAG;
+ self.f += constants.H_FLAG
+ self.f += (self.f & constants.C_FLAG) + constants.N_FLAG;
return data;
@@ -568,21 +564,21 @@
s = ((data & 0x7F) << 1) + ((data & 0x80) >> 7);
self.f = 0
if s == 0:
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
if (data & 0x80) != 0:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
return s;
def rl(self, data):
s = ((data & 0x7F) << 1)
- if (self.f & C_FLAG) != 0:
+ if (self.f & constants.C_FLAG) != 0:
self.f += 0x01;
self.f =0
if (s == 0):
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
if (data & 0x80) != 0:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
return s;
@@ -590,19 +586,19 @@
s = (data >> 1) + ((data & 0x01) << 7);
self.f = 0
if s == 0:
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
if (data & 0x01) != 0:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
return s;
def rr(self, data):
- s = (data >> 1) + ((self.f & C_FLAG) << 3);
+ s = (data >> 1) + ((self.f & constants.C_FLAG) << 3);
self.f = 0
if s == 0:
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
if (data & 0x01) != 0:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
return s;
@@ -610,9 +606,9 @@
s = (data << 1) & 0xFF;
self.f = 0
if s == 0:
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
if (data & 0x80) != 0:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
return s;
@@ -620,9 +616,9 @@
s = (data >> 1) + (data & 0x80);
self.f = 0
if s == 0:
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
if (data & 0x01) != 0:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
return s;
@@ -630,9 +626,9 @@
s = (data >> 1);
self.f = 0
if s == 0 :
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
if (data & 0x01) != 0:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
return s;
@@ -640,24 +636,24 @@
s = ((data << 4) & 0xF0) + ((data >> 4) & 0x0F);
self.f = 0
if s == 0:
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
return s;
def bit(self, n, data):
- self.f = (self.f & C_FLAG) + H_FLAG
+ self.f = (self.f & constants.C_FLAG) + constants.H_FLAG
if (data & (1 << n)) == 0:
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
def add(self, hi, lo):
s = ((self.h << 8) + self.l + (hi << 8) + lo) & 0xFFFF;
- self.f = (self.f & Z_FLAG)
+ self.f = (self.f & constants.Z_FLAG)
if ((s >> 8) & 0x0F) < (self.h & 0x0F):
- self.f += H_FLAG
+ self.f += constants.H_FLAG
self.f += s < (self.h << 8)
if self.l:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
self.l = s & 0xFF;
self.h = s >> 8;
@@ -1176,28 +1172,28 @@
# CPL
def cpl(self):
self.a ^= 0xFF;
- self.f |= N_FLAG + H_FLAG;
+ self.f |= constants.N_FLAG + constants.H_FLAG;
# DAA
def daa(self):
delta = 0;
- if ((self.f & H_FLAG) != 0 or (self.a & 0x0F) > 0x09):
+ if ((self.f & constants.H_FLAG) != 0 or (self.a & 0x0F) > 0x09):
delta |= 0x06;
- if ((self.f & C_FLAG) != 0 or (self.a & 0xF0) > 0x90):
+ if ((self.f & constants.C_FLAG) != 0 or (self.a & 0xF0) > 0x90):
delta |= 0x60;
if ((self.a & 0xF0) > 0x80 and (self.a & 0x0F) > 0x09):
delta |= 0x60;
- if ((self.f & N_FLAG) == 0):
+ if ((self.f & constants.N_FLAG) == 0):
self.a = (self.a + delta) & 0xFF;
else:
self.a = (self.a - delta) & 0xFF;
- self.f = (self.f & N_FLAG)
+ self.f = (self.f & constants.N_FLAG)
if delta >= 0x60:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
if self.a == 0:
- self.f += Z_FLAG
+ self.f += constants.Z_FLAG
self.cycles -= 1;
@@ -1305,21 +1301,21 @@
if (offset >= 0):
self.f = 0
if s < self.sp:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
if (s & 0x0F00) < (self.sp & 0x0F00):
- self.f += H_FLAG
+ self.f += constants.H_FLAG
else:
self.f = 0
if s > self.sp:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
if (s & 0x0F00) > (self.sp & 0x0F00):
- self.f += H_FLAG
+ self.f += constants.H_FLAG
# RLCA
def rlca(self):
self.f = 0
if (self.a & 0x80) != 0:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
self.a = ((self.a & 0x7F) << 1) + ((self.a & 0x80) >> 7);
self.cycles -= 1;
@@ -1327,11 +1323,11 @@
# RLA
def rla(self):
s = ((self.a & 0x7F) << 1)
- if (self.f & C_FLAG) != 0:
+ if (self.f & constants.C_FLAG) != 0:
s += 0x01
self.f = 0
if (self.a & 0x80) != 0:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
self.a = s;
self.cycles -= 1;
@@ -1340,7 +1336,7 @@
def rrca(self):
self.f = 0
if (self.a & 0x01) != 0:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
self.a = ((self.a >> 1) & 0x7F) + ((self.a << 7) & 0x80);
self.cycles -= 1;
@@ -1348,21 +1344,21 @@
# RRA
def rra(self):
s = ((self.a >> 1) & 0x7F)
- if (self.f & C_FLAG) != 0:
+ if (self.f & constants.C_FLAG) != 0:
se += 0x80
self.f = 0
if (self.a & 0x01) != 0:
- self.f += C_FLAG
+ self.f += constants.C_FLAG
self.a = s;
self.cycles -= 1;
# CCF/SCF
def ccf(self):
- self.f = (self.f & (Z_FLAG | C_FLAG)) ^ C_FLAG;
+ self.f = (self.f & (constants.Z_FLAG | constants.C_FLAG)) ^ constants.C_FLAG;
def scf(self):
- self.f = (self.f & Z_FLAG) | C_FLAG;
+ self.f = (self.f & constants.Z_FLAG) | constants.C_FLAG;
# NOP
@@ -1397,19 +1393,19 @@
def jp_NZ_nnnn(self):
- self.jp_cc_nnnn((self.f & Z_FLAG) == 0);
+ self.jp_cc_nnnn((self.f & constants.Z_FLAG) == 0);
def jp_NC_nnnn(self):
- self.jp_cc_nnnn((self.f & C_FLAG) == 0);
+ self.jp_cc_nnnn((self.f & constants.C_FLAG) == 0);
def jp_Z_nnnn(self):
- self.jp_cc_nnnn((self.f & Z_FLAG) != 0);
+ self.jp_cc_nnnn((self.f & constants.Z_FLAG) != 0);
def jp_C_nnnn(self):
- self.jp_cc_nnnn((self.f & C_FLAG) != 0);
+ self.jp_cc_nnnn((self.f & constants.C_FLAG) != 0);
# JR +nn
@@ -1434,19 +1430,19 @@
def jr_NZ_nn(self):
- self.jr_cc_nn((self.f & Z_FLAG) == 0);
+ self.jr_cc_nn((self.f & constants.Z_FLAG) == 0);
def jr_Z_nn(self):
- self.jr_cc_nn((self.f & Z_FLAG) != 0);
+ self.jr_cc_nn((self.f & constants.Z_FLAG) != 0);
def jr_NC_nn(self):
- self.jr_cc_nn((self.f & C_FLAG) == 0);
+ self.jr_cc_nn((self.f & constants.C_FLAG) == 0);
def jr_C_nn(self):
- self.jr_cc_nn((self.f & C_FLAG) != 0);
+ self.jr_cc_nn((self.f & constants.C_FLAG) != 0);
# CALL nnnn
@@ -1471,19 +1467,19 @@
def call_NZ_nnnn(self):
- self.call_cc_nnnn((self.f & Z_FLAG) == 0);
+ self.call_cc_nnnn((self.f & constants.Z_FLAG) == 0);
def call_NC_nnnn(self):
- self.call_cc_nnnn((self.f & C_FLAG) == 0);
+ self.call_cc_nnnn((self.f & constants.C_FLAG) == 0);
def call_Z_nnnn(self):
- self.call_cc_nnnn((self.f & Z_FLAG) != 0);
+ self.call_cc_nnnn((self.f & constants.Z_FLAG) != 0);
def call_C_nnnn(self):
- self.call_cc_nnnn((self.f & C_FLAG) != 0);
+ self.call_cc_nnnn((self.f & constants.C_FLAG) != 0);
# RET
@@ -1506,19 +1502,19 @@
def ret_NZ(self):
- self.ret_cc((self.f & Z_FLAG) == 0);
+ self.ret_cc((self.f & constants.Z_FLAG) == 0);
def ret_NC(self):
- self.ret_cc((self.f & C_FLAG) == 0);
+ self.ret_cc((self.f & constants.C_FLAG) == 0);
def ret_Z(self):
- self.ret_cc((self.f & Z_FLAG) != 0);
+ self.ret_cc((self.f & constants.Z_FLAG) != 0);
def ret_C(self):
- self.ret_cc((self.f & C_FLAG) != 0);
+ self.ret_cc((self.f & constants.C_FLAG) != 0);
# RST nn
Modified: pypy/branch/gameboy-emulator/pypy/lang/gameboy/gameboy.py
==============================================================================
--- pypy/branch/gameboy-emulator/pypy/lang/gameboy/gameboy.py (original)
+++ pypy/branch/gameboy-emulator/pypy/lang/gameboy/gameboy.py Thu Mar 13 13:57:30 2008
@@ -4,12 +4,10 @@
Gameboy Scheduler and Memory Mapper
"""
+from pypy.lang.gameboy import constants
class GameBoy(object):
- # Registered Symbol, convert to byte
- REGISTERED_BITMAP = [0x3C, 0x42, 0xB9, 0xA5, 0xB9, 0xA5, 0x42, 0x3C ];
-
# RAM
ram = None;
cartridge = None;
@@ -176,7 +174,7 @@
self.video.write(0x8016 + (index << 3), pattern1);
for index in range(0, 8):
- self.video.write(0x8190 + (index << 1), REGISTERED_BITMAP[index]);
+ self.video.write(0x8190 + (index << 1), constants.REGISTERED_BITMAP[index]);
for tile in range(0, 12):
self.video.write(0x9904 + tile, tile + 1);
Modified: pypy/branch/gameboy-emulator/pypy/lang/gameboy/interrupt.py
==============================================================================
--- pypy/branch/gameboy-emulator/pypy/lang/gameboy/interrupt.py (original)
+++ pypy/branch/gameboy-emulator/pypy/lang/gameboy/interrupt.py Thu Mar 13 13:57:30 2008
@@ -4,18 +4,9 @@
Interrupt Controller
"""
-class Interrupt(object):
+from pypy.lang.gameboy import constants
- # Interrupt Registers
- IE = 0xFFFF # Interrupt Enable */
- IF = 0xFF0F # Interrupt Flag */
-
- # Interrupt Flags
- VBLANK = 0x01 # V-Blank Interrupt (INT 40h) */
- LCD = 0x02 # LCD STAT Interrupt (INT 48h) */
- TIMER = 0x04 # Timer Interrupt (INT 50h) */
- SERIAL = 0x08 # Serial Interrupt (INT 58h) */
- JOYPAD = 0x10 # Joypad Interrupt (INT 60h) */
+class Interrupt(object):
# Registers
enable = 0;
@@ -47,16 +38,16 @@
def write(self, address, data):
- if address == IE:
+ if address == constants.IE:
self.setInterruptEnable(data);
- elif address==IF:
+ elif address == constants.IF:
self.setInterruptFlag(data);
def read(self, address):
- if address==IE:
+ if address == constants.IE:
return self.getInterruptEnable();
- elif address== IF:
+ elif address == constants.IF:
return self.getInterruptFlag();
return 0xFF;
Modified: pypy/branch/gameboy-emulator/pypy/lang/gameboy/joypad.py
==============================================================================
--- pypy/branch/gameboy-emulator/pypy/lang/gameboy/joypad.py (original)
+++ pypy/branch/gameboy-emulator/pypy/lang/gameboy/joypad.py Thu Mar 13 13:57:30 2008
@@ -5,14 +5,6 @@
"""
class Joypad(object):
- # Joypad Registers
- JOYP = 0xFF00; # P1 */
-
- # Gameboy Clock Speed (1048576 Hz)
- GAMEBOY_CLOCK = 1 << 20;
-
- # Joypad Poll Speed (64 Hz)
- JOYPAD_CLOCK = GAMEBOY_CLOCK >> 6;
# Registers
joyp = 0;
@@ -32,7 +24,7 @@
def reset(self):
self.joyp = 0xFF;
- self.cycles = JOYPAD_CLOCK;
+ self.cycles = constants.JOYPAD_CLOCK;
def cycles(self):
@@ -45,17 +37,17 @@
if (self.driver.isRaised()):
self.update();
- self.cycles = JOYPAD_CLOCK;
+ self.cycles = constants.JOYPAD_CLOCK;
def write(self, address, data):
- if (address == JOYP):
+ if (address == constants.JOYP):
self.joyp = (self.joyp & 0xCF) + (data & 0x30);
self.update();
def read(self, address):
- if (address == JOYP):
+ if (address == constants.JOYP):
return self.joyp;
return 0xFF;
@@ -72,7 +64,7 @@
data |= 0x0F;
if ((self.joyp & ~data & 0x0F) != 0):
- self.interrupt.raiseInterrupt(Interrupt.JOYPAD);
+ self.interrupt.raiseInterrupt(constants.JOYPAD);
self.joyp = data;
Modified: pypy/branch/gameboy-emulator/pypy/lang/gameboy/ram.py
==============================================================================
--- pypy/branch/gameboy-emulator/pypy/lang/gameboy/ram.py (original)
+++ pypy/branch/gameboy-emulator/pypy/lang/gameboy/ram.py Thu Mar 13 13:57:30 2008
@@ -3,11 +3,11 @@
Work and High RAM
"""
+
+from pypy.lang.gameboy import constants
+
class RAM(object):
- WRAM_SIZE = 8192
- HIGH_SIZE = 128
-
# Work RAM
wram = []
@@ -18,13 +18,13 @@
self.reset();
def reset(self):
- self.wram = range(0, WRAM_SIZE)
- for index in range(0, WRAM_SIZE):
+ self.wram = range(0, constants.WRAM_SIZE)
+ for index in range(0, constants.WRAM_SIZE):
#TODO convert to byte
self.wram[index] = 0x00;
- self.hram = range(0, HIGH_SIZE)
- for index in range(0, HIGH_SIZE):
+ self.hram = range(0, constants.HIGH_SIZE)
+ for index in range(0, constants.HIGH_SIZE):
#TODO convert to byte
self.hram[index] = 0x00;
Modified: pypy/branch/gameboy-emulator/pypy/lang/gameboy/serial.py
==============================================================================
--- pypy/branch/gameboy-emulator/pypy/lang/gameboy/serial.py (original)
+++ pypy/branch/gameboy-emulator/pypy/lang/gameboy/serial.py Thu Mar 13 13:57:30 2008
@@ -2,64 +2,54 @@
Mario GameBoy (TM) Emulator
Serial Link Controller
"""
-class Serial(object):
- # Gameboy Clock Speed (1048576 Hz)
- GAMEBOY_CLOCK = 1 << 20;
-
- # Serial Clock Speed (8 x 1024 bits/sec)
- SERIAL_CLOCK = GAMEBOY_CLOCK >> 16;
-
- # Serial Idle Speed (128 Hz)
- SERIAL_IDLE_CLOCK = GAMEBOY_CLOCK >> 7;
+from pypy.lang.gameboy import constants
- # Serial Register Addresses
-
- SB = 0xFF01; #Serial Transfer Data */
- SC = 0xFF02; # Serial Transfer Control */
+class Serial(object):
# Registers
- sb = 0;
- sc = 0;
- cycles = 0;
+ sb = 0
+ sc = 0
+ cycles = 0
# Interrupt Controller #Interrupt
- interrupt = None;
+ interrupt = None
def __init__(self, interrupt):
- self.interrupt = interrupt;
- self.reset();
+ self.interrupt = interrupt
+ self.reset()
def reset(self):
- self.cycles = SERIAL_CLOCK;
- self.sb = 0x00;
- self.sc = 0x00;
+ self.cycles = constants.SERIAL_CLOCK
+ self.sb = 0x00
+ self.sc = 0x00
def cycles(self):
- return self.cycles;
+ return self.cycles
def emulate(self, ticks):
if ((self.sc & 0x81) == 0x81):
- self.cycles -= ticks;
+ self.cycles -= ticks
if (self.cycles <= 0):
- self.sb = 0xFF;
- self.sc &= 0x7F;
- self.cycles = SERIAL_IDLE_CLOCK;
+ self.sb = 0xFF
+ self.sc &= 0x7F
+ self.cycles = constants.SERIAL_IDLE_CLOCK
- self.interrupt.raiseInterrupt(Interrupt.SERIAL);
+ self.interrupt.raiseInterrupt(constants.SERIAL)
def setSerialData(self, data):
- self.sb = data;
+ self.sb = data
def setSerialControl(self, data):
- self.sc = data;
+ self.sc = data
# HACK: delay the serial interrupt (Shin Nihon Pro Wrestling)
- self.cycles = SERIAL_IDLE_CLOCK + SERIAL_CLOCK;
+ self.cycles = constants.SERIAL_IDLE_CLOCK + constants.SERIAL_CLOCK
def getSerialData(self):
- return self.sb;
+ return self.sb
def getSerialControl(self):
- return self.sc;
+ return self.sc
+
Modified: pypy/branch/gameboy-emulator/pypy/lang/gameboy/sound.py
==============================================================================
--- pypy/branch/gameboy-emulator/pypy/lang/gameboy/sound.py (original)
+++ pypy/branch/gameboy-emulator/pypy/lang/gameboy/sound.py Thu Mar 13 13:57:30 2008
@@ -4,50 +4,10 @@
Audio Processor Unit (Sharp LR35902 APU)
"""
+from pypy.lang.gameboy import constants
class Sound(object):
- # Gameboy Clock Speed (1048576 Hz)
-
- GAMEBOY_CLOCK = 1 << 20;
-
-
- # Sound Clock (256 Hz)
-
- SOUND_CLOCK = 256;
-
-
- # Sound Register Addresses
-
- NR10 = 0xFF10 # AUD1SWEEP */
- NR11 = 0xFF11 # AUD1LEN */
- NR12 = 0xFF12 # AUD1ENV */
- NR13 = 0xFF13 # AUD1LOW */
- NR14 = 0xFF14 # AUD1HIGH */
-
- NR21 = 0xFF16 # AUD2LEN */
- NR22 = 0xFF17 # AUD2ENV */
- NR23 = 0xFF18 # AUD2LOW */
- NR24 = 0xFF19 # AUD2HIGH */
-
- NR30 = 0xFF1A # AUD3ENA */
- NR31 = 0xFF1B # AUD3LEN */
- NR32 = 0xFF1C # AUD3LEVEL */
- NR33 = 0xFF1D # AUD3LOW */
- NR34 = 0xFF1E # AUD3HIGH */
-
- NR41 = 0xFF20 # AUD4LEN */
- NR42 = 0xFF21 # AUD4ENV */
- NR43 = 0xFF22 # AUD4POLY */
- NR44 = 0xFF23 # AUD4GO */
-
- NR50 = 0xFF24 # AUDVOL */
- NR51 = 0xFF25 # AUDTERM */
- NR52 = 0xFF26 # AUDENA */
-
- AUD3WAVERAM = 0xFF30;
-
-
# Audio Channel 1 int
nr10=0;
nr11=0;
@@ -141,44 +101,44 @@
self.updateAudio();
if (self.driver.isEnabled()):
self.frames += self.driver.getSampleRate();
- length = (self.frames / SOUND_CLOCK) << 1;
+ length = (self.frames / constants.SOUND_CLOCK) << 1;
self.mixAudio(self.buffer, length);
self.driver.write(self.buffer, length);
- self.frames %= SOUND_CLOCK;
+ self.frames %= constants.SOUND_CLOCK;
- self.cycles += GAMEBOY_CLOCK / SOUND_CLOCK;
+ self.cycles += constants.GAMEBOY_CLOCK / constants.SOUND_CLOCK;
def reset(self):
- self.cycles = GAMEBOY_CLOCK / SOUND_CLOCK;
+ self.cycles = constants.GAMEBOY_CLOCK / constants.SOUND_CLOCK;
self.frames = 0;
self.audio1Index = self.audio2Index = self.audio3Index = self.audio4Index = 0;
- self.write(NR10, 0x80);
- self.write(NR11, 0x3F); # 0xBF
- self.write(NR12, 0x00); # 0xF3
- self.write(NR13, 0xFF);
- self.write(NR14, 0xBF);
-
- self.write(NR21, 0x3F);
- self.write(NR22, 0x00);
- self.write(NR23, 0xFF);
- self.write(NR24, 0xBF);
-
- self.write(NR30, 0x7F);
- self.write(NR31, 0xFF);
- self.write(NR32, 0x9F);
- self.write(NR33, 0xFF);
- self.write(NR34, 0xBF);
-
- self.write(NR41, 0xFF);
- self.write(NR42, 0x00);
- self.write(NR43, 0x00);
- self.write(NR44, 0xBF);
-
- self.write(NR50, 0x00); # 0x77
- self.write(NR51, 0xF0);
- self.write(NR52, 0xFF); # 0xF0
+ self.write(constants.NR10, 0x80);
+ self.write(constants.NR11, 0x3F); # 0xBF
+ self.write(constants.NR12, 0x00); # 0xF3
+ self.write(constants.NR13, 0xFF);
+ self.write(constants.NR14, 0xBF);
+
+ self.write(constants.NR21, 0x3F);
+ self.write(constants.NR22, 0x00);
+ self.write(constants.NR23, 0xFF);
+ self.write(constants.NR24, 0xBF);
+
+ self.write(constants.NR30, 0x7F);
+ self.write(constants.NR31, 0xFF);
+ self.write(constants.NR32, 0x9F);
+ self.write(constants.NR33, 0xFF);
+ self.write(constants.NR34, 0xBF);
+
+ self.write(constants.NR41, 0xFF);
+ self.write(constants.NR42, 0x00);
+ self.write(constants.NR43, 0x00);
+ self.write(constants.NR44, 0xBF);
+
+ self.write(constants.NR50, 0x00); # 0x77
+ self.write(constants.NR51, 0xF0);
+ self.write(constants.NR52, 0xFF); # 0xF0
for address in range(0xFF30, 0xFF3F):
write = 0xFF
@@ -188,108 +148,108 @@
def read(self, address):
- if address==NR10:
+ if address==constants.NR10:
return self.getAudio1Sweep();
- elif address == NR11:
+ elif address == constants.NR11:
return self.getAudio1Length();
- elif address == NR12:
+ elif address == constants.NR12:
return self.getAudio1Envelope();
- elif address == NR13:
+ elif address == constants.NR13:
return self.getAudio1Frequency();
- elif address == NR14:
+ elif address == constants.NR14:
return self.getAudio1Playback();
- elif address == NR21:
+ elif address == constants.NR21:
return self.getAudio2Length();
- elif address == NR22:
+ elif address == constants.NR22:
return self.getAudio2Envelope();
- elif address==NR23:
+ elif address==constants.NR23:
return self.getAudio2Frequency();
- elif address==NR24:
+ elif address==constants.NR24:
return self.getAudio2Playback();
- elif address==NR30:
+ elif address==constants.NR30:
return self.getAudio3Enable();
- elif address==NR31:
+ elif address==constants.NR31:
return self.getAudio3Length();
- elif address==NR32:
+ elif address==constants.NR32:
return self.getAudio3Level();
- elif address==NR33:
+ elif address==constants.NR33:
return self.getAudio4Frequency();
- elif address==NR34:
+ elif address==constants.NR34:
return self.getAudio3Playback();
- elif address==NR41:
+ elif address==constants.NR41:
return self.getAudio4Length();
- elif address==NR42:
+ elif address==constants.NR42:
return self.getAudio4Envelope();
- elif address==NR43:
+ elif address==constants.NR43:
return self.getAudio4Polynomial();
- elif address==NR44:
+ elif address==constants.NR44:
return self.getAudio4Playback();
- elif address==NR50:
+ elif address==constants.NR50:
return self.getOutputLevel();
- elif address==NR51:
+ elif address==constants.NR51:
return self.getOutputTerminal();
- elif address==NR52:
+ elif address==constants.NR52:
return self.getOutputEnable();
- elif (address >= AUD3WAVERAM and address <= AUD3WAVERAM + 0x3F):
+ elif (address >= constants.AUD3WAVERAM and address <= constants.AUD3WAVERAM + 0x3F):
return self.getAudio3WavePattern(address);
return 0xFF;
def write(self, address, data):
- if address==NR10:
+ if address==constants.NR10:
self.setAudio1Sweep(data);
- elif address == NR11:
+ elif address == constants.NR11:
self.setAudio1Length(data);
- elif address == NR12:
+ elif address == constants.NR12:
self.setAudio1Envelope(data);
- elif address == NR13:
+ elif address == constants.NR13:
self.setAudio1Frequency(data);
- elif address == NR14:
+ elif address == constants.NR14:
self.setAudio1Playback(data);
- elif address == NR21:
+ elif address == constants.NR21:
self.setAudio2Length(data);
- elif address == NR22:
+ elif address == constants.NR22:
self.setAudio2Envelope(data);
- elif address == NR23:
+ elif address == constants.NR23:
self.setAudio2Frequency(data);
- elif address == NR24:
+ elif address == constants.NR24:
self.setAudio2Playback(data);
- elif address == NR30:
+ elif address == constants.NR30:
self.setAudio3Enable(data);
- elif address == NR31:
+ elif address == constants.NR31:
self.setAudio3Length(data);
- elif address == NR32:
+ elif address == constants.NR32:
self.setAudio3Level(data);
- elif address == NR33:
+ elif address == constants.NR33:
self.setAudio3Frequency(data);
- elif address == NR34:
+ elif address == constants.NR34:
self.setAudio3Playback(data);
- elif address == NR41:
+ elif address == constants.NR41:
self.setAudio4Length(data);
- elif address == NR42:
+ elif address == constants.NR42:
self.setAudio4Envelope(data);
- elif address == NR43:
+ elif address == constants.NR43:
self.setAudio4Polynomial(data);
- elif address == NR44:
+ elif address == constants.NR44:
self.setAudio4Playback(data);
- elif address == NR50:
+ elif address == constants.NR50:
self.setOutputLevel(data);
- elif address == NR51:
+ elif address == constants.NR51:
self.setOutputTerminal(data);
- elif address == NR52:
+ elif address == constants.NR52:
self.setOutputEnable(data);
- elif (address >= AUD3WAVERAM and address <= AUD3WAVERAM + 0x3F):
+ elif (address >= constants.AUD3WAVERAM and address <= constants.AUD3WAVERAM + 0x3F):
self.setAudio3WavePattern(address, data);
@@ -353,12 +313,12 @@
def setAudio1Sweep(self, data):
self.nr10 = data;
- self.audio1SweepLength = (SOUND_CLOCK / 128) * ((self.nr10 >> 4) & 0x07);
+ self.audio1SweepLength = (constants.SOUND_CLOCK / 128) * ((self.nr10 >> 4) & 0x07);
def setAudio1Length(self, data):
self.nr11 = data;
- self.audio1Length = (SOUND_CLOCK / 256) * (64 - (self.nr11 & 0x3F));
+ self.audio1Length = (constants.SOUND_CLOCK / 256) * (64 - (self.nr11 & 0x3F));
def setAudio1Envelope(self, data):
@@ -388,12 +348,12 @@
self.nr52 |= 0x01;
if ((self.nr14 & 0x40) != 0 and self.audio1Length == 0):
- self.audio1Length = (SOUND_CLOCK / 256) * (64 - (self.nr11 & 0x3F));
+ self.audio1Length = (constants.SOUND_CLOCK / 256) * (64 - (self.nr11 & 0x3F));
- self.audio1SweepLength = (SOUND_CLOCK / 128) * ((self.nr10 >> 4) & 0x07);
+ self.audio1SweepLength = (constants.SOUND_CLOCK / 128) * ((self.nr10 >> 4) & 0x07);
self.audio1Volume = self.nr12 >> 4;
- self.audio1EnvelopeLength = (SOUND_CLOCK / 64) * (self.nr12 & 0x07);
+ self.audio1EnvelopeLength = (constants.SOUND_CLOCK / 64) * (self.nr12 & 0x07);
def updateAudio1(self):
@@ -409,7 +369,7 @@
self.audio1Volume+=1;
elif (self.audio1Volume > 0):
self.audio1Volume-=1;
- self.audio1EnvelopeLength += (SOUND_CLOCK / 64) * (self.nr12 & 0x07);
+ self.audio1EnvelopeLength += (constants.SOUND_CLOCK / 64) * (self.nr12 & 0x07);
if (self.audio1SweepLength > 0):
self.audio1SweepLength-=1;
if (self.audio1SweepLength <= 0):
@@ -428,7 +388,7 @@
self.audio1Frequency = 0;
self.nr52 &= ~0x01;
- self.audio1SweepLength += (SOUND_CLOCK / 128) * ((self.nr10 >> 4) & 0x07);
+ self.audio1SweepLength += (constants.SOUND_CLOCK / 128) * ((self.nr10 >> 4) & 0x07);
def mixAudio1(self, buffer, length):
@@ -474,7 +434,7 @@
def setAudio2Length(self, data):
self.nr21 = data;
- self.audio2Length = (SOUND_CLOCK / 256) * (64 - (self.nr21 & 0x3F));
+ self.audio2Length = (constants.SOUND_CLOCK / 256) * (64 - (self.nr21 & 0x3F));
def setAudio2Envelope(self, data):
@@ -504,10 +464,10 @@
self.nr52 |= 0x02;
if ((self.nr24 & 0x40) != 0 and self.audio2Length == 0):
- self.audio2Length = (SOUND_CLOCK / 256) * (64 - (self.nr21 & 0x3F));
+ self.audio2Length = (constants.SOUND_CLOCK / 256) * (64 - (self.nr21 & 0x3F));
self.audio2Volume = self.nr22 >> 4;
- self.audio2EnvelopeLength = (SOUND_CLOCK / 64) * (self.nr22 & 0x07);
+ self.audio2EnvelopeLength = (constants.SOUND_CLOCK / 64) * (self.nr22 & 0x07);
@@ -526,7 +486,7 @@
self.audio2Volume+=1;
elif (self.audio2Volume > 0):
self.audio2Volume-=1;
- self.audio2EnvelopeLength += (SOUND_CLOCK / 64) * (self.nr22 & 0x07);
+ self.audio2EnvelopeLength += (constants.SOUND_CLOCK / 64) * (self.nr22 & 0x07);
def mixAudio2(self, buffer, length):
@@ -583,7 +543,7 @@
def setAudio3Length(self, data):
self.nr31 = data;
- self.audio3Length = (SOUND_CLOCK / 256) * (256 - self.nr31);
+ self.audio3Length = (constants.SOUND_CLOCK / 256) * (256 - self.nr31);
def setAudio3Level(self, data):
@@ -603,7 +563,7 @@
if ((self.nr34 & 0x80) != 0 and (self.nr30 & 0x80) != 0):
self.nr52 |= 0x04;
if ((self.nr34 & 0x40) != 0 and self.audio3Length == 0):
- self.audio3Length = (SOUND_CLOCK / 256) * (256 - self.nr31);
+ self.audio3Length = (constants.SOUND_CLOCK / 256) * (256 - self.nr31);
@@ -667,7 +627,7 @@
def setAudio4Length(self, data):
self.nr41 = data;
- self.audio4Length = (SOUND_CLOCK / 256) * (64 - (self.nr41 & 0x3F));
+ self.audio4Length = (constants.SOUND_CLOCK / 256) * (64 - (self.nr41 & 0x3F));
def setAudio4Envelope(self, data):
@@ -695,10 +655,10 @@
self.nr52 |= 0x08;
if ((self.nr44 & 0x40) != 0 and self.audio4Length == 0):
- self.audio4Length = (SOUND_CLOCK / 256) * (64 - (self.nr41 & 0x3F));
+ self.audio4Length = (constants.SOUND_CLOCK / 256) * (64 - (self.nr41 & 0x3F));
self.audio4Volume = self.nr42 >> 4;
- self.audio4EnvelopeLength = (SOUND_CLOCK / 64) * (self.nr42 & 0x07);
+ self.audio4EnvelopeLength = (constants.SOUND_CLOCK / 64) * (self.nr42 & 0x07);
self.audio4Index = 0;
@@ -720,7 +680,7 @@
elif (self.audio4Volume > 0):
self.audio4Volume-=1;
- self.audio4EnvelopeLength += (SOUND_CLOCK / 64) * (self.nr42 & 0x07);
+ self.audio4EnvelopeLength += (constants.SOUND_CLOCK / 64) * (self.nr42 & 0x07);
def mixAudio4(self, buffer, length):
@@ -782,7 +742,7 @@
# frequency = (4194304 / 32) / (2048 - period) Hz
for period in range(0, 2048):
- skip = (((GAMEBOY_CLOCK << 10) / sampleRate) << (22 - 8)) / (2048 - period);
+ skip = (((constants.GAMEBOY_CLOCK << 10) / sampleRate) << (22 - 8)) / (2048 - period);
if (skip >= (32 << 22)):
self.frequencyTable[period] = 0;
else:
@@ -796,7 +756,7 @@
divider = 1
if ratio != 0:
divider = 2 * ratio
- self.noiseFreqRatioTable[ratio] = (GAMEBOY_CLOCK / divider) * ((1 << 16) / sampleRate);
+ self.noiseFreqRatioTable[ratio] = (constants.GAMEBOY_CLOCK / divider) * ((1 << 16) / sampleRate);
Modified: pypy/branch/gameboy-emulator/pypy/lang/gameboy/timer.py
==============================================================================
--- pypy/branch/gameboy-emulator/pypy/lang/gameboy/timer.py (original)
+++ pypy/branch/gameboy-emulator/pypy/lang/gameboy/timer.py Thu Mar 13 13:57:30 2008
@@ -6,32 +6,6 @@
class Timer(object):
- # Gameboy Clock Speed (1048576 Hz)
-
- GAMEBOY_CLOCK = 1 << 20;
-
-
- # DIV Timer Speed (16384 Hz)
-
- DIV_CLOCK = GAMEBOY_CLOCK >> 14;
-
-
- # Timer Clock Speeds (4096, 262144, 65536 and 16384 Hz)
-
- TIMER_CLOCK = [ GAMEBOY_CLOCK >> 12,
- GAMEBOY_CLOCK >> 18,
- GAMEBOY_CLOCK >> 16,
- GAMEBOY_CLOCK >> 14 ];
-
-
- # Timer Register Addresses
-
- DIV = 0xFF04 # Divider Register */
- TIMA = 0xFF05 # Timer Counter */
- TMA = 0xFF06 # Timer Modulo */
- TAC = 0xFF07 # Timer Control */
-
-
# Registers
#int
div = 0;
@@ -54,31 +28,31 @@
def reset(self):
self.div = 0;
- self.dividerCycles = DIV_CLOCK;
+ self.dividerCycles = constants.DIV_CLOCK;
self.tima = self.tma = self.tac = 0x00;
- self.timerCycles = self.timerClock = TIMER_CLOCK[self.tac & 0x03];
+ self.timerCycles = self.timerClock = constants.TIMER_CLOCK[self.tac & 0x03];
def write(self, address, data):
- if address==DIV:
+ if address==constants.DIV:
self.setDivider(data);
- elif address==TIMA:
+ elif address==constants.TIMA:
self.setTimerCounter(data);
- elif address==TMA:
+ elif address==constants.TMA:
self.setTimerModulo(data);
- elif address==TAC:
+ elif address==constants.TAC:
self.setTimerControl(data);
def read(self, address):
- if address==DIV:
+ if address==constants.DIV:
return self.getDivider();
- elif address==TIMA:
+ elif address==constants.TIMA:
return self.getTimerCounter();
- elif address==TMA:
+ elif address==constants.TMA:
return self.getTimerModulo();
- elif address==TAC:
+ elif address==constants.TAC:
return self.getTimerControl();
return 0xFF;
@@ -98,7 +72,7 @@
def setTimerControl(self, data):
if ((self.tac & 0x03) != (data & 0x03)):
- self.timerCycles = self.timerClock = TIMER_CLOCK[data & 0x03];
+ self.timerCycles = self.timerClock = constants.TIMER_CLOCK[data & 0x03];
self.tac = data;
@@ -133,7 +107,7 @@
self.dividerCycles -= ticks;
while (self.dividerCycles <= 0):
self.div = (self.div + 1) & 0xFF;
- self.dividerCycles += DIV_CLOCK;
+ self.dividerCycles += constants.DIV_CLOCK;
@@ -147,5 +121,5 @@
if (self.tima == 0x00):
self.tima = self.tma;
- self.interrupt.raiseInterrupt(Interrupt.TIMER);
+ self.interrupt.raiseInterrupt(constants.TIMER);
Modified: pypy/branch/gameboy-emulator/pypy/lang/gameboy/video.py
==============================================================================
--- pypy/branch/gameboy-emulator/pypy/lang/gameboy/video.py (original)
+++ pypy/branch/gameboy-emulator/pypy/lang/gameboy/video.py Thu Mar 13 13:57:30 2008
@@ -1,82 +1,20 @@
"""
Mario GameBoy (TM) Emulator
- LCD Video Display Processor
+ constants.LCD Video Display Processor
"""
+from pypy.lang.gameboy import constants
class Video(object):
- # LCD Register Addresses
- LCDC = 0xFF40 #LCD Control */
- STAT = 0xFF41 #LCD Status */
- SCY = 0xFF42 #BG Scroll Y (0-255) */
- SCX = 0xFF43 #BG Scroll X (0-255) */
- LY = 0xFF44 #LCDC Y-Coordinate (0-153) */
- LYC = 0xFF45 #LY Compare */
- DMA = 0xFF46 #OAM DMA Transfer */
- BGP = 0xFF47 #BG Palette Data */
- OBP0 = 0xFF48 #Object Palette 0 Data */
- OBP1 = 0xFF49 #Object Palette 1 Data */
- WY = 0xFF4A #Window Y Position (0-143) */
- WX = 0xFF4B #Window X Position (0-166) */
-
- # OAM Register Addresses
- OAM_ADDR = 0xFE00;
- # OAM Object Attribute Map
- # (FE00..FE9F)
- OAM_SIZE = 0xA0
-
- # Video RAM Addresses
- VRAM_ADDR = 0x8000 #8KB Video RAM (8000..9FFF) */
- VRAM_SIZE = 0x2000
-
- # VRAM Tile Data/Maps Addresses
- VRAM_DATA_A = 0x0000
- # 4KB Tile Data
- # (8000..8FFF)
-
- VRAM_DATA_B = 0x0800
- # 4KB Tile Data
- # (8800..97FF)
-
-
- VRAM_MAP_A = 0x1800
- # 1KB BG Tile Map 0
- # (9800..9BFF)
-
- VRAM_MAP_B = 0x1C00
- # 1KB BG Tile Map 1
- # (9C00..9FFF)
-
-
- # Gameboy Clock Speed (1048576 Hz)
- GAMEBOY_CLOCK = 1 << 20
-
- # LCD Mode Durations
- MODE_0_TICKS = 50 #H-Blank */
- MODE_1_TICKS = 114 #V-Blank */
- MODE_2_TICKS = 20 #OAM */
- MODE_3_BEGIN_TICKS = 12 #Display */
- MODE_3_END_TICKS = 32 #Display */
- MODE_1_BEGIN_TICKS = 8 #V-Blank Line 144 */
- MODE_1_END_TICKS = 1 #V-Blank Line 153 */
-
- # Objects per Line
- OBJECTS_PER_LINE = 10
-
- # LCD Color Palette
- COLOR_MAP = [ 0x9CB916, 0x8CAA14, 0x306430, 0x103F10
- # 0xE0F8D0, 0x88C070, 0x386850, 0x081820
- # 0xFFFFFF, 0xAAAAAA, 0x555555, 0x000000
- ]
- # OAM Registers
+ # constants.OAM Registers
oam = [] #= new byte[OAM_SIZE]
- # Video RAM
+ # Video constants.RAM
vram = []#= new byte[VRAM_SIZE]
- # LCD Registers int
+ # constants.LCD Registers int
lcdc = 0
stat = 0
scy = 0
@@ -102,7 +40,7 @@
vblank = False
dirty = False
- # Line Buffer, OAM Cache and Color Palette
+ # Line Buffer, constants.OAM Cache and Color Palette
line = []#= new int[8 + 160 + 8]
objects = []#= new int[OBJECTS_PER_LINE]
palette = []#= new int[1024]
@@ -133,7 +71,7 @@
def reset(self):
- self.cycles = MODE_2_TICKS
+ self.cycles = constants.MODE_2_TICKS
self.lcdc = 0x91
self.stat = 2
@@ -152,79 +90,79 @@
self.vblank = True
self.dirty = True
- for index in range(0, VRAM_SIZE):
+ for index in range(0, constants.VRAM_SIZE):
self.vram[index] = 0x00
- for index in range(0, OAM_SIZE):
+ for index in range(0, constants.OAM_SIZE):
self.oam[index] = 0x00
def write(self, address, data):
# assert data >= 0x00 and data <= 0xFF
- if address == LCDC :
+ if address == constants.LCDC :
self.setControl(data)
- elif address == STAT:
+ elif address == constants.STAT:
self.setStatus(data)
- elif address == SCY:
+ elif address == constants.SCY:
self.setScrollY(data)
- elif address == SCX:
+ elif address == constants.SCX:
self.setScrollX(data)
- elif address == LY:
+ elif address == constants.LY:
# Read Only
pass
- elif address == LYC:
+ elif address == constants.LYC:
self.setLYCompare(data)
- elif address == DMA:
+ elif address == constants.DMA:
self.setDMA(data)
- elif address == BGP:
+ elif address == constants.BGP:
self.setBackgroundPalette(data)
- elif address == OBP0:
+ elif address == constants.OBP0:
self.setObjectPalette0(data)
- elif address == OBP1:
+ elif address == constants.OBP1:
self.setObjectPalette1(data)
- elif address == WY:
+ elif address == constants.WY:
self.setWindowY(data)
- elif address == WX:
+ elif address == constants.WX:
self.setWindowX(data)
else:
- if (address >= OAM_ADDR and address < OAM_ADDR + OAM_SIZE):
+ if (address >= constants.OAM_ADDR and address < constants.OAM_ADDR + constants.OAM_SIZE):
#TODO convert to byte
- self.oam[address - OAM_ADDR] = data
- elif (address >= VRAM_ADDR and address < VRAM_ADDR + VRAM_SIZE):
+ self.oam[address - constants.OAM_ADDR] = data
+ elif (address >= constants.VRAM_ADDR and address < constants.VRAM_ADDR + constants.VRAM_SIZE):
#TODO convert to byte
- self.vram[address - VRAM_ADDR] =data
+ self.vram[address - constants.VRAM_ADDR] =data
def read(self, address):
- if address == LCDC:
+ if address == constants.LCDC:
return self.getControl()
- elif address == STAT:
+ elif address == constants.STAT:
return self.getStatus()
- elif address == SCY:
+ elif address == constants.SCY:
return self.getScrollY()
- elif address == SCX:
+ elif address == constants.SCX:
return self.getScrollX()
- elif address == LY:
+ elif address == constants.LY:
return self.getLineY()
- elif address == LYC:
+ elif address == constants.LYC:
return self.getLineYCompare()
- elif address == DMA:
+ elif address == constants.DMA:
return self.getDMA()
- elif address == BGP:
+ elif address == constants.BGP:
return self.getBackgroundPalette()
- elif address == OBP0:
+ elif address == constants.OBP0:
return self.getObjectPalette0()
- elif address == OBP1:
+ elif address == constants.OBP1:
return self.getObjectPalette1()
- elif address == WY:
+ elif address == constants.WY:
return self.getWindowY()
- elif address == WX:
+ elif address == constants.WX:
return self.getWindowX()
else:
- if (address >= OAM_ADDR and address < OAM_ADDR + OAM_SIZE):
- return self.oam[address - OAM_ADDR] & 0xFF
- elif (address >= VRAM_ADDR and address < VRAM_ADDR + VRAM_SIZE):
- return self.vram[address - VRAM_ADDR] & 0xFF
+ if (address >= constants.OAM_ADDR and address < constants.OAM_ADDR + constants.OAM_SIZE):
+ return self.oam[address - constants.OAM_ADDR] & 0xFF
+ elif (address >= constants.VRAM_ADDR and address < constants.VRAM_ADDR + constants.VRAM_SIZE):
+ return self.vram[address - constants.VRAM_ADDR] & 0xFF
return 0xFF
@@ -297,16 +235,16 @@
def setControl(self, data):
if ((self.lcdc & 0x80) != (data & 0x80)):
- # NOTE: do not reset LY=LYC flag (bit 2) of the STAT register (Mr.
+ # constants.NOTE: do not reset constants.LY=LYC flag (bit 2) of the constants.STAT register (Mr.
# Do!)
if ((data & 0x80) != 0):
self.stat = (self.stat & 0xFC) | 0x02
- self.cycles = MODE_2_TICKS
+ self.cycles = constants.MODE_2_TICKS
self.ly = 0
self.display = False
else:
self.stat = (self.stat & 0xFC) | 0x00
- self.cycles = MODE_1_TICKS
+ self.cycles = constants.MODE_1_TICKS
self.ly = 0
self.clearFrame()
@@ -323,7 +261,7 @@
self.stat = (self.stat & 0x87) | (data & 0x78)
# Gameboy Bug
if ((self.lcdc & 0x80) != 0 and (self.stat & 0x03) == 0x01 and (self.stat & 0x44) != 0x44):
- self.interrupt.raiseInterrupt(Interrupt.LCD)
+ self.interrupt.raiseInterrupt(constants.LCD)
def setScrollY(self, data):
@@ -338,20 +276,20 @@
self.lyc = data
if ((self.lcdc & 0x80) != 0):
if (self.ly == self.lyc):
- # NOTE: raise interrupt once per line (Prehistorik Man, The
+ # constants.NOTE: raise interrupt once per line (Prehistorik Man, The
# Jetsons, Muhammad Ali)
if ((self.stat & 0x04) == 0):
- # LYC=LY interrupt
+ # constants.LYC=LY interrupt
self.stat |= 0x04
if ((self.stat & 0x40) != 0):
- self.interrupt.raiseInterrupt(Interrupt.LCD)
+ self.interrupt.raiseInterrupt(constants.LCD)
else:
self.stat &= 0xFB
def setDMA(self, data):
self.dma = data
- for index in range(0, OAM_SIZE):
+ for index in range(0, constants.OAM_SIZE):
#TODO convert to byte
self.oam[index] = self.memory.read((self.dma << 8) + index)
@@ -384,7 +322,7 @@
def emulateOAM(self):
self.stat = (self.stat & 0xFC) | 0x03
- self.cycles += MODE_3_BEGIN_TICKS
+ self.cycles += constants.MODE_3_BEGIN_TICKS
self.transfer = True
@@ -393,32 +331,32 @@
if (self.display):
self.drawLine()
self.stat = (self.stat & 0xFC) | 0x03
- self.cycles += MODE_3_END_TICKS
+ self.cycles += constants.MODE_3_END_TICKS
self.transfer = False
else:
self.stat = (self.stat & 0xFC) | 0x00
- self.cycles += MODE_0_TICKS
+ self.cycles += constants.MODE_0_TICKS
# H-Blank interrupt
if ((self.stat & 0x08) != 0 and (self.stat & 0x44) != 0x44):
- self.interrupt.raiseInterrupt(Interrupt.LCD)
+ self.interrupt.raiseInterrupt(constants.LCD)
def emulateHBlank(self):
self.ly+=1
if (self.ly == self.lyc):
- # LYC=LY interrupt
+ # constants.LYC=LY interrupt
self.stat |= 0x04
if ((self.stat & 0x40) != 0):
- self.interrupt.raiseInterrupt(Interrupt.LCD)
+ self.interrupt.raiseInterrupt(constants.LCD)
else:
self.stat &= 0xFB
if (self.ly < 144):
self.stat = (self.stat & 0xFC) | 0x02
- self.cycles += MODE_2_TICKS
- # OAM interrupt
+ self.cycles += constants.MODE_2_TICKS
+ # constants.OAM interrupt
if ((self.stat & 0x20) != 0 and (self.stat & 0x44) != 0x44):
- self.interrupt.raiseInterrupt(Interrupt.LCD)
+ self.interrupt.raiseInterrupt(constants.LCD)
else:
if (self.display):
self.drawFrame()
@@ -430,7 +368,7 @@
self.display = False
self.stat = (self.stat & 0xFC) | 0x01
- self.cycles += MODE_1_BEGIN_TICKS
+ self.cycles += constants.MODE_1_BEGIN_TICKS
self.vblank = True
@@ -439,35 +377,35 @@
self.vblank = False
self.stat = (self.stat & 0xFC) | 0x01
- self.cycles += MODE_1_TICKS - MODE_1_BEGIN_TICKS
+ self.cycles += constants.MODE_1_TICKS - constants.MODE_1_BEGIN_TICKS
# V-Blank interrupt
if ((self.stat & 0x10) != 0):
- self.interrupt.raiseInterrupt(Interrupt.LCD)
+ self.interrupt.raiseInterrupt(constants.LCD)
# V-Blank interrupt
- self.interrupt.raiseInterrupt(Interrupt.VBLANK)
+ self.interrupt.raiseInterrupt(constants.VBLANK)
elif (self.ly == 0):
self.stat = (self.stat & 0xFC) | 0x02
- self.cycles += MODE_2_TICKS
- # OAM interrupt
+ self.cycles += constants.MODE_2_TICKS
+ # constants.OAM interrupt
if ((self.stat & 0x20) != 0 and (self.stat & 0x44) != 0x44):
- self.interrupt.raiseInterrupt(Interrupt.LCD)
+ self.interrupt.raiseInterrupt(constants.LCD)
else:
if (self.ly < 153):
self.ly+=1
self.stat = (self.stat & 0xFC) | 0x01
if (self.ly == 153):
- self.cycles += MODE_1_END_TICKS
+ self.cycles += constants.MODE_1_END_TICKS
else:
- self.cycles += MODE_1_TICKS
+ self.cycles += constants.MODE_1_TICKS
else:
self.ly = self.wly = 0
self.stat = (self.stat & 0xFC) | 0x01
- self.cycles += MODE_1_TICKS - MODE_1_END_TICKS
+ self.cycles += constants.MODE_1_TICKS - constants.MODE_1_END_TICKS
if (self.ly == self.lyc):
- # LYC=LY interrupt
+ # constants.LYC=LY interrupt
self.stat |= 0x04
if ((self.stat & 0x40) != 0):
- self.interrupt.raiseInterrupt(Interrupt.LCD)
+ self.interrupt.raiseInterrupt(constants.LCD)
else:
self.stat &= 0xFB
@@ -502,12 +440,12 @@
y = (self.scy + self.ly) & 0xFF
x = self.scx & 0xFF
- tileMap = VRAM_MAP_A
+ tileMap = constants.VRAM_MAP_A
if (self.lcdc & 0x08) != 0:
- tileMap = VRAM_MAP_B
- tileData = VRAM_DATA_B
+ tileMap = constants.VRAM_MAP_B
+ tileData = constants.VRAM_DATA_B
if (self.lcdc & 0x10) != 0:
- tileData = VRAM_DATA_A
+ tileData = constants.VRAM_DATA_A
tileMap += ((y >> 3) << 5) + (x >> 3)
tileData += (y & 7) << 1
@@ -516,12 +454,12 @@
def drawWindow(self):
if (self.ly >= self.wy and self.wx < 167 and self.wly < 144):
- tileMap = VRAM_MAP_A
+ tileMap = constants.VRAM_MAP_A
if (self.lcdc & 0x40) != 0:
- tileMap = VRAM_MAP_B
- tileData = VRAM_DATA_B
+ tileMap = constants.VRAM_MAP_B
+ tileData = constants.VRAM_DATA_B
if (self.lcdc & 0x10) != 0:
- tileData = VRAM_DATA_A
+ tileData = constants.VRAM_DATA_A
tileMap += (self.wly >> 3) << 5
tileData += (self.wly & 7) << 1
@@ -574,7 +512,7 @@
if ((flags & 0x40) != 0):
y = 7 - y
self.objects[count] = (x << 24) + (count << 20) + (flags << 12) + ((tile << 4) + (y << 1))
- if (++count >= OBJECTS_PER_LINE):
+ if (++count >= constants.OBJECTS_PER_LINE):
break
self.sortScanObject(count)
return count
@@ -765,24 +703,24 @@
pixels = self.driver.getPixels()
length = self.driver.getWidth() * self.driver.getHeight()
for offset in range(0, length):
- pixels[offset] = COLOR_MAP[0]
+ pixels[offset] = constants.COLOR_MAP[0]
def updatePalette(self):
if (not self.dirty):
return
- # bit 4/0 = BG color, bit 5/1 = OBJ color, bit 2 = OBJ palette, bit
- # 3 = OBJ priority
+ # bit 4/0 = constants.BG color, bit 5/1 = constants.OBJ color, bit 2 = constants.OBJ palette, bit
+ # 3 = constants.OBJ priority
for pattern in range(0, 64):
#color
if ((pattern & 0x22) == 0 or ((pattern & 0x08) != 0 and (pattern & 0x11) != 0)):
- # OBJ behind BG color 1-3
+ # constants.OBJ behind constants.BG color 1-3
color = (self.bgp >> ((((pattern >> 3) & 0x02) + (pattern & 0x01)) << 1)) & 0x03
- # OBJ above BG
+ # constants.OBJ above constants.BG
elif ((pattern & 0x04) == 0):
color = (self.obp0 >> ((((pattern >> 4) & 0x02) + ((pattern >> 1) & 0x01)) << 1)) & 0x03
else:
color = (self.obp1 >> ((((pattern >> 4) & 0x02) + ((pattern >> 1) & 0x01)) << 1)) & 0x03
- self.palette[((pattern & 0x30) << 4) + (pattern & 0x0F)] = COLOR_MAP[color]
+ self.palette[((pattern & 0x30) << 4) + (pattern & 0x0F)] = constants.COLOR_MAP[color]
self.dirty = False
More information about the Pypy-commit
mailing list