Posts by A-Frame - SMW Central

I know this is a stupid question, but I've been looking everywhere for a single-use bounce block (As used in Invictus and Nightmare Cafe III) That "poofs" away when you use it.

I have thoroughly searched the blocks section, gone through forums, and I still can't find it.

Thanks,
(and sorry)

-[Insert Signature Here]

Originally posted by MarioriaM

Is this it? https://www.smwcentral.net/?p=section&a=details&id=23551

Yes - perfect. Thanks so much!

-[Insert Signature Here]

I am trying to apply an HDMA parallax to the title screen of my hack. I am using the Cave Story - Outer Wall background.

I was not satisfied with the default parallax that came in the zip file, so I decided to make my own with Effect Tool. I am a complete noob at coding, and I don't know if the code is the issue or not. With the default parallax, it worked on the title screen, but with the one I made, it looks like the HDMA hasn't been applied.

I apply it in Uberasm\level, as I would any other UberASM file.

Here's the code for the parallax I made in Effect Tool:

Code

; To be upplied to a level using UberASMTool.


INIT:                                   ;\  This section is to be used in the INIT code of levelASM
   REP #$20                             ; | 
   LDA #$0F42                           ; | Use indeirect and mode 2 on register 210F
   STA $4350                            ; | 4350 = Mode, 4351 = Register
   LDA #ParallaxTable_160416162         ; | Address of HDMA table, get high and low byte
   STA $4352                            ; | 4352 = Low-Byte of table, 4353 = High-Byte of table
   SEP #$20                             ; | 
   LDA.b #ParallaxTable_160416162>>16   ; | Address of HDMA table, get bank byte
   STA $4354                            ; | 4354 = Bank-Byte of table
   LDA #$7F                             ; | Address of indirect table in RAM bank byte
   STA $4357                            ; | 4354 = Bank-Byte of indirect table
   LDA #$20                             ; | 
   TSB $0D9F|!addr                      ; | Enable HDMA channel 5
   RTL                                  ;/  Return	  	

;The Table takes up 10 bytes of the free RAM
;It ranges from $7F9E00 - $7F9E09 (both addresses included)

MAIN:                                   ;\  This section is to be used in the MAIN code of levelASM
   REP #$20                             ;/  16 bit action starts here. (To load the x position of the BG)

   LDA #$0000                           ;\  Multiplied by 0
   PHA                                  ; | Preserve A (current multiplication result)
   CLC : ADC #$01FE                     ; | Add rate.
   STA $7F9E00                          ; | Store to FreeRAM for indirect HDMA
   PLA                                  ;/  Restore A (current multiplication result)
   LDA $1E                              ;\  Load BG x Position
   LSR #2                               ; | Multiplied by 0.25
   PHA                                  ; | Preserve A (current multiplication result)
   CLC : ADC #$0006                     ; | Add rate.
   STA $7F9E02                          ; | Store to FreeRAM for indirect HDMA
   PLA                                  ;/  Restore A (current multiplication result)
   LDA $1E                              ;\  Load BG x Position
   ASL #0                               ; | Multiplied by 1
   PHA                                  ; | Preserve A (current multiplication result)
   CLC : ADC #$01F8                     ; | Add rate.
   STA $7F9E04                          ; | Store to FreeRAM for indirect HDMA
   PLA                                  ;/  Restore A (current multiplication result)
   LDA $1E                              ;\  Load BG x Position
   ASL #2                               ; | Multiplied by 4
   PHA                                  ; | Preserve A (current multiplication result)
   CLC : ADC #$01F2                     ; | Add rate.
   STA $7F9E06                          ; | Store to FreeRAM for indirect HDMA
   PLA                                  ;/  Restore A (current multiplication result)
   LDA $1E                              ;\  Load BG x Position
   ASL #1                               ; | Multiplied by 2
   STA $7F9E08                          ;/  Store to FreeRAM for indirect HDMA
   SEP #$20                             ; Back to 8bit
   RTL                                  ; Return

ParallaxTable_160416162:                ;\  
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E00                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E02                    ; | 
   db $01 : dw $9E04                    ; | 
   db $01 : dw $9E04                    ; | 
   db $01 : dw $9E04                    ; | 
   db $01 : dw $9E04                    ; | 
   db $01 : dw $9E04                    ; | 
   db $01 : dw $9E04                    ; | 
   db $01 : dw $9E04                    ; | 
   db $01 : dw $9E04                    ; | 
   db $01 : dw $9E04                    ; | 
   db $01 : dw $9E04                    ; | 
   db $01 : dw $9E04                    ; | 
   db $01 : dw $9E04                    ; | 
   db $01 : dw $9E04                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E06                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $01 : dw $9E08                    ; | 
   db $00                               ;/

