First off, I have added a lot of controls to the Jewel menu system since I last wrote about it. I’ve added sub-menus and sliders, while also cleaning up the codebase. I concluded this would be much easier to program with C++, particularly for exception handling, which has always been a problem for C programmers like me. As such, I will probably be converting by the next release.

Download the latest version of Jewel here. (Released under the GNU General Public License version 3 or later).

I’ve found rewriting CANINE from the ground up to be particularly frustrating, and haven’t spent as much time as I should have on it. I tried updating Alpha-2 to have the changes I was planning for the new version to see how that would work, but that has also been oddly difficult. It doesn’t help that I have so many other things I want to do, too.

However, I have progress on the scripting language compiler! I wrote it in Ruby to allow for rapid prototyping and it is all hand-made. It supports a tied file-module structure (each file is a module) with module-level fields and functions. Good support for arithmetic, conditions and function calls has been implemented, though there are no control structures. The resulting output is in a human-readable assembly-like pseudo-code so that I can debug the compiler. This project has been rather fun.

Download orangecc.rb here. (GPLv3+ as well.)

What has caught my interest lately is voxel-based engines like Minecraft. Though, I’d like to point out that the blocks themselves in most of these aren’t actually voxels, but they often refer to the blocks as voxels, which is unusual and can get a bit confusing. However, I have learned a lot about modern OpenGL programming (and real-time graphics in general).

The most useful thing I’ve learned about is vertex arrays. As opposed to making a function call for every single vertex in the world, you just make one given an array of all the vertices you want. This speeds things up massively, though it further displays the usefulness of C++ (creating those lists is easier with std::vector’s than manual malloc/realloc-arrays). You can bring it down even further by culling out (ignoring) faces that are blocked by other cubes.

What’s interesting about voxel-based engines is the way they implement this. The world’s always changing, so you can’t have a static, unchanging array of vertices. Instead, the list must be regenerated every time the world is modified. Of course, this would take way too long in a world as big as Minecraft’s, which is what makes chunk-based design so useful.

For those of you who don’t know, Minecraft-type engines separate their worlds into multiple 16x16x256 (numbers change between some versions) chunks of blocks. What most people know is that this allows parts of the world to be loaded and unloaded at will. Something that most people may not know is that this also allows each chunk to maintain a separate vertex array.

When you modify a chunk, only that chunk’s array is modified. This allows regeneration to occur in real-time while still bringing render-times down in orders of magnitude. All you have to do at this point is balance array regeneration against render speed to determine chunk size, which is a decision left up to the human.

I’m not particularly sure if this is how Minecraft does it, but it appears that this is how many voxel-based engines work. I know Minecraft uses chunks, I just don’t know if it generates vertex arrays and, if it does, if there’s anything more they do.

From all this information, I wrote my own little voxel test. I call it McCraft because I really didn’t feel like thinking up a fancy name and that was the first thing that came to my head. I built it with Allegro 5.0.9 (for input and graphics) and libNoise (for Perlin-noise height map generation).

Download McCraft here. (Again, GPLv3+.)

So that’s the news. Also check out the latest version of Pizazz which now supports alternative currencies!

The first one was requested a long time ago, but I deprioritized it because the person had edited a few lines of code and got a workable result. What he wanted was for Pizazz to support selection between Zazzle’s target countries. This is used when querying price information to figure out the units by locality. I’ve added a global setting, and now you can display your stores in Yen and Monopoly Money (Canadian dollars)!

The other feature is just a checkbox/shortcode option: the ability to hide the “See More” button. I have few guesses as to why exactly someone would want to do this (perhaps if everything’s already visible in their site?), but it was requested and required very little modification to the code base. Of course, “See More” will remain visible by default.

So that’s that. I’ve also verified that it works with the newest WordPress (3.5.1 as of March 13, 2013), and that’s always good. The update isn’t vital unless you need those new features, as there are no outstanding bugs that had to be fixed.

Before I go, I would like to give out a little PSA. If you get a message saying that the “query did not return any products,” it means that there is literally nothing with the keywords you specified (or, at least, not in your store if you filled in that field). You can verify this by searching Zazzle with the same keywords. If Zazzle pops up with something anyway, then something went horribly wrong. The most likely scenario is that their RSS feeds are down (which happens surprisingly often), but if it persists for more than a few hours than there might be a bug in Pizazz. If so, don’t hesitate to contact me!

Download the latest version from WordPress.org.

