View difference between Paste ID: DwrwhCSC and jerGtyVP

 with the exception of rendering a few text strings and looping that dice->LCD code, game is done. Things of note...
 
 1. In the game, if you CANNOT score against a combo, you are forced to enter a score of 0 on an open combo. In this code, this is written as a value of -1. Every score is therefore upped by 1, so I can just dec a before saving it. The code to see if a combo is available (under EnterScore) should exit if a non-zero value exists for that combo.
 
 2. entryMode now controls what actions you can perform. Bit0 is throwing the dice, Bit1 is scoring against a combo. In this code, if both bits are set, you should be able to do everything. If only bit 0 is set, you should be able to roll the dice, and hold a dice, but do nothing else. If only bit 1 is set, you should be able to toggle combos and select one, but do nothing else. You should always be able to bring up the instructions and quit the game.
 
 
 ; Yatzee for TI-83+/84+
 ; Version 1.0
 ; by ACagliano
 
 .nolist
 #include "ti83plus.inc"
 #include "dcs7.inc"
 .list
 ; defines/equates
 #define diceOne 0
 #define diceTwo 1
 #define diceThree 2
 #define diceFour 3
 #define diceFive 4
 #define diceSix 5
 #define comboScores saferam1
  #define threeOnes 0
  #define threeTwos 1
  #define threeThrees 2
  #define threeFours 3
  #define threeFives 4
  #define threeSixes 5
  #define threeOfaKind 6
  #define fourOfaKind 7
  #define fullHouse 8
  #define smStraight 9
  #define lgStraight 10
  #define chance 11
  #define yatzee 12
  #define threesBonus 13
 #define gameScore comboScores+threesBonus
 #define entryMode gameScore+2
  #define spin 0
  #define score 1
 #define highScore entryMode+1
 #define curRolls highScore+2
 #define dieValues curRolls+1
 #define dieHoldFlags dieValues+5
 #define threesPoints dieHoldFlags+1
 #define saveSize threesPoints-comboFlags
 
 #define selectedCombo dieHoldFlags+1
 #define ptsforSelected selectedCombo+1
 #define rollBonuses ptsforSelected+2
 #define ctOnes rollBonuses+1
 #define ctTwos ctOnes+1
 #define ctThrees ctTwos+1
 #define ctFours ctThrees+1
 #define ctFives ctFours+1
 #define ctSixes ctFives+1
 
 
 .db $BB,$6D
 .org progstart
 
 Start:
 	bcall(_ClrLCDFull)
 	ld a,r          ;\
   	ld h,a          ; |
     	xor 77          ; |Seed the RNG
     	ld l,a          ; |
     	ld (seed1),hl   ; |
     	ld (seed2),hl   ;/
 
 	push iy \ ld iy,comboScores		; push system flags location, set IY to comboScores address
 	ld ix,dieValues				; set IX to 5-byte die roll values
 
 	ld hl,gameScore \ ld b,ctSixes-comboScores \ call zeroData	; zero the RAM savestate
 
 	ld hl,GameSave \ rst 20h \ bcall(_ChkFindSym)	; \
 	jr c,StartGame					;  | check whether save file exists
 	ld b,a \ or a \ jr z,{1@}			;  | if it doesn't skip to game start
 	bcall(_Arc_Unarc) \ bcall(_ChkFindSym)		;  | if it does and is unarchived, skip to loading
 @:	ex de,hl \ ld de,comboFlags			;  | if it does and is archived, unarchive it
 	inc hl \ inc hl					;  | load the savestate into RAM
 	ld bc,saveSize					;  |
 	ldir						; /
 StartGame:
 	call renderDie
 	call renderStats
 	ld hl,entryMode \ set spin,(hl)		; enable spinning, but not scoring yet
 KeywaitLoop:
 	ld a,(kbdScanCode) \ or a \ jr z,KeywaitLoop
 	ld hl,entryMode
 	bit score,(hl) \ jr z,{1@}  	; if the score bit is reset, you are not allowed to score now
