def rysuj():
    turtle.tracer(0, 0)  # wylaczenie animacji co KROK, w celu przyspieszenia
    turtle.hideturtle()  # ukrycie glowki zolwika
    turtle.penup() # podnosimy zolwia, zeby nie mazal nam linii podczas ruchu

    ostatnie_rysowanie = 0  # ile kropek temu zostal odrysowany rysunek

    for i in xrange(ILE_KROPEK):
        # losujemy wierzcholek do ktorego bedziemy zmierzac	
        do = random.choice(WIERZCHOLKI)
        # bierzemy nasza aktualna pozycje 
        teraz = turtle.position()
        # ustawiamy sie w polowie drogi do wierzcholka, ktorego wczesniej obralismy
        turtle.setpos(w_polowie_drogi(teraz, do))
        # stawiamy kropke w nowym miejscu
        turtle.dot(1)
        ostatnie_rysowanie += 1
        if ostatnie_rysowanie == OKRES_ODSWIEZENIA:
            # postawilismy na tyle duzo kropek, zeby odswiezyc rysunek
            turtle.update()
            ostatnie_rysowanie = 0

    pozdrowienia()

    turtle.update()
Example #2
0
    def draw(self, x, y, width, height, max_length=None, force_fields=None):
        """Draw the string. The grammar-system axiom is extended to
        the specified depth"""
        self.reset()
        turtle.setup(width,height,None,None)
        turtle.tracer(200,0)
        self.penup()
        self.setposition(x,y)
        self.origin = x, y
        self.max_length = max_length
        while not self.grammar_system.done and \
                self.grammar_system.generation < self.depth:
            self.grammar_system.step()
            if (self.max_length is not None and
                len(self.grammar_system.string) > self.max_length):
                self.hideturtle()
                print("Drawing exceeded maximum length")
                return False
        print(self.grammar_system.string)

        if force_fields:
            for force_field in force_fields:
                self.force_fields.append(Attractor(force_field['type'], force_field['effect'], force_field['x'], force_field['y'], force_field['size']))

        non_null = self._draw(self.grammar_system.string, self._rules)
        self.hideturtle()
        turtle.update()
        return non_null
Example #3
0
def set(): #set of parameters
    turtle.hideturtle()
    turtle.tracer(1e3,1)
    turtle.left(95)
    turtle.penup()
    turtle.goto(0,-turtle.window_height()/2)
    turtle.pendown()
Example #4
0
def draw_maze():
    t.speed(0)

    turtle.tracer(10, 25)

    t.pensize(3)
    t.penup()
    t.goto(0, 0)
    t.pendown()
    t.goto(20 * NC, 0)
    t.goto(20 * NC, 20 * NR)
    t.goto(0, 20 * NR)
    t.goto(0, 0)
    for i, ns in enumerate(nodes):
        y1, x1 = points[i]
        for n in (n for n in ns if n > i):
            y2, x2 = points[n]
            t.penup()
            if n == i + 1:
                t.goto(20 * x2, 20 * y1)
                t.pendown()
                t.goto(20 * x2, 20 * (y1 + 1))
            else:
                t.goto(20 * x1, 20 * y2)
                t.pendown()
                t.goto(20 * (x1 + 1), 20 * y2)
Example #5
0
def setup():
    turtle.hideturtle()
    turtle.tracer(1e3,0)
    turtle.left(90)
    turtle.penup()
    turtle.goto(0,-turtle.window_height()/2)
    turtle.pendown()
Example #6
0
    def __init__(self, length=10, angle=90, colors=None, lsystem=None):
        import turtle
        self.length = length
        self.angle = angle
        if colors is None:
            self.colors = ['red', 'green', 'blue', 'orange', 'yellow', 'brown']
        if lsystem is not None:
            self.lsystem(lsystem)

        # draw number
        self.ith_draw = 0

        # origin of next draw
        self.origin = [0, 0]

        # bounding_box
        self._box = 0, 0, 0, 0


        # turtle head north and positive angles is clockwise
        turtle.mode('world')
        turtle.setheading(90)
        turtle.speed(0) # fastest
        turtle.hideturtle()
        turtle.tracer(0, 1)
	
        # set pencolor
        self.pencolor()
Example #7
0
    def draw(self):
        super(DragonLSystem, self).draw()

        turtle.setup(800,600)
        wn = turtle.Screen()
        wn.bgcolor('lightblue')
        wn.title("Wingled Dragon")

        self.turtle = turtle.Turtle()
        self.turtle.shape('blank')
        turtle.tracer(int(sys.argv[2]),25)
        t = self.turtle
        t.reset()

        t.penup()
        t.setpos(-200,0)
        t.pendown()
        i = 200.0
        for c in self.state:
            if c == "F":
                t.forward(math.ceil(i))
            elif c == "+":
                t.right(90)
            elif c == "-":
                t.left(90)
            elif c == "C":
                i = i/math.sqrt(2)
                t.left(45)

        wn.exitonclick()
