Specify the ldh instruction, don't turn ld into ldh

engine/math/bcd.asm

@@ -6,39 +6,39 @@ DivideBCDPredef4::
 
 DivideBCD::
 	xor a
-	ld [hDivideBCDBuffer], a
-	ld [hDivideBCDBuffer+1], a
-	ld [hDivideBCDBuffer+2], a
+	ldh [hDivideBCDBuffer], a
+	ldh [hDivideBCDBuffer+1], a
+	ldh [hDivideBCDBuffer+2], a
 	ld d, $1
 .mulBy10Loop 
 ; multiply the divisor by 10 until the leading digit is nonzero
 ; to set up the standard long division algorithm
-	ld a, [hDivideBCDDivisor]
+	ldh a, [hDivideBCDDivisor]
 	and $f0
 	jr nz, .next
 	inc d
-	ld a, [hDivideBCDDivisor]
+	ldh a, [hDivideBCDDivisor]
 	swap a
 	and $f0
 	ld b, a
-	ld a, [hDivideBCDDivisor+1]
+	ldh a, [hDivideBCDDivisor+1]
 	swap a
-	ld [hDivideBCDDivisor+1], a
+	ldh [hDivideBCDDivisor+1], a
 	and $f
 	or b
-	ld [hDivideBCDDivisor], a
-	ld a, [hDivideBCDDivisor+1]
+	ldh [hDivideBCDDivisor], a
+	ldh a, [hDivideBCDDivisor+1]
 	and $f0
 	ld b, a
-	ld a, [hDivideBCDDivisor+2]
+	ldh a, [hDivideBCDDivisor+2]
 	swap a
-	ld [hDivideBCDDivisor+2], a
+	ldh [hDivideBCDDivisor+2], a
 	and $f
 	or b
-	ld [hDivideBCDDivisor+1], a
-	ld a, [hDivideBCDDivisor+2]
+	ldh [hDivideBCDDivisor+1], a
+	ldh a, [hDivideBCDDivisor+2]
 	and $f0
-	ld [hDivideBCDDivisor+2], a
+	ldh [hDivideBCDDivisor+2], a
 	jr .mulBy10Loop
 .next
 	push de
@@ -48,16 +48,16 @@ DivideBCD::
 	ld a, b
 	swap a
 	and $f0
-	ld [hDivideBCDBuffer], a
+	ldh [hDivideBCDBuffer], a
 	dec d
 	jr z, .next2
 	push de
 	call DivideBCD_divDivisorBy10
 	call DivideBCD_getNextDigit
 	pop de
-	ld a, [hDivideBCDBuffer]
+	ldh a, [hDivideBCDBuffer]
 	or b
-	ld [hDivideBCDBuffer], a
+	ldh [hDivideBCDBuffer], a
 	dec d
 	jr z, .next2
 	push de
@@ -67,16 +67,16 @@ DivideBCD::
 	ld a, b
 	swap a
 	and $f0
-	ld [hDivideBCDBuffer+1], a
+	ldh [hDivideBCDBuffer+1], a
 	dec d
 	jr z, .next2
 	push de
 	call DivideBCD_divDivisorBy10
 	call DivideBCD_getNextDigit
 	pop de
-	ld a, [hDivideBCDBuffer+1]
+	ldh a, [hDivideBCDBuffer+1]
 	or b
-	ld [hDivideBCDBuffer+1], a
+	ldh [hDivideBCDBuffer+1], a
 	dec d
 	jr z, .next2
 	push de
@@ -86,23 +86,23 @@ DivideBCD::
 	ld a, b
 	swap a
 	and $f0
-	ld [hDivideBCDBuffer+2], a
+	ldh [hDivideBCDBuffer+2], a
 	dec d
 	jr z, .next2
 	push de
 	call DivideBCD_divDivisorBy10
 	call DivideBCD_getNextDigit
 	pop de
-	ld a, [hDivideBCDBuffer+2]
+	ldh a, [hDivideBCDBuffer+2]
 	or b
-	ld [hDivideBCDBuffer+2], a
+	ldh [hDivideBCDBuffer+2], a
 .next2