-	cp skLeft \ jp cycleLeftCombos
+	cp skEnter \ jp z,EnterScore
-	cp skRight \ jp cycleRightCombos
+	cp skLeft \ jr nz,$+11 \ ld hl,selectedCombo \ dec (hl) \ call calcScore \ jr KeywaitLoop
-	cp skEnter \ jp EnterScore
+	cp skRight \ jr nz,$+11 \ ld hl,selectedCombo \ inc (hl) \ call calcScore \ jr KeywaitLoop
 	bit spin,(hl) \ jr z,KeywaitLoop	; if the spin bit is reset, you are not allowed to spin now
 
 @:	sub 54 \ add a,5 \ jp c,holdDice
 	add a,49
 	cp sk2nd \ jp throwDie
 	cp skClear \ jp QuitGame
 	jr KeywaitLoop
 
 holdDice:
 	ld hl,dieValues
 	add a,l \ ld l,a \ jr nc,$+3
 	inc h \ ld a,(hl)
 	xor 80h \ ld (hl),a
 	jp KeywaitLoop
 
 
 ; ### Select Combo and Compute Score ###
 
-cycleLeftCombos:
+
-	ld hl,selectedCombo \ dec (hl)
+
-	call calcScore
+	ld de,dieValues-1
 	ld bc,$0507
-cycleRightCombos:
+	inc de
-	ld hl,selectedCombo \ inc (hl)
+	ld a,(de) \ and c	; mask out the flag bits of the die
-	call calcScore
+	ld hl,ctOnes
 	add a,l
 	ld l,a
 	jr nc,$+3
 	inc h
 	inc (hl)
-	call getDieValue
+	djnz $-11
-	call getDieValue
+
-	call getDieValue
+
-	call getDieValue
+
-	call getDieValue
+	ld hl,jmptbl
 	add a,a
 	add a,l
 	ld l,a
-	or a \ jr z,isThreeOnes
+	jr nc,$+3
-	cp threeTwos \ jr z,isThreeTwos
+	inc h
-	cp threeThrees \ jr z,isThreeThrees
+	ld a,(hl)
-	cp threeFours \ jr z,isThreeFours
+
-	cp threeFives \ jr z,isThreeFives
+	ld h,(hl)
-	cp threeSixes \ jr z,isThreeSixes
+	jp (hl)
-	cp threeOfaKind \ jr z,isThreeOfaKind
+jmptbl:
-	cp fourOfaKind \ jr z,isFourOfaKind
+.dw isThreeOnes
-	cp fullHouse \ jr z,isFullHouse
+.dw isThreeTwos
-	cp smStraight \ jr z,isSmStraight
+.dw isThreeThrees
-	cp lgStraight \ jr z,isLgStraight
+.dw isThreeFours
-	cp chance \ jr z,sumtheDie
+.dw isThreeFives
-	cp yatzee \ jr z,isYatzee
+.dw isThreeSixes
 .dw isThreeOfaKind
 .dw isFourOfaKind
 .dw isfullHouse
 .dw isSmStraight
 .dw isLgStraight
 .dw sumtheDie
 .dw isYatzee
 
 calcBonuses:
 	dec a \ ld (ptsforSelected),a
 	call isYatzee \ or a \ jr z,{1@}
 	dec a \ ld (rollBonuses),a
 @:	ld a,(threesBonus) \ or a \ call z,isFullTopSix
-	rla \ inc a \ ret
+
 	call rendertPoints
 	ret
-	ld b,a \ rla \ add a,b
+
 isThreeOnes:
 	ld a,(ctOnes) \ inc a \ ret
 isThreeTwos:
-	rla \ rla
+
 	add a,a \ inc a \ ret
 isThreeThrees:
 	ld a,(ctThrees)
-	ld b,a \ rla \ rla \ add a,b
+	ld b,a \ add a,a \ add a,b
 	inc a \ ret
 isThreeFours:
 	ld a,(ctFours)
