fix big_negate, allow lowercase z in firm name, tighten up bigfloat.s

6 files changed, 84 insertions, 139 deletions

diff --git a/README.txt b/README.txt
index ad6736d..90fd0f8 100644
--- a/README.txt
+++ b/README.txt
@@ -43,6 +43,10 @@ Build Requirements:
 
 - perl. I use version 5.18.1, probably any 5.x version will work.
 
+- git. You don't exactly *need* this to build the code, but if you
+  have it, the git hash will be built into the binary and appear on
+  the title screen.
+
 - A UNIX/POSIX environment. At least, you need a 'cat' command and
   a shell that does I/O redirection. Linux, BSD, and Mac OS X should
   be fine. If you're on Windows, try Cygwin.
@@ -116,13 +120,6 @@ arcade game).
 
 BUGS! At least these:
 
-- The BSS can overlap the start of the title screen (it's very close
-  anyway). Consequences: There is a momentary graphics glitch when the
-  main game is done loading and before it shows the "name your firm"
-  screen. Also, we can't go back and display the title screen (but that's
-  not something really necessary anyway). The fix: make the damn code
-  smaller! Also, rearrange memory layout (see memory_layout.txt).
-
 - After a battle, the prices don't get reset (or, not always?) when
   entering the new port (confirm?).
 
@@ -155,11 +152,9 @@ BUGS! At least these:
   I'm using the graphical title screen, I have a few more characters I
   can redefine as damaged ship sections.
 
-- One of my playtesters reported that, when running away from combat, it
-  said 4 billion ships were attacking (number of ships must have gone
-  negative). I was never able to reproduce this.... but another playtester
-  reported that (in a later version), the number of enemy ships suddenly
-  jumped to 6000+ during a fight, so there's something hinky there.
+- Fixed, I think: One of my playtesters reported that, when running away
+  from combat, it said 4 billion ships were attacking (number of ships
+  must have gone negative).
 
 - After a fight, "Arriving at Manila" or such will sometimes appear on the
   fight screen without clearing it first (ships still visible).
diff --git a/bigfloat.h b/bigfloat.h
index 359438d..1976908 100644
--- a/bigfloat.h
+++ b/bigfloat.h
@@ -15,16 +15,16 @@
 /* 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 */
+/* one thousand, one million, one billion, one trillion
+   used by cprintfancy_big() */
 #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, 2**32-1 */
 #define BIG_MAX_ULONG { 0x44, 0x42, 0x94, 0x96, 0x72, 0x95 }
 
+/* unused. */
+// #define BIG_100M { 0x44, 0x01, 0x00, 0x00, 0x00, 0x00 }
+// #define BIG_10M  { 0x43, 0x10, 0x00, 0x00, 0x00, 0x00 }
diff --git a/bigfloat.s b/bigfloat.s
index 9cfae63..1ee2dc9 100644
--- a/bigfloat.s
+++ b/bigfloat.s
@@ -1,21 +1,23 @@
 
 
- .importzp ptr3, ptr4, sreg
+ .importzp ptr3, 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
 
+ ; cc65's atari.inc is missing this FP entry point:
  NORMALIZE = $dc00
 
+ ; atari.inc also has a typo, PLD1P for FLD1P
+ FLD1P = PLD1P
+
  .rodata
-BIG_64K:
+BIG_64K: ; 65535 (2**16-1) in float format.
  .byte $42, $06, $55, $36, $00, $00
 
 ;BIG_ULONG_MAX:
@@ -23,7 +25,18 @@ BIG_64K:
 
  .code
 
-; TODO: replace these *_to_* with OS calls
+; It seems like fr0_to_fptemp and friends should be using the OS
+; FLD* and FST* routines, doesn't it? But look:
+
+;fr0_to_fptemp:
+; lda #<fptemp
+; sta FLPTR
+; lda #>fptemp
+; sta FLPTR+1
+; jmp FST0P
+
+; ...that's 11 bytes of code. The fr0_to_fptemp saves 1 byte of code,
+; plus it runs faster (doesn't use FLPTR, no JMP).
 
 fr0_to_fptemp:
  ldx #5
@@ -52,36 +65,35 @@ fptemp_to_fr1:
  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
+;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);
+; void __fastcall__ big_negate(bignump b);
+; This doesn't call the ROM or use FR0/FR1, it just inverts the sign
+; bit in-place.
 _big_negate:
  sta ptr3
  stx ptr3+1
