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()
Exemple #2
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()
Exemple #3
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()
Exemple #4
0
def setup():
    turtle.hideturtle()
    turtle.tracer(1e3,0)
    turtle.left(90)
    turtle.penup()
    turtle.goto(-100,-100)
    turtle.pendown()
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')
Exemple #6
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)
Exemple #7
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
 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)
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()
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' )	
Exemple #11
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
Exemple #12
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)
Exemple #13
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)
Exemple #14
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' )
Exemple #15
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()
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()
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()
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 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 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 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()
Exemple #22
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()
Exemple #23
0
def setup():
    turtle.hideturtle()
    turtle.tracer(1e3,0)
    turtle.left(90)
    turtle.penup()
    turtle.goto(0,-turtle.window_height()/2)
    turtle.pendown()
    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
 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__)
Exemple #26
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()
Exemple #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)
Exemple #29
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()
 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)
Exemple #31
0
import lampe
import turtle
import collections
import copy

window = turtle.Screen()
lines = []
currentLine = [0]

colors = ["nothing", "red", "blue", "green", "pink", "yellow", "brown"]
code = ["red", "blue", "red", "red"]
currentColorSelection = ["", "", "", ""]

turtle.tracer(False, 0)

for i in range(10):
    line = []
    for j in range(4):
        l = lampe.Lampe(50 * j - 20, 40 * i - 200, 20, "gray")
        l.anschalten()
        line.append([l, 0])
        turtle.update()
    for j in range(2):
        for k in range(2):
            l = lampe.Lampe(10 * k - 65, 40 * i + 10 * j - 200, 5, "red")
            l.anschalten()
            line.append([l, 0])
            turtle.update()
    lines.append(line)
l = lampe.Lampe(250, -180, 40, "blue")
l.anschalten()
Exemple #32
0
import turtle as t
import string


def write(char):
    def _write():
        t.clear()
        t.write(char, align="center", font=f"Arial {s}")
        t.update()

    return _write


