Savaged articles/txt files

Author: avivace

LICENSE

@@ -1,10 +1,10 @@
-Copyright (c) 2015-2016 Antonio Vivace
+Copyright (c) 2015-2017 Antonio Vivace
 
 DISCLAIMER
 No commercial adaptation or implementation of this material is allowed 
 since the Game Boy platform is copyrighted by Nintendo and this is just 
 a collection of private hacking passionates that managed to write working 
-code and hw mods to the original Nintendo paltform. 
+code and hardware mods to the original Nintendo platform.
 Nintendo never authorised or endorsed in anyway this type of work.
 
                     GNU GENERAL PUBLIC LICENSE

README.md

@@ -188,6 +188,9 @@ An online converter, translates gameboy assembly into Pokémon R/B/Y items ([Sou
 - [GameBoy Color DMA-Transfers v0.0.1](http://gameboy.mongenel.com/dmg/gbc_dma_transfers.txt)
 - [STAT interrupt timings](http://gameboy.mongenel.com/dmg/istat98.txt)
 
+#### Old articles
+[This](https://github.com/avivace/awesome-gbdev/tree/master/articles/savaged) folder is an historical archive of old articles, FAQs and in general text documents about the game boy development. Note that a lot of information may be wrong or obsolete - they are archived for historical reasons.
+
 ### C
 - [8-Bit Wonderland](http://belial.blarzwurst.de/gbpaper/paper.pdf) - Well-written introductory document about how the Game Boy works and how to start developing working code for it.
 - [Grooves Game Boy Programming](https://github.com/gbdk-salvage/grooves-game-boy-programming) - A complete set of lessons about implementing various game mechanics in a Game Boy game.

articles/savaged/2player.txt

@@ -0,0 +1,142 @@
+Fast Two Player Code using RGBASM
+(or Fast OOP using RGBASM)
+Written by GeeBee
+With an addition by Otaku
+
+ As an example, let's say you have an assembly language two
+player game that you are working on where the majority of
+the code for player one might be identical for player two.
+There are basically two ways of handling this: 
+
+ 1) Pass a pointer to these routines that points to the
+ "object" structure that you wish to process.
+
+ 2) Repeat all of these code routines using slightly
+ different function/variable names.
+
+ The advantage to using approach number 1 is that you can
+have two or more objects that share the same code routines.
+One disadvantage is the code will be slower than approach
+2 because you have to access the object structure through
+a pointer. Also this pointer can tie up valuable GB registers
+which can cause longer/slower code due to fewer available
+registers.
+
+ The advantage to using approach number 2 is that since your
+object data doesn't have to be accessed through a pointer the
+code can be much quicker which sometimes is very important
+on the limited GB/GBC platform. The disadvantages are that
+code must be repeated for each object (which can rapidly eat
+up ROM space for a large number of objects) and having several
+identical routines (with different function & variable names)
+is a big maintenance problem when the same changes need to be
+applied to each object.
+
+
+ If you can get around the maintenance problems of approach
+number 2, this can be ideal in some cases where you need
+fast execution speed OR in cases where you have just finished
+coding a 1 player game and as an after-thought you decide to
+add 2 player support but you don't want to rewrite your code
+to use object pointers.
+
+ RGBASM is powerful enough that you can eliminate the majority
+of the maintenance problems in this case. Here's example code:
+(The macro operator '@' is incremented with each macro included
+in your source code so this code needs to be compiled stand-alone
+and then linked with other code or you must guarantee that no
+macros are included before this code. The macro FOO below is
+only used to increment '@' from 0 to 1 so that the first object
+ends with _1 instead of _0.)
+
+
+ObjectX_1:	DB
+ObjectY_1:      DB
+ObjectX_2:	DB
+ObjectY_2:      DB
+
+FOO:	MACRO
+        db 0
+        ENDM
+
+; Set Object X,Y coordinates to H,L
+
+OBJCODE: MACRO
+
+SetObjectPos\@:
+	ld	a,h
+	ld	[ObjectX\@],a
+	ld	a,l
+	ld	[ObjectY\@],a
+	ret
+
+GetObjectPos\@:
+	ld	a,[ObjectX\@]
+	ld	h,a
+	ld	a,[ObjectY\@]
+	ld	l,a
+	ret
+
+	ENDM
+
+; Include code for object #1
+	OBJCODE
+; Include code for object #2
+	OBJCODE
+
+; Set Object 1 coordinates to 0,0
+	ld	hl,0
+	call	SetObjectPos_1
+
+; Set Object 2 coordinates to 0,0
+	ld	hl,0
+	call	SetObjectPos_2
+
+; Return Object 1 coordinates in H,L
+	call	GetObjectPos_1
+
+; Return Object 2 coordinates in H,L
+	call	GetObjectPos_2
+
+--
+added by Otaku
+
+Using SET to point to the start of your object
+structure, and then calculating offsets into the
+object structure is a neater way of doing this,
+without having to worry about an idle use of MACRO
+incrementing the @ counter.
+
+So:
+Object1:  DS  16
+Object2:  DS  16
+
+          RSRESET
+X_POS     RB    2
+Y_POS     RB    2
+HEALTH    RB    1
+
+
+; assume that x & y are passed in BC & DE
+; assume for this example that GB has the ability
+; to move registers directly to memory without using
+; the A register
+SetObjectPos:   MACRO
+ObjectBase SET \1
+                LD   [ObjectBase+X_POS],C
+                LD   [ObjectBase+X_POS+1],B
+                LD   [ObjectBase+Y_POS],E
+                LD   [ObjectBase+Y_POS+1],D
+                PURGE ObjectBase
+                ENDM
+
+SetObject1Pos:
+                SetObjectPos   Object1
+                RET
+SetObject2Pos:
+                SetObjectPos   Object2
+                RET
+
+
+
+

articles/savaged/2xsprites.txt

@@ -0,0 +1,28 @@
+Some ideas for why sprites would disappear in 2x Speed Mode
+Written by Jan-Lieuwe Koopmans
+[email protected] 
+
+
+- You move your sprites using an ISR (interrupt service routine) and that
+particular interrupt is disabled by the cpu-speed switch routine (IE_REG
+being altered);
+
+
+- Bit 1 of the LCDC register is somehow set to zero;
+
+
+- The DMA copy of OAM workram to real OAM ram is not done anymore (that
+routine is in HiRam and is being called by the default VBL ISR).
+
+
+- Your sprite-tiles are not being copied to VRAM in a proper way.
+
+
+
+You can check all these easily using No$Gmb (press F10 in debug mode to see
+register contents, check HiRam (starting at $FF80) using the debugger, check
+Video RAM using F5 in debug mode).
+
+
+
+

articles/savaged/JPtable.txt

@@ -0,0 +1,70 @@
+by The ZenPsycho
+
+;*****************************
+;*      Jump table code      *
+;*****************************
+;
+;******************************************************************
+;
+;  on entry:
+;  A = Address offset
+;
+;  Registers used:
+;  A, HL, DE
+;  
+;  on exit:
+;  A  destroyed
+;  hl contains address from jump table
+;  
+;  place this routine at reset $08
+;
+;  [example code]
+;  (If A=0 then jp this)
+;  (if A=1 then jp that)
+;  (if A=2 then jp theother)
+;
+;  RST $08         ;call function to jump to address from pointer table
+;  DB this         ;pointer table
+;  DB that
+;  DB theother
+;
+;
+;******************************************************************
+
+
+  pop  hl         ;get address of first pointer from stack                  
+  push de         ;preserve DE        
+  add  a,a        ;multiply A by two           
+  ld   e,a        ;store A in E          
+  ld   d,00       ;so that we can           
+  add  hl,de      ;add the offset to hl         
+  ldi  a,(hl)     ;and now          
+  ld   h,(hl)     ;get an address from the pointer table        
+  ld   l,a        ;           
+  pop  de         ;restore DE        
+  jp   hl         ;and jump to address from table                          
+  
+  
+  
+  
+  
+  
+  
+  
+;*****************************************************************
+
+    pop  hl     ;get address
+    push bc     ;preserve BC
+    ld   c,a    ;get offset from A into BC
+    ld   b,00   ;
+    ldi  a,(hl) ;load from address into A and increment address
+    push hl     ;store address+1
+    add  hl,bc  ;add offset to address+1
+    ld   c,a    ;get data from address+1 into BC (B still=0)
+    ld   a,(hl) ;get data from address+1+offset
+    pop  hl     ;restore address+1
+    add  hl,bc  ;
+    pop  bc     ;
+    jp   hl     ;
+
+;*****************************************************************

articles/savaged/LUtable.txt

@@ -0,0 +1,46 @@
+;***************************************
+;*      Lookup table function          *
+;***************************************
+;
+; On entry:
+; A contains table index
+; 
+; registers used:
+; A, HL, BC
+; 
+; On exit:
+; A contains table entry
+; HL contains address of the end of the table
+; BC is preserved
+; 
+; this function is placed at $0018
+;
+; [Example Code]
+; LD A, $04
+; CALL TABLE
+; 
+; TABLE:
+; RST $18  ;call table look up function , push PC onto stack
+; DB $06   ;number of bytes in table
+; DB $06, $05, $04, $03, $02, $01  ;table data
+; ret
+; 
+; after running this code the accumulator (A) contains $02
+;
+;************************************************************************
+
+
+  POP   HL       ;Load address from stack
+  PUSH  BC       ;preserve BC
+  LD    C,A      ;Load index
+  LD    B,0      ;into BC
+  LD    A,[HLI]  ;Load size of table into A
+  PUSH  HL       ;preserve the address of the start of the table
+  ADD   HL,BC    ;HL now points to table index
+  LD    C,A      ;load size of table into BC
+  LD    A,[HL]   ;A now contains Table entry at the specified index
+  POP   HL       ;to the start address of the table,
+  ADD   HL,BC    ;add the size of the table
+  POP   BC       ;restore BC
+  JP    HL       ;and jump to the instruction AFTER the table
+

articles/savaged/ZenDMA.txt

@@ -0,0 +1,78 @@
+Ok so you want sprites in your gameboy game/demo. You've got a DMA routine, you know how it works. What you don't know is what is the quickest, best way to copy it into HRAM at $FF80. That's where document comes in. I'm going to teach you how to use a routine that will allow you to easily copy data to ram. and this isn't only good for copying your DMA routine, you can use it to copy tile data and other bits of assorted code into ram, easily. the first thing you do is you put the following routine at $0028, like this:
+
+
+SECTION "COPY DATA",home[$0028]
+
+POP  HL
+PUSH BC
+LD   A,[HLI]
+LD   B,A
+LD   A,[HLI]
+LD   C,A
+copydataloop:
+LD   A,[HLI]
+LD   [DE],A
+INC  DE
+DEC  BC
+LD   A,B
+OR   C
+JR   NZ, copydataloop
+POP  BC
+JP   [HL]
+
+
+	The reason we put it at $0028 is because it's a reset code. which means you only need one byte to call the code that's there, as opposed to the 3 bytes you use in a normal call.
+	I'll explain this code a little later, but for now I will show you how to use it. We'll create a new file called "DMA.INC". in this file you put this:
+
+
+DMACOPY:
+LD   DE, $FF80      ;$FF80 is where we want to copy this data
+RST  $28            ;Call the copy routine
+DB   $00, $0D       ;the amount of bytes we want to copy,
+                    ;represented in a 16 bit unsigned integer.
+                    
+
+                    ;And now the data. This is a DMA routine.
+                    ;Hand assembled. It copies data from $C100
+
+DB   $F5, $3E, $C1, $EA, $46, $FF, $3E, $28, $3D, $20, $FD, $F1, $D9
+
+RET                 
+
+
+now save this file, and include it in your main file. then when you want to copy the DMA routine to $FF80,
+
+CALL DMACOPY
+
+simple huh?
+ok now let's explore how the routine itself works.
+
+
+
+POP  HL            ;when you call RST $28, it pushes the address of the
+                   ;byte immediately following it, onto the stack.
+                   ;this instruction stores that address into HL 
+PUSH BC            ;(preserve BC)
+LD   A,[HLI]       ;This copies the byte at that address into B
+LD   B,A           ;which is the MSB of the amount of bytes we want to 
+LD   A,[HLI]       ;copy. Then this copies the LSB into C.
+LD   C,A           ;Now HL should point at the first byte of our data
+copydataloop:
+LD   A,[HLI]       ;Copy that byte into a
+LD   [DE],A        ;then copy a to the address contained in DE ($FF80)
+INC  DE                ;Increment the address in DE.
+DEC  BC                ;One byte down, BC to go
+LD   A,B               ;then OR B and C together
+OR   C                 ;to find out if BC = 0
+JR   NZ, copydataloop  ;if it isn't, copy another byte
+POP  BC                ;(restore BC)
+JP   [HL]              ;Jump to the byte after the data, which is a RET
+	
+
+
+Pretty clever eh? 
+
+If you have any questions or comments, E-mail me at [email protected]
+
+
+