Merge pull request #91 from fractal161/negative-delay

Add negative delay to the hz display

Author: kirjavascript

CHANGELOG.md

@@ -24,6 +24,8 @@
 * Famicom Keyboard support
 * MMC3 Support
 * MMC5 Support
+* Added "negative delay" to the hz display
+* Keep hz display enabled when topped out
 
 ## [v5 tournament]
 * Linecap Menu (from CTM Masters September 2022)

src/gamemodestate/initstate.asm

@@ -149,6 +149,8 @@ gameModeState_initGameState:
 @noTypeBPlayfield:
 
         jsr hzStart
+        lda #0
+        sta hzSpawnDelay
         jsr practiseInitGameState
         jsr resetScroll
 

src/modes/hz.asm

@@ -9,7 +9,6 @@ hzDebounceThreshold := $10
 
 hzStart: ; called in playState_spawnNextTetrimino, gameModeState_initGameState, gameMode_gameTypeMenu
         lda #0
-        sta hzSpawnDelay
         sta hzTapCounter
         lda #hzDebounceThreshold
         sta hzDebounceCounter
@@ -50,7 +49,7 @@ hzControl: ; called in playState_playerControlsActiveTetrimino, gameTypeLoopCont
         bne @noDelayInc
         lda hzSpawnDelay
         cmp #$F
-        beq @noDelayInc
+        bcs @noDelayInc
         inc hzSpawnDelay
 @noDelayInc:
         rts
@@ -183,6 +182,33 @@ hzTap:
         sta renderFlags
         rts
 
+; X: value to store if left or right is newly pressed
+checkNegativeDelay:
+        ; the tail of entry delay has two paths: a normal path, and one where
+        ; spawn delay is added (currently, tspins and debug mode)
+        ; if the spawn delay is too large, we shouldn't update here
+        lda spawnDelay
+        cmp #3
+        bcs @ret
+        lda hzSpawnDelay
+        bne @ret
+        lda newlyPressedButtons_player1
+        and #BUTTON_DPAD
+        cmp #BUTTON_LEFT
+        beq @setDelay
+        lda newlyPressedButtons_player1
+        and #BUTTON_DPAD
+        cmp #BUTTON_RIGHT
+        beq @setDelay
+        rts
+@setDelay:
+        stx hzSpawnDelay
+        lda renderFlags
+        ora #$10
+        sta renderFlags
+@ret:
+        rts
+
 dasLimitLookup:
         .byte 0, 0, 4, 11, 18, 24, 30, 36, 42 , 48; , 54, 60
         .byte 0, 0, 3, 7, 12, 16, 20, 24, 28, 32 ; PAL

src/nmi/render_hz.asm

@@ -1,15 +1,23 @@
 renderHz:
         ; only set at game start and when player is controlling a piece
         ; during which, no other tile updates are happening
-        ; this is pretty expensive and uses up $7 PPU tile writes and 1 palette write
+        ; this is pretty expensive and uses up $8 PPU tile writes and 1 palette write
 
         ; delay
 
         lda #$22
         sta PPUADDR
-        lda #$68
+        lda #$67
         sta PPUADDR
+        ldx #$24 ; minus sign
         lda hzSpawnDelay
+        and #$80
+        bne @isNegative
+        ldx #$FF ; blank tile
+@isNegative:
+        stx PPUDATA
+        lda hzSpawnDelay
+        and #$7F ; clear sign flag
         sta PPUDATA
 
 renderHzSpeedTest:

src/nmi/render_mode_play_and_demo.asm

@@ -93,7 +93,7 @@ render_mode_play_and_demo:
         and #RENDER_SCORE
         beq @renderHz
 
-        ; 8 safe tile writes freed from stats / hz
+        ; 7 safe tile writes freed from stats / hz
         ; (lazy render hz for 10 more)
         ; 1 added in level (3 total)
         ; 2 added in lines (5 total)

src/playstate/gameover_rocket.asm

@@ -1,4 +1,5 @@
 playState_checkStartGameOver:
+        jsr hzControl
 .if !ALWAYS_CURTAIN
         ; skip curtain / rocket when not qualling
         lda qualFlag

src/playstate/garbage.asm

@@ -37,8 +37,12 @@ playState_receiveGarbage:
         lda #$00
         sta pendingGarbage
         sta vramRow
-@ret:  inc playState
-@delay:  rts
+@ret:   inc playState
+        lda #$00 ; earliest possible measured point
+        sta hzSpawnDelay
+        ldx #$83 ; -3 tap delay
+        jsr checkNegativeDelay
+        rts
 
 
 garbageLines:

src/playstate/spawnnext.asm

@@ -3,11 +3,24 @@ SPAWN_NEXT_ADDONS := 1
 playState_spawnNextTetrimino:
         lda vramRow
         cmp #$20
-        bmi @ret
+        bpl :+
+        ldx #$82 ; -2 tap delay
+        jsr checkNegativeDelay
+        rts
 
+:
 .if SPAWN_NEXT_ADDONS
         lda spawnDelay
         beq @notDelaying
+        ; here, spawnDelay=1 means hzSpawnDelay=-2, 2 implies -3, and etc.
+        cmp #3 ; if spawnDelay is >= 3, don't update
+        bcs @noCheck
+        clc
+        adc #1
+        ora #$80 ; mark delay as negative
+        tax
+        jsr checkNegativeDelay
+@noCheck:
         dec spawnDelay
         jmp @ret
 .endif
