#echo
#echo ----------------- MASTER MIND ---------------------
#echo           Game with 4 digits from 1 to 7
#echo --------- 2007 guillaume.tello@orange.fr ----------
#echo

; procedures

#label A guess
#label E init

; variables

#reg 15 seed
#reg 13 secret
#reg 12 answer
#reg 09 guess_ptr
#reg 00 secret_ptr
#reg 10 my_guess
#reg 14 secret_temp

; arrays (TI Compiler V1.4 mini)

#array Gtab 1 4     ; array for guess digits
#array Stab 5 8     ; array for secret digits

;-------------------------------------------------
; nnnn A to make a guess, answer is nn,gw
; nn:number of guesses, g=number in good position,
; w=number in wrong position (nn,40 = won!)
;-------------------------------------------------

    LBL guess 
        STO my_guess                           ; 4 digits combination stored
        guess_ptr={ TOP Gtab }
        secret_ptr={ TOP Stab }
        secret_temp={ @secret }
        answer={ 1 + @answer = INT }           ; one more guess, remove fractional part (0,gw)

        ;------------------------------------------------------
        ; first part: dispach 4 digits in 4 registers for
        ;             my guess and the secret combination
        ;             At the same time, looks for right numbers
        ;             in the right place
        ;------------------------------------------------------
        
        FOR guess_ptr
            my_guess-{
                        my_guess*{ $.1 }    ; shift right
                        @my_guess frac      ; right most digit 0,n
                     }
            
            * $10 =
            STO Gtab(guess_ptr) X/T         ; n sored into array and in T

            secret_temp-{
                        secret_temp*{ $.1 } ; shift right
                        @secret_temp frac   ; right most digit 0,n'
                        }

            * $10 =                         ; n' for X (and n for T)
        
            IF(x=t)         		        ; are digits equal?
            		                    ; if so, stores 0 as my_digit (to avoid later use)
                     Gtab(guess_ptr)={ 0 }
            	   answer+{ $.1 }         ; and one more good digit in nn,gw (+0.1)
	      ENDIF

            STO Stab(secret_ptr)            ; stores digit (or 0,1 if equals to avoid later use)

            DEC secret_ptr                  ; decrement pointer
        LOOP                                ; loop from 4 to 1

        ;-------------------------------------
        ; second part: looks for right numbers
        ;              in the wrong place
        ;-------------------------------------
        
            secret_ptr={ TOP Stab }             ; loop through secret digits (reg 8,7,6,5)
            
            DO                              
                RCL Stab(secret_ptr) X/T        ; one secret digit in T to compare

                guess_ptr={ TOP Gtab }          ; to loop through my digits (reg 4,3,2,1)

                FOR guess_ptr
                    RCL Gtab(guess_ptr)
                UNTIL(x=t) wrong_place
                
                GTO lb4
                
            wrong_place:                        ; here a good digit in the wrong place
                Gtab(guess_ptr)={ 0 }           ; deletes my digit to avoid later use
                answer+{ $.01 }                 ; and one more wrong in nn,gw (+0.01)
                
            lb4:
                5 X/T                           ; 5 in T
                DEC secret_ptr
                RCL secret_ptr
            UNTIL(x<t)                          ; while >=5, go on!
            
            RCL answer                      ; displays nn,gw
            FIX 2                           ; with 2 decimals
            RTN                             ; stop

;-------------------------------------
; E to init game, secret comb is built
;-------------------------------------

#reg 09 counter

    LBL init
        answer,secret={ 0 }
        counter={ 4 }
        
        FOR counter
            secret*{ $10 }              ; shift to the left

                                        ; ramdom x'=frac[(x+pi)^5]
                                        ; converted to 1->7 digit
            secret+{                    ; and add new digit
                        seed={ @seed + PI = YX 5 = frac }
                        * 7 + 1 =                  
                        INT
                   }
        LOOP
        
        CLR                             ; hide all
    RTN

#end