├── .gitignore
├── .gradle
├── 7.2
│ ├── dependencies-accessors
│ │ ├── dependencies-accessors.lock
│ │ └── gc.properties
│ ├── executionHistory
│ │ ├── executionHistory.bin
│ │ └── executionHistory.lock
│ ├── fileChanges
│ │ └── last-build.bin
│ ├── fileHashes
│ │ ├── fileHashes.bin
│ │ └── fileHashes.lock
│ └── gc.properties
├── 8.0.2
│ ├── checksums
│ │ └── checksums.lock
│ ├── dependencies-accessors
│ │ ├── dependencies-accessors.lock
│ │ └── gc.properties
│ ├── fileChanges
│ │ └── last-build.bin
│ ├── fileHashes
│ │ └── fileHashes.lock
│ └── gc.properties
├── buildOutputCleanup
│ ├── buildOutputCleanup.lock
│ ├── cache.properties
│ └── outputFiles.bin
├── checksums
│ └── checksums.lock
└── vcs-1
│ └── gc.properties
├── .idea
├── .gitignore
├── codeStyles
│ ├── Project.xml
│ └── codeStyleConfig.xml
├── compiler.xml
├── encodings.xml
├── jarRepositories.xml
├── kotlinc.xml
├── libraries
│ ├── KotlinJavaRuntime__2_.xml
│ └── javassist.xml
├── misc.xml
├── uiDesigner.xml
├── vcs.xml
└── workspace.xml
├── GBemu.iml
├── README.md
├── pom.xml
├── src
├── main
│ ├── java
│ │ ├── gbc
│ │ │ ├── controller
│ │ │ │ ├── ConfigManager.java
│ │ │ │ ├── EmulatorController.java
│ │ │ │ └── FileLoader.java
│ │ │ ├── model
│ │ │ │ ├── GameBoyColor.java
│ │ │ │ ├── cartridge
│ │ │ │ │ ├── Cartridge.java
│ │ │ │ │ ├── CartridgeFactory.java
│ │ │ │ │ ├── MBC1.java
│ │ │ │ │ ├── MBC2.java
│ │ │ │ │ ├── MBC3.java
│ │ │ │ │ ├── MBC5.java
│ │ │ │ │ └── ROM.java
│ │ │ │ ├── controller
│ │ │ │ │ └── Controller.java
│ │ │ │ ├── cpu
│ │ │ │ │ ├── CPU.java
│ │ │ │ │ ├── Instructions.java
│ │ │ │ │ ├── Interruptions.java
│ │ │ │ │ ├── Operation.java
│ │ │ │ │ ├── OperationExecutor.java
│ │ │ │ │ ├── OperationsLoader.java
│ │ │ │ │ └── Registers.java
│ │ │ │ ├── graphics
│ │ │ │ │ ├── GPU.java
│ │ │ │ │ └── Screen.java
│ │ │ │ ├── memory
│ │ │ │ │ └── Memory.java
│ │ │ │ └── sound
│ │ │ │ │ ├── SoundChannel1.java
│ │ │ │ │ └── SoundChannel2.java
│ │ │ └── view
│ │ │ │ ├── DebugView.java
│ │ │ │ ├── EmulatorView.java
│ │ │ │ ├── EmulatorWindow.java
│ │ │ │ └── MenuBar.java
│ │ └── main.java
│ └── resources
│ │ ├── OperationCodes.json
│ │ └── opcodes.xml
└── test
│ └── java
│ └── gbc
│ ├── MemoryTest.java
│ └── RegistersTest.java
└── target
├── classes
├── gbc
│ ├── controller
│ │ ├── EmulatorController.class
│ │ └── FileLoader.class
│ ├── model
│ │ ├── GameBoyColor.class
│ │ ├── cartridge
│ │ │ ├── Cartridge.class
│ │ │ ├── CartridgeFactory.class
│ │ │ ├── MBC1.class
│ │ │ ├── MBC2.class
│ │ │ ├── MBC3.class
│ │ │ ├── MBC5.class
│ │ │ └── ROM.class
│ │ ├── controller
│ │ │ └── Controller.class
│ │ ├── cpu
│ │ │ ├── CPU.class
│ │ │ ├── Instructions.class
│ │ │ ├── Interruptions.class
│ │ │ ├── Operation.class
│ │ │ └── Registers.class
│ │ ├── graphics
│ │ │ ├── GPU.class
│ │ │ └── Screen.class
│ │ └── memory
│ │ │ └── Memory.class
│ └── view
│ │ ├── DebugView.class
│ │ ├── EmulatorView.class
│ │ └── MenuBar.class
└── main.class
└── test-classes
└── gbc
└── MemoryTest.class
/.gitignore:
--------------------------------------------------------------------------------
1 | *.gb
2 | *.gbc
3 | .idea/
4 | .gradle/
5 | target/
6 |
--------------------------------------------------------------------------------
/.gradle/7.2/dependencies-accessors/dependencies-accessors.lock:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/7.2/dependencies-accessors/dependencies-accessors.lock
--------------------------------------------------------------------------------
/.gradle/7.2/dependencies-accessors/gc.properties:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/7.2/dependencies-accessors/gc.properties
--------------------------------------------------------------------------------
/.gradle/7.2/executionHistory/executionHistory.bin:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/7.2/executionHistory/executionHistory.bin
--------------------------------------------------------------------------------
/.gradle/7.2/executionHistory/executionHistory.lock:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/7.2/executionHistory/executionHistory.lock
--------------------------------------------------------------------------------
/.gradle/7.2/fileChanges/last-build.bin:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/.gradle/7.2/fileHashes/fileHashes.bin:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/7.2/fileHashes/fileHashes.bin
--------------------------------------------------------------------------------
/.gradle/7.2/fileHashes/fileHashes.lock:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/7.2/fileHashes/fileHashes.lock
--------------------------------------------------------------------------------
/.gradle/7.2/gc.properties:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/7.2/gc.properties
--------------------------------------------------------------------------------
/.gradle/8.0.2/checksums/checksums.lock:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/8.0.2/checksums/checksums.lock
--------------------------------------------------------------------------------
/.gradle/8.0.2/dependencies-accessors/dependencies-accessors.lock:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/8.0.2/dependencies-accessors/dependencies-accessors.lock
--------------------------------------------------------------------------------
/.gradle/8.0.2/dependencies-accessors/gc.properties:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/8.0.2/dependencies-accessors/gc.properties
--------------------------------------------------------------------------------
/.gradle/8.0.2/fileChanges/last-build.bin:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/.gradle/8.0.2/fileHashes/fileHashes.lock:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/8.0.2/fileHashes/fileHashes.lock
--------------------------------------------------------------------------------
/.gradle/8.0.2/gc.properties:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/8.0.2/gc.properties
--------------------------------------------------------------------------------
/.gradle/buildOutputCleanup/buildOutputCleanup.lock:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/buildOutputCleanup/buildOutputCleanup.lock
--------------------------------------------------------------------------------
/.gradle/buildOutputCleanup/cache.properties:
--------------------------------------------------------------------------------
1 | #Sun Nov 19 12:15:19 CET 2023
2 | gradle.version=7.2
3 |
--------------------------------------------------------------------------------
/.gradle/buildOutputCleanup/outputFiles.bin:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/buildOutputCleanup/outputFiles.bin
--------------------------------------------------------------------------------
/.gradle/checksums/checksums.lock:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/checksums/checksums.lock
--------------------------------------------------------------------------------
/.gradle/vcs-1/gc.properties:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/.gradle/vcs-1/gc.properties
--------------------------------------------------------------------------------
/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 | # Editor-based HTTP Client requests
5 | /httpRequests/
6 | # Datasource local storage ignored files
7 | /dataSources/
8 | /dataSources.local.xml
9 |
--------------------------------------------------------------------------------
/.idea/codeStyles/Project.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
--------------------------------------------------------------------------------
/.idea/codeStyles/codeStyleConfig.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
--------------------------------------------------------------------------------
/.idea/compiler.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
--------------------------------------------------------------------------------
/.idea/encodings.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
--------------------------------------------------------------------------------
/.idea/jarRepositories.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
--------------------------------------------------------------------------------
/.idea/kotlinc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/.idea/libraries/KotlinJavaRuntime__2_.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
--------------------------------------------------------------------------------
/.idea/libraries/javassist.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
10 |
11 |
12 |
13 |
14 |
15 |
--------------------------------------------------------------------------------
/.idea/uiDesigner.xml:
--------------------------------------------------------------------------------
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 |
--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/.idea/workspace.xml:
--------------------------------------------------------------------------------
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 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 | {
71 | "associatedIndex": 1
72 | }
73 |
74 |
75 |
76 |
77 |
78 |
79 | {
80 | "keyToString": {
81 | "Application.main.executor": "Run",
82 | "RunOnceActivity.OpenProjectViewOnStart": "true",
83 | "RunOnceActivity.ShowReadmeOnStart": "true",
84 | "WebServerToolWindowFactoryState": "false",
85 | "git-widget-placeholder": "master",
86 | "kotlin-language-version-configured": "true",
87 | "last_opened_file_path": "/home/pablo/ProyectosPropios/GBJava",
88 | "node.js.detected.package.eslint": "true",
89 | "node.js.detected.package.tslint": "true",
90 | "node.js.selected.package.eslint": "(autodetect)",
91 | "node.js.selected.package.tslint": "(autodetect)",
92 | "nodejs_package_manager_path": "npm",
93 | "onboarding.tips.debug.path": "/home/pablo/ProyectosPropios/GBJava/untitled/src/main/java/org/example/Main.java",
94 | "project.structure.last.edited": "Modules",
95 | "project.structure.proportion": "0.0",
96 | "project.structure.side.proportion": "0.0",
97 | "settings.editor.selected.configurable": "reference.settings.project.maven.repository.indices",
98 | "vue.rearranger.settings.migration": "true"
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 |
137 |
138 |
139 |
140 |
141 |
142 |
143 |
144 |
145 |
146 |
147 |
148 |
149 |
150 | 1700442285478
151 |
152 |
153 | 1700442285478
154 |
155 |
156 |
157 |
158 |
159 |
160 |
161 |
162 |
163 |
164 |
165 |
166 |
167 |
168 |
169 |
170 |
171 |
172 |
173 |
174 |
175 |
176 |
177 |
178 |
179 |
180 |
181 |
182 |
183 |
184 |
185 |
186 | file://$PROJECT_DIR$/src/main/java/org/example/Main.java
187 | 15
188 |
189 |
190 |
191 |
192 |
193 |
194 |
195 |
196 |
197 |
--------------------------------------------------------------------------------
/GBemu.iml:
--------------------------------------------------------------------------------
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 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # gbc
2 | A WIP GB emulator made from scratch in java.
3 |
--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
1 |
2 |
5 | 4.0.0
6 |
7 | org.example
8 | GBJava
9 | 1.0-SNAPSHOT
10 |
11 |
12 | 19
13 | 19
14 | UTF-8
15 |
16 |
17 |
18 | junit
19 | junit
20 | RELEASE
21 | test
22 |
23 |
24 | org.junit.jupiter
25 | junit-jupiter
26 | RELEASE
27 | test
28 |
29 |
30 | com.google.code.gson
31 | gson
32 | 2.10.1
33 |
34 |
35 |
36 |
--------------------------------------------------------------------------------
/src/main/java/gbc/controller/ConfigManager.java:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/src/main/java/gbc/controller/ConfigManager.java
--------------------------------------------------------------------------------
/src/main/java/gbc/controller/EmulatorController.java:
--------------------------------------------------------------------------------
1 | package gbc.controller;
2 |
3 | import gbc.model.GameBoyColor;
4 | import gbc.view.EmulatorWindow;
5 |
6 | public class EmulatorController {
7 | private GameBoyColor gbc;
8 | private EmulatorWindow view;
9 |
10 |
11 | public EmulatorController(GameBoyColor gbc, EmulatorWindow view) {
12 | this.gbc = gbc;
13 | this.view = view;
14 | }
15 |
16 | public EmulatorController() {
17 | this.gbc = new GameBoyColor();
18 | this.view = new EmulatorWindow(this.gbc);
19 |
20 | }
21 |
22 |
23 | public void start() {
24 | // Init view
25 | view.update();
26 |
27 |
28 | // Main loop
29 | while (true) {
30 | // Handle input
31 | handleInput();
32 | // Update model
33 | gbc.executeCycle();
34 | // Update view
35 | view.update();
36 |
37 | // Update debug view
38 |
39 | }
40 |
41 | }
42 |
43 | public void handleInput() {
44 | // Procesar las entradas del usuario y actualizar el Modelo y la Vista
45 | }
46 |
47 | public void loadRom(String path) {
48 | // Cargar el archivo ROM en el Modelo
49 | gbc.insertCartridge(path);
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/src/main/java/gbc/controller/FileLoader.java:
--------------------------------------------------------------------------------
1 | package gbc.controller;
2 |
3 | import java.io.File;
4 | import java.io.IOException;
5 | import java.nio.file.Files;
6 |
7 | public class FileLoader {
8 | public static byte[] loadFile(String path) {
9 | File file = new File(path);
10 | try {
11 | return Files.readAllBytes(file.toPath());
12 | } catch (IOException e) {
13 | e.printStackTrace();
14 | return null;
15 | }
16 | }
17 | }
--------------------------------------------------------------------------------
/src/main/java/gbc/model/GameBoyColor.java:
--------------------------------------------------------------------------------
1 | package gbc.model;
2 |
3 | import java.io.IOException;
4 | import java.nio.file.Files;
5 | import java.nio.file.Paths;
6 |
7 | import gbc.model.cartridge.*;
8 | import gbc.model.controller.Controller;
9 | import gbc.model.cpu.*;
10 | import gbc.model.memory.*;
11 | import gbc.view.EmulatorView;
12 | import gbc.model.graphics.*;
13 |
14 | public class GameBoyColor {
15 | private final CPU cpu;
16 | private final Memory memory;
17 | private GPU gpu;
18 |
19 | private Screen screen;
20 |
21 | private Controller input;
22 |
23 | public GameBoyColor() {
24 | this.memory = new Memory();
25 | this.cpu = new CPU(this.memory);
26 | this.screen = new Screen();
27 | this.gpu = new GPU(this.memory, this.screen);
28 | this.input = new Controller();
29 |
30 | }
31 |
32 | public void executeCycle() {
33 |
34 | input.handleInput();
35 | cpu.executeCycle();
36 | gpu.step(cpu.getCycles());
37 | cpu.setCycles(0);
38 | }
39 |
40 | public void insertCartridge(String path) {
41 | byte[] data;
42 | try {
43 | data = Files.readAllBytes(Paths.get(path));
44 | Cartridge cartridge = CartridgeFactory.create(data);
45 | memory.loadCartridge(cartridge);
46 | } catch (IOException e) {
47 | e.printStackTrace();
48 | }
49 |
50 | }
51 |
52 | public void reset() {
53 | cpu.reset();
54 | memory.reset();
55 | this.screen = new Screen();
56 | gpu = new GPU(this.memory, this.screen);
57 |
58 | }
59 |
60 | public Controller getController() {
61 | return this.input;
62 | }
63 |
64 | public CPU getCpu() {
65 | return this.cpu;
66 | }
67 |
68 | public Memory getMemory() {
69 | return this.memory;
70 | }
71 |
72 |
73 | public GPU getGpu() {
74 | return this.gpu;
75 | }
76 | }
77 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/cartridge/Cartridge.java:
--------------------------------------------------------------------------------
1 | package gbc.model.cartridge;
2 |
3 | public abstract class Cartridge {
4 | protected byte[] data;
5 |
6 | public Cartridge(byte[] data) {
7 | this.data = data;
8 | }
9 |
10 | // Use 'int' for address to accommodate the full range of Game Boy addresses
11 | public abstract byte read(int address);
12 | public abstract void write(int address, byte value);
13 |
14 | public byte[] getData() {
15 | return data;
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/cartridge/CartridgeFactory.java:
--------------------------------------------------------------------------------
1 | package gbc.model.cartridge;
2 |
3 | public class CartridgeFactory {
4 |
5 | public static Cartridge create(byte[] data) {
6 | byte value = data[0x147];
7 | System.out.println("CartridgeFactory: " + value);
8 | return switch (value) {
9 | case 0x00 -> new ROM(data);
10 | case 0x01, 0x02, 0x03 -> new MBC1(data);
11 | case 0x05, 0x06 -> new MBC2(data);
12 | case 0x0F, 0x10, 0x11, 0x12, 0x13 -> new MBC3(data);
13 | case 0x19, 0x1A, 0x1B, 0x1C, 0x1D -> new MBC5(data);
14 | default -> null;
15 | };
16 | }
17 |
18 | }
19 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/cartridge/MBC1.java:
--------------------------------------------------------------------------------
1 | package gbc.model.cartridge;
2 |
3 | public class MBC1 extends Cartridge {
4 | private int romBankNumber = 1; // Default ROM bank
5 | private int ramBankNumber = 0; // Default RAM bank
6 | private boolean ramEnabled = false;
7 | private boolean bankingMode = false; // false: ROM banking mode, true: RAM banking mode
8 |
9 | public MBC1(byte[] data) {
10 | super(data);
11 | }
12 |
13 | @Override
14 | public byte read(int address) {
15 | if (address >= 0x0000 && address < 0x4000) {
16 | // ROM bank 0
17 | return data[address];
18 | } else if (address >= 0x4000 && address < 0x8000) {
19 | // Switchable ROM bank
20 | int bankOffset = romBankNumber * 0x4000;
21 | int index = bankOffset + (address - 0x4000);
22 | return data[index];
23 | } else if (address >= 0xA000 && address < 0xC000 && ramEnabled) {
24 | // Switchable RAM bank
25 | int bankOffset = ramBankNumber * 0x2000;
26 | int index = bankOffset + (address - 0xA000);
27 | return data[index];
28 | }
29 | return 0;
30 | }
31 |
32 | @Override
33 | public void write(int address, byte value) {
34 | if (address >= 0x0000 && address < 0x2000) {
35 | // RAM enable/disable
36 | ramEnabled = ((value & 0x0F) == 0x0A);
37 | } else if (address >= 0x2000 && address < 0x4000) {
38 | // ROM bank number
39 | romBankNumber = (value & 0x1F);
40 | if (romBankNumber == 0) romBankNumber = 1;
41 | } else if (address >= 0x4000 && address < 0x6000) {
42 | // RAM bank number or upper bits of ROM bank number
43 | if (bankingMode) {
44 | ramBankNumber = (value & 0x03);
45 | } else {
46 | romBankNumber = (romBankNumber & 0x1F) | ((value & 0x03) << 5);
47 | }
48 | } else if (address >= 0x6000 && address < 0x8000) {
49 | // Banking mode select
50 | bankingMode = ((value & 0x01) == 0x01);
51 | }
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/cartridge/MBC2.java:
--------------------------------------------------------------------------------
1 | package gbc.model.cartridge;
2 |
3 | public class MBC2 extends Cartridge {
4 | private int romBankNumber = 1; // Default ROM bank
5 | private boolean ramEnabled = false;
6 |
7 | public MBC2(byte[] data) {
8 | super(data);
9 | }
10 |
11 | @Override
12 | public byte read(int address) {
13 | if (address >= 0x0000 && address < 0x4000) {
14 | // ROM bank 0
15 | return data[address];
16 | } else if (address >= 0x4000 && address < 0x8000) {
17 | // Switchable ROM bank
18 | int bankOffset = romBankNumber * 0x4000;
19 | int index = bankOffset + (address - 0x4000);
20 | return data[index];
21 | } else if (address >= 0xA000 && address < 0xA200 && ramEnabled) {
22 | // MBC2 has 512x4 bits built-in RAM
23 | int index = address - 0xA000;
24 | return (byte) (data[index] & 0x0F); // Only lower 4 bits are used
25 | }
26 | return 0;
27 | }
28 |
29 | @Override
30 | public void write(int address, byte value) {
31 | if (address >= 0x0000 && address < 0x4000) {
32 | if ((address & 0x0100) == 0) {
33 | // RAM enable/disable
34 | ramEnabled = ((value & 0x0F) == 0x0A);
35 | } else {
36 | // ROM bank number
37 | romBankNumber = (value & 0x0F);
38 | if (romBankNumber == 0) romBankNumber = 1;
39 | }
40 | }
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/cartridge/MBC3.java:
--------------------------------------------------------------------------------
1 | package gbc.model.cartridge;
2 |
3 | //Imports for Real Time Clock
4 | import java.util.Calendar;
5 | import java.util.Date;
6 | import java.util.GregorianCalendar;
7 |
8 |
9 | public class MBC3 extends Cartridge {
10 | private int romBankNumber = 1; // Default ROM bank
11 | private int ramBankNumber = 0; // Default RAM bank
12 | private boolean ramEnabled = false;
13 |
14 | public MBC3(byte[] data) {
15 | super(data);
16 | }
17 |
18 | public byte[] rtc() {
19 | //Logic of Real Time Clock
20 | Calendar calendar = new GregorianCalendar();
21 | Date trialTime = new Date();
22 | calendar.setTime(trialTime);
23 | int hour = calendar.get(Calendar.HOUR);
24 | int minute = calendar.get(Calendar.MINUTE);
25 | int second = calendar.get(Calendar.SECOND);
26 | int day = calendar.get(Calendar.DAY_OF_MONTH);
27 | int month = calendar.get(Calendar.MONTH);
28 | int year = calendar.get(Calendar.YEAR);
29 | byte[] rtc = new byte[7];
30 | rtc[0] = (byte) second;
31 | rtc[1] = (byte) minute;
32 | rtc[2] = (byte) hour;
33 | rtc[3] = (byte) day;
34 | rtc[4] = (byte) month;
35 | rtc[5] = (byte) year;
36 | rtc[6] = (byte) 0;
37 | return rtc;
38 |
39 | }
40 |
41 | @Override
42 | public byte read(int address) {
43 | if (address >= 0x0000 && address < 0x4000) {
44 | // ROM bank 0
45 | return data[address];
46 | } else if (address >= 0x4000 && address < 0x8000) {
47 | // Switchable ROM bank
48 | int bankOffset = romBankNumber * 0x4000;
49 | int index = bankOffset + (address - 0x4000);
50 | return data[index];
51 | } else if (address >= 0xA000 && address < 0xC000 && ramEnabled) {
52 | // Switchable RAM bank
53 | int bankOffset = ramBankNumber * 0x2000;
54 | int index = bankOffset + (address - 0xA000);
55 | return data[index];
56 | }
57 | return 0;
58 | }
59 |
60 | @Override
61 | public void write(int address, byte value) {
62 | if (address >= 0x0000 && address < 0x2000) {
63 | // RAM enable/disable
64 | ramEnabled = ((value & 0x0F) == 0x0A);
65 | } else if (address >= 0x2000 && address < 0x4000) {
66 | // ROM bank number
67 | romBankNumber = (value & 0x7F);
68 | if (romBankNumber == 0) romBankNumber = 1;
69 | } else if (address >= 0x4000 && address < 0x6000) {
70 | // RAM bank number
71 | ramBankNumber = (value & 0x03);
72 | }
73 |
74 |
75 |
76 | }
77 | }
78 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/cartridge/MBC5.java:
--------------------------------------------------------------------------------
1 | package gbc.model.cartridge;
2 |
3 | public class MBC5 extends Cartridge {
4 | private static final int ROM_BANK_SIZE = 0x4000; // Size of a ROM bank
5 | private static final int RAM_BANK_SIZE = 0x2000; // Size of a RAM bank
6 |
7 | private int romBankNumber;
8 | private int ramBankNumber;
9 | private boolean ramEnabled;
10 |
11 | public MBC5(byte[] data) {
12 | super(data);
13 | this.romBankNumber = 1; // Default to bank 1, as bank 0 is always mapped to 0x0000-0x3FFF
14 | this.ramBankNumber = 0;
15 | this.ramEnabled = false;
16 | }
17 |
18 | @Override
19 | public byte read(int address) {
20 | if (address >= 0x0000 && address < 0x4000) {
21 | // Always read from ROM bank 0
22 | return data[address];
23 | } else if (address >= 0x4000 && address < 0x8000) {
24 | // Read from the selected ROM bank
25 | int bankOffset = romBankNumber * ROM_BANK_SIZE;
26 | int index = bankOffset + (address - 0x4000);
27 | return data[index];
28 | } else if (address >= 0xA000 && address < 0xC000 && ramEnabled) {
29 | // Read from the selected RAM bank, if enabled
30 | int bankOffset = ramBankNumber * RAM_BANK_SIZE;
31 | int index = bankOffset + (address - 0xA000);
32 | return data[index];
33 | }
34 | return 0; // Return 0 for invalid or disabled addresses
35 | }
36 |
37 | @Override
38 | public void write(int address, byte value) {
39 | if (address >= 0x0000 && address < 0x2000) {
40 | // Enable or disable RAM
41 | ramEnabled = ((value & 0x0A) != 0);
42 | } else if (address >= 0x2000 && address < 0x3000) {
43 | // Write lower 8 bits of ROM bank number
44 | romBankNumber = (romBankNumber & 0x100) | (value & 0xFF);
45 | } else if (address >= 0x3000 && address < 0x4000) {
46 | // Write 9th bit of ROM bank number
47 | romBankNumber = (romBankNumber & 0xFF) | ((value & 0x01) << 8);
48 | } else if (address >= 0x4000 && address < 0x6000) {
49 | // Select RAM bank
50 | ramBankNumber = value & 0x0F;
51 | } else if (address >= 0xA000 && address < 0xC000 && ramEnabled) {
52 | // Write to the selected RAM bank, if enabled
53 | int bankOffset = ramBankNumber * RAM_BANK_SIZE;
54 | int index = bankOffset + (address - 0xA000);
55 | data[index] = value;
56 | }
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/cartridge/ROM.java:
--------------------------------------------------------------------------------
1 | package gbc.model.cartridge;
2 |
3 | public class ROM extends Cartridge {
4 |
5 | public ROM(byte[] data) {
6 | super(data);
7 | }
8 |
9 | @Override
10 | public byte read(int address) {
11 | // Simple direct mapping for ROM-only cartridges
12 | if (address >= 0 && address < data.length) {
13 | return data[address];
14 | }
15 | return 0;
16 | }
17 |
18 | @Override
19 | public void write(int address, byte value) {
20 | // ROM is read-only; writes have no effect
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/controller/Controller.java:
--------------------------------------------------------------------------------
1 | package gbc.model.controller;
2 |
3 | public class Controller {
4 | private boolean[] keys;
5 | private boolean[] keysPressed;
6 | private boolean[] keysReleased;
7 |
8 | public Controller() {
9 | keys = new boolean[8];
10 | keysPressed = new boolean[8];
11 | keysReleased = new boolean[8];
12 | }
13 |
14 | public void setKey(int key, boolean pressed) {
15 | keys[key] = pressed;
16 | if (pressed) {
17 | keysPressed[key] = true;
18 | } else {
19 | keysReleased[key] = true;
20 | }
21 | }
22 |
23 | public void handleInput() {
24 | resetKeys();
25 | }
26 |
27 | public boolean isKeyPressed(int key) {
28 | return keysPressed[key];
29 | }
30 |
31 | public boolean isKeyReleased(int key) {
32 | return keysReleased[key];
33 | }
34 |
35 | public void resetKeys() {
36 | keysPressed = new boolean[8];
37 | keysReleased = new boolean[8];
38 | }
39 |
40 | public boolean isKeyPressed() {
41 | for (int i = 0; i < keysPressed.length; i++) {
42 | if (keysPressed[i]) {
43 | return true;
44 | }
45 | }
46 | return false;
47 | }
48 |
49 | public boolean isKeyReleased() {
50 | for (int i = 0; i < keysReleased.length; i++) {
51 | if (keysReleased[i]) {
52 | return true;
53 | }
54 | }
55 | return false;
56 | }
57 |
58 | public boolean isKey(int key) {
59 | return keys[key];
60 | }
61 | }
--------------------------------------------------------------------------------
/src/main/java/gbc/model/cpu/CPU.java:
--------------------------------------------------------------------------------
1 | package gbc.model.cpu;
2 |
3 | import gbc.model.memory.Memory;
4 |
5 | public class CPU {
6 | private Registers registers;
7 | private Memory memory;
8 | private Interruptions interrupts;
9 | private OperationsLoader operationsLoader;
10 |
11 | private int cycles;
12 | private StringBuilder opcodeLog;
13 |
14 | public CPU(Memory memory) {
15 | this.memory = memory;
16 | this.registers = new Registers();
17 | this.interrupts = new Interruptions(memory, registers);
18 | this.opcodeLog = new StringBuilder();
19 | this.operationsLoader = new OperationsLoader();
20 | reset();
21 | }
22 |
23 | public void reset() {
24 | registers.reset();
25 | memory.reset();
26 | interrupts.reset();
27 | cycles = 0;
28 | }
29 |
30 | public void executeCycle() {
31 | handleInterrupts();
32 | int opcode = fetchByte();
33 | executeInstruction(opcode);
34 | updateCycles(opcode);
35 | }
36 |
37 | private void handleInterrupts() {
38 | interrupts.handleInterrupts();
39 | }
40 |
41 | private void executeInstruction(int opcode) {
42 | Operation operation = operationsLoader.getOperation(opcode);
43 | if (operation != null) {
44 | operation.perform(registers, memory);
45 | opcodeLog.append(String.format("PC: 0x%04X, Opcode: 0x%02X\n", (byte)registers.getPC(), opcode));
46 | }
47 | }
48 |
49 | private void updateCycles(int opcode) {
50 | Operation operation = operationsLoader.getOperation(opcode);
51 | if (operation != null) {
52 | cycles += operation.getCycles().get(0); // assuming the first cycle count is the base cycle count
53 | }
54 | }
55 |
56 | private int fetchByte() {
57 | int value = memory.readByte(registers.getPC()) & 0xFF;
58 | registers.incrementPC();
59 | return value;
60 | }
61 |
62 | public int getCycles() {
63 | return cycles;
64 | }
65 |
66 | public void setCycles(int cycles) {
67 | this.cycles = cycles;
68 | }
69 |
70 | public String getOpcodeLog() {
71 | return opcodeLog.toString();
72 | }
73 |
74 | public Registers getRegisters() {
75 | return registers;
76 | }
77 |
78 |
79 | // Other methods...
80 | }
--------------------------------------------------------------------------------
/src/main/java/gbc/model/cpu/Instructions.java:
--------------------------------------------------------------------------------
1 | package gbc.model.cpu;
2 |
3 | import gbc.model.memory.Memory;
4 | import java.util.HashMap;
5 | import java.util.Map;
6 |
7 | public class Instructions {
8 |
9 | private Registers r;
10 | private Memory m;
11 |
12 |
13 | Instructions(Registers r, Memory m) {
14 | this.r = r;
15 | this.m = m;
16 | }
17 |
18 | public void execute(byte opcode) {
19 |
20 | }
21 |
22 |
23 |
24 |
25 |
26 | // ... (other instruction methods)
27 |
28 | public void setRegisters(Registers r) {
29 | this.r = r;
30 | }
31 |
32 | public void setMemory(Memory m) {
33 | this.m = m;
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/cpu/Interruptions.java:
--------------------------------------------------------------------------------
1 | package gbc.model.cpu;
2 | import gbc.model.memory.Memory;
3 |
4 | public class Interruptions {
5 | private boolean masterEnabled;
6 | private Memory memory;
7 | private Registers registers;
8 |
9 | private static final int ADDR_INTERRUPT_FLAG = 0xFF0F;
10 | private static final int ADDR_INTERRUPT_ENABLE = 0xFFFF;
11 |
12 | private static final byte INTERRUPT_VBLANK = 0x01;
13 | private static final byte INTERRUPT_LCDSTAT = 0x02;
14 | private static final byte INTERRUPT_TIMER = 0x04;
15 | private static final byte INTERRUPT_SERIAL = 0x08;
16 | private static final byte INTERRUPT_JOYPAD = 0x10;
17 |
18 | public Interruptions(Memory memory, Registers registers) {
19 | this.memory = memory;
20 | this.registers = registers;
21 | this.masterEnabled = true;
22 | }
23 |
24 | public void setMasterEnabled(boolean enabled) {
25 | this.masterEnabled = enabled;
26 | }
27 |
28 | public boolean isMasterEnabled() {
29 | return masterEnabled;
30 | }
31 |
32 | public void requestInterrupt(byte interrupt) {
33 | byte currentFlags = (byte) memory.readByte(ADDR_INTERRUPT_FLAG);
34 | currentFlags |= interrupt;
35 | memory.writeByte(ADDR_INTERRUPT_FLAG, currentFlags);
36 | }
37 |
38 | public void handleInterrupts() {
39 | if (!masterEnabled) {
40 | return;
41 | }
42 |
43 | byte interruptFlag = (byte) memory.readByte(ADDR_INTERRUPT_FLAG);
44 | byte interruptEnable = (byte) memory.readByte(ADDR_INTERRUPT_ENABLE);
45 |
46 | byte interruptFired = (byte) (interruptFlag & interruptEnable);
47 | if (interruptFired == 0) {
48 | return;
49 | }
50 |
51 | // Service the first interrupt that's fired
52 | if ((interruptFired & INTERRUPT_VBLANK) != 0) {
53 | serviceInterrupt(INTERRUPT_VBLANK, 0x0040);
54 | } else if ((interruptFired & INTERRUPT_LCDSTAT) != 0) {
55 | serviceInterrupt(INTERRUPT_LCDSTAT, 0x0048);
56 | } else if ((interruptFired & INTERRUPT_TIMER) != 0) {
57 | serviceInterrupt(INTERRUPT_TIMER, 0x0050);
58 | } else if ((interruptFired & INTERRUPT_SERIAL) != 0) {
59 | serviceInterrupt(INTERRUPT_SERIAL, 0x0058);
60 | } else if ((interruptFired & INTERRUPT_JOYPAD) != 0) {
61 | serviceInterrupt(INTERRUPT_JOYPAD, 0x0060);
62 | }
63 | }
64 |
65 | private void serviceInterrupt(byte interrupt, int handlerAddress) {
66 | // Push current PC on stack
67 | pushPC();
68 |
69 | // Jump to interrupt handler
70 | registers.setPC((char) handlerAddress);
71 |
72 | // Disable further interrupts
73 | setMasterEnabled(false);
74 |
75 | // Reset the interrupt flag
76 | byte currentFlags = (byte) memory.readByte(ADDR_INTERRUPT_FLAG);
77 | currentFlags &= ~interrupt;
78 | memory.writeByte(ADDR_INTERRUPT_FLAG, currentFlags);
79 | }
80 |
81 | private void pushPC() {
82 | char sp = registers.getSP();
83 | memory.writeChar((char) (sp - 2), registers.getPC());
84 | registers.setSP((char) (sp - 2));
85 | }
86 |
87 | public void reset() {
88 | masterEnabled = true;
89 | }
90 | }
91 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/cpu/Operation.java:
--------------------------------------------------------------------------------
1 | package gbc.model.cpu;
2 |
3 | import gbc.model.memory.Memory;
4 |
5 | import java.util.List;
6 | import java.util.Map;
7 |
8 | public class Operation {
9 | private OperationExecutor executor;
10 | private String mnemonic;
11 | private int bytes;
12 | private List cycles;
13 | private boolean immediate;
14 | private Map flags;
15 | private List> operands;
16 |
17 | public Operation(OperationExecutor executor, String mnemonic, int bytes, List cycles, boolean immediate, Map flags, List> operands) {
18 | this.executor = executor;
19 | this.mnemonic = mnemonic;
20 | this.bytes = bytes;
21 | this.cycles = cycles;
22 | this.immediate = immediate;
23 | this.flags = flags;
24 | this.operands = operands;
25 | }
26 |
27 | public void perform(Registers registers, Memory memory) {
28 | executor.execute(registers, memory, operands);
29 | }
30 |
31 | // getters and setters for the new fields...
32 |
33 |
34 | public OperationExecutor getExecutor() {
35 | return executor;
36 | }
37 |
38 | public void setExecutor(OperationExecutor executor) {
39 | this.executor = executor;
40 | }
41 |
42 | public String getMnemonic() {
43 | return mnemonic;
44 | }
45 |
46 | public void setMnemonic(String mnemonic) {
47 | this.mnemonic = mnemonic;
48 | }
49 |
50 | public int getBytes() {
51 | return bytes;
52 | }
53 |
54 | public void setBytes(int bytes) {
55 | this.bytes = bytes;
56 | }
57 |
58 | public List getCycles() {
59 | return cycles;
60 | }
61 |
62 | public void setCycles(List cycles) {
63 | this.cycles = cycles;
64 | }
65 |
66 | public boolean isImmediate() {
67 | return immediate;
68 | }
69 |
70 | public void setImmediate(boolean immediate) {
71 | this.immediate = immediate;
72 | }
73 |
74 | public Map getFlags() {
75 | return flags;
76 | }
77 |
78 | public void setFlags(Map flags) {
79 | this.flags = flags;
80 | }
81 |
82 | public List> getOperands() {
83 | return operands;
84 | }
85 |
86 | public void setOperands(List> operands) {
87 | this.operands = operands;
88 | }
89 | }
--------------------------------------------------------------------------------
/src/main/java/gbc/model/cpu/OperationExecutor.java:
--------------------------------------------------------------------------------
1 | package gbc.model.cpu;
2 |
3 | import gbc.model.memory.Memory;
4 |
5 | import java.util.List;
6 | import java.util.Map;
7 |
8 | @FunctionalInterface
9 | public interface OperationExecutor {
10 | void execute(Registers registers, Memory memory, List> operands);
11 | }
12 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/cpu/OperationsLoader.java:
--------------------------------------------------------------------------------
1 | package gbc.model.cpu;
2 |
3 | import com.google.gson.Gson;
4 | import com.google.gson.JsonElement;
5 | import com.google.gson.JsonObject;
6 | import gbc.model.memory.Memory;
7 |
8 | import java.io.InputStream;
9 | import java.io.InputStreamReader;
10 | import java.util.HashMap;
11 | import java.util.List;
12 | import java.util.Map;
13 |
14 | public class OperationsLoader {
15 | private Map operations;
16 | private Map executors;
17 |
18 | public OperationsLoader() {
19 | this.operations = new HashMap<>();
20 | this.executors = new HashMap<>();
21 | loadOperations();
22 | }
23 |
24 | private void loadOperations() {
25 | try (InputStream is = getClass().getClassLoader().getResourceAsStream("OperationCodes.json");
26 | InputStreamReader isr = new InputStreamReader(is)) {
27 | Gson gson = new Gson();
28 | JsonObject rootObj = gson.fromJson(isr, JsonObject.class);
29 |
30 | JsonObject unprefixed = rootObj.getAsJsonObject("unprefixed");
31 | parseOperationSection(unprefixed, gson);
32 |
33 | JsonObject cbprefixed = rootObj.getAsJsonObject("cbprefixed");
34 | parseOperationSection(cbprefixed, gson);
35 |
36 | } catch (Exception e) {
37 | e.printStackTrace();
38 | }
39 | }
40 |
41 | private void parseOperationSection(JsonObject operationSection, Gson gson) {
42 | for (Map.Entry entry : operationSection.entrySet()) {
43 | try {
44 | // Remove the '0x' prefix if present and trim any whitespace
45 | String key = entry.getKey().replace("0x", "").trim();
46 | // Now parse the clean hexadecimal string
47 | int opcode = Integer.parseInt(key, 16);
48 | Operation operation = gson.fromJson(entry.getValue(), Operation.class);
49 | operation.setExecutor(createExecutorForOperation(operation));
50 | operations.put(opcode, operation);
51 | } catch (NumberFormatException e) {
52 | System.err.println("Invalid key format for entry: '" + entry.getKey() + "'");
53 | }
54 | }
55 | }
56 |
57 | private OperationExecutor createExecutorForOperation(Operation operation) {
58 | if ("RET".equals(operation.getMnemonic())) {
59 | return (registers, memory, operands) -> {
60 | // Lambda for RET executor
61 | System.out.println("Executing RET operation");
62 | // Typically, RET pops an address from the stack and sets the program counter to that address.
63 | // Example implementation (assuming these methods exist in your Registers and Memory classes):
64 | char address = memory.popFromStack();
65 | registers.setPC(address);
66 | };
67 | }
68 | if ("LD".equals(operation.getMnemonic())) {
69 | return (registers, memory, operands) -> {
70 | // Lambda for LD executor
71 | System.out.println("Executing LD operation");
72 | // LD typically loads a value into a register or memory location.
73 | // The exact behavior depends on the operands.
74 | // For example, if operands specify a register and a value:
75 | if (operands.size() >= 2) {
76 | String register = operands.get(0).get("register").toString();
77 | int value = Integer.parseInt(operands.get(1).get("value").toString(), 16);
78 | registers.setRegister(register, (byte) value);
79 | }
80 | };
81 | }
82 | if ("JP".equals(operation.getMnemonic())) {
83 | return (registers, memory, operands) -> {
84 | // Lambda for JP executor
85 | System.out.println("Executing JP operation");
86 | // JP typically sets the program counter to a given address.
87 | // The exact behavior depends on the operands.
88 | // For example, if operands specify a value:
89 | if (operands.size() >= 1) {
90 | int value = Integer.parseInt(operands.get(0).get("value").toString(), 16);
91 | registers.setPC((char) value);
92 | }
93 | };
94 | }
95 |
96 | if("SET".equals(operation.getMnemonic())) {
97 | return (registers, memory, operands) -> {
98 | // Lambda for SET executor
99 | System.out.println("Executing SET operation");
100 | // SET typically sets a bit in a register or memory location.
101 | // The exact behavior depends on the operands.
102 | // For example, if operands specify a register and a bit:
103 | if (operands.size() >= 2) {
104 | String register = operands.get(0).get("name").toString();
105 | }
106 | };
107 | }
108 |
109 | if("RES".equals(operation.getMnemonic())) {
110 | return (registers, memory, operands) -> {
111 | // Lambda for RES executor
112 | System.out.println("Executing RES operation");
113 | // RES typically resets a bit in a register or memory location.
114 | // The exact behavior depends on the operands.
115 | // For example, if operands specify a register and a bit:
116 | if (operands.size() >= 2) {
117 | String register = operands.get(0).get("register").toString();
118 | int bit = Integer.parseInt(operands.get(1).get("bit").toString(), 16);
119 | registers.setRegister(register, (byte) (registers.getRegister(register) & ~(1 << bit)));
120 | }
121 | };
122 | }
123 |
124 | if("BIT".equals(operation.getMnemonic())) {
125 | return (registers, memory, operands) -> {
126 | // Lambda for BIT executor
127 | System.out.println("Executing BIT operation");
128 | // BIT typically checks a bit in a register or memory location.
129 | // The exact behavior depends on the operands.
130 | // For example, if operands specify a register and a bit:
131 | if (operands.size() >= 2) {
132 | String register = operands.get(0).get("register").toString();
133 | int bit = Integer.parseInt(operands.get(1).get("bit").toString(), 16);
134 | if((registers.getRegister(register) & (1 << bit)) == 0) {
135 | registers.setRegister("F", (byte) (registers.getRegister("F") | 0x80));
136 | }
137 | else {
138 | registers.setRegister("F", (byte) (registers.getRegister("F") & 0x7F));
139 | }
140 | }
141 | };
142 | }
143 |
144 |
145 |
146 | // Other mnemonics...
147 | return (registers, memory, operands) -> {
148 | // Lambda for default executor
149 | System.out.println("Executing default operation for mnemonic: " + operation.getMnemonic());
150 | };
151 | }
152 |
153 |
154 | public Operation getOperation(int opcode) {
155 | return operations.get(opcode);
156 | }
157 |
158 | // Other methods...
159 | }
160 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/cpu/Registers.java:
--------------------------------------------------------------------------------
1 | package gbc.model.cpu;
2 |
3 | public class Registers {
4 | private byte A, B, C, D, E, F, H, L;
5 | private char PC, SP;
6 |
7 | public Registers() {
8 | reset();
9 | }
10 |
11 | public byte getRegister(String register) {
12 | return switch (register) {
13 | case "A" -> A;
14 | case "B" -> B;
15 | case "C" -> C;
16 | case "D" -> D;
17 | case "E" -> E;
18 | case "F" -> F;
19 | case "H" -> H;
20 | case "L" -> L;
21 | default -> throw new IllegalArgumentException("Invalid register: " + register);
22 | };
23 | }
24 |
25 | public void setRegister(String register, byte value) {
26 | switch (register) {
27 | case "A" -> A = value;
28 | case "B" -> B = value;
29 | case "C" -> C = value;
30 | case "D" -> D = value;
31 | case "E" -> E = value;
32 | case "F" -> F = value;
33 | case "H" -> H = value;
34 | case "L" -> L = value;
35 | default -> throw new IllegalArgumentException("Invalid register: " + register);
36 | }
37 | }
38 |
39 | public char getPC() {
40 | return PC;
41 | }
42 |
43 | public void setPC(char value) {
44 | PC = value;
45 | }
46 |
47 | public char getSP() {
48 | return SP;
49 | }
50 |
51 | public void setSP(char value) {
52 | SP = value;
53 | }
54 |
55 | public char getAF() {
56 | return (char) ((A << 8) | (F & 0xFF));
57 | }
58 |
59 | public void setAF(char value) {
60 | A = (byte) ((value >> 8) & 0xFF);
61 | F = (byte) (value & 0xFF);
62 | }
63 |
64 | public char getBC() {
65 | return (char) ((B << 8) | (C & 0xFF));
66 | }
67 |
68 | public void setBC(char value) {
69 | B = (byte) ((value >> 8) & 0xFF);
70 | C = (byte) (value & 0xFF);
71 | }
72 |
73 | public char getDE() {
74 | return (char) ((D << 8) | (E & 0xFF));
75 | }
76 |
77 | public void setDE(char value) {
78 | D = (byte) ((value >> 8) & 0xFF);
79 | E = (byte) (value & 0xFF);
80 | }
81 |
82 | public char getHL() {
83 | return (char) ((H << 8) | (L & 0xFF));
84 | }
85 |
86 | public void setHL(char value) {
87 | H = (byte) ((value >> 8) & 0xFF);
88 | L = (byte) (value & 0xFF);
89 | }
90 |
91 | public void reset() {
92 | A = 0x01;
93 | B = 0x00;
94 | C = 0x13;
95 | D = 0x00;
96 | E = (byte) 0xD8;
97 | F = (byte) 0xB0;
98 | H = 0x01;
99 | L = 0x4d;
100 | SP = 0xfffe;
101 | PC = 0x0100;
102 | }
103 |
104 | public void incrementPC() {
105 | PC++;
106 | }
107 |
108 | @Override
109 | public String toString() {
110 | return "A: 0x" + String.format("%02X", A) + "\n" +
111 | "B: 0x" + String.format("%02X", B) + "\n" +
112 | "C: 0x" + String.format("%02X", C) + "\n" +
113 | "D: 0x" + String.format("%02X", D) + "\n" +
114 | "E: 0x" + String.format("%02X", E) + "\n" +
115 | "F: 0x" + String.format("%02X", F) + "\n" +
116 | "H: 0x" + String.format("%02X", H) + "\n" +
117 | "L: 0x" + String.format("%02X", L) + "\n" +
118 | "PC: 0x" + String.format("%04X", (int) PC) + "\n" +
119 | "SP: 0x" + String.format("%04X", (int) SP) + "\n";
120 | }
121 | }
122 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/graphics/GPU.java:
--------------------------------------------------------------------------------
1 | package gbc.model.graphics;
2 |
3 | import gbc.model.memory.Memory;
4 |
5 | public class GPU {
6 | private Memory memory;
7 | private Screen screen;
8 | private int[] frameBuffer = new int[160 * 144]; // Frame buffer array
9 |
10 | private int mode; // Current mode of the GPU
11 | private int modeClock; // Clock for timing mode changes
12 |
13 | public GPU(Memory memory, Screen screen) {
14 | this.memory = memory;
15 | this.screen = screen;
16 | this.mode = 2; // Start in OAM mode
17 | this.modeClock = 0;
18 | }
19 |
20 | public void step(int cycles) {
21 | modeClock += cycles;
22 | switch (mode) {
23 | case 2: // OAM mode
24 | if (modeClock >= 80) {
25 | modeClock = 0;
26 | mode = 3; // Switch to VRAM mode
27 | }
28 | break;
29 | case 3: // VRAM mode
30 | if (modeClock >= 172) {
31 | modeClock = 0;
32 | mode = 0; // Switch to HBlank
33 | updateLine();
34 | }
35 | break;
36 | case 0: // HBlank
37 | if (modeClock >= 204) {
38 | modeClock = 0;
39 | memory.writeByte(0xFF44, (byte) (memory.readByte(0xFF44) + 1));
40 | if (memory.readByte(0xFF44) == 143) {
41 | mode = 1; // Switch to VBlank
42 | // Render screen here
43 | } else {
44 | mode = 2; // Switch to OAM
45 | }
46 | }
47 | break;
48 |
49 | case 1: // VBlank
50 | if (modeClock >= 456) {
51 | modeClock = 0;
52 | memory.writeByte(0xFF44, (byte) (memory.readByte(0xFF44) + 1));
53 | if (memory.readByte(0xFF44) > 153) {
54 | mode = 2; // Switch to OAM
55 | memory.writeByte(0xFF44, (byte) 0);
56 | }
57 | }
58 | break;
59 |
60 | default:
61 | break;
62 |
63 |
64 | }
65 |
66 | }
67 |
68 | private void updateLine() {
69 | int currentLine = memory.readByte(0xFF44) & 0xFF; // Ensure it's treated as an unsigned byte
70 | if (currentLine < 0 || currentLine >= 144) {
71 | // Invalid scanline number, handle error or return
72 | return;
73 | }
74 | int offset = 160 * currentLine;
75 | for (int i = 0; i < 160; i++) {
76 | int index = i + offset;
77 | if (index >= 0 && index < frameBuffer.length) {
78 | frameBuffer[index] = 0xFFFFFF; // Set color to white
79 | }
80 | }
81 | screen.render(frameBuffer);
82 | }
83 |
84 | // Other methods for rendering tiles, sprites, etc.
85 |
86 | public void updateGraphics() {
87 | this.step(456);
88 | }
89 |
90 | public Screen getScreen() {
91 | return this.screen;
92 | }
93 |
94 | public void setScreen(Screen screen) {
95 | this.screen = screen;
96 | }
97 |
98 | public int[] getFrameBuffer() {
99 | return this.frameBuffer;
100 | }
101 |
102 | public void setFrameBuffer(int[] frameBuffer) {
103 | this.frameBuffer = frameBuffer;
104 | }
105 |
106 | public int getMode() {
107 | return this.mode;
108 | }
109 |
110 | public void setMode(int mode) {
111 | this.mode = mode;
112 | }
113 |
114 | public int getModeClock() {
115 | return this.modeClock;
116 | }
117 |
118 | public void setModeClock(int modeClock) {
119 | this.modeClock = modeClock;
120 | }
121 |
122 | public Memory getMemory() {
123 | return this.memory;
124 | }
125 |
126 | public void setMemory(Memory memory) {
127 | this.memory = memory;
128 | }
129 |
130 |
131 | }
132 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/graphics/Screen.java:
--------------------------------------------------------------------------------
1 | package gbc.model.graphics;
2 |
3 | import java.awt.*;
4 | import java.awt.image.BufferedImage;
5 | import javax.swing.JPanel;
6 |
7 | public class Screen extends JPanel {
8 | private static final int WIDTH = 160; // Game Boy screen width
9 | private static final int HEIGHT = 144; // Game Boy screen height
10 |
11 | private BufferedImage image;
12 |
13 | public Screen() {
14 | this.image = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
15 | setPreferredSize(new Dimension(WIDTH, HEIGHT));
16 | }
17 |
18 | public void render(int[] frameBuffer) {
19 | image.setRGB(0, 0, WIDTH, HEIGHT, frameBuffer, 0, WIDTH);
20 | repaint();
21 | }
22 |
23 | @Override
24 | protected void paintComponent(Graphics g) {
25 | super.paintComponent(g);
26 | g.drawImage(this.image, 0, 0, this);
27 | }
28 |
29 | public BufferedImage getImage() {
30 | return this.image;
31 | }
32 |
33 | public void setImage(BufferedImage image) {
34 | this.image = image;
35 | }
36 |
37 | public int getWidth() {
38 | return WIDTH;
39 | }
40 |
41 | public int getHeight() {
42 | return HEIGHT;
43 | }
44 |
45 | public void setPixel(int x, int y, int color) {
46 | this.image.setRGB(x, y, color);
47 | }
48 |
49 | public int getPixel(int x, int y) {
50 | return this.image.getRGB(x, y);
51 | }
52 |
53 | public void clear() {
54 | this.image = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
55 | }
56 |
57 | public void clear(int color) {
58 | for (int y = 0; y < HEIGHT; y++) {
59 | for (int x = 0; x < WIDTH; x++) {
60 | this.image.setRGB(x, y, color);
61 | }
62 | }
63 | }
64 |
65 | public void drawLine(int x1, int y1, int x2, int y2, int color) {
66 | int dx = Math.abs(x2 - x1);
67 | int dy = Math.abs(y2 - y1);
68 |
69 | int sx = (x1 < x2) ? 1 : -1;
70 | int sy = (y1 < y2) ? 1 : -1;
71 |
72 | int err = dx - dy;
73 |
74 | while (true) {
75 | this.setPixel(x1, y1, color);
76 |
77 | if ((x1 == x2) && (y1 == y2)) {
78 | break;
79 | }
80 |
81 | int e2 = 2 * err;
82 |
83 | if (e2 > -dy) {
84 | err -= dy;
85 | x1 += sx;
86 | }
87 |
88 | if (e2 < dx) {
89 | err += dx;
90 | y1 += sy;
91 | }
92 | }
93 | }
94 | }
95 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/memory/Memory.java:
--------------------------------------------------------------------------------
1 | package gbc.model.memory;
2 |
3 | import gbc.model.cartridge.Cartridge;
4 |
5 | public class Memory {
6 | private final byte[] memoryBank = new byte[0x10000]; // 65,536 bytes for the entire addressable range
7 | private Cartridge cartridge;
8 |
9 | public Memory() {
10 | reset();
11 | }
12 |
13 | public int readByte(int address) {
14 | if (address >= 0x0000 && address < 0x8000) {
15 | return cartridge.read(address) & 0xFF; // Ensure unsigned byte
16 | } else if (address >= 0x8000 && address <= 0xFFFF) {
17 | return memoryBank[address] & 0xFF; // Ensure unsigned byte
18 | } else {
19 | throw new IllegalArgumentException("Invalid address: " + address);
20 | }
21 | }
22 |
23 | public int readChar(int address) {
24 | int high = readByte(address + 1);
25 | int low = readByte(address);
26 | return (high << 8) | low;
27 | }
28 |
29 | public void writeByte(int address, int value) {
30 | byte byteValue = (byte) (value & 0xFF); // Ensure we store as byte
31 |
32 | if (address >= 0x0000 && address < 0x8000) {
33 | cartridge.write(address, byteValue);
34 | } else if (address >= 0x8000 && address <= 0xFFFF) {
35 | memoryBank[address] = byteValue;
36 | } else {
37 | throw new IllegalArgumentException("Invalid address: " + address);
38 | }
39 | }
40 |
41 | public void writeChar(int address, int value) {
42 | writeByte(address, value & 0xFF);
43 | writeByte(address + 1, (value >> 8) & 0xFF);
44 | }
45 |
46 | public void loadCartridge(Cartridge cartridge) {
47 | this.cartridge = cartridge;
48 | }
49 |
50 | public void reset() {
51 | for (int i = 0; i < memoryBank.length; i++) {
52 | memoryBank[i] = 0x00;
53 | }
54 | // Initialize other registers as required
55 | }
56 |
57 | @Override
58 | public String toString() {
59 | StringBuilder sb = new StringBuilder();
60 |
61 | // Header
62 | sb.append(String.format("%-6s | %-4s | %-6s | %-4s | %-6s | %-4s%n",
63 | "Address", "Value", "Address", "Value", "Address", "Value"));
64 |
65 | // Separator
66 | sb.append("------------------------------------------------------\n");
67 |
68 | for (int i = 0; i < memoryBank.length; i += 16) {
69 | for (int j = 0; j < 16; j++) {
70 | int address = i + j;
71 | if (address < memoryBank.length) {
72 | // Address Column
73 | sb.append(String.format("%04X", address));
74 |
75 | // Value Column
76 | sb.append(String.format(" | %02X ", memoryBank[address]));
77 |
78 | // Separator for next column set or end of line
79 | if (j % 5 == 4) {
80 | sb.append("| ");
81 | }
82 | }
83 | }
84 | sb.append("\n");
85 | }
86 | return sb.toString();
87 | }
88 |
89 | public char popFromStack() {
90 | char value = (char) readChar(0xFFFD);
91 | writeChar(0xFFFD, readChar(0xFFFD) + 1);
92 | return value;
93 | }
94 |
95 | public void pushToStack(byte value) {
96 | writeChar(0xFFFD, readChar(0xFFFD) - 1);
97 | writeByte(readChar(0xFFFD), value);
98 | }
99 |
100 |
101 |
102 | // Additional methods if needed
103 | }
104 |
--------------------------------------------------------------------------------
/src/main/java/gbc/model/sound/SoundChannel1.java:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/src/main/java/gbc/model/sound/SoundChannel1.java
--------------------------------------------------------------------------------
/src/main/java/gbc/model/sound/SoundChannel2.java:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/src/main/java/gbc/model/sound/SoundChannel2.java
--------------------------------------------------------------------------------
/src/main/java/gbc/view/DebugView.java:
--------------------------------------------------------------------------------
1 | package gbc.view;
2 |
3 | import gbc.model.GameBoyColor;
4 | import gbc.model.cpu.CPU;
5 | import gbc.model.memory.Memory;
6 |
7 | import javax.swing.*;
8 | import java.awt.*;
9 |
10 | public class DebugView extends JFrame {
11 |
12 | private final GameBoyColor gbc;
13 | private final CPU cpu;
14 | private final Memory memory;
15 | private final JTextArea opcodeArea;
16 | private final JTextArea memoryArea;
17 | private final JTextArea registerArea;
18 |
19 | public DebugView(GameBoyColor gbc) {
20 | this.gbc = gbc;
21 | this.cpu = gbc.getCpu();
22 | this.memory = gbc.getMemory();
23 |
24 |
25 | setTitle("Emulator Debug View");
26 | setPreferredSize(new Dimension(800, 600)); // Preferred size is used for better layout management
27 | setLayout(new BorderLayout());
28 |
29 | opcodeArea = createTextArea();
30 | memoryArea = createTextArea();
31 | registerArea = createTextArea();
32 |
33 | JTabbedPane tabbedPane = new JTabbedPane();
34 | tabbedPane.addTab("Opcodes", new JScrollPane(opcodeArea));
35 | tabbedPane.addTab("Memory", new JScrollPane(memoryArea));
36 | tabbedPane.addTab("Registers", new JScrollPane(registerArea));
37 |
38 | add(tabbedPane, BorderLayout.CENTER);
39 | setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // Change to DISPOSE to avoid shutting down the whole app
40 | pack(); // Use pack instead of setSize to fit components
41 | setLocationRelativeTo(null); // Center on screen
42 | setVisible(false);
43 |
44 | }
45 |
46 | private JTextArea createTextArea() {
47 | JTextArea textArea = new JTextArea();
48 | textArea.setFont(new Font("Monospaced", Font.PLAIN, 12)); // Set a monospaced font for alignment
49 | textArea.setEditable(false); // Set text area to be read-only
50 | return textArea;
51 | }
52 |
53 | public void update() {
54 |
55 | if (super.isVisible()) {
56 | updateOpcodes();
57 | updateMemory();
58 | updateRegisters();
59 | }
60 |
61 | }
62 |
63 | private void updateOpcodes() {
64 | // Display current opcode and next few opcodes
65 | opcodeArea.setText(cpu.getOpcodeLog()); // Requires toString method in Opcode class
66 | }
67 |
68 | private void updateMemory() {
69 | // Display a portion of memory or specific memory locations
70 | memoryArea.setText(memory.toString()); // Requires toString method in Memory class
71 | }
72 |
73 | private void updateRegisters() {
74 | // Display current register values
75 | registerArea.setText(cpu.getRegisters().toString()); // Requires toString method in Registers class
76 | }
77 | }
78 |
--------------------------------------------------------------------------------
/src/main/java/gbc/view/EmulatorView.java:
--------------------------------------------------------------------------------
1 | package gbc.view;
2 |
3 | import javax.swing.JPanel;
4 | import java.awt.*;
5 | import java.awt.image.BufferedImage;
6 | import java.io.Serial;
7 |
8 | import gbc.model.GameBoyColor;
9 | import gbc.model.graphics.Screen;
10 | import gbc.model.graphics.GPU;
11 |
12 | public class EmulatorView extends JPanel {
13 |
14 | @Serial
15 | private static final long serialVersionUID = 1L;
16 | private final GameBoyColor gbc;
17 |
18 | private GPU gpu;
19 | private Screen screen;
20 |
21 | public EmulatorView(GameBoyColor gbc) {
22 | this.gpu = gbc.getGpu();
23 | this.gbc = gbc;
24 | this.screen = gpu.getScreen();
25 | this.setPreferredSize(new Dimension(320, 288)); // Scaled size
26 | }
27 |
28 | @Override
29 | public void paintComponent(Graphics g) {
30 | super.paintComponent(g);
31 | BufferedImage image = screen.getImage();
32 | if (image != null) {
33 | g.drawImage(image, 0, 0, this.getWidth(), this.getHeight(), null);
34 | }
35 | }
36 |
37 | public void update() {
38 | this.gpu.updateGraphics();
39 | this.repaint();
40 | }
41 |
42 | public void setGPU(GPU gpu) {
43 | this.gpu = gpu;
44 | this.screen = gpu.getScreen();
45 | }
46 |
47 | public GPU getGPU() {
48 | return this.gpu;
49 | }
50 | }
--------------------------------------------------------------------------------
/src/main/java/gbc/view/EmulatorWindow.java:
--------------------------------------------------------------------------------
1 | package gbc.view;
2 |
3 | import gbc.model.GameBoyColor;
4 |
5 | import javax.swing.*;
6 |
7 | public class EmulatorWindow extends JFrame {
8 | DebugView debugView;
9 | EmulatorView emulatorView;
10 | MenuBar menuBar;
11 |
12 | GameBoyColor gbc;
13 |
14 | public EmulatorWindow(GameBoyColor gbc) {
15 | this.gbc = gbc;
16 | this.debugView = new DebugView(gbc);
17 | this.emulatorView = new EmulatorView(gbc);
18 | this.menuBar = new MenuBar(gbc, debugView);
19 |
20 | this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
21 | this.setBounds(100, 100, 320, 288); // Scaled size for better visibility
22 | this.setContentPane(this.emulatorView);
23 | this.pack();
24 | this.setVisible(true);
25 | this.setResizable(false);
26 | this.setJMenuBar(menuBar);
27 | }
28 |
29 | public void update() {
30 | this.emulatorView.update();
31 | this.debugView.update();
32 | }
33 |
34 | public void openDebugView() {
35 | this.debugView.setVisible(true);
36 | }
37 |
38 | }
--------------------------------------------------------------------------------
/src/main/java/gbc/view/MenuBar.java:
--------------------------------------------------------------------------------
1 | package gbc.view;
2 |
3 | import gbc.model.GameBoyColor;
4 | import gbc.model.cpu.CPU;
5 | import gbc.model.memory.Memory;
6 |
7 | import javax.swing.*;
8 | import javax.swing.filechooser.FileNameExtensionFilter;
9 | import java.awt.event.ActionEvent;
10 | import java.io.File;
11 | import java.io.IOException;
12 |
13 | public class MenuBar extends JMenuBar {
14 |
15 | private final GameBoyColor gbc;
16 | private CPU cpu;
17 | private Memory memory;
18 |
19 | private final DebugView debugView;
20 |
21 | public MenuBar(GameBoyColor gbc, DebugView debugView) {
22 | this.gbc = gbc;
23 | this.cpu = gbc.getCpu();
24 | this.memory = gbc.getMemory();
25 | this.debugView = debugView;
26 |
27 |
28 | JMenu fileMenu = new JMenu("File");
29 | JMenuItem openItem = new JMenuItem("Open");
30 | JMenuItem debugItem = new JMenuItem("Debug View");
31 | JMenuItem exitItem = new JMenuItem("Exit");
32 |
33 | fileMenu.add(openItem);
34 | fileMenu.add(debugItem);
35 | fileMenu.addSeparator();
36 | fileMenu.add(exitItem);
37 |
38 | openItem.addActionListener(this::openFile);
39 | debugItem.addActionListener(this::openDebugView);
40 | exitItem.addActionListener(e -> closeApplication(
41 | new ActionEvent(this, ActionEvent.ACTION_PERFORMED, null)
42 | ));
43 |
44 | this.add(fileMenu);
45 | }
46 |
47 | private void openFile(ActionEvent e) {
48 | JFileChooser fileChooser = new JFileChooser();
49 | fileChooser.setDialogTitle("Open ROM File");
50 | fileChooser.setAcceptAllFileFilterUsed(false);
51 | FileNameExtensionFilter filter = new FileNameExtensionFilter("ROM Files", "gb", "gbc");
52 | fileChooser.addChoosableFileFilter(filter);
53 |
54 | int result = fileChooser.showOpenDialog(this);
55 | if (result == JFileChooser.APPROVE_OPTION) {
56 | File selectedFile = fileChooser.getSelectedFile();
57 | try {
58 | loadROM(selectedFile);
59 | } catch (IOException ex) {
60 | // Handle exception
61 | ex.printStackTrace();
62 | }
63 | }
64 | }
65 |
66 | private void loadROM(File file) throws IOException {
67 | // Implement the logic to load and start the ROM
68 | System.out.println("Loading ROM: " + file.getAbsolutePath());
69 | // You might need to call a method from your emulator core here
70 | this.gbc.insertCartridge(file.getAbsolutePath());
71 | }
72 |
73 | private void openDebugView(ActionEvent e) {
74 | debugView.setVisible(true);
75 |
76 | }
77 |
78 | private void closeApplication(ActionEvent e) {
79 | // Assuming that this class is an inner class of a JFrame subclass
80 | SwingUtilities.getWindowAncestor(this).dispose();
81 | }
82 | }
--------------------------------------------------------------------------------
/src/main/java/main.java:
--------------------------------------------------------------------------------
1 | import gbc.controller.EmulatorController;
2 |
3 |
4 | public class main {
5 |
6 | public static void main(String[] args) {
7 | EmulatorController controller = new EmulatorController();
8 | controller.loadRom("./Tetris.gb");
9 | controller.start();
10 | }
11 |
12 |
13 | }
14 |
--------------------------------------------------------------------------------
/src/main/resources/opcodes.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | // ... (lineas para modificar flags)
4 | println "Ejecutando INC1";
5 |
6 |
7 |
8 |
9 | println "Ejecutando INC2";
10 |
11 |
12 |
13 |
--------------------------------------------------------------------------------
/src/test/java/gbc/MemoryTest.java:
--------------------------------------------------------------------------------
1 | package gbc;
2 |
3 | import gbc.controller.FileLoader;
4 | import gbc.model.cartridge.CartridgeFactory;
5 | import gbc.model.memory.Memory;
6 | import gbc.model.cartridge.Cartridge;
7 | import org.junit.jupiter.api.BeforeEach;
8 | import org.junit.jupiter.api.Test;
9 | import static org.junit.jupiter.api.Assertions.*;
10 | import java.util.HashMap;
11 |
12 | public class MemoryTest {
13 | private Memory memory;
14 | private Cartridge cartridge;
15 |
16 | @BeforeEach
17 | public void setUp() {
18 | memory = new Memory();
19 | cartridge = CartridgeFactory.create(FileLoader.loadFile("./Pokemon.gb"));
20 | memory.loadCartridge(cartridge);
21 | }
22 |
23 | @Test
24 | public void testReadAndWriteByte() {
25 | int address = 0x9871;
26 | byte value = (byte) 0xAB;
27 |
28 | memory.writeByte(address, value);
29 | byte result = memory.readByte(address);
30 |
31 | assertEquals(value, result);
32 | }
33 |
34 | @Test
35 | public void testReadAndWriteChar() {
36 | int address = 0x9871;
37 | char value = (char) 0xCDEF;
38 |
39 | memory.writeChar(address, value);
40 | char result = memory.readChar(address);
41 |
42 | assertEquals(value, result);
43 | }
44 |
45 | @Test
46 | public void testReadFromCartridge() {
47 | int address = 0x2000;
48 | byte value = (byte) 0x55;
49 |
50 | cartridge.write(address, value);
51 | byte result = memory.readByte(address);
52 |
53 | assertEquals(value, result);
54 | }
55 |
56 | @Test
57 | public void testWriteToCartridge() {
58 | int address = 0x3000;
59 | byte value = (byte) 0xAA;
60 |
61 | memory.writeByte(address, value);
62 | byte result = cartridge.read(address);
63 |
64 | assertEquals(value, result);
65 | }
66 |
67 | @Test
68 | public void testGetMemoryRange() {
69 | int startAddress = 0x8001;
70 | int endAddress = 0x8040;
71 |
72 | byte[] values = {(byte) 0x11, (byte) 0x22, (byte) 0x33, (byte) 0x44, (byte) 0x55, (byte) 0x66};
73 |
74 | for (int i = 0; i < values.length; i++) {
75 | memory.writeByte(startAddress + i, values[i]);
76 | }
77 |
78 | HashMap result = memory.getMemoryRange(startAddress, endAddress);
79 |
80 | for (int i = 0; i < values.length; i++) {
81 | assertEquals(values[i], result.get(startAddress + i));
82 | }
83 | }
84 |
85 | @Test
86 | public void testReset() {
87 | int address = 0x9132;
88 | byte value = (byte) 0xAB;
89 |
90 | memory.writeByte(address, value);
91 | memory.reset();
92 | byte result = memory.readByte(address);
93 |
94 | assertEquals((byte) 0x00, result);
95 | }
96 |
97 | @Test
98 | public void testInvalidAddressRead() {
99 | int invalidAddress = 0x10000; // Beyond the memory range
100 | assertThrows(IllegalArgumentException.class, () -> {
101 | memory.readByte(invalidAddress);
102 | });
103 | }
104 |
105 | @Test
106 | public void testInvalidAddressWrite() {
107 | int invalidAddress = 0x10000; // Beyond the memory range
108 | assertThrows(IllegalArgumentException.class, () -> {
109 | memory.writeByte(invalidAddress, (byte) 0x00);
110 | });
111 | }
112 | }
113 |
--------------------------------------------------------------------------------
/src/test/java/gbc/RegistersTest.java:
--------------------------------------------------------------------------------
1 | package gbc.model.cpu;
2 |
3 | import org.junit.jupiter.api.BeforeEach;
4 | import org.junit.jupiter.api.Test;
5 | import static org.junit.jupiter.api.Assertions.*;
6 |
7 | public class RegistersTest {
8 | private Registers registers;
9 |
10 | @BeforeEach
11 | public void setUp() {
12 | registers = new Registers();
13 | }
14 |
15 | @Test
16 | public void testGetAndSetRegisters() {
17 | byte[] testValues = {10, 20, 30, 40, 50, 60, 70, 80};
18 | String[] registerNames = {"A", "B", "C", "D", "E", "F", "H", "L"};
19 |
20 | for (int i = 0; i < registerNames.length; i++) {
21 | String register = registerNames[i];
22 | byte testValue = testValues[i];
23 |
24 | registers.setRegister(register, testValue);
25 | assertEquals(testValue, registers.getRegister(register), "Mismatch in register " + register);
26 | }
27 | }
28 |
29 |
30 | @Test
31 | public void testGetAndSetRegisterPairs() {
32 | registers.setAF((char) 100);
33 | assertEquals(100, registers.getAF());
34 |
35 | registers.setBC((char) 200);
36 | assertEquals(200, registers.getBC());
37 |
38 | registers.setDE((char) 300);
39 | assertEquals(300, registers.getDE());
40 |
41 | registers.setHL((char) 400);
42 | assertEquals(400, registers.getHL());
43 |
44 | registers.setSP((char) 500);
45 | assertEquals(500, registers.getSP());
46 |
47 | registers.setPC((char) 600);
48 | assertEquals(600, registers.getPC());
49 | }
50 | }
--------------------------------------------------------------------------------
/target/classes/gbc/controller/EmulatorController.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/controller/EmulatorController.class
--------------------------------------------------------------------------------
/target/classes/gbc/controller/FileLoader.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/controller/FileLoader.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/GameBoyColor.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/GameBoyColor.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/cartridge/Cartridge.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/cartridge/Cartridge.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/cartridge/CartridgeFactory.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/cartridge/CartridgeFactory.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/cartridge/MBC1.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/cartridge/MBC1.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/cartridge/MBC2.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/cartridge/MBC2.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/cartridge/MBC3.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/cartridge/MBC3.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/cartridge/MBC5.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/cartridge/MBC5.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/cartridge/ROM.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/cartridge/ROM.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/controller/Controller.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/controller/Controller.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/cpu/CPU.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/cpu/CPU.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/cpu/Instructions.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/cpu/Instructions.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/cpu/Interruptions.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/cpu/Interruptions.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/cpu/Operation.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/cpu/Operation.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/cpu/Registers.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/cpu/Registers.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/graphics/GPU.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/graphics/GPU.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/graphics/Screen.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/graphics/Screen.class
--------------------------------------------------------------------------------
/target/classes/gbc/model/memory/Memory.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/model/memory/Memory.class
--------------------------------------------------------------------------------
/target/classes/gbc/view/DebugView.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/view/DebugView.class
--------------------------------------------------------------------------------
/target/classes/gbc/view/EmulatorView.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/view/EmulatorView.class
--------------------------------------------------------------------------------
/target/classes/gbc/view/MenuBar.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/gbc/view/MenuBar.class
--------------------------------------------------------------------------------
/target/classes/main.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/classes/main.class
--------------------------------------------------------------------------------
/target/test-classes/gbc/MemoryTest.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/murapadev/GBJava/ae578ecaa476b27bb0eb89754ab4e6bbed312663/target/test-classes/gbc/MemoryTest.class
--------------------------------------------------------------------------------