Sorry for the inconvenience...

-[Insert Signature Here]

Okay - I just removed the RTL from the INIT:, and it looked like nothing happened. (This is how it loads with the Effect Tool versions, no matter whether I removed the RTL from the INIT or not):

Just for reference, here is the parallax that came with the bg:

This parallax worked right off the bat, but as you can see, there are some flaws with it (pieces of cloud clip and front three layers move at same speed.)

Don't know what to do...

-[Insert Signature Here]

WYE - Inserting the code and putting in the Fast BG Scroll WORKED in the level! Here's what it looked like. Granted, I'll have to rework effect tool because I screwed up and some clouds move at the wrong pace...

However, the HDMA was a bit weird on the title screen - everything moved at the same pace. Here's what it looked like.

I really appreciate your help, and I'm glad we're making progress. Don't know what else could be going wrong...

-[Insert Signature Here]

Where would I find that, perchance? (sorry, I'm fairly new)

-[Insert Signature Here]

Okay - I am trying to set a breakpoint in Mesen-S. I have the debugger open and in the very bottom in the middle section there is the "Breakpoints" spot - I'm trying to make a new breakpoint, and set the ram address (ASM file says it uses 7F9E00 - 7F9E09). The text where I type the address in turns red when I go beyond 4 digits and won't let me press "OK"- how should I proceed?

(Also - would the Breakpoint Type count as "Video RAM"?)

So sorry to keep bothering you guys..

-[Insert Signature Here]

I got it working! Thanks so much!

-[Insert Signature Here]

I am making a level where all of the foreground (sprites, ground, Mario, etc) is entirely black, and the background is using a HDMA Parallax. It is similar to the silhouette levels in DKC Returns.

In order to make Mario entirely black, I used the Custom Mario Palette v1.5.

Right before the checkpoint, I put in one Sumo Brother Lightning sprite (to troll the player). Here's a link to a video of what happened:

https://youtu.be/QnVvgSfuTXs

Here is what my palette editor looks like:

I want Mario to stay entirely black instead of turning green, and I also don't want the glitched tile near the base of the midpoint.

So far, I've applied:

-Retry Patch
-fixSpinItemJank
-Slow BG Scroll
-Jump Clip Fix
-Remove Status Bar
-Walljump Noteblock Glitch Fix
-Save Prompt Select

and an HDMA parallax made with Effectool.

Thanks!

__________________

EDIT:

If it helps, here is the bps of my rom. The level in question is 106.

EDIT 2:

New Info:

I tried applying this patch, thinking it might fix something.

Problem not resolved...

Hope this helps!

-[Insert Signature Here]

(restricted)

Final update - I narrowed it down to the custom mario palette asm file. The lightning sprite gives the glitch when you are using custom mario palettes.

I will just use a different troll because I don't know enough with asm to fix it...

-[Insert Signature Here]

I can't figure out how to put the Single Screen Patch and the Sprite Scroll Fix in the same level. I would use:

Code

init:
	JSL onescreen_init
	RTL SpriteScrollFix_init

main:
	JSL onescreen_main
	JSL SpriteScrollFix_main
	RTL

but the SpriteScrollFix doesn't have an init or main. How would I apply both?

-[Insert Signature Here]

Thanks so much!

-[Insert Signature Here]

Hello!

I am trying to insert the Sprite Scroll Fix patch, but it uses the same free ram as another patch. Where do I change the free ram?

Code:: Show/Hide

!Freeram_PrevPos = $60
;^[4 bytes], determines direction from its previous position. The first
;two bytes are for X position, and the last two are for the Y. When working
;with ASM to control the screen (by changing $7E1462 and $7E1464), DO NOT
;modify this value, you'll end up with sprites not spawning during the
;frame its modified. Note that this freeram is NOT auto-converted to SA-1
;(in case you wanted to use freeram addresses created by SA-1).

!Displacement = 0
;^Set this to 1 if you wanted to use a number that is the amount of pixels
;the screen has been moved.

!Freeram_ScrnDisplace = $7F8332
;[4 bytes], this ram is used if !Displacement is set to 1. This ram address
;holds the amount of pixels the screen has moved. Format:
;-First 2 bytes = moved horizontally
;-Last 2 = vertical.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;SA1 detector:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
if read1($00FFD5) == $23
!SA1 = 1
sa1rom
else
!SA1 = 0
endif

; Example usage
if !SA1
; SA-1 base addresses ;Give thanks to absentCrowned for this:
;http://www.smwcentral.net/?p=viewthread&t=71953
!Base1 = $3000 ;>$0000-$00FF -> $3000-$30FF
!Base2 = $6000 ;>$0100-$0FFF -> $6100-$6FFF and $1000-$1FFF -> $7000-$7FFF
else
; Non SA-1 base addresses
!Base1 = $0000
!Base2 = $0000
endif

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;Hijack
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
org $00F728 ;>Routine that depends on mario's x pos on-screen that sets $55/$56.
nop #4

org $00F80C
nop #4 ;>Routine that depends on mario's y pos on-screen that sets $55/$56.

org $00F713 ;>Where mario scrolls the screen horizontally
autoclean JML BetterScrollX
nop #1

org $00F7F4 ;>Where mario scrolls the screen vertically.
autoclean JML BetterScrollY ;>(they left out $13F1, I think...)
nop #1

freecode
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;code to be inserted to freespace
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
BetterScrollX:
PHA ;>Save A
PHX ;>Save X
PHP ;>Save processor flags.

LDX #$00
JSR ScrollSub

PLP ;>Restore processor flags.
PLX ;>Restore X
PLA ;>Restore A

LDY $1411+!Base2 ;\Restore code.
BEQ + ;|
JML $00F718 ;|
+ JML $00F75A ;/

BetterScrollY:
PHA ;>Save A
PHX ;>Save X
PHP ;>Save processor flags.

LDX #$02 ;\Use routine
JSR ScrollSub ;/

PLP ;>Restore processor flags.
PLX ;>Restore X
PLA ;>Restore A

LDX $1412+!Base2 ;\restore code
BNE + ;|
JML $00F7F9 ;>You cannot RTS on freespace if JML (must end on correct bank).
+ JML $00F7FA ;/

ScrollSub:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;Input:
;X=#$00 for x position
;X=#$02 for y position
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
REP #$20 ;>16-bit A
LDA $1462+!Base2,x ;>Load final position
if !Displacement == 0
CMP !Freeram_PrevPos,x ;>Compare (CMP actually subtracts without effecting A) with inital pos.
else
SEC ;\Subtract by previous to find the amount of change in position
SBC !Freeram_PrevPos,x ;/(the delta symbol in math)
STA !Freeram_ScrnDisplace,x ;>Store displacement into RAM
endif
BEQ .DidntScroll ;>If result is zero, the screen didn't scroll and leave $55/$56 as is.
BPL .ScrollRightDown ;>if positive (right and/or down), set $55/$56 to #$02
;.ScrollLeftUp ;>Otherwise, if negative (left and/or up), set $55/$56 to #$00
LDA #$0000 ;>load #$00 (up/left value)
BRA +

.ScrollRightDown
LDA #$0202 ;>Load #$02 (right/down value)
+
STA $55 ;>Store on $55 and $56
LDA $1462+!Base2,x ;\Update so that in case if the
STA !Freeram_PrevPos,x ;/screen scroll again on the 3rd frame.
.DidntScroll
SEP #$20 ;>8-bit A
RTS

-[Insert Signature Here]

Is there a way to change the background color and a palette row once Mario hits a certain X value? Or some equivalent to make it look like the level switched from day to night halfway through the level?

-[Insert Signature Here]

I have a song that I inserted into my ROM and doesn't loop when it finishes playing. Is there a way to just have it restart from the beginning or something similar?

-[Insert Signature Here]

Thanks so much!! It worked.

-[Insert Signature Here]

I'm looking for an effect similar to edit1754's ScrollBars tool, but that uses level ASM and I haven't found a way to run LevelASM via Asar or UberASM. Can Hdma parallax with EffecTool even generate a parallax that still has the different scrolling rates, but doesn't scroll by itself?

tl;dr: Can I get the "A Plumber For All Seasons" parallaxes in EffecTool, or how do I run LevelASM code via UberASM?

-[Insert Signature Here]

Wow! Thanks! Didn't know that - that helps a ton! Just to clarify, the main thing I have to change in LevelASM code to have it work in UberASM is changing {InitCodeLabel} and {MainCodeLabel} to init and main?

Thanks again!

-[Insert Signature Here]