I Like Programming

4Fourths

Fri, 12 Mar 2010 05:37:11 -0500

What a beautiful game! I got to play with this at Gamma 4 as part of their One Button showcase. It’s a co-operative game where four players control two ships using one button each: players 1 and 3 can charge and shoot their lasers, while players 2 and 4 control the upward thrust of each ship.

4Fourths

Unlike a lot of co-operative games, this one does nothing to stop players from killing each other. In fact, it’s pretty fun to spar between challenges, and most players who pick the game up got right into shooting and dodging each other. Before long, the first enemy is lowered between the players like a giant wall, forcing them to break it up and learn how to work together without a word of dialog. But as the game goes on, bosses place less walls between the players until they must be very careful not to blow each other up.

Despite the fun of shooting each other, there are no competitive scoring elements. Also, it’s rather difficult to defeat a boss without both players’ combined firepower, and failing to do so in time means everyone loses. That makes this one of the most purely co-operative games I’ve played.

Also, I love the bright colors and boxy graphics. It’s so Nu-Lo-Fi. And it’s made in unity.

N-Key Rollover, or Why Modern Keyboards Suck

Sat, 19 Sep 2009 23:16:00 -0400

Have you ever tried to play a two-player game on one keyboard? Chances are it wasn’t a fun experience. You press down a few keys, and the rest don’t register at all! What gives?

What we want is called n-key rollover aka NKRO, a feature that older keyboards like the IBM Model M used to have. But these days, manufacturers have been cutting costs. According to this blog, keyboard manufacturers save seven cents per key by using matrix circuits. That’s $7.28 for 104 keys, which makes me wonder how vendors can justify charging over $50 for “gaming keyboards” that don’t have it.

It’s hard to find any keyboards these days with NKRO. Fortunately, the Filco keyboards on EliteKeyboards.com advertise the feature prominently. I’ll have to get one of these.

JavaScript Scoping Oddity

Fri, 11 Sep 2009 04:07:00 -0400

Guess the output.

var outer = "test1"

function test1(){
  var inner = outer
  return inner
}

function test2(){
  var inner = outer
  var outer = "test2"
  return inner
}

test1()
test2()

Shrinky-Fit TextArea

Mon, 31 Aug 2009 02:46:46 -0400

While working on my latest hobby project, I wanted the text entry boxes to always be just large enough for the text you’re typing into them, similar to the text boxes in desktop apps like OmniFocus.

The first solution I found, jquery.autogrow, was not satisfactory. It simply did not respond to input quick enough to avoid having text slip out of the top of my input for a moment if I hit enter too fast, and it assumed you’d leave some space to write and not truly shrink to fit.

Wishing to replace it, I chatted with a friend and we came up with a scheme quite similar to another solution by Peter Michaux which I didn’t discover until after I threw together mine.

The gists of all of them are similar: take the text of your current textarea, place it in a similarly-styled div, let the browser flow it the way you want it, then apply its height back to the textarea.

My solution made a few little changes. Here’s the gist of it. I attached this as a keydown handler on the affected textareas. Each keydown, it copies the text into a similarly styled div, then sets the height like usual. Also, I used a zero-millisecond setTimeout so it would fire just after the textarea’s text was changed. I suppose I could have used bubbling up events instead. Not to be wasteful, my version only uses one doppelganger div for each different style of textarea I needed. Both are positioned absolutely at left:-9999999px.

Who says Python doesn't have function static variables?

Tue, 02 Jun 2009 23:38:00 -0400

If you want to store internal state in a python function, most people would say you need to create a class and use class or instance attributes. Of course you don’t. Python 3 introduces “nonlocal” as a keyword for creating static variables, but you can already make them without this help.

In fact, you might even create them accidentally, due to this weird behavior with default arguments. Python only evaluates default arguments once, so if your default argument is mutable complex type, you have yourself some internal state.

>>> def counter(count=[0]):
...   count[0] += 1
...   return count[0]
... 
>>> counter()
1
>>> counter()
2
>>> counter()
3

Well, that’s kind of a hack. A better way to do this is to use function attributes. Yes, functions can have attributes, just like classes.

def counter():
  counter.count += 1
  return counter.count
counter.count = 0

Building a Good New User Experience for Elemental Chess

Mon, 01 Jun 2009 03:15:59 -0400

People don’t like to log in to things until they’re convinced it’s worth it. That’s a given. My first thought was to just make a sandbox mode for my game, where you can play it purely on the client side, with a friend or against the computer. If you wanted to play against other players online, you’d need to log in with an openid provider.

I showed off my new sandbox mode at Google IO. It didn’t have AI or checkmate detection yet, since I couldn’t decide whether to implement that on the client side or the server side. Google Web Toolkit seems like a nice solution for client/server code sharing that I will definitely pursue. But then I thought, I can solve this code sharing problem and provide a better user experience, if I get a little more ambitious with my user account handling. I’ll let users do anything they want except hang onto their history if they’re not logged in.

