开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
Io.cpp
资源名称：fcSOURCE.rar　[点击查看]
上传用户：luhy168
上传日期：2022-01-10
资源大小：240k
文件大小：9k
源码类别：

模拟服务器

开发平台：

Visual C++

Io.cpp：源码内容
  1. //------------------------------------------------------------------------------
  2. // Name: Io.cpp
  3. // Desc: Holds all the functions to read and write to memory.
  4. //------------------------------------------------------------------------------
  6. // Includes
  7. #include <windows.h>
  8. #include "Io.h"
  9. #include "Sound.h"
  12. //------------------------------------------------------------------------------
  13. // Name: GetMemoryByte()
  14. // Desc: Returns a byte from the Cpu's memory.
  15. //------------------------------------------------------------------------------
  16. BYTE __stdcall GetMemoryByte(WORD wAddress)
  17. {
  18. if (wAddress >= 0x8000 && wAddress < 0xC000)
  19. return CPU.pbyPRGROMBank1[wAddress-0x8000];
  20. else if (wAddress >= 0xC000 && wAddress <= 0xFFFF)
  21. return CPU.pbyPRGROMBank2[wAddress-0xC000];
  22. else
  23. return CPU.Memory[wAddress];
  24. } // end GetMemoryByte()
  27. //------------------------------------------------------------------------------
  28. // Name: GetMemoryPointer()
  29. // Desc: Returns a pointer to a byte from the Cpu's memory.
  30. //------------------------------------------------------------------------------
  31. BYTE* __stdcall GetMemoryPointer(WORD wAddress)
  32. {
  33. if (wAddress >= 0x8000 && wAddress < 0xC000)
  34. return (&(CPU.pbyPRGROMBank1[wAddress-0x8000]));
  35. else if (wAddress >= 0xC000 && wAddress <= 0xFFFF)
  36. return (&(CPU.pbyPRGROMBank2[wAddress-0xC000]));
  37. else
  38. return (&(CPU.Memory[wAddress]));
  39. } // end GetMemoryPointer()
  42. //------------------------------------------------------------------------------
  43. // Name: ReadMemory()
  44. // Desc: N/A
  45. //------------------------------------------------------------------------------
  46. BYTE __stdcall ReadMemory(WORD wAddress)
  47. {
  48. static BYTE byVRAMBuffer; // See the case where wAddress=0x2007.
  50. if (wAddress >= 0x8000 && wAddress <= 0xFFFF)
  51. return MapperOnRead(wAddress);
  52. else
  53. {
  54. // Check for all the register reads.
  55. if (wAddress == 0x2002)
  56. {
  57. BYTE byRetVal = CPU.Memory[0x2002];
  59. // Clear the vblank bit.
  60. CPU.Memory[0x2002] &= 0x7F;
  61. // Clear the VRAM toggle.
  62. byVRAMAddrRegToggle = 0;
  64. return byRetVal;
  65. }
  66. else if (wAddress == 0x2003)
  67. {
  68. return CPU.Memory[0x2003];
  69. }
  70. else if (wAddress == 0x2004)
  71. {
  72. return abySPRRAM[CPU.Memory[0x2003]];
  73. }
  74. else if (wAddress == 0x2007)
  75. {
  76. /*
  77.  * Cut and paste from yoshi's document nestech.txt
  78.  *
  79.  O. PPU Quirks
  80.  -------------
  81. The first read from VRAM is invalid. Due to this aspect, the NES will
  82. returned pseudo-buffered values from VRAM rather than linear as expec-
  83. ted. See the below example:
  85. VRAM $2000 contains $AA $BB $CC $DD.
  86. VRAM incrementation value is 1.
  87. The result of execution is printed in the comment field. 
  89. LDA #$20
  90. STA $2006
  91. LDA #$00
  92. STA $2006        ; VRAM address now set at $2000
  93. LDA $2007        ; A=??     VRAM Buffer=$AA
  94. LDA $2007        ; A=$AA    VRAM Buffer=$BB
  95. LDA $2007        ; A=$BB    VRAM Buffer=$CC
  96. LDA #$20
  97. STA $2006
  98. LDA #$00
  99. STA $2006        ; VRAM address now set at $2000
  100. LDA $2007        ; A=$CC    VRAM Buffer=$AA
  101. LDA $2007        ; A=$AA    VRAM Buffer=$BB
  103. As shown, the PPU will post-increment it's internal address data after
  104. the first read is performed. This *ONLY APPLIES* to VRAM $0000-3EFF
  105. (e.g. Palette data and their respective mirrors do not suffer from
  106. this phenomenon).
  107. */
  108. if (wVRAMAddress >= 0 && wVRAMAddress < 0x3F00)
  109. {
  110. BYTE byReturnVal = byVRAMBuffer;
  112. // Read the byte into the VRAM buffer.
  113. byVRAMBuffer = PPUReadMemory(wVRAMAddress);
  115. // Increment the address by 1 or 32 depending on the
  116. // status of bit 2 of reg $2000.
  117. (CPU.Memory[0x2000] & 4) ? (wVRAMAddress += 32) : wVRAMAddress++;
  119. return byReturnVal;
  120. }
  121. else
  122. return PPUReadMemory(wVRAMAddress);
  123. }
  124. // All the APU registers.
  125. else if (wAddress == 0x4015)
  126. {
  127. return APU_Read(wAddress);
  128. }
  129. else if (wAddress == 0x4016)
  130. {
  131. return Joy1.read();
  132. }
  134. // If its not one of the registers, then just write the byte to memory.
  135. else
  136. return CPU.Memory[wAddress];
  137. }
  139. return 0;
  140. } // end ReadMemory()
  143. //------------------------------------------------------------------------------
  144. // Name: WriteMemory()
  145. // Desc: Writes to CPU memory and checks to see if its a register write as
  146. //       well. Then depending on if its a register write, it does the
  147. //       appropriate action.
  148. //------------------------------------------------------------------------------
  149. VOID __stdcall WriteMemory(WORD wAddress, BYTE byData)
  150. {
  151. // PRG-ROM writes.
  152. if (wAddress >= 0x8000 && wAddress <= 0xFFFF)
  153. MapperOnWrite(wAddress, byData);
  154. else 
  155. {
  156. // Check for all the register writes.
  157. if (wAddress == 0x2000)
  158. {
  159. CPU.Memory[0x2000] = byData;
  160. }
  161. else if (wAddress == 0x2001)
  162. {
  163. CPU.Memory[0x2001] = byData;
  164. }
  165. else if (wAddress == 0x2003)
  166. {
  167. // Save the address to access sprite ram with.
  168. CPU.Memory[0x2003] = byData;
  169. }
  170. else if (wAddress == 0x2004)
  171. {
  172. // Write the data into the sprite ram at the
  173. // addres specified in register $2003.
  174. abySPRRAM[CPU.Memory[0x2003]] = byData;
  175. }
  176. else if (wAddress == 0x2005)
  177. {
  178. // The second write is the vertical scroll, the
  179. // first write is the horizontal scroll.
  180. if (byVRAMAddrRegToggle)
  181. byVScroll[0] = byData;
  182. else
  183. byHScroll[0] = byData;
  185. // Toggle to indicate that we are on the second write.
  186. byVRAMAddrRegToggle ^= 1;
  187. }
  188. else if (wAddress == 0x2006)
  189. {
  190. if (byVRAMAddrRegToggle)
  191. // Write the lower byte into the VRAM address register.
  192. *((BYTE*)(&wVRAMAddress)) = byData;
  193. else
  194. // Write the upper byte into the VRAM address register.
  195. *(((BYTE*)(&wVRAMAddress))+1) = byData;
  197. // Toggle to indicate that we are on the second write.
  198. byVRAMAddrRegToggle ^= 1;
  199. }
  200. else if (wAddress == 0x2007)
  201. {
  202. // Write the byte to video memory.
  203. PPUWriteMemory(wVRAMAddress, byData);
  205. // Increment the address by 1 or 32 depending on the
  206. // status of bit 2 of reg $2000.
  207. (CPU.Memory[0x2000] & 4) ? (wVRAMAddress += 32) : wVRAMAddress++;
  208. }
  209. // All the APU registers.
  210. else if (wAddress == 0x4003 || wAddress == 0x4015)
  211. {
  212. CPU.Memory[wAddress] = byData;
  213. APU_Write(wAddress, byData);
  214. }
  215. else if (wAddress == 0x4014)
  216. {
  217. // Transfers 256 bytes of memory into SPR-RAM. The address
  218. // read from is $100*N, where N is the value written.
  219. memcpy(abySPRRAM, &CPU.Memory[0x100*byData], 256);
  220. CPU.Memory[0x4014] = byData;
  221. }
  222. else if (wAddress == 0x4016)
  223. {
  224. Joy1.write(byData);
  225. CPU.Memory[0x4016] = byData;
  226. }
  227. // If its not one of the registers, then just write the byte to memory.
  228. else
  229. CPU.Memory[wAddress] = byData;
  230. }
  232. } // end WriteMemory()
  235. //------------------------------------------------------------------------------
  236. // Name: PPUReadMemory()
  237. // Desc: N/A
  238. //------------------------------------------------------------------------------
  239. BYTE __stdcall PPUReadMemory(WORD wAddress)
  240. {
  241. // Pattern table read.
  242. if (wAddress < 0x1000)
  243. return *((PPU.apbyPatternTables[0])+(wAddress));
  244. else if (wAddress >= 0x1000 && wAddress < 0x2000)
  245. return *((PPU.apbyPatternTables[1])+(wAddress-0x1000));
  246. else if (wAddress >= 0x2000 && wAddress < 0x3000)
  247. {
  248. if (wAddress >= 0x2000 && wAddress < 0x2400)
  249. return *(PPU.apbyNameTables[0] + (wAddress - 0x2000));
  250. else if (wAddress >= 0x2400 && wAddress < 0x2800)
  251. return *(PPU.apbyNameTables[1] + (wAddress - 0x2400));
  252. else if (wAddress >= 0x2800 && wAddress < 0x2C00)
  253. return *(PPU.apbyNameTables[2] + (wAddress - 0x2800));
  254. else
  255. return *(PPU.apbyNameTables[3] + (wAddress - 0x2C00));
  256. }
  257. else if (wAddress >= 0x3F00 && wAddress < 0x3F20)
  258. return PPU.abyPalettes[wAddress-0x3F00];
  259. else
  260. return 0;
  261. } // end PPUReadMemory()
  264. //------------------------------------------------------------------------------
  265. // Name: PPUWriteMemory()
  266. // Desc: N/A
  267. //------------------------------------------------------------------------------
  268. VOID __stdcall PPUWriteMemory(WORD wAddress, BYTE byData)
  269. {
  270. // Pattern table write.
  271. if (wAddress < 0x1000)
  272. *((PPU.apbyPatternTables[0])+(wAddress)) = byData;
  273. else if (wAddress >= 0x1000 && wAddress < 0x2000)
  274. *((PPU.apbyPatternTables[1])+(wAddress-0x1000)) = byData;
  275. else if (wAddress >= 0x2000 && wAddress < 0x3000)
  276. {
  277. if (wAddress >= 0x2000 && wAddress < 0x2400)
  278. *(PPU.apbyNameTables[0] + (wAddress - 0x2000)) = byData;
  279. else if (wAddress >= 0x2400 && wAddress < 0x2800)
  280. *(PPU.apbyNameTables[1] + (wAddress - 0x2400)) = byData;
  281. else if (wAddress >= 0x2800 && wAddress < 0x2C00)
  282. *(PPU.apbyNameTables[2] + (wAddress - 0x2800)) = byData;
  283. else
  284. *(PPU.apbyNameTables[3] + (wAddress - 0x2C00)) = byData;
  285. }
  286. else if (wAddress >= 0x3F00 && wAddress < 0x3F20)
  287. PPU.abyPalettes[wAddress-0x3F00] = byData;
  288. } // end PPUWriteMemory()