Beispiel #1
0
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()
Beispiel #2
0
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)
Beispiel #4
0
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()
Beispiel #7
0
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)
Beispiel #8
0
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
Beispiel #9
0
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)
Beispiel #11
0
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)
Beispiel #13
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
Beispiel #15
0
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()
Beispiel #16
0
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)
Beispiel #17
0
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()