コード例 #1
0
def juhuslikud_konnad(n=100, t=100):
    """
    Tekitab n juhuslikult liikuvat konna
    """
    ekraan = Screen()
    konnad = []
    for i in range(n):
        # Paigutame konna i juhuslikele koordinaatidele
        konn_i = RawTurtle(ekraan)
        konn_i.up()
        x = randint(-100, 100)
        y = randint(-100, 100)
        konn_i.goto(x, y)
        konn_i.down()
        # Värvime konna juhusliku värviga
        varv = choice(['green', 'brown', 'black', 'red', 'blue'])
        konn_i.color(varv)
        # Lisame konna i konnade hulka
        konnad.append(konn_i)

    # Teeme t juhuslikku liikumist juhusliku konnaga
    for ti in range(t):
        suunamuutus = randint(-60, 60)
        konn = choice(konnad)
        konn.left(suunamuutus)
        konn.fd(20)
コード例 #2
0
def juhuslikud_konnad(n=10, t=10000):
    """
tekitab n juhuslike konne
    """
    ekraan = Screen()
    konnad = []
    for i in range(n):
        #paigutame konna i juhuslikudele koordinaatidele
        konn_i = RawTurtle(ekraan)
        konn_i.up()
        x = randint(-100, 100)
        y = randint(-100, 100)
        konn_i.goto(x, y)
        konn_i.down()
        #lisame konna i konnade hulka
        konnad.append(konn_i)
        #varvilised konnad
        varv = choice(['green', 'brown', 'black', 'blue', 'red', 'yellow'])
        konn_i.color(varv)
        #lisame varvilisi konne
        konnad.append(konn_i)
    #teeme tee juhuslikku liikumist juhusliku konnaga
    for ti in range(t):
        suunamuutus = randint(-61, 61)
        juhuslikk_indeks = randint(0, n - 1)
        konn = choice(konnad)
        konn.left(suunamuutus)
        konn.fd(20)
コード例 #3
0
ファイル: window.py プロジェクト: alexpdev/Games
 def pen(self):
     turt = RawTurtle(self.screen)
     turt.ht()
     turt.speed(0)
     turt.up()
     turt.goto(-self.width, self.height)
     turt.down()
     return turt
