From d72f8556e703eb8c84d055bfc5a8dcb2620ad61e Mon Sep 17 00:00:00 2001 From: "B. Watson" Date: Sun, 17 Jan 2016 04:08:52 -0500 Subject: restore colors/font on exit, fix bank withdrawal bug, rename bignum stuff --- Makefile | 11 +- bigfloat.s | 334 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ bignum.h | 49 ++++----- bignum.s | 334 ------------------------------------------------------------- newtitle.s | 15 +++ taipan.c | 31 ++++-- 6 files changed, 397 insertions(+), 377 deletions(-) create mode 100644 bigfloat.s delete mode 100644 bignum.s diff --git a/Makefile b/Makefile index 4375957..c3a46b4 100644 --- a/Makefile +++ b/Makefile @@ -93,9 +93,14 @@ TAIMAIN_ASM_SRC=rand.s draw_lorcha.s timed_getch.s jsleep.s portstat.s clrtobot. # Comment these lines out to build without big number support. # This will stop being possible at some point. -BIGNUM_SRC=bignum.s -BIGNUM_HDRS=bignum.h -BIGNUM_CFLAGS=-DBIGNUM +BIGNUM_SRC=bigfloat.s +BIGNUM_HDRS=bignum.h bigfloat.h +BIGNUM_CFLAGS=-DBIGNUM=BIGFLOAT + +# Uncomment these for experimental int48 big numbers +#BIGNUM_SRC=bigint48.c +#BIGNUM_HDRS=bignum.h bigint48.h +#BIGNUM_CFLAGS=-DBIGNUM=BIGINT48 # Default rule for plain 'make' command is to build the binary. all: $(XEX) diff --git a/bigfloat.s b/bigfloat.s new file mode 100644 index 0000000..9cfae63 --- /dev/null +++ b/bigfloat.s @@ -0,0 +1,334 @@ + + + .importzp ptr3, ptr4, sreg + .import popeax, popax, pushax, _memcmp + .export _ulong_to_big, _big_to_ulong, _big_add, _big_sub, _big_mul, _big_div + .export _bank_maxed_out, _big_cmp, _big_copy, _big_negate + + .include "atari.inc" + +;IFP = $d9aa + + fptemp = $a0 ; for now + trampoline = $c0 + + NORMALIZE = $dc00 + + .rodata +BIG_64K: + .byte $42, $06, $55, $36, $00, $00 + +;BIG_ULONG_MAX: + ;.byte $44, $42, $94, $96, $72, $95 + + .code + +; TODO: replace these *_to_* with OS calls + +fr0_to_fptemp: + ldx #5 +@l: + lda FR0,x + sta fptemp,x + dex + bpl @l + rts + +fptemp_to_fr0: + ldx #5 +@l: + lda fptemp,x + sta FR0,x + dex + bpl @l + rts + +fptemp_to_fr1: + ldx #5 +@l: + lda fptemp,x + sta FR1,x + dex + bpl @l + rts + +fr0_to_ptr3: + ldy #5 +@l: + lda FR0,y + sta (ptr3),y + dey + bpl @l + rts + +ptr4_to_fr1: + ldy #5 +@l: + lda (ptr4),y + sta FR1,y + dey + bpl @l + rts + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; void __fastcall__ big_negate(bignump dest, bignump src); +_big_negate: + sta ptr3 + stx ptr3+1 + jsr popax + sta ptr4 + stx ptr4+1 + ldy #0 + lda (ptr3),y + eor #$80 + sta (ptr4),y + rts + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; truncate FR0 to integer (no rounding: 2.8 -> 2) +trunc_fr0: + lda FR0 + and #$7f ; strip sign bit (we only care about exponent magnitude) + sec + sbc #$3f ; A now holds # of base-100 digits in integer part + bcs @ok ; # of int digits > 0? + jmp ZFR0 ; no, zero out FR0 and exit + +@ok: + cmp #5 ; are there <= 5 int digits? + bcs @done ; no, the number's already an integer. + + tax ; zero out digits: X is first one after decimal point + lda #0 +@zloop: + sta FR0+1,x + inx + cpx #5 + bne @zloop + +@done: + rts + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; void __fastcall__ big_copy(bignump dest, bignump src) +_big_copy: + sta FLPTR ; src arg in FLPTR + stx FLPTR+1 + jsr FLD0P ; load src value into FR0 + jsr popax ; get dest arg + sta FLPTR ; dest arg in FLPTR + stx FLPTR+1 + jmp FST0P ; store FR0 value into dest + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; void __fastcall__ big_binary_op(bignump dest, bignump a, bignump b, unsigned int jsraddr); +_big_binary_op: + + ; JSR address in A/X pair, set up JMP instruction + sta trampoline+1 + stx trampoline+2 + lda #$4c ; JMP opcode + sta trampoline + + ; get 2nd operand (b), load into FR1 + jsr popax + sta FLPTR + stx FLPTR+1 + jsr PLD1P + + ; get 1st operand (a), load into FR0 + jsr popax + sta FLPTR + stx FLPTR+1 + jsr FLD0P + + ; call the FP routine + jsr trampoline + +; jsr NORMALIZE +; .byte $02 + + ; result now in FR0, get destination & copy + jsr popax + sta FLPTR + stx FLPTR+1 + jmp FST0P + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; void __cdecl__ big_add(bignump dest, bignump a, bignump b); +_big_add: + lda #FADD + jmp _big_binary_op + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; void __cdecl__ big_sub(bignump dest, bignump a, bignump b); +_big_sub: + lda #FSUB + jmp _big_binary_op + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; void __cdecl__ big_mul(bignump dest, bignump a, bignump b); +_big_mul: + lda #FMUL + jmp _big_binary_op + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; void __cdecl__ big_div(bignump dest, bignump a, bignump b); +_big_div: + lda #FDIV + jmp _big_binary_op + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; void __fastcall__ big_trunc(bignump b); +; C-callable wrapper for trunc_fr0 + sta FLPTR + stx FLPTR+1 + jsr FLD0P + jsr trunc_fr0 + jsr FST0P + rts + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; void __fastcall__ ulong_to_big(const unsigned long l, bignum *b); +_ulong_to_big: + sta ptr3 + stx ptr3+1 ; save b (destination) + + jsr popeax ; get low 16 bits of l in A/X (hi 16 bits in sreg) + sta FR0 + stx FR0+1 + jsr IFP ; convert A/X to fp + + jsr fr0_to_fptemp ; stash it + + lda sreg ; now get high 16 bits of l in A/X + sta FR0 + ldx sreg+1 + stx FR0+1 + jsr IFP ; convert to fp + + lda #BIG_64K + sta ptr4+1 + jsr ptr4_to_fr1 + + jsr FMUL ; multiply... + jsr fptemp_to_fr1 ; grab low value + jsr FADD ; add to total + jmp fr0_to_ptr3 ; store it in b and we're done. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; char __fastcall__ big_to_ulong(bignump b, unsigned long *l); +; +; This works, but it's not small, fast, or elegant... +_big_to_ulong: + sta ptr3 + stx ptr3+1 ; save *l (dest) + + jsr popax ; get b + sta FLPTR + sta sreg + stx FLPTR+1 + stx sreg+1 + jsr FLD0P ; there's a typo in atari.inc, should be FLD1P + + ldx #BIG_64K + jsr FLD1R + + jsr FDIV ; FR0 = FR0 / FR1 + jsr trunc_fr0 ; FR0 = INT(FR0) + jsr fr0_to_fptemp ; stash for later... + jsr FPI ; get integer form + bcc @ok ; OS supposed to return with C set if range error + + ; failed, return 0 to caller + lda #0 + tax + rts + +@ok: + ldy #2 ; save top 16 bits of result where they belong + lda FR0 + sta (ptr3),y + iny + lda FR0+1 + sta (ptr3),y + + jsr fptemp_to_fr0 ; this is int((*b)/65536) in FR0 now + + ldx #BIG_64K + jsr FLD1R + + jsr FMUL ; FR0 now int((*b)/65536)*65536 + jsr FMOVE ; FR1 = FR0 + + ldx sreg ; reload original *b in FR0 + ldy sreg+1 + jsr FLD0R + jsr trunc_fr0 ; grrr. If we don't do this, we get rounding (not desired) + + jsr FSUB ; FR0 = FR0 - FR1 + jsr FPI + + ldy #0 ; store low 16 bits where they belong + lda FR0 + sta (ptr3),y + iny + lda FR0+1 + sta (ptr3),y + + ; success. return 1 to caller. + tya + ldx #0 + rts + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; char __fastcall__ bank_maxed_out(bignump b); +_bank_maxed_out: + sta FLPTR + stx FLPTR+1 + jsr FLD0P + jsr NORMALIZE ; just in case + lda FR0 ; get exponent + ldx #0 + eor #$7f ; remove sign bit (should never be negative anyway!) + cmp #$46 + bcc @false + lda #1 + rts +@false: + txa + rts + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; signed char __fastcall__ big_cmp(bignump a, bignump b) +; +; this could be better: it could be a wrapper for _big_binary_op. But +; I'd have to move stuff all around on the stack. +_big_cmp: + sta FLPTR + stx FLPTR+1 + jsr FLD0P + + jsr FMOVE ; move to FR1 (since it's the 2nd arg) + + jsr popax ; get a arg + + sta FLPTR + stx FLPTR+1 + jsr FLD0P + + ; subtract (and throw away the result, only care about sign) + jsr FSUB ; FR0 = FR0 - FR1 + + lda FR0 ; exponent has sign bit, and happily is 0 if the result was 0! + tax ; sign extension, grr. + rts + diff --git a/bignum.h b/bignum.h index 501d47c..4bf754c 100644 --- a/bignum.h +++ b/bignum.h @@ -21,34 +21,21 @@ which looks a little weird I admit. */ -#define bignum(x) char x[6] -#define bignump char * - -/****** constants ******/ -/* zero */ -#define BIG_0 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } - -/* TODO: calculate bank interest differently: this bignum - implementation is floating point, but I might swap it out - for an int-based one! */ -/* 1.005 (bank interest) */ -#define BIG_1_005 { 0x40, 0x01, 0x00, 0x50, 0x00, 0x00 } - -/* bignum 100, used for score calculations in final_stats() */ -#define BIG_100 { 0x41, 0x01, 0x00, 0x00, 0x00, 0x00 } - -/* one thousand, one million, one hundred million */ -#define BIG_1K { 0x41, 0x10, 0x00, 0x00, 0x00, 0x00 } -#define BIG_1M { 0x43, 0x01, 0x00, 0x00, 0x00, 0x00 } -#define BIG_100M { 0x44, 0x01, 0x00, 0x00, 0x00, 0x00 } - -/* 10 million, one billion, one trillion */ -#define BIG_10M { 0x43, 0x10, 0x00, 0x00, 0x00, 0x00 } -#define BIG_1B { 0x44, 0x10, 0x00, 0x00, 0x00, 0x00 } -#define BIG_1T { 0x46, 0x01, 0x00, 0x00, 0x00, 0x00 } - -/* max value for a ulong */ -#define BIG_MAX_ULONG { 0x44, 0x42, 0x94, 0x96, 0x72, 0x95 } +/* list all our implementations here */ +#define BIGFLOAT 1 +#define BIGINT48 2 + +#ifndef BIGNUM +#error bignum.h requires BIGNUM to be defined +#endif + +#if BIGNUM == BIGFLOAT +#include "bigfloat.h" +#elif BIGNUM == BIGINT48 +#include "bigint48.h" +#else +#error BIGNUM must be defined to one of: BIGFLOAT BIGINT48 +#endif /****** functions ******/ @@ -92,7 +79,7 @@ extern char __cdecl__ big_sub(bignump dest, bignump minuend, bignump subtrahend) extern char __cdecl__ big_mul(bignump dest, bignump multiplicand, bignump multiplier); extern char __cdecl__ big_div(bignump dest, bignump dividend, bignump divisor); -/* dest = src * -1 */ +/* negation: dest = src * -1, or dest = -src if you prefer. */ extern void __fastcall__ big_negate(bignump dest, bignump src); /* returns true if the bank is maxed out. We do this by checking the exponent @@ -105,7 +92,5 @@ extern void __fastcall__ big_negate(bignump dest, bignump src); */ extern char __fastcall__ bank_maxed_out(bignump b); -// signed char big_cmp(const bignum *a, const bignum *b) - -extern unsigned long cformat_big(char *magnitude, bignump b); +/* print a bignum, Taipan-style. Code for this lives in taipan.c actually. */ extern void cprintfancy_big(bignump b); diff --git a/bignum.s b/bignum.s deleted file mode 100644 index 9cfae63..0000000 --- a/bignum.s +++ /dev/null @@ -1,334 +0,0 @@ - - - .importzp ptr3, ptr4, sreg - .import popeax, popax, pushax, _memcmp - .export _ulong_to_big, _big_to_ulong, _big_add, _big_sub, _big_mul, _big_div - .export _bank_maxed_out, _big_cmp, _big_copy, _big_negate - - .include "atari.inc" - -;IFP = $d9aa - - fptemp = $a0 ; for now - trampoline = $c0 - - NORMALIZE = $dc00 - - .rodata -BIG_64K: - .byte $42, $06, $55, $36, $00, $00 - -;BIG_ULONG_MAX: - ;.byte $44, $42, $94, $96, $72, $95 - - .code - -; TODO: replace these *_to_* with OS calls - -fr0_to_fptemp: - ldx #5 -@l: - lda FR0,x - sta fptemp,x - dex - bpl @l - rts - -fptemp_to_fr0: - ldx #5 -@l: - lda fptemp,x - sta FR0,x - dex - bpl @l - rts - -fptemp_to_fr1: - ldx #5 -@l: - lda fptemp,x - sta FR1,x - dex - bpl @l - rts - -fr0_to_ptr3: - ldy #5 -@l: - lda FR0,y - sta (ptr3),y - dey - bpl @l - rts - -ptr4_to_fr1: - ldy #5 -@l: - lda (ptr4),y - sta FR1,y - dey - bpl @l - rts - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; void __fastcall__ big_negate(bignump dest, bignump src); -_big_negate: - sta ptr3 - stx ptr3+1 - jsr popax - sta ptr4 - stx ptr4+1 - ldy #0 - lda (ptr3),y - eor #$80 - sta (ptr4),y - rts - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; truncate FR0 to integer (no rounding: 2.8 -> 2) -trunc_fr0: - lda FR0 - and #$7f ; strip sign bit (we only care about exponent magnitude) - sec - sbc #$3f ; A now holds # of base-100 digits in integer part - bcs @ok ; # of int digits > 0? - jmp ZFR0 ; no, zero out FR0 and exit - -@ok: - cmp #5 ; are there <= 5 int digits? - bcs @done ; no, the number's already an integer. - - tax ; zero out digits: X is first one after decimal point - lda #0 -@zloop: - sta FR0+1,x - inx - cpx #5 - bne @zloop - -@done: - rts - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; void __fastcall__ big_copy(bignump dest, bignump src) -_big_copy: - sta FLPTR ; src arg in FLPTR - stx FLPTR+1 - jsr FLD0P ; load src value into FR0 - jsr popax ; get dest arg - sta FLPTR ; dest arg in FLPTR - stx FLPTR+1 - jmp FST0P ; store FR0 value into dest - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; void __fastcall__ big_binary_op(bignump dest, bignump a, bignump b, unsigned int jsraddr); -_big_binary_op: - - ; JSR address in A/X pair, set up JMP instruction - sta trampoline+1 - stx trampoline+2 - lda #$4c ; JMP opcode - sta trampoline - - ; get 2nd operand (b), load into FR1 - jsr popax - sta FLPTR - stx FLPTR+1 - jsr PLD1P - - ; get 1st operand (a), load into FR0 - jsr popax - sta FLPTR - stx FLPTR+1 - jsr FLD0P - - ; call the FP routine - jsr trampoline - -; jsr NORMALIZE -; .byte $02 - - ; result now in FR0, get destination & copy - jsr popax - sta FLPTR - stx FLPTR+1 - jmp FST0P - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; void __cdecl__ big_add(bignump dest, bignump a, bignump b); -_big_add: - lda #FADD - jmp _big_binary_op - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; void __cdecl__ big_sub(bignump dest, bignump a, bignump b); -_big_sub: - lda #FSUB - jmp _big_binary_op - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; void __cdecl__ big_mul(bignump dest, bignump a, bignump b); -_big_mul: - lda #FMUL - jmp _big_binary_op - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; void __cdecl__ big_div(bignump dest, bignump a, bignump b); -_big_div: - lda #FDIV - jmp _big_binary_op - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; void __fastcall__ big_trunc(bignump b); -; C-callable wrapper for trunc_fr0 - sta FLPTR - stx FLPTR+1 - jsr FLD0P - jsr trunc_fr0 - jsr FST0P - rts - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; void __fastcall__ ulong_to_big(const unsigned long l, bignum *b); -_ulong_to_big: - sta ptr3 - stx ptr3+1 ; save b (destination) - - jsr popeax ; get low 16 bits of l in A/X (hi 16 bits in sreg) - sta FR0 - stx FR0+1 - jsr IFP ; convert A/X to fp - - jsr fr0_to_fptemp ; stash it - - lda sreg ; now get high 16 bits of l in A/X - sta FR0 - ldx sreg+1 - stx FR0+1 - jsr IFP ; convert to fp - - lda #BIG_64K - sta ptr4+1 - jsr ptr4_to_fr1 - - jsr FMUL ; multiply... - jsr fptemp_to_fr1 ; grab low value - jsr FADD ; add to total - jmp fr0_to_ptr3 ; store it in b and we're done. - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; char __fastcall__ big_to_ulong(bignump b, unsigned long *l); -; -; This works, but it's not small, fast, or elegant... -_big_to_ulong: - sta ptr3 - stx ptr3+1 ; save *l (dest) - - jsr popax ; get b - sta FLPTR - sta sreg - stx FLPTR+1 - stx sreg+1 - jsr FLD0P ; there's a typo in atari.inc, should be FLD1P - - ldx #BIG_64K - jsr FLD1R - - jsr FDIV ; FR0 = FR0 / FR1 - jsr trunc_fr0 ; FR0 = INT(FR0) - jsr fr0_to_fptemp ; stash for later... - jsr FPI ; get integer form - bcc @ok ; OS supposed to return with C set if range error - - ; failed, return 0 to caller - lda #0 - tax - rts - -@ok: - ldy #2 ; save top 16 bits of result where they belong - lda FR0 - sta (ptr3),y - iny - lda FR0+1 - sta (ptr3),y - - jsr fptemp_to_fr0 ; this is int((*b)/65536) in FR0 now - - ldx #BIG_64K - jsr FLD1R - - jsr FMUL ; FR0 now int((*b)/65536)*65536 - jsr FMOVE ; FR1 = FR0 - - ldx sreg ; reload original *b in FR0 - ldy sreg+1 - jsr FLD0R - jsr trunc_fr0 ; grrr. If we don't do this, we get rounding (not desired) - - jsr FSUB ; FR0 = FR0 - FR1 - jsr FPI - - ldy #0 ; store low 16 bits where they belong - lda FR0 - sta (ptr3),y - iny - lda FR0+1 - sta (ptr3),y - - ; success. return 1 to caller. - tya - ldx #0 - rts - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; char __fastcall__ bank_maxed_out(bignump b); -_bank_maxed_out: - sta FLPTR - stx FLPTR+1 - jsr FLD0P - jsr NORMALIZE ; just in case - lda FR0 ; get exponent - ldx #0 - eor #$7f ; remove sign bit (should never be negative anyway!) - cmp #$46 - bcc @false - lda #1 - rts -@false: - txa - rts - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -; signed char __fastcall__ big_cmp(bignump a, bignump b) -; -; this could be better: it could be a wrapper for _big_binary_op. But -; I'd have to move stuff all around on the stack. -_big_cmp: - sta FLPTR - stx FLPTR+1 - jsr FLD0P - - jsr FMOVE ; move to FR1 (since it's the 2nd arg) - - jsr popax ; get a arg - - sta FLPTR - stx FLPTR+1 - jsr FLD0P - - ; subtract (and throw away the result, only care about sign) - jsr FSUB ; FR0 = FR0 - FR1 - - lda FR0 ; exponent has sign bit, and happily is 0 if the result was 0! - tax ; sign extension, grr. - rts - diff --git a/newtitle.s b/newtitle.s index 15b73ad..8997d82 100644 --- a/newtitle.s +++ b/newtitle.s @@ -9,6 +9,13 @@ ; change this here, change it in sounds.h also! sound_disabled = $06ff + ; since we're changing the font and colors, we'll save the old + ; ones here. If you change these, change them in taipan.c + ; also. +fontsave = $06fc +color1save = $06fd +color2save = $06fe + ; where our screen was loaded (see newtitle.pl) ;screendata = $2400 @@ -127,6 +134,14 @@ sounddisp = help + 78 ; executable code here start: + ; save old color registers and font addr. + lda CHBAS + sta fontsave + lda COLOR1 + sta color1save + lda COLOR2 + sta color2save + ; setup color registers lda colorchoices sta COLOR2 ; text bg diff --git a/taipan.c b/taipan.c index 97d2271..fc3bb7b 100644 --- a/taipan.c +++ b/taipan.c @@ -1860,10 +1860,21 @@ void final_stats(void) return; } - /* restore ROM character set. TODO: save old PEEK(756) - in newtitle.s, restore that here instead of using - hardcoded value. */ - POKE(756, 224); + + /* exit(0) works by itself in DOS 2.0S or 2.5, or any DUP.SYS + style DOS that reopens the E: device when entering the menu. + However, command-line DOSes (XL and Sparta) don't do this, + which results in garbage on screen and wrong colors. So: */ + + /* restore CHBAS to its original value, generally the ROM font. + This is called fontsave in newtitle.s. */ + POKE(756, PEEK(0x6fc)); + + /* restore COLOR1 and COLOR2. These locations are called + color1save and color2save in newtitle.s. */ + POKE(709, PEEK(0x6fd)); + POKE(710, PEEK(0x6fe)); + exit(0); } @@ -2919,10 +2930,14 @@ void visit_bank(void) continue; } - big_sub(bank, bank, bigamt); - big_add(bigcash, bigcash, bigamt); - big_to_ulong(bigcash, &cash); - break; + if(big_cmp(bank, bigamt) < 0) { + you_only_have(1); + } else { + big_sub(bank, bank, bigamt); + big_add(bigcash, bigcash, bigamt); + big_to_ulong(bigcash, &cash); + break; + } #else if (amount == -1) { -- cgit v1.2.3