rozgo

The Force Unleashed videos.

Official Trailer

Interviews

I wrote this a long time ago, the code might show this.

#    author       : Alexander Orozco
#    copyright    : DoWhatEverYouWantWithIt LICENSE
#    email        : alex@rozgo.com
#    language     : Python script
#
#    This is a simple demostration of genetic algorithms.
#    Given these digits: '0,1,2,3,4,5,6,7,8,9' the algorithm
#    must combine them with these operators '+,-,*,/' and
#    find an equation that can evaluate to a given target.
#    I'll be using binary encoded genes to represent
#    chromosomes.
#
#    Example:
#        6*8+4+9-5
#
#    Other resources:
#        I find A-Depot very helpfull - http://ai-depot.com/
#        And here (http://www.ai-junkie.com/gat1.htm) is the
#        tutorial I used to write this script
#
#    A WORD ABOUT GENETIC ALGORITHMS (extracted from www.geneticalgo.com)
#    Most Genetic Algorithms work with a constant population
#    size. As the computation progresses from one generation
#    to the other, the weaker individuals gradually pave way
#    for the stronger ones, corresponding to some improved
#    solutions. Comparisons between members are made based on
#    what is called the fitness value acquired directly or
#    indirectly from the system.

import sys
import random

# GENE TYPE ENCODING
# We need a way to encode any potential solution into a
# chromosome

gene_t = {}

gene_t['0'] = ['0','0','0','0']
gene_t['1'] = ['0','0','0','1']
gene_t['2'] = ['0','0','1','0']
gene_t['3'] = ['0','0','1','1']
gene_t['4'] = ['0','1','0','0']
gene_t['5'] = ['0','1','0','1']
gene_t['6'] = ['0','1','1','0']
gene_t['7'] = ['0','1','1','1']
gene_t['8'] = ['1','0','0','0']
gene_t['9'] = ['1','0','0','1']
gene_t['+'] = ['1','0','1','0']
gene_t['-'] = ['1','0','1','1']
gene_t['*'] = ['1','1','0','0']
gene_t['/'] = ['1','1','0','1']

#
#    ENCODE A SOLUTION
#    This will encode a potential solution into a binary
#    representation of a chromosome
#
#     Example:
#        Given solution: 2+5*8/5
#        Encodes to: 0010 1010 0101 1100 1000 1101 0101
#
def encode(solution):

	chromosome = []

	for char in solution:
		if gene_t.has_key(char):
			chromosome.extend(gene_t[char])

	return chromosome

#
#    DECODE A CHROMOSOME
#    This will reverse a binary representation of a
#    chromosome into a string representation of an
#    equation. The reverse of the above function.
#
def decode(chromosome):

	solution = []

	for gene in range(0,len(chromosome),4):
		for key in gene_t.keys():
			if gene_t[key] == chromosome[gene:gene+4]:
				solution.append(key)

	return solution

#
#    PARSE A SOLUTION
#    This will parse a solution into a valid equation.
#    Following the pattern:
#        digit-operand-digit-operand-...
#
#    Example:
#        Solution: 2+/4*3/+4-5
#        Parsed: 2+4*3/4-5
#
def parse(solution):

	# generate valid expression
	expression = ''
	for i in range(0,len(solution)):
		s = solution[i]
		if s.isdigit():
			if int(s) == 0 and (len(expression) == 0 or not expression[-1:].isdigit()):
				pass
			else:
				expression += s
		elif len(expression) > 1 and expression[-1:].isdigit():
			expression += s

	# last character must be digit
	if len(expression) > 0 and not expression[-1:].isdigit():
		expression = expression[:-1]

	return expression

#
#    SOLVE A PARSED SOLUTION
#    This will evaluate the parsed solution.
#
def solve(parsed):

	return int(eval(parsed))

#
#    FITNESS OF CHROMOSOME
#    This will return a fitness score that's inversely
#    proportional to the difference between the target
#    and the value a chromosome represents.
#
def fitness(chromosome,target):

	fit = abs(target-solve(parse(decode(chromosome))))
	if fit == 0:
		return 0
	return 1/float(fit)

#
#    ROULETTE SELECTION OF CHROMOSOME
#    Randomly choose a chromosome from the population
#    proportionally to its fitness.
#
def roulette(population,target,maxfitness):

	pick = random.random() * maxfitness
	totalfitness = 0
	for chromosome in population:
		totalfitness += fitness(chromosome,target)
	if totalfitness > pick:
		return chromosome

