Making a binary tree using fractals, classes and swampy's TurtleWorld - Python - Debuging

Question

I have this piece of code, which read and then interpretes a Fractal description language file, then uses FractalWorld, Which is a special version of TurtleWorld, which just removes the turtle and has no delays.

import math, random, sys
from FractalWorld import *

world = FractalWorld(width=1000,height=1000,delay=0)
Rasmus = Fractal(draw=False)

class command(object):
    def __init__(self, cmd, l):
            self.cmd = cmd
            self.l = l

    def execute(self, turtle, length):
            if self.cmd=='lt':
                    lt(turtle, int(self.l[0]))
            if self.cmd=='rt':
                    rt(turtle, int(self.l[0]))
            if self.cmd=='fd':
                    fd(turtle, length)
            if self.cmd=='bk':
                    bk(turtle, length)
            if self.cmd=='scale':
                    lenght = length*float(self.l[0])

class rule(object):
    def __init__(self):
            self.rule={} #we make an empty dictionary

    def newrule(self,leftside,rightside):
            self.rule[leftside]=rightside #we fill the dictionary

    def expand (self,oldlist,depth):
            if depth <= 0:
                    return oldlist 
            newlist=[] # we make an empty new list
            for i in oldlist:
                    if i not in self.rule:
                            newlist.append(i)
                    else:
                            newlist.append(self.expand(self.rule[i],depth-1))
            return newlist

class Fractal(object):
    def __init__(self, start, rules, commands, length, depth):
            self.start = start
            self.rules = rules
            self.commands = commands
            self.length = length
            self.depth = depth

    def draw(self, oldlist):
            for i in oldlist:
                    if type(i) == list:
                            self.draw(i)
                    else:
                            cmd = self.commands[i]
                            cmd.execute(Rasmus, self.length)

def read():
    files = open('tree.fdl')
    commands = {}
    r = rule()
    for line in files:
            line = line.strip()
            oldlist = line.split(' ')
            if oldlist[0] == 'start':
                    start = oldlist[1:]
            elif oldlist[0] == 'rule':
                    r.newrule(oldlist[1], oldlist[3:])
            elif oldlist[0] == 'cmd':
                    cmd = command(oldlist[2], oldlist[3:])
                    commands[oldlist[1]] = cmd
            elif oldlist[0] == 'length':
                    length = int(oldlist[1])
            elif oldlist[0] == 'depth':
                    depth = int(oldlist[1])
    return Fractal(start, r, commands, length, depth)

re = read()

print re.commands.keys()

l = re.rules.expand(re.start , re.depth)
re.draw(l)


wait_for_user()

The fdl file will make an binary tree and it looks like this:

start X

rule X -> F L D X R X U L B

length 100

depth 10

cmd X nop

cmd F fd

cmd B bk

cmd R rt 70

cmd L lt 35

cmd D scale 0.7

cmd U scale 1.4285714285714286

My problem is there is a bug, in my interpreter. It seems that the interpreter does not read the scale correct and down scales my lines for the next depth of the trees branches. I have tried to debug it but haven't been able to do it.

Answer 1

lenght = length*float(self.l[0])

This line has two bugs. First, a typo. But then even if the name was correct, you'd be assigning a new value to a local variable as the last thing you do in the function, which is pointless. You probably should replace it with xxx.length so that calling the function can change its value. The object I wrote as xxx could be the Fractal instance available at the caller; then you'd pass it as an argument, instead of the length.