We're using cookies to ensure you get the best experience on our website. More info
Understood
@horvatmRegistered December 28, 2008Active 4 months, 2 weeks ago
586 Replies made

Yes, I have too. Apparently it replaces the first four characters with “Re: ” and then truncates the string to 20 characters.

RunnerPack wrote:
1) Limited to Windows BMP files for input

I’m trying to keep it simple. If you need other formats, you can use ImageMagick or something to convert them. I’ll add support for images with fewer colors though so you won’t have to waste space with 24-bit BMPs. Although NTFS compression works quite well on them.

2) User is required to specify all filenames, without extensions

This makes it harder to use in a makefile.

What’s your proposed alternative?

3) Only C or raw binary output

C takes longer to parse, and binary requires an asm “stub” to link. GNU assembly output shouldn’t be too hard to add, right?

Right. What does it need? A label and a list of .dbs? I’m not very familiar with the GNU assembler – I’ve only used it with the asm() macro in C code.

4) Not open-source

😉

No comment on that.

Just look at the credits for each game on this site.

Anyone he can get his hands on! Though I doubt Nintendo programmers would want to give out any details.

He should try to convince the programmers to give us the source code of their games, especially the unreleased ones. 🙂

It should. I’ve used a 9 V adapter for years without problems.

I think you should continue, but you should also learn proper programming techniques, such as how to split up code into functions and how to use arrays. If you would have, the game would be much more finished by now.

Greg Stevens wrote:
I’ve never used a flash boy but assuming it uses a standard usb storage device interface I doubt it would be very difficult to create a simple app.

It does not.

http://www.planetvb.com/modules/newbb/viewtopic.php?topic_id=3673&post_id=8666#forumpost8666

You guys have it all wrong. It is a little known fact that one of the codenames for the Virtual Boy was Yob Lautriv, but Nintendo changed the name slightly before the release when they already had some manuals printed, so this is a really rare collector’s item. I bet Benjamin Stevens will offer you a lot of money for that one.

sw201444 wrote:
Could also be the golfer’s name….

No, as the string is hardcoded in the ROM.

BTW, you only have to press Select.

Benjamin Stevens wrote:
Even with that, though, I don’t think either Waterworld or Virtual Lab has an in-game high score that one is supposed to beat, and making it to level 99 in Virtual Lab would likely take a person more than 100 hours of continuous play, while making it to level 99 in Waterworld is a complete impossibility.

Not only that, you’d also have to be lucky for Virtual Lab not to reboot (is that just a myth or does it really do that?).

Also, I have just searched through its code and there is no special score that you have to get. The highest readable score you can get is 327670; after that, it displays garbage, and once you get to 655350 (which you can’t see), it starts at 0 again.

I’m not sure how you would get to level 99 (actually 100, but stored internally as 99) anyway, as I usually can’t get past level 7 or so.

Welcome back! How’s Virty? 😛

I remember there being a bug in the past that caused badges to disappear and members’ post counters to display -1. Maybe that’s what happened. I’m sure KR155E would make an announcement if badges were being removed.

thunderstruck wrote:

Craby wrote:
I did not want to make a thread for just a (probably) stupid question, so I will ask here :

Is there a way to create a multiboot-rom / homebrew compilation / to merge several little roms into one 2048ko rom ?
I use my FB+ mainly for homebrew, that would be very handy 🙂

HorvatM once posted (can’t find the thread anymore) that he wrote an tool that can merge 2 roms into one. There was a problem with running the merged rom on hardware though. Also I don’t remember if he published the tool itself.

I don’t think there exists a proper solution right now.

I didn’t release the program, but if you want, I can continue working on it so that it hopefully becomes useful.

There will never be a fully automatic ROM joiner though because to join two or more games, you have to hack each one to be compatible with the others (most of the work can be automated, but you still have to do some things manually). So probably the best way to do this is to make pre-made compilations of games. Even then, some games would be incompatible with others if they use all 8 kilobytes of SRAM (they would erase each other’s data, but otherwise they would work fine).

I also think that digital TV and widescreen displays are bullshit.

With analog TV, I could watch movies in rural areas even if the picture wasn’t perfect. With digital TV, unless the signal is perfect, the picture is unwatchable and there is no sound at all.

Widescreen displays are completely useless on a PC unless all you do is watch movies. Maybe we should have square displays, they would be good for any purpose.

