Mercurial > vba-linux

comparison src/gb/gbSGB.cpp @ 17:75e5bb1e0aa1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
going to now integrate the gb src tree since it has no dependencies
author Robert McIntyre <rlm@mit.edu>
date Sat, 03 Mar 2012 11:44:47 -0600
parents f9f4f1b99eed
children
comparison
equal deleted inserted replaced
16:9e598342e182 17:75e5bb1e0aa1
1 #include <cstdlib>
2 #include <cstring>
3
4 #include "../common/System.h"
5 #include "../common/Util.h"
6 #include "GB.h"
7 #include "gbGlobals.h"
8 #include "../common/movie.h"
9
10 extern u8 * pix;
11
12 #define GBSGB_NONE 0
13 #define GBSGB_RESET 1
14 #define GBSGB_PACKET_TRANSMIT 2
15
16 u8 gbSgbBorderChar [32 * 256];
17 u8 gbSgbBorder [2048];
18
19 int32 gbSgbCGBSupport = 0;
20 int32 gbSgbMask = 0;
21 int32 gbSgbMode = 0;
22 int32 gbSgbPacketState = GBSGB_NONE;
23 int32 gbSgbBit = 0;
24 int32 gbSgbPacketTimeout = 0;
25 int32 GBSGB_PACKET_TIMEOUT = 66666;
26 u8 gbSgbPacket[16 * 7];
27 int32 gbSgbPacketNBits = 0;
28 int32 gbSgbPacketByte = 0;
29 int32 gbSgbPacketNumber = 0;
30 int32 gbSgbMultiplayer = 0;
31 int32 gbSgbFourPlayers = 0;
32 u8 gbSgbNextController = 0x0f;
33 u8 gbSgbReadingController = 0;
34 u16 gbSgbSCPPalette[4 * 512];
35 u8 gbSgbATF[20 * 18];
36 u8 gbSgbATFList[45 * 20 * 18];
37 u8 gbSgbScreenBuffer[4160];
38
39 inline void gbSgbDraw24Bit(u8 *p, u16 v)
40 {
41 *((u32 *) p) = systemColorMap32[v];
42 }
43
44 inline void gbSgbDraw32Bit(u32 *p, u16 v)
45 {
46 *p = systemColorMap32[v];
47 }
48
49 inline void gbSgbDraw16Bit(u16 *p, u16 v)
50 {
51 *p = systemColorMap16[v];
52 }
53
54 void gbSgbReset()
55 {
56 gbSgbPacketTimeout = 0;
57 gbSgbCGBSupport = 0;
58 gbSgbMask = 0;
59 gbSgbPacketState = GBSGB_NONE;
60 gbSgbBit = 0;
61 gbSgbPacketNBits = 0;
62 gbSgbPacketNumber = 0;
63 gbSgbMultiplayer = 0;
64 gbSgbFourPlayers = 0;
65 gbSgbNextController = 0x0f;
66 gbSgbReadingController = 0;
67
68 memset(gbSgbSCPPalette, 0, 512 * 4);
69 memset(gbSgbATF, 0, 20 * 18);
70 memset(gbSgbATFList, 0, 45 * 20 * 18);
71 memset(gbSgbPacket, 0, 16 * 7);
72 memset(gbSgbBorderChar, 0, 32 * 256);
73 memset(gbSgbBorder, 0, 2048);
74
75 int i;
76 for (i = 1; i < 2048; i += 2)
77 {
78 gbSgbBorder[i] = 1 << 2;
79 }
80
81 for (i = 0; i < 4; i++)
82 {
83 gbPalette[i * 4] = (0x1f) | (0x1f << 5) | (0x1f << 10);
84 gbPalette[i * 4 + 1] = (0x15) | (0x15 << 5) | (0x15 << 10);
85 gbPalette[i * 4 + 2] = (0x0c) | (0x0c << 5) | (0x0c << 10);
86 gbPalette[i * 4 + 3] = 0;
87 }
88 }
89
90 void gbSgbInit()
91 {
92 gbSgbReset();
93 }
94
95 void gbSgbShutdown()
96 {
97 memset(gbSgbBorderChar, 0, 32 * 256);
98 memset(gbSgbBorder, 0, 2048);
99 }
100
101 void gbSgbFillScreen(u16 color)
102 {
103 switch (systemColorDepth)
104 {
105 case 16:
106 {
107 for (int y = 0; y < 144; y++)
108 {
109 int yLine = (y + gbBorderRowSkip + 1) * (gbBorderLineSkip + 2) +
110 gbBorderColumnSkip;
111 u16 *dest = (u16 *)pix + yLine;
112 for (register int x = 0; x < 160; x++)
113 gbSgbDraw16Bit(dest++, color);
114 }
115 }
116 break;
117 case 24:
118 {
119 for (int y = 0; y < 144; y++)
120 {
121 int yLine = (y + gbBorderRowSkip) * gbBorderLineSkip + gbBorderColumnSkip;
122 u8 *dest = (u8 *)pix + yLine * 3;
123 for (register int x = 0; x < 160; x++)
124 {
125 gbSgbDraw24Bit(dest, color);
126 dest += 3;
127 }
128 }
129 }
130 break;
131 case 32:
132 {
133 for (int y = 0; y < 144; y++)
134 {
135 int yLine = (y + gbBorderRowSkip + 1) * (gbBorderLineSkip + 1) + gbBorderColumnSkip;
136 u32 *dest = (u32 *)pix + yLine;
137 for (register int x = 0; x < 160; x++)
138 {
139 gbSgbDraw32Bit(dest++, color);
140 }
141 }
142 }
143 break;
144 }
145 }
146
147 void gbSgbRenderScreenToBuffer()
148 {
149 u16 mapAddress = 0x9800;
150
151 if (register_LCDC & 0x08)
152 mapAddress = 0x9c00;
153
154 u16 patternAddress = 0x8800;
155
156 int flag = 1;
157
158 if (register_LCDC & 0x10)
159 {
160 patternAddress = 0x8000;
161 flag = 0;
162 }
163
164 u8 *toAddress = gbSgbScreenBuffer;
165
166 for (int i = 0; i < 13; i++)
167 {
168 for (int j = 0; j < 20; j++)
169 {
170 int tile = gbReadMemoryQuick(mapAddress);
171 mapAddress++;
172
173 if (flag)
174 {
175 if (tile > 127)
176 tile -= 128;
177 else
178 tile += 128;
179 }
180 for (int k = 0; k < 16; k++)
181 *toAddress++ = gbReadMemoryQuick(patternAddress + tile * 16 + k);
182 }
183 mapAddress += 12;
184 }
185 }
186
187 void gbSgbDrawBorderTile(int x, int y, int tile, int attr)
188 {
189 u16 *dest = (u16 *)pix + ((y + 1) * (256 + 2)) + x;
190 u8 * dest8 = (u8 *)pix + ((y * 256) + x) * 3;
191 u32 *dest32 = (u32 *)pix + ((y + 1) * 257) + x;
192
193 u8 *tileAddress = &gbSgbBorderChar[tile * 32];
194 u8 *tileAddress2 = &gbSgbBorderChar[tile * 32 + 16];
195
196 u8 l = 8;
197
198 u8 palette = ((attr >> 2) & 7);
199
200 if (palette < 4)
201 palette += 4;
202
203 palette *= 16;
204
205 u8 xx = 0;
206 u8 yy = 0;
207
208 int flipX = attr & 0x40;
209 int flipY = attr & 0x80;
210
211 while (l > 0)
212 {
213 u8 mask = 0x80;
214 u8 a = *tileAddress++;
215 u8 b = *tileAddress++;
216 u8 c = *tileAddress2++;
217 u8 d = *tileAddress2++;
218
219 while (mask > 0)
220 {
221 u8 color = 0;
222 if (a & mask)
223 color++;
224 if (b & mask)
225 color += 2;
226 if (c & mask)
227 color += 4;
228 if (d & mask)
229 color += 8;
230
231 u8 xxx = xx;
232 u8 yyy = yy;
233
234 if (flipX)
235 xxx = 7 - xx;
236 if (flipY)
237 yyy = 7 - yy;
238
239 u8 realx = x + xxx;
240 u8 realy = y + yyy;
241
242 u16 c = gbPalette[palette + color];
243 if (!color)
244 c = gbPalette[0];
245 if ((realy < 40 || realy >= 184) || (realx < 48 || realx >= 208))
246 {
247 switch (systemColorDepth)
248 {
249 case 16:
250 gbSgbDraw16Bit(dest + yyy * (256 + 2) + xxx, c);
251 break;
252 case 24:
253 gbSgbDraw24Bit(dest8 + (yyy * 256 + xxx) * 3, c);
254 break;
255 case 32:
256 gbSgbDraw32Bit(dest32 + yyy * (256 + 1) + xxx, c);
257 break;
258 }
259 }
260
261 mask >>= 1;
262
263 xx++;
264 }
265 yy++;
266 xx = 0;
267 l--;
268 mask = 0x80;
269 }
270 }
271
272 void gbSgbRenderBorder()
273 {
274 if (gbBorderOn)
275 {
276 u8 *fromAddress = gbSgbBorder;
277
278 for (u8 y = 0; y < 28; y++)
279 {
280 for (u8 x = 0; x < 32; x++)
281 {
282 u8 tile = *fromAddress++;
283 u8 attr = *fromAddress++;
284
285 gbSgbDrawBorderTile(x * 8, y * 8, tile, attr);
286 }
287 }
288 }
289 }
290
291 void gbSgbPicture()
292 {
293 gbSgbRenderScreenToBuffer();
294
295 memcpy(gbSgbBorder, gbSgbScreenBuffer, 2048);
296
297 u16 *paletteAddr = (u16 *)&gbSgbScreenBuffer[2048];
298
299 for (int i = 64; i < 128; i++)
300 {
301 gbPalette[i] = READ16LE(paletteAddr++);
302 }
303
304 gbSgbCGBSupport |= 4;
305
306 if (gbBorderAutomatic && !gbBorderOn && gbSgbCGBSupport > 4)
307 {
308 gbBorderOn = 1;
309 systemGbBorderOn();
310 }
311
312 if (gbBorderOn && !gbSgbMask)
313 gbSgbRenderBorder();
314
315 if (gbSgbMode && gbCgbMode && gbSgbCGBSupport > 4)
316 {
317 gbSgbCGBSupport = 0;
318 gbSgbMode = 2;
319 gbSgbMask = 0;
320 gbSgbRenderBorder();
321 gbReset();
322 }
323
324 if (gbSgbCGBSupport > 4)
325 gbSgbCGBSupport = 0;
326 }
327
328 void gbSgbSetPalette(int a, int b, u16 *p)
329 {
330 u16 bit00 = READ16LE(p++);
331 int i;
332
333 for (i = 1; i < 4; i++)
334 {
335 gbPalette[a * 4 + i] = READ16LE(p++);
336 }
337
338 for (i = 1; i < 4; i++)
339 {
340 gbPalette[b * 4 + i] = READ16LE(p++);
341 }
342
343 gbPalette[0] = gbPalette[4] = gbPalette[8] = gbPalette[12] = bit00;
344 if (gbBorderOn && !gbSgbMask)
345 gbSgbRenderBorder();
346 }
347
348 void gbSgbScpPalette()
349 {
350 gbSgbRenderScreenToBuffer();
351
352 u16 *fromAddress = (u16 *)gbSgbScreenBuffer;
353
354 for (int i = 0; i < 512 * 4; i++)
355 {
356 gbSgbSCPPalette[i] = READ16LE(fromAddress++);
357 }
358 }
359
360 void gbSgbSetATF(int n)
361 {
362 if (n < 0)
363 n = 0;
364 if (n > 44)
365 n = 44;
366 memcpy(gbSgbATF, &gbSgbATFList[n * 20 * 18], 20 * 18);
367
368 if (gbSgbPacket[1] & 0x40)
369 {
370 gbSgbMask = 0;
371 if (gbBorderOn)
372 gbSgbRenderBorder();
373 }
374 }
375
376 void gbSgbSetPalette()
377 {
378 u16 pal = READ16LE((((u16 *)&gbSgbPacket[1]))) & 511;
379 memcpy(&gbPalette[0], &gbSgbSCPPalette[pal * 4], 4 * sizeof(u16));
380
381 pal = READ16LE((((u16 *)&gbSgbPacket[3]))) & 511;
382 memcpy(&gbPalette[4], &gbSgbSCPPalette[pal * 4], 4 * sizeof(u16));
383
384 pal = READ16LE((((u16 *)&gbSgbPacket[5]))) & 511;
385 memcpy(&gbPalette[8], &gbSgbSCPPalette[pal * 4], 4 * sizeof(u16));
386
387 pal = READ16LE((((u16 *)&gbSgbPacket[7]))) & 511;
388 memcpy(&gbPalette[12], &gbSgbSCPPalette[pal * 4], 4 * sizeof(u16));
389
390 u8 atf = gbSgbPacket[9];
391
392 if (atf & 0x80)
393 {
394 gbSgbSetATF(atf & 0x3f);
395 }
396
397 if (atf & 0x40)
398 {
399 gbSgbMask = 0;
400 if (gbBorderOn)
401 gbSgbRenderBorder();
402 }
403 }
404
405 void gbSgbAttributeBlock()
406 {
407 u8 *fromAddress = &gbSgbPacket[1];
408
409 u8 nDataSet = *fromAddress++;
410 if (nDataSet > 12)
411 nDataSet = 12;
412 if (nDataSet == 0)
413 nDataSet = 1;
414
415 while (nDataSet)
416 {
417 u8 controlCode = (*fromAddress++) & 7;
418 u8 paletteDesignation = (*fromAddress++) & 0x3f;
419 u8 startH = (*fromAddress++) & 0x1f;
420 u8 startV = (*fromAddress++) & 0x1f;
421 u8 endH = (*fromAddress++) & 0x1f;
422 u8 endV = (*fromAddress++) & 0x1f;
423
424 u8 *toAddress = gbSgbATF;
425
426 for (u8 y = 0; y < 18; y++)
427 {
428 for (u8 x = 0; x < 20; x++)
429 {
430 if (x < startH || y < startV ||
431 x > endH || y > endV)
432 {
433 // outside
434 if (controlCode & 0x04)
435 *toAddress = (paletteDesignation >> 4) & 0x03;
436 }
437 else if (x > startH && x < endH &&
438 y > startV && y < endV)
439 {
440 // inside
441 if (controlCode & 0x01)
442 *toAddress = paletteDesignation & 0x03;
443 }
444 else
445 {
446 // surrounding line
447 if (controlCode & 0x02)
448 *toAddress = (paletteDesignation >> 2) & 0x03;
449 else if (controlCode == 0x01)
450 *toAddress = paletteDesignation & 0x03;
451 }
452 toAddress++;
453 }
454 }
455 nDataSet--;
456 }
457 }
458
459 void gbSgbSetColumnPalette(u8 col, u8 p)
460 {
461 // if(col < 0)
462 // col = 0;
463 if (col > 19)
464 col = 19;
465
466 p &= 3;
467
468 u8 *toAddress = &gbSgbATF[col];
469
470 for (u8 y = 0; y < 18; y++)
471 {
472 *toAddress = p;
473 toAddress += 20;
474 }
475 }
476
477 void gbSgbSetRowPalette(u8 row, u8 p)
478 {
479 // if(row < 0)
480 // row = 0;
481 if (row > 17)
482 row = 17;
483
484 p &= 3;
485
486 u8 *toAddress = &gbSgbATF[row * 20];
487
488 for (u8 x = 0; x < 20; x++)
489 {
490 *toAddress++ = p;
491 }
492 }
493
494 void gbSgbAttributeDivide()
495 {
496 u8 control = gbSgbPacket[1];
497 u8 coord = gbSgbPacket[2];
498 u8 colorBR = control & 3;
499 u8 colorAL = (control >> 2) & 3;
500 u8 colorOL = (control >> 4) & 3;
501
502 if (control & 0x40)
503 {
504 if (coord > 17)
505 coord = 17;
506
507 for (u8 i = 0; i < 18; i++)
508 {
509 if (i < coord)
510 gbSgbSetRowPalette(i, colorAL);
511 else if (i > coord)
512 gbSgbSetRowPalette(i, colorBR);
513 else
514 gbSgbSetRowPalette(i, colorOL);
515 }
516 }
517 else
518 {
519 if (coord > 19)
520 coord = 19;
521
522 for (u8 i = 0; i < 20; i++)
523 {
524 if (i < coord)
525 gbSgbSetColumnPalette(i, colorAL);
526 else if (i > coord)
527 gbSgbSetColumnPalette(i, colorBR);
528 else
529 gbSgbSetColumnPalette(i, colorOL);
530 }
531 }
532 }
533
534 void gbSgbAttributeLine()
535 {
536 u8 *fromAddress = &gbSgbPacket[1];
537
538 u8 nDataSet = *fromAddress++;
539
540 if (nDataSet > 0x6e)
541 nDataSet = 0x6e;
542
543 while (nDataSet)
544 {
545 u8 line = *fromAddress++;
546 u8 num = line & 0x1f;
547 u8 pal = (line >> 5) & 0x03;
548 if (line & 0x80)
549 {
550 if (num > 17)
551 num = 17;
552 gbSgbSetRowPalette(num, pal);
553 }
554 else
555 {
556 if (num > 19)
557 num = 19;
558 gbSgbSetColumnPalette(num, pal);
559 }
560 nDataSet--;
561 }
562 }
563
564 void gbSgbAttributeCharacter()
565 {
566 u8 startH = gbSgbPacket[1] & 0x1f;
567 u8 startV = gbSgbPacket[2] & 0x1f;
568 int nDataSet = READ16LE(((u16 *)&gbSgbPacket[3]));
569 int style = gbSgbPacket[5] & 1;
570 if (startH > 19)
571 startH = 19;
572 if (startV > 17)
573 startV = 17;
574
575 u8 s = 6;
576 u8 *fromAddress = &gbSgbPacket[6];
577 u8 v = *fromAddress++;
578
579 if (style)
580 {
581 while (nDataSet)
582 {
583 u8 p = (v >> s) & 3;
584 gbSgbATF[startV * 20 + startH] = p;
585 startV++;
586 if (startV == 18)
587 {
588 startV = 0;
589 startH++;
590 if (startH == 20)
591 break;
592 }
593
594 if (s)
595 s -= 2;
596 else
597 {
598 s = 6;
599 v = *fromAddress++;
600 nDataSet--;
601 }
602 }
603 }
604 else
605 {
606 while (nDataSet)
607 {
608 u8 p = (v >> s) & 3;
609 gbSgbATF[startV * 20 + startH] = p;
610 startH++;
611 if (startH == 20)
612 {
613 startH = 0;
614 startV++;
615 if (startV == 18)
616 break;
617 }
618
619 if (s)
620 s -= 2;
621 else
622 {
623 s = 6;
624 v = *fromAddress++;
625 nDataSet--;
626 }
627 }
628 }
629 }
630
631 void gbSgbSetATFList()
632 {
633 gbSgbRenderScreenToBuffer();
634
635 u8 *fromAddress = gbSgbScreenBuffer;
636 u8 *toAddress = gbSgbATFList;
637
638 for (int i = 0; i < 45; i++)
639 {
640 for (int j = 0; j < 90; j++)
641 {
642 u8 v = *fromAddress++;
643 u8 s = 6;
644 if (i == 2)
645 s = 6;
646 for (int k = 0; k < 4; k++)
647 {
648 *toAddress++ = (v >> s) & 0x03;
649 s -= 2;
650 }
651 }
652 }
653 }
654
655 void gbSgbMaskEnable()
656 {
657 int gbSgbMaskFlag = gbSgbPacket[1] & 3;
658
659 gbSgbMask = gbSgbMaskFlag;
660
661 switch (gbSgbMaskFlag)
662 {
663 case 1:
664 break;
665 case 2:
666 gbSgbFillScreen(0x0000);
667 // memset(&gbPalette[0], 0, 128*sizeof(u16));
668 break;
669 case 3:
670 gbSgbFillScreen(gbPalette[0]);
671 break;
672 }
673 if (!gbSgbMask)
674 {
675 if (gbBorderOn)
676 gbSgbRenderBorder();
677 }
678 }
679
680 void gbSgbChrTransfer()
681 {
682 gbSgbRenderScreenToBuffer();
683
684 int address = (gbSgbPacket[1] & 1) * (128 * 32);
685
686 if (gbSgbPacket[1] & 1)
687 gbSgbCGBSupport |= 2;
688 else
689 gbSgbCGBSupport |= 1;
690
691 memcpy(&gbSgbBorderChar[address], gbSgbScreenBuffer, 128 * 32);
692
693 if (gbBorderAutomatic && !gbBorderOn && gbSgbCGBSupport > 4)
694 {
695 gbBorderOn = 1;
696 systemGbBorderOn();
697 }
698
699 if (gbBorderOn && !gbSgbMask)
700 gbSgbRenderBorder();
701
702 if (gbSgbMode && gbCgbMode && gbSgbCGBSupport == 7)
703 {
704 gbSgbCGBSupport = 0;
705 gbSgbMode = 2;
706 gbSgbMask = 0;
707 gbSgbRenderBorder();
708 gbReset();
709 }
710
711 if (gbSgbCGBSupport > 4)
712 gbSgbCGBSupport = 0;
713 }
714
715 void gbSgbMultiRequest()
716 {
717 if (gbSgbPacket[1] & 1)
718 {
719 gbSgbMultiplayer = 1;
720 if (gbSgbPacket[1] & 2)
721 gbSgbFourPlayers = 1;
722 else
723 gbSgbFourPlayers = 0;
724 gbSgbNextController = 0x0e;
725 }
726 else
727 {
728 gbSgbFourPlayers = 0;
729 gbSgbMultiplayer = 0;
730 gbSgbNextController = 0x0f;
731 }
732 }
733
734 void gbSgbCommand()
735 {
736 int command = gbSgbPacket[0] >> 3;
737 // int nPacket = gbSgbPacket[0] & 7;
738
739 switch (command)
740 {
741 case 0x00:
742 gbSgbSetPalette(0, 1, (u16 *)&gbSgbPacket[1]);
743 break;
744 case 0x01:
745 gbSgbSetPalette(2, 3, (u16 *)&gbSgbPacket[1]);
746 break;
747 case 0x02:
748 gbSgbSetPalette(0, 3, (u16 *)&gbSgbPacket[1]);
749 break;
750 case 0x03:
751 gbSgbSetPalette(1, 2, (u16 *)&gbSgbPacket[1]);
752 break;
753 case 0x04:
754 gbSgbAttributeBlock();
755 break;
756 case 0x05:
757 gbSgbAttributeLine();
758 break;
759 case 0x06:
760 gbSgbAttributeDivide();
761 break;
762 case 0x07:
763 gbSgbAttributeCharacter();
764 break;
765 case 0x0a:
766 gbSgbSetPalette();
767 break;
768 case 0x0b:
769 gbSgbScpPalette();
770 break;
771 case 0x11:
772 gbSgbMultiRequest();
773 break;
774 case 0x13:
775 gbSgbChrTransfer();
776 break;
777 case 0x14:
778 gbSgbPicture();
779 break;
780 case 0x15:
781 gbSgbSetATFList();
782 break;
783 case 0x16:
784 gbSgbSetATF(gbSgbPacket[1] & 0x3f);
785 break;
786 case 0x17:
787 gbSgbMaskEnable();
788 break;
789 }
790 }
791
792 void gbSgbResetPacketState()
793 {
794 gbSgbPacketState = GBSGB_NONE;
795 gbSgbPacketTimeout = 0;
796 }
797
798 void gbSgbDoBitTransfer(u8 value)
799 {
800 value = value & 0x30;
801 switch (gbSgbPacketState)
802 {
803 case GBSGB_NONE:
804 if (value == 0)
805 {
806 gbSgbPacketState = GBSGB_RESET;
807 gbSgbPacketTimeout = GBSGB_PACKET_TIMEOUT;
808 }
809 else if (value == 0x30)
810 {
811 if (gbSgbMultiplayer)
812 {
813 if ((gbSgbReadingController & 7) == 7)
814 {
815 gbSgbReadingController = 0;
816 if (gbSgbMultiplayer)
817 {
818 gbSgbNextController--;
819 if (gbSgbFourPlayers)
820 {
821 if (gbSgbNextController == 0x0b)
822 gbSgbNextController = 0x0f;
823 }
824 else
825 {
826 if (gbSgbNextController == 0x0d)
827 gbSgbNextController = 0x0f;
828 }
829 }
830 }
831 else
832 {
833 gbSgbReadingController &= 3;
834 }
835 }
836 gbSgbPacketTimeout = 0;
837 }
838 else
839 {
840 if (value == 0x10)
841 gbSgbReadingController |= 0x2;
842 else if (value == 0x20)
843 gbSgbReadingController |= 0x01;
844 gbSgbPacketTimeout = 0;
845 }
846 gbSgbPacketTimeout = 0;
847 break;
848 case GBSGB_RESET:
849 if (value == 0x30)
850 {
851 gbSgbPacketState = GBSGB_PACKET_TRANSMIT;
852 gbSgbPacketByte = 0;
853 gbSgbPacketNBits = 0;
854 gbSgbPacketTimeout = GBSGB_PACKET_TIMEOUT;
855 }
856 else if (value == 0x00)
857 {
858 gbSgbPacketTimeout = GBSGB_PACKET_TIMEOUT;
859 gbSgbPacketState = GBSGB_RESET;
860 }
861 else
862 {
863 gbSgbPacketState = GBSGB_NONE;
864 gbSgbPacketTimeout = 0;
865 }
866 break;
867 case GBSGB_PACKET_TRANSMIT:
868 if (value == 0)
869 {
870 gbSgbPacketState = GBSGB_RESET;
871 gbSgbPacketTimeout = 0;
872 }
873 else if (value == 0x30)
874 {
875 if (gbSgbPacketNBits == 128)
876 {
877 gbSgbPacketNBits = 0;
878 gbSgbPacketByte = 0;
879 gbSgbPacketNumber++;
880 gbSgbPacketTimeout = 0;
881 if (gbSgbPacketNumber == (gbSgbPacket[0] & 7))
882 {
883 gbSgbCommand();
884 gbSgbPacketNumber = 0;
885 gbSgbPacketState = GBSGB_NONE;
886 gbSgbPacketTimeout = 0;
887 }
888 }
889 else
890 {
891 if (gbSgbPacketNBits < 128)
892 {
893 gbSgbPacket[gbSgbPacketNumber * 16 + gbSgbPacketByte] >>= 1;
894 gbSgbPacket[gbSgbPacketNumber * 16 + gbSgbPacketByte] |= gbSgbBit;
895 gbSgbPacketNBits++;
896 if (!(gbSgbPacketNBits & 7))
897 {
898 gbSgbPacketByte++;
899 }
900 gbSgbPacketTimeout = GBSGB_PACKET_TIMEOUT;
901 }
902 }
903 }
904 else
905 {
906 if (value == 0x20)
907 gbSgbBit = 0x00;
908 else
909 gbSgbBit = 0x80;
910 gbSgbPacketTimeout = GBSGB_PACKET_TIMEOUT;
911 }
912 gbSgbReadingController = 0;
913 break;
914 default:
915 gbSgbPacketState = GBSGB_NONE;
916 gbSgbPacketTimeout = 0;
917 break;
918 }
919 }
920
921 variable_desc gbSgbSaveStruct[] = {
922 { &gbSgbMask, sizeof(int32) },
923 { &gbSgbPacketState, sizeof(int32) },
924 { &gbSgbBit, sizeof(int32) },
925 { &gbSgbPacketNBits, sizeof(int32) },
926 { &gbSgbPacketByte, sizeof(int32) },
927 { &gbSgbPacketNumber, sizeof(int32) },
928 { &gbSgbMultiplayer, sizeof(int32) },
929 { &gbSgbNextController, sizeof(u8) },
930 { &gbSgbReadingController, sizeof(u8) },
931 { NULL, 0 }
932 };
933
934 variable_desc gbSgbSaveStructV3[] = {
935 { &gbSgbMask, sizeof(int32) },
936 { &gbSgbPacketState, sizeof(int32) },
937 { &gbSgbBit, sizeof(int32) },
938 { &gbSgbPacketNBits, sizeof(int32) },
939 { &gbSgbPacketByte, sizeof(int32) },
940 { &gbSgbPacketNumber, sizeof(int32) },
941 { &gbSgbMultiplayer, sizeof(int32) },
942 { &gbSgbNextController, sizeof(u8) },
943 { &gbSgbReadingController, sizeof(u8) },
944 { &gbSgbFourPlayers, sizeof(int32) },
945 { NULL, 0 }
946 };
947
948 void gbSgbSaveGame(gzFile gzFile)
949 {
950 utilWriteData(gzFile, gbSgbSaveStructV3);
951
952 utilGzWrite(gzFile, gbSgbBorder, 2048);
953 utilGzWrite(gzFile, gbSgbBorderChar, 32 * 256);
954
955 utilGzWrite(gzFile, gbSgbPacket, 16 * 7);
956
957 utilGzWrite(gzFile, gbSgbSCPPalette, 4 * 512 * sizeof(u16));
958 utilGzWrite(gzFile, gbSgbATF, 20 * 18);
959 utilGzWrite(gzFile, gbSgbATFList, 45 * 20 * 18);
960
961 utilGzWrite(gzFile, gbSgbScreenBuffer, 4160);
962 utilGzWrite(gzFile, &gbSgbMode, sizeof(gbSgbMode));
963 utilGzWrite(gzFile, &gbSgbCGBSupport, sizeof(gbSgbCGBSupport));
964 utilGzWrite(gzFile, &gbSgbPacketTimeout, sizeof(gbSgbPacketTimeout));
965 }
966
967 void gbSgbReadGame(gzFile gzFile, int version)
968 {
969 if (version >= 3)
970 utilReadData(gzFile, gbSgbSaveStructV3);
971 else
972 {
973 utilReadData(gzFile, gbSgbSaveStruct);
974 gbSgbFourPlayers = 0;
975 }
976
977 if (version >= 8)
978 {
979 utilGzRead(gzFile, gbSgbBorder, 2048);
980 utilGzRead(gzFile, gbSgbBorderChar, 32 * 256);
981 }
982
983 utilGzRead(gzFile, gbSgbPacket, 16 * 7);
984
985 utilGzRead(gzFile, gbSgbSCPPalette, 4 * 512 * sizeof(u16));
986 utilGzRead(gzFile, gbSgbATF, 20 * 18);
987 utilGzRead(gzFile, gbSgbATFList, 45 * 20 * 18);
988
989 if (version >= 11)
990 {
991 utilGzRead(gzFile, gbSgbScreenBuffer, 4160);
992 utilGzRead(gzFile, &gbSgbMode, sizeof(gbSgbMode));
993 utilGzRead(gzFile, &gbSgbCGBSupport, sizeof(gbSgbCGBSupport));
994 utilGzRead(gzFile, &gbSgbPacketTimeout, sizeof(gbSgbPacketTimeout));
995 }
996 }
997