-	rla \ rla \ rla
+	add a,a \ add a,a
 	inc a \ ret
 isThreeFives:
 	ld a,(ctFives)
 	ld b,a \ add a,a \ add a,a \ add a,b
 	inc a \ ret
 isThreeSixes:
 	ld a,(ctSixes)
 	ld b,a
 	add a,a
 	add a,b
 	add a,a
-	ld a,0
+
 isThreeOfaKind:
 	ld a,2 \ jr {1@}
 isFourOfaKind:
 	ld a,3
 @:	ld hl,ctOnes-1
 	checkQuantity \ jr c,sumtheDie
 	checkQuantity \ jr c,sumtheDie
 	checkQuantity \ jr c,sumtheDie
 	checkQuantity \ jr c,sumtheDie
 	checkQuantity \ jr c,sumtheDie
 	xor a
 	ret
 
 isFullHouse:
 	ld a,2 \ ld hl,ctOnes-1
 	checkQuantity \ jr c,{1@}
-	jr {2@}
+
 	checkQuantity \ jr c,{1@}
-@:	ld a,0 \ ret
+
 	checkQuantity \ jr c,{1@}
 	jr {3@}
 @:	ld a,1 \ ld hl,ctOnes-1
 	checkQuantity \ jr c,{1@}
 	checkQuantity \ jr c,{1@}
 	checkQuantity \ jr c,{1@}
 	checkQuantity \ jr c,{1@}
 	checkQuantity \ jr c,{1@}
 	xor a\ ret
 @:	ld a,26 \ ret
 
 isSmStraight:
 	ld hl,ctOnes \ ld a,(hl)
 	or a \ jr z,strt_start_2
 	ld b,3
 	inc hl \ and (hl)
 	djnz $-2
 	jr nz,{1@}
 strt_start_2:
 	inc hl \ ld a,(hl)
 	or a \ jr z,strt_start_3
 	ld b,3
 	inc hl \ and (hl)
 	djnz $-2
 	jr nz,{}
 strt_start_3:
 	inc hl \ ld a,(hl)
 	or a \ ret z
 	ld b,3
 	inc hl \ and (hl)
 	djnz $-2
 	ret z
 @:	ld a,31 \ ret
 
 isLgStraight
-@:	ld a,0 \ ret
+
 	or a \ jr z,strt_1_to_5
 ;strt_2_to_6:
 	inc hl
 strt_1_to5:
 	ld a,(hl) \ ld b,3
 	inc hl \ and (hl)
 	djnz $-2
 	ret z
-	ld a,0 \ ret
+
 
 isYatzee:
 	ld hl,ctOnes-1 \ ld a,4
-	ld hl,comboScores \ ld a,0
+
 	checkQuantity \ jr c,{1@}
 	checkQuantity \ jr c,{1@}
 	checkQuantity \ jr c,{1@}
 	checkQuantity \ jr c,{1@}
-	ld a,0 \ ret
+	xor a \ ret
 @:	ld a,51 \ ret
 
 isFullTopSix:
 	ld hl,comboScores \ xor a
 	ld b,6
 @:	add a,(hl) \ inc hl
-	ld a,0 \ ld hl,dieValues
+
 	cp 62 \ jr c,{1@}
 	xor a \ ret
 @: 	ld a,1 \ ld (threesBonus),a \ ld a,35 \ ret
-	inc a
+
 
 
 
 sumtheDie:
 	ld a,1 \ ld hl,dieValues
-getDieValue:
+
 @:	add a,(hl) \ inc hl