I abandoned the FLTK-style array-based menu definition for something a bit more flexible. I instead based it off the Syslinux bootloader’s way of doing it, which is declaring the menus like a series of function calls. My implementation is quite a bit different, of course, but it still fits the bill. I chose this design over the previous system because I thought it would make it much easier to bind to other programming languages, or to allow people to load their menu definitions from scripts and data files.

Declaring a menu looks something like this:

JEWEL_MENU *menu = jewel_create_menu(my_awesome_font);
jewel_add_inform(menu, "Are you sure you would like to quit? All progress will be lost!");
jewel_add_button(menu, "Yes", &quit_yes_clicked);
jewel_add_button(menu, "No", &quit_no_clicked);

That displays a black-and-white menu with a question and two options. You can navigate the options using the arrow keys and select one pressing either enter or space. It’s looking pretty good!

The next thing I want to do is add a toggle button and slider. Afterwards, sub-menus will be top priority. One of the primary reasons I wanted to write a library was to handle this.

Lastly will be themes. Currently, you can set the font for text and it will adjust dimensions appropriately, but I want to implement configurations for back/foreground color, margins, and padding. Even more, I want to have controls able to specify classes like in CSS so you can style them differently (e.g. to make the aforementioned “Yes” button more impending).

Code cleanup is also on the list. I’m considering obliterating all of the asserts in the library and having any and all errors just return error codes. I’d rather programmers be able to display error dialogs then to have sudden crashes and weird 0x0000F82A-type messages.

For now I’m uploading the source code as Alpha-1. I hereby place it under the GNU General Public License version 3 or later. Feel free to play around with it! (Note: only tested on the 64-bit Arch Linux GNU/Linux distribution. Requires Allegro 5.x, tested with 5.0.8.)

• Jewel Alpha-1
• Allegro 5.x
• Arch Linux

More than just to my blog, though. I’m revisiting the CANINE engine, a Wolfenstein-3D-style game engine that I said I was going to focus on and then forgot about! Sadly, more important things came up and it got pushed too far back. I am really interested in getting this game done, because I really like the retro feel it gave off.

Its current status is less than optimal. There is a working C++/Allegro5 code base that looks like what I had shown in my last video, but with a cruddy attempt at a skybox and support for see-through grates. I forked it to add Google V8 JavaScript to it, but V8 ended up feeling too bulky and I couldn’t think of a good way to integrate it into the engine. Largely, this was caused by the engine’s poor design. The raycaster’s great, the renderer’s great-ish, the resource management is where things broke down.

I started managing resources in a way that is just too complicated. Unsigned 8-bit integers (usually represented as ASCII printable characters) map resources in a palette which the level associates with itself. The renderer pulls textures from it, but it’s even more complicated than that. The palette doesn’t actually manage resources, it stores a table of identifier-filename pairs, and gets the bitmaps for each request from a dedicated resource manager. The resource manager stores data in filename-pointer pairs and handles loading automatically.

This entire architecture makes me sad and I can’t go on with it. Instead, I’m going to rewrite the engine. Yes, for a third time, but read on! This time I’m going to plan things out, and I’m making the process public.

I’ve decided to release CANINE as free/libre and open source software under the GNU General Public License. This means it will grant you the right to run CANINE for any purpose, modify it and redistribute original/modified versions (even commercially). All that the license requires is that you share these rights with anyone you redistribute CANINE, and any modifications, to.

Initially I’m going to do is upload the three editions I have. First is Alpha-1, which is written in C and supports a basic textured environment. Next is Alpha-2, a rewrite in C++ that supports the weird palette-resource system, skyboxes and transparency in walls. Lastly is Alpha-2J, which sports some initial bindings to JavaScript.

• Alpha-1
• Alpha-2
• Alpha-2JS

My plan for the next version is to write a few libraries and run some tests before writing the main game. I believe the project modularity will help me create a clean system: each project is created and maintained separately, allowing each one to be completed individually so that the final product requires little work in comparison.

The first library, codename “Jewel,” will provide a simple menu engine in C built on top of the Allegro game programming library. The idea is to design the entire menu as one multidimensional array with callback support. Here’s an example of what I have in mind:

