microchess.asm

;***********************************************************************
;
;  MicroChess (c) 1996-2002 Peter Jennings, peterj@benlo.com 
;
;***********************************************************************
; Daryl Rictor:
; I have been given permission to distribute this program by the
; author and copyright holder, Peter Jennings.  Please get his 
; permission if you wish to re-distribute a modified copy of 
; this file to others.  He specifically requested that his 
; copyright notice be included in the source and binary images.
; Thanks! 
;
; Marek Karcz:
; I have been given permission to distribute this program by the
; original author Peter Jennings under condition that I include
; link to his website in attribution.
; Here it is: http://www.benlo.com/microchess/index.html
; I did not bother to contact Daryl Rictor to ask permission to
; distribute his modifications to this software because according to
; the copyright notice on the web page of his project, permission is
; already given for personal non-commercial use:
; http://sbc.rictor.org/avr65c02.html
; http://sbc.rictor.org/download/AVR65C02.zip, readme.txt
; If this is incorrect or I misunderstood the author's intention,
; please note that I acted with no malicious intent and will remove 
; this file from my project if I receive such request.
;
; To build this program with CL65:
;
; cl65 -C microchess.cfg -l --start-addr 1024 -t none -o microchess.bin
; microchess.asm
;
; Binary image microchess.bin can be loaded to emulator with 'L'
; command in debug console. Start emulator: mkbasic, then issue
; command in debug console:
; L B MICROCHESS.BIN
;
; Memory image definition file can be generated which can be loaded
; to emulator via command line argument and automatically executed.
; To create that file, build microchess.bin image, then execute:
; 
; bin2hex -f microchess.bin -o microchess.dat -w 0 -x 1024 -z
;
; and add following lines at the end of microchess.dat file:
;
; IOADDR
; $E000
; ENIO
;
; Instructions to play:
;
; Load the game to emulator and auto-execute with command:
;    mkbasic microchess.dat
; then perform following steps:
; 1. Press 'C' to setup board.
; 2. Enter your move: 4 digits - BBEE, BB - piece coordinates,
;    EE - destination coordinates and press ENTER
; 3. After board is updated, press 'P' to make program make the move.
; 4. Repeat steps 2 and 3 until the game is finished.
; 
;
; 1/14/2012
; 	Modified Daryl Rictor's port to run on MKHBC-8-R1 homebrew
;       computer under MKHBCOS (derivative of M.O.S. by Scott 
;       Chidester).
;
; 3/11/2016
;       Adapted to run in MKBASIC (V65) emulator.
;
; 3/12/2016
;       Modified UI behavior:
;       - chess board is only printed after move, not after each
;         keystroke
;       - copyright banner is only printed once at the start
;         of the program
;
; 6551 I/O Port Addresses
;
;ACIADat    =    $7F70
;ACIAsta    =    $7F71
;ACIACmd    =    $7F72
;ACIACtl    =    $7F73

; M.O.S. API defines (kernal) - OK for emulator, no changes

.define 	mos_StrPtr	$E0
.define		tmp_zpgPt	$F6

; jumps, originally for M.O.S., now modified for emulator

.define		mos_CallGetCh	$FFED
.define		mos_CallPutCh	$FFF0
.define		mos_CallPuts	$FFF3