-	ld a,(hl) \ and %01111111	; reset high byte in A, not in memory
+
-	cp 1 \ jr nz,{1@}
+
-	ld a,(ctOnes) \ inc a \ ld (ctOnes),a \ ret
+
-@:	cp 2 \ jr nz,{1@}
+
-	ld a,(ctTwos) \ inc a \ ld (ctTwos),a \ ret
+
-@:	cp 3 \ jr nz,{1@}
+
-	ld a,(ctThrees) \ inc a \ ld (ctThrees),a \ ret
+
-@:	cp 4 \ jr nz,{1@}
+
-	ld a,(ctFours) \ inc a \ ld (ctFours),a \ ret
+
-@:	cp 5 \ jr nz,{1@}
+
-	ld a,(ctFives) \ inc a \ ld (ctFives),a \ ret
+	call roll
-@:	cp 6 \ ret nz
+	call roll
-	ld a,(ctSixes) \ inc a \ ld (ctSixes),a \ ret
+	call roll
 	call roll
 	call roll
 	call renderDie
 	ld hl,entryMode \ set score,(hl)	; allow scoring once die rolled
 	ld hl,curRolls \ inc (hl)		; increment number of rolls by one
 	ld a,3 \ sub (hl) \ jr nz,KeywaitLoop	; if rolls != 3, leave routine
 	ld hl,entryMode \ res spin,(hl)		; if rolls = 3, disable rolling
 	jr KeywaitLoop
-    	call roll
+
-    	call roll
+
-    	call roll
+
-   	call roll
+
-    	call roll
+
-    	call renderDie
+
-    	ld hl,entryMode \ set score,(hl)	; allow scoring once die rolled
+
-    	ld hl,curRolls \ inc (hl)		; increment number of rolls by one
+
-    	ld a,3 \ sub (hl) \ jr nz,KeywaitLoop	; if rolls != 3, leave routine
+	inc a \ jr z,{1@}
-    	ld hl,entryMode \ res spin,(hl)		; if rolls = 3, disable rolling
+
-    	jr KeywaitLoop
+
 	add hl,bc		; add score to game score
 	xor a
 	ld b,a \ ld c,(rollBonuses)
 	add hl,bc		; add bonuses to game score
 	ld (gameScore),hl	; write new score back
 	ld hl,entryMode \ res score,(hl) \ set spin,(hl)	; disable scoring, enable spinning
 	ld (curRolls),a			; set back to 0 rolls
 @:	jp KeywaitLoop
-	cp -1 \ jr z,{1@}
+
 QuitGame:
 	ld hl,GameSave \ rst 20h \ bcall(_ChkFindSym)
 	jr nc,{1@}					; if save exists already, skip to saving
-	ld b,0 \ ld c,(rollBonuses)
+
 @:	ld hl,comboFlags \ inc de \ inc de		; set read address to RAM state, set write address to after size word
 	ld bc,saveSize \ ldir				; set size, load
 	bcall(_ClrLCDFull)				; clear screen
-	ld a,0 \ ld (curRolls),a			; set back to 0 rolls
+
 	ret						; exit game
 
 renderDie:
 	ld hl,Sprites
 
 	ret
 
 renderStats:
 
 	ret
 
 
 
 rendertPoints:
 	ld a,(selectedCombo)
 	ld hl,ComboNameText \ ld b,a
 	or a \ jr z,{2@}
 @:	add hl,7
 	djnz {-1@}
 @:	; set penCol and penRow
 	bcall(_vPutS)
 	ld a,(ptsforSelected)
 	; convert byte value into text string
 	ret
 
 die_setZero:
 	ld hl,dieValues		; set read address to dieValues
 	xor a \ ld (hl),a	; set dieValues to 0
 	ld de,dieValues+1	; set write address to dieValues+1
 	ld bc,4 \ ldir		; copy 4 bytes from read address to write address
 	ret
 
 zeroData:
 	xor a
 	ld (hl),a \ inc hl
 	djnz zeroData
 	ret
-	ld a,0 \ ld (hl),a	; set dieValues to 0
+
 ; ########################
 ; Random Number Generator
 ; ########################
 
 prng16:
