class ROMTests(unittest.TestCase):
def setUp(self):
gba = console_lookup("GBA")
self.roms_console = gba
self.rom = ROM("/Users/scottrice/ROMs/GBA/Pokemon Emerald.gba", gba)
self.noext_rom = ROM("/Users/scottrice/ROMs/GBA/Pokemon Emerald", gba)
def test_name(self):
"""
Name should be the name of the ROM file minus the extension.
If the ROM has no extension, then the name should just be the name of
the ROM file
"""
self.assertEqual(self.rom.name(), "Pokemon Emerald")
self.assertEqual(self.noext_rom.name(), "Pokemon Emerald")
def test_executable(self):
"""
The executable should be a file in the executables directory with the
same name as the ROM. On Windows, this file should end with a .cmd file
extension. On Mac/Linux systems, it should end with a .sh
"""
rom_exe_location = self.rom.executable_path()
# Assert that the exe is in the exe directory for it's console
self.assertEqual(os.path.dirname(rom_exe_location),
self.roms_console.executables_directory())
# Assert that the exe name is the same as the ROM name with the correct
# extension for the current platform
if sys.platform.startswith('win'):
self.assertEqual(os.path.basename(rom_exe_location),
self.rom.name() + ".cmd")
else:
self.assertEqual(os.path.basename(rom_exe_location),
self.rom.name() + ".sh")
def __init__(self, params):
super(ModelCell, self).__init__()
self.device = torch.device("cpu")
if torch.cuda.is_available():
self.device = torch.device("cuda")
# set params
self.params = params
# create memory
self.memory = ROM(params.memory_n, params.memory_m)
# create controller
self.controller = LSTMController(
params.sequence_width + 1 + self.memory.M, params.controller_size,
params.controller_layers)
# create state
self.state = State(self.memory, self.controller)
# create FC layer for addressing using controller output
self.addressing_params_sizes = [self.memory.M, 1, 1, 3, 1]
self.fc1 = nn.Sequential(
nn.Linear(params.controller_size, sum(
self.addressing_params_sizes))) # no sigmoid needed here.
# create FC layer to make output from controller output and read value
self.fc2 = nn.Sequential(
nn.Linear(params.controller_size + self.memory.M,
params.sequence_width + 1), nn.Sigmoid())
self.to(self.device)
class ROMTests(unittest.TestCase):
def setUp(self):
gba = Console("GBA", "Gameboy Advance")
self.roms_console = gba
self.rom = ROM("/Users/scottrice/ROMs/GBA/Pokemon Emerald.gba",gba)
self.noext_rom = ROM("/Users/scottrice/ROMs/GBA/Pokemon Emerald",gba)
def test_name(self):
"""
Name should be the name of the ROM file minus the extension.
If the ROM has no extension, then the name should just be the name of
the ROM file
"""
self.assertEqual(self.rom.name(),"Pokemon Emerald")
self.assertEqual(self.noext_rom.name(),"Pokemon Emerald")
def test_executable(self):
"""
The executable should be a file in the executables directory with the
same name as the ROM. On Windows, this file should end with a .cmd file
extension. On Mac/Linux systems, it should end with a .sh
"""
rom_exe_location = self.rom.executable_path()
# Assert that the exe is in the exe directory for it's console
self.assertEqual(os.path.dirname(rom_exe_location),self.roms_console.executables_directory())
# Assert that the exe name is the same as the ROM name with the correct
# extension for the current platform
if sys.platform.startswith('win'):
self.assertEqual(os.path.basename(rom_exe_location),self.rom.name() + ".cmd")
else:
self.assertEqual(os.path.basename(rom_exe_location),self.rom.name() + ".sh")
def __init__(self, params):
super(ModelCell, self).__init__()
self.device = torch.device("cpu")
if torch.cuda.is_available():
self.device = torch.device("cuda")
# set params
self.params = params
# create memory
self.memory = ROM(params.memory_n, params.memory_m)
# create controller
self.controller = LSTMController(self.memory.M, params.controller_size,
params.controller_layers)
# create state
self.state = State(self.memory, self.controller)
# create variational model
self.vmodel = params.variationalmodel(params.sequence_width,
params.variational_hidden_size,
params.memory_m, params.memory_m)
# create FC layer for addressing using controller output
self.addressing_params_sizes = [self.memory.M, 1, 1, 3, 1]
self.fc1 = nn.Linear(params.controller_size,
sum(self.addressing_params_sizes))
self.to(self.device)
def test_zexdoc(self):
print(">>> RUNNING ZEXDOC")
debugger = Debugger()
debugger.stopOnError = False
debugger.setHook(0x5, self.systemFunction)
debugger.setHook(0x0, self.stop)
rom = ROM(mapAt=0x100)
rom.loadFrom('./zexdoc.com', False)
cpu = CPU(rom=rom, debugger=debugger)
cpu.SP = 0xF000
cpu.run(0x100)
self.assertTrue(True)
class NES(object):
def __init__(self):
self.cpu = CPU()
self.rom = ROM()
def load_rom(self, rom_path):
with open(rom_path, 'rb') as f:
self.rom.load_rom(f.read())
def start(self):
for instruction in self.rom.PRG_ROM:
self.cpu.process_instruction(instruction)
class ModelCell(nn.Module):
def __init__(self, params):
super(ModelCell, self).__init__()
self.device = torch.device("cpu")
if torch.cuda.is_available():
self.device = torch.device("cuda")
# set params
self.params = params
# create memory
self.memory = ROM(params.memory_n, params.memory_m)
# create controller
self.controller = LSTMController(
params.sequence_width + 1 + self.memory.M, params.controller_size,
params.controller_layers)
# create state
self.state = State(self.memory, self.controller)
# create FC layer for addressing using controller output
self.addressing_params_sizes = [self.memory.M, 1, 1, 3, 1]
self.fc1 = nn.Sequential(
nn.Linear(params.controller_size, sum(
self.addressing_params_sizes))) # no sigmoid needed here.
# create FC layer to make output from controller output and read value
self.fc2 = nn.Sequential(
nn.Linear(params.controller_size + self.memory.M,
params.sequence_width + 1), nn.Sigmoid())
self.to(self.device)
def reset_parameters(self, stdv=1e-1):
for weight in self.parameters():
weight.data.normal_(0, stdv)
def forward(self, X):
cout, self.state.controllerstate.state = self.controller(
torch.cat([X, self.state.readstate.r], dim=1),
self.state.controllerstate.state)
address_params = self.fc1(cout)
k, beta, g, s, gamma = _split_cols(address_params,
self.addressing_params_sizes)
self.state.readstate.w = self.memory.address(k, beta, g, s, gamma,
self.state.readstate.w)
self.state.readstate.r = self.memory.read(self.state.readstate.w)
self.memory.write(X)
outp = self.fc2(torch.cat([cout, self.state.readstate.r], dim=1))
return outp
def __open_rom_dialog(self, evt):
path = self.view.show_file_dialog()
if path:
try:
with open(path, 'rb') as file:
if path.endswith(".nes") or path.endswith(".NES"):
self.emu.set_rom(ROM(file, True))
elif path.endswith(".dat") or path.endswith(".DAT"):
self.emu.set_rom(ROM(file, False))
self.__refresh_rom()
except IOError:
wx.LogError("Cannot open file: '%s'." % path)
self.__set_code_button(self.emu.has_rom())
class ROMTests(unittest.TestCase):
def setUp(self):
gba = Console("GBA", "Gameboy Advance")
self.roms_console = gba
self.rom = ROM("/Users/scottrice/ROMs/GBA/Pokemon Emerald.gba",gba)
self.noext_rom = ROM("/Users/scottrice/ROMs/GBA/Pokemon Emerald",gba)
def test_name(self):
"""
Name should be the name of the ROM file minus the extension.
If the ROM has no extension, then the name should just be the name of
the ROM file
"""
self.assertEqual(self.rom.name(),"Pokemon Emerald")
self.assertEqual(self.noext_rom.name(),"Pokemon Emerald")
def test_lra_does_modify_value_correctly(self):
cpu = CPU(ROM(b'\x17'))
cpu.A = 0b01110110
cpu.CFlag = True
cpu.readOp()
self.assertEqual(0b11101101, cpu.A)
self.assertFalse(cpu.CFlag)
def test_sbc_a_b_correctly_calculates_result(self):
cpu = CPU(ROM(b'\x98'))
cpu.A = 0x40
cpu.B = 0x3f
cpu.CFlag = Bits.set()
cpu.readOp()
self.assertEqual(0, cpu.A)
def test_sbc_hl_de_that_overflows_sets_pv_flag(self):
cpu = CPU(ROM(b'\xed\x52'))
cpu.HL = 0x8000
cpu.DE = 0x1111
cpu.PVFlag = False
cpu.readOp()
self.assertTrue(cpu.PVFlag)
def test_sbc_hl_de_that_does_not_overflows_resets_pv_flag(self):
cpu = CPU(ROM(b'\xed\x52'))
cpu.HL = 0xaaaa
cpu.DE = 0xbbbb
cpu.PVFlag = True
cpu.readOp()
self.assertFalse(cpu.PVFlag)
def test_sbc_hl_de_that_results_in_value_greater_than_zero_resets_s_flag(self):
cpu = CPU(ROM(b'\xed\x52'))
cpu.HL = 0x1000
cpu.DE = 0x0999
cpu.SFLag = True
cpu.readOp()
self.assertFalse(cpu.SFlag)
def test_call_not_s_jumps_if_SFlag_is_not_set(self):
cpu = CPU(ROM(b'\x00' * 0x1A47 + b'\xf4\x20\x15'))
cpu.PC = 0x1A47
cpu.SP = 0x3002
cpu.SFlag = False
cpu.readOp()
self.assertEqual(0x1520, cpu.PC)
def test_ld_hl_E_correctly_stores_value_from_given_address_to_hl(self):
ram = RAM()
cpu = CPU(ROM(b'\x73'), ram)
cpu.HL = 0x2000
cpu.E = 0x20
cpu.readOp()
self.assertEqual(0x20, ram[0x2000])
def test_sbc_a_c_without_c_calculates_results(self):
cpu = CPU(ROM(b'\x99'))
cpu.A = 0x40
cpu.C = 0x3f
cpu.CFlag = Bits.reset()
cpu.readOp()
self.assertEqual(1, cpu.A)
def test_sbc_hl_de_sets_n_flag(self):
cpu = CPU(ROM(b'\xed\x52'))
cpu.HL = 0x9999
cpu.DE = 0x1223
cpu.NFlag = False
cpu.readOp()
self.assertTrue(cpu.NFlag)
def test_sbc_a_d_sets_SFlag_when_result_is_below_zero(self):
cpu = CPU(ROM(b'\x9a'))
cpu.A = 0x40
cpu.D = 0x44
cpu.CFlag = Bits.reset()
cpu.readOp()
self.assertTrue(cpu.SFlag)
def test_sbc_hl_de_that_results_in_value_less_than_zero_set_s_flag(self):
cpu = CPU(ROM(b'\xed\x52'))
cpu.HL = 0x1000
cpu.DE = 0x1002
cpu.SFlag = False
cpu.readOp()
self.assertTrue(cpu.SFlag)
def test_and_a_resets_n_and_c_flag(self):
cpu = CPU(ROM(b'\xa7'))
cpu.CFlag = True
cpu.NFlag = True
cpu.readOp()
self.assertFalse(cpu.CFlag)
self.assertFalse(cpu.NFlag)
def test_sbc_hl_de_that_does_generate_borrow_sets_c_flag(self):
cpu = CPU(ROM(b'\xed\x52'))
cpu.HL = 0x1000
cpu.DE = 0x2000
cpu.CFlag = False
cpu.readOp()
self.assertTrue(cpu.CFlag)
def test_sbc_a_e_sets_ZFlag_when_result_is_zero(self):
cpu = CPU(ROM(b'\x9b'))
cpu.A = 0x44
cpu.E = 0x44
cpu.CFlag = Bits.reset()
cpu.readOp()
self.assertTrue(cpu.ZFlag)
def test_sbc_hl_de_that_does_not_generate_carry_on_12bit_resets_h_flag(self):
cpu = CPU(ROM(b'\xed\x52'))
cpu.HL = 0x0910
cpu.DE = 0x0100
cpu.HFlag = True
cpu.readOp()
self.assertFalse(cpu.HFlag)
def test_sbc_hl_de_that_does_generate_carry_on_12th_bit_set_h_flag(self):
cpu = CPU(ROM(b'\xed\x52'))
cpu.HL = 0x1000
cpu.DE = 0x0001
cpu.HFlag = False
cpu.readOp()
self.assertTrue(cpu.HFlag)
def main():
# Set up command line arguments parser
parser = argparse.ArgumentParser(description='NES Emulator')
parser.add_argument('rom_path',
metavar='R',
type=str,
help='The location to the rom file')
args = parser.parse_args()
# load rom
with open(args.rom_path, 'rb') as file:
rom_bytes = file.read()
rom = ROM(rom_bytes)
# create ram
ram = RAM()
# create ppu
ppu = PPU()
# create cpu
cpu = CPU(ram, ppu)
cpu.start_up()
cpu.run_rom(rom)
def test_sbc_hl_de_that_results_zero_sets_z_flag(self):
cpu = CPU(ROM(b'\xed\x52'))
cpu.HL = 0x9999
cpu.DE = 0x9999
cpu.ZFlag = False
cpu.readOp()
self.assertTrue(cpu.ZFlag)
def test_sbc_hl_bc_result_is_crrect_if_c_flag_is_reset(self):
cpu = CPU(ROM(b'\xed\x42'))
cpu.HL = 0x9999
cpu.BC = 0x1111
cpu.CFlag = False
cpu.readOp()
self.assertEqual(0x8888, cpu.HL)
def test_sbc_hl_de_result_is_correct_if_c_flag_is_set(self):
cpu = CPU(ROM(b'\xed\x52'))
cpu.HL = 0x9999
cpu.DE = 0x1111
cpu.CFlag = True
cpu.readOp()
self.assertEqual(0x8887, cpu.HL)
def test_sbc_a_mem_hl_correctly_calculates_value(self):
cpu = CPU(ROM(b'\x9e\x00\x00\x22'))
cpu.A = 0x23
cpu.HL = 0x3
cpu.CFlag = Bits.set()
cpu.readOp()
self.assertEqual(0, cpu.A)
def test_ld_bc_a_loads_corect_value(self):
ram = RAM()
cpu = CPU(ROM(b'\x02'), ram)
cpu.A = 0x7a
cpu.BC = 0x1212
cpu.readOp()
self.assertEqual(0x7a, cpu.ram[cpu.BC])
def test_sbc_hl_de_that_does_not_generate_borrow_resets_c_flag(self):
cpu = CPU(ROM(b'\xed\x52'))
cpu.HL = 0x1000
cpu.DE = 0x0999
cpu.CFlag = True
cpu.readOp()
self.assertFalse(cpu.CFlag)
def test_name(self):
prefix = "Any Text"
gba = Console("Gameboy Advance")
prefix_gba = Console("Gameboy Advance", { "prefix": prefix })
empty_prefix_gba = Console("Gameboy Advance", {"prefix": "" })
rom_path = "/Users/scottrice/ROMs/GBA/Pokemon Emerald.gba"
rom = ROM(rom_path, gba)
prefix_rom = ROM(rom_path, prefix_gba)
empty_prefix_rom = ROM(rom_path, empty_prefix_gba)
# With no prefix, the name should be the same as the basename
self.assertEqual(rom.name(), "Pokemon Emerald")
# When the prefix is the empty string, it should be treated as if no
# prefix was given
self.assertEqual(empty_prefix_rom.name(), "Pokemon Emerald")
# When the console has a prefix, the ROM should begin with that string
self.assertTrue(prefix_rom.name().startswith(prefix))
def test_basename(self):
"""
Basename should be the name of the ROM file minus the extension.
If the ROM has no extension, then the name should just be the name of
the ROM file
"""
gba = Console("Gameboy Advance")
prefix_gba = Console("Gameboy Advance", { "prefix":"Any Text" })
rom_path = "/Users/scottrice/ROMs/GBA/Pokemon Emerald.gba"
noext_rom_path = "/Users/scottrice/ROMs/GBA/Pokemon Emerald"
rom = ROM(rom_path,gba)
noext_rom = ROM(noext_rom_path,gba)
prefix_rom = ROM(rom_path, prefix_gba)
# Standard situation
self.assertEqual(rom.basename(),"Pokemon Emerald")
# Should correctly figure out the basename when the ROM has no extension
self.assertEqual(noext_rom.basename(),"Pokemon Emerald")
# The basename shouldn't include the prefix
self.assertEqual(prefix_rom.basename(), "Pokemon Emerald")
return b1,b2
print "Split: %s:%s -> %s:%s,%s:%s"%(self.addr,self.endaddr,b1.addr,b1.endaddr,b2.addr,b2.endaddr)
def contains(self,addr):
if addr<self.addr:
return False
if addr>=self.endaddr:
return False
return True
def UtoS(n):
if n<0x80:
return n
return -(0x100-n)
disasmd={}
if __name__=="__main__":
rom=ROM()
with open('pacman.nes','rb') as f:
rom.load(f)
#rom.prgbanks[0][0x30C3:0x30C8]=[0xA2,0x00,0xA0,0x00,0xA1,0xAA,0xB1,0x55,0x60]
labels={rom.read16(0xFFFA):['nmi',CODE,False],rom.read16(0xFFFC):['rst',CODE,False],rom.read16(0xFFFE):['irq',CODE,False]}
#labels={rom.read16(0xFFFC):['rst',CODE,False]}
#labels={0xF0C3:['rst',CODE,False]}
toprocess=[i for i in labels.keys()]
blocks={}
jumptables=[[0xC267,4],[0xC52E,12],[0xC7A1,3],[0xCAD7,9],[0xD40E,4],[0xD596,5],[0xD601,4],[0xD6DE,4]]
while len(toprocess)>0:
k=toprocess.pop()
if k in blocks:
continue
b1=None
for i in blocks.values():
def setUp(self):
gba = console_lookup("GBA")
self.roms_console = gba
self.rom = ROM("/Users/scottrice/ROMs/GBA/Pokemon Emerald.gba",gba)
self.noext_rom = ROM("/Users/scottrice/ROMs/GBA/Pokemon Emerald",gba)
CODE=1
DATA=2
JTT=4
JT=8
CC=16
PC=32
def UtoS(n):
if n<0x80:
return n
return -(0x100-n)
disasmd={}
if __name__=="__main__":
rom=ROM()
with open('C:\\users\\Andrew.Sentman\\workspace\\AIIEmu\\tests\\pacman.nes','rb') as f:
rom.load(f)
labels={rom.read16(0xFFFA):['nmi',CODE,False],rom.read16(0xFFFD):['rst',CODE,False],rom.read16(0xFFFE):['irq',CODE,False]}
jumptables=[[0xC267,4],[0xC52E,12],[0xC7A1,3],[0xCAD7,9],[0xD40E,4],[0xD596,5],[0xD601,4],[0xD6DE,4]]
byteflags=[0]*0x10000
for i in jumptables:
for j in xrange(i[0],i[0]+i[1]*2):
byteflags[j]|=JT
for j in xrange(i[1]):
taddr=rom.read16(i[0]+j*2)
if taddr not in labels:
labels[taddr]=['__'+hex(taddr),CODE|JTT,False]
else:
labels[taddr][1]|=CODE|JTT
#print labels
inloc=NodeLocImmediate(self.bytes[1])
if self.op[0]=='AND':
ast.append(NodeAssign(NodeLocReg('A'),NodeAND(NodeLocReg('A'),inloc)))
ast.append(NodeAssign(NodeLocReg('fS'),NodeBit(NodeLocReg('A'),7)))
ast.append(NodeAssign(NodeLocReg('fZ'),NodeEqual(NodeLocReg('A'),NodeLocImmediate(0))))
return ast
if self.op[0] in ['LDA','LDX','LDY']:
ast.append(NodeAssign(NodeLocReg(self.op[0][2]),inloc))
return ast
if self.op[5]==STO:
if self.op[1]==ZP:
return [NodeWrite(NodeLocAbsolute(self.bytes[1]),NodeLocReg(self.op[0][2]))]
if self.op[5]==JSR:
return [NodeBranch(NodeLocAbsolute(self.bytes[1]+(self.bytes[2]<<8)))]
if self.op[5]==JMP:
if self.op[1]==ABS:
return [NodeBranch(NodeLocAbsolute(self.bytes[1]+(self.bytes[2]<<8)))]
if self.op[5]==RTS:
return [NodeRTS()]
print self.op[0]
print 5/0
if __name__=="__main__":
rom=ROM()
with open('C:\\users\\Andrew.Sentman\\workspace\\AIIEmu\\tests\\pacman.nes','rb') as f:
rom.load(f)
addr=0xc033
while True:
op=Opcode()
addr=op.load(rom,addr)
print op.genAST()
def setUp(self):
gba = Console("GBA", "Gameboy Advance")
self.roms_console = gba
self.rom = ROM("/Users/scottrice/ROMs/GBA/Pokemon Emerald.gba",gba)
self.noext_rom = ROM("/Users/scottrice/ROMs/GBA/Pokemon Emerald",gba)
