Since you seem earnest, probably play_my_game or possibly gamedev.

I reserve further comments until I know whether you posted this in this community: a) deliberately but seriously, b) deliberately and sarcastically, or c) by accident.

I think I can appreciate where you’re coming from, but in the context of the article it was legitimately necessary to address the topic somehow; it’s not like it was written apropos of nothing as a commentary on transsexuality. As a CIS person, I also have a “percieved gender” with which I identify.

Would “post-transition gender” be a more sensitive term, or less?

Let me know if you find one that uses AI to find groupings of my search terms in its catalogues instead of using AI to reduce my search to the nearest common searches made by others, over some arbitrary popularity threshold.

Theoretical search: “slip banana peel 1980s comedy movie”
Expected results in 2010: Pages about people slipping on banana peels, mostly in comedy movies, mostly from the 80s.
Expected results in 2024: More than I ever wanted to know about buying bananas online, the health impacts of eating too many or not enough bananas, and whatever “celebrities” have recently said something about them. Nothing about movies from the 80s.

I watched the video that you linked to, and it was very interesting! I’d never thought about exploiting the possibility of double-dipping the logo. It simply wouldn’t have been practical back in the day. However, there are two important facts that change the situation a bit.

(EDIT: I’ve left the following discussion of logo checksums intact, but I kept digging and found what is claimed to be a dumped and disassembled copy of the OG GameBoy boot ROM, which does include a byte-for-byte check of the logo data. Colour me surprised! I was interested in GBA homebrew back in the day and I’d swear that I saw a dumped GB boot ROM that only calculated a checksum. Also, those cartridges with the non-standard logos? I own them. Unfortunately I can’t get my hands on them right now, but I saw them with my own eyes. If it wasn’t just fooling a checksum, then I don’t know what the deal was there, especially the carts with “garbage” logos. Not to mention that as I said, I don’t think it was practical to do a bait-and-switch in a retail cartridge back in the day.)

(EDIT 2: Yes, I’m still reading about this! It seems like the bait-and-switch was feasible back in the day. Some publishers used special mappers, while others apparently redirected address lines with carefully-chosen capacitors, which seems delightfully hackey to me.)

First, neither the OG nor the Color GameBoy have a complete copy of the Nintendo logo stored in their boot ROM. Instead, the boot code calculates a checksum of the cartridge’s logo data, and compares that to a stored checksum of the official logo. If the checksums match, the check is passed. There are unofficial cartridges which boot just fine by having “garbage” logo data that passes the checksum test. I have even seen one company that took the time to come up with a different recognizable logo that still passed the check. The lettering looked weird, but you can read it.

By the time the GameBoy Advance came around, ROM was cheap enough to include a complete copy of the official logo and compare it byte-for-byte, so they did.

Second, Sega tried a similar tactic on some of their consoles: The boot rom contained a routine which would display a screen claiming that the software had been produced by or under license from Sega Enterprises. If the code on the cartridge/disc didn’t call that routine fairly early, the boot ROM would cause the console to lock up. The idea was that if software had to call that routine, Sega could sue unapproved publishers for claiming to be licensed when they weren’t.

Unfortunately for Sega, the US courts ruled (Sega vs. Accolade, 1992) that since it was impossible to run software on the system (which the court upheld that Sega had no right to block, ah the days before DMCA) without calling this routine, that unlicensed publishers couldn’t be said to be wilfully claiming licensing rights from Sega; they were just calling a routine that was necessary to make the console work. The fact that Sega had attached this licensing screen to it was immaterial.

No doubt Nintendo’s legal team would go after anyone who tried this on one of their systems, either under DMCA somehow, or even simply on the premise of being able to bankrupt their opponent with requests and delays before ever making it to trial. But I suspect (I am not a lawyer) that technically, anyone putting a Nintendo logo in a GB cartridge could claim the 1992 case as a precedent.

It’s definitely bad design, but in a pinch it is readable in landscape mode for me. Alternatively, if your browser has a “force desktop mode” option, that often makes badly-written websites useable, if annoying.

