Moving: MVT6

       Name: MVT6                                                    [Show more]
       Type: Subroutine
   Category: Moving
    Summary: Calculate (A P+2 P+1) = (x_sign x_hi x_lo) + (A P+2 P+1)
    Context: See this subroutine in context in the source code
 References: This subroutine is called as follows:
             * MVEIT (Part 5 of 9) calls MVT6


 Do the following calculation, for the coordinate given by X (so this is what
 it does for the x-coordinate):

   (A P+2 P+1) = (x_sign x_hi x_lo) + (A P+2 P+1)

 A is a sign bit and is not included in the calculation, but bits 0-6 of A are
 preserved. Bit 7 is set to the sign of the result.


 Arguments:

   A                    The sign of P(2 1) in bit 7

   P(2 1)               The 16-bit value we want to add the coordinate to

   X                    The coordinate to add, as follows:

                          * If X = 0, add to (x_sign x_hi x_lo)

                          * If X = 3, add to (y_sign y_hi y_lo)

                          * If X = 6, add to (z_sign z_hi z_lo)


 Returns:

   A                    The sign of the result (in bit 7)


.MVT6

 TAY                    ; Store argument A into Y, for later use

 EOR INWK+2,X           ; Set A = A EOR x_sign

 BMI MV50               ; If the sign is negative, i.e. A and x_sign have
                        ; different signs, jump to MV50

                        ; The signs are the same, so we can add the two
                        ; arguments and keep the sign to get the result

 LDA P+1                ; First we add the low bytes:
 CLC                    ;
 ADC INWK,X             ;   P+1 = P+1 + x_lo
 STA P+1

 LDA P+2                ; And then the high bytes:
 ADC INWK+1,X           ;
 STA P+2                ;   P+2 = P+2 + x_hi

 TYA                    ; Restore the original A argument that we stored earlier
                        ; so that we keep the original sign

 RTS                    ; Return from the subroutine

.MV50

 LDA INWK,X             ; First we subtract the low bytes:
 SEC                    ;
 SBC P+1                ;   P+1 = x_lo - P+1
 STA P+1

 LDA INWK+1,X           ; And then the high bytes:
 SBC P+2                ;
 STA P+2                ;   P+2 = x_hi - P+2

 BCC MV51               ; If the last subtraction underflowed, then the C flag
                        ; will be clear and x_hi < P+2, so jump to MV51 to
                        ; negate the result

 TYA                    ; Restore the original A argument that we stored earlier
 EOR #%10000000         ; but flip bit 7, which flips the sign. We do this
                        ; because x_hi >= P+2 so we want the result to have the
                        ; same sign as x_hi (as it's the dominant side in this
                        ; calculation). The sign of x_hi is x_sign, and x_sign
                        ; has the opposite sign to A, so we flip the sign in A
                        ; to return the correct result

 RTS                    ; Return from the subroutine

.MV51

 LDA #1                 ; Our subtraction underflowed, so we negate the result
 SBC P+1                ; using two's complement, first with the low byte:
 STA P+1                ;
                        ;   P+1 = 1 - P+1

 LDA #0                 ; And then the high byte:
 SBC P+2                ;
 STA P+2                ;   P+2 = 0 - P+2

 TYA                    ; Restore the original A argument that we stored earlier
                        ; as this is the correct sign for the result. This is
                        ; because x_hi < P+2, so we want to return the same sign
                        ; as P+2, the dominant side

 RTS                    ; Return from the subroutine