2024 Business Card Challenge: Integrated Game Card

June 21, 2024 by Dave Rowntree 10 Comments

[Dan Schnur] has a simple strategy to ensure their business card stays on the client’s desk and doesn’t just get lobbed in a drawer: make it into a simple gaming platform. This entry into the 2024 Business Card Challenge is based around the tinyjoypad project, integrating an SSD1306 OLED display, joypad, and push button.

Powered by the superstar ATTiny85, the electronics are really not all that much, just a sprinkling of passives to support the display and the six switch inputs from the joystick and push button. Or at least, that’s how much we can glean from the PCB images, as the PCB design files are not provided in the project GitHub.

Leaving the heavy lifting of the software to the tinyjoypad project, the designer can concentrate on the actual job at hand and the reason the business card exists to stay at the forefront of the client’s mind. In the meantime, the card can be a useful distraction for those idle moments. A few such distractions include a tiny version of Missile Command (as shown above), tiny tris, and a very cut-down Q-bert. Sadly, that last game isn’t quite the same without that distinctive sound.

Easy Retro 3D Look With Voxel Displacement Renderer

June 14, 2024 by Maya Posch 9 Comments

Voxels are effectively like 3D pixels, and they form an integral part of what is commonly referred to as a ‘retro 3D’ look, with pixelated edges sharp enough to cut your retinas on. The problems with modeling a scene using voxels come in the form of creating the geometry and somehow making a physics engine work with voxels rather than conventional triangular (or quad) meshes.

The same scene in Blender (above) and in the voxel-based renderer (below). (Credit: Daniel Schroeder)

The approach demonstrated by [Daniel Schroeder] comes in the form of a Voxel Displacement Renderer implemented in C++ and using the Vulkan API. Best part of it? It only requires standard meshes along with albedo and displacement maps.

These inputs are processed by the C++-based tools, which generate the voxels that should be rendered and their properties, while the GLSL-based shader handles the GPU-based rendering step. The pre-processing steps required make it a good idea to bake these resources rather than try to process it in real-time. With that done, [Daniel]’s demo was able to sustain a solid 100+ FPS on a Radeon RX 5700 XT GPU at 1440p, and 60+ FPS on a Steam Deck OLED.

In a second blog post [Daniel] goes through his motivations for this project, with it originally having been intended as a showpiece for his resume, but he can imagine it being integrated into a game engine.

There are still questions to be resolved, such as how to integrate this technique for in-scene characters and other dynamic elements (i.e. non-static scenery), but in terms of easing voxel-based rendering by supporting a standard mesh-based workflow it’s an intriguing demonstration.

Continue reading “Easy Retro 3D Look With Voxel Displacement Renderer” →

Tight Handheld CRT Asteroids Game Curses In Tuscan

June 12, 2024 by Elliot Williams 5 Comments

How many Arduini does it take to make a tiny CRT Asteroids game? [Marco Vallegi] of MVV Blog’s answer: two. One for the game mechanics and one for the sound effects. And the result is a sweet little retro arcade machine packed tightly into a very nicely 3D printed case.

If you want to learn to curse like a Tuscan sailor, you can watch the two-part video series, embedded below, in its entirety. Otherwise, we have excerpted the good stuff out of the second video for you.

For instance, we love the old-school voice synthesis sound of the Speak and Spell. Here, playback is implemented using the Talkie library for Arduino, and [Marco] is using the BlueWizard software on a dated Macbook for recording and encoding. (We’d use the more portable Python Wizard ourselves.) Check out [Marco] tweaking the noise parameters here to get a good recording.

And since the Talkie Arduino library uses PWM on a digital output pin to create the audio, the high-frequency noise was freaking out his simple transistor amplifier. Here, [Marco] adds a feedback capacitor to cancel that high-frequency hash out.

The build needs to be quite compact, and the stacked-Arduino-with-PCB-case design is tight. And the 3D-printed case has a number of nice refinements that you might like. We especially like the use of thin veneers that cover the case all around with the build-plate’s surface texture, and the contrasting “Asteroids” logos are very nice.

All in all, this is a really fun build that’s also full of little details that might help you with your own projects. Heck, even if it just encourages you to play around with the Talkie library, it’s worth your time in our opinion. And while you’re at it, you can turn on the subtitles and pick up some vocab that’ll make your nonna roll over in her grave.

Continue reading “Tight Handheld CRT Asteroids Game Curses In Tuscan” →

Baldur’s Gate III Comes To The TRS-80 Model 100

June 12, 2024 by Tom Nardi 8 Comments

To say that Tandy’s TRS-80 Model 100 was an influential piece of computer hardware would be something of an understatement. While there’s some debate over which computer can historically be called the “first laptop”, the Model 100 was early enough that it helped influence our modern idea of portable computing. It was also one of the most successful of these early portables, due in part to how easy it was to write your own software for it using the built-in BASIC interpreter.

But as handy and capable as that integrated development environment might have been, it never produced anything as impressive as this Baldur’s Gate III “demake” created by [Alex Bowen]. Written in assembly, the game’s engine implements a subset of the Dungeons & Dragons Systems Reference Document (SRD), and is flexible enough that you could use it to produce your own ASCII art role-playing game that can run on either a Model 100 emulator like Virtual-T or on the real hardware.

Continue reading “Baldur’s Gate III Comes To The TRS-80 Model 100″ →

Happy Birthday, Tetris!

June 8, 2024 by Elliot Williams 6 Comments

Porting DOOM to everything that’s even vaguely Turing complete is a sport for the advanced hacker. But if you are just getting started, or want to focus more on the physical build of your project, a simpler game is probably the way to go. Maybe this explains the eternal popularity of games like PONG, Tetris, Snake, or even Pac-Man. The amount of fun you can have playing the game, relative to the size of the code necessary to implement them, make these games evergreen.

Yesterday was Tetris’ 40th birthday, and in honor of the occasion, I thought I’d bring you a collection of sweet Tetris hacks.

On the big-builds side of things, it’s hard to beat these MIT students who used colored lights in the windows of the Green Building back in 2012. They apparently couldn’t get into some rooms, because they had some dead pixels, but at that scale, who’s complaining? Coming in just smaller, at the size of a whole wall, [Oat Foundry]’s giant split-flap display Tetris is certainly noisy enough.

Smaller still, although only a little bit less noisy, this flip-dot Tetris is at home on the coffee table, while this one by [Electronoobs] gives you an excuse to play around with RGB LEDs. And if you need a Tetris for your workbench, but you don’t have the space for an extra screen, this oscilloscope version is just the ticket. Or just play it (sideways) on your business card.

All of the above projects have focused on the builds, but if you want to tackle your own, you’ll need to spend some time with the code as well. We’ve got you covered. Way back, former Editor in Chief [Mike Szczys] ported Tetris to the AVR platform. If you need color, this deep dive into the way the NES version of Tetris worked also comes with demo code in Java and Lua. TetrOS is the most minimal version of the game we’ve seen, coming in at a mere 446 bytes, but it’s without any of the frills.

No Tetris birthday roundup would be complete without mentioning the phenomenal “From NAND to Tetris” course, which really does what it says on the package: builds a Tetris game, and your understanding of computing in general, from the ground up.

Can you think of other projects to celebrate Tetris’ 40th? We’d love to see your favorites!

Foosbar: The World’s Best* Foosball Robot From Scratch

June 6, 2024 by Jonathan Bennett 6 Comments

[Xander Naumenko] is back with another bonkers project. This is the same creator that built a working 32-bit computer inside a Terraria world. This time it’s a bit more physical of a creation: a self-playing foosball table.

We’re not sure of the impetus for this idea, but we’re delighted to see the engineering it took to make it work. It sounds so simple. It’s just servos mounted on linear actuators, right? Oh, and some computer vision to determine where the ball actually is on the table. And the software to actually control the motors, pass the ball around, and play offense and defense. So maybe not so simple. All the code and some other resources are available under the MIT license.

As to while the claim of “best” foosball robot has an asterisk? That’s because, although we’ve seen a few potential competitors over the years, there isn’t yet a world foosball competition. We’re hoping that changes, as a tournament of robots playing foosball sounds like a sports event we’d show up for!

Continue reading “Foosbar: The World’s Best* Foosball Robot From Scratch” →

Tarzan, Lost Since 1983, Swings Back Onto The Atari 2600

June 6, 2024 by Jenny List 12 Comments

Computer gaming history is littered with tales of fabled lost hardware and software. Some of them are very famous such as the E.T. cartridges buried in a desert landfill or the few prototype SNES/CD-ROM hybrid that Nintendo was developing with Sony before the introduction of the PlayStation, but others have faded somewhat into obscurity. Among these is Tarzan for the Atari 2600, a game which was never released due to the 1983 console crash, and which the [Video Game History Foundation] have a report on its rediscovery and preservation.

The game was to be published by Coleco for their ColecoVision console as well as the 2600. The ColecoVision version was released and was apparently even fairly well reviewed, but the Atari port was canceled and its very existence eventually faded into obscurity.

Continue reading “Tarzan, Lost Since 1983, Swings Back Onto The Atari 2600″ →