@@ -24,7 +37,8 @@ playState_spawnNextTetrimino:
         sta saveStateDirty
         rts
 @noSaveState:
-
+        ldx #$81 ; -1 tap delay
+        jsr checkNegativeDelay
         jsr hzStart
 .endif
 

tests/src/cycle_count.rs

@@ -1,7 +1,56 @@
 use crate::{util, score, labels, playfield};
-use rusticnes_core::nes::NesState;
 
 pub fn count_cycles() {
+    test_hz_cycles();
+    test_max_score_cycles();
+    test_mode_score_cycles();
+}
+
+fn test_hz_cycles() {
+    // check max hz calculation amount
+    let mut emu = util::emulator(None);
+
+    let hz_flag = labels::get("hzFlag") as usize;
+    let game_mode = labels::get("gameMode") as usize;
+    let x = labels::get("tetriminoX") as usize;
+    let y = labels::get("tetriminoY") as usize;
+    let main_loop = labels::get("mainLoop");
+    let level_number = labels::get("levelNumber") as usize;
+    let debounce = labels::get("hzDebounceThreshold") as usize;
+
+    util::run_n_vblanks(&mut emu, 3);
+
+    emu.memory.iram_raw[hz_flag] = 1;
+    emu.memory.iram_raw[level_number] = 18;
+    emu.memory.iram_raw[game_mode] = 4;
+    emu.registers.pc = main_loop;
+
+    util::run_n_vblanks(&mut emu, 5);
+
+    let mut highest = 0;
+
+    for buttons in &[
+        "L.L.L.L.L",
+        "RR...R...R...R.R.",
+        ".....L.L..L.L.",
+        "LLL..L.L...L.R.R..L...R....L....L...L....L",
+        "R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R",
+    ] {
+        buttons.chars().for_each(|button| {
+            emu.memory.iram_raw[x] = 5;
+            emu.memory.iram_raw[y] = 0;
+            util::set_controller(&mut emu, button);
+            highest = highest.max(util::cycles_to_vblank(&mut emu));
+        });
+
+        util::run_n_vblanks(&mut emu, debounce + 1);
+    }
+
+    println!("hz display most cycles {}", highest);
+}
+
+fn test_max_score_cycles() {
+    // check max scoring cycle amount
     let mut emu = util::emulator(None);
 
     let completed_lines = labels::get("completedLines") as usize;
@@ -18,7 +67,6 @@ pub fn count_cycles() {
 
     let mut highest = 0;
 
-    // check every linecount on every level
     for level in 0..=255 {
         for lines in 0..=4 {
             let count = score(999999, lines, level);
@@ -30,9 +78,10 @@ pub fn count_cycles() {
     }
 
     println!("scoring routine most cycles: {}", highest);
+}
 
+fn test_mode_score_cycles() {
     // check clock cycles frames in each mode
-
     let mut emu = util::emulator(None);
 
     for mode in 0..labels::get("MODE_GAME_QUANTITY") {
@@ -76,7 +125,7 @@ pub fn count_cycles() {
             emu.memory.iram_raw[labels::get("autorepeatY") as usize] = 0;
 
             for _ in 0..45 {
-                let cycles = cycles_to_vblank(&mut emu);
+                let cycles = util::cycles_to_vblank(&mut emu);
 
                 if cycles > highest {
                     highest = cycles;
@@ -88,64 +137,4 @@ pub fn count_cycles() {
 
         println!("cycles {} lines {} mode {}", highest, lines, mode);
     }
-
-}
-
-fn cycles_to_vblank(emu: &mut NesState) -> u32 {
-    let vblank = labels::get("verticalBlankingInterval") as usize;
-    let mut cycles = 0;
-    let mut done = false;
-
-    while emu.ppu.current_scanline == 242 {
-        emu.cycle();
-        if !done {
-            cycles += 1;
-            if emu.memory.iram_raw[vblank] == 1 {
-                done = true;
-            }
-        }
-        let mut i = 0;
-        while emu.cpu.tick >= 1 && i < 10 {
-            emu.cycle();
-            if !done {
-                cycles += 1;
-                if emu.memory.iram_raw[vblank] == 1 {
-                    done = true;
-                }
-            }
-            i += 1;
-        }
-        if emu.ppu.current_frame != emu.last_frame {
-            emu.event_tracker.swap_buffers();
-            emu.last_frame = emu.ppu.current_frame;
-        }
-    }
-    emu.memory.iram_raw[vblank] = 1;
-    done = false;
-    while emu.ppu.current_scanline != 242 {
-        emu.cycle();
-        if !done {
-            cycles += 1;
-            if emu.memory.iram_raw[vblank] == 0 {
-                done = true;
-            }
-        }
-        let mut i = 0;
-        while emu.cpu.tick >= 1 && i < 10 {
-            emu.cycle();
-            if !done {
-                cycles += 1;
-                if emu.memory.iram_raw[vblank] == 0 {
-                    done = true;
-                }
-            }
-            i += 1;
-        }
-        if emu.ppu.current_frame != emu.last_frame {
-            emu.event_tracker.swap_buffers();
-            emu.last_frame = emu.ppu.current_frame;
-        }
-    }
-
-    cycles
 }