static const MENU *game_menu = {
   { MENU_BUTTON, "Start", &start_game },
   { MENU_SUBMENU, "Options", NULL },
      { MENU_SUBMENU, "Video", NULL },
         { MENU_TOGGLE, "Fullscreen?", &set_fullscreen },
         { MENU_TOGGLE, "Blood/Gore?", &set_blood_gore },
         { MENU_END, NULL, NULL },
      { MENU_SUBMENU, "Audio", NULL },
         { MENU_SLIDER, "Music Volume", &set_music_volume },
         { MENU_SLIDER, "Sfx Volume", &set_sfx_volume },
         { MENU_END, NULL, NULL },
      { MENU_END, NULL, NULL },
   { MENU_SUBMENU, "Quit", NULL },
      { MENU_MESSAGE, "Are you sure you want to quit?", NULL },
      { MENU_BUTTON, "Yes", &quit_game },
      { MENU_BACK, "No", NULL },
      { MENU_END, NULL, NULL },
   { MENU_END, NULL, NULL }
};

Inspired by the Fast Light Toolkit’s menu system, I believe it’s easy for people to work with and allows for a really lightweight implementation. We’ll see how it goes.

Afterwards will be a scripting language, codename “Orange.” What held me up in each version of CANINE was trying to figure out a good way to implement scripting. In CANINE Alpha-1 it lead me to believe the design was flawed. In CANINE Alpha-2 the primary problem was my inability to select a language.

I have a problem with pretty much every language I encountered. Squirrel’s too slow, AngleScript doesn’t have enough documentation of the actual language, Pawn doesn’t compile on 64-bit GNU/Linux, TinyScheme is also slow, GameMonkey makes me feel like I’m downloading a virus, PSL’s design just doesn’t fit, and Lua is insecure. There’s some cross-over there, but I just listed my major grievances with each one. GameMonkey could fair well with a better website.

For this reason, I’m going to implement my own scripting language. I’m going to keep it small and simple, considering it’s going to be my first implementation of a programming language since my Tiny BASIC compiler. I’m shooting for a bit of a combo between PSL (PLIB Scripting Language/Library) and Dink-C (from the anti-hit title Dink Smallwood). The language will be a dumbed-down version of C designed for an event-driven game engine. All that I’ll implement in the beginning is file-level globals, int/float/const-string variables, int/float arithmetic, public/private functions and the if-statement.

That’s right. The if-statement. Not for, not while, not do-while. For the stuff I’m starting out with, I won’t need loops. Eventually I will implement them, but I want to get something working first.

The idea is that each script defines handlers for an object. For instance, the “zombie.script” file will define the “update” function to handle its movement each loop and the “collision_bullet” function to handle getting shot. The point of the public/private function system is to allow me to add as many callbacks as I want over time without worrying about accidentally calling a private helper function from older scripts that just so happens to have the same name.

The compiler will be separate from the virtual machine so that game loading won’t be affected by compilation efficiency. I’m still pretty n00b at compilers so I don’t want to have to worry about that. Scripts will be stored in a portable, CPU-independent format so that you won’t have to worry about switching between 32/64-bit and big/little-endian machines.

The last thing I’m going to do is write a little client-server chat program and experiment with the networking libraries out there. Why? I think it’d be cool if CANINE had multiplayer support, because playing against friends (or enemies, really) is fun. The Enet library is looking particularly enticing… more on that later.

Throughout this process, I’m going to try and blog as much as possible (without overdoing it). I believe that talking about it constantly will help me stay focused on the project(s). Of course, I’ll still have normal work to do, but I’ll make time.

That’s all I have to say. Noch guten tag!

More information

• The last post I had on CANINE
• PSL and Dink-C, so you have an idea of what I’m thinking about
• Enet, same reason as above
• Google Translate, to figure out what that last thing I said was

Also, I replayed Mass Effect 2 and finished 3.

Hello again, readers! I just finished replaying Mass Effect and decided that it is time to write a new article.

Over the weekend I designed and implemented a WordPress theme for a friend of mine from the Secret Maryo Chronicles project. I know him as MrVertigo27, but others call him Spitfire25565. He has a YouTube channel full of tutorials and Let’s Plays of Minecraft and its plethora of mods. They are pretty cool and you can go check them out — but I will not give you the link until you finish reading! =P

All of his videos are coagulated into a group called GameMode5. GM5 focuses on reviewing and rating Minecraft-related technologies, particularly mods. This ranges from minor mods such as Hack/Mine, which mostly just modifies gameplay, to the Aether mod, which creates an entirely new sub-world (like the Nether).

Despite all of the videos under the GM5 name, however, their website spent several months as an unconfigured, content-less Joomla! installation. After awhile, that kind of thing starts to get on my nerves, and I finally broke down and offered to build his website for him (a similar event to when I wrote the GNU FreeDink website theme).

He happily agreed, and even gave me complete creative control. This allowed me to play with it a lot, though it also required me to think more carefully — I wanted to make sure that he would still like it.

