briancarper.net (λ) (Tag: Gaming)

Making an RPG in Clojure (part one of many?)

Sat, 20 Feb 2010 16:27:40 -0800

What do you get when you combine old-school Final Fantasy-style RPGs with Clojure? Fun times for all. Well, for me at least.

I'm working on a sort of RPG engine in Clojure so I can make my own RPG. Click the thumbnail for a very preliminary video demo (6.5 MB) showing the engine in action.

All I do in the video is walk around, and eventually start adding random NPCs to the map to test collision detection. Not all that exciting, but I'm proud nonetheless.

To forestall questions, yes I'll eventually post the source code, but no, not yet. It barely works. Just a proof of concept so far.

Right now I can walk around a map while NPCs also randomly walk around the map, not much more. So there isn't much to talk about. But not bad for 4 days and 600 lines of code (one tenth of which is ASCII art... more on that later). Keep in mind that I have no idea what I'm doing.

Collision detection works so people don't walk through walls or each other, and after endless tweaking I got all the animations to be very smooth, even when I add a few dozen NPCs to the map (as I do in the video). The video is a bit jerky but it looks better in person. All of the admittedly poor artwork is also created by myself, thanks to the GIMP and some hastily-read tutorials on pixel art.

It all runs on plain old Swing in Clojure. Here's some of what went right and what went wrong so far.

Background

I've played a lot of RPGs, but I've never programmed a game more complex than Pong. I knew what double-buffering is, and that's as far as my knowledge of game programming went when I started.

My first idea was to use a plain old Swing JFrame. I'd make a bunch of sprites saved as PNG files, read them all in and draw them on the JFrame, as many times per second as I could manage. Then there's some global state to keep track of where everything is. Simple enough.

(PS I have no idea what I'm doing.)

Failures

My first version used Clojure agents (i.e. threads) for everything. The game logic was a thread, the renderer ran in a thread, every NPC was its own thread. The world itself was a single ref that all of these agents banged on. So the NPCs would tell the ref "I want to move down one square", another thread might say "Brian just pushed 'left' on the keyboard, so start scrolling the map". The world-ref would kindly oblige while preventing two NPCs from standing on each other or letting the PC walk through the walls.

Clojure is awesome in letting you do this in a completely safe and coordinated way. Everything worked well. But even for the crappy 2D graphics I'm using, all those threads caused way too much lag. I could get a good framerate if everyone was standing still, but if I was walking while the NPCs were walking, I'd get lots of lag. It was even worse on a slower computer.

My best guess is that the reason for the lag was the constant restarting of canceled transactions due to multiple threads trying to edit the world ref 50+ times per second. My sucky 2-core CPU couldn't keep up. It isn't surprising that this failed, in hindsight.

OpenGL?

Next, I decided to try out OpenGL. There are multiple options for OpenGL in Java. One is JOGL and another is lwjgl.

I program in Linux, and my video card is ancient. I can barely get OpenGL to work in the best of times. Installing JOGL was a slight chore (Gentoo doesn't even include it in its repo). JOGL is not just a JAR you throw onto CLASSPATH, you need some native extensions, obviously. I got it running somehow, but I wouldn't want to explain to someone else how I did it.

I did get jwjgl to work too, eventually, which was nice. There is a really nice Java 2D game framework called Slick which uses lwjgl. Some good games were created using this, for example Stickvania, which recently hit Reddit recently. I got Slick up and running in short order.

Unfortunately Slick doesn't play nicely with a Clojure REPL. I could build and start a game, but once the game is stopped, it never runs properly again without restarting the REPL. Slick caches images to try to be speedy, and it seems like the cache is either corrupted or destroyed when you close down your game, for one thing. This is not conducive to Clojure REPL-style development, and I didn't want to spend a lot of time fixing it.

Another issue is that I'd really like this game to be cross-platform and available to non-hackers, and the thought of trying to tell the average gamer how to install JOGL or lwjgl was daunting, given the bullcrap I had to go through. Not sure if I can just throw JOGL into a JAR and distribute it, maybe I can, but I didn't want to bother reading about it. Swing on the other hand runs everywhere with no effort.

My main problem is that I know even less about OpenGL programming than I do about Swing, and don't have a month to learn. Back to the drawing board.

Success

It turns out I don't need OpenGL anyways. All I need is program more intelligently. (Did I mention I have no idea what I'm doing?) Instead of dozens of threads, my current (working) version has one thread. It updates the game logic, then renders the game, then waits 10 milliseconds or so, then repeats this (forever).

With the single-threaded version, the logic is actually more complex than the multi-threaded version. Agents and refs were really nice and braindead-easy to work with. But such is life.

Once I learned about keeping track of things in realtime by counting milliseconds instead of counting frames or using timeouts to do logic/render updates, things worked better. (Did I mention I have no idea what I'm doing?) The game loop looks like this now:

(defn game-loop [#^Canvas canvas]
  (loop [last-time (get-time)]
    (let [curr-time (get-time)
          delta (- curr-time last-time)]
      (do-logic delta)
      (do-render canvas)
      (when @RUNNING
        (Thread/sleep 10)
        (recur curr-time)))))

The code to actually start the game, to give you an idea:

(defn start-world [world]
  (let [#^JFrame frame (doto (JFrame. "Game")
                         (.addWindowListener (proxy [WindowAdapter] []
                                               (windowClosing [e] (stop)))))
        #^JPanel panel (doto (.getContentPane frame)
                         (.setPreferredSize (Dimension. REAL-WIDTH REAL-HEIGHT))
                         (.setLayout nil))
        #^Canvas canvas (Canvas.)]
    (doto canvas
      (.setBounds 0 0 REAL-WIDTH REAL-HEIGHT)
      (.setIgnoreRepaint true)
      (.addKeyListener (proxy [KeyAdapter] []
                         (keyPressed [e] (handle-keypress e))))
      (.addMouseListener (proxy [MouseAdapter] []
                           (mouseClicked [e] (handle-mouse e))))
      )
    (.add panel canvas)
    (doto frame
      (.pack)
      (.setResizable false)
      (.setVisible true))
    (.createBufferStrategy canvas 2)
    (dosync (ref-set RUNNING true)
            (ref-set PAINTER (agent canvas))
            (ref-set WORLD world))
    (send-off @PAINTER game-loop)))

That's about it for the Swing side of things, aside from scribbling on the Canvas in the render function.

The agent I wrap around the Canvas controls the thread that runs the game loop. The agent helpfully keeps track of any exceptions that happen during the loop, and I can view those exceptions via agent-error, which is handy for debugging.

Note how little code it is to set up a keyboard event handler, thanks to proxy:

    (doto canvas
      ...
      (.addKeyListener (proxy [KeyAdapter] []
                         (keyPressed [e] (handle-keypress e))))

A couple lines of Clojure for what would be a lot of senseless boilerplate in Java. Notice how you the keyboard handler calls a normal Clojure function handle-keypress. Clojure / Java interop really is seamless.

Maps

My maps are made using ASCII art. (Did I mention I have no id-... never mind.) Here's the code for the test map, for example. Map here is a deftype (available in bleeding-edge Clojure), which takes a map of tiles, a "pad" tile, the map, and then a mask showing walls / tiles where the player shouldn't be allowed to walk. My Map type acts like a Clojure hash-map most of the time, but it also lets me name the fields that all maps should share, and has a proper "type", among other things.

(deftype Map [tileset pad tiles walls]
  clojure.lang.IPersistentMap)

(def test-map (cache-map
               (Map {\  (tile "ground")
                     \/ (tile "ground-shadow-botright")
                     \< (tile "ground-shadow-left")
                     \d (tile "dirt")
                     \| (tile "wall_vertical")
                     \- (tile "wall_horizontal")
                     \1 (tile "wall_topleft")
                     \2 (tile "wall_topright")
                     \3 (tile "wall_bottomleft")
                     \4 (tile "wall_bottomright")
                     \u (tile "below-wall")
                     \v (tile "below-wall-shadow")
                     \w (tile "wood-floor")
                     \c (tile "cobble")
                     \b (tile "bush")}

                    (tile "ground")

                    ["                 1----2                            "
                     "                 |vuuu|                            "
                     "1----------------4<bbb3--------------------------2 "
                     "|vuuuuuuuuuuuuuuuu/   uuuuuuuuuuuuuuuuuuuuuuuuuuu|<"
                     "|<1------------2               cccccccc d        |<"
                     "|<|vuuuuuuuuuuu|<       d      c      c          |<"
                     "|<|<           |< cccccccccccccc    d ccccccc d  |<"
                     "|<3------ -----4< c                         ccccc|<"
                     "|<uuuuuuu/uuuuuu/ c  1-------2    1------------2 |<"
                     "|<1---2 bcb       c  |vuuuuuu|<   |vuuuuuuuuuuu|<|<"
                     "|<|vuu|< c  d     c  |< 1-- -4<   |<           |<|<"
                     "|<3- -4<bcb       c  |< |vucuu/   3------ -----4<|<"
                     "|<uu/uu/ c        c  3--4< c      uuuuuuu/uuuuuu/|<"
                     "|<  c  dbcb       c  uuuu/ cccc         bcb      |<"
                     "|<  cccccccccccccccccccccccc  cccccccc   c   d   |<"
                     "|<  d        d                     d ccccc       |<"
                     "|<                    1--------------------------4<"
                     "3---------------------4uuuuuuuuuuuuuuuuuuuuuuuuuuu/"
                     "uuuuuuuuuuuuuuuuuuuuuuu/                           "]

                    ["                 xxxxxx                            "
                     "                 x    x                            "
                     "xxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx "
                     "x                                                x "
                     "x xxxxxxxxxxxxxx                                 x "
                     "x x            x                                 x "
                     "x x            x                                 x "
                     "x xxxxxxx xxxxxx                                 x "
                     "x                    xxxxxxxxx    xxxxxxxxxxxxxx x "
                     "x xxxxx x x          x       x    x            x x "
                     "x x   x              x  xxx xx    x            x x "
                     "x xx xx x x          x  x         xxxxxxx xxxxxx x "
                     "x                    xxxx                        x "
                     "x       x x                             x x      x "
                     "x                                                x "
                     "x                                                x "
                     "x                     xxxxxxxxxxxxxxxxxxxxxxxxxxxx "
                     "xxxxxxxxxxxxxxxxxxxxxxx                            "]
                    )))

This lets me make all of my tiles be simple PNG files with sane names. I could dork around with sprite sheets, but why bother? Emacs or Vim column-editing and overwrite modes make it easy enough to make a map this way. Swing thankfully handles transparency for me if I use PNGs, so it's a no-brainer to make multiple map layers later, which I'll need later. The code for reading in PNGs is brain-dead simple thanks to Java's ImageIO:

(defn tile [name]
  (ImageIO/read (File. (str "img/" name ".png"))))

The cache-map function (below) iterates over the ASCII art (via seqs on the Strings), using each character as a key into the map of real images, and builds a BufferedImage out of it. This is cached, since the renderer needs to re-draw the background every frame. In this function I'm also drawing a "padding" layer to sit under the background, so that I see endless fields of grass when I walk close to the edge of the map, instead of garbled, smeared-out graphical artifacts.

(defn cache-map [amap]
  (let [height (count (:tiles amap))
        width (count (first (:tiles amap)))

        #^BufferedImage img (BufferedImage. (tile-to-real width) (tile-to-real height) BufferedImage/TYPE_INT_ARGB)
        #^Graphics2D g (.createGraphics img)

        #^BufferedImage pad (BufferedImage. (tile-to-real width) (tile-to-real height) BufferedImage/TYPE_INT_ARGB)
        #^Graphics2D padg (.createGraphics pad)]
    (doseq [[y row] (cseq/indexed (:tiles amap))
            [x tile] (cseq/indexed row)]
      (.drawImage padg (:pad amap) (tile-to-real x) (tile-to-real y) REAL-TILE-SIZE REAL-TILE-SIZE nil)
      (if-let [#^Image img ((:tileset amap) tile)]
        (.drawImage g img (tile-to-real x) (tile-to-real y) REAL-TILE-SIZE REAL-TILE-SIZE nil)
        (throw (Exception. (str "Missing tile " tile ".")))))
    (assoc amap
      :map-image img
      :pad-image pad
      :max-map-x width
      :max-map-y height)))

This code is nasty, mostly due to converting between tile-based coordinates and pixel-based coordinates. This code needs to be cleaned up a bit. But that's about the most complex code you'll find in my program so far.

Who needs mutable state?

Clojure is a mostly functional language, in the sense of strongly discouraging unnecessary use of mutable state, and this program is no different. I'm sometimes amazed how far I can get before I need mutable state at all. The vast majority of my functions take a world value (a plain old hash-map) as an argument, and return a new world value after making changes to it. The current state of the world is whatever value is currently in the global WORLD ref.

The render loop grabs a snapshot of the world from the ref on each iteration, and then draws it. Thanks to Clojure refs, the snapshot of the world is guaranteed to be consistent (e.g. no NPC objects in the middle of mutating themselves) and persistent (the world value sticks around as long as the renderer needs it, even if the WORLD ref is changing in another thread). Once it's been drawn, the renderer throws the world snapshot away and it's garbage-collected later.

This all happens around 50-100 times per second in my game, and there's no noticeable lag. So that's a good thing.

Conclusion

That's about it. I'll post the full source code once it doesn't suck as much.

In my opinion, exploring a new area of study is some of the best fun a person can have. It's a flood of information and a surprise every 10 seconds.

Making a game has been like that. There's a huge wealth of knowledge about this kind of programming that I never knew existed. Everything I read on this topic is new to me and fascinating. The saddest(?) part of this whole thing is that I'm going to have more fun programming this game than I usually have playing games I buy in the store.

Spriting and learning

Mon, 07 Sep 2009 13:57:09 -0700

In the mid-1990's I was really into Nintendo games, as was everyone. My favorite was the original NES Final Fantasy. Sometime in my teens I got my first computer, and I decided it would be cool if I had some sprites of that game on my computer.

Before

My first computer ran at 640x480 with 16 colors. I had Windows 3.1 and the most sophisticated image manipulation program around was MS Paint. How could I get sprites into my computer? Well, I had a strategy guide for the game, with blurry photos of all of the enemies, so I just opened up MS Paint, zoomed waaaaaaaay in, and drew all of the sprites pixel-by-pixel. Insane? Maybe, but it's a fun kind of insane.

This took about a year of off-and-on work, but in the end I had something I thought was great. I still have the file:

Note that my computer couldn't even produce sophisticated colors like "orange" and "brown", so I had to tile red and yellow together so it looks orange from a distance. Oh how computers have progressed since then.

At this point I loved computers but I literally didn't even know what programming was. I had never heard of the internet. I didn't even get a taste of programming until high school.

In 1999 I was in college but still largely ignorant of programming. I decided to start my first website, which was about the NES Final Fantasy that I still liked. I decided to put some sprites on the site. For the first version I chopped up my old image file from above into individual sprite files, but the quality of these was terrible.

So the way I got good sprites was by taking screen-captures of the game in an NES emulator, then in Paint Shop Pro I cropped out the backgrounds. This was much faster than hand-drawing, but it still took months.

This is an example of using a thousand-dollar piece of equipment as a hammer to pound in a nail. It's the most rudimentary form of computer use. It's the kind of thing I cringe at when I see coworkers do it today.

After

Last weekend, many years older and hopefully a tiny bit wiser, I pulled out my copy of the most recent remake of FF1, for the PSP. I decided it'd be cool if I could rip some sprites from this.

So, first I got an ISO of the game and mounted it loopback so I could view the files. In the ISO there's a 100MB BPK file. I didn't know what this is so I opened it in a hex editor and saw that it was some kind of archive. You could clearly see an initial list of filenames with byte offsets and some other flags for each, then a bunch of binary data.

A few google searches later and I found this where someone else had the same idea as I did. There's an extraction script there in some language I don't know, but it wasn't hard to figure out what it was doing.

So then I was going to write a script to extract the BPK but thankfully someone in Japan already did which saved me the trouble of even doing that. Some of the extracted files were themselves archives, but after running the script on its own output a few times I had a bunch of GIM files.

What's a GIM file? Never heard of it. But a quick google search for "GIM to BMP" will net you a program called gimconv. Sadly it's Windows-only, but a batch file or two later and I had a bunch of BMPs like this:

These files have solid backgrounds, but I want transparent backgrounds. But it isn't hard to make an image's background transparent in Linux using ImageMagick and its nice documentation. One snag is that all the images have different background colors, but I can tell ImageMagick to use the color of the top-left pixel as the transparency color:

for f in *.bmp; do convert -matte -fill none -draw 'color 0,0 replace' $f ${f/bmp/png}; done

Some of these images look like sprite sheets. So let's pick one, chop the sprites into individual files, then make an animated .gif from these sprites (while also adding a transparent border around it).

convert KURO.png -crop 32x32 +repage KURO%d.gif
convert -matte -bordercolor none -border 28 -compose Copy KURO?.gif -delay 25 -dispose Background KURO.gif

Giving us:

So after a matter of 2-3 hours (most of which was puzzling over some hex data and then googling around), I am already pretty much done. Barely any skill on my part required other than knowing what to look for.

The moral of this story is:

The internet is awesome. It's easy to forget how much better life is with so much knowledge at our fingertips. I can't even remember what it was like without the internet and I'd never want to go back to that.
Learning is fun. What was a year-long job became a few-minutes job with even a rudimentary knowledge of scripting.
ImageMagick is pretty handy.
Old school games are great. FF1 is still fun after 20 years. They keep re-making it for new systems for a good reason.
I got a late start in programming. I wish I would've started at a younger age. Think of how much more I could've accomplished with my time. I'm still playing catch-up in many ways.
Sitting here in front of 3840x1200 pixels worth of million-color monitor screen, typing a story people are going to read in a few minutes in countries I'll never visit, ripping sprites from a portable game device that's probably thousands of times faster than my old NES, I can't even imagine what we're going to be doing with computers in another 15 years.

Stylus DIY, hand health

Sun, 01 Feb 2009 14:39:52 -0800

The stylus that comes with a Nintendo DS is a very mild form of hand torture. Not sure whose hands those were designed for, but not mine. In googling for a good replacement, I chanced upon a blog post which suggests finding a nice big ballpoint pen and jamming a DS stylus inside so just the tip sticks out. This works amazingly well. It's not as portable, but I will make that sacrifice to prevent being crippled.

I am in fact always a bit worried about preserving the health of my hands. I have no hard data to support this, but I suspect my generation may have major hand-related problems in the coming decades. What with computer keyboards and tiny cell-phone and PDA keys and lots of other techy things. Many of us use our hands to communicate almost as much as our voices. Until we have Star Trek voice-recognition software, this will be a problem.

I started experiencing a lot of aches and pains in my hands and wrists a decade or so ago, and I attributed it to computer use. Since I started paying more attention, things are better. I maintain a very comfortable typing position for my hands. I have a nice big comfortable mouse. And so on. My hands don't hurt any longer nowadays, which is nice. If I become unable to type someday, I'm completely screwed. How can I work as a programmer if I can't input text into a computer? And I won't be able to draw or do origami or play video games or do many other things I enjoy.

OpenVPN in Gentoo in 15 minutes

Sat, 08 Sep 2007 08:58:12 -0700

Situation: You have two computers at different locations. One of them is behind a very restrictive firewall that doesn't permit any incoming connections, and may be running Windows (ugh). The other is running Gentoo and is more permissive.

Problem: You want to play a game on these two computers, like ZSNES, which requires both machines to accept a connection on some port. ZSNES ideally uses UDP protocol for this. Or, you want to play some game that requires connections on multiple ports. For these or some other reason, an SSH tunnel isn't practical. So you must defeat the firewall.

Concerns: There are only two computers involved and no chance of more than two ever being involved. You don't care about encryption; if someone wants to snoop your Final Fantasy 6 traffic, so be it. You want to get something up and running in 15 minutes. You want something that is fast and easy to use from that point forward. You need something that works in Windows.

Solution: OpenVPN works really well for this. If you don't care about encryption and such, this "static" HOWTO is very effective at getting something working quickly. Gentoo can also help a lot in this regard, via some nice wiki entries on Gentoo-Wiki.

Anyways, this is how I did it:

Make sure Universal TUN/TAP device driver support is enabled in your kernel for any Linux machines involved. (If you don't already have this included in your kernel, I guess there goes your 15 minutes right there. Oops!)
Have the client install OpenVPN on their computer. (For Windows, download here.)

On the server machine, run:

emerge openvpn
cd /etc/openvpn
openvpn --genkey --secret static.key

Edit /etc/openvpn/openvpn.conf and put this in it:

dev tun
ifconfig 10.8.0.1 10.8.0.2
secret static.key

Edit client.ovpn and put this in it (filling in your proper server IP address or domain):
```
remote SERVER.IP.ADDRESS
dev tun
ifconfig 10.8.0.2 10.8.0.1
secret static.key
```
Send client.ovpn and static.key to the client by whatever means necessary. You should also keep a copy of static.key in /etc/openvpn on the server. You can get rid of client.ovpn on the server machine.
Start up the server:
```
/etc/init.d/openvpn start
```

That's it, you should now be able to fire up any program and point to 10.8.0.2 to access the client from the server, or 10.8.0.1 to access the server from the client, any port, TCP or UDP protocol.

If you really care about encryption or security, there are much better ways of doing this using real public/private key sharing. It may be worth taking the extra half hour or so to set up OpenVPN the right way depending on your needs.

pSX

Sat, 25 Aug 2007 16:54:19 -0700

I found a need to install a Playstation emulator today, and recalling the minor nightmare installing ePSXe always turns out to be, I searched the Gentoo forums. There's a (somewhat) new emulator called pSX which works really amazingly well. No need to hunt down video/audio/CD-ROM plugins, thank God. It just works. The source code appears to be sadly unavailable so it'll be a binary install only. If you need to install it in Gentoo, it depends on dev-cpp/gtkglextmm and x11-libs/gtkglext.

That's better

Fri, 20 Jul 2007 18:05:14 -0700

This is why I like Gentoo. I installed ZSNES and I got version 1.51 from the Portage tree, but that version doesn't have netplay. The version I want was some funky 1.42n version somebody wrote with netplay built in. It took me all of five minutes to write an ebuild based on the build in the Portage tree and mask the later versions and install what I wanted. In Ubuntu I'd have been back to ./configure && make && sudo make install and it probably would've bombed due to missing libraries.

Lots of chatter on blogs lately about Gentoo management problems. As usual, I guess. Something I've been guilty of in the past myself is ignoring all the good and focusing on the bad. It's somehow easy to install 1000 packages and focus on the one that fails and respond with "Holy crap Gentoo is broken, stupid lazy devs". It's easy to see one offhand comment from a dev on a mailing list that may be very vaguely insulting to someone if read in a certain way and conclude that Gentoo devs as a group hate non-dev users and think they're scum. (How can a one-paragraph email spawn a five-page forums thread?) I'm making a concerted effort to ignore all of this crap as much as possible.

There's so much good here if you open your eyes to it. Sure some things don't work sometimes, but so many things do work so much of the time and it's easy to lose sight of those. This is one reason I think it's important to make some noise when things DO work sometimes, even if it seems redundant. Just to keep perspective.

PHP design patterns?

Tue, 23 Jan 2007 18:44:48 -0800

As one of my professors used to say, "There's no problem that can't be solved by adding another layer of abstraction". He was joking, but there's a little bit of truth to that.

I've been working on my other website for a while. It's all PHP4, not entirely by my choice but I'm limited what can be installed on my server. PHP4 turned out to be a lot more powerful than I'd initially thought. Namely the OOP options available are mostly adequate and in a few places surprisingly OK. PHP has some nice meta-programming sorts of functions like get_func_args() and call_user_func() which let you play around with doing weird things dynamically at runtime, which were almost essential in putting all this crap together. It lacks the completeness or elegance of Ruby, and PHP's syntax is generally horrific and painful, but it'll do.

I recently read Head First Design Patterns which is quite a good book. I was able to use plenty of what I learned there in designing a sort of templating system for my other website. Basically I have tons and tons of tables of different sorts of data. CSS goes a long way to making the presentation of the tables easy to change given that they are properly marked-up, but actually marking them up properly and consistently was the problem.

So I put together a bunch of classes that generate HTML tables. One of the things from Design Patterns that really makes sense when you hear it is to lean toward composition rather than inheritance. In other words, an object that has another object as an instance variable is often easier to deal with than an object that inherits the same functionality from a parent class; the reason being that you can use polymorphism to your advantage, and have your object contain a member of a GENERIC type, and then you can give your object an object of any subtype of that generic type you want. So your class then does not depend on the type of its instance variable at all, so long as all possible objects that end up in that variable have the same interface. Loose coupling and all that.

I have used this to great advantage in adding flexibility in marking up table cells. A cell will be a different class (actually a different composition of lots of classes) depending on the kind of data it stores. A TextCell holds text, so I know to pad it and format it (differently than an ImageCell, or a cell containing an unordered list). I can composite TextCells with other more specific types; a value that represents a percentile is a PercentileCell; the class handles formatting the numeric value and sticking a % on the end. I could composite it with an ImportantCell which will give it a special background color. It's as simple as $cell = new TextCell( new ImportantCell( new PercentileCell( 56 ))); The nifty thing is that I can composite the cells arbitrarily in any order or combination, because each simply holds a generic "cell" member and calling a method on an object only causes it to call the same method on its child object, all the way down the stack. Also, if I later decide to take the % off the end of all my percentile values, I can do it by changing a single class definition. That's the kind of thing you can't handle well with HTML/CSS alone. Before, it'd take me a month and half to go mucking around in static HTML files fixing it all. (Or an hour worth of Perl regexing, but still, no fun.) Or if I want my HTML to validate as XHTML Strict, I can change the HTML for all my tables at once by screwing with the base Cell class. If I want to turn it into XML or some other markup, I could do that too, in theory.

At this point I'm essentially writing most of my pages entirely in PHP, never needing to write any raw HTML by hand at all, which is a very nice change of pace. I wish they'd have taught more of this sort of thing in college. We learned how to write searching and sorting algorithms until blue in the face. But we never really touched on how to design software at a very high level. I still think I'm not too good at it in many ways, but I'm learning, at least.

PHP makes me sad; programming makes me happy

Fri, 24 Nov 2006 20:21:40 -0800

My other site is about Final Fantasy (the original video game of the series, for the NES). That site is how I learned HTML, a good 7 years ago. It's still my baby and (perhaps sadly) one of what I consider my greatest accomplishments. I wish I had more time to work on it nowadays, but such is life.

Oh how the internet has changed. I started out on that site with plain old static HTML files. It used to take me months to do or change anything. Eventually I learned about server-side includes and I started using those. A few years later I delved into PHP and started using it as a more sophisticated "include" mechanism and templated a good bit of the site.

Fast forward to today, and I'm trying to get most of my data in a mysql database. I learned a lot from work about how to properly design a database. That part I think I did pretty well at, on my FF1 site. The PHP frontend is where I started having problems. PHP is just such an un-fun language to work with. I hear PHP5 is nicer than PHP4, but PHP4 is what I'm stuck with. At first I tried a purely functional solution, and it very quickly become such a tangled mess of spaghetti code that it was nearly impossible to use. Today I rewrote that crap using the extremely weak OOP constructs PHP4 has to offer, and weak though they may be, my code is ten times shorter and probably ten times easier to read.

Sometimes I'll be sitting here banging out code, and it will be not working. The grunt-work of programming is debugging. You write something you think will work, and 10 times out of 10, it will fail the first time. So you find the first bug, fix it, rerun it. Failure. Find the next bug, fix it, run it, failure. Find, fix, run, failure. And you repeat this over and over and over. But eventually you hit that point where you find the very last show-stopper bug, and you fix it, and run your program, and it all of a sudden it WORKS. You almost never expect it to work. Success flies out of nowhere and hits you in the head, and it's really exciting. You get screen after screen of delicious output, all thanks to that last little tweak. That's the moment that makes the slog of computer programming all worth it.

Fullscreen games under TwinView

Fri, 06 Oct 2006 22:13:16 -0700

The only thing bad about having two monitors in Linux is fullscreen apps, from time to time. Mplayer for example is smart, it fullscreens to whatever screen it's on and leaves the other alone. VLC for example bugs out but at least it sticks to one monitor while doing so.

NWN is not so smart, and tries to run at an enormous resolution which either bleeds across both screens or takes up all of one screen and runs off the edge.

One solution is to run in windowed mode. This is less than optimal for all kinds of reasons, especially if you happen to have an auto-raising kicker or something similar.

Found this on the Gentoo forums though; putting a NULL into one of your MetaModes works:

Option "MetaModes" "1280x1024,1680x1050;NULL,1680x1050"

It turns off one monitor and leaves the other on. CTRL-ALT-+ to switch to and from meta-modes, obviously. NWN recognized the smaller resolution and let me run at 1680x1050. Good old Gentoo forums, never let me down.

I think I can handle this

Fri, 06 Oct 2006 20:51:01 -0700

After I emerged Neverwinter Nights, I got this:

 * The NWN linux client is now installed.
 * Proceed with the following step in order to get it working:
 * Run /opt/nwn/fixinstall as root
>>> Regenerating /etc/ld.so.cache...
>>> games-rpg/nwn-1.67-r1 merged.
>>> Recording games-rpg/nwn in "world" favorites file...

>>> No packages selected for removal by clean.

>>> Auto-cleaning packages...

>>> No outdated packages were found on your system.


 * GNU info directory index is up-to-date.

I hope I didn't run that step out of order. : (