def extension1():
	turtle.tracer(False)
	for i in range(50):
		turtle.setheading( random.randint(0,360))
		shapelib.parallelogram( random.randint(-350,-250),
							random.randint(-300, 300),
							random.random(), 'red')
	for i in range(50):
		turtle.setheading( random.randint(0,360))
		shapelib.cross( random.randint(-200, -100),
						random.randint(-300, 300),
						random.random(), 'yellow')
	for i in range(50):
		turtle.setheading( random.randint(0,360))
		shapelib.star( random.randint(-50, 50),
						random.randint(-300, 300),
						random.random(), 'pink')
	for i in range(50):
		turtle.setheading( random.randint(0,360))
		shapelib.star( random.randint(100, 200),
							random.randint(-300, 300),
							random.random(), 'orange')
	for i in range(50):
		turtle.setheading( random.randint(0,360))
		shapelib.cross( random.randint(250, 350),
						random.randint(-300, 300),
						random.random(), 'green')
	for i in range(50):
		turtle.setheading( random.randint(0,360))
		shapelib.parallelogram( random.randint(400, 500),
						random.randint(-300, 300),
						random.random(), 'blue')
def skyobjects( x, y, scale ):
	'''puts all of the objects in sky functions togehter'''
	t.tracer(False)
	star(x-300*scale, y+225*scale, 1*scale, 'True', 'orange')
	cloud(x+250*scale, y+200*scale, 1*scale, 'gray')
	cloud(x+175*scale, y+125*scale, 0.5*scale, 'gray')
	cloud(x+125*scale, y+215*scale, 0.25*scale, 'gray')
def Run():
    #bounds
    nearRange = [0, 50]
    farRange = [50, 200]
    frusHL = 100

    #Logic
    nearDist = random.uniform(nearRange[0], nearRange[1])
    farDist = random.uniform(farRange[0], farRange[1])
    d = frusHL * 2
    an = nearDist
    af = farDist
    b = (d*d + af*af - an*an) / (2 * d)
    radius = math.sqrt(b*b + an*an)
    originY = -frusHL + b

    #text.insert('end', 'Origin: %d\n' % originY)

    #Render
    turtle.clear()
    turtle.hideturtle()
    turtle.tracer(0, 0)
    turtle.penup()
    turtle.goto(-farDist, frusHL)
    turtle.pendown()
    turtle.goto(-nearDist, -frusHL)
    turtle.goto(nearDist, -frusHL)
    turtle.goto(farDist, frusHL)
    turtle.goto(-farDist, frusHL)
    turtle.penup()
    DrawCircle(0, originY, radius);
    turtle.update()
    def __init__(self, model):
        """Initialize the view at the starting of the application."""
        self.model = model

        self.cellWidth = self.CELL_WIDTH
        self.model = model
        self.gridSize = model.GRID_SIZE
        self.player = self.model.player1
        self.screen = turtle.Screen()
        self.gridWidth = self.CELL_WIDTH * self.gridSize
        self.playerGrid = self.player.getGrid(self.player.PLAYER_GRID)
        self.enemyGrid = self.player.getGrid(self.player.OPPONENT_GRID)
        self.iconsToDraw = []

        turtle.title('BATTLESHIP : {} vs {}'.format(
            self.model.player1.playerName, self.model.player2.playerName))
        self.__setScreen()
        self.__setColor()
        turtle.tracer(0, 0)

        gridWidth = self.gridWidth
        gridAnchorPoints = []
        gridAnchorPoints.append((
            -self.width/2 + self.GRID_MARGINLEFT,
            self.height/2 - self.GRID_MARGINTOP - gridWidth))
        gridAnchorPoints.append((
            self.width/2 - gridWidth - self.GRID_MARGINRIGHT,
            self.height/2 - self.GRID_MARGINTOP - gridWidth ))

        self.__drawGrid(gridAnchorPoints[0], gridWidth)
        self.__drawGrid(gridAnchorPoints[1], gridWidth)

        self.gridAnchorPoints = gridAnchorPoints