I replaced Joomla! with the more popular WordPress content management system and got to work on a draft, which I then converted into a dynamic theme. The end result, for reference, is here: http://gamemode5.com/.

A screenshot of the GameMode5 theme I wrote.

The first thing I did was create the logo. Using the powerful GNU Image Manipulation Program (GIMP), this task was fairly straight-forward. The first thing I did was place, in big, bold letters, “GameMode5.” I used the free and open font Orbitron to make it look nice and video-gamey. The letters were a bit too close together, so I increased the “kerning” (inter-character spacing) until the text fit across the whole screen.

The next thing I did was create a drop-shadow using one of the GIMP’s filters. I played with a few depths until I settled on 5×5 with a bright grey coloration. This was pretty cool, but it was missing something. So, I ran through this algorithm:

 10  LET F = FIRST FILTER
 20  APPLY FILTER F
 30  IF IMAGE LOOKS COOL THEN GOTO 60 ELSE GOTO 40
 40  UNDO FILTER
 50  GOTO 70
 60  TINKER WITH FILTER SETTINGS
 70  IF MORE FILTERS THEN GOTO 80 ELSE GOTO 100
 80  LET F = NEXT FILTER
 90  GOTO 20
100  EXIT

This algorithm resulted in just one filter, “Erase Every Other Line,” which looked pretty frelling cool. I then applied the same filter to the drop-shadow. It occurred to me that it might look better to erase every odd line instead of every even line of the drop-shadow, so I tried that, too. I preferred the later because it made the text glow more.

After that I just put a little green motto line beneath it and called it done. This end result is what you see now.

The next thing I did was create the web page layout, consisting of a header, content area, sidebar and copyright footer. I aligned them using some pretty CSS3 and divs. You can do a lot by setting fixed widths and the “float” attribute. For instance, the middle area is just:

div#sidebar {
  width: 200px;
  float: right;
}

div#content {
  width: 595px;
}

I decided on fixed width because I really wanted to show off the background, which I wanted to be tiles from Minecraft itself. However, I wanted to website to be dark since I felt it fit the mood better (note that I always find myself in the most horrific circumstances in this game — being ganged up on by skeletons, surprise-attacked by three creepers in a row, falling into lava when I was standing still…). So, I decided to use GIMP’s wonderful Colorize tool to darken the original tile set.

I chose the stone because, well, stone’s awesome. Do not even try to deny it: stone is the best block in Minecraft. Ever. Everything should be built out of stone. Cobblestone is evil. Cobblestone must die. Why do the creepers only go after my stone?!?!?! \(O_O)/

Ahem. So, I placed all of these in the background and made a conclusion: it was super boring. To spice it up, I placed a few gold ores around. A few CSS tweaks later, along with a nice Lorem Ipsum example text, and I decided to show MrV what I had done.

He liked it (=D) but made one request. He wanted to know if I could randomize the ores in the background. Lo and behold, it is time for every web developers greatest tool and worst nightmare. JavaScript.

It took a bit of time, largely because I tend to forget the names of the JavaScript functions, but I eventually succeeded. The algorithm is pretty cool; I split the screen into individual, 64×64 tiles and iterate through them. In each tile, I randomly decide if there’s going to be an ore there. If there is, then I randomly select which ore it is.

Leaving it there, though, is not really in the spirit of Minecraft. In Minecraft ores only appear at certain levels, encouraging you to go deeper to find the more important valuable resources. Well, it took quite a bit of tinkering, but I got something very nice.

Between regions 1 and 5, there is a 50-50 shot of the cell either being coal or iron. Between 5 and 10, it becomes an even statistical split between coal, gold and iron. Lastly, anywhere past ten it turns into an equal chance of either diamond or redstone. This can be simplified into the following JavaScript:

if (y > 10) {
  switch (Math.floor(Math.random() * 2)) {
    case 0: /* redstone */; break;
    case 1: /* diamond  */; break;
  }
}
else {
  switch (Math.floor(Math.random() * (y > 5 ? 3 : 2))) {
    case 0: /* coal     */; break;
    case 1: /* iron     */; break;
    case 2: /* gold     */; break;
  }
}

Beautiful, eh? Took quite a while to figure out where to put the parenthesis in the ternary (A>B?C:D) statement, but the end result works like a charm!

Of course, there’s the question of how I got the images back there, anyway. Well, all I did was insert an absolute-positioned image-div with a negative z-index after the ending copyright statement. The web browser, assuming it understands CSS properly (which all modern browsers do) will position them exactly where they are needed.

That basically sums it up, but there’s one last thing that I want to mention. It is a library called jQuery, without which I would have been driven insane writing this simple program. jQuery lets me do stuff like get the dimensions of the document area and insert elements without having to deal with the constant browser quirks and incompatibilities. On my own I would have needed to write this to get the document width:

function getWidth()
{
  if (typeof (window.innerWidth) == 'number') {
    /* most web browsers (but not all of them
       or all versions) */
    return window.innerWidth;
  } else if (document.documentElement
             && (document.documentElement.clientWidth
                 || document.documentElement.clientHeight)) {
    /* internet explorer version six and later
       in standards mode */
    return document.documentElement.clientWidth;
  } else if (document.body && (document.body.clientWidth
                               || document.body.clientHeight)) {
    /* internet explorer version four */
    return document.body.clientWidth;
  }
}

…and that is the simplest version of this code I could find. However, which jQuery all I have to say is:

$(document).width

…and this works in Internet Explorer, Firefox, Chromium and even Opera!

The key to jQuery is the $() function, which functions sort of as a more powerful document.getElementById() which can also accept the document and window objects, plus CSS identifiers and HTML code. The later usage is how I inserted the background divs:

$('<div>blah blah blah</div>').insertAfter('div#copyright');

jQuery makes JavaScript coding super easy and its generously licensed under the super-liberal, free and open source MIT/X11 license, which essentially means you can do whatever you want with it as long as you do not remove the copyright notice(s).

They also have a really cool user interface library which I used in an older project to make a draggable window within the page. jQuery’s a life saver, and I definitely recommend you check it out.

Links

• GameMode5: the website that I developed the theme for
• Orbitron: the free and open font that I used in the logo
• jQuery: the library I mentioned
• GIMP: the tool I used to create the logo
• fancy-background.js: the script I wrote to manage the background ores
• Mr. Vertigo’s YouTube Channel: since I promised you a link earlier =)

License Notice

I wrote the theme and JavaScript code for GameMode5, so I am letting them decide how they want to license this stuff. The Fancy Background script should be used for reference, only.

Let us start out with a status update: what I have been doing since the last time I posted.

I have spent most of my time advancing my knowledge in chemistry, reading up on philosophy, expanding my background in the history of software development, learning conversational German (Bedingung, ich hätte gern die Suppe als vorspeise, bitte!) and, more recently, studying the field of psychology. With all this going on, I have largely forgot about actually programming anything.

Since the holidays are rolling in, and hence the candy, I started thinking about Rolos. They say that you can “role a Rolo to a friend,” though the very design of the chocolate implies that you must compensate for the unavoidable curved path it will take. I decided to search for a precise equation for the number of degrees you would have to rotate your fist to role a Rolo to someone X meters away from you.

“You can roll a rolo to a friend!”

Chemistry is a beautiful subject. The study of atomic interactions is fascinating, but the real beauty is in the mathematical bit. Specifically, I speak of stoichiometry, the wonderful subject of converting from one unit to another. It is amazing how much you can gleam from this simple concept. For instance, let us take this everyday equation:

2 Bread + 1 Cheese → 1 Sandwich

Albeit this is not what you normally see in chemistry, but it is a really great example that I have been taught. Now, in the pantry you have 14 pieces of bread and 8 pieces of cheese. The question is, which one of these ingredients limits how many sandwiches you can make. In chemistry, this value is known as the “limiting reactant” or the “limiting reagent.”

This is really simple to discover just by simple conversion (stoichiometry) and comparison. First, we must find how many sandwiches we could make from the bread if we had unlimited cheese:

(14 Bread) × (1 Sandwich ÷ 2 Bread) = 7 Sandwiches

Grilled Cheese! =D

Next, we do the same thing with limited cheese and unlimited bread:

(8 Cheese) × (1 Sandwich ÷ 1 Cheese) = 8 Sandwiches

As you can see, 14 Bread only gives us 7 Sandwiches, while 8 Cheese gives us 8 Sandwiches. Therefore, since our resources are limited this way, we can only make 7 Sandwiches, and therefore Bread is the limiting reagent.

Fascinating, is it not? Now, let us take a simple example using an actual chemical equation:

H₂ + O₂ → H₂O

Wait, but there is a problem. If you look carefully, the first half of the equation has two hydrogen atoms and two oxygen atoms, but the second half has two hydrogen atoms and only one oxygen atom! This means that we have to balance the equation by prefixing the molecules (note: not the individual atoms) with a coefficient to make everything equal.

2H₂ + O₂ → 2H₂O