- jsr popax
- sta ptr4
- stx ptr4+1
  ldy #0
  lda (ptr3),y
  eor #$80
- sta (ptr4),y
+ sta (ptr3),y
  rts
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -134,7 +146,7 @@ _big_binary_op:
  jsr popax
  sta FLPTR
  stx FLPTR+1
- jsr PLD1P
+ jsr FLD1P
 
  ; get 1st operand (a), load into FR0
  jsr popax
@@ -194,6 +206,9 @@ _big_div:
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ; void __fastcall__ ulong_to_big(const unsigned long l, bignum *b);
+; This works by splitting the 32-bit l into two 16-bit ints and
+; converting them separately using the OS, then multiplying the high
+; result by 2^16 and adding the low result.
 _ulong_to_big:
  sta ptr3
  stx ptr3+1 ; save b (destination)
@@ -211,16 +226,32 @@ _ulong_to_big:
  stx FR0+1
  jsr IFP    ; convert to fp
 
- lda #<BIG_64K  ; high value needs to be multiplied by 65536
- sta ptr4
+ ; high value needs to be multiplied by 65536
+
+ lda #<BIG_64K
+ sta FLPTR
  lda #>BIG_64K
- sta ptr4+1
- jsr ptr4_to_fr1
+ sta FLPTR+1
+ jsr FLD1P
 
- jsr FMUL       ; multiply...
+ ; old version:
+; lda #<BIG_64K
+; sta ptr4
+; 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.
+
+ ; store it in b and we're done.
+ ;jmp fr0_to_ptr3 ; used to do this, use OS instead:
+ lda ptr3
+ sta FLPTR
+ lda ptr3+1
+ sta FLPTR+1
+ jmp FST0P
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ; char __fastcall__ big_to_ulong(bignump b, unsigned long *l);
@@ -235,7 +266,7 @@ _big_to_ulong:
  sta sreg
  stx FLPTR+1
  stx sreg+1
- jsr FLD0P ; there's a typo in atari.inc, should be FLD1P
+ jsr FLD0P
 
  ldx #<BIG_64K ; FR1 = 65536
  ldy #>BIG_64K
diff --git a/bignum.h b/bignum.h
index 4bf754c..535ea65 100644
--- a/bignum.h
+++ b/bignum.h
@@ -79,8 +79,8 @@ 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);
 