Example #12
0
def foliageRight( x, y, scale):
	''' foliage scenery right side of image
			use tree() and leaf() functions defined earlier
			to make a variety of size and color foliage
			using for loops to make multiple'''
	t.tracer(False)
	for i in range(5):
		tree( x+random.randint( 100, 350 )*scale,
				y+random.randint( -300, -100 )*scale,
				random.randint( 1, 2 )*scale)
	for i in range(10):
		leaf( x+random.randint( 100, 300 )*scale,
				y+random.randint( -300, -100 )*scale,
				random.random()*scale,
				'red' )
	for i in range(10):
		leaf( x+random.randint( 100, 300 ),
				y+random.randint( -300, -100 ),
				random.random()*scale,
				'orange' )
	for i in range(10):
		leaf( x+random.randint( 100, 300 )*scale,
				y+random.randint( -300, -100 )*scale,
				random.random()*scale,
				'yellow' )	
 def setTurtle(self):
     """Initializes the turtle object and screen object, while also setting the speed to the maximum"""
     
     self.t = turtle.Turtle()
     self.s = turtle.Screen()
     self.t.speed(0)
     turtle.tracer(0,0)
Example #14
0
def setup():
    turtle.hideturtle()
    turtle.tracer(1e3,0)
    turtle.left(90)
    turtle.penup()
    turtle.goto(-100,-100)
    turtle.pendown()
def tree1(argv, x, y):
	lsys_filename1 = argv[1]
	lsys1 = ls.createLsystemFromFile( lsys_filename1 )
	print lsys1
	num_iter1 = int( 3 )
	dist = float( 5 )
	angle1 = float( 22 )
	
	s1 = ls.buildString( lsys1, num_iter1 )
	
	#draw lsystem1
	'''this is my first lsystem
		with filename mysystem1.txt
		with 3 iterations and
		with angle = 45 dist = 10'''
	turtle.tracer(False)
	turtle.speed(50000000)
	turtle.up()
	turtle.goto(0,0)
	turtle.goto(x, y)
	turtle.down()
	turtle.pencolor('White')
	it.drawString( s1, dist, angle1 )
	
	# wait and update
	turtle.update()
Example #16
0
def drawSetup(title,xlimits,xscale,ylimits,yscale,axisThickness=None):
	turtle.title(title)
	xmin, xmax = xlimits
	ymin, ymax = ylimits
	#turtle.setup(xmax-xmin,ymax-ymin,0,0) #window-size
	globals()['xmin'] = xmin
	globals()['xmax'] = xmax
	globals()['ymin'] = ymin
	globals()['ymax'] = ymax
	globals()['xscale'] = xscale
	globals()['yscale'] = yscale

	turtle.setworldcoordinates(xmin,ymin,xmax,ymax)
	#turtle.speed(0) #turtle.speed() does nothing w/ turtle.tracer(0,0)
	turtle.tracer(0,0)

	drawGrid()
	#drawGridBorder()
	
	turtle.pensize(axisThickness)

	drawXaxis()
	drawXtickers()
	numberXtickers()
	
	drawYaxis()
	drawYtickers()
	numberYtickers()

	turtle.pensize(1)
Example #17
0
    def __init__(self):
        # Janela sobre
        self.janSobre = None


        # Cor de fundo
        self.corFundo = "gray"


        turtle.screensize(1000, 700, self.corFundo)
        turtle.setup(width=1000, height=700)
        turtle.title("cidadeBela - Janela de desenho")


        turtle.speed(0)
        turtle.tracer(4)

        # Definindo variáveis globais
        self._tamPadrao = ""

        # Listas de prédios
        self.predios = ['Casa', 'Hotel']
        self.prediosProc = [ 'hotel', 'hotelInv', 'casa', 'casaInv' ]


        # Sorteando elementos
        self.sorteioPredios    = [["casa", 1], ["hotel", 1]]
        self.sorteioPrediosInv = [["casaInv", 1], ["hotelInv", 1]]


        #  Cores dos prédios
        self.coresHotel = ["076080190", "255255255", "167064057", "153204255", "000090245",
                           "201232098", "255058123", "010056150", "130255255", "255255000",
                           "255000000", "255127042", "000255000", "255170255", "000255170",
                           "212000255", "170255127", "127212255", "255127127", "255212085",
                           "212212255", "255255127", "222202144" ]
        self.coresCasa  = ['209187103', '115155225', '130047006', '255137111', '203229057',
                           '017130100', '025195159', '204057065', '194082255', '092221159',
                           '167045055', '238243030', '069241248', '000156228', '159094040',
                           '048033253', '040209239', '138164253', '190042177', '000122159',
                           '255255255', '253208201', '245228133']
        self.coresLoja  = ['255255255', '253208201', '245228133' ]

        #  Janelas dos prédios
        self.janelasHotel = janelas.janelasHotel
        self.janelasCasa  = janelas.janelasCasa
        self.janelasLoja  = janelas.janelasLoja
        self.janelasTodas = janelas.janelasTodas

        #  Tetos dos prédios
        self.tetosHotel = tetos.tetosHotel
        self.tetosCasa  = tetos.tetosCasa
        self.tetosLoja  = tetos.tetosLoja
        self.tetosTodas = tetos.tetosTodas

        #  Portas dos prédios
        self.portasHotel = portas.portasHotel
        self.portasCasa  = portas.portasCasa
        self.portasLoja  = portas.portasLoja
        self.portasTodas = portas.portasTodas
