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.

http://www.infoq.com/presentations/pampuch-vm-optimizations-language-designers

I wondered under what conditions do profilers detect deadlock and then report it, so I wrote code that reaches deadlock.

package com.grayger.deadlock;

public class SimpleDeadlocker {
	private final static Object OBJ1=new Object();
	private final static Object OBJ2=new Object();

	private final static int LOOP=100;

	public void obj1First() {
		synchronized(OBJ1) {
			printInfo("Hold OBJ1");
			synchronized(OBJ2) {
				printInfo("Hole OBJ2");
			}
			printInfo("Release OBJ2");
		}
		printInfo("Release OBJ1");
	}

	public void obj2First() {
		synchronized(OBJ2) {
			printInfo("Hold OBJ2");
			synchronized(OBJ1) {
				printInfo("Hole OBJ1");
			}
			printInfo("Release OBJ1");
		}
		printInfo("Release OBJ2");
	}

	private void printInfo(String info) {
		System.out.println(Thread.currentThread().getName()+" "+info);
	}

	public static void main(String args[]) {
		final SimpleDeadlocker d=new SimpleDeadlocker();
		Thread t1=new Thread(new Runnable() {
			public void run() {
				for(int i=0;i<loop;i++)>
					d.obj1First();
				}
				d.printInfo("Terminated");
			}
		}, "OBJ1_First");

		Thread t2=new Thread(new Runnable() {
			public void run() {
				for(int i=0;i<loop;i++)>
					d.obj2First();
				}
				d.printInfo("Terminated");
			}
		}, "OBJ2_First");

		t1.start();
		t2.start();
	}
}

Above example can be refactored as follows:

package com.grayger.deadlock;

public class Deadlocker {
	private final static int LOOP=100;

	static class Deadlock1 {
		private final static Object OBJ1=new Object();
		private final static Object OBJ2=new Object();		

		public void obj1First() {
			synchronized(OBJ1) {
				printInfo("Hold OBJ1");
				synchronized(OBJ2) {
					printInfo("Hole OBJ2");
				}
				printInfo("Release OBJ2");
			}
			printInfo("Release OBJ1");
		}
	}

	static class Deadlock2 {
		private final static Object OBJ1=new Object();
		private final static Object OBJ2=new Object();

		public void obj2First() {
			synchronized(OBJ2) {
				printInfo("Hold OBJ2");
				synchronized(OBJ1) {
					printInfo("Hole OBJ1");
				}
				printInfo("Release OBJ1");
			}
			printInfo("Release OBJ2");
		}
	}

	public static void printInfo(String info) {
		System.out.println(Thread.currentThread().getName()+" "+info);
	}

	public static void main(String args[]) {
		final Deadlock1 d1=new Deadlock1();
		final Deadlock2 d2=new Deadlock2();
		Thread t1=new Thread(new Runnable() {
			public void run() {
				for(int i=0;i<loop;i++)>
					d1.obj1First();
				}
				Deadlocker.printInfo("Terminated");
			}
		}, "OBJ1_First");

		Thread t2=new Thread(new Runnable() {
			public void run() {
				for(int i=0;i<loop;i++)>
					d2.obj2First();
				}
				Deadlocker.printInfo("Terminated");
			}
		}, "OBJ2_First");

		t1.start();
		t2.start();
	}
}

Unfortunately I couldn’t find any document on the change from java.sun.com site. Missing this issue from the release note of Java6 seems to be a mistake as http://blogs.sun.com/ahe/entry/override_snafu says.