-/* negation: dest = src * -1, or dest = -src if you prefer. */
-extern void __fastcall__ big_negate(bignump dest, bignump src);
+/* negation: b = -b, or b *= -1 */
+extern void __fastcall__ big_negate(bignump b);
 
 /* returns true if the bank is maxed out. We do this by checking the exponent
 	byte, so the "max" is tied to the bignum implementation, which is why its
diff --git a/taipan.c b/taipan.c
index c440625..24b1443 100644
--- a/taipan.c
+++ b/taipan.c
@@ -313,8 +313,6 @@ bignum(big1B) = BIG_1B;
 bignum(big1M) = BIG_1M;
 bignum(big1K) = BIG_1K;
 bignum(big0) = BIG_0;
-// bignum(big100M) = BIG_100M;
-// bignum(big10M) = BIG_10M;
 
 /* what we should have:
 	For Million/Billion, 3 significant digits.
@@ -337,7 +335,7 @@ void cprintfancy_big(bignump b) {
 
 	if(big_cmp(tmp, big0) < 0) {
 		cputc('-');
-		big_negate(tmp, tmp);
+		big_negate(tmp);
 	}
 
 	if(big_cmp(tmp, big1T) >= 0) {
@@ -382,66 +380,7 @@ void cprintfancy_big(bignump b) {
 		cputc(letter);
 		cputs("illion");
 	}
-
-	// cputs("\r\n"); // TODO: see if this can go away
 }
-
-/*
-Requires a bit of explanation. b's value will always be zero or
-positive, and can range up to 1.0e+14 (aka 100 trillion).
-
-magnitude values:
-0 - result is used as-is (result range 0 - 999999)
-    b range 0 - 999999
-1 - result is in 100000's, print result/10 Million (range 0-9999)
-    b range 1,000,000 - 999,999,999 (999 Million)
-2 - result is in 100 millions, print result/10 Billion (range 0-9999)
-    b range 1,000,000,000 (1 Billion) - 999,999,999,999 (1 trillion - 1)
-
-The calling code decides whether or not to print a decimal point
-and 10ths digit (using integer math only).
-*/
-
-#if 0
-unsigned long cformat_big(char *magnitude, bignump b) {
-	bignum(tmp);
-	unsigned long ret;
-	if(big_cmp(b, big1M) < 0) {
-		*magnitude = 0;
-		big_to_ulong(b, &ret);
-	} else if(big_cmp(b, big1B) < 0) {
-		*magnitude = 1;
-		big_to_ulong(b, &ret);
-		ret /= 100000L;
-	} else {
-		*magnitude = 2;
-		big_div(tmp, b, big100M);
-		big_to_ulong(tmp, &ret);
-	}
-	return ret;
-}
-
-void cprintfancy_big(bignump b) {
-	char m;
-	unsigned long l = cformat_big(&m, b);
-	if(!m) {
-		// cprintf("%lu", l);
-		cprintulong(l);
-	} else {
-		if(l > 100) {
-			cprintulong(l / 10L);
-		} else {
-			cprintulong(l / 10L);
-			cputc('.');
-			cprintulong(l % 10L);
-		}
-		cputc(' ');
-		cputc(m == 1 ? 'M' : 'B');
-		cputs("illion");
-	}
-	cputs("\r\n");
-}
-#endif
 #endif
 
 int get_time(void) {
@@ -937,33 +876,13 @@ int sea_battle(int id, int num_ships) {
 					targeted = randi()%10;
 				} while(ships_on_screen[targeted] == 0);
 
-				/*
-            targeted = randi()%10;
-            while(ships_on_screen[targeted] == 0) {
-               targeted = randi()%10;
-            }
-				*/
-
 				/* flash_lorcha must be called an even number of times
 					to leave the lorcha in an unflashed state after. */
 				for(flashctr = 0; flashctr < 6; flashctr++) {
 					flash_lorcha(targeted);
 					jsleep(2);
 				}
-				/*
-				flash_lorcha(targeted);
-				jsleep(2);
-				flash_lorcha(targeted);
-				jsleep(2);
-				flash_lorcha(targeted);
-				jsleep(2);
-				flash_lorcha(targeted);
-				jsleep(2);
-				flash_lorcha(targeted);
-				jsleep(2);
-				flash_lorcha(targeted);
-				jsleep(2);
-				*/
+
 				damage_lorcha(targeted);
 
             ships_on_screen[targeted] -= randi()%30 + 10;
@@ -2989,7 +2908,7 @@ void bignum_test(void) {
 	for(i = 0; i < 14; i++) {
 		cprintfancy_big(n);
 		cputc(' ');
-		big_negate(n, n);
+		big_negate(n);
 		cprintfancy_big(n);
 		cputs("\r\n");
 		big_mul(n, n, o);
diff --git a/timed_getch.s b/timed_getch.s
index 5dea09c..f52f50c 100644
--- a/timed_getch.s
+++ b/timed_getch.s
@@ -67,7 +67,7 @@ notnull:
 notcontrol:
  cmp #$7c ; | (pipe, vertical bar) allowed as-is.
  beq ok
- cmp #$7a ; rest of range $7b - $7f is unmappable.
+ cmp #$7b ; rest of range $7b - $7f is unmappable.
  bcc ok   ; (remember, $7e, backspace, was handled above)
  lda #$20
 ok: