So if this error is bubbling up, it’s an ArgumentException.

Fantasy Consoles?

While there are differing opinions on exactly what constitutes a fantasy console, the basic idea is that it’s a game development platform for hardware that doesn’t exist. In some cases, there are entire systems dedicated to maintaining the illusion that somewhere in an alternative universe, these video game consoles could have existed.

Why Fantasy Consoles?

The most appealing aspect of developing on these platforms is the artificially-imposed constraint that working within a proscribed set of parameters affords. That’s a mouthful, but it’d probably be simpler to explain the idea with some practical examples.

Pico-8 demo cart

Display resolution: 128×128 pixels, 16 pre-set colors (through an additional palette 16 additional colors have been discovered)
Audio: 4-channel “bloops” (basic FM synthesis) simultanous
Input: Up to 4 six-button gamepads
Memory: Up to 32k for each cartridge
Language: Customized version of Lua

Cartridges for this platform are stored in the lower bits of the color channels in a standard PNG image, so the “cartridge” file actually contains all the relevant game data. The system itself comes with a feature to browse finished games, so Pico-8 can be used as a standalone console.

While you’d think that being limited to 128×128 pixels with only 16 colors at a time is fairly limiting, the community itself has made the platform an overwhelming success, and they continue to push out amazing games using a highly constrained format.

Some example Pico-8 games (click each to visit)

More Fantasy Consoles

Since Pico-8, there have been a slew of other fantasy consoles released, some with similar design goals, and some that are completely esoteric. I am currently maintaining a (mostly up-to-date) list of all the fantasy consoles I can find (let me know if I’m missing yours!). I’ve also helped a couple other people with their systems, and learned some different programming languages on the way.

Resources

If you need help getting started, check out the fantasy console list. If you’re looking for a well-established product with tons of community support, I really can’t recommend Pico-8 enough. It’s not free (at $14.99), but it’s one of the more polished systems out there.

My personal fantasy console recommendations are as follows:

• Pico-8 ($14.99) – The original. Has a huge community following, and is the origin of #tweetcart.
• TIC-80 (free) – This project came out almost directly on the heels of Pico-8. It has similar, but far less constraints, with a low barrier to entry.
• PixelVision 8 ($14.99) – A system that lets you design your own constrained system, then make a game for it.

To discuss with other like-minded individuals, check out these Discord servers:

Pico-8 – Useful for things other than Pico-8, but mostly centered around Pico-8.
Fantasy Consoles – Includes most other smaller fantasy console channels.

There’s also a Fantasy Consoles wiki with more information on different FCs.

Making Games

And finally, what blog post would be complete without a little self-promotion? While working on the Leikr fantasy console, I turned a small demo into a “full” Flappy Bird style clone! The gameplay isn’t much to be impressed about, but all assets in the game were made by me: graphics, code, sounds, and music.

Update: Took down the game link because I broke it.

NES ROM header

But this post isn’t about nostalgia; it’s about organizing games, specifically ROM files. While I’m fairly certain I’ve got several discs (and old HDDs) filled with variously-complete ROM sets for various platforms, these were mostly collected from newsgroups waaay back in the day and as a result have a wide variety of headers, possible trainers, and intros. Nowadays, even the Internet Archive maintains full sets of “no-intro” ROMs donated by people who stayed in the scene far longer than I did.

If you intend to organize such a non-trivial amount of games, you’re gonna need some ROM utilities. The most well-known of these are clrmamepro, RomCenter, and RomVault. I’m sure there are others, but these are the big players. I’m not really going to speak about their various strengths/weaknesses, as that’s a little outside the scope of this post.

What I actually want to discuss is how checksums are calculated using the “datfiles” provided by the No-Intro site’s users. I had a hard time finding this information initially, so I’m putting it here for anyone else. Also, if I’m wrong, I’d love to be called out and told what I’m doing wrong.

I’m using the following:

• No Intro NES ROM set
• Dat-o-Matic Fulltitle NES datfile
• clrmamepro iNES header config (not linked from anywhere I could see on the No-Intro site)

I only found the clrmamepro iNES header config far later than the rest of this info. This specific file is fairly sparse, and only has the following:

<detector>
<name>No-Intro NES Dat iNES Header Skipper</name>
<author>Yakushi~Kabuto</author>
<version>20070321</version>
<rule start_offset="10">
<data offset="0" value="4E4553"/>
</rule>
</detector>

Basically, take this to mean we’re starting at offset 0x10 and reading to EOF (NES files aren’t larger than 0x4e4553 bytes). Once I did this, my CRC32 checks started working. I’d normally stop there, but it looks like my MD5 and SHA-1 hashes are wrong. Adding the entire file back in fixes this, so…I’m not really sure why we’re bothering to trim the header for only one check.

To sum up:

CRC32 – 0x10 through EOF
MD5 – entire file
SHA-1 – entire file

That being said, at work we use newline braces, and I don’t like it. A good programmer follows the in-place coding style, so that’s what I’ve been doing. It doesn’t mean I have to like it, though. While I use a separate installation of Visual Studio on an entirely different computer for coding my personal projects, there are times where I’d like to not have to completely switch machines to bang out some lines of code.

After reading that you can export and import Visual Studio settings, I created two settings files trimmed down to only include indentation and newline settings, so now I can simply import a settings file and all the rules I want changed are changed.

Feel free to edit the below files to your needs:

VS_Personal.vssettings (3.6k) – Cuddly style
VS_Work.vssettings (3.6k) – Non-cuddly style (braces on newlines)

These are only for Visual Studio, though. I’ve got nothing to offer for other editors, but feel free to contribute settings files for any other IDE.

I’ve heard it pronounced this way in video tutorials (especially from one specific “guru” who knows a lot about Blender ;), but recently I’ve noticed this malapropism being used in written tutorials as well.

After spending way too long (~30 minutes) trying to figure out why my background Blender renders were producing default cubes when that is clearly not what is in the scene, I finally looked at the console output and understood.

blender --background --python script.py myfile.blend

What this command does is tells Blender, “Load into memory as a background process and run script.py (which changes some settings and starts a render). Then load myfile.blend.” Once the file is loaded, background Blender exits.

In the proper order:

blender myfile.blend --background --python script.py

PDFs are easy! Like riding a…oh.

Since this was a low-priority project (read as: for fun), I needed something that’s free, preferably open source. I tried four of the top PHP PDF libraries, excluding libraries that are part of a larger framework (i.e. Zend Framework has fairly robust PDF functionality, from what I’ve read).

Skip to the bottom if you’re not interested in a per-product breakdown.

FPDF

I’ve used FPDF in the past. My invoice generator that I wrote over 5 years ago actually uses FPDF. The only problem is, that’s around when the FPDF project was last updated, which means that all the things that bugged me in 2010 are still a problem.

For starters, the API is a bit messy. I mean, it’s easy to get started, and if you want to just knock out a quick document that also happens to be a PDF, then great. This library is probably for you.

Embedding fonts, for me, was an exercise in frustration. FPDF needs a .php file containing glyph information for FPDF, and a .z file that contains the gzipped font. It doesn’t always work, and there’s no documentation explaining the errors. One issue that kept popping up was the failure to generate the .z file, which I ended up working around and creating myself.

More to the point of my immediate need, though: FPDF only supports JPEG, PNG, and GIF (if GD is installed). It’s important for this project that the PDF contain only vector artwork, so that was a no-go from the start.

TCPDF

TCPDF, on the other hand, does support vector graphics in the form of SVG, EPS, and even raw Illustrator (.ai) files. EPS and SVG import worked equally well, and the API is a bit cleaner than FPDF.

All fonts are imported via the addTTFfont() method, which is also used for OpenType or Type 1 fonts. After permissions were set up, there was no large issue importing the fonts, aside from TCPDF appearing to discard any hinting or kerning information. The documentation claims to allow for kerning, but the “tracking/kerning” demo actually only shows tracking and stretching. When I used an imported font, the kerning went completely random and I had no way to correct it. Seems to work fine with system fonts, though.

Since I needed vector-only artwork and a specific non-system font, TCPDF is out too.

On a marginally-related note, SourceForge is terrible. Please don’t host code there.

dompdf

I read that dompdf (name is lowercase; not just me being lazy) was good at converting HTML to PDFs with styling and background images (which requires GD installed) intact. I will admit, this worked surprisingly well in practice. The library includes an administration panel that allows direct font loading and conversion. This also worked well and I had no issues with it. Fonts seem to use their built-in kerning and tracking and came out looking clean.

The only problem I had with dompdf was that it has no support for vector image formats, even SVG. I hoped SVG support might be coming, since it’s just more XML and is supported by most modern browsers as a valid image format.

If this project didn’t absolutely require that there be vector-only artwork (it’s for a print project), I’d drop everything else and use dompdf in a second. HTML and CSS is a hell of a lot easier to work with than PHP classes written by someone else.

FPDI

So what if, I thought, I could use TCPDF to import the artwork to a “template” PDF (or just create the template myself), and use dompdf to create a text-only PDF, then merge the elements?

Enter FPDI. It’s a library made to work with existing PDF files. In the included examples, it even claims to work with TCPDF, but I found it to be less than clear about how this was working. There was some mention of templates, but I honestly couldn’t figure out the whole thing.

It requires FPDF, but also claims to be able to use TCPDF instead? I don’t know. I was unable to find any way to merge to pages into the same page, but plenty of examples of PDF concatenation (not what I want). Perhaps I missed something, but it seemed fairly opaque to me. Exit FPDI.

Screw It

In the end, I copped out and avoided the PDF generation entirely. Starting from an SVG exported from Illustrator, I’m stepping through the textual fields with DOMDocument and replacing the text before it’s sent to the browser. The output is saved directly to the client’s disk as an SVG file. When that SVG file is dragged into Illustrator, it’s good to go. Illustrator includes glyph information with the SVG for its own use, so fonts are already set up and correct. I can then just save the file as a PDF with no modifications.

Sure, it’s not the 100% automated plan I had in the beginning, but this still saves me at least 20 minutes each time I have to do this process. So, a win at least.

Conclusions

The free offerings for PHP->PDF libraries kind of suck in their own unique ways. I found dompdf to be the slickest of all of them, for sure, but it has some limitations. I’d heard good things about the PDF tool in Zend Framework, but I don’t use Zend so haven’t tried it.

mPDF is similar to dompdf in that it converts HTML (including CSS3) to PDF. The examples were ugly, but showed an impressive array of features. I didn’t end up trying it out, but it looks decent.

If you’re able to use a non-free solution, I can easily recommend PDFLib, but it’s not cheap ($1150 for a server license). I’ve used this in the past with different programming languages and found it to be solid. Since it’s a mature product, there are hundreds of real-world examples of developers using it in actual projects.

So here you go. The HP Color LaserJet 3600 64-bit driver for Windows 7, 8, and 8.1.

HP3600_64_Bit.zip (14.2 MB)

When I first took a look at LESS as a CSS replacement, I wasn’t too interested in having even a command-line compiler. The idea of having my stylesheet loaded and parsed by Javascript didn’t sound that great either, but tolerable if it saved me enough time and effort writing CSS.

While testing LESS on my local server, I used less.js to process my .less stylesheet on the client side. It worked well, and on modern browsers the processing time is minimal, but I decided to look around for LESS compilers anyway. I discovered SimpLESS nearly immediately, and it looked perfect.

Compiling a .less file is as easy as drag-and-drop, and it monitors the file for changes. When your file is saved, it is nearly immediately compiled into a CSS file. If you’ve made an error in your file, the file highlights red and specifies the line number at which the problem occurred. Output is pure, minified CSS goodness.

SimpLESS, by default, inserts a comment at the top referring to its website. This can easily be disabled if you like.

When I first started using SimpLESS, I was copying and pasting the output into a WordPress template style.css file, which requires a properly-formatted comment at the top to describe the theme. Since SimpLESS performs minification, comments are stripped out. I thought this was the only way to keep my WordPress theme comment intact while still using the features of LESS. This copy-paste tedium was something I specifically wanted to avoid in the first place.

Note: The remainder of this post was written before SimpLESS users complained enough about this very issue, so theme comment preservation is no longer an issue.

I thought that there must be some way to preserve a comment when compiling. Surely that wasn’t an uncommon use case? I checked out the SimpLESS source code to see how it was performing its minification (master/Resources/js/clean_css.js, line 30 if you’re interested), and saw they included a special character to preserve certain comments: the exclamation mark.

To preserve a CSS comment in SimpLESS (not that this will not work using the Javascript version, as WordPress will not find a style.less file), simply put an exclamation point after the initial comment delimiter, like so:

/*!
Theme Name: My Super-Cool Theme
Theme URI: https://www.pixelbath.com/
Description: Blah blah blah...
[cut for length]
*/

The exclamation point is ignored by WordPress, and if you have SimpLESS processing your style.less file, you can continue to upload your theme’s style.css file as usual.

Everybody wants a rainbow, apparently.

The only things you can do from Photoshop’s own menus are:

1. reset the swatch palette to the default colors
2. replace the palette with a new swatch palette by selecting “Replace Swatches.”

Anyway, there are two ways to clear the swatch palette completely. Actually, there are three, but one of those is to manually right-click each swatch and select Delete swatch.” If you’ve got way too much time on your hands, this would be the way to go. For the rest of us that would rather get on with our lives, there are two better methods of clearing out the palette.

The first method is to do it manually, only with the help of a keyboard shortcut. While holding your mouse cursor over the swatch palette, hold down Alt (⌥ Option on Mac). Your cursor should change to a scissors icon (). Click any color in the swatch palette to delete it. You’ll have to do this over a hundred times to clear out the palette, but if you’re a furious clicker like me, you can have this done in under 10 seconds (I play Starcraft, so…yeah).

The Alt/⌥ Option clicking works fairly well, but is still somewhat labor intensive. If you want to clear it even faster, you can download this (mostly empty) swatch file. It includes only one color, black, so you can simply delete this single swatch and begin filling the palette with your own colors.

Download the file below:

single_swatch.aco (50 bytes)