-	ld a, [hDivideBCDBuffer]
-	ld [hDivideBCDQuotient], a ; the same memory location as hDivideBCDDivisor
-	ld a, [hDivideBCDBuffer+1]
-	ld [hDivideBCDQuotient+1], a
-	ld a, [hDivideBCDBuffer+2]
-	ld [hDivideBCDQuotient+2], a
+	ldh a, [hDivideBCDBuffer]
+	ldh [hDivideBCDQuotient], a ; the same memory location as hDivideBCDDivisor
+	ldh a, [hDivideBCDBuffer+1]
+	ldh [hDivideBCDQuotient+1], a
+	ldh a, [hDivideBCDBuffer+2]
+	ldh [hDivideBCDQuotient+2], a
 	pop de
 	ld a, $6 
 	sub d
@@ -117,28 +117,28 @@ DivideBCD::
 	ret
 
 DivideBCD_divDivisorBy10:
-	ld a, [hDivideBCDDivisor+2]
+	ldh a, [hDivideBCDDivisor+2]
 	swap a
 	and $f
 	ld b, a
-	ld a, [hDivideBCDDivisor+1]
+	ldh a, [hDivideBCDDivisor+1]
 	swap a
-	ld [hDivideBCDDivisor+1], a
+	ldh [hDivideBCDDivisor+1], a
 	and $f0
 	or b
-	ld [hDivideBCDDivisor+2], a
-	ld a, [hDivideBCDDivisor+1]
+	ldh [hDivideBCDDivisor+2], a
+	ldh a, [hDivideBCDDivisor+1]
 	and $f
 	ld b, a
-	ld a, [hDivideBCDDivisor]
+	ldh a, [hDivideBCDDivisor]
 	swap a
-	ld [hDivideBCDDivisor], a
+	ldh [hDivideBCDDivisor], a
 	and $f0
 	or b
-	ld [hDivideBCDDivisor+1], a
-	ld a, [hDivideBCDDivisor]
+	ldh [hDivideBCDDivisor+1], a
+	ldh a, [hDivideBCDDivisor]
 	and $f
-	ld [hDivideBCDDivisor], a
+	ldh [hDivideBCDDivisor], a
 	ret
 
 DivideBCD_getNextDigit:

engine/math/multiply_divide.asm

@@ -2,142 +2,142 @@ _Multiply::
 	ld a, $8
 	ld b, a
 	xor a
-	ld [hProduct], a
-	ld [hMultiplyBuffer], a
-	ld [hMultiplyBuffer+1], a
-	ld [hMultiplyBuffer+2], a
-	ld [hMultiplyBuffer+3], a
+	ldh [hProduct], a
+	ldh [hMultiplyBuffer], a
+	ldh [hMultiplyBuffer+1], a
+	ldh [hMultiplyBuffer+2], a
+	ldh [hMultiplyBuffer+3], a
 .loop
-	ld a, [hMultiplier]
+	ldh a, [hMultiplier]
 	srl a
-	ld [hMultiplier], a ; (aliases: hDivisor, hMultiplier, hPowerOf10)
+	ldh [hMultiplier], a ; (aliases: hDivisor, hMultiplier, hPowerOf10)
 	jr nc, .smallMultiplier
-	ld a, [hMultiplyBuffer+3]
+	ldh a, [hMultiplyBuffer+3]
 	ld c, a
-	ld a, [hMultiplicand+2]
+	ldh a, [hMultiplicand+2]
 	add c
-	ld [hMultiplyBuffer+3], a
-	ld a, [hMultiplyBuffer+2]
+	ldh [hMultiplyBuffer+3], a
+	ldh a, [hMultiplyBuffer+2]
 	ld c, a
-	ld a, [hMultiplicand+1]
+	ldh a, [hMultiplicand+1]
 	adc c
-	ld [hMultiplyBuffer+2], a
-	ld a, [hMultiplyBuffer+1]
+	ldh [hMultiplyBuffer+2], a
+	ldh a, [hMultiplyBuffer+1]
 	ld c, a
-	ld a, [hMultiplicand] ; (aliases: hMultiplicand)
+	ldh a, [hMultiplicand] ; (aliases: hMultiplicand)
 	adc c
-	ld [hMultiplyBuffer+1], a
-	ld a, [hMultiplyBuffer]
+	ldh [hMultiplyBuffer+1], a
+	ldh a, [hMultiplyBuffer]
 	ld c, a