Example #18
0
def floor( x, y, scale ):
	t.tracer(False)
	position1 = [-600, -500, -400, -300, -200, -100, 0, 100, 200, 300, 400, 500]
	position2 = [-550, -450, -350, -250, -150, -50, 50, 150, 250, 350, 450,  550]
	for i in range(len(position1)):
		t.begin_fill()
		t.color('Black')
		bsl.buildingblock(x+position1[i]*scale, y-300*scale, 50*scale, 50*scale)
		t.end_fill()
	for i in range(len(position1)):
		t.begin_fill()
		t.color('Gold')
		bsl.buildingblock(x+position2[i]*scale, y-300*scale, 50*scale, 50*scale)
		t.end_fill()
	for i in range(len(position1)):
		t.begin_fill()
		t.color('Gold')
		bsl.buildingblock(x+position1[i]*scale, y-250*scale, 50*scale, 50*scale)
		t.end_fill()
	for i in range(len(position1)):
		t.begin_fill()
		t.color('Black')
		bsl.buildingblock(x+position2[i]*scale, y-250*scale, 50*scale, 50*scale)
		t.end_fill()
	for i in range(len(position1)):
		t.begin_fill()
		t.color('Black')
		bsl.buildingblock(x+position1[i]*scale, y-200*scale, 50*scale, 50*scale)
		t.end_fill()
	for i in range(len(position1)):
		t.begin_fill()
		t.color('Gold')
		bsl.buildingblock(x+position2[i]*scale, y-200*scale, 50*scale, 50*scale)
		t.end_fill()
Example #19
0
  def draw(self, w, h, dot = False):
    norm = CoordinateNormalizer(self, w, h)
    window = turtle.Screen()
    cursor = turtle.Turtle()

    window.setup(w, h)
    window.setworldcoordinates(0, 0, w, h)
    window.delay(0)

    cursor.ht()

    turtle.tracer(0)

    cursor.up()
    for way in self.getWays():
      tags = self.ways[way].tags
      line = self.getPolyline(way)
      for (x, y) in line:
        cursor.pencolor('black')
        x, y = norm(x, y)
        cursor.setpos(x, y)
        if dot:
          cursor.dot()
        if not cursor.isdown():
          cursor.down()
      cursor.up()

    turtle.update()

    window.exitonclick()
Example #20
0
   def initialize_plot(self, positions):
      self.positions = positions
      self.minX = minX = min(x for x,y in positions.values())
      maxX = max(x for x,y in positions.values())
      minY = min(y for x,y in positions.values())
      self.maxY = maxY = max(y for x,y in positions.values())
      
      ts = turtle.getscreen()
      if ts.window_width > ts.window_height:
          max_size = ts.window_height()
      else:
          max_size = ts.window_width()
      self.width, self.height = max_size, max_size
      
      turtle.setworldcoordinates(minX-5,minY-5,maxX+5,maxY+5)
      
      turtle.setup(width=self.width, height=self.height)
      turtle.speed("fastest") # important! turtle is intolerably slow otherwise
      turtle.tracer(False)    # This too: rendering the 'turtle' wastes time
      turtle.hideturtle()
      turtle.penup()
      
      self.colors = ["#d9684c","#3d658e","#b5c810","#ffb160","#bd42b3","#0eab6c","#1228da","#60f2b7" ]

      for color in self.colors:         
         s = turtle.Shape("compound")
         poly1 = ((0,0),(self.cell_size,0),(self.cell_size,-self.cell_size),(0,-self.cell_size))
         s.addcomponent(poly1, color, "#000000")
         turtle.register_shape(color, s)
      
      s = turtle.Shape("compound")
      poly1 = ((0,0),(self.cell_size,0),(self.cell_size,-self.cell_size),(0,-self.cell_size))
      s.addcomponent(poly1, "#000000", "#000000")
      turtle.register_shape("uncolored", s)