Similar concepts (i.e. connect to random strangers’ devices when in close physical proximity, and trade mini profiles/trading tokens/whatever) have been done at least half a dozen times, both before and after Nintendo, but somehow they never seem to stick. Street Pass may have been the most successful iteration that I’m aware of. I think that it’s hard to get critical mass. Users are excited at first when they set things up, but after a few days or weeks of not getting any hits, they tend to lose interest and turn the service off to save battery life.

OP must have a phone, tablet, or computer, since they’re posting here; they could even just use that.

Ah, OK! Well, even if you’re writing your game in JavaScript, there’s still no need to work with the data directly as a JSON object. JS has built-in functions for serializing stored objects into JSON format (After all, the “JS” in “JSON” stands for “JavaScript”). If you aren’t using JS, working with your data in a JSON representation seems like unnecessary overhead.

I think that one very common approach would be to make a simple array of objects for each “container” (this includes the player character and NPCs). Exactly what those objects are would vary by your language, platform, and personal tastes. You could have objects which contain all the information associated with themselves, such as name, description, weight, etc., or they could be as simple as an ID code that is an index into another table, and a count of how many of that item are held (this can reduce the likelihood of bugs).

The objects could also have their own methods such as reporting the weight or value of the item, which may simplify things if one property of an item (e.g. resale value) can sometimes be affected by another (e.g. level of wear), but not always. Or alternatively you could have functions that query the item objects and do all the necessary calculation and adjustment externally.

That’s if your objects are mostly copies of the same things (e.g. health packs, ammo). If your objects are mostly unique (e.g. key, to room 102, Michael’s pencil), many people instead make a single array which contains every object in the game/level, and each object includes a “location” attribute, with values such as in the player’s inventory, in a particular NPC’s inventory, or at a spot in the game world (perhaps specified in another object attribute). This can reduce the chances of accidentally creating multiple copies of “unique” items.

With regards to saving, if you’re using JS then you can just automagically serialize your top-level array(s) to JSON and save that to a file. If you’re using another language/environment, you’ll need to figure out a file format that suits you, or look for a library. Making your own file format shouldn’t be too hard, because a file is just a big array of byte values, and presumably you don’t need to worry about interoperability.

“Inventory” usually refers to the list of items that the player character is carrying while the game is running. Why would you store that in a file and not memory? Are you talking about a game save file?

That XKCD reminds me of the case a year or three ago where some solo dev that no-one had ever heard of was maintaining a library that a couple of other very popular and major libraries depended on. Something somewhere broke for some reason, and normally this guy would’ve been all over it before most people even realized there had been a problem, but he was in hospital or jail or something, so dozens of huge projects that indirectly relied on his library came crashing down.

What upset me most was reading the community discussion. I didn’t see a single person saying, “How can we make sure that some money gets to this guy and not just the more visible libraries that rely so heavily on his work?”, even though the issue was obliquely raised in several places, but I did see quite a few saying, “How can we wrest this code out of this guy’s hands against his will and make multiple other people maintain it (but not me, I’m too busy) so we don’t have a single point of failure?”

I’d argue that you do need to be good at math to be an effective programmer, it’s just that that doesn’t mean what a lot of people think it means. You don’t need to know all the ins and outs of quadratics, integrals, and advanced trigonometry, but I think you do need to have a really solid, gut-level understanding of basic algebra and a bit of set theory. If you’re the sort of person whose head starts to swim when you see “y=3x+2”, you’re going to find programming difficult at best.

This game is criminally unknown even in Japan. I first learned about it years ago and wish I had paid the high price to buy a copy then; now it sells for 10 times as much, and that’s if you can even find a copy. It’s the only game missing from my physical collection that I know I want.

I’ve tried a couple of times to get into it over the years, but the language barrier was always too high for me and broke immersion. Hopefully I and others can now give this game the attention that I think it deserves.

Edit: A link to the patch: https://www.romhacking.net/translations/7187/

There was already a Spanish patch a few years ago, as well.

Edit 2: And now it’s been flagged as “noncompliant”. I’m not sure what that means, but it’s not available from that site for the moment.

Anyone who’s interested in VR but doesn’t want the high outlay or to commit to particular hardware just yet, and has any half-decent Android or iOS phone, should check out VRidge from RiftCat. It turns your phone into a Steam-compatible VR headset; just get one of those head-mounted phone holders and away you go.