-	ld a, [hProduct] ; (aliases: hProduct, hPastLeadingZeros, hQuotient)
+	ldh a, [hProduct] ; (aliases: hProduct, hPastLeadingZeros, hQuotient)
 	adc c
-	ld [hMultiplyBuffer], a
+	ldh [hMultiplyBuffer], a
 .smallMultiplier
 	dec b
 	jr z, .done
-	ld a, [hMultiplicand+2]
+	ldh a, [hMultiplicand+2]
 	sla a
-	ld [hMultiplicand+2], a
-	ld a, [hMultiplicand+1]
+	ldh [hMultiplicand+2], a
+	ldh a, [hMultiplicand+1]
 	rl a
-	ld [hMultiplicand+1], a
-	ld a, [hMultiplicand]
+	ldh [hMultiplicand+1], a
+	ldh a, [hMultiplicand]
 	rl a
-	ld [hMultiplicand], a
-	ld a, [hProduct]
+	ldh [hMultiplicand], a
+	ldh a, [hProduct]
 	rl a
-	ld [hProduct], a
+	ldh [hProduct], a
 	jr .loop
 .done
-	ld a, [hMultiplyBuffer+3]
-	ld [hProduct+3], a
-	ld a, [hMultiplyBuffer+2]
-	ld [hProduct+2], a
-	ld a, [hMultiplyBuffer+1]
-	ld [hProduct+1], a
-	ld a, [hMultiplyBuffer]
-	ld [hProduct], a
+	ldh a, [hMultiplyBuffer+3]
+	ldh [hProduct+3], a
+	ldh a, [hMultiplyBuffer+2]
+	ldh [hProduct+2], a
+	ldh a, [hMultiplyBuffer+1]
+	ldh [hProduct+1], a
+	ldh a, [hMultiplyBuffer]
+	ldh [hProduct], a
 	ret
 
 _Divide::
 	xor a
-	ld [hDivideBuffer], a
-	ld [hDivideBuffer+1], a
-	ld [hDivideBuffer+2], a
-	ld [hDivideBuffer+3], a
-	ld [hDivideBuffer+4], a
+	ldh [hDivideBuffer], a
+	ldh [hDivideBuffer+1], a
+	ldh [hDivideBuffer+2], a
+	ldh [hDivideBuffer+3], a
+	ldh [hDivideBuffer+4], a
 	ld a, $9
 	ld e, a
 .asm_37db3
-	ld a, [hDivideBuffer]
+	ldh a, [hDivideBuffer]
 	ld c, a
-	ld a, [hDividend+1] ; (aliases: hMultiplicand)
+	ldh a, [hDividend+1] ; (aliases: hMultiplicand)
 	sub c
 	ld d, a
-	ld a, [hDivisor] ; (aliases: hDivisor, hMultiplier, hPowerOf10)
+	ldh a, [hDivisor] ; (aliases: hDivisor, hMultiplier, hPowerOf10)
 	ld c, a
-	ld a, [hDividend] ; (aliases: hProduct, hPastLeadingZeros, hQuotient)
+	ldh a, [hDividend] ; (aliases: hProduct, hPastLeadingZeros, hQuotient)
 	sbc c
 	jr c, .asm_37dce
-	ld [hDividend], a ; (aliases: hProduct, hPastLeadingZeros, hQuotient)
+	ldh [hDividend], a ; (aliases: hProduct, hPastLeadingZeros, hQuotient)
 	ld a, d
-	ld [hDividend+1], a ; (aliases: hMultiplicand)
-	ld a, [hDivideBuffer+4]
+	ldh [hDividend+1], a ; (aliases: hMultiplicand)
+	ldh a, [hDivideBuffer+4]
 	inc a
-	ld [hDivideBuffer+4], a
+	ldh [hDivideBuffer+4], a
 	jr .asm_37db3
 .asm_37dce
 	ld a, b
 	cp $1
 	jr z, .asm_37e18
-	ld a, [hDivideBuffer+4]
+	ldh a, [hDivideBuffer+4]
 	sla a
-	ld [hDivideBuffer+4], a
-	ld a, [hDivideBuffer+3]
+	ldh [hDivideBuffer+4], a
+	ldh a, [hDivideBuffer+3]
 	rl a
-	ld [hDivideBuffer+3], a
-	ld a, [hDivideBuffer+2]
+	ldh [hDivideBuffer+3], a
+	ldh a, [hDivideBuffer+2]
 	rl a
