119 lines
3.0 KiB
Zig
119 lines
3.0 KiB
Zig
const types = @import("types.zig");
|
|
const Mirroring = types.Mirroring;
|
|
|
|
const Mapper65 = @This();
|
|
|
|
prg_banks: [3]u8 = [_]u8{ 0, 1, 2 },
|
|
chr_banks: [8]u8 = [_]u8{ 0, 1, 2, 3, 4, 5, 6, 7 },
|
|
|
|
mirroring_mode: Mirroring = .vertical,
|
|
|
|
irq_enabled: bool = false,
|
|
irq_counter: u16 = 0,
|
|
irq_reload: u16 = 0,
|
|
irq_assert: bool = false,
|
|
|
|
prg_bank_count: usize,
|
|
chr_bank_count: usize,
|
|
|
|
pub fn init(
|
|
prg_size: usize,
|
|
chr_size: usize,
|
|
mirroring_mode: Mirroring,
|
|
) Mapper65 {
|
|
return .{
|
|
.prg_bank_count = prg_size / 0x2000,
|
|
.chr_bank_count = if (chr_size > 0) chr_size / 0x0400 else 1,
|
|
.mirroring_mode = mirroring_mode,
|
|
};
|
|
}
|
|
|
|
pub fn cpuMapRead(
|
|
self: *const Mapper65,
|
|
address: u16,
|
|
) ?usize {
|
|
if (address < 0x8000) return null;
|
|
|
|
const offset = @as(usize, address & 0x1fff);
|
|
const last_bank = self.prg_bank_count - 1;
|
|
|
|
switch ((address - 0x8000) / 0x2000) {
|
|
0 => return (@as(usize, self.prg_banks[0]) % self.prg_bank_count) * 0x2000 + offset,
|
|
1 => return (@as(usize, self.prg_banks[1]) % self.prg_bank_count) * 0x2000 + offset,
|
|
2 => return (@as(usize, self.prg_banks[2]) % self.prg_bank_count) * 0x2000 + offset,
|
|
3 => return last_bank * 0x2000 + offset,
|
|
else => unreachable,
|
|
}
|
|
}
|
|
|
|
pub fn cpuWrite(
|
|
self: *Mapper65,
|
|
address: u16,
|
|
value: u8,
|
|
) void {
|
|
if (address < 0x8000) return;
|
|
|
|
switch (address) {
|
|
0x8000 => self.prg_banks[0] = value,
|
|
0xa000 => self.prg_banks[1] = value,
|
|
0xc000 => self.prg_banks[2] = value,
|
|
|
|
0x9001 => self.mirroring_mode = if ((value & 0x80) != 0) .horizontal else .vertical,
|
|
|
|
0x9003 => {
|
|
self.irq_enabled = (value & 0x80) != 0;
|
|
self.irq_assert = false;
|
|
},
|
|
0x9004 => {
|
|
self.irq_reload = (self.irq_reload & 0xff00) | value;
|
|
},
|
|
0x9005 => {
|
|
self.irq_reload = (self.irq_reload & 0x00ff) | (@as(u16, value) << 8);
|
|
self.irq_counter = self.irq_reload;
|
|
self.irq_assert = false;
|
|
},
|
|
|
|
0xb000 => self.chr_banks[0] = value,
|
|
0xb001 => self.chr_banks[1] = value,
|
|
0xb002 => self.chr_banks[2] = value,
|
|
0xb003 => self.chr_banks[3] = value,
|
|
0xb004 => self.chr_banks[4] = value,
|
|
0xb005 => self.chr_banks[5] = value,
|
|
0xb006 => self.chr_banks[6] = value,
|
|
0xb007 => self.chr_banks[7] = value,
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
pub fn ppuMapRead(
|
|
self: *const Mapper65,
|
|
address: u16,
|
|
) ?usize {
|
|
if (address >= 0x2000) return null;
|
|
|
|
const slot = address / 0x0400;
|
|
const offset = @as(usize, address & 0x03ff);
|
|
const bank = @as(usize, self.chr_banks[slot]) % self.chr_bank_count;
|
|
|
|
return bank * 0x0400 + offset;
|
|
}
|
|
|
|
pub fn ppuMapWrite(
|
|
self: *const Mapper65,
|
|
address: u16,
|
|
) ?usize {
|
|
return self.ppuMapRead(address);
|
|
}
|
|
|
|
pub fn mirroring(
|
|
self: *const Mapper65,
|
|
) Mirroring {
|
|
return self.mirroring_mode;
|
|
}
|
|
|
|
pub fn irqAsserted(
|
|
self: *const Mapper65,
|
|
) bool {
|
|
return self.irq_assert;
|
|
}
|