;
; page zero variables
;
BOARD   =	$50 
BK      =	$60 
PIECE   =	$B0 
SQUARE  =	$B1 
SP2     =	$B2 
SP1     =	$B3 
incHEK  =	$B4 
STATE   =	$B5 
MOVEN   =	$B6 
REV	=       $B7
OMOVE   =	$2C 
WCAP0   =	$2D 
COUNT   =	$2E 
BCAP2   =	$2E 
WCAP2   =	$2F 
BCAP1   =	$20 
WCAP1   =	$21 
BCAP0   =	$22 
MOB     =	$23 
MAXC    =	$24 
CC      =	$25 
PCAP    =	$26 
BMOB    =	$23 
BMAXC   =	$24 
BMCC    =	$25 ; was bcc (TASS doesn't like it as a label)
BMAXP   =	$26 
XMAXC   =	$28 
WMOB    =	$2B 
WMAXC   =	$3C 
WCC     =	$3D 
WMAXP   =	$3E 
PMOB    =	$3F 
PMAXC   =	$40 
PCC     =	$41 
PCP     =	$42 
OLDKY   =	$43 
BESTP   =	$4B 
BESTV   =	$4A 
BESTM   =	$49 
DIS1    =	$4B 
DIS2    =	$4A 
DIS3    =	$49 
temp    =       $4C

;
;
;

.segment "BEGN"

        .ORG $0000

.segment "CODE"

        .ORG    $0400            ; load into RAM @ $1000-$15FF

        lda     #$00        ; REVERSE TOGGLE
        sta     REV
        jmp     CHESS

PAINT:  .byte   $FF         ; set this flag if board needs painting
                            ; unset otherwise
PRNBANN:
        .byte   $FF         ; set this flag to print copyright banner                            

        ;jsr     Init_6551
CHESS:  cld    			; INITIALIZE
        ldx    #$FF		; TWO STACKS
        txs    
        ldx    #$C8
        stx    SP2
;        
;       ROUTINES TO LIGHT LED
;       DISPLAY and GET KEY
;       FROM KEYBOARD
;        
OUT:    jsr    POUT       ; DISPLAY and
        jsr    KIN        ; GET INPUT   *** my routine waits for a keypress
        cmp    #$43        ; [C]
        bne    NOSET       ; SET UP
        lda    #$FF        ; set PAINT flag
        sta    PAINT       ; board needs to be diplayed
        ldx    #$1F        ; BOARD
WHSET:  lda    SETW,X      ; FROM
        sta    BOARD,X     ; SETW
        dex    
        bpl    WHSET
        ldx    #$1B        ; *ADDED
        stx    OMOVE       ; INITS TO $FF
        lda    #$CC        ; DISPLAY CCC
        bne    CLDSP
;        
NOSET:  cmp    #$45        ; [E]
        bne    NOREV       ; REVERSE
        lda    #$FF
        sta    PAINT
        jsr    REVERSE     ; BOARD IS
        sec
        lda    #$01
        sbc    REV
        sta    REV          ; TOGGLE REV FLAG
        lda    #$EE         ; IS
        bne    CLDSP
;        
NOREV:  cmp    #$40         ; [P]
        bne    NOGO         ; PLAY CHESS
        lda    #$FF
        sta    PAINT
        jsr    GO
CLDSP:  sta    DIS1         ; DISPLAY
        sta    DIS2         ; ACROSS
        sta    DIS3         ; DISPLAY
        bne    CHESS
;        
NOGO:   cmp    #$0D         ; [Enter]
        bne    NOMV         ; MOVE MAN
        pha
        lda    #$FF
        sta    PAINT
        pla
        jsr    MOVE         ; AS ENTERED
        jmp    DISP
NOMV:   cmp    #$41         ; [Q] ***Added to allow game exit***
        beq    DONE         ; quit the game, exit back to system.  
        pha
        lda    #$00
        sta    PAINT
        pla
        jmp    INPUT        ; process move
DONE:   rts
;jmp     $FF00        ; *** MUST set this to YOUR OS starting address
;        
;       THE ROUTINE JANUS DIRECTS THE
;       ANALYSIS BY DETERMINING WHAT
;       SHOULD OCCUR AFTER EACH MOVE
;       GENERATED BY GNM
;        
;        
;
JANUS:  ldx    STATE
        bmi    NOCOUNT
;        
;       THIS ROUTINE COUNTS OCCURRENCES
;       IT DEPENDS UPON STATE TO INdex
;       THE CORRECT COUNTERS
;        
COUNTS: lda    PIECE
        beq    OVER             ; IF STATE=8
        cpx    #$08             ; DO NOT COUNT
        bne    OVER             ; BLK MAX CAP
        cmp    BMAXP            ; MOVES FOR
        beq    XRT              ; WHITE
;         
OVER:   inc    MOB,X            ; MOBILITY
        cmp    #$01             ;  + QUEEN
        bne    NOQ              ; FOR TWO
        inc    MOB,X
;        
NOQ:    bvc    NOCAP
        ldy    #$0F             ; CALCULATE
        lda    SQUARE           ; POINTS
ELOOP:  cmp    BK,Y             ; CAPTURED
        beq    FOUN             ; BY THIS
        dey            ; MOVE
        bpl    ELOOP
FOUN:   lda    POINTS,Y
        cmp    MAXC,X
        bcc    LESS             ; SAVE IF
        sty    PCAP,X           ; BEST THIS
        sta    MAXC,X           ; STATE
;        
LESS:   clc    
        php            ; ADD TO
        adc    CC,X             ; CAPTURE
        sta    CC,X             ; COUNTS
        plp    
;        
NOCAP:  cpx    #$04
        beq    ON4
        bmi    TREE             ;(=00 ONLY)
XRT:    rts    
;        
;      GENERATE FURTHER MOVES FOR COUNT
;      and ANALYSIS    
;        
ON4:    lda    XMAXC            ; SAVE ACTUAL 
        sta    WCAP0             ; CAPTURE
        lda    #$00               ; STATE=0
        sta    STATE
        jsr    MOVE              ; GENERATE
        jsr    REVERSE           ; IMMEDIATE
        jsr    GNMZ             ; REPLY MOVES  
        jsr    REVERSE
;        
        lda    #$08           ; STATE=8
        sta    STATE            ; GENERATE
;        jsr    OHM              ; CONTINUATION
        jsr    UMOVE             ; MOVES
;        
        jmp    STRATGY           ; FINAL EVALUATION
NOCOUNT:cpx    #$F9
        bne    TREE
;        
;      DETERMINE IF THE KING CAN BE
;      TAKEN, USED BY CHKCHK
;        
        lda    BK               ; IS KING
        cmp    SQUARE           ; IN CHECK?
        bne    RETJ             ; SET incHEK=0
        lda    #$00             ; IF IT IS
        sta    incHEK
RETJ:   rts    
;        
;      IF A PIECE HAS BEEN CAPTURED BY
;      A TRIAL MOVE, GENERATE REPLIES &
;      EVALUATE THE EXCHANGE GAIN/LOSS
;        
TREE:   bvc    RETJ              ; NO CAP
        ldy    #$07               ; (PIECES)
        lda    SQUARE
LOOPX:  cmp    BK,Y
        beq    FOUNX
        dey    
        beq    RETJ              ; (KING)
        bpl    LOOPX             ; SAVE
FOUNX:  lda    POINTS,Y           ; BEST CAP
        cmp    BCAP0,X            ; AT THIS
        bcc    NOMAX             ; LEVEL
        sta    BCAP0,X
NOMAX:  dec    STATE
        lda    #$FB               ; IF STATE=FB
        cmp    STATE            ; TIME TO TURN
        beq    UPTREE            ; AROUND
        jsr    GENRM             ; GENERATE FURTHER
UPTREE: inc    STATE            ; CAPTURES
        rts    
;        
;      THE PLAYER'S MOVE IS INPUT
;        
INPUT:  cmp    #$08           ; NOT A LEGAL
        bcs    ERROR          ; SQUARE #
        jsr    DISMV
DISP:   ldx    #$1F
SEARCH: lda    BOARD,X
        cmp    DIS2
        beq    HERE           ; DISPLAY
        dex                   ; PIECE AT    
        bpl    SEARCH         ; FROM
HERE:   stx    DIS1           ; SQUARE
        stx    PIECE
ERROR:  jmp    CHESS
;        
;      GENERATE ALL MOVES FOR ONE
;      SIDE, CALL JANUS AFTER EACH
;      ONE FOR NEXT STE?
;        
;
GNMZ:   ldx    #$10            ; CLEAR
GNMX:   lda    #$00            ; COUNTERS
CLEAR:  sta    COUNT,X
        dex    
        bpl    CLEAR
;        
GNM:    lda    #$10            ; SET UP
        sta    PIECE            ; PIECE
NEWP:   dec    PIECE            ; NEW PIECE
        bpl    NEX               ; ALL DONE?
        rts            ; #NAME?
;        
NEX:    jsr    RESET            ; READY
        ldy    PIECE            ; GET PIECE
        ldx    #$08
        stx    MOVEN            ; COMMON staRT
        cpy    #$08            ; WHAT IS IT?
        bpl    PAWN              ; PAWN
        cpy    #$06
        bpl    KNIGHT            ; KNIGHT
        cpy    #$04
        bpl    BISHOP           ; BISHOP
        cpy    #$01
        beq    QUEEN             ; QUEEN
        bpl    ROOK              ; ROOK
;        
KING:   jsr    SNGMV             ; MUST BE KING!
        bne    KING              ; MOVES
        beq    NEWP              ; 8 TO 1
QUEEN:  jsr    LINE
        bne    QUEEN             ; MOVES
        beq    NEWP              ; 8 TO 1
;        
ROOK:   ldx    #$04
        stx    MOVEN            ; MOVES
AGNR:   jsr    LINE              ; 4 TO 1
        bne    AGNR
        beq    NEWP
;        
BISHOP: jsr    LINE
        lda    MOVEN            ; MOVES
        cmp    #$04               ; 8 TO 5
        bne    BISHOP
        beq    NEWP
;        
KNIGHT: ldx    #$10
        stx    MOVEN            ; MOVES
AGNN:   jsr    SNGMV             ; 16 TO 9
        lda    MOVEN
        cmp    #$08
        bne    AGNN
        beq    NEWP
;        
PAWN:   ldx    #$06
        stx    MOVEN
P1:     jsr    CMOVE             ; RIGHT CAP?
        bvc    P2
        bmi    P2
        jsr    JANUS             ; YES
P2:     jsr    RESET
        dec    MOVEN            ; LEFT CAP?
        lda    MOVEN
        cmp    #$05
        beq    P1
P3:     jsr    CMOVE             ; AHEAD
        bvs    NEWP              ; ILLEGAL
        bmi    NEWP
        jsr    JANUS
        lda    SQUARE           ; GETS TO
        and    #$F0               ; 3RD RANK?
        cmp    #$20
        beq    P3                ; DO DOUBLE
        jmp    NEWP
;        
;      CALCULATE SINGLE STEP MOVES
;      FOR K,N    
;        
SNGMV:  jsr    CMOVE            ; CALC MOVE
        bmi    ILL1               ; -IF LEGAL
        jsr    JANUS           ; -EVALUATE
ILL1:   jsr    RESET
        dec    MOVEN
        rts    
;        
;     CALCULATE ALL MOVES DOWN A
;     STRAIGHT LINE FOR Q,B,R
;        
LINE:   jsr    CMOVE             ; CALC MOVE
        bcc    OVL                ; NO CHK
        bvc    LINE        ; NOCAP       
OVL:    bmi    ILL             ; RETURN
        php    
        jsr    JANUS             ; EVALUATE POSN
        plp    
        bvc    LINE              ; NOT A CAP
ILL:    jsr    RESET             ; LINE STOPPED
        dec    MOVEN             ; NEXT DIR
        rts    
;        
;      EXCHANGE SIDES FOR REPLY
;      ANALYSIS    
;        
REVERSE:ldx    #$0F
ETC:    sec    
        ldy    BK,X               ; SUBTRACT
        lda    #$77               ; POSITION
        sbc    BOARD,X            ; FROM 77
        sta    BK,X
        sty    BOARD,X         ; and
        sec    
        lda    #$77               ; EXCHANGE
        sbc    BOARD,X            ; PIECES
        sta    BOARD,X
        dex    
        bpl    ETC
        rts    
;        
;        CMOVE CALCULATES THE TO SQUARE
;        USING SQUARE and THE MOVE
;       TABLE  FLAGS SET AS FOLLOWS:
;       N#NAME?    MOVE
;       V#NAME?    (LEGAL UNLESS IN CR)
;       C#NAME?    BECAUSE OF CHECK
;       [MY &THANKS TO JIM BUTTERFIELD
;        WHO WROTE THIS MORE EFFICIENT
;        VERSION OF CMOVE)
;        
CMOVE:  lda    SQUARE           ; GET SQUARE
        ldx    MOVEN           ; MOVE POINTER
        clc    
        adc    MOVEX,X            ; MOVE LIST
        sta    SQUARE           ; NEW POS'N
        and    #$88
        bne    ILLEGAL           ; OFF BOARD
        lda    SQUARE
;            
        ldx    #$20
LOOP:   dex            ; IS TO
        bmi    NO                ; SQUARE
        cmp    BOARD,X            ; OCCUPIED?
        bne    LOOP
;            
        cpx    #$10            ; BY SELF?
        bmi    ILLEGAL
;            
        lda    #$7F        ; MUST BE CAP!
        adc    #$01            ; SET V FLAG
        bvs    SPX             ; (jmp)
;            
NO:     clv            ; NO CAPTURE
;            
SPX:    lda    STATE             ; SHOULD WE
        bmi    RETL               ; DO THE
        cmp    #$08             ; CHECK CHECK?
        bpl    RETL
;            
;        CHKCHK REVERSES SIDES
;       and LOOKS FOR A KING
;       CAPTURE TO INDICATE
;       ILLEGAL MOVE BECAUSE OF
;       CHECK  SincE THIS IS
;       TIME CONSUMING, IT IS NOT
;       ALWAYS DONE    
;        
CHKCHK: pha                ; STATE  #392
        php    
        lda    #$F9
        sta    STATE             ; GENERATE
        sta    incHEK            ; ALL REPLY
        jsr    MOVE              ; MOVES TO
        jsr    REVERSE           ; SEE IF KING
        jsr    GNM               ; IS IN
        jsr    RUM               ; CHECK
        plp    
        pla    
        sta    STATE
        lda    incHEK
        bmi    RETL               ; NO - SAFE
        sec            ; YES - IN CHK
        lda    #$FF
        rts    
;        
RETL:   clc            ; LEGAL
        lda    #$00            ; RETURN
        rts    
;        
ILLEGAL:lda    #$FF
        clc            ; ILLEGAL
        clv            ; RETURN
        rts    
;        
;       REPLACE PIECE ON CORRECT SQUARE
;        
RESET:  ldx    PIECE          ; GET LOGAT
        lda    BOARD,X        ; FOR PIECE
        sta    SQUARE         ; FROM BOARD
        rts    
;        
;        
;        
GENRM:  jsr    MOVE             ; MAKE MOVE
GENR2:  jsr    REVERSE          ; REVERSE BOARD
        jsr    GNM              ; GENERATE MOVES
RUM:    jsr    REVERSE          ; REVERSE BACK
;        
;       ROUTINE TO UNMAKE A MOVE MADE BY
;      MOVE
;        
UMOVE:  tsx            ; UNMAKE MOVE
        stx    SP1
        ldx    SP2     ; EXCHANGE
        txs            ; STACKS
        pla            ; MOVEN
        sta    MOVEN
        pla            ; CAPTURED
        sta    PIECE   ; PIECE
        tax    
        pla            ; FROM SQUARE
        sta    BOARD,X
        pla            ; PIECE
        tax    
        pla            ; TO SOUARE
        sta    SQUARE
        sta    BOARD,X
        jmp    STRV
;        
;       THIS ROUTINE MOVES PIECE
;       TO SQUARE, PARAMETERS
;       ARE SAVED IN A staCK TO UNMAKE
;       THE MOVE LATER
;        
MOVE:   tsx    
        stx    SP1     ; SWITCH
        ldx    SP2     ; STACKS
        txs    
        lda    SQUARE
        pha            ; TO SQUARE
        tay    
        ldx    #$1F
CHECK:  cmp    BOARD,X ; CHECK FOR
        beq    TAKE    ; CAPTURE
        dex    
        bpl    CHECK
TAKE:   lda    #$CC
        sta    BOARD,X
        txa            ; CAPTURED
        pha            ; PIECE
        ldx    PIECE
        lda    BOARD,X
        sty    BOARD,X ; FROM
        pha            ; SQUARE
        txa    
        pha            ; PIECE
        lda    MOVEN
        pha            ; MOVEN
STRV:   tsx    
        stx    SP2     ; SWITCH
        ldx    SP1     ; STACKS
        txs            ; BACK
        rts    
;            
;       CONTINUATION OF SUB STRATGY
;       -CHECKS FOR CHECK OR CHECKMATE
;       and ASSIGNS VALUE TO MOVE
;        
CKMATE: ldy    BMAXC   ; CAN BLK CAP
        cpx    POINTS  ; MY KING?
        bne    NOCHEK    
        lda    #$00    ; GULP!
        beq    RETV    ; DUMB MOVE!
;        
NOCHEK: ldx    BMOB    ; IS BLACK
        bne    RETV    ; UNABLE TO
        ldx    WMAXP   ; MOVE and
        bne    RETV    ; KING IN CH?
        lda    #$FF    ; YES! MATE
;        
RETV:   ldx    #$04    ; RESTORE
        stx    STATE   ; STATE=4
;        
;       THE VALUE OF THE MOVE (IN ACCU)
;       IS COMPARED TO THE BEST MOVE and
;       REPLACES IT IF IT IS BETTER
;        
PUSH:   cmp    BESTV       ; IS THIS BEST
        bcc    RETP        ; MOVE SO FAR?
        beq    RETP
        sta    BESTV       ; YES!
        lda    PIECE       ; SAVE IT
        sta    BESTP
        lda    SQUARE
        sta    BESTM       ; FLASH DISPLAY
RETP:   lda    #'.'        ; print ... instead of flashing disp
        jmp    syschout    ; print . and return
;        
;       MAIN PROGRAM TO PLAY CHESS
;       PLAY FROM OPENING OR THINK
;        
GO:     ldx    OMOVE           ; OPENING?
        bmi    NOOPEN          ; -NO   *ADD CHANGE FROM bpl
        lda    DIS3            ; -YES WAS
        cmp    OPNING,X        ; OPPONENT'S
        bne    END             ; MOVE OK?
        dex    
        lda    OPNING,X         ; GET NEXT
        sta    DIS1             ; CANNED
        dex            ; OPENING MOVE
        lda    OPNING,X
        sta    DIS3             ; DISPLAY IT
        dex    
        stx    OMOVE            ; MOVE IT
        bne    MV2              ; (jmp)
;            
END:    lda     #$FF        ; *ADD - STOP CANNED MOVES
        sta    OMOVE        ; FLAG OPENING
NOOPEN: ldx    #$0C         ; FINISHED
        stx    STATE        ; STATE=C
        stx    BESTV        ; CLEAR BESTV
        ldx    #$14         ; GENERATE P
        jsr    GNMX         ; MOVES
;        
        ldx    #$04         ; STATE=4
        stx    STATE        ; GENERATE and
        jsr    GNMZ         ; TEST AVAILABLE
;
;    MOVES
;        
        ldx    BESTV        ; GET BEST MOVE
        cpx    #$0F         ; IF NONE
        bcc    MATE         ; OH OH!
;        
MV2:    ldx    BESTP        ; MOVE
        lda    BOARD,X      ; THE
        sta    BESTV        ; BEST
        stx    PIECE        ; MOVE
        lda    BESTM
        sta    SQUARE       ; and DISPLAY
        jsr    MOVE         ; IT
        jmp    CHESS
;        
MATE:   lda    #$FF         ; RESIGN
        rts                 ; OR staLEMATE
;        
;       SUBROUTINE TO ENTER THE
;       PLAYER'S MOVE
;        
DISMV:  ldx    #$04    ; ROTATE
Drol:   asl    DIS3    ; KEY
        rol    DIS2    ; INTO
        dex            ; DISPLAY
        bne    Drol    ;
        ora    DIS3
        sta    DIS3
        sta    SQUARE
        rts    
;        
;       THE FOLLOWING SUBROUTINE ASSIGNS
;       A VALUE TO THE MOVE UNDER
;       CONSIDERATION and RETURNS IT IN
;    THE ACCUMULATOR
;        

STRATGY:clc    
        lda    #$80
        adc    WMOB            ; PARAMETERS
        adc    WMAXC           ; WITH WHEIGHT
        adc    WCC             ; OF O25
        adc    WCAP1
        adc    WCAP2
        sec    
        sbc    PMAXC
        sbc    PCC
        sbc    BCAP0
        sbc    BCAP1
        sbc    BCAP2
        sbc    PMOB
        sbc    BMOB
        bcs    POS             ; UNDERFLOW
        lda    #$00            ; PREVENTION
POS:    lsr    
        clc                    ; **************
        adc    #$40
        adc    WMAXC           ; PARAMETERS
        adc    WCC             ; WITH WEIGHT
        sec                    ; OF 05
        sbc    BMAXC
        lsr            ; **************
        clc    
        adc    #$90
        adc    WCAP0           ; PARAMETERS
        adc    WCAP0           ; WITH WEIGHT
        adc    WCAP0           ; OF 10
        adc    WCAP0
        adc    WCAP1
        sec                    ; [UNDER OR OVER-
        sbc    BMAXC           ; FLOW MAY OCCUR
        sbc    BMAXC           ; FROM THIS
        sbc    BMCC            ; secTION]
        sbc    BMCC
        sbc    BCAP1
        ldx    SQUARE          ; ***************
        cpx    #$33
        beq    POSN            ; POSITION
        cpx    #$34            ; BONUS FOR
        beq    POSN            ; MOVE TO
        cpx    #$22            ; CENTRE
        beq    POSN            ; OR
        cpx    #$25            ; OUT OF
        beq    POSN            ; BACK RANK
        ldx    PIECE
        beq    NOPOSN
        ldy    BOARD,X
        cpy    #$10
        bpl    NOPOSN
POSN:   clc
        adc    #$02
NOPOSN: jmp    CKMATE          ; CONTINUE


;-----------------------------------------------------------------
; The following routines were added to allow text-based board
; DISPLAY over a standard RS-232 port.
;
POUT:   lda    PAINT
        bne    POUT0
        rts                ; return if PAINT flag = 0
POUT0:  jsr    POUT9       ; print CRLF
        jsr    POUT13      ; print copyright
        jsr    POUT10      ; print column labels
        ldy    #$00        ; init board location
        jsr    POUT5       ; print board horz edge
POUT1:  lda    #'|'        ; print vert edge
        jsr    syschout    ; PRINT ONE ASCII CHR - SPACE
        ldx    #$1F
POUT2:  tya                ; scan the pieces for a location match
        cmp    BOARD,X     ; match found?
        beq    POUT4       ; yes; print the piece's color and type
        dex                ; no
        bpl    POUT2       ; if not the last piece, try again
        tya                ; empty square    
        and    #$01        ; odd or even column?                
        sta    temp        ; save it
        tya                ; is the row odd or even
        lsr                ; shift column right 4 spaces 
        lsr                ;
        lsr                ;
        lsr                ;
        and    #$01        ; strip LSB  
        clc                ; 
        adc    temp        ; combine row & col to determine square color  
        and    #$01        ; is board square white or blk?
        bne    POUT25      ; white, print space
        lda    #'*'        ; black, print *
		
        .byte  $2c         ; used to skip over lda #$20
		;jmp    POUT25A

POUT25: lda    #$20        ; ASCII space
POUT25A:jsr    syschout    ; PRINT ONE ASCII CHR - SPACE
        jsr    syschout    ; PRINT ONE ASCII CHR - SPACE
POUT3:  iny            ; 
        tya            ; get row number
        and    #$08        ; have we completed the row?     
        beq    POUT1       ; no, do next column
        lda    #'|'        ; yes, put the right edge on
        jsr    syschout    ; PRINT ONE ASCII CHR - |             
        jsr    POUT12      ; print row number
        jsr    POUT9       ; print CRLF
        jsr    POUT5       ; print bottom edge of board
        clc                ; 
        tya                ; 
        adc    #$08        ; point y to beginning of next row
        tay                ;
        cpy    #$80        ; was that the last row?
        beq    POUT8       ; yes, print the LED values
        bne    POUT1       ; no, do new row

POUT4:  lda    REV        ; print piece's color & type
        beq    POUT41     ;
        lda    cpl+16,X   ;
        bne    POUT42     ;
POUT41: lda    cpl,x      ;
POUT42: jsr    syschout   ;
        lda    cph,x      ;
        jsr    syschout   ; 
        bne    POUT3      ; branch always

POUT5:  txa            ; print "-----...-----<crlf>"
        pha
        ldx    #$19
        lda    #'-'
POUT6:  jsr    syschout    ; PRINT ONE ASCII CHR - "-"
        dex
        bne    POUT6
        pla
        tax
        jsr    POUT9
        rts             

POUT8:  jsr    POUT10        ; 
        lda    BESTP
        jsr    syshexout    ; PRINT 1 BYTE AS 2 HEX CHRS    
        lda    #$20
        jsr    syschout    ; PRINT ONE ASCII CHR - SPACE
        lda    BESTV
        jsr    syshexout    ; PRINT 1 BYTE AS 2 HEX CHRS    
        lda    #$20
        jsr    syschout    ; PRINT ONE ASCII CHR - SPACE
        lda    DIS3
        jsr    syshexout    ; PRINT 1 BYTE AS 2 HEX CHRS    

POUT9:  lda    #$0D
        jsr    syschout    ; PRINT ONE ASCII CHR - CR
        lda    #$0A
        jsr    syschout    ; PRINT ONE ASCII CHR - LF
        rts 

POUT10: ldx    #$00        ; print the column labels
POUT11: lda    #$20        ; 00 01 02 03 ... 07 <CRLF>
        jsr    syschout
        txa
        jsr    syshexout
        inx
        cpx    #$08
        bne    POUT11
        beq    POUT9
POUT12: tya
        and    #$70
        jsr    syshexout
        rts

; print banner only once, preserve registers A, X, Y
POUT13: stx    tmp_zpgPt
	sta    tmp_zpgPt+1
	sty    tmp_zpgPt+2
        lda    PRNBANN
        beq    NOPRNBANN
	lda    #<banner
        sta    mos_StrPtr
	lda    #>banner
	sta    mos_StrPtr+1
	jsr    mos_CallPuts
NOPRNBANN:
        lda    #$00
        sta    PRNBANN        
	ldx    tmp_zpgPt
	lda    tmp_zpgPt+1
	ldy    tmp_zpgPt+2
	rts

;        ldx    #$00        ; Print the copyright banner
;POUT14: lda    banner,x
;        beq    POUT15
;        jsr    syschout
;        inx
;        bne    POUT14
;POUT15: rts         

KIN:    lda    #'?'
        jsr    syschout    ; PRINT ONE ASCII CHR - ?
        jsr    syskin      ; GET A KEYSTROKE FROM SYSTEM
        jsr    syschout    ; echo entered character
        and    #$4F        ; MASK 0-7, and ALpha'S
        rts
;
; 6551 I/O Support Routines
;
;
;Init_6551      lda   #$1F               ; 19.2K/8/1
;               sta   ACIActl            ; control reg 
;               lda   #$0B               ; N parity/echo off/rx int off/ dtr active low
;               sta   ACIAcmd            ; command reg 
;               rts                      ; done
;
; input chr from ACIA1 (waiting)
;
syskin:
		jsr mos_CallGetCh
		rts

               ;lda   ACIAsta            ; Serial port status             
               ;and   #$08               ; is recvr full
               ;beq   syskin             ; no char to get
               ;lda   ACIAdat            ; get chr
               ;rts                      ;
;
; output to OutPut Port
;
syschout:		; MKHBCOS: must preserve X, Y and A
		stx tmp_zpgPt
		sta tmp_zpgPt+1
		;sty tmp_zpgPt+2
		jsr mos_CallPutCh
		ldx tmp_zpgPt
		lda tmp_zpgPt+1
		;ldy tmp_zpgPt+2
		rts
;	        pha                      ; save registers
;ACIA_Out1      lda   ACIAsta            ; serial port status
;               and   #$10               ; is tx buffer empty
;               beq   ACIA_Out1          ; no
;               pla                      ; get chr
;               sta   ACIAdat            ; put character to Port
;               rts                      ; done

syshexout:     pha                     ;  prints AA hex digits
               lsr                     ;  MOVE UPPER NIBBLE TO LOWER
               lsr                     ;
               lsr                     ;
               lsr                     ;
               jsr   PrintDig          ;
               pla                     ;
PrintDig:      
	       sty	 tmp_zpgPt+2
               and   #$0F              ;
               tay                     ;
               lda   Hexdigdata,Y      ;
               ldy   tmp_zpgPt+2       ;
               jmp   syschout          ;

Hexdigdata:   .byte    "0123456789ABCDEF"
banner:       .byte    "MicroChess (c) 1996-2002 Peter Jennings, peterj@benlo.com"
              .byte    $0d, $0a, $00
cpl:          .byte    "WWWWWWWWWWWWWWWWBBBBBBBBBBBBBBBBWWWWWWWWWWWWWWWW"
cph:          .byte    "KQCCBBRRPPPPPPPPKQCCBBRRPPPPPPPP"
              .byte    $00
;
; end of added code
;
; BLOCK DATA

.segment "DATA"

	.ORG $0A20

SETW:       .byte     $03, $04, $00, $07, $02, $05, $01, $06
            .byte     $10, $17, $11, $16, $12, $15, $14, $13
            .byte     $73, $74, $70, $77, $72, $75, $71, $76
            .byte     $60, $67, $61, $66, $62, $65, $64, $63

MOVEX:      .byte     $00, $F0, $FF, $01, $10, $11, $0F, $EF, $F1
            .byte     $DF, $E1, $EE, $F2, $12, $0E, $1F, $21

POINTS:     .byte     $0B, $0A, $06, $06, $04, $04, $04, $04
            .byte     $02, $02, $02, $02, $02, $02, $02, $02

OPNING:     .byte     $99, $25, $0B, $25, $01, $00, $33, $25
            .byte     $07, $36, $34, $0D, $34, $34, $0E, $52
            .byte     $25, $0D, $45, $35, $04, $55, $22, $06
            .byte     $43, $33, $0F, $CC

.segment "KERN"

        .ORG $FE00

CHRIN:  lda $E000
        rts

CHROUT: sta $E000
        rts          

; this function was shamelessly ripped :-) from M.O.S. code (c) by Scott Chidester

STROUT:
        ldy #0                  ; Non-indexed variant starts at zero, of course
        lda mos_StrPtr+1        ; Save StrPtr so it isn't modified
        pha
PutsLoop:
        lda (mos_StrPtr),y      ; Get the next char in the string
        beq PutsDone            ; Zero means end of string
        jsr CHROUT              ; Otherwise put the char

    ; Update string pointer
        iny                     ; increment StrPtr-lo
        bne PutsLoop            ; No rollover? Loop back for next character
        inc mos_StrPtr+1        ; StrPtr-lo rolled over--carry hi byte
        jmp PutsLoop            ; Now loop back

PutsDone:
        pla
        sta mos_StrPtr+1            ; Restore StrPtr
        rts

.segment "VECT"

        .ORG $FFED

        jmp CHRIN
        jmp CHROUT
        jmp STROUT

;
;
; end of file
;