[Archived] Hack ideas: for those without the skill but with all the ideas.

Started by Piotyr, March 23, 2007, 10:11:50 PM

Previous topic - Next topic


This TMNT Re-revenge hack is good and i can't help thinking that now someone can use the beats of rage engine and use all the custom streets of rage levels. Adding these tmnt's and the storyline we could get a finished version on dreamcast. I really hope you guys can do this as there is sooo many Beats of rage version's on dreamcast now this seems like it could be easyer now that Re-revenge has been made to the streets of rage rom.

TMNT Re-revenge:  https://www.romhacking.net/hacks/7399/

Now that beat's even pizza dude


An idea: (Gameboy) Ultima Runes of Virtue 1 & 2 DX
Colorization plus faster transitions and Magic Points regen (since Magic is vital to progress sometimes, and it's possible to wind up in a situation where you are forced to not waste a single spell point else you can't solve the puzzle and must restart the dungeon)


It occurred to me that in 'Super Mario Bros.' the title screen doesn't make much sense as Luigi isn't there with Mario. So there's no 'Bros.', just Mario. It's sorta silly but I feel the title screen should have both Mario and Luigi present to be consistent with 'Bros.'


Rom Hack Ideas: Since I lack the skill I have to ask for fellow Megaman fans and programmers. I am trying to play as much Megaman X games and rom hacks as I can since I am very sick.  I absolutely love the Protoman and Zero editions since they give me an amazing nostalgia feeling. I am asking If any1 knows of a hack or knows how to edit sprits for X, X2, or/and X3 and Bring Bass into the X Games. Playing these games again bring back my best childhood memories and Bass is one of my favorite characters. I am hoping and praying some1 sees this post and can help me out. Ty.



This sprite is amazing but can not find the creator nor rom hack =(


I know how to edit and change the sprite graphics in Mega Man X titles 1-3. I also made an X1 hack that was dubbed as Bass 21XX, much similar to the original name of my hack featuring Protoman. I started working on it in 2013. And updated in 2015, but I never released it. I still have it, and I can even send a PM to you if you want to try it out.

I also have a sprite editing tutorial on how to edit the graphics in Mega Man X 1 to 3.


This may get buried. Would anyone be interested in creating an editor for Record Of Lodoss War: Advent Of Cardice? Specifically for mob stats. I love the gears and ancients available, but some parts of the game are easier than others. I think it would be amazing if an editor were created to be able to edit all of the stats of each mob. Id love to make my own hardtype to make it more challenging, and make the end game a punishment even with maxed out ancients. It would give more weight and purpose to the grind Imo. Just a thought


Hey there! If anyone is willing to translate the SNES game "Fortune Quest: Dice o Korogase" / "Fortune Quest: Dice wo Korogase" from Japanese to English, please post it in the Script Help and Language Discussion section of the RomHacking.net forum.

Original Japanese: Fortune Quest - Dice o Korogase
English Translation: Fortune Quest - Roll the Dice
Developed by: Zamuse

Original Japanese release date: April 1994
English translation release date: Soon, hopefully. :)

Database match: Fortune Quest - Dice o Korogase (Japan)
Database: No-Intro: Super Nintendo Entertainment System (v. 20210222-050638)
File SHA-1: E6AFFC113774D88625CC3F7114BC6BBA7EEBF1D7
File MD5: 1DE01A0C9FECC71BCA8DFF5428E9A75E
File CRC32: 909128CB
ROM SHA-1: 88196F790071C51EDB15E9CADDA5172FDA344262
ROM MD5: CEA1C1F391252D67BEE0934B07C87267
ROM CRC32: 448E3712


various Wily Wars hack ideas:

Ports of the first 3 gameboy games with GB4 replacing Wily Tower

Ports of the best rom hacks for all 3 main games and rearranged Wily Tower levels