Example #21
0
def sky( x, y, scale ):
	'''draws a huge blue square given location and scale'''
	t.tracer(False)
	t.begin_fill()
	t.color('light blue')
	buildingblock(x-1000*scale, y+0*scale, 2000*scale, 1075*scale)
	t.end_fill()
Example #22
0
def grass( x, y, scale ):
	'''draws a huge blue square given location and scale'''
	t.tracer(False)
	t.begin_fill()
	t.color('green')
	buildingblock(x-1000*scale, y-1000*scale, 2000*scale, 1075*scale)
	t.end_fill()
def drawPattern(turt, offx, offy, radius, step):
    # Points is the number of points per side, NOT including the corner points
    # Draw lines between the points around teh box in the given pattern
    # drawRect(turt, offx, offy, sizex, sizey)        # Basic rectangle to outline the shape
    pointsl = drawCricle(turt, offx, offy, radius, step)

    turtle.tracer(1)
    for p in range(len(pointsl)):
        turt.color(getRandColor(cols))
        for p2 in range(len(pointsl)-3):
            if not p+p2+2 > len(pointsl)-1:
                drawLine(turt, pointsl[p][0], pointsl[p][1], pointsl[p+p2+2][0], pointsl[p+p2+2][1])
            else:
                drawLine(turt, pointsl[p][0], pointsl[p][1], pointsl[p+p2+2 - len(pointsl)][0], pointsl[p+p2+2 - len(pointsl)][1])



    turtle.update()
    # Draw a nice looking border around the rectangle
    # turt.pensize(10)            # Make it thick
    # drawRect(turt, offx, offy, sizex, sizey)
    # turt.pensize(1)             # Reset pen size
    turt.penup()
    turt.setpos(offx, offy)     #Sit in the centre of the circle at the end
    turtle.update()
Example #24
0
def foliageLeft():
	''' foliage scenery left side of image
			use tree() and leaf() functions defined earlier
			to make a variety of size and color foliage
			using for loops to make multiple'''
	turtle.tracer(False)
	for i in range(5):
		tree( random.randint( -300, -100 ),
				random.randint( -300, -100 ),
				random.randint( 1, 2 ))
	for i in range(10):
		leaf( random.randint( -300, -100 ),
				random.randint( -300, -100 ),
				random.random(),
				'red' )
	for i in range(10):
		leaf( random.randint( -300, -100 ),
				random.randint( -300, -100 ),
				random.random(),
				'orange' )
	for i in range(10):
		leaf( random.randint( -300, -100 ),
				random.randint( -300, -100 ),
				random.random(),
				'yellow' )
Example #25
0
def main():  
    # 打开/关闭龟动画,并为更新图纸设置延迟。  
    turtle.tracer(False)  
    Init()  
    SetupClock(160)  
    turtle.tracer(True)  
    Tick()  
    turtle.mainloop()  
def drawRect(t, x1, y1, sizex, sizey):
    # Simply draws a rectangle
    turtle.tracer(0)            # If this is 0, the rectangle is drawn instantly
    drawLine(t, x1 - sizex/2, y1 - sizey/2, x1 + sizex/2, y1 - sizey/2)     # Up
    drawLine(t, x1 - sizex/2, y1 + sizey/2, x1 + sizex/2, y1 + sizey/2)     # Down
    drawLine(t, x1 - sizex/2, y1 - sizey/2, x1 - sizex/2, y1 + sizey/2)     # Left
    drawLine(t, x1 + sizex/2, y1 - sizey/2, x1 + sizex/2, y1 + sizey/2)     # Right
    turtle.update()
Example #27
0
def main(i):
    t.speed('fastest'); t.tracer(1,0); t.colormode(255)

    t.lt(90)
    while (i >= 1):
        drawLineOfSqrs(i)
        i -= 1
    raw_input()
Example #28
0
def painting( x, y, scale ):
	t.tracer(False)
	t.begin_fill()
	t.color('Brown')
	bsl.buildingblock(x-400*scale, y-75*scale, 250*scale, 250*scale)
	t.end_fill()
	bsl.myscene2(-275, 50,.10)
	t.setheading(0)
Example #29
0
 def __init__(self):
   self.turtle = turtle.Turtle()
   self.turtle.hideturtle()
   self.struct_header = '>III'
   self.size = 40
   self.mh = None
   self.reset()
   turtle.tracer(__DEBUG__)
Example #30
0
 def drawleaf(self):
     turtle.tracer(0)
     self.turt.color("green")
     self.turt.pensize(random.randint(5, 10))
     self.turt.penup()
     self.turt.right(random.randint(-20, 20))
     self.turt.pendown()
     self.turt.forward(10)