These “innovations” were obviously designed to make everyone “upgrade” their decades old 4:3 analog TVs by requiring us to buy those stupid converter boxes and then leave a quarter of the screen unused because of those black bars.

I do hope though that 3D TV becomes the affordable norm (possibly in an analog form :D). 3D TV for a 3D world. Hell, all pictures everywhere should be 3D if it makes sense; most of us have two eyes and we should use them both.

One of my complaints about the VB is that many sprites are two-dimensional — in “Wario Land” all characters are paper-thin. Our home-brew games promise they can deliver “3D sprites” — like in Mario Cart and others; I’m excited about that.

The problem with stereoscopic sprites is not only that it’s harder for the artists, but also that it can use twice as much character RAM, limiting the variety of graphics you see at a time, and it also halves the number of sprites you can have at a time.

I’m really pleased (and not a little jealous!) at those writing new games for the VB; hope it continues, and hope we eventually will come up with copies of the “Holy Grails” (especially Dragonhopper, Zero Racers, and Goldeneye). I confess I never thought I’d get to actually play “Bound High” — it’s one of the best games!

I think we should create original games, so the Ballface situation of wasted(?) effort wouldn’t happen again.

I think vb-fan was trying to remind us of an unwritten rule all VB fans should follow: thou shalt have no virtual reality systems before the Virtual Boy.

Anyhow, the Oculus Rift can’t natively run VB software, so it doesn’t qualify as a VB clone.

I did some comparison between the two ROM images. To compare the code, I used the function that seems to load BGMaps (and does something else?), as it writes to the address 0x20000.

The disassembly is modified from David Tucker’s disassembler’s output.

“Ben’s Sample Soft for VUE Programing – Proto Cart.vb” (abbreviated “BSS”):
[font=Courier]000005e4 add -8, $SP
000005e6 st.w $29, 4[$SP]
000005ea mov $SP, $29
000005ec st.w $6, 8[$29]
000005f0 mov $7, $10
000005f2 st.w $8, 16[$29]
000005f6 st.h $10, 2[$29]
000005fa st.h $0, 0[$29]
000005fe ld.h 0[$29], $10
00000602 mov $10, $11
00000604 shl -16, $11
00000606 mov $11, $10
00000608 sar -16, $10
0000060a ld.h 2[$29], $11
0000060e mov $11, $12
00000610 shl -16, $12
00000612 mov $12, $11
00000614 sar -16, $11
00000616 cmp $11, $10
00000618 blt 4
0000061a br 48
0000061c addi 10, $29, $10
00000620 ld.w 0[$10], $11
00000624 ld.w 8[$29], $12
00000628 ld.h 0[$12], $13
0000062c st.h $13, 0[$11]
00000630 add 2, $12
00000632 st.w $12, 8[$29]
00000636 add 2, $11
00000638 st.w $11, 0[$10]
0000063c ld.h 0[$29], $10
00000640 addi 01, $10, $11
00000644 st.h $11, 0[$29]
00000648 br -74
0000064a mov $29, $SP
0000064c ld.w 4[$SP], $29
00000650 add 8, $SP
00000652 jmp [$LP][/font]

“Sample Soft for VUE Programming (v1.0) – PVB Version.vb” (abbreviated “PVBSS”):
[font=Courier]0000122e addi ffe8, $SP, $SP
00001232 st.w $8, 4[$SP]
00001236 st.w $25, 8[$SP]
0000123a st.w $6, 12[$SP]
0000123e st.w $9, 16[$SP]
00001242 st.w $7, 20[$SP]
00001246 mov $8, $25
00001248 mov $6, $8
0000124a mov 0, $6
0000124c st.h $6, 0[$SP]
00001250 movhi 700, $0, $1
00001254 movea 127a, $1, $1
00001258 jmp [$1]
0000125a ld.h 0[$8], $6
0000125e st.h $6, 0[$25]
00001262 add 2, $8
00001264 add 2, $25
00001266 ld.h 0[$SP], $6
0000126a mov $6, $9
0000126c shl -16, $9
0000126e sar -16, $9
00001270 add 1, $9
00001272 andi ffff, $9, $6
00001276 st.h $6, 0[$SP]
0000127a mov $7, $9
0000127c shl -16, $9
0000127e sar -16, $9
00001280 ld.h 0[$SP], $10
00001284 mov $10, $6
00001286 shl -16, $6
00001288 sar -16, $6
0000128a cmp $9, $6
0000128c blt -50
0000128e ld.w 4[$SP], $8
00001292 ld.w 8[$SP], $25
00001296 ld.w 12[$SP], $6
0000129a ld.w 16[$SP], $9
0000129e ld.w 20[$SP], $7
000012a2 addi 18, $SP, $SP
000012a6 jmp [$LP][/font]

