class App: def __init__(self): self.win = tk.Tk() self.win.geometry("640x400") self.canvas = Canvas() self.canvas.pack() self.scr = TurtleScreen(self.canvas) self.t = RawTurtle(self.scr) self.btn = Button(self.win, text="Press me!", command=self.do_action()) self.btn.pack() def do_action(self): self.t.pensize(3) self.t.pencolor(random.choice(colors)) self.t.speed(0) self.length = 5 while self.length < 500: self.t.left(89) self.t.forward(self.length) self.t.right(-105) self.t.forward(self.length) self.length += 3 def run(self): self.win.mainloop()
class App : def __init__(self): self.win = Tk() self.btn = Button(self.win, text="확인", command=self.press) self.btn.pack() self.canvas = Canvas(self.win) self.canvas.config(width=600, height=300) self.canvas.pack() self.src = TurtleScreen(self.canvas) self.t = RawTurtle(self.src) self.t.pensize(5) # 서버와 소켓 연결 self.client = socket(AF_INET, SOCK_STREAM) self.client.connect(('127.0.0.1',9999)) def move(self): print("터틀 제어하기") # 서버에서 받은 데이터로 터틀을 제어한다. data = self.client.recv(1024) obj = json.loads(data.decode('utf-8')) direction = obj['direction'] angle = obj['angle'] self.t.left(angle) if direction=='L' else self.t.right(angle) self.t.forward(obj['length']) def press(self): self.client.send('I am Client^^'.encode('utf-8')) print("서버에 메세지 보내기") # 터틀 제어하기 self.move()
def lihtne_demo(): #tekitame objekti, mis kuulub klassi Screen ekraan = Screen() #tekitame konna objekti, mis kuulub klassi RawTrutle ja on ekraani peal konn = RawTurtle(ekraan) konn.forward(100) #tekitame teise konna kermit = RawTurtle(ekraan) kermit.color("green") kermit.left(30) kermit.forward(50) #liigutame esimest konna konn.back(100)
def draw_maze(maze, scale, *, screen=None, tracer=False, delay=0, speed=0, updates=False, start_x=0, start_y=0): if screen is None: screen = Screen() width = scale * maze.width height = scale * maze.height original_tracer = screen.tracer() original_delay = screen.delay() screen.tracer(tracer) screen.delay(delay) turtle = RawTurtle(screen, visible=False) turtle.speed(speed) turtle.setpos(start_x, start_y) turtle.setheading(0) turtle.showturtle() x, y, dx, dy = 0, 0, 1, 0 while True: sx, sy = rotate_right(dx, dy) print(x, y, maze[x, y]) if maze[x, y][sx, sy]: if maze[x, y][rotate_left(sx, sy)]: print('a') turtle.forward(scale - 1) turtle.left(90) dx, dy = rotate_left(dx, dy) else: print('b') turtle.forward(scale) x, y = x + dx, y + dy else: print('c') turtle.right(90) turtle.forward(1) dx, dy = rotate_right(dx, dy) x, y = x + dx, y + dy if (x, y, dx, dy) == (0, 0, 1, 0): break screen.tracer(original_tracer) screen.delay(original_delay) screen.update() return screen
class Sierpinski: def __init__(self, x): self.it = x S = "E+D+D" for i in range(self.it): pesan = "" for j in range(len(S)): if S[j] == "E": pesan += "E+D-E-D+E" elif S[j] == "D": pesan += "DD" else: pesan += S[j] S = pesan root3 = tk.Tk() if self.it != 1: root3.title('Sierpinski Fractal with ' + str(self.it) + ' iterations') else: root3.title('Sierpinski Fractal with an iteration') self.canvas = ScrolledCanvas(master=root3, width=1000, height=1000) self.canvas.pack(fill=tk.BOTH, expand=tk.YES) screen = TurtleScreen(self.canvas) screen.screensize(10000, 10000) self.turtle = RawTurtle(screen) self.turtle.ht() self.turtle.speed(0) for i in range(len(S)): if S[i] == "E" or S[i] == "D": self.turtle.forward(10) elif S[i] == "+": self.turtle.left(120) else: self.turtle.right(120) self.canvas.bind('<MouseWheel>', self.zoom) screen.mainloop() def zoom(self, event): amount = 0.9 if event.delta < 0 else 1.1 self.canvas.scale(tk.ALL, 0, 0, amount, amount)
def draw(list_rectangles, list_squares): """ Opens a window and draws all the Rectangles and Squares using turtle module Args: list_rectangles (list): list of rectangles to draw list_squares (list): list of squares to draw """ screen = Screen() screen.setup() screen.bgcolor("black") colors = ["cyan", "red", "blue", "white", "purple", "green", "brown", "#285078"] square = RawTurtle(screen) rectangle = RawTurtle(screen) # square.speed(10) # rectangle.speed(10) for sq in list_squares: square.penup() square.home() square.color(random.choice(colors)) square.goto(sq.x, sq.y) square.pendown() square.begin_fill() i = 0 while i < 4: square.forward(sq.size) square.left(90) i += 1 square.end_fill() square.hideturtle() for rect in list_rectangles: rectangle.penup() rectangle.home() rectangle.color(random.choice(colors)) rectangle.goto(rect.x, rect.y) rectangle.pendown() i = 0 while i < 2: rectangle.forward(rect.width) rectangle.left(90) rectangle.forward(rect.height) rectangle.left(90) i += 1 rectangle.hideturtle() done()
class TurtleCanvas(): def __init__(self,canvas): #self.window = master #self.canvas = ScrolledCanvas(master=self.window, width=800, height=600) #self.canvas.pack(fill=tk.BOTH, expand=tk.YES) self.canvas = canvas self.screen = TurtleScreen(canvas) self.turtle = RawTurtle(self.screen) self.turtle.speed("fastest") #self.window.geometry('%dx%d+%d+%d' % (cWidth, cHeight, x, y)) self.canvas.bind('<MouseWheel>', self.zoom) self.canvas.bind("<ButtonPress-1>", self.scroll_start) self.canvas.bind("<B1-Motion>", self.scroll_move) self.canvas.bind("<ButtonPress-3>", self.changeDirection) #self.canvas.bind("<c>", self.changeColor) self.rightDirection = True def changeDirection(self,event): #print(self.rightDirection) if(self.rightDirection): self.rightDirection = False else: self.rightDirection = True def changeColor(self,event): currentColorIndex = colors.index(self.turtle.color()[0]) if (currentColorIndex == (len(colors) - 1)): self.turtle.color(colors[0]) else: self.turtle.color(colors[currentColorIndex + 1]) def scroll_start(self,event): self.canvas.scan_mark(event.x, event.y) def scroll_move(self,event): self.canvas.scan_dragto(event.x, event.y, gain=1) def zoom(self,event): amount = 0.9 if event.delta < 0 else 1.1 self.canvas.scale(tk.ALL, 0, 0, amount, amount) def square(self,sidelength = 50): for i in range(4): self.turtle.forward(sidelength) self.turtle.right(90) def triangle(self,sidelength = 50): for i in range(3): self.turtle.forward(sidelength) self.turtle.right(120) def star(self,sidelength = 50): for i in range(5): self.turtle.forward(sidelength) self.turtle.right(144) def shapeDriver(self, shapeFunc, steps): self.turtle.st() i = 0 for j in range(steps): shapeFunc(1 + i) if(self.rightDirection == True): self.turtle.right(1) else: self.turtle.left(1) i += 0.1 self.turtle.ht() def helperDriver(self, shape, steps, color): print(color) self.turtle.color(color) if(shape == "Square"): self.shapeDriver(self.square,steps) if(shape == "Triangle"): self.shapeDriver(self.triangle,steps) if(shape == "Star"): self.shapeDriver(self.star,steps)
class Vehicle: def __init__(self, turtle_window, id_number): # comment here self.turtle_window = turtle_window self.id_number = id_number # comment here self.speed_params = [20, 0.2, 6] self.turn_parameters = [20] # comment here self.turtle_object = RawTurtle(self.turtle_window.wn) self.turtle_object.hideturtle() self.turtle_object.shape('turtle') self.turtle_object.turtlesize(1) self.turtle_object.penup() # comment here self.likes_food_dict = {'Sugar': random.choice([True, False])} # comment here if self.likes_food_dict['Sugar']: self.turtle_object.color("red", (1, 0.85, 0.85)) else: self.turtle_object.color("blue", (0.85, 0.85, 1)) # comment here self.place() self.turtle_object.showturtle() def place(self): # comment here self.turtle_object.goto(random.randint(-MAX_LOCATION, MAX_LOCATION), random.randint(-MAX_LOCATION, MAX_LOCATION)) self.turtle_object.right(random.randint(0, 360)) def move(self): # comment here cumulative_speed = 0 cumulative_turn_amount = 0 # comment here for food_source in self.turtle_window.food_source_list: # comment here likes_food = self.likes_food_dict[food_source.name] # comment here input_distance = self.turtle_object.distance( food_source.turtle_object.pos()) # comment here input_angle = self.turtle_object.heading( ) - self.turtle_object.towards(food_source.turtle_object.pos()) # comment here sin_angle = math.sin(math.radians(input_angle)) # comment here left_sensor_distance = input_distance - sin_angle right_sensor_distance = input_distance + sin_angle # comment here left_speed, right_speed, combined_speed = self.compute_speed( left_sensor_distance, right_sensor_distance, likes_food) # comment here turn_amount = self.turn_parameters[0] * (right_speed - left_speed) # comment here cumulative_speed += combined_speed cumulative_turn_amount += turn_amount # comment here if isinstance(cumulative_turn_amount, complex): cumulative_turn_amount = 0 # comment here if cumulative_speed < 0: cumulative_speed = 0 # comment here self.turtle_object.right(cumulative_turn_amount) self.turtle_object.forward(cumulative_speed) # comment here self.check_border_collision() def check_border_collision(self): ''' comment here. Make one big comment for the function, but it must be more specific and detailed then just repeating the function name... ''' if self.turtle_object.xcor() > MAX_LOCATION: self.turtle_object.goto(MAX_LOCATION, self.turtle_object.ycor()) if self.turtle_object.xcor() < -MAX_LOCATION: self.turtle_object.goto(-MAX_LOCATION, self.turtle_object.ycor()) if self.turtle_object.ycor() > MAX_LOCATION: self.turtle_object.goto(self.turtle_object.xcor(), MAX_LOCATION) if self.turtle_object.ycor() < -MAX_LOCATION: self.turtle_object.goto(self.turtle_object.xcor(), -MAX_LOCATION) if self.turtle_object.ycor() <= -MAX_LOCATION: if 0 <= self.turtle_object.heading() <= 180: turn_angle = 180 - self.turtle_object.heading() self.turtle_object.setheading(turn_angle) else: turn_angle = abs(360 - self.turtle_object.heading()) self.turtle_object.setheading(turn_angle) if self.turtle_object.ycor() >= MAX_LOCATION: if 0 <= self.turtle_object.heading() <= 180: turn_angle = 360 - self.turtle_object.heading() self.turtle_object.setheading(turn_angle) else: turn_angle = 360 - (self.turtle_object.heading() - 180) self.turtle_object.setheading(turn_angle) if self.turtle_object.xcor() <= -MAX_LOCATION: if 0 <= self.turtle_object.heading() <= 90: turn_angle = 360 - self.turtle_object.heading() self.turtle_object.setheading(turn_angle) if 270 < self.turtle_object.heading() <= 360: turn_angle = 360 - self.turtle_object.heading() self.turtle_object.setheading(turn_angle) if 90 < self.turtle_object.heading() < 180: turn_angle = self.turtle_object.heading() - 90 self.turtle_object.setheading(turn_angle) if 180 <= self.turtle_object.heading() <= 360: turn_angle = self.turtle_object.heading() + 90 self.turtle_object.setheading(turn_angle) if self.turtle_object.xcor() >= MAX_LOCATION: if 0 <= self.turtle_object.heading() <= 180: turn_angle = self.turtle_object.heading() + 90 self.turtle_object.setheading(turn_angle) else: turn_angle = self.turtle_object.heading() - 90 self.turtle_object.setheading(turn_angle) ############################################################################################################### def compute_speed(self, left_distance, right_distance, likes_food): ''' comment here. Make one big comment for the function, but it must be more specific and detailed then just repeating the function name... explain this in Braitenberg's terms ''' if likes_food: left_speed = ( self.speed_params[0] / (right_distance**self.speed_params[1])) - self.speed_params[2] right_speed = ( self.speed_params[0] / (left_distance**self.speed_params[1])) - self.speed_params[2] else: left_speed = ( self.speed_params[0] / (left_distance**self.speed_params[1])) - self.speed_params[2] right_speed = ( self.speed_params[0] / (right_distance**self.speed_params[1])) - self.speed_params[2] combined_speed = (left_speed + right_speed) / 2 return left_speed, right_speed, combined_speed
from turtle import TurtleScreen, RawTurtle, TK root = TK.Tk() root.title("Ejemplo 1") canvas = TK.Canvas(root, width=500, height=500) canvas.pack() turtle = RawTurtle(screen) turtle.shape("turtle") turtle.left(20) turtle.forward(50) turtle.left(90) turtle.forward(50) turtle.left(90) turtle.forward(50) turtle.left(90) turtle.forward(50) turtle.left(90) delay(1000) turtle.left(30) turtle.forward(50) turtle.left(90) turtle.forward(50) turtle.left(90) turtle.forward(50) turtle.left(90) turtle.forward(50)
turtle_canvas.bgcolor("white") # Create a turtle to draw on the canvas sammy = RawTurtle(turtle_canvas) # If you want the drawing to be as fast as possible, uncomment these lines # turtle_canvas.delay(0) # sammy.hideturtle() # sammy.speed("fastest") # Draw squadron NN patch (your code goes here) #get turtle in position for first side of triangle sammy.up() sammy.left(90) sammy.forward(50) sammy.right(90) #draw first side of triangle sammy.down() sammy.forward(75) sammy.backward(150) #draw second side of triangle sammy.left(300) sammy.forward(150) #draw final side of triangle sammy.left(120) sammy.forward(150)
class MainApplication(tk.Frame): def __init__(self, parent, *args, **kwargs): tk.Frame.__init__(self, parent, *args, **kwargs) self.parent = parent self.filepath = os.path.join(os.path.expanduser("~"), "kod.nxc") self.power_var = tk.IntVar() self.forward_wait_var = tk.IntVar() self.degrees_var = tk.IntVar() self.wait_wait_var = tk.IntVar() self.power_var.set(50) self.forward_wait_var.set(1000) self.degrees_var.set(90) self.wait_wait_var.set(1000) self.create_widgets() self.connect_widgets() def create_widgets(self): tk.Label(self.parent, text="Robot Driver Inc.", font=('Arial', 25)).grid(row=0, column=0, columnspan=6) self.forward_btn = tk.Button(self.parent, text="Jazda do przodu") self.rotate_btn = tk.Button(self.parent, text="Obrót") self.wait_btn = tk.Button(self.parent, text="Czekaj") self.undo_btn = tk.Button(self.parent, text="Cofnij") self.generate_btn = tk.Button(self.parent, text="Generuj kod") self.canvas = tk.Canvas(self.parent, width=640, height=480) self.draw = RawTurtle(self.canvas) self.forward_btn.grid(row=1, column=0, sticky=tk.E + tk.W) self.rotate_btn.grid(row=2, column=0, sticky=tk.E + tk.W) self.wait_btn.grid(row=3, column=0, sticky=tk.E + tk.W) self.undo_btn.grid(row=4, column=0, sticky=tk.E + tk.W) self.generate_btn.grid(row=5, column=0, sticky=tk.E + tk.W) self.canvas.grid(row=6, column=0, columnspan=6) tk.Label(self.parent, text="Moc:").grid(row=1, column=1) self.power_input = tk.Entry(self.parent, textvariable=self.power_var) tk.Label(self.parent, text="Czas:").grid(row=1, column=3) self.forward_wait_input = tk.Entry(self.parent, textvariable=self.forward_wait_var) tk.Label(self.parent, text="Stopnie:").grid(row=2, column=1) self.rotate_input = tk.Entry(self.parent, textvariable=self.degrees_var) tk.Label(self.parent, text="Czas:").grid(row=3, column=1) self.wait_wait_input = tk.Entry(self.parent, textvariable=self.wait_wait_var) tk.Label(self.parent, text="Ścieżka:").grid(row=4, column=1, rowspan=2) self.filepath_label = tk.Label(self.parent, text=self.filepath, wraplength=150, justify='center') self.filepath_btn = tk.Button(self.parent, text="Wybierz") self.power_input.grid(row=1, column=2) self.forward_wait_input.grid(row=1, column=4) self.rotate_input.grid(row=2, column=2) self.wait_wait_input.grid(row=3, column=2) self.filepath_label.grid(row=4, column=2, rowspan=2) self.filepath_btn.grid(row=5, column=3, columnspan=2, sticky=tk.E + tk.W) def connect_widgets(self): self.forward_btn.bind('<Button-1>', lambda x: self.on_forward_btn_pressed()) self.rotate_btn.bind('<Button-1>', lambda x: self.on_rotate_btn_pressed()) self.wait_btn.bind('<Button-1>', lambda x: self.on_wait_btn_pressed()) self.generate_btn.bind('<Button-1>', lambda x: self.on_generate_btn_pressed()) self.undo_btn.bind('<Button-1>', lambda x: self.on_undo_btn_pressed()) self.filepath_btn.bind('<Button-1>', lambda x: self.on_filepath_btn_pressed()) def on_forward_btn_pressed(self): self.draw.forward(10) def on_rotate_btn_pressed(self): self.draw.right(45) def on_wait_btn_pressed(self): print("Wait:", self.wait_wait_var.get()) def on_generate_btn_pressed(self): print(self.filepath) def on_undo_btn_pressed(self): print("Undo") def on_filepath_btn_pressed(self): self.filepath = asksaveasfilename(initialdir=os.path.expanduser("~"), filetypes=(("NXC File", "*.nxc"), ("TXT File", "*.txt"))) self.filepath_label['text'] = self.filepath
# tess.right(90) # tess.left(3600) # tess.right(-90) # tess.left(3600) # tess.left(3645) # tess.forward(-100) #---------------------------------------------------------------------- # Challenge Problems 1 # Implement a loop within a loop that draws the pattern shown in the Lab05 # description. It is created by drawing a set of square where each square # is orientated 30 degrees from the previous square. #---------------------------------------------------------------------- for i in range(4): mary.forward(25) mary.left(90) mary.forward(50) mary.left(90) mary.forward(25) mary.left(90) mary.forward(25) mary.left(90) mary.forward(50) for j in range(4): mary.forward(50) mary.left(90) mary.up() mary.setpos(0, 0)
class Vehicle: ############################################################################################################### def __init__(self, turtle_window, id_number): self.speed_params = [20, 0.2, 6] self.turn_parameters = [20] self.turtle_window = turtle_window self.max_location = self.turtle_window.screen_size / 2 - 10 self.vehicle = RawTurtle(self.turtle_window.wn) self.vehicle.hideturtle() self.id_number = id_number self.type = random.choice(["crossed", "direct"]) self.vehicle.shape('turtle') self.vehicle.turtlesize(1) self.vehicle.penup() if self.type == 'crossed': self.vehicle.color("red", (1, 0.85, 0.85)) else: self.vehicle.color("blue", (0.85, 0.85, 1)) self.place() self.vehicle.showturtle() def place(self): self.vehicle.goto( random.randint(-self.max_location, self.max_location), random.randint(-self.max_location, self.max_location)) self.vehicle.right(random.randint(0, 360)) ############################################################################################################### def move(self): cumulative_speed = 0 cumulative_turn_amount = 0 for heat_source in self.turtle_window.heat_source_list: input_distance = self.vehicle.distance( heat_source.heat_source.pos()) input_angle = self.vehicle.heading() - self.vehicle.towards( heat_source.heat_source.pos()) sin_angle = math.sin(math.radians(input_angle)) left_sensor_distance = input_distance - sin_angle right_sensor_distance = input_distance + sin_angle left_speed, right_speed, combined_speed = self.compute_speed( left_sensor_distance, right_sensor_distance) turn_amount = self.turn_parameters[0] * (right_speed - left_speed) cumulative_speed += combined_speed cumulative_turn_amount += turn_amount if isinstance(cumulative_turn_amount, complex): cumulative_turn_amount = 0 if cumulative_speed < 0: cumulative_speed = 0 self.vehicle.right(cumulative_turn_amount) self.vehicle.forward(cumulative_speed) self.check_border_collision() def check_border_collision(self): if self.vehicle.xcor() > self.max_location: self.vehicle.goto(self.max_location, self.vehicle.ycor()) if self.vehicle.xcor() < -self.max_location: self.vehicle.goto(-self.max_location, self.vehicle.ycor()) if self.vehicle.ycor() > self.max_location: self.vehicle.goto(self.vehicle.xcor(), self.max_location) if self.vehicle.ycor() < -self.max_location: self.vehicle.goto(self.vehicle.xcor(), -self.max_location) if self.vehicle.ycor() <= -self.max_location: if 0 <= self.vehicle.heading() <= 180: turn_angle = 180 - self.vehicle.heading() self.vehicle.setheading(turn_angle) else: turn_angle = abs(360 - self.vehicle.heading()) self.vehicle.setheading(turn_angle) if self.vehicle.ycor() >= self.max_location: if 0 <= self.vehicle.heading() <= 180: turn_angle = 360 - self.vehicle.heading() self.vehicle.setheading(turn_angle) else: turn_angle = 360 - (self.vehicle.heading() - 180) self.vehicle.setheading(turn_angle) if self.vehicle.xcor() <= -self.max_location: if 0 <= self.vehicle.heading() <= 90: turn_angle = 360 - self.vehicle.heading() self.vehicle.setheading(turn_angle) if 270 < self.vehicle.heading() <= 360: turn_angle = 360 - self.vehicle.heading() self.vehicle.setheading(turn_angle) if 90 < self.vehicle.heading() < 180: turn_angle = self.vehicle.heading() - 90 self.vehicle.setheading(turn_angle) if 180 <= self.vehicle.heading() <= 360: turn_angle = self.vehicle.heading() + 90 self.vehicle.setheading(turn_angle) if self.vehicle.xcor() >= self.max_location: if 0 <= self.vehicle.heading() <= 180: turn_angle = self.vehicle.heading() + 90 self.vehicle.setheading(turn_angle) else: turn_angle = self.vehicle.heading() - 90 self.vehicle.setheading(turn_angle) ############################################################################################################### def compute_speed(self, left_distance, right_distance): if self.type == 'crossed': left_speed = ( self.speed_params[0] / (right_distance**self.speed_params[1])) - self.speed_params[2] right_speed = ( self.speed_params[0] / (left_distance**self.speed_params[1])) - self.speed_params[2] else: left_speed = ( self.speed_params[0] / (left_distance**self.speed_params[1])) - self.speed_params[2] right_speed = ( self.speed_params[0] / (right_distance**self.speed_params[1])) - self.speed_params[2] combined_speed = (left_speed + right_speed) / 2 return left_speed, right_speed, combined_speed
class Robot: def __init__(self, scene, robot_id): #sets variables self.robot_id = robot_id self.turtle = RawTurtle(scene.canvas) self.scene = scene self.scr = self.turtle.getscreen() self.scr.setworldcoordinates(0, scene.height, scene.width, 0) self.turtle.penup() if robot_id == 1: self.turtle.color("blue") else: self.turtle.color("red") #create turtles sprite ## self.turtle.register_shape("ship",((-7,-2),(-6,-1),(-3,0),(-3,1),(-2,5), ## (0,7),(2,5),(3,1),(3,0),(6,-1),(7,-2), ## (3,-1),(3,-2),(2,-7),(-2,-7),(-3,-2), ## (-3,-1),(-2,-1),(-2,-2),(-1,-6),(1,-6), ## (2,-2),(2,-1),(-2,-1),(-2,0),(2,0), ## (2,1),(1,4),(0,5),(-1,4),(-2,1), ## (-2,-1),(-3,-1)) ## ) ## self.turtle.shape("ship") ## self.turtle.shapesize(2,2) #place robot using reset self.reset() def reset(self): #set start positions for robots positions = [((15,15), 45), ((self.scene.width-15, 15), 135), ((15, self.scene.height-15), 315), ((self.scene.height-15, self.scene.width-15), 135)] #move robot to starting possition self.turtle.speed(0) self.turtle.setpos(positions[self.robot_id][0]) #print positions[self.robot_id] self.turtle.left(positions[self.robot_id][1]) self.turtle.forward(20) self.turtle.speed(0) self.turtle.screen.bgcolor("sky blue") def orientate(self, landmarks, canvas, goal): ##sd = shortest distance ##x1,x2,y1,y2 = circles corners ##lx,ly = length x/y ##h = hypothinus ##ln = landmark number sd = 40000000 ln = 0 for ID in landmarks: if canvas.itemcget(ID, "fill") == "dark green": ln+=1 x1,y1,x2,y2 = canvas.coords(ID) lx = ((x1+x2)/2) - self.turtle.xcor() ly = ((y1+y2)/2) - self.turtle.ycor() h = math.sqrt(lx*lx + ly*ly) if h < sd: sd = h stored_ID = ID stored_x = lx stored_y = ly if ln == 0: stored_ID = goal x1,y1,x2,y2 = canvas.coords(goal) lx = ((x1+x2)/2) - self.turtle.xcor() ly = ((y1+y2)/2) - self.turtle.ycor() sd = math.sqrt(lx*lx + ly*ly) stored_x = ((x1+x2)/2) - self.turtle.xcor() stored_y = ((y1+y2)/2) - self.turtle.ycor() if sd < 37: return stored_ID if stored_x < 0: if stored_y < 0: new_heading = 180 + math.degrees(math.atan((-stored_y)/(-stored_x))) else: new_heading = 180 - math.degrees(math.atan(stored_y/(-stored_x))) elif stored_y < 0: new_heading = 360 - math.degrees(math.atan((-stored_y)/stored_x)) else: new_heading = math.degrees(math.atan(stored_y/stored_x)) self.turtle.seth(new_heading) return False def collisions_move(self, speed, depth): ##breaks the recursion if the robots get to close if depth > 10: return ##sets variables for checking collision turtle_x = self.turtle.xcor() turtle_y = self.turtle.ycor() t_heading = self.turtle.heading() ##variables used to check right xr = turtle_x + 15*math.cos(math.radians(self.turtle.heading()+30)) yr = turtle_y + 15*math.sin(math.radians(self.turtle.heading()+30)) ##variables used to check left xl = turtle_x + 15*math.cos(math.radians(self.turtle.heading()-30)) yl = turtle_y + 15*math.sin(math.radians(self.turtle.heading()-30)) ##check for the collision left = self.scene.canvas.find_overlapping(xl-1,yl-1,xl+1,yl+1) right = self.scene.canvas.find_overlapping(xr-1,yr-1,xr+1,yr+1) if left: ##turn away self.turtle.left(20) self.collisions_move(speed, depth+1) #self.turtle.forward(speed/5) elif right: ##turn away self.turtle.right(20) self.collisions_move(speed, depth+1) #self.turtle.forward(speed/5) else: ##else move forward self.turtle.forward(speed) return
from guizero import App, Drawing from turtle import RawTurtle app = App() drawing = Drawing(app) turtle = RawTurtle(drawing.tk) turtle.forward(100) turtle.left(720) app.display()
class Robot: def __init__(self, scene, robot_id): self.robot_id = robot_id self.done = False self.signal = None self.turtle = RawTurtle(scene.canvas) self.scene = scene self.scr = self.turtle.getscreen() self.scr.setworldcoordinates(0, scene.height, scene.width, 0) self.turtle.penup() self.reset() def reset(self): positions = [((15,15), 45), ((self.scene.width-15, 15), 135), ((15, self.scene.height-15), 315), ((self.scene.height-15, self.scene.width-15), 135)] self.turtle.speed(0) self.turtle.setpos(positions[self.robot_id][0]) print positions[self.robot_id] self.turtle.left(positions[self.robot_id][1]) self.turtle.forward(20) self.turtle.speed("normal") def process(self): ##sets variables for checking collision turtle_x = self.turtle.xcor() turtle_y = self.turtle.ycor() t_heading = self.turtle.heading() ##variables used to check right xr = turtle_x + 15*math.cos(math.radians(self.turtle.heading()+30)) yr = turtle_y + 15*math.sin(math.radians(self.turtle.heading()+30)) ##variables used to check left xl = turtle_x + 15*math.cos(math.radians(self.turtle.heading()-30)) yl = turtle_y + 15*math.sin(math.radians(self.turtle.heading()-30)) ##turns the robot at window boundries st_orient = [0, 90, 180, 270] bounce_d = 20 if turtle_x - bounce_d < 0: self.turtle.setheading(180-t_heading) if turtle_x + bounce_d > self.scene.width: self.turtle.setheading(180-t_heading) if turtle_y - bounce_d < 0: self.turtle.setheading(360-t_heading) if turtle_y + bounce_d > self.scene.height: self.turtle.setheading(360-t_heading) ##check collisions left = self.scene.canvas.find_overlapping(xl-1,yl-1,xl+1,yl+1) right = self.scene.canvas.find_overlapping(xr-1,yr-1,xr+1,yr+1) if self.goal_id in left + right: self.done = True elif left: ##turn away self.turtle.left(10) elif right: ##turn away self.turtle.right(10) else: ##else move forward self.turtle.forward(5) ##if goal not reached: if self.signal: if self.signal == "STOP": self.signal = None return elif not self.done: self.scene.master.after(20, self.process)
pen1.width(3) # Configuring the second pen pen2.color("violet", "misty rose") pen2.width(3) # Drawing the figure pen1.begin_fill() pen2.begin_fill() pen1.goto(0, 100) pen2.goto(0, 100) pen1.goto(0, -50) pen2.goto(0, -50) pen2.left(40) pen1.left(140) pen2.forward(100) pen1.forward(100) for side in range(185): pen2.forward(1) pen1.forward(1) pen2.left(1) pen1.right(1) # Filling the figure pen2.end_fill() pen1.end_fill() # Deleting the arrows of the pens when the figure is finished pen2.hideturtle() pen1.hideturtle()