BUMS featuring Bentley, the Upwardly Mobile Bum

What you see here is a complete and faithful rewrite in Python of the Commodore 64 classic Rags To Riches, written by Bob Keener in 1985. It's nearly pixel-perfect, with differences from the original being virtually imperceptible.

Bugs and glitches from the original game have been fixed (such as uncontrolled treasure spawning), making this version even more challenging. To compensate for the increased difficulty, I've added a pause feature.

Every element has been meticulously recreated: characters, shops, jobs, and all game mechanics. I spent months measuring and calibrating every aspect. The result is a playable version for modern Linux, macOS, and Windows computers.

The title is a tribute to Bob Keener, who wanted to call it this but had to rename it at the publisher's request.

Enjoy and good luck!

P.S. Just like the original, there's no real ending - the game is an open-ended sandbox where the goal is to survive and become a millionaire in as few days as possible!

THE LONGER STORY

Among the many masterpieces from the Commodore 64 era, there's a lesser-known gem universally considered a masterpiece of originality and technical achievement. That gem is Rags To Riches, a side-scrolling game from 1985 written by Bob Keener, where you play as a homeless person trying to climb the social ladder and become rich.

I was about 5 years old when I got my hands on a budget version brought by my cousin, renamed "Escalation" for the Italian market (I only discovered the original title 20 years later). We were used to playing platformers, shoot 'em ups, adventures and puzzles, but a homeless simulator with such complexity was missing from gaming history records.

I spent entire days playing this exceptionally original yet difficult game. There was no pause, no passwords to restart at higher levels, NOTHING to help the player (except a glitch that made dollars appear continuously by moving back and forth a few pixels).

Fast forward to the early 2000s: I was deep into retrogaming and while surfing the internet, I stumbled upon a review on Dave Pye's blog: "Rags to Riches, a C64 Anomaly". I discovered not only the game's original name, but also that it was beloved worldwide.

The rabbit hole is always deeper than you think. Searching further, I found reviews and forum posts: everything indicated that Rags To Riches was a masterpiece and that its programmer was an untraceable ghost. Bob Keener was just an endless list of Americans who had nothing to do with video games, let alone the Commodore 64.

Until one day I noticed that on YouTube, a certain Jason Wampler wrote that the game had been created by a friend of his. The encirclement maneuver had begun and, a year later, I found myself writing the first email to Bob Keener, who shortly after gave me an interview (now published on Lemon64 and Ready64), marking our intercontinental friendship. I'll refer you to that interview for all the details about Rags To Riches.

And from there we come to 2025. I was looking for a way to quickly learn Python to access the skills needed to program robots with ROS2. The idea flashed to reimplement my favorite game from scratch. The result of 2 months of sleepless nights programming is the star of this page.

CURIOUS FACTS

In the original game:

• The character is off-center toward the left of the screen
• The right and left sides of the character are NOT mirrored images, but completely different sprites
• Cities are connected by 25 "offlimits" screens showing a "to city" sign with a directional arrow, followed by another 25 identical screens with the arrow pointing the opposite direction. Traveling through all cities brings you back to the starting point, suggesting the entire game world is a circular carousel
• The glitch that makes treasures appear continuously stems from Bob's spawning system design. During my rewrite, I also faced the challenge of deciding how to make treasures appear for the player. It's not trivial: simple random spawns don't work well gameplay-wise. The original game's glitch works like this: you take the currently displayed world X coordinate and divide it by the screen width multiplied by 1.5. Let's call this value a "zone". If the previous zone differs from the current zone, two treasures spawn at the sides of the screen, just outside the player's view. In my rewrite, I added a random time delay to the actual spawn, while in Bob's original game the spawn happened immediately: this detail is what creates the treasure spawn glitch, which in my opinion invalidates all the speedrun attempts to "finish" the game you see in numerous YouTube videos.
• The alcohol level indicator decreases slower than the food one. However, both food and alcohol levels aren't fractioned based on the indicator's length (16 units), but rather on the duration of a day (18 seconds). Food decreases every 18 seconds, while alcohol decreases every 18 seconds + half a day = 27 seconds. In my rewrite I simplified this: alcohol decreases by half a unit every 18 seconds along with the food decrease. This makes alcohol even slower to decrease in my rewrite compared to the original, giving it a little greater utility.
• It's possible to travel by subway to the same city you're already in. Additionally, the character always appears at the same coordinate in every city upon arrival. These can be considered conceptual errors, which I deliberately fixed in my rewrite. In my rewrite, you cannot travel to the city you're already in, and in any case the character "exits" from the correct subway door.
• Nights last 5 seconds, with all the consequences this has on food and alcohol level depletion, suggesting the player must necessarily find a hotel or apartment to spend the night. In my rewrite I extended the night duration to 6 seconds to slightly ease the difficulty, and I'm still undecided whether to extend it to 9 seconds, which would be half a day, for the same reason.
• The R in the flashing IRS text above the tax collector has a deformed R designed to show the enemy's eye during the flashes. In my rewrite I drew the R without this "deformity", because in my game engine the flashing always shows the enemy's eye.
• The enemy spawning mechanism doesn't account for whether you've just exited a job, the subway, or a night spent in a hotel or apartment. While the sudden appearance of these enemies isn't conceptually an error, it represents a frustration issue at the gameplay level. In my rewrite, enemies never appear right after exiting the subway, a job, or a night's rest.
  
• The dollar counter font isn't the standard C64 font. It's probably a bitmap font containing only digits, period, comma, and the letters that make up "am" and "pm". It's not very noticeable, but they're also used for the day count, after the "DAY" text, which however is in standard C64 font. In my rewrite, I used a custom font derived from “Acknowledge,” which I found to be probably the only typeface in existence that even vaguely resembles the one Bob Keener drew for the Rags to Riches counter. The day counter, on the other hand, uses the standard C64 font for both the “DAY” label and the actual day number.

TECHNICAL INFORMATION

The game is written in Python and was used as a playground to learn different techniques and language constructs that I had never seen in other languages (nor knew existed). I used the "Arcade" library in its latest version, which is a wrapper for Pyglet, which in turn encapsulates OpenGL.

At the core of the entire development is the asset collection. Specifically, the game map is composed of four city zones, each one made of a 600x17 grid of 8x8 pixel tiles. The game is therefore displayed at 2:1 scale to achieve a 640x400 window, the same typically used in C64 emulators like VICE or CCS64. My rewrite's palette is original, but heavily inspired by my childhood memory of how the game looked on my home CRT TV, and by the CCS64 emulator's palette colors, while having almost nothing in common with the default VICE colors. My rewrite, being European, is PAL and therefore both the music and game speed are slightly slower compared to the American NTSC counterpart, which in any case seems to have a more chaotic and less measured pace.

The game code uses various Python constructs. Specifically, world doors are implemented with named tuples, while apartment management uses a wrapper class. A custom GroupedSpriteList was implemented to handle parent-child relationships between sprites (beard and hat following the character). Property decorators with setters automatically manage HUD updates. Special doors use lambda functions to pass different parameters to the same function (e.g., lambda: self.special_loft(0, 10) for different apartments).  Door checking uses Python introspection to dynamically filter class attributes based on the current zone. City limits are dynamically managed: when the player approaches the visible edge of the map, sprites with "to city ->" textures are added that repeat infinitely, creating the illusion of an endless world without wasting memory. This, summed up with the fact the different city zones are piled on top of each other, represents a departure from the aforementioned "carousel" structure of the original Rags To Riches. Timing was achieved through a class called Juggler, inspired by a similar class in Sparrow Framework (a famous game framework from the first decade of the 2000s): it's far superior to Arcade's scheduled events and allowed me to implement the Pause functionality flawlessly.

Finally, all the code is then translated to C and compiled with Nuitka, ready to be run by your computer.