To me, BSS seems to be compiled with a non-VUCC compiler, because it copies $SP to $29 and then uses $29 to access local variables. VUCC always modifies $SP directly with ADD or ADDI, though it is sometimes MOVEA’d to a temporary register ($10 to $19) in the Insmouse code, but I’m pretty sure this is only done to address elements of a local array. Also, when passing parameters to a function (before a JAL), it goes from left to right – starting with $6. VUCC always starts at the right, finishing with $6.

Now look at PVBSS: it simply pushes everything to the stack, no weird tricks with the $SP. The JMP at 0x1258 is a bit strange, but this occurs all the time in Virtual Lab. There are also redundant SHL/SAR instructions everywhere to sign extend registers (VUCC does this a lot, gccVB not so much). And parameters are moved to registers from right to left.

I have also thought about it. I think that a clone of the VB should be similar to the real VB in all aspects due to its simplicity, but obviously the design should be less fragile. The goal should be simply to make the VB and its games more accessible to people interested in it. There should also be an easy way of using it as a 3D display device for a PC and video output so we wouldn’t have to bother with cameras.

But I’m not sure what medium it should use for software. Cartridges are obviously expensive. Am I the only one who doesn’t have a memory card unit? Or is everyone on laptops?

No it wouldn’t. Physical copies (on cartridges) would still be just as rare. And you can already download ROM images of VB games, though the legality of this is questionable.

I don’t know much about the first-person view, but I know that it’s composed of multiple worlds/BGMaps, and all sprites (items, monsters, the crosshair, HUD icons, timer numbers) are objects:

41B78 – pointers to charset for each monster kind (4 words)
9A8F8 – charset for monster kind 0 (1024 characters)
9E0F8 – charset for monster kind 1 (1024 characters)
A20F8 – charset for monster kind 2 (1024 characters)
A60F8 – charset for monster kind 3 (1024 characters)
AA0F8 – charset for floor/walls/ceiling (256 characters)
AB0F8 – charset for floor/walls/ceiling, “moving parts” (I forgot what that means, probably doors)
AC0F8 – charset for floor/walls/ceiling
AE0F8 – charset for non-monster sprites
B90F8 – first-person view BGMap – charseg 0 is AA0F8
BB0F8 – same as B90F8, but for different eye
BD0F8 – BGMap for all doors – charseg 0 is AA0F8
BF0F8 – same as BD0F8, but for different eye
C10F8 – unknown BGMap – may be related
C30F8 – C10F8 for different eye
C50F8 – unknown BGMap
C70F8 – C50F8 for different eye

All addresses, except for monster charsets, are hardcoded.

Everything is uncompressed and loaded with the functions I listed before.

There are probably pointer arrays for the sprites, but I haven’t discovered them yet (well, actually, I know where a lot of pointers are, but I don’t yet know what they point to).

Dark monsters use the same characters as bright ones, but a different palette.

My plan is to eventually put all of this onto my Web site to create the ultimate Insmouse resource, but my perfectionism prohibits me from doing it right now, and I’d have to translate everything first anyway.

So, just tell me what things you want to replace and I’ll give you the addresses. If you’re going to map things I haven’t yet (mostly ending cutscenes), it will be helpful to know these two functions:

8482 (LoadBGMap)
$6 -> source
$7 = index of BGMap (0 = 0x20000, 1 = 0x22000, etc.)
Note: BGMaps are always 8K

84A6 (LoadCharset)
$6 -> source
$7 = destination character data index divided by 256 characters (gets multiplied by 0x1000 and added to 0x78000 to produce the destination pointer)
$8 = number of words to copy (1 character = 4 words)

If you want to load BGMaps that are smaller than 8K, you can use this function:

13154 (CopyMemH)
$6 -> source
$7 = number of halfwords to copy
$8 -> destination