-	ld [hDivideBuffer+2], a
-	ld a, [hDivideBuffer+1]
+	ldh [hDivideBuffer+2], a
+	ldh a, [hDivideBuffer+1]
 	rl a
-	ld [hDivideBuffer+1], a
+	ldh [hDivideBuffer+1], a
 	dec e
 	jr nz, .asm_37e04
 	ld a, $8
 	ld e, a
-	ld a, [hDivideBuffer]
-	ld [hDivisor], a ; (aliases: hDivisor, hMultiplier, hPowerOf10)
+	ldh a, [hDivideBuffer]
+	ldh [hDivisor], a ; (aliases: hDivisor, hMultiplier, hPowerOf10)
 	xor a
-	ld [hDivideBuffer], a
-	ld a, [hDividend+1] ; (aliases: hMultiplicand)
-	ld [hDividend], a ; (aliases: hProduct, hPastLeadingZeros, hQuotient)
-	ld a, [hDividend+2]
-	ld [hDividend+1], a ; (aliases: hMultiplicand)
-	ld a, [hDividend+3]
-	ld [hDividend+2], a
+	ldh [hDivideBuffer], a
+	ldh a, [hDividend+1] ; (aliases: hMultiplicand)
+	ldh [hDividend], a ; (aliases: hProduct, hPastLeadingZeros, hQuotient)
+	ldh a, [hDividend+2]
+	ldh [hDividend+1], a ; (aliases: hMultiplicand)
+	ldh a, [hDividend+3]
+	ldh [hDividend+2], a
 .asm_37e04
 	ld a, e
 	cp $1
 	jr nz, .asm_37e0a
 	dec b
 .asm_37e0a
-	ld a, [hDivisor] ; (aliases: hDivisor, hMultiplier, hPowerOf10)
+	ldh a, [hDivisor] ; (aliases: hDivisor, hMultiplier, hPowerOf10)
 	srl a
-	ld [hDivisor], a ; (aliases: hDivisor, hMultiplier, hPowerOf10)
-	ld a, [hDivideBuffer]
+	ldh [hDivisor], a ; (aliases: hDivisor, hMultiplier, hPowerOf10)
+	ldh a, [hDivideBuffer]
 	rr a
-	ld [hDivideBuffer], a
+	ldh [hDivideBuffer], a
 	jr .asm_37db3
 .asm_37e18
-	ld a, [hDividend+1] ; (aliases: hMultiplicand)
-	ld [hRemainder], a ; (aliases: hDivisor, hMultiplier, hPowerOf10)
-	ld a, [hDivideBuffer+4]
-	ld [hQuotient+3], a
-	ld a, [hDivideBuffer+3]
-	ld [hQuotient+2], a
-	ld a, [hDivideBuffer+2]
-	ld [hQuotient+1], a ; (aliases: hMultiplicand)
-	ld a, [hDivideBuffer+1]
-	ld [hDividend], a ; (aliases: hProduct, hPastLeadingZeros, hQuotient)
+	ldh a, [hDividend+1] ; (aliases: hMultiplicand)
+	ldh [hRemainder], a ; (aliases: hDivisor, hMultiplier, hPowerOf10)
+	ldh a, [hDivideBuffer+4]
+	ldh [hQuotient+3], a
+	ldh a, [hDivideBuffer+3]
+	ldh [hQuotient+2], a
+	ldh a, [hDivideBuffer+2]
+	ldh [hQuotient+1], a ; (aliases: hMultiplicand)
+	ldh a, [hDivideBuffer+1]
+	ldh [hDividend], a ; (aliases: hProduct, hPastLeadingZeros, hQuotient)
 	ret

engine/math/random.asm

@@ -1,13 +1,13 @@
 Random_::
 ; Generate a random 16-bit value.
-	ld a, [rDIV]
+	ldh a, [rDIV]
 	ld b, a
-	ld a, [hRandomAdd]
+	ldh a, [hRandomAdd]
 	adc b
-	ld [hRandomAdd], a
-	ld a, [rDIV]
+	ldh [hRandomAdd], a
+	ldh a, [rDIV]
 	ld b, a
-	ld a, [hRandomSub]
+	ldh a, [hRandomSub]
 	sbc b
-	ld [hRandomSub], a
+	ldh [hRandomSub], a
 	ret