コード例 #4
0
def draw(ans):
    """Вывод топологической схемы"""
    global xax, moves, oboz, window

    turx, tury = xax - int(xax*0.3), int(yax*0.25)
    bg_def = window.cget('bg')
    canvas = Canvas(window, relief='sunken', borderwidth=5, width=turx, height=tury, background=bg_def)
    canvas.place(relx=0.5, rely=0.1, y=int(yax*0.19), anchor=CENTER)
    screen = TurtleScreen(canvas)
    global turtle
    turtle = RawTurtle(canvas)

    turtle.speed(5)
    turtle.hideturtle()

    allen = (turx - int(xax*0.2))
    global let
    if len(ans) > 7:
        if ans[5] == 1 and ans[8] == 1:
            let = allen // 3
        else:
            if ans[5] == 1:
                let = allen // 4
            elif ans[8] == 1:
                let = allen // 4
            else:
                let = allen // 5
        if ans[5] == 2:
            allen -= let//2
        if ans[8] == 2:
            allen -= let//2

    else:
        if ans[5] == 1:
            let = allen // 2
        else:
            let = allen // 3
        if ans[5] == 2:
            allen -= let//2

    turtle.color('white')
    turtle.up()
    turtle.goto(x=-allen // 2, y=-int(yax*0.09))
    turtle.down()
    turtle.color('black')
    turtle.dot(5, 'black')
    turtle.write('A')

    for i in [moves[k + 1][x] for k, x in enumerate(ans) if k + 1 in moves]:
        print(i)
        eval(i)
コード例 #5
0
ファイル: linedraw.py プロジェクト: son2005/BrachioGraph
def draw(lines):
    from tkinter import Tk, LEFT
    from turtle import Canvas, RawTurtle, TurtleScreen

    # set up the environment
    root = Tk()
    canvas = Canvas(root, width=800, height=800)
    canvas.pack()

    s = TurtleScreen(canvas)

    t = RawTurtle(canvas)
    t.speed(0)
    t.width(1)

    for line in lines:
        x, y = line[0]
        t.up()
        t.goto(x * 800 / 1024 - 400, -(y * 800 / 1024 - 400))
        for point in line:
            t.down()
            t.goto(point[0] * 800 / 1024 - 400, -(point[1] * 800 / 1024 - 400))

    s.mainloop()
コード例 #6
0
# set up canvas
canvas = Canvas(root, width=WIDTH, height=HEIGHT, highlightthickness=0)
turtle_screen = TurtleScreen(canvas)
turtle_screen.bgcolor("black")
canvas.pack()

# set up turtle
turt = RawTurtle(turtle_screen)
turt.hideturtle()
turt.speed(0)
turt.pencolor("RED")
turt.width(3)
turt.up()
turt.setx(START_POS[0])
turt.sety(START_POS[1])
turt.down()

farthest_pos = [0, 0]


def update_pos():
    tpos = turt.pos()
    pos = [tpos[0] - START_POS[0], tpos[1] - START_POS[1]]
    if abs(pos[0]) > abs(farthest_pos[0]):
        farthest_pos[0] = pos[0]
    if abs(pos[1]) > abs(farthest_pos[1]):
        farthest_pos[1] = pos[1]


def draw_fractal(n = 0):
    if n <= 0:
コード例 #7
0
ファイル: mousetree.py プロジェクト: alexpdev/Games
def leftDragon(t, sz, level):
    if level == 0:
        t.left(90)
        t.fd(sz)
    else:
        leftDragon(t, sz * .8, level - 1)
        t.left(90)
        rightDragon(t, sz * 8, level - 1)


def rightDragon(t, sz, level):
    if level == 0:
        t.fd(sz)
        t.right(90)
    else:
        leftDragon(t, sz * .8, level - 1)
        t.right(90)
        rightDragon(t, sz * .8, level - 1)


window = Screen()
window.setup(1400, 800, 50, 50)
t = RawTurtle(window)
t.up()
t.home()
print(t.pen())
t.down()
draw_line(t)
window.mainloop()
コード例 #8
0
ファイル: board.py プロジェクト: alexpdev/Games
class Board:
    """ Area of the screen dedicated to the connect 4 game board.
    """
    def __init__(self,screen,corners,width,height,x,y):
        self.corners = corners
        self.screen = screen
        self.pen = RawTurtle(screen)
        self.pen.speed(8)
        self.width = width
        self.height = height
        self.x = x
        self.y = y
        self.spaces = []
        self.draw()
        self.draw_spaces()

    def draw(self):
        self.pen.up()
        self.pen.goto(self.corners[-1])
        self.pen.color("#ddd")
        self.pen.down()
        self.pen.begin_fill()
        for i in self.corners:
            self.pen.goto(i)
        self.pen.ht()
        self.pen.end_fill()
        return

    def check_winner(self,space):
        r, c = space.idx
        if  self.check_row(space,r,c) or \
            self.check_column(space,r,c) or \
            self.check_direction(space,r,c):
            return True
        return False

    def check_row(self,space,r,c):
        if space.state*4 in "".join([str(i.state) for i in self.spaces[r]]):
            return True

    def check_column(self,space,r,c):
        if space.state*4 in "".join([str(i[c].state) for i in self.spaces]):
            return True

    def check_direction(self,space,r,c):
        direct,score = [(-1,-1),(-1,1),(1,1),(1,-1)],[0,0]
        for i,(x,y) in enumerate(direct):
            idx = 0 if i % 2 == 0 else 1
            score[idx] += self.check_angle(space,r,c,x,y,(x,y))
            if max(score) >= 3: return True
        return False

    def check_angle(self,space,r,c,x,y,i):
        if r+x >= 0 and r+x < 6 and c+y >= 0 and c+y < 7:
            if self.spaces[r+x][c+y].state == space.state:
                return 1 + self.check_diag(space,r,c,x+i[0],y+i[1],i)
            return 0
        return 0

    def animate_drop(self,space):
        r,c = space.idx
        for i in range(r):
            self.spaces[i][c].draw()
            self.spaces[i][c].remove()
        return

    def space_empty(self,space):
        r,c = space.idx
        if r == len(self.spaces)-1 or self.spaces[r+1][c].state:
            return space
        for row in range(r+1,len(self.spaces)):
            if self.spaces[row][c].state:
                return self.spaces[row-1][c]
        return self.spaces[len(self.spaces)-1][c]


    def find_space(self,x,y):
        for row in self.spaces:
            cent,rad = row[0].center, row[0].radius
            if y > cent[1] - rad and y < cent[1] + rad:
                return self.search_column(row,x)
        return False

    def search_column(self,row,x):
        for space in row:
            x2 = space.center[0]
            if x > x2-space.radius and x < x2 + space.radius:
                return space
        return False

    def draw_spaces(self):
        row,size = [],self.width/7
        radius = (size*.9)/2
        x,y = self.corners[0]
        for j in range(6):
            for i in range(7):
                space_x = x + (size*i)
                space_y = y - (size*j)
                center = space_x+(size/2),space_y-(size/2)
                color = "#643"
                idx = (j,i)
                space = Space(self,center,radius,color,idx)
                row.append(space)
            self.spaces.append(row)
            row = []
        return
コード例 #9
0
# 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)
    mary.down()
    mary.right(22.5)

#----------------------------------------------------------------------
# Challenge Problem 2
# Implement a program to draw the pattern shown in the Lab05 description.
#----------------------------------------------------------------------

# Keep the window open until the user closes it.
TK.mainloop()
コード例 #10
0
ファイル: objects.py プロジェクト: alexpdev/turtleSource
class Stage:

    @classmethod
    def create(cls, screen):
        stage = cls(screen)
        start = screen.start
        blocks = screen.blocks
        for i in range(blocks):
            stop = start + screen.blockwidth
            stage.positions.append((start,stop))
            base = -screen.base
            height = screen.increment * (i+1)
            color = next(screen.gradient)
            block = Block(screen, base=base, index=i, height=height, parent=stage, color=color)
            stage.blocks.append(block)
            block.draw()
            start = stop + 1
        stage.get_pen()
        return stage

    def append(self, other):
        if other.index:
            other.clear()
        l = len(self)
        other.index = (l)
        self.blocks.append()

    def slice(self, *args):
        if len(args) > 2: raise Exception
        if len(args) == 2: start, stop = args
        if len(args) == 1: start, stop = 0, args[0]
        if len(args) == 0: start, stop = 0, len(self.blocks)
        stage = Stage(self.screen)
        for idx, i in enumerate(range(start,stop)):
            stage.positions.append(self.positions[i])
            block = self.blocks[i].new()
            block.index = idx
            stage.blocks.append(block)
        return stage

    def __init__(self, screen):
        self.screen = screen
        self.positions = []
        self.blocks = []
        self.operations = 0
        self.pen = None

    def get_pen(self):
        self.pen = RawTurtle(self.screen)
        self.pen.color("#f0d1bf")
        xpos = 0
        ypos = self.screen.height - 30
        self.pen.up()
        self.pen.ht()
        self.pen.goto(xpos, ypos)
        self.pen.down()

    def __getitem__(self, idx):
        return self.blocks[idx]

    def __setitem__(self, idx, other):
        if other.index not in [idx, None]:
            other.clear()
            self.blocks[other.index] = None
        if self.blocks[idx] != None:
            self.blocks[idx].clear()
            self.blocks[idx].delindex()
        self.blocks[idx] = other
        self.blocks[idx].setindex(idx)
        other.draw()

    def __str__(self):
        return str([i.value for i in self.blocks])

    def __repr__(self):
        return str(self)

    def __len__(self):
        return len(self.blocks)

    def __iter__(self):
        self.iterable = iter(self.blocks)
        return self.iterable

    def __next__(self):
        try:
            block = next(self.iterable)
            return block
        except StopIteration:
            raise StopIteration
コード例 #11
0
# 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)

#setup and draw the 2
sammy.up()
sammy.setposition(0, 0)
sammy.down()