When a user hits the site without a user in their session cookie, I’ll create a brand new user for them with a randomized name (and plenty of invitation to change it). This is a full-featured user, with one caveat: it can expire, at about the time their cookie-based session should. To keep it from expiring, all the user has to do is associate it with an OpenID. This is exactly the same thing as logging in.

Okay, but what if a lazy user who already has a saved account comes along and plays a few games without logging in? Easy. When they eventually do log in, we can delete their temporary account and replace every instance of it with the real one! Talk about awesome.

Since I’m totally overloading my Login button to function as “Login”, “Register”, “Save”, and “Merge Accounts”, I think it’s appropriate to call it something else. “Recognize Me” sounds pretty good!

Rebuilding

Mon, 18 May 2009 07:15:11 -0400

I’ve lost tons of work in the past in almost every way imaginable, from melted or crushed hard disks to raid failures and unreliable hosts. I thought redundancy would save me, but these failures always seem to happen in pairs. I could fill a graveyard with all the work I’ve lost.

But I’m not gonig to let this get me down. I can still remember how I made most of those old things, and some of them were pretty good simple ideas, so it might be fun to re-make them better stronger faster than before!

In the future, I’ll use reliable backup sites like github, amazon s3, and I’ll look into Mozy. Their commercial is spot on, after all. Fortunately, not all of my data is gone. A good hunk of it survived on my 120GB WD Passport, which includes things as far back as 2005. I better back this up before I lose it!

Reduce by Any Other Name

Tue, 05 May 2009 19:51:00 -0400

One of my favorite functions is `reduce`. It’s the perfect way to represent anything like sum, product, factorial, reverse, that walks along a list accumulating the values it finds. Unfortunately, it’s hard to share my love of reduce when every language calls it something different. Observe:

# Python - reduce # reduce(function, iterable[, initializer]) def factorial(n): return reduce(lambda acc,x: acc*x, range(1,n), 1) # Ruby - inject # Enumerable#inject(init) {|result, item| ...} def factorial(n) (1..n).inject(1) {|acc,x| acc*x} end

-- Haskell - fold -- foldl :: (a -> b -> a) -> a -> [b] -> a factorial n = foldl (*) 1 [1..n]

// C# - Aggregate // Enumerable.Aggregate<(Of <(TSource, TAccumulate>)>) // Method (IEnumerable<(Of <(TSource>)>), // TAccumulate, Func<(Of <(TAccumulate, TSource, TAccumulate>)>)) // (This type signature is pretty ridiculous) int factorial(int n){ return Enumerable.Range(1, n).Aggegate(1, (acc,x) => acc*x); }

Board Game Abstraction

Mon, 04 May 2009 08:11:23 -0400

How would you model a board game in a sql database? I’ve been overthinking this. I’d probably have a Game model to keep track of whose turn it is, with a lot of Pieces associated with it. But that’s obvious.

To be totally generic, a Piece could consist of string:kind, string:space, and string:color. But what if you were playing a game like chess with a 2D board? You could name the space something like 2-2. What if the piece has meta information like rank and class? You could encode it in the kind, like fire-2. Why bother using data types other than string if you’re just going to fetch all pieces and assemble the board whenever you compute a move?

Or is there a reason to query on meta information and board positions? Would you optimize your game logic by not constructing the whole board each time? Should you create a new model for the kind of piece that exists in each game, like a monopoly piece which moves around the board linearly versus a checkers piece which traverses in two dimensions and can be kinged? Do you want many small tables or few large ones?

Ruby Doesn't Have Inner Functions

Fri, 16 Jan 2009 21:16:00 -0500

Ruby syntax allows you to write something that looks a lot like an inner function in other languages. However, it really isn’t. Lets explore this odd behavior.

class Foo
  def bar
    x = "scoped variable"
    def baz
      puts x
    end
  end
end

This looks like a pretty standard test of closures. One might expect the bar method to define a function baz with access to bar’s scope, namely the variable x. Lets see what really happens.

puts Foo.instance_methods.include?("bar") # true
puts Foo.instance_methods.include?("baz") # false

Still consistent with our expectations, we see we have created an instance method bar, but not baz. Lets test out bar on an instance.

instance = Foo.new
instance.bar
puts Foo.instance_methods.include?("baz") # true

Oho, where did this baz method come from that wasn’t there before? Running bar created it! In fact, calling `bar’ in our instance even changed the global class definition to include it! Lets try it out!

instance.baz # NameError: undefined local variable or method ‘x’ for #

So much for closures. It seems baz doesn’t have access to bar’s scope. It’s just a plain old instance method that we’ve defined.

Well, it doesn’t behave much like other languages, but this behavior could still be useful. You could use it to evaluate method definitions conditionally, or just wait and create some of your methods after others have run. It’s not all that useful, but it’s still good to know so you don’t accidentally use this syntax wrong.