There, now the amount of atoms is equal on both sides. Given 50 moles of hydrogen and 100 grams of oxygen, we must find the limiting reagent. The problem here is that we are given oxygen in grams, but limiting reagents in chemistry require everything to be in moles. The “mole” corresponds to approximately 6.022 × 10²³ entities (in this case, molecules). The equation above could be read as “Two moles of dihydrogen plus one mole of dioxygen reacts to form two moles of water.”

To convert from grams to moles, me must first remember that moles are specific to the molecule they are linked with. In the case of hydrogen, there are 50 mol H₂ (moles of dihydrogen). This is not the same as 50 mol O₂ (moles of dioxygen). Given this, to convert from grams of a molecule to moles, you must divide the amount of grams by the molar mass of the molecule. The molar mass (measured in g/mol or “grams per mole”) is found by adding the molar mass of its atoms (given on the periodic table). In this case, the molar mass of oxygen is approximately 2 × 16 g/mol, giving dioxygen a mass of 32 g/mol. Hence,

100 g O₂ ÷ 32 g/mol = 3.125 mol O₂

Now, we can apply the bread-and-cheese!

50 mol H₂ × (2 mol H₂O ÷ 2 mol H₂) = 50 mol H₂O

3.125 mol O₂ × (2 mol H₂O ÷ 1 mol O₂) = 6.25 mol H₂O

Thus, we have discovered that oxygen is the limiting reagent. The difference is so large because one oxygen atom is about sixteen times the size of a hydrogen atom. For example, if you had a tank, you could fit sixteen times more hydrogen atoms than oxygen atoms into it.

I was going to end this post with the text “Voila! Simple, is it not?” but then I remembered that the first time I saw this I had a mental heart attack. Instead, I say good luck!

I added a new shortcode that allows you to embed Pizazz into your posts and pages, which will allow you to make store pages and advertise your products where they’re relevant. Are you blogging about asparagus? Then why not embed a Pizazz product feed with a bunch of asparagus T-shifts and mugs? Just type in [pizazz store=asparagus rows=8 columns=3] into your post and you’re ready to go! For the full documentation on Pizazz’s shortcodes, go to Settings->Pizazz and scroll down.

There is also a few more customizations. You can now change the alignment of text or just make it disappear and links can be made to open in new windows and the prices can be displayed right next to your products! This should give you a bit more flexibility while designing your website.

Lastly, the associate ID used to get referrals has been moved from the widget properties into Settings->Pizazz. I was worried that people would have to copy and paste their ID into all of their shortcodes and it would become too difficult to maintain. A dialog box will appear at the top of your administrative control panel after the update to remind you, so don’t fret!

The new release is up at the WordPress plugin repository. I recommend you update and check out these cool new features. Tell me what you think in the comments below and if you need help, check out the support area at WordPress!

TinyBASIC is a simple microcontroller language from back in the days where 4K was a normal amount of RAM. It was popular because it could fit in 3K and still run your reasonably useful programs. It looks like this:


REM FIBONACCI SEQUENCE GENERATOR
REM RELEASED INTO THE PUBLIC DOMAIN

REM SETUP THE VARIABLES — COUNTER, CURRENT VALUE AND LAST VALUE
10 LET I = 0
20 LET X = 1
30 LET Y = 0

REM DISPLAY THE CURRENT ITERATION AND VALUE
40 PRINT “FIB: “; I, X

REM ADD THE LAST VALUE TO THE CURRENT VALUE WHILE SAVING THE CURRENT VALUE
REM AS THE NEW LAST VALUE
50 LET Z = X
60 LET X = X + Y
70 LET Y = Z

REM INCREMENTING THE ITERATOR AND ABORTING WHEN IT’S TIME
80 LET I = I + 1
90 IF I <= 10 GOTO 40

Pretty neat, eh? It’s actually pretty easy to parse when you get in the hang of things. I read the first few chapters in Jack Crenshaw’s tutorial on compilers, Let’s Build a Compiler to get a basic expression parser running and did the rest on my own. Now, that code above compiles and runs perfectly!

The most important thing I learned from this, after all my previous attempts at writing compilers, is that parser generators are time-wasters from the depths of hell. It takes me three hours to set up something that looks like it might parse the code — not compile, but parse — that throws constant errors while I got a few working statements from my hand-written compiler in one.

The resulting code is much cleaner, too, because you don’t have a parser generator putting in tons of impossible-to-read tables and includes that it shouldn’t even need (Bison WTF is wrong with you?). LALR parsers, from what I understand, are the primary output of most of these parser generators. They seem to have a reputation for being almost unreadable and unwritable by human beings, and I have yet to find an upside to them other than that they are memory-efficient compared to some of the alternative results of parser generators. At the same time, I only use a few global integers in my compiler, and the code is smaller… especially considering that the compiler includes both a scanner and parser in the same code set.

