157 lines
7.5 KiB
Plaintext
157 lines
7.5 KiB
Plaintext
; NumberJack: a number-only blackjack game in MU8A for the mu808 VM
|
|
;
|
|
; How to play:
|
|
; * you start with a $1000 balance
|
|
; * on each round, enter your bet
|
|
; (the game will quit if the bet is above your balance)
|
|
; * the first card of the dealer's hand will be shown
|
|
; (hands are shown with a leading 1 that you must ignore)
|
|
; (card values are: 1 is ace, 2 to 9 are "as is", 0 is 10 to K)
|
|
; * on the first turn, select 0 (stand), 1 (hit) or 2 (double)
|
|
; * on each next turn, select 0 (stand) or 1 (hit)
|
|
; * as a result of the round, the dealer's final hand will be shown
|
|
; first and then yours
|
|
; * the dealer must draw on 16 and stand on any 17
|
|
; * player's blackjack pays 3 to 2
|
|
;
|
|
; Created by Luxferre in 2025, released into public domain
|
|
|
|
; constants section
|
|
set 10 0 51 ; set constant 10 to loc 51
|
|
set 100 0 52 ; set constant 100 to loc 52
|
|
set 13 0 53 ; upper RNG limit to loc 53
|
|
set 16 0 54 ; dealer draw limit to loc 54
|
|
set 21 0 55 ; 21 score limit to loc 55
|
|
set 12 0 56 ; 12 score limit to loc 56
|
|
set 1000 0 60 ; set $1000 initial balance
|
|
set 2 0 57 ; set constant 2 to loc 57
|
|
set 36 0 58 ; set constant 36 to loc 58
|
|
set 101 0 80 ; set the first blackjack condition to loc 80
|
|
set 110 0 81 ; set the second blackjack condition to loc 81
|
|
juc :main ; jump to the main code
|
|
|
|
; subroutines section (return address is in loc 99)
|
|
; random card pulling procedure (result is in loc 2, from 0 to 9)
|
|
:gcard rnd 127 53 1 ; set loc 1 to random integer between 1 and 13
|
|
div 1 51 2 ; divide it by 10 into loc 2
|
|
mdf 2 0 2 ; get the floor part of the result into the same loc 2
|
|
sub 127 2 2 ; subtract it from 1
|
|
mul 1 2 ; multiply by the random choice itself, result is in loc 2
|
|
iuc 99 ; jump to the return address in loc 99
|
|
|
|
; score evaluation procedure
|
|
; param is in loc 1, resulting scores are in locs 2 and 3
|
|
:score set 0 0 2 ; set score1 to 0
|
|
set 0 0 8 ; set aces to 0
|
|
:slp mdf 1 51 4 ; get the current digit n of val
|
|
div 1 51 1 ; divide val by 10
|
|
mdf 1 0 1 ; get the floor part into the same loc
|
|
jgt 4 :scn ; skip if n > 0
|
|
fma 51 127 4 ; add 10 to n
|
|
:scn fma 4 127 2 ; add n to score1 at loc 2
|
|
sub 4 127 5 ; subtract 1 from n to loc 5
|
|
jne 5 :sc2 ; skip if n != 1
|
|
inc 8 ; increment aces count at loc 8
|
|
:sc2 sub 1 127 5 ; subtract 1 from val to loc 5
|
|
jgt 5 :slp ; go to loop start if val > 1
|
|
dva 2 3 ; assign score2 (at loc 3) = score1 (at loc 2)
|
|
sub 8 127 5 ; subtract 1 from aces (loc 8)
|
|
jne 5 :send ; go to procedure end if aces != 1
|
|
sub 2 56 5 ; subtract 12 from the score1 value
|
|
jge 5 :send ; go to procedure end if score1 >= 12
|
|
fma 51 127 3 ; add 10 to score2 if there was exactly one non-busting ace
|
|
:send iuc 99 ; jump to the return address in loc 99
|
|
|
|
; main code section
|
|
; variables:
|
|
; 60 - balance, 61 - bet, 62 - dealer's hand, 63 - player's hand, 64 - round
|
|
:main out 58 58 1 ; output the dollar sign (if supported)
|
|
out 60 60 0 ; output the current balance
|
|
jeq 60 :end ; game over if it's zero
|
|
inp 61 61 0 ; input your bet
|
|
sub 60 61 60 ; subtract the bet from the balance
|
|
jlt 60 :end ; game over if over balance
|
|
dca :r1 99 ; set the return address
|
|
juc :gcard ; call the card generation procedure
|
|
:r1 fma 52 51 2 ; loc 2 <- 100 + 10 * card in loc 2
|
|
dva 2 62 ; copy the result into loc 62
|
|
dca :r2 99 ; set the return address
|
|
juc :gcard ; call the card generation procedure again (in loc 2)
|
|
:r2 fma 2 127 62 ; add this result into loc 62 (dealer's hand)
|
|
dva 62 1 ; copy the dealer's hand as the proc parameter
|
|
dca :r3 99 ; set the return address
|
|
juc :score ; call the scoring procedure
|
|
:r3 sub 3 55 5 ; we only have to compare score 2 to 21
|
|
jeq 5 :main ; start the loop over if we have dealer's blackjack
|
|
dca :r4 99 ; set the return address
|
|
juc :gcard ; call the card generation procedure
|
|
:r4 fma 52 51 2 ; loc 2 <- 100 + 10 * card in loc 2
|
|
dva 2 63 ; copy the result into loc 63 (player's hand)
|
|
dca :r5 99 ; set the return address
|
|
juc :gcard ; call the card generation procedure again (in loc 2)
|
|
:r5 fma 2 127 63 ; add this result into loc 63 (player's hand)
|
|
div 62 51 5 ; get the start of the dealer's hand by dividing it by 10...
|
|
mdf 5 0 5 ; and getting the floor part
|
|
out 5 5 0 ; display the start of the dealer's hand
|
|
set 0 0 64 ; set the round index to 0
|
|
set 0 0 9 ; set the stand flag to 0
|
|
:rnl out 63 63 0 ; start of the inner player loop, display the player's hand
|
|
inp 6 6 0 ; input the action into loc 6
|
|
jeq 6 :std ; jump to stand action if 0
|
|
sub 6 127 5 ; check if 1
|
|
jeq 5 :hit ; jump to hit action if 1
|
|
sub 5 127 5 ; check if 2
|
|
jeq 5 :dbl ; jump to double action if 2
|
|
juc :skp ; jump to skip otherwise
|
|
:dbl jne 64 :skp ; skip double if not the first round
|
|
sub 60 61 60 ; subtract more balance
|
|
mul 57 61 ; double the bet
|
|
set 1 0 9 ; set the stand flag, proceed to the hit section next
|
|
:hit dca :r6 99 ; set the return address
|
|
juc :gcard ; call the card generation procedure
|
|
:r6 fma 2 51 63 ; loc 63 <- loc 63 * 10 + card in loc 2
|
|
inc 64 ; increment the round index
|
|
juc :skp ; jump to skip afterwards
|
|
:std set 1 0 9 ; set the stand flag
|
|
inc 64 ; increment the round index
|
|
:skp dva 63 1 ; copy the current player's hand to loc 1 as a parameter
|
|
dca :r7 99 ; set the return address
|
|
juc :score ; call the scoring procedure
|
|
:r7 sub 2 55 5 ; we only have to compare score 1 to 21
|
|
jle 5 :nob ; reloop to beginning if the player is bust
|
|
out 63 63 0 ; output the player's hand
|
|
juc :main ; reloop
|
|
:nob jeq 9 :rnl ; repeat the inner player loop if the stand flag is 0
|
|
dva 3 72 ; copy the player score 2 to loc 72
|
|
set 0 0 9 ; set the stand flag to 0
|
|
:rnd dva 62 1 ; start the inner dealer's loop, set the scoring procedure param
|
|
dca :r9 99 ; set the return address
|
|
juc :score ; call the scoring procedure
|
|
:r9 sub 2 55 5 ; we need to compare score 1 to 21 => loc 5
|
|
sub 3 54 6 ; we need to compare score 2 to 16 => loc 6
|
|
jgt 5 :s3 ; go to stand if score1 > 21
|
|
jgt 6 :s3 ; go to stand if score2 > 16
|
|
juc :s4 ; skip if neither
|
|
:s3 juc :s5 ; jump outside to stand
|
|
:s4 dca :r8 99 ; set the return address
|
|
juc :gcard ; call the card generation procedure
|
|
:r8 fma 2 51 62 ; loc 62 <- loc 62 * 10 + card in loc 2
|
|
jeq 9 :rnd ; repeat the inner dealer loop if the stand flag is 0
|
|
:s5 out 62 63 0 ; output both hands (dealer's first)
|
|
sub 63 80 1 ; compare player hand with 101
|
|
jeq 1 :bjk ; jump to the blackjack condition if equal
|
|
sub 63 81 1 ; compare player hand with 110
|
|
jeq 1 :bjk ; jump to the blackjack condition if equal
|
|
sub 3 72 1 ; compare dealer score 2 and player score 2
|
|
jeq 1 :push ; push condition
|
|
jlt 1 :win ; player win condition
|
|
sub 2 55 1 ; compare dealer score 1 with 21
|
|
jgt 1 :win ; player win condition
|
|
juc :main ; reloop to beginning
|
|
:bjk div 61 57 1 ; halve the bet
|
|
fma 1 127 60 ; add half the bet (for blackjack calc)
|
|
:win fma 61 127 60 ; add bet first time
|
|
:push fma 61 127 60 ; add bet second time
|
|
juc :main ; reloop to beginning
|
|
:end nnn ; just a nop label for the program end
|