Programming:Display and update Scores - Revision history

MacDeath at 19:28, 8 October 2009

2009-10-08T19:28:24Z

Executioner: Finished the page

2007-09-21T04:18:37Z

Finished the page

Executioner: /* Multiple BCD Bytes */

2007-09-20T23:33:11Z

‎Multiple BCD Bytes

Executioner: /* Multiple BCD Bytes */

2007-09-20T23:32:15Z

‎Multiple BCD Bytes

Executioner: /* Multiple BCD Bytes */

2007-09-20T23:31:30Z

‎Multiple BCD Bytes

Deprecated: The each() function is deprecated. This message will be suppressed on further calls in /mnt/cpcwiki-httpdocs/includes/diff/DairikiDiff.php on line 434

Executioner: /* Multiple BCD Bytes */

2007-09-20T23:30:15Z

‎Multiple BCD Bytes

Executioner: /* Multiple BCD Bytes */

2007-09-20T23:29:19Z

‎Multiple BCD Bytes

Executioner: Score routines

2007-09-20T23:27:21Z

Score routines

New page

== Methods for Storing Scores in Memory ==

There are a number of methods for storing a Score in memory, here are a few examples: 
=== A Single Word ===
This is the simplest and smallest method for storing the score in memory, but it has a couple of disadvantages over some other methods. It can only hold a score up to 65535 (although you can add an extra '0' or two on the display to make that 655350 or 6553500), converting it to digits for display requires a relatively slow algorithm, and adding extra lives every 10000 points for example can take a complex routine. The advantage of using a straight Word is that the maths required to add points to the score is very simple and fast. 
 
To define the score:
<pre>
.score dw 0
</pre>
To add some points (in BC):
<pre>
.add_score_bc
ld hl,(score)
add hl,bc
ld (score),hl
ret
</pre>
To display the score requires converting to a decimal:
<pre>
.show_score
ld hl,score
ld bc,-10000
call show_digit
ld bc,-1000
call show_digit
ld bc,-100
call show_digit
ld bc,-10
call show_digit
ld a,l
add '0'
jp show_char

.show_digit
ld a,'0' - 1
.inc_digit
inc a
add hl,bc
jr nc,inc_digit
or a
sbc hl,bc
add '0'
jp show_char ; This assumes the show_char routine doesn't corrupt HL
</pre>
Checking for every 10000 points is complicated, this would normally done in the add_score routine, and I'm not going to write the code. It would however, be quite simple to add an extra life every multiple of 256 units (eg. 10240 points) by checking the most significant byte. eg:
<pre>
.add_score_bc
ld hl,(score)
ld a,h
add hl,bc
ld (score),hl
sub h
cp 2
ret c
ld hl,lives
inc (hl)
ret
</pre>

=== A Double Word ===
Like the above method, this provides a simple and efficient way to store and add points, but the routine required to convert the number to decimal for display is even more difficult, as is the extra lives every 10000 points. 
 
To define the score:
<pre>
.score ds 4
</pre>
To add BC points to the score:
<pre>
.add_score_bc
ld hl,(score)
add hl,bc
ld (score),hl
ret nc
ld hl,(score + 2)
inc hl
ld (score + 2),hl
ret
</pre>
Displaying the score is much more tricky since it involves a lot of DWord subtractions etc. Most Z80 assemblers (including WinAPE) can't handle DWord values, so you need to get your calculator out to figure out what the values are to subtract for successive digits. The score can go as high as 4294967295, but I wouldn't recommend doing the maths for all possible digits. The code to display a DWord value is too complicated for this document.

=== A Single BCD Word ===
This is similar to the above method, but the score is treated as Binary Coded Decimal. It's main disadvantage is that it can hold even less values than the single Word, restricting the score to 10000 possible combinations (one again with extra zeroes if required). Depending on the type of game and difficulty, this could be a good method to use. It's easy to store in memory and pass around, displaying and adding points are all relatively easy. 
 
To define the score is exactly the same as for a Single Word:
<pre>
.score dw 0
</pre>
Adding BC points is also fairly straightforward (here with the extra life check every 1000 units):
<pre>
.add_score_BC
ld hl,(score)
ld d,h
ld a,l
add c
daa
ld l,a
ld a,h
adc b
daa
ld h,a
ld (score),hl
sub d
cp #10
ret c
ld hl,lives
inc (hl)
ret
</pre>
And the routine to display the score:
<pre>
.show_score
ld hl,(score)
.bcd_hl
ld a,h
call bcd_a
ld a,l
.bcd_a
ld h,a
rra:rra:rra:rra
and #0f
add '0'
call show_char
ld a,h
and #0f
add '0'
jp show_char
</pre>