I also found that writing the compiler by hand was much more enjoyable as immediate results were faster to procure and having full control and responsibility for the code felt more challenging. Considering I’m primarily a hobbyist, challenge is one of the most important parts of anything I do.

I targeted MS-DOS/FreeDOS because it has what is quite possibly the cleanest and simplest system call table that I’ve ever encountered (in other words, it was really easy to target). I used DosBox to emulate the MS-DOS kernel on my GNU/Linux machine. By request of a friend of mine, I tested my compiler on Windows and found that the resulting executables ran natively. Now that’s backwards compatibility!

All in all the project was pretty fun and the result was a neat little toy. This new skill should come in handy when it comes time to implement scripting into one of my game projects. Lua is for babies!

The source code is available online under the GNU General Public License version 3 or later. Leave a note in the comments if it helps you figure out how compilers work! If you are really interested in writing your own compiler, I highly recommend Jack Crenshaw’s tutorial. It’s very helpful and spans over topics from expression parsing to interpreters.

• TinyBASIC-C at GitHub
• Let’s Build a Compiler
• More on TinyBASIC
• NASM/YASM (required to build the results of Tiny BASIC all the way to binary format)
• DosBox (for people who want to try out the compiler on GNU/Linux)
• Wikipedia Entry on LALR Parsers

Stay tuned: I’m doing some finishing touches on a new release of Pizazz and have been doing some behind-the-scenes work on CANINE!

The first thing I wanted to deal with is that the thumbnail-size property stopped working. Previously, I had used PHP’s str_replace function to change “_125.jpg” to “_theCustomThumbnailSize.jpg”. As it turns out, Zazzle automatically generates the images based on the last number in the filename, hence I was able to implement this nice little feature. However, for some incomprehensible reason Zazzle changed the default number to 152. I’m pretty sure that’s a typo, because the five and two have been switched and that’s it. Generally this would be dangerous for everybody who relies on this default size to use the feed in any of their products.

The fix for this is pretty simple, but I had to fix something else, first. I installed Pizazz on my fresh, new test server and it didn’t work. At all, or at least at all by default. If you chose the lucky tags then it would work perfectly. After awhile I figured out what was wrong: the RSS feed was broken (or, better put, malformed). The titles of the products in some areas contained ampersands (“&”). Normally this is fine, except that they were just ampersands. Under XML (from which RSS derives), the ampersand has a special meaning. It is used to identify special characters; for instance, “&gt;” indicates the greater-than sign (“>”). So, an ampersand on its own is erroneous, and should actually be “&amp;”. Sadly, the XML parser I was using — SimpleXML — isn’t forgiving, and would abort on such lines. Most XML parsers break on these types of things, even Internet Explorer failed to read these feeds (though that browser fails on a lot of things). However, since Pizazz was made for Zazzle, and Zazzle always does things like this, SimpleXML had to go.

I rewrote the parser to use PCRE — Perl-Compatible Regular Expressions — to extract data from the text file without parsing it as true XML. So instead of running the XML parser and pulling out the data from a specialized PHP data structure, I just asked PHP to give me the text in between each “<item>” and “</item>”, then from there pull out the title from “<title><![CDATA[" and "]]></title>”, etc. This also removed the need for a number of verifiers that I wrote in to handle when Zazzle only produces bad RSS every-other request (that happens sometimes). In combination, this results in faster feed-caching and much more forgiving RSS parsing. The number of times that Pizazz abruptly fails due to XML parsing errors has been greatly reduced if not eliminated. Even when Zazzle returns its home page surrounding the RSS data the proper fields can still be extracted!

Great, now I could get back to the bug that I initially wanted to fix: the thumbnail sizer. Well, I could have just changed the parameter for str_replace from 125 to 152, but I’m absolutely sure that Zazzle will change this number again and I’ll have to change that again. So, instead, I just got PCRE to replace “_anyNumberAtAll.jpg” with what I want. That fixed it for now, and should prevent anything like this from happening again.

Then I got a bug report from one of my clients using multisite. Specifically, Pizazz didn’t work on multisite (well, it sort of did). Before, she activated Pizazz on each sub-blog individually, which circumvented the problem where “Network Activate” would crash WordPress’s network dashboard with a E500 Internal Server Error. I was going to fix Network Activate but, considering that there was a way around it and I had other stuff on my mind, I deprioratized it and ended up forgetting about it. Well, she got around to enabling it on the main site, and ended up breaking the network dashboard again. There was no way around this one, so I had to go working on it.

