1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
#include "nes/sys/mapper.hh"
#include "nes/sys/cartridge.hh"
namespace nes::sys
{
namespace
{
// -------------------------------------------------------------------------------------------------------------
// NROM
// -------------------------------------------------------------------------------------------------------------
class mapper_nrom final : public mapper
{
public:
explicit mapper_nrom() = default;
auto validate(cartridge& cartridge) -> status override
{
if (cartridge.get_ram_length() != 0x2000)
{
return status::error_invalid_ines_data;
}
if (cartridge.get_prg_rom_length() != 0x4000 && cartridge.get_prg_rom_length() != 0x8000)
{
return status::error_invalid_ines_data;
}
if (cartridge.get_chr_rom_length() != 0x2000)
{
return status::error_invalid_ines_data;
}
return status::success;
}
auto read_cpu(address const addr, cartridge& cartridge) -> std::uint8_t override
{
if (addr <= address{ 0x5FFF })
{
return 0x0;
}
if (addr <= address{ 0x7FFF })
{
return cartridge.get_ram()[addr.get_absolute() - 0x6000];
}
if (addr <= address{ 0xBFFF })
{
auto const rel = addr.get_absolute() - 0x8000u;
return cartridge.get_prg_rom()[rel];
}
if (addr <= address{ 0xFFFF })
{
auto rel = addr.get_absolute() - 0xC000u;
if (cartridge.get_prg_rom_length() > 0x4000) { rel += 0x4000; }
return cartridge.get_prg_rom()[rel];
}
return 0x0;
}
auto write_cpu(address const addr, std::uint8_t const value, cartridge& cartridge) -> void override
{
if (addr <= address{ 0x5FFF })
{
return;
}
if (addr <= address{ 0x7FFF })
{
cartridge.get_ram_mut()[addr.get_absolute() - 0x6000] = value;
return;
}
}
auto read_ppu(address const addr, cartridge& cartridge, std::uint8_t const* vram) -> std::uint8_t override
{
if (addr <= address{ 0x1FFF })
{
auto const rel = addr.get_absolute();
return cartridge.get_chr_rom()[rel];
}
if (addr <= address{ 0x3EFF })
{
return vram[mirrored_vram_address(addr, cartridge)];
}
return 0x0;
}
auto write_ppu(address const addr, std::uint8_t const value, cartridge& cartridge, std::uint8_t* vram) -> void override
{
if (addr <= address{ 0x1FFF })
{
return;
}
if (addr <= address{ 0x3EFF })
{
vram[mirrored_vram_address(addr, cartridge)] = value;
return;
}
}
private:
static auto mirrored_vram_address(address const addr, cartridge const& cartridge) -> unsigned
{
auto const rel = addr.get_absolute() % 0x1000u;
switch (cartridge.get_name_table_arrangement())
{
case name_table_arrangement::horizontal:
// $2000 = $2400, $2800 = $2c00
if (rel <= 0x3FF) { return 0x000u + (rel % 0x400u); }
if (rel <= 0x7FF) { return 0x000u + (rel % 0x400u); }
if (rel <= 0xBFF) { return 0x400u + (rel % 0x400u); }
if (rel <= 0xFFF) { return 0x400u + (rel % 0x400u); }
break;
case name_table_arrangement::vertical:
// $2000 = $2800, $2400 = $2c00
if (rel <= 0x3FF) { return 0x000u + (rel % 0x400u); }
if (rel <= 0x7FF) { return 0x400u + (rel % 0x400u); }
if (rel <= 0xBFF) { return 0x000u + (rel % 0x400u); }
if (rel <= 0xFFF) { return 0x400u + (rel % 0x400u); }
break;
}
return 0;
}
};
// -------------------------------------------------------------------------------------------------------------
// Invalid
// -------------------------------------------------------------------------------------------------------------
class mapper_invalid final : public mapper
{
public:
explicit mapper_invalid() = default;
auto validate(cartridge&) -> status override { return status::error_unsupported_mapper; }
auto read_cpu(address, cartridge&) -> std::uint8_t override { return 0; }
auto write_cpu(address, std::uint8_t, cartridge&) -> void override {}
auto read_ppu(address, cartridge&, std::uint8_t const*) -> std::uint8_t override { return 0; }
auto write_ppu(address, std::uint8_t, cartridge&, std::uint8_t*) -> void override {}
};
} // namespace
// -----------------------------------------------------------------------------------------------------------------
// Instances
// -----------------------------------------------------------------------------------------------------------------
auto mapper::invalid() -> mapper&
{
static auto instance = mapper_invalid{};
return instance;
}
auto mapper::get(std::uint8_t const number) -> mapper&
{
switch (number)
{
case 0x00:
{
static auto instance = mapper_nrom{};
return instance;
}
default:
{
return invalid();
}
}
}
} // namespace nes::sys
|