VR controls can be an issue; the software lets you fake them with a standard game controller, but I haven’t found any easy way to have full VR controls (real first-party VR controllers all seem to be tied to the headset, and third-party software that uses things like Wii remotes and Sony PS Move controllers seems complicated and fiddly). But for this EmuVR I don’t think that VR controls are likely to be a sticking point.

EDIT: The VRidge site says that it supports iOS as well.

Whatever it may have become in later years, Alan Kay, who is often called “The Father of Object-oriented Programming”, outlined the message-passing idea as the main concept he was driving at, originally.

He also says that he probably misnamed it.

Here’s a discussion in which the man himself makes a (small) appearance: https://softwareengineering.stackexchange.com/questions/46592/so-what-did-alan-kay-really-mean-by-the-term-object-oriented

I am currently working on a game for the Atari 2600, and you just gave a good outline of my code. And I love it.

I tend to agree. I think this attitude is something of a holdover from the early days of computer science, when of academics from all the other, existing fields, mathematicians were usually the best fit. Now that we have formal computer scientists, computer engineers, and software engineers, this is no longer the case.

In my experience, when someone from a purely mathematical background tries to program or explain something for programmers, they often (but not always, to be fair) insist vehemently on sticking to methods and algorithms that at best confuse the issue in a programming setting, and sometimes even run counter to how the computing hardware works, reducing performance. In these situations the rationale given is usually something along the lines of, “Listen, we mathematicians have been doing it this way for X hundred years, so that’s the way it should be done!”

I haven’t used it for a while, but the last time I was using Lakka I don’t think it had been ported to Pi yet. It worked great and was very much for PCs. I don’t know about interfaces though; my install booted straight into RetroArch which isn’t the slickest-looking thing but worked fine for me.

Make sure to check compatibility lists for the emulators you want to use. You may be surprised by how many games don’t run/can’t be finished/have major glitches on later systems like PS2, PS3, and GameCube. Also, there are no PS3 RetroArch cores, so you’ll need to use the standalone version of RPCS3.

I love low-level stuff and this still took me a little while to break down, so I’d like to share some notes on the author’s code snippet that might help someone else.

The function morse_decode is meant to be called iteratively by another routine, once per morse “character” c (dot, dash, or null) in a stream, while feeding its own output back into it as state. As long as the function returns a negative value, that value represents the next state of the machine, and the morse stream hasn’t yet been resolved into an output symbol. When the return value is positive, that represents the decoded letter, and the next call to morse_decode should use a state of 0. If the return value is 0, something has gone wrong with the decoding.

state is just a negated index into the array t, which is actually two arrays squeezed into one. The first 64 bytes are a binary heap of bytes in the format nnnnnnlr, each corresponding to one node in the morse code trie. l and r are single bits that represent the existence of a left or right child of the current node (i.e. reading a dot or dash in the current state leading to another valid state). nnnnnn is a 6-bit value that, when shifted appropriately and added to 63, becomes an index into the second part of the array, which is a list of UTF-8/ASCII codes for letters and numbers for the final output.

Yep, this works well. I used to have a cheap, old, secondhand ultralight notebook that I used for work, and I installed Lakka to a tiny bootable USB drive so that on evenings when we planned to gather at one colleague or another’s house after work, I could just throw the drive and a couple of controllers in my bag and we could have a nice, clean, 100% emulation-focused system to game on. Even a 10-year-old laptop with Lakka should smash a Raspberry Pi 4’s cost/performance ratio.

I usually plugged in power and a display, but of course as a laptop it was fine for using on the go, too. Not quite a handheld, but still very portable.

Another option is one of the cheaper ARM-based handhelds with a USB port and HDMI output, so you can still play on a big screen at home. I later got a Retroid 2 for this, which also worked well, but needed a bit more technical fiddling than the Lakka laptop, and couldn’t emulate a few things at full speed. The Retroid 3 should be better, or there are other options such as Ambernic, Game Park, and PowKiddy.

Now, I just use my phone with a Bluetooth controller, and optionally an HDMI output dongle when I’m at home. If your phone doesn’t support HDMI over USB-C natively (mine doesn’t), look into a DisplayLink compatible USB dongle. If you check specs carefully you can even find some that work over USB 2.0 for older/cheaper phones. They have a free app for Android phones.