-	ld a,0
+
 ;;Output:
 ;;    HL is a pseudo-random int
 ;;    A and BC are also, but much weaker and smaller cycles
 ;;    Preserves DE
 ;;148cc, super fast
 ;;26 bytes
 ;;period length: 4,294,901,760
 seed1=$+1
     ld hl,9999
     ld b,h
     ld c,l
     add hl,hl
     add hl,hl
     inc l
     add hl,bc
     ld (seed1),hl
 seed2=$+1
     ld hl,987
     add hl,hl
     sbc a,a
     and %00101101
     xor l
     ld l,a
     ld (seed2),hl
     add hl,bc
     ret
 roll:
 ;;Input: A is the range.
 ;;Output: Returns in A a random number from 0 to B-1.
 ;;  B=0
 ;;  DE is not changed
 ;;Destroys:
 ;;  HL
 ;;Speed:
 ;;  322cc to 373cc, 347.5cc average
      inc hl
      ld a,(hl) \ add a,a
      ret nc
      push hl
      call prng16
      ld l,h \ ld h,0
      ld b,h \ ld c,l
      add hl,hl \ add hl,bc \ add hl,hl
      inc h \ ld a,h
      pop hl
      ld (hl),a
      ret
 
 ; ########################
 ; ## Rendering Routines ##
 ; ########################
 
 drawSprite_6_Bit:
 	ld a,d \ add a,$79	; Y coord into A
 	ld b,12			; Loop this 12 times
 drawSprite_outerloop:
 	inc a \ push af
 	out ($10),a \ call lcdwait
 	ld a,e \ add a,$20
 	out ($10),a \ call lcdwait	; use outi instead
 	ld c,$11
 	outi \ call lcdwait
 	outi \ call lcdwait
 	pop bc \ pop af
 	djnz drawSprite_outerloop
 
 
 
 
 
 
 
 
 lcdwait:
 	in a,($10) ;bit 7 set if LCD is busy
 	rla \ jr c,lcdwait
 	ret
 
 
 
 GameSave:
 .db AppVarObj,"YatSave",0
 
 ComboNameText:
 .db "Ones  ",0
 .db "Twos  ",0
 .db "Threes",0
 .db "Fours ",0
 .db "Fives ",0
 .db "Sixes ",0
 .db "3.of.a",0
 .db "4.of.a.",0
 .db "F.Hse.",0
 .db "Sm.St.",0
 .db "Lg.St.",0
 .db "Chance",0
 .db "Yatzee",0
 
 
 Sprites:
 ; empty die
 .db %11111111,%11110000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %11111111,%11110000
 ; one die
 .db %11111111,%11110000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000110,%00010000
 .db %10000110,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %11111111,%11110000
 ; two die
 .db %11111111,%11110000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000110,%00010000
 .db %10000110,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000110,%00010000
 .db %10000110,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %11111111,%11110000
 ; three die
 .db %11111111,%11110000
 .db %10000000,%00010000
 .db %10000000,%11010000
 .db %10000000,%11010000
 .db %10000000,%00010000
 .db %10000110,%00010000
 .db %10000110,%00010000
 .db %10000000,%00010000
 .db %10110000,%00010000
 .db %10110000,%00010000
 .db %10000000,%00010000
 .db %11111111,%11110000
 ; four die
 .db %11111111,%11110000
 .db %10000000,%00010000
 .db %10110000,%11010000
 .db %10110000,%11010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10000000,%00010000
 .db %10110000,%11010000
 .db %10110000,%11010000
 .db %10000000,%00010000
 .db %11111111,%11110000
 ; five die
 .db %11111111,%11110000
 .db %10000000,%00010000
 .db %10011001,%10010000
 .db %10011001,%10010000
 .db %10000000,%00010000
 .db %10000110,%00010000
 .db %10000110,%00010000
 .db %10000000,%00010000
 .db %10011001,%10010000
 .db %10011001,%10010000
 .db %10000000,%00010000
 .db %11111111,%11110000
 ; six die
 .db %11111111,%11110000
 .db %10000000,%00010000
 .db %10011001,%10010000
 .db %10011001,%10010000
 .db %10000000,%00010000
 .db %10011001,%10010000
 .db %10011001,%10010000
 .db %10000000,%00010000
 .db %10011001,%10010000
 .db %10011001,%10010000
 .db %10000000,%00010000
 .db %11111111,%11110000