You can play it via http://www.kongregate.com/games/grayger/snake-runaway
I welcome your comment.

2. Contents
The new game page looks similar to (crapy) game portals. While most game portals have categories such as action, sports, puzzle etc., my site has categories: fun, artistic, additing, creative, even undervalued which is for games that are not popular but more attention should be paid to. There is also a category for games developed by me. I created pages for each game by hand. The hassle job includes downloading a zipped game bundle from mochi games, extracting it, and constructing the page. I will automate the job later.

My job is to make games. I don’t want to put much time on this site. It is for just fun.

Challenge 20 levels! I hope you enjoy this game. PLAY!

You can also play the game on kongregate!

Implementing the algorithm in Python was easy except creating a palette. I hadn’t understood how to “make” a palette, rather I thought palettes are provided by OS or libraries. The code from Pygame repository that creates red-palette is good for me to understand how to make a palette.

Anyway my code is as below

'''
Created on Nov 12, 2009

Class for fire special effect 

Dependency:
 numpy: http://numpy.scipy.org/
 pygame: http://pygame.org/

@author: grayger (http://www.grayger.com/)
'''

import random
import sys
import numpy
import pygame
from pygame.locals import *

class FireEffect:
    def __init__(self, size=(40, 40), coolingFactor=5, fuelRange=(-31, 32)):
        self.__width, self.__height = size
        self.coolingFactor = coolingFactor
        self.fuelRange = fuelRange

        self.__array = numpy.zeros((self.__width, self.__height))
        self.__fireSurface = pygame.Surface((self.__width, self.__height), 0, 8 )
        self.__fireSurface.set_palette(self.__getPalette())

        random.seed()

    def __getPalette(self):
        gstep, bstep = 75, 150
        cmap = numpy.zeros((256, 3))
        cmap[:, 0] = numpy.minimum(numpy.arange(256) * 3, 255)
        cmap[gstep:, 1] = cmap[:-gstep, 0]
        cmap[bstep:, 2] = cmap[:-bstep, 0]
        return cmap  

    def getFireSurface(self):
        tempArray = numpy.zeros(self.__array.shape)
        for r in range(0, self.__width):
            for c in range(0, self.__height):
                tempArray[r, max(0, c - 1)] = min(255, max(0, (int(self.__array[max(0, r - 1), c]) + int(self.__array[min(self.__width - 1, r + 1), c]) + int(self.__array[r, max(0, c - 1)]) + int(self.__array[r, min(self.__height - 1, c + 1)])) / 4 - self.coolingFactor))

        for r in range (0, self.__width, 2):
            fuel = min(255, max(0, self.__array[r, self.__height - 1] + random.randint(*self.fuelRange)))

            tempArray[r, self.__height - 1] = fuel
            tempArray[r + 1, self.__height - 1] = fuel

        self.__array = tempArray
        pygame.surfarray.blit_array(self.__fireSurface, self.__array.astype('int'))
        return self.__fireSurface

#######################################

pygame.init()
screen = pygame.display.set_mode((320, 120), 0, 8 )
fireEffect = FireEffect()

clock = pygame.time.Clock()

while True:
    for event in pygame.event.get():
        if event.type == QUIT:
            pygame.quit()
            sys.exit()
        if event.type == KEYDOWN:
            if event.key == K_a and fireEffect.coolingFactor < 10:
                fireEffect.coolingFactor += 1
            elif event.key == K_z and fireEffect.coolingFactor > 1:
                fireEffect.coolingFactor -= 1

    fireSurface=fireEffect.getFireSurface()
    # draw the original fire image
    screen.blit(fireSurface, (0,0))    

    # draw the scaled and mirrored fire image
    pos = (0, 40)
    fireSurface = pygame.transform.scale(fireSurface, (80, 80))
    fireSurface2 = pygame.transform.flip(fireSurface, True, False)
    for i in range(0, 4, 2):
        screen.blit(fireSurface, (pos[0] + fireSurface.get_width()*i, pos[1]))
        screen.blit(fireSurface2, (pos[0] + fireSurface.get_width()*(i + 1), pos[1]))

    clock.tick(30)
    pygame.display.flip()

#######################################    

When creating a FireEffect instance, you can set the size of surface array, cooling factor, and the range of fuel factor. The bigger size requires more CPU resource but produces better quality. The bigger cooling factor, the shorter the fire height. The bigger fuel factor, the brighter the fire.

The upper image is original-sized one and the lower image is scaled/mirrored one.

def _is_pow2(v):
    # http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2
    return (v & (v - 1)) == 0

At a glance, I can understand how it works, but I have never devised it!
It is from “Bit Hacks” by Sean Eron Anderson. They are not only beautiful but very useful in graphics libraries.

For the past 40 years, for example, we’ve tortured ourselves over our inability to finish a software project on time and on budget. But as I hinted earlier, this never should have been the supreme goal. The more important goal is transformation, creating software that changes the world or that transforms a company or how it does business.

Is software engineering, which weights controls over software projects, outdated? Really? The article is too short to strenghten his sensational arguments. However, software developement may become boring and dry as we focus more on a defined process or metrics.

The stuffs that I didn’t know before are

• Double brace initialization

	Map map=new HashMap<String,String>() {
		{
			put("key1","value1");
			put("key2","value2");
		}
	};

• Instance initializer

public class Initializer {
	static {
		System.out.println("static");
	}
	{
		System.out.println("instance");
	}
	public Initializer() {
		System.out.println("constructor");
	}
}

• Covariant return type

	abstract class Base {
		abstract List getList();
	}

	class Sub extends Base {
		@Override
		ArrayList getList() {
			return null;
		}
	}

Double brace initialization uses instance initializer because first brace is for declairing annomymous inner class and second brace is for instance initializer block.

Most of good parts are well-known, but not widely used. I can see they are fully and correctly used in JavaScript frameworks or toolkits but they are rarely or inappropriately used by page designers.

For me, sections on bad parts are much useful. I tell “===” from “==” but I have never used “===” just because I, as a Java programmer, am not familiar to it. The book helps use bad parts less rather than use good parts more.