#
#    CROSSOVER OF CHROMOSOMES
#    Given two chromosomes the rate will decide the
#    chance that these chromosomes will swap their genes.
#    A random gene is selected and crossover is performed
#    swapping all genes from that point on.
#
def crossover(chromosome_a,chromosome_b,rate):

	if random.random() < rate:
		start_gene = random.randint(0,len(chromosome_a)-1)
		for gene in range(start_gene,len(chromosome_a)):
			swap = chromosome_a[gene]
			chromosome_a[gene] = chromosome_b[gene]
			chromosome_b[gene] = swap

#
#    MUTATE CHROMOSOME
#    Given a chromosome the rate will decide the chance
#    of a gene being flipped (bit 0 to 1 or 1 to 0)
#
def mutate(chromosome,rate):

	for gene in range(0,len(chromosome)):
		if random.random() < rate:
			if chromosome[gene]=='0':
				chromosome[gene]='1'
			else:
				chromosome[gene]='0' # fix by Lon Barfield lonwen@hotmail.com

#
#    SPAWN A CHROMOSOME TO LIFE
#    Generate a chromosome with randomly generated
#    genes.
#
def spawn(size):

	chromosome=[]
	for gene in range(0,size):
		if random.random() < 0.5:
			chromosome.append('0')
		else:
			chromosome.append('1')
	return chromosome

#
#    MAIN EXECUTION FUNCTION
#    Get some user input, generate an initial population,
#    roulette select chromosomes by fitness, and
#    crossover/mute them into a new population of the same
#    size. Each chromosome of the population is decoded into
#    a potential solution, then evaluated to check if target
#    is met. Keep on going generation to generation.
#
def main():

	# settings
	POPULATION_SIZE = 10
	CHROMOSOME_SIZE = 100
	TARGET = 25
	CROSSOVER_RATE = 0.7
	MUTATE_RATE = 0.01

	user_input = raw_input('TARGET=(25)')
	if len(user_input)>0:
		TARGET = int(user_input)

	user_input = raw_input('CHROMOSOME_SIZE=(100)')
	if len(user_input)>0:
		CHROMOSOME_SIZE = int(user_input)

	user_input = raw_input('POPULATION_SIZE=(10)')
	if len(user_input)>0:
		POPULATION_SIZE = int(user_input)

	user_input = raw_input('CROSSOVER_RATE=(0.7)')
	if len(user_input)>0:
		CROSSOVER_RATE = float(user_input)

	user_input = raw_input('MUTATE_RATE=(0.01)')
	if len(user_input)>0:
		MUTATE_RATE = float(user_input)

	# create population
	finished = False
	generations = 0
	population = []
	for i in range(0,POPULATION_SIZE):
		population.append(spawn(CHROMOSOME_SIZE))

	while finished==False:

		# test if target met
		for chromosome in population:
			parsed = parse(decode(chromosome))
			result = solve(parsed)
			print result,'\t=','\t',parsed,'\t'#,''.join(decode(chromosome))
			if result == TARGET:
				print 'SOLVED !!!!!!'
				print 'Generations required:',generations
				print 'Expression:',parse(decode(chromosome)),'=',result
				finished = True
				break
				#sys.exit()

		#if finished==True:
		#	break

		# create new population by mating
		totalfitness = 0
		for chromosome in population:
			totalfitness += fitness(chromosome,TARGET)

		next_generation=[]
		for i in range(0,POPULATION_SIZE/2):

			# roulette parents
			chromosome_a = roulette(population,TARGET,totalfitness)[:]
			chromosome_b = roulette(population,TARGET,totalfitness)[:]

			# crossover
			crossover(chromosome_a,chromosome_b,CROSSOVER_RATE)

			# mutate
			mutate(chromosome_a,MUTATE_RATE)
			mutate(chromosome_b,MUTATE_RATE)

			next_generation.append(chromosome_a)
			next_generation.append(chromosome_b)

		population = next_generation
		generations += 1
		print '----------------------------- Generation #',generations,'-----------------------------'

	user_input = raw_input('Again? (y/n)')
	if user_input != 'n':
		main()

main()

I’m tired of the crappy, low quality casual games out there. But, apparently, nobody else is. Maybe its to early, maybe its not for it, but high quality 3D casual games cannot be seen at this distance.

I’ve seen some progress on physics based gameplay, which might hint us on whats coming; Wii quality casual games, or Wii as the sole platform for casual games. Wait ! Thats it, Wii is the new nextgen casual game platform.

So, I rediscovered flash (Adobe Flash), after a long goodbye. 2D and 3D physics engines and renderers, HD video, 95% install base, desktop apps, wow, impressive. I got to recognize flash is making a comeback stronger than ever; there’s so much potential. Also danger of loosing a niche.

But, predictions aside, the tech is great. I’ve seen Box2D physics engine work flawlessly and 3D Sandy bring DS quality. And, I like what I see. Maybe I’ll try to get into this huge casual games business everybody is talking about.