During the first day I successfully fixed the undefined-function error PHP was spewing out by moving Pizazz’s initialization code into a WordPress init-hook, as I technically should have from the beginning. This resulted in a different error: “function get_current_screen is not defined in /…/wp-admin/network/settings.php.”

This one took me 36-hours to debug. I painstakingly scoured the blogs, the WordPress codex, the forums, anywhere Google would take me and never found anything that would solve my problem. Worse off, PHP doesn’t give tracebacks unless you install a debugging plugin, which wasn’t a viable option. I kept on trying new things, including rewriting the settings page entirely. Albeit, the rewrite resulted in a cleaner script and moved the settings into their own page, which was nice, but it was (is) still frustrating.

I ended going onto my client’s server and just putting in a bunch of die calls throughout the source code, trying to pinpoint where everything went wrong. I knew it was in settings.php, and the die calls didn’t help any further. That error kept cropping up in the network dashboard, and I couldn’t figure it out!

Finally, I commented out the code that loaded settings.php because I just wanted to remember what the network dashboard looked like. Then, carelessly, I hovered over and past the Network Settings tab. I froze, then moved my mouse back. I noticed that the Network Settings didn’t have any plugin fields listed. I looked back at the main site dashboard and hovered over the settings there and saw the plugins again. I un-commented the lines that loaded settings.php and looked back. The network dashboard stopped working, but the settings field worked perfectly in the main site dashboard. I wanted to scream.

You can’t register options pages in the network dashboard! As opposed to WordPress raising an error when this was attempted, it prevented the function from being created in the assumption that plugin developers would know what the “undefined function” error meant. They don’t say that you can’t define option tables ANYWHERE in the documentation! I checked, it isn’t there. No wonder so many plugins don’t work in multisite, they don’t document these incompatibilities! All I had to do was change ( is_admin() ) to ( is_admin() and ( ! is_network_admin() ) ) and it worked again. Who the hell manages the codex!

There was much internal screeching, pacing and (for some unhealthy reason) eating that came afterwards. This has to be one of the most frustrating things I have ever had to deal with. One line, one problem that I wouldn’t have had if they had just documented it!

Eh…anyway, here’s the new plugin. All these bugs have been fixed and there are some minor code clean-ups. I don’t remember at which point it was but I rewrote the cache manager to use opendir instead of glob when iterating through the files, because for some reason glob doesn’t always work when opendir does, so that should help any users who had or would of had a problem with this.

Now, I’m going to play with writing a little TinyBASIC compiler to cool off, and when I’m back to Pizazz I’ll implement shortcodes to embed Pizazz product inventories into your posts and pages. Keep tuning in!

Pizazz is available here.

Since I’ve been away for so long, some cob webs have cropped up. CANINE is still just a basic little rendering engine (still entertains me, though!) and Pizazz has some bugs due to incompatibilities with a slight (SLIGHT!) change in the Zazzle RSS feed. Also, I should give Secret Maryo Chronicles some love…that game helped me get through a week of nothing-to-do (or a month? I can’t remember…) and I want to ensure its continued development. So, here’s my game plan:

1. Fix the bug in Pizazz where image resizing stopped working. Make a hotfix release.
2. See if I can get my secret TinyBASIC compiler to a little more than just tokenize source code.
3. Add in a way to embed Zazzle product feeds into WordPress pages with Pizazz via shortcodes. [pizazz-listing query=asparagus store=HolidayBug]
4. Hack on the secret platformer I’ve been working a bit on with a new friend of mine.
5. Get some basic scripting going in CANINE so we can get some interactivity out of the billboards. (Exploding barrels here I come! Later.)
6. Add in a script editor to Secret Maryo Chronicles to help out Quintus’s new scripting subsystem.
7. Hack a bit more on CANINE to get some bullets and enemies going.
8. Get that TinyBASIC compiler I mentioned to output something that I can compile with Netwide Assembler (hence marking my first successful attempt at a compiler).
9. Work a bit on that beat-em-up I made some mock-up-graphics for.

I’m going to try and stick to this as much as possible, only diluting it with Team Fortress 2. (Why must I have friends to play Mann vs. Machine? I don’t have enough! I don’t need Valve’s social pressure. >:[) If anybody gives me compelling reason, though, this order may be subject to change. It has to be really compelling, though.

Thanks to anybody who’s still interested in my projects,

- Luiji Maryo