=== A Double BCD Word ===
This is actually one of the best methods of storing and displaying a score since the maths and display methods remain fairly simple, and your score can now hold up to 8 digits. Luckily the Z80 has just enough fast 16 bit registers (ie. Non-index registers) to be able to handle all the things you require. 
 
To define the score:
<pre>
.score ds 4
</pre>
To add BC points to the score (here with the extra life check every 10000 units):
<pre>
ld hl,(score)
ld a,l
add c
daa
ld l,a
ld a,h
adc b
daa
ld h,a
ld (score),hl
ret nc
ld hl,lives
inc (hl)
ld hl,(score + 2)
ld a,l
add 1
daa
ld l,a
ld a,h
adc 0
daa
ld h,a
ld (score + 2),hl
ret
</pre>
Displaying the score is relatively simple too, using the same routine as above:
<pre>
.show_score
ld hl,(score + 2)
call bcd_hl
ld hl,(score)
.bcd_hl
.
.
.
</pre>

=== Multiple BCD Bytes ===
This is very similar to the above method, but the values are stored and manipulated in a slightly different way. With this method, you can determine exactly how many digits you require. Maths is pretty straightforward, as is extra lives and display. One advantage this method has is that if you want to add 100 to the score, you don't have to add the two zeroes since you can start at the second BCD digit. With this method, you can store the score either little-endian (least significant bytes first) or big-endian. Big-endian has the advantage that you can read the score in a memory editor left-to-right. eg. 1234500 points is displayed as 01 23 45 00. This can make debugging easier. 
 
To define the score (6 digits):
<pre>
.score ds 3
</pre>
To add C points to the score:
<pre>
ld b,3
.add_part
ld hl,score + 2
ld a,(hl)
daa
ld (hl),a
ret nc

ret
</pre>
Displaying the score is relatively simple too, using the same routine as above:
<pre>
.show_score
ld hl,(score + 2)
call bcd_hl
ld hl,(score)
.bcd_hl
.
.
.
</pre>

More to come...

[[User:Executioner|Executioner]] 01:27, 21 September 2007 (CEST)

← Older revision		Revision as of 19:28, 8 October 2009
Line 304:		Line 304:

	[[User:Executioner\|Executioner]] 06:18, 21 September 2007 (CEST)		[[User:Executioner\|Executioner]] 06:18, 21 September 2007 (CEST)
		+
		+	[[Category:Programming]]

@@ Line 1: / Line 1: @@
-== Methods for Storing Scores in Memory ==
+== Methods for Storing, Displaying and Updating Scores ==
 There are a number of methods for storing a Score in memory, here are a few examples:<br>
 === A Single Word ===
 This is the simplest and smallest method for storing the score in memory, but it has a couple of disadvantages over some other methods. It can only hold a score up to 65535 (although you can add an extra '0' or two on the display to make that 655350 or 6553500), converting it to digits for display requires a relatively slow algorithm, and adding extra lives every 10000 points for example can take a complex routine. The advantage of using a straight Word is that the maths required to add points to the score is very simple and fast.<br>
@@ Line 214: / Line 215: @@
 </pre>
-More to come...
+=== One Byte per Digit ===
-[[User:Executioner|Executioner]] 01:27, 21 September 2007 (CEST)
+[[User:Executioner|Executioner]] 06:18, 21 September 2007 (CEST)

@@ Line 183: / Line 183: @@
 To add C points to the score:
 <pre>
 ld b,2		; This is the number of score bytes - 1
 ld hl,score + 2
 ld a,(hl)
 add c

@@ Line 203: / Line 203: @@
 <pre>
 .show_score
-ld hl,(score + 2)
+ld hl,score
-call bcd_hl
+ld b,3
-ld hl,(score)
+.show_loop
-.bcd_hl
+ld a,(hl)
+inc hl
+call bcd_a
+djnz show_loop
 </pre>

@@ Line 187: / Line 187: @@
 ld hl,score + 2
 ld a,(hl)
-sub c
+add c
 daa
 ld (hl),a
@@ Line 194: / Line 194: @@
 dec hl
 ld a,(hl)
-sub 0
+adc 0
 daa
 ld (hl),a