Rockman: KAIZO WORLD (An insanely unfair version of Wily Wars

Slowdown removal to match the Genesis Mini but on original genesis hardware. (like 100% removed slowdown)

Sega CD & 32X Support Edition


A new utiliy for Super Mario Kart to make sure every tracks has a different graphic?


Dragon Ball Z hyper Dimension Hack MSU compatible patch English translation


Twilight Tanslations https://www.romhacking.net/translations/1537/

This is the best Dragon Ball Z on Super Nintendo, 16 and 32 bits generation. ( Very personal opinion )

Thanks in advance.  :thumbsup:


I wish that Vargskelethor from the Vinesauce community would release Super Bone Bros. 2 to the public, I asked him and the community in the past in their discord servers if anyone has it, and of course everybody stays hush hush for some reason.

Maybe someone can recreate Super Bone Bros. 2 so our community can have it, we already have Super Bone Bros.


Could anyone please look into the code for Super Mario Bros. to find out why the invisible platform bug exists (World 4-3 comes to mind)? In Super Mario Bros. 2 (Japan; "The Lost Levels" to us) there were some tweaks to correct some of the original NES SMB1's flaws, but not that one.

For example:
    tay                         ;save offset from state as Y
    lda Enemy_ID,y              ;check if other object is balance platform
    cmp #$24
    bne ExBalP                  ;if not, leave
    lda PlatformCollisionFlag,x ;get collision flag of platform
    sta $00                     ;store here

Here's the original code for those of you interested in looking at it for your SMB1 hacks (part 1 of 2):
;$00 - used to hold collision flag, Y movement force + 5 or low byte of name table for rope
;$01 - used to hold high byte of name table for rope
;$02 - used to hold page location of rope

       lda Enemy_Y_HighPos,x       ;check high byte of vertical position
       cmp #$03
       bne DoBPl
       jmp EraseEnemyObject        ;if far below screen, kill the object
DoBPl: lda Enemy_State,x           ;get object's state (set to $ff or other platform offset)
       bpl CheckBalPlatform        ;if doing other balance platform, branch to leave

       tay                         ;save offset from state as Y
       lda PlatformCollisionFlag,x ;get collision flag of platform
       sta $00                     ;store here
       lda Enemy_MovingDir,x       ;get moving direction
       beq ChkForFall
       jmp PlatformFall            ;if set, jump here

       lda #$2d                    ;check if platform is above a certain point
       cmp Enemy_Y_Position,x
       bcc ChkOtherForFall         ;if not, branch elsewhere
       cpy $00                     ;if collision flag is set to same value as
       beq MakePlatformFall        ;enemy state, branch to make platforms fall
       adc #$02                    ;otherwise add 2 pixels to vertical position
       sta Enemy_Y_Position,x      ;of current platform and branch elsewhere
       jmp StopPlatforms           ;to make platforms stop

       jmp InitPlatformFall        ;make platforms fall

       cmp Enemy_Y_Position,y      ;check if other platform is above a certain point
       bcc ChkToMoveBalPlat        ;if not, branch elsewhere
       cpx $00                     ;if collision flag is set to same value as
       beq MakePlatformFall        ;enemy state, branch to make platforms fall
       adc #$02                    ;otherwise add 2 pixels to vertical position
       sta Enemy_Y_Position,y      ;of other platform and branch elsewhere
       jmp StopPlatforms           ;jump to stop movement and do not return

        lda Enemy_Y_Position,x      ;save vertical position to stack
        lda PlatformCollisionFlag,x ;get collision flag
        bpl ColFlg                  ;branch if collision
        lda Enemy_Y_MoveForce,x
        clc                         ;add $05 to contents of moveforce, whatever they be
        adc #$05
        sta $00                     ;store here
        lda Enemy_Y_Speed,x
        adc #$00                    ;add carry to vertical speed
        bmi PlatDn                  ;branch if moving downwards
        bne PlatUp                  ;branch elsewhere if moving upwards
        lda $00
        cmp #$0b                    ;check if there's still a little force left
        bcc PlatSt                  ;if not enough, branch to stop movement
        bcs PlatUp                  ;otherwise keep branch to move upwards
ColFlg: cmp ObjectOffset            ;if collision flag matches
        beq PlatDn                  ;current enemy object offset, branch
PlatUp: jsr MovePlatformUp          ;do a sub to move upwards
        jmp DoOtherPlatform         ;jump ahead to remaining code
PlatSt: jsr StopPlatforms           ;do a sub to stop movement
        jmp DoOtherPlatform         ;jump ahead to remaining code
PlatDn: jsr MovePlatformDown        ;do a sub to move downwards

       ldy Enemy_State,x           ;get offset of other platform
       pla                         ;get old vertical coordinate from stack
       sbc Enemy_Y_Position,x      ;get difference of old vs. new coordinate
       adc Enemy_Y_Position,y      ;add difference to vertical coordinate of other
       sta Enemy_Y_Position,y      ;platform to move it in the opposite direction
       lda PlatformCollisionFlag,x ;if no collision, skip this part here
       bmi DrawEraseRope
       tax                         ;put offset which collision occurred here
       jsr PositionPlayerOnVPlat   ;and use it to position player accordingly

         ldy ObjectOffset            ;get enemy object offset
         lda Enemy_Y_Speed,y         ;check to see if current platform is
         ora Enemy_Y_MoveForce,y     ;moving at all
         beq ExitRp                  ;if not, skip all of this and branch to leave
         ldx VRAM_Buffer1_Offset     ;get vram buffer offset
         cpx #$20                    ;if offset beyond a certain point, go ahead
         bcs ExitRp                  ;and skip this, branch to leave
         lda Enemy_Y_Speed,y
         pha                         ;save two copies of vertical speed to stack
         jsr SetupPlatformRope       ;do a sub to figure out where to put new bg tiles
         lda $01                     ;write name table address to vram buffer
         sta VRAM_Buffer1,x          ;first the high byte, then the low
         lda $00
         sta VRAM_Buffer1+1,x
         lda #$02                    ;set length for 2 bytes
         sta VRAM_Buffer1+2,x
         lda Enemy_Y_Speed,y         ;if platform moving upwards, branch
         bmi EraseR1                 ;to do something else
         lda #$a2
         sta VRAM_Buffer1+3,x        ;otherwise put tile numbers for left
         lda #$a3                    ;and right sides of rope in vram buffer
         sta VRAM_Buffer1+4,x
         jmp OtherRope               ;jump to skip this part
EraseR1: lda #$24                    ;put blank tiles in vram buffer
         sta VRAM_Buffer1+3,x        ;to erase rope
         sta VRAM_Buffer1+4,x

         lda Enemy_State,y           ;get offset of other platform from state
         tay                         ;use as Y here
         pla                         ;pull second copy of vertical speed from stack
         eor #$ff                    ;invert bits to reverse speed
         jsr SetupPlatformRope       ;do sub again to figure out where to put bg tiles 
         lda $01                     ;write name table address to vram buffer
         sta VRAM_Buffer1+5,x        ;this time we're doing putting tiles for
         lda $00                     ;the other platform
         sta VRAM_Buffer1+6,x
         lda #$02
         sta VRAM_Buffer1+7,x        ;set length again for 2 bytes
         pla                         ;pull first copy of vertical speed from stack
         bpl EraseR2                 ;if moving upwards (note inversion earlier), skip this
         lda #$a2
         sta VRAM_Buffer1+8,x        ;otherwise put tile numbers for left
         lda #$a3                    ;and right sides of rope in vram
         sta VRAM_Buffer1+9,x        ;transfer buffer
         jmp EndRp                   ;jump to skip this part
EraseR2: lda #$24                    ;put blank tiles in vram buffer
         sta VRAM_Buffer1+8,x        ;to erase rope
         sta VRAM_Buffer1+9,x
EndRp:   lda #$00                    ;put null terminator at the end
         sta VRAM_Buffer1+10,x
         lda VRAM_Buffer1_Offset     ;add ten bytes to the vram buffer offset
         clc                         ;and store
         adc #10
         sta VRAM_Buffer1_Offset
ExitRp:  ldx ObjectOffset            ;get enemy object buffer offset and leave

        pha                     ;save second/third copy to stack
        lda Enemy_X_Position,y  ;get horizontal coordinate
        adc #$08                ;add eight pixels
        ldx SecondaryHardMode   ;if secondary hard mode flag set,
        bne GetLRp              ;use coordinate as-is
        adc #$10                ;otherwise add sixteen more pixels
GetLRp: pha                     ;save modified horizontal coordinate to stack
        lda Enemy_PageLoc,y
        adc #$00                ;add carry to page location
        sta $02                 ;and save here
        pla                     ;pull modified horizontal coordinate
        and #%11110000          ;from the stack, mask out low nybble
        lsr                     ;and shift three bits to the right
        sta $00                 ;store result here as part of name table low byte
        ldx Enemy_Y_Position,y  ;get vertical coordinate
        pla                     ;get second/third copy of vertical speed from stack
        bpl GetHRp              ;skip this part if moving downwards or not at all
        adc #$08                ;add eight to vertical coordinate and
        tax                     ;save as X
GetHRp: txa                     ;move vertical coordinate to A
        ldx VRAM_Buffer1_Offset ;get vram buffer offset
        rol                     ;rotate d7 to d0 and d6 into carry
        pha                     ;save modified vertical coordinate to stack
        rol                     ;rotate carry to d0, thus d7 and d6 are at 2 LSB
        and #%00000011          ;mask out all bits but d7 and d6, then set
        ora #%00100000          ;d5 to get appropriate high byte of name table
        sta $01                 ;address, then store
        lda $02                 ;get saved page location from earlier
        and #$01                ;mask out all but LSB
        asl                     ;shift twice to the left and save with the
        ora $01                 ;rest of the bits of the high byte, to get
        sta $01                 ;the proper name table and the right place on it
        pla                     ;get modified vertical coordinate from stack
        and #%11100000          ;mask out low nybble and LSB of high nybble
        adc $00                 ;add to horizontal part saved here
        sta $00                 ;save as name table low byte
        lda Enemy_Y_Position,y
        cmp #$e8                ;if vertical position not below the
        bcc ExPRp               ;bottom of the screen, we're done, branch to leave
        lda $00
        and #%10111111          ;mask out d6 of low byte of name table address
        sta $00
ExPRp:  rts                     ;leave!

      tya                        ;move offset of other platform from Y to X
      jsr GetEnemyOffscreenBits  ;get offscreen bits
      lda #$06
      jsr SetupFloateyNumber     ;award 1000 points to player
      lda Player_Rel_XPos
      sta FloateyNum_X_Pos,x     ;put floatey number coordinates where player is
      lda Player_Y_Position
      sta FloateyNum_Y_Pos,x
      lda #$01                   ;set moving direction as flag for
      sta Enemy_MovingDir,x      ;falling platforms

      jsr InitVStf             ;initialize vertical speed and low byte
      sta Enemy_Y_Speed,y      ;for both platforms and leave
      sta Enemy_Y_MoveForce,y

      tya                         ;save offset for other platform to stack
      jsr MoveFallingPlatform     ;make current platform fall
      tax                         ;pull offset from stack and save to X
      jsr MoveFallingPlatform     ;make other platform fall
      ldx ObjectOffset
      lda PlatformCollisionFlag,x ;if player not standing on either platform,
      bmi ExPF                    ;skip this part
      tax                         ;transfer collision flag offset as offset to X
      jsr PositionPlayerOnVPlat   ;and position player appropriately
ExPF: ldx ObjectOffset            ;get enemy object buffer offset and leave


        lda Enemy_Y_Speed,x          ;if platform moving up or down, skip ahead to
        ora Enemy_Y_MoveForce,x      ;check on other position
        bne ChkYCenterPos
        sta Enemy_YMF_Dummy,x        ;initialize dummy variable
        lda Enemy_Y_Position,x
        cmp YPlatformTopYPos,x       ;if current vertical position => top position, branch
        bcs ChkYCenterPos            ;ahead of all this
        lda FrameCounter
        and #%00000111               ;check for every eighth frame
        bne SkipIY
        inc Enemy_Y_Position,x       ;increase vertical position every eighth frame
SkipIY: jmp ChkYPCollision           ;skip ahead to last part

        lda Enemy_Y_Position,x       ;if current vertical position < central position, branch
        cmp YPlatformCenterYPos,x    ;to slow ascent/move downwards
        bcc YMDown
        jsr MovePlatformUp           ;otherwise start slowing descent/moving upwards
        jmp ChkYPCollision
YMDown: jsr MovePlatformDown         ;start slowing ascent/moving downwards

       lda PlatformCollisionFlag,x  ;if collision flag not set here, branch
       bmi ExYPl                    ;to leave
       jsr PositionPlayerOnVPlat    ;otherwise position player appropriately
ExYPl: rts                          ;leave

Thank you,

Ben (SMB2J-2Q)


And here's the second part of the same SMB1 platform code for you:
;$00 - used as adder to position player horizontally

      lda #$0e                     ;load preset maximum value for secondary counter
      jsr XMoveCntr_Platform       ;do a sub to increment counters for movement
      jsr MoveWithXMCntrs          ;do a sub to move platform accordingly, and return value
      lda PlatformCollisionFlag,x  ;if no collision with player,
      bmi ExXMP                    ;branch ahead to leave

         lda Player_X_Position
         clc                       ;add saved value from second subroutine to
         adc $00                   ;current player's position to position
         sta Player_X_Position     ;player accordingly in horizontal position
         lda Player_PageLoc        ;get player's page location
         ldy $00                   ;check to see if saved value here is positive or negative
         bmi PPHSubt               ;if negative, branch to subtract
         adc #$00                  ;otherwise add carry to page location
         jmp SetPVar               ;jump to skip subtraction
PPHSubt: sbc #$00                  ;subtract borrow from page location
SetPVar: sta Player_PageLoc        ;save result to player's page location
         sty Platform_X_Scroll     ;put saved value from second sub here to be used later
         jsr PositionPlayerOnVPlat ;position player vertically and appropriately
ExXMP:   rts                       ;and we are done here


       lda PlatformCollisionFlag,x  ;if no collision between platform and player
       bmi ExDPl                    ;occurred, just leave without moving anything
       jsr MoveDropPlatform         ;otherwise do a sub to move platform down very quickly
       jsr PositionPlayerOnVPlat    ;do a sub to position player appropriately
ExDPl: rts                          ;leave

;$00 - residual value from sub

       jsr MoveEnemyHorizontally     ;move platform with current horizontal speed, if any
       sta $00                       ;store saved value here (residual code)
       lda PlatformCollisionFlag,x   ;check collision flag, if no collision between player
       bmi ExRPl                     ;and platform, branch ahead, leave speed unaltered
       lda #$10
       sta Enemy_X_Speed,x           ;otherwise set new speed (gets moving if motionless)
       jsr PositionPlayerOnHPlat     ;use saved value from earlier sub to position player
ExRPl: rts                           ;then leave


      jsr MoveLiftPlatforms  ;execute common to all large and small lift platforms
      jmp ChkYPCollision     ;branch to position player correctly

      jsr MoveLiftPlatforms      ;execute common to all large and small lift platforms
      jmp ChkSmallPlatCollision  ;branch to position player correctly

      lda TimerControl         ;if master timer control set, skip all of this
      bne ExLiftP              ;and branch to leave
      lda Enemy_YMF_Dummy,x
      clc                      ;add contents of movement amount to whatever's here
      adc Enemy_Y_MoveForce,x
      sta Enemy_YMF_Dummy,x
      lda Enemy_Y_Position,x   ;add whatever vertical speed is set to current
      adc Enemy_Y_Speed,x      ;vertical position plus carry to move up or down
      sta Enemy_Y_Position,x   ;and then leave

         lda PlatformCollisionFlag,x ;get bounding box counter saved in collision flag
         beq ExLiftP                 ;if none found, leave player position alone
         jsr PositionPlayerOnS_Plat  ;use to position player correctly
ExLiftP: rts                         ;then leave

~Ben (SMB2J-2Q)


This is a bit of a shot in the dark, but any chance someone might be interested in a relatively small project for the N64? I don't have the skill to do so, but I love the Chameleon Twist games, and the second game had the characters replaced with really ugly models, and made some unnecessary changes to game play. It's all noted on this page.

The game is fully localized into English, so it would essentially be transplanting the English script from the NA version back into the JP version. I don't know if there's a full English font present in the JP version of the game already, but I would assume that this could also be transplanted over to the JP rom if needed. The only other thing to keep in mind is that a character named Linda was Engrished as "Rinda" in the character-select screen, and the characters have belt buckles/backpacks with their initial on them, so she has an R instead of an L. The name graphic was fixed in the western release so it could easily (I would assume) be extracted from the NA release to replace the JP graphic. The only extra bit to take it to a fully completed project would be extracting the textures for this character and redrawing the initial from an R to an L. Aside from that one minor instance of graphical editing, it's essentially a cut and past job for anyone capable of dissecting N64 code.

Anybody wanna give it a shot? I know I'd personally adore being able to play one of my old favorites how it was meant to be played, and I'm sure there's at least a few other people that would dig it. I'm aware it won't be all *that* simple, but as far as hacking projects go it seems like it would be a bit of low-hanging fruit to practice on for someone who has a little know-how. If anyone does decide to run with the idea, just know that I love you. :laugh:


Quote from: SMB2J-2Q on December 31, 2022, 08:27:28 PMCould anyone please look into the code for Super Mario Bros. to find out why the invisible platform bug exists (World 4-3 comes to mind)? In Super Mario Bros. 2 (Japan; "The Lost Levels" to us) there were some tweaks to correct some of the original NES SMB1's flaws, but not that one.

That is more of a graphical limitation than a code issue. The 8x8 sprites which make up the enemies (including moving platforms) are constantly shuffled to work around the 8-per-scanline limitation. It's just that the platforms are so wide that the scanline limit is already maxed out in most scenarios where multiple of them are onscreen.


Quote from: TakuikaNinja on January 01, 2023, 08:24:20 PMThat is more of a graphical limitation than a code issue. The 8x8 sprites which make up the enemies (including moving platforms) are constantly shuffled to work around the 8-per-scanline limitation. It's just that the platforms are so wide that the scanline limit is already maxed out in most scenarios where multiple of them are onscreen.
Thank you for the heads up... this code will then need to be tweaked to make it better comply with these sprite bounds.



Well, the sprites which make up the player aren't shuffled. However, I believe that is a deliberate choice by the developers to ensure the player is always visible. Note that sprite 0 absolutely cannot be shuffled as it is used for keeping the HUD in place.


ROM Hack Idea: Streets of Rage 2 x Futari wa Pretty Cure Max Heart

TOEI's Pretty Cure series is all about (most of the time) magical girls beating the crap out of bad guys using good ol' fisticuffs (and kicks!).

Sadly, Bandai Namco (who used to make a lot of Precure games) seemed to have missed the point because most of that series' games are about girly slice of life stuff (eg. cooking, dressing).

The first Precure video game for the Nintendo DS, "Futari wa Precure Max Heart: Danzen! DS de Precure Chikara o Awasete Dai Battle", was a traditional beat 'em up akin to the likes of Streets of Rage.

And that got me thinking: Seeing as people seem to enjoy making character hacks for Streets of Rage 2, how about one that puts the Cures from "Futari wa Precure Max Heart" as playable characters?  Spriter's Resource seems to have all of their sprites ripped, so that's less one thing to worry about I suppose?

To keep the "all girl protagonists" theme of the series, Blaze could be the only SoR character to be playable alongside them (Axel, Skate and Max would have been kidnapped as a result of Mr. X teaming up with the villains from the Dotsuko Zone).