s = 300
t.hideturtle()
t.tracer(False)
t.color("red")
t.up()
t.right(90)
t.forward(2 * s // 3)
t.down()

chars = string.ascii_letters + string.digits
for i in range(len(chars)):
    t.onkey(write(chars[i]), chars[i])

t.listen()
t.exitonclick()
import turtle
from turtle import *
import random
import math
import time
from platform import Platform
from player import *
import tkinter as tk

turtle.setup(900, 800)
turtle.tracer(100, 1)
turtle.hideturtle()
running = True
sleep = 0.0077
turtle.pu()
screen_width = turtle.getcanvas().winfo_width() // 2
screen_height = turtle.getcanvas().winfo_height() // 2

turtle.register_shape("galaxy.gif")
turtle.register_shape("clouds(1).gif")
turtle.register_shape("abed.gif")
turtle.register_shape("ahmad.gif")
turtle.register_shape("kidjumping(1).gif")
turtle.register_shape("gal.gif")
turtle.register_shape("sadek.gif")
turtle.register_shape("background(1).gif")
turtle.register_shape("uriel.gif")
turtle.register_shape("mahed.gif")

turtle.bgpic("background(1).gif")
number_of_platforms = 5
Exemple #34
0
"""Sierpinkski's Game, by Al Sweigart [email protected]

Sierpinkski's "game" is an algorithm that draws Sierpinski's Triangle
with turtle graphics.
More info at https://en.wikipedia.org/wiki/Chaos_game"""
__version__ = 0

import turtle
import random, time
turtle.tracer(60, 0)  # Make the turtle draw faster.
turtle.setworldcoordinates(0, 0, 960, 810)

DOT_SIZE = 3
NUMBER_OF_DOTS = 1500


def main():
    turtle.bgcolor(0.1, 0.1, 0.1)
    turtle.penup()
    while True:
        # Pick a random color to draw with:
        redAmount = random.randint(50, 100) / 100.0
        greenAmount = random.randint(50, 100) / 100.0
        blueAmount = random.randint(50, 100) / 100.0
        turtle.pencolor(redAmount, greenAmount, blueAmount)

        # Pick three random points for the triangle:
        ax = random.randint(0, 960)
        ay = random.randint(0, 810)
        bx = random.randint(0, 960)
        by = random.randint(0, 810)
import turtle
import random

turtle.tracer(1, 0)
enemy = turtle.clone()
enemy.penup()
enemy.goto(200, 0)
turtle.register_shape("ghost_F.gif")
enemy.shape("ghost_F.gif")
#enemy.shape("circle")
#screan size
SIZE_X = 1028
SIZE_Y = 800
turtle.setup(SIZE_X, SIZE_Y)
#square size
SQUARE_SIZE = 20

#installing arrows
UP_ARROW = "Up"
DOWN_ARROW = "Down"
RIGHT_ARROW = "Right"
LEFT_ARROW = "LEFT"
TIME_STEP = 100
#lists
pos_list = []
enemy_pos_list = []
turtle.penup()

UP = 0
DOWN = 1
RIGHT = 2
Exemple #36
0
import turtle
import time 
import random
import math 
from ball import Ball

#part 1 create a ball


turtle.tracer(0)
turtle.hideturtle()
turtle_gameover = turtle.clone()
runinng =  True 
screen_width = turtle.getcanvas().winfo_width()/2
screen_hight = turtle.getcanvas().winfo_height()/2
turtle.colormode(255)

def random_color():
    r = random.randint(0,255)
    g = random.randint(0,255)
    b = random.randint(0,255)
    return (r,g,b)

my_ball = Ball(100,35,21,23,50,random_color())

number_of_balls = 5
minimum_ball_radius = 10
maximum_ball_radius = 100
minimum_ball_dx = -5
maximum_ball_dx = 5
minimum_ball_dy = -5
Exemple #37
0
import turtle
import random
turtle.tracer(5)
wn = turtle.Screen()
wn.bgcolor('blue')
#turtle.tracer(5)
t = turtle.Turtle('turtle')
#t.hideturtle()

t.pensize(2)
#t.up()
clr = [
    'red', 'brown', 'blue', 'pink', 'gold', 'violet', 'navy', 'green',
    'firebrick'
]


def draw_star(points, size, x, y):
    t.up()
    t.goto(x, y)
    t.down()
    angle = 180 - (180 / points)
    t.color(random.choice(clr))
    t.begin_fill()
    for m in range(points):
        t.fd(size)
        t.rt(angle)
    t.end_fill()


draw_star(12, 100, 200, -100)
import turtle
import random  #We'll need this later in the lab
turtle.register_shape("Smiley.gif")
turtle.bgcolor("black")
turtle.tracer(1, 0)  #This helps the turtle move more smoothly
score_turtle = turtle.clone()
score_turtle.hideturtle()
score = 0
SIZE_X = 1500
SIZE_Y = 1000
turtle.setup(1500, 1000)  #Curious? It's the turtle window
#size.
turtle.penup()

SQUARE_SIZE = 20
START_LENGTH = 6

#Initialize lists
pos_list = []
stamp_list = []
food_pos = []
food_stamps = []

UP_EDGE = 500
DOWN_EDGE = -500
RIGHT_EDGE = 750
LEFT_EDGE = -750
#Set up positions (x,y) of boxes that make up the snake
snake = turtle.clone()
snake.shape("Smiley.gif")
Exemple #39
0
# def draw_circle(ttl):
#     x = random.randint(-200, 200) #получаем случайные координаты
#     y = random.randint(-200, 200)

#     ttl.color('violet') #устанавливаем цвет линии
#     ttl.penup() # убираем "ручку" от холста, чтобы переместить в нужное место
#     ttl.setpos(x, y) # перемещаем в "основание" - это будет самая низкая точка
#     ttl.pendown() #опускаем ручку обратно

#     ttl.circle(25) #рисуем круг радиуса 25



# def main():
turtle.tracer(0, 0) #устанавливаем все задержки в 0, чтобы рисовалось мгновенно
turtle.hideturtle() #убираем точку посередине

ttl = turtle.Turtle() #создаём объект черепашки для рисования
ttl.hideturtle() #делаем её невидимой

while True:
    time.sleep(0.2) #засыпаем на полсекунды, чтобы увидеть что нарисовали
    ttl.clear() #очищаем всё нарисованое ранее
    rectangle.draw()
    rectangle.random_move(100)
    triangle.draw()
    triangle.random_move(100)
    circle.draw()
    circle.random_move(20)
    quadrangle.draw()
Exemple #40
0
import turtle
import random
import town
from town import *

turtle.speed( 'fastest' )
turtle.tracer( False )

draw_field( )

num_of_rows = 14
num_of_cols = 14

for r in range( 0, num_of_rows ):
    for c in range( 0, num_of_cols ):
        x = ( c - (num_of_cols - 1) / 2 ) * 7 + random.uniform( -1.0, 1.0 )
        y = ( r - (num_of_rows - 1) / 2 ) * 7
        x_screen, y_screen = world_to_screen( x, y )
        size = 3 * world_to_scale( x, y )
        type_list = [ 'lex', 'anya' ]
        house_type = random.choice( type_list )
        color_list = [ 'yellow', 'orange', 'red', 'maroon', 'violet',
                       'magenta', 'navy', 'blue', 'cyan', 'turquoise',
                       'chocolate', 'gray' ]
        house_color = random.choice( color_list )
        color_list.remove( house_color )
        roof_color = random.choice( color_list )
        color_list.remove( roof_color )
        door_color = random.choice( color_list )
        color_list.remove( door_color )
Exemple #41
0
    Xh = x - x2
    Yh = y - y2


def smooth_r(x2, y2, x, y):  # 平滑三阶贝塞尔曲线到相对坐标(x,y)
    global Xh
    global Yh
    te.penup()
    X_now = te.xcor() + Width / 2
    Y_now = Height / 2 - te.ycor()
    Bezier_3(X_now, Y_now, X_now + Xh, Y_now + Yh,
             X_now + x2, Y_now + y2, X_now + x, Y_now + y)
    Xh = x - x2
    Yh = y - y2

te.tracer(10)
te.setup(Width, Height, 0, 0)
te.pensize(1)
te.speed(Speed)
te.penup()

# 图层_2
# time.sleep(20)
te.color("black", "#F2F2F2")  # 外套
Moveto(61, 462)
te.begin_fill()
smooth_r(12, -41, 27, -58)
curveto_r(-6, -36, 6, -118, 9, -132)
curveto_r(-15, -27, -23, -51, -26, -74)
curveto_r(4, -66, 38, -105, 65, -149)
Horizontal(486)
Exemple #42
0
# Python Intro Turtle Graphics

# Python has a rich "library" of functions.
# We are going to use "turtle" to do some simple graphics.
import turtle
from random import randint

if __name__ == "__main__":
    # Setup our drawning surface
    turtle.setup(800,600)     # Sets up the size of the window
    turtle.Screen()           # Turns on the graphics window

    width = 50                # Create a variable called "width"

    turtle.tracer(0,0);
    turtle.pencolor("white")
    turtle.goto(0,300)
          # and make it equal to 10
                              
    # Do some turtle graphics commands
    # Notice all commands from the turtle library is prefixed by "turtle."
    for x in range(0, 1000):
        turtle.pencolor((randint(0, 255)/255.0,
                         randint(0, 255)/255.0,
                         randint(0, 255)/255.0))
        for y in range(0, 360):
            turtle.forward((x+5)/10)
            turtle.right(1)
            
    turtle.update();
    def __init__(self, sid, sname, snickname, cid, auth):

        # validate student id
        if STUDENT_ID == '2018123456':
            print('\n\nInvalid STUDENT_ID!')

        # student info
        self.sid = sid
        self.sname = sname
        self.snickname = snickname
        self.cid = cid
        self.auth = auth

        # screen dimension
        self.swidth = 1000
        self.sheight = 500
        self.margin = 100

        # init turtle module
        self.screen = turtle.Screen()
        turtle.setup(self.swidth + self.margin * 2,
                     self.sheight + self.margin * 2)
        turtle.tracer(0, 0)

        # a tutle for drawing nodes
        self.turtle_node = turtle.Turtle()
        self.turtle_node.shape('circle')
        self.turtle_node.color('navy')
        self.turtle_node.shapesize(0.4)
        self.turtle_node.penup()
        self.turtle_node.ht()

        # a tutle for drawing paths
        self.turtle_path = turtle.Turtle()
        self.turtle_path.color('green')
        self.turtle_path.ht()

        # a tutle for drawing texts
        self.turtle_text = turtle.Turtle()
        self.turtle_text.ht()
        self.turtle_text.penup()

        # texts
        self.title_text = 'Traveling Salesman Problem'
        self.name_text = '{} {} ({})'.format(self.sid, self.sname,
                                             self.snickname)
        self.status_text = ''
        self.menu_text = 'Key: (1) Random (2) Greedy (3) 2-Opt (Q) QUIT'

        # init path
        self.path = []
        self.path_length = 0
        self.path_to_be_uploaded = None

        # draw timer
        self.upload_timer = 0
        self.draw_timer = 0

        # initialize nodes
        self.download_from_server()

        # initial drawing
        self.draw()
        self.write_texts()
Exemple #44
0
    def drawString(self, dstring, distance, angle):
        """ 
		Interpret the characters in string dstring as a series
      	of turtle commands. Distance specifies the distance
      	to travel for each forward command. Angle specifies the
      	angle (in degrees) for each right or left command. The list of 
      	turtle supported turtle commands is:
      	F : forward
      	- : turn right
      	+ : turn left
      	[ : save position, heading
      	] : restore position, heading
      	< : saves color
      	> : restore color
      	g : set color to green
      	y : set color to light yellow
      	r : set color to light red
      	B : set color to brown
      	L : draws a filled in semicircular leaf
      	f : fills in shape
      	n : ends filling in shape
      	R : set color to brightest red possible
      	b : set color to black
      	s : set color to light blue
      	"""
        stack = []
        colorstack = []
        for c in dstring:
            turtle.tracer(False)
            if c == 'F':
                turtle.forward(distance)
            elif c == '+':
                turtle.left(angle)
            elif c == '-':
                turtle.right(angle)
            elif c == '[':
                stack.append(turtle.position())
                stack.append(turtle.heading())
            elif c == ']':
                turtle.up()
                turtle.setheading(stack.pop())
                turtle.goto(stack.pop())
                turtle.down()
            elif c == 'B':
                turtle.color('brown')
            elif c == '<':
                colorstack.append(turtle.color()[0])
            elif c == '>':
                turtle.color(colorstack.pop())
            elif c == 'g':
                turtle.color((0.15, 0.5, 0.2))
            elif c == 'y':
                turtle.color((0.8, 0.8, 0.3))
            elif c == 'r':
                turtle.color((0.7, 0.2, 0.3))
            elif c == 'L':
                turtle.fill(True)
                turtle.circle(distance, 180)
                turtle.fill(False)
            elif c == 'f':
                turtle.fill(True)
            elif c == 'n':
                turtle.fill(False)
            elif c == 'R':
                turtle.color('red')
            elif c == 'b':
                turtle.color('black')
            elif c == 's':
                turtle.color('lightblue')
def aumenta_velocidade_de_Robertina (  ) :

    turtle.delay ( 0 )
    Robertina.color ( "yellow" )
    Robertina.speed ( 9 )
    turtle.tracer ( 30, 0 )
Exemple #46
0
 def __init__(self, dx=800, dy=800):
     turtle.setup()
     turtle.tracer(False)
Exemple #47
0
    # Start fill
    t.color(r.colour)
    t.pencolor("black")
    t.begin_fill()

    # Go to the next three coordinates in order
    for i in range(1, 4):
        t.goto(points[i])

    # End fill
    t.end_fill()


# Set up turtle
t.tracer(0, 0)
t.hideturtle()

# Create a rectangle
r = Rect(-50, 50, 200, 200, "blue", 0)

# Game loop
while True:

    # Clear the canvas
    t.clear()

    # Draw a rect
    drawRect(r)

    # Rotate r
import os
import random

import turtle
turtle.title("Space Wars")
turtle.fd(0)
turtle.speed(0)
turtle.bgcolor("black")
turtle.ht()
turtle.setundobuffer(1)
turtle.tracer(1)

class Sprite(turtle.Turtle):
*tab*def __init__(self, spriteshape, color, startx, starty):
*tab**tab*turtle.Turtle.__init__(self, shape = spriteshape)
*tab**tab*self.speed(0)
*tab**tab*self.penup()
*tab**tab*self.color(color)
*tab**tab*self.fd(0)
*tab**tab*self.goto(startx, starty)
*tab**tab*self.speed = 1

*tab*def move(self):
*tab**tab*self.fd(self.speed)
*tab**tab*if self. xcor() > 290:
*tab**tab**tab*self.setx(290)
*tab**tab**tab*self.rt(60)

*tab**tab*if self. xcor() < -290:
*tab**tab**tab*self.setx(-290)
*tab**tab**tab*self.rt(60)
Exemple #49
0
# Maze Game python code

import turtle
from math import sqrt, acos, pi
import random as r

# Create a screen
screen = turtle.Screen()
screen.bgcolor("black")
screen.title("Maze Game")
screen.setup(800, 800)

turtle.setundobuffer(1)  #limits the memory to undo.
turtle.tracer(0)  #update speed


# Create a pen
class Pen(turtle.Turtle):
    def __init__(self):
        turtle.Turtle.__init__(self)
        self.shape("square")
        self.color("white")
        self.penup()
        self.speed(0)


# Create objective
class Objective(turtle.Turtle):
    def __init__(self):
        turtle.Turtle.__init__(self)
        self.shape("circle")
Exemple #50
0
import turtle as tu
import math

lines = 10

with open("1miopi.txt", "r") as f:
    pi = f.read()

print(pi[0:10])  # gib mir nur die ersten 10 Zeichen wieder der gegebenen Liste
print(pi[-10:])  #du sollst anfangen 10 zeichen vor Ende und das ausdrucken
tu.mode("logo")
tu.tracer(False)
tu.screensize(5000, 5000, "black")
#tu.pencolor("red")
tu.colormode(255)

for n in range(
        lines
):  #schritt der wiederholung =n #lines ist definiert, wie oft soll er wiederholen?
    color = int(n / (lines / 255))
    b = color
    if color < 20:
        g = 0
    else:
        g = 255 - color
    if 235 < g < 200:
        r = 0
    else:
        if color < 240:
            r = 255
        else:
Exemple #51
0
# Arleth Salinas
# Lab 4
# August 4, 2019; 10pm

# Imports the turtle graphics module
import turtle

# creates a turtle (pen) an sets the speed (where 0 is fastest and 10 is slowest)
# The colors can be set through their names or through hexadecimal codes, use hex for accuracy
startingX = -200
startingY = 200
turtle.screensize(200, 200, bg="#FFFFFF")
turtle.tracer(60)
myPen = turtle.Turtle()
myPen.color("#000000")
myPen.speed(0)
doneDrawing = False

# If you would like to slow down the animation, uncomment the next line. Higher delay, the slower it will be
#turtle.delay(100)

# setting out box sizes to the n sq pixels per box
boxSize = 10

#paths of each art piece
choices = [
    'art/banana.txt', 'art/blinky.txt', 'art/epic_smiley_face.txt',
    'art/mario.txt', 'art/mushroom.txt', 'art/heart.txt', 'art/sushi.txt'
]
#names of each art piece
choiceNames = [
Exemple #52
0
def main():
    """ Main function. """
    trt.hideturtle()
    trt.tracer(0)

    screen = trt.getscreen()
    answer = screen.textinput('Welcome!', ru.WELCOME)

    if answer == '1':
        data = get_data(100, 20)
        place('1')
        sq(data['size'], data['depth'])

    elif answer == '2':
        data = get_data(100, 4)
        place('2')
        tree(data['size'], data['depth'])

    elif answer == '3':
        data = get_data(400, 3)
        place('3')
        branch(data['depth'], data['size'])

    elif answer == '4':
        data = get_data(500, 3)
        place('4')
        koch(data['depth'], data['size'])

    elif answer == '5':
        data = get_data(100, 3)
        place('5')
        snowflake(data['depth'], data['size'])

    elif answer == '6':
        data = get_data(200, 3)
        place('6')
        mink(data['depth'], data['size'])

    elif answer == '7':
        data = get_data(50, 3)
        place('7')
        ice_fractal(data['size'] * 10, data['depth'])

    elif answer == '8':
        data = get_data(50, 3)
        place('7')
        ice_2fractal(data['size'] * 10, data['depth'])

    elif answer == '9':
        data = get_data(150, 3)
        place('7')
        ice_snowflake(data['size'], data['depth'])

    elif answer == '10':
        data = get_data(20, 7)
        place('6')
        lev(data['depth'], data['size'])

    elif answer == '11':
        data = get_data(200, 12)
        place('6')
        dragon(data['depth'], data['size'], 1)

    trt.update()
    trt.mainloop()
Exemple #53
0
def main():
    screen = turtle.Screen()
    turtle.mode('standard')
    xspan, yspan = screen.screensize()
    turtle.setworldcoordinates(0, 0, xspan, yspan)

    # makes the turtle invisible, improves drawing speed
    turtle.hideturtle()
    # fastest speed for the drawing
    turtle.speed('fastest')
    # no tracing within turtle, improves drawing speed
    turtle.tracer(0, 0)
    # turtle pen is off the canvas to start
    turtle.penup()

    board = Grid(xspan // SIZE, yspan // SIZE)

    def flip_state(x, y):
        x_cell = x // SIZE
        y_cell = y // SIZE
        board.flip_state(x_cell, y_cell)
        board.display()

    turtle.onscreenclick(turtle.listen)
    turtle.onscreenclick(flip_state)

    def clear_board():
        board.clear_board()
        board.display()

    # binds function to the 'e' key
    turtle.onkey(clear_board, 'e')

    # binds function to the 'q' key
    turtle.onkey(sys.exit, 'q')

    continuous = False

    def step_once():
        # allows for the rebinding of variables outside of the local scope
        nonlocal continuous
        continuous = False
        perform_step()

    def step_continuous():
        nonlocal continuous
        continuous = True
        perform_step()

    def perform_step():
        board.step()
        board.display()

        if continuous:
            # calls function in question after t milliseconds
            turtle.ontimer(perform_step, 25)

    # binds functions to the 's' and 'c' keys respectively
    turtle.onkey(step_once, 's')
    turtle.onkey(step_continuous, 'c')

    # prints out the coordinates (keys) of the current live cells
    def print_live():
        board.print_keys()

    turtle.onkey(print_live, 'p')

    # draws a Glider in the upper left of the display
    def draw_glider():
        board.glider()
        board.display()

    turtle.onkey(draw_glider, '1')

    # draws a Garden of Eden in the display
    def draw_garden():
        board.garden()
        board.display()

    turtle.onkey(draw_garden, '2')

    # draws a Gosper Glider Gun in the display
    def draw_glider_gun():
        board.glider_gun()
        board.display()

    turtle.onkey(draw_glider_gun, '3')

    # draws a Sparky in the display
    def draw_sparky():
        board.sparky()
        board.display()

    turtle.onkey(draw_sparky, '4')

    # turtle listens for key events
    turtle.listen()
    # required last statement in a program using turtle graphics
    turtle.mainloop()
Exemple #54
0
        elif current == ']':
            heading, position = stack.pop()
            myturtle.penup()
            myturtle.goto(position)
            myturtle.setheading(heading)
            myturtle.pendown()


x = axiom
for i in range(5):
    x = generate(x, rules)
# print(x, '\n')

t = turtle.Turtle()
t.color("white")
t.setposition(0, -300)
t.color("black")
t.pensize(1)
t.hideturtle()
wn = turtle.Screen()
wn.setup(width=0.8, height=0.8, startx=0, starty=0)

t.left(90)
t.speed(10)
turtle.tracer(0, 0)
parser(t, x, 25)
turtle.update()
turtle.getscreen().getcanvas().postscript(file='outputname.eps')

wn.exitonclick()
Exemple #55
0
        elif memglobal.tipoMem(e) == type([]):                   
            lir = lee_memoria(e)            
            aux.append(lee_arreglo(lir))      
        else:
            aux.append(lee_memoria(e))
    return aux

# Descripción: Método de instancia el cual nos indica si el registro de memoria de la funcion esta listo.
def registro_listo(self):
    return stackeje.stack.Peek().rm.ready()

def main():
    if (len(sys.argv) <= 1):
        print "No se encuentra archivo."
        exit(1)
    else:
        turtle.title("Raplog - "+sys.argv[1])
        cargarArchivo(sys.argv[1])
        if permiteEjecutar():
            ejecutaCuadruplos()
            if a:
                turtle.done()

if __name__ == "__main__":
    # parametros iniciales de trutle
    turtle.title("Raplog")
    turtle.speed("normal")
    turtle.tracer(True)
    main()
    turtle.done()
Exemple #56
0
    t.circle(30)
    t.end_fill()


def snowflake():
    t.pencolor("#ADD8E6")
    t.goto(random.randint(-500, 500), random.randint(-500, 500))
    t.pendown()
    t.rt(90)
    for i in range(6):
        t.fd(10)
        t.bk(10)
        t.rt(60)
    t.penup()


if __name__ == "__main__":
    screen = turtle.Screen()
    t = turtle.Turtle()
    turtle.tracer(10000, 0)
    #main()
    t.penup()
    n = 0
    while (n == 0):
        t.penup()
        for i in range(1000):
            t.penup()
            snowflake()
        t.reset()

    screen.exitonclick()
Exemple #57
0
# SpaceWare by @TokyoEdTech 
# Part I : Getting started

import os
import random
import turtle


turtle.speed(0) # Set the animations sepeed to the maximum
turtle.bgcolor('black') # Change the background color
turtle.hideturtle() # hide the default turtle
turtle.setundobuffer(1) # This saves memory
turtle.tracer(1) # This speeds up drawing

turtle.register_shape('fishtank.gif')

class Sprite(turtle.Turtle):
	def __init__(self, spriteshape, color, startx, starty):
		turtle.Turtle.__init__(self, shape= spriteshape)
		#self.shape(spriteshape)
		self.speed(0)
		self.penup()
		self.color(color)
		self.goto(startx, starty)
		self.speed = 1

	def move(self):
		self.fd(self.speed)

class Player(Sprite):
Exemple #58
0
def main():
    display_help_window()

    scr = turtle.Screen()
    turtle.mode('standard')
    xsize, ysize = scr.screensize()
    turtle.setworldcoordinates(0, 0, xsize, ysize)

    turtle.hideturtle()
    turtle.speed('fastest')
    turtle.tracer(0, 0)
    turtle.penup()

    board = LifeBoard(xsize // CELL_SIZE, 1 + ysize // CELL_SIZE)

    # Set up mouse bindings
    def toggle(x, y):
        cell_x = x // CELL_SIZE
        cell_y = y // CELL_SIZE
        if board.is_legal(cell_x, cell_y):
            board.toggle(cell_x, cell_y)
            board.display()

    turtle.onscreenclick(turtle.listen)
    turtle.onscreenclick(toggle)

    board.makeRandom()
    board.display()

    # Set up key bindings
    def erase():
        board.erase()
        board.display()

    turtle.onkey(erase, 'e')

    def makeRandom():
        board.makeRandom()
        board.display()

    turtle.onkey(makeRandom, 'r')

    turtle.onkey(sys.exit, 'q')

    # Set up keys for performing generation steps, either one-at-a-time or not.
    continuous = False

    def step_once():
        nonlocal continuous
        continuous = False
        perform_step()

    def step_continuous():
        nonlocal continuous
        continuous = True
        perform_step()

    def perform_step():
        board.step()
        board.display()
        # In continuous mode, we set a timer to display another generation
        # after 25 millisenconds.
        if continuous:
            turtle.ontimer(perform_step, 25)

    turtle.onkey(step_once, 's')
    turtle.onkey(step_continuous, 'c')

    # Enter the Tk main loop
    turtle.listen()
    turtle.mainloop()
Exemple #59
0
import bisect
import math
import turtle
import random

maze_data = ((0, 0, 0, 0, 0, 0, 0, 0, 0, 0), (0, 2, 1, 1, 2, 1, 2, 1, 2, 0),
             (0, 1, 0, 0, 0, 0, 0, 0, 1, 0), (0, 1, 0, 2, 1, 1, 2, 0, 1, 0),
             (0, 2, 0, 1, 0, 0, 1, 0, 1, 0), (0, 1, 0, 1, 0, 0, 1, 0, 2, 0),
             (0, 1, 0, 2, 1, 0, 2, 0, 1, 0), (0, 1, 0, 0, 0, 0, 1, 0, 1, 0),
             (0, 2, 1, 1, 2, 1, 2, 0, 1, 0), (0, 0, 0, 0, 0, 0, 0, 0, 2, 0))

PARTICLE_COUNT = 5000

ROBOT_HAS_COMPASS = False

turtle.tracer(50000, delay=0)
# turtle.register_shape("dot", ((-3,-3), (-3,3), (3,3), (3,-3)))
turtle.register_shape("tri", ((-3, -2), (0, 3), (3, -2), (0, 0)))
turtle.speed(0)
turtle.title("Importance sampling and resampling")

UPDATE_EVERY = 0
DRAW_EVERY = 2


def add_noise(level, *coords):
    return [x + random.uniform(-level, level) for x in coords]


def add_little_noise(*coords):
    return add_noise(0.02, *coords)
Exemple #60
0
    p.seth(0)


def tlo(r):
    p.begin_fill()
    p.color(kolor_bombki, kolor_bombki)
    p.circle(r)
    p.end_fill()


def gwiazdka(r):
    p.begin_fill()
    p.color(kolor_bombki, kolor_gwiazki)
    for i in range(5):
        p.fd(r*2-10)
        p.rt(180 - 36)
    p.end_fill()


def bombka(r):
    wysrodkowanie(r)
    tlo(r)
    p.lt(90)
    p.fd(r*2)
    p.rt(180 - (36/2))
    gwiazdka(r)

tracer(0)
bombka(100)
update()
mainloop()