コード例 #1
0
ファイル: swarm.py プロジェクト: Tyro17/runestone
def main():
    swarmSize = 100
    t = Turtle()
    win = Screen()
    win.setworldcoordinates(-600, -600, 600, 600)
    t.speed(10)
    t.hideturtle()
    t.tracer(15)

    for i in range(swarmSize):
        if random.randrange(100) == 0:
            LeaderFish()
        else:
            FocalFish()

    for i in range(5):
        Obstacle()

    for turn in range(1000):
        for schooler in Schooler.swarm:
            schooler.getNewHeading()

        for schooler in Schooler.swarm:
            schooler.setHeadingAndMove()

    win.exitonclick()
コード例 #2
0
def main():
	# creating a window
	window = Screen()
	# window.bgcolor("orange")

	remo = Turtle()
	remo.shape("turtle")
	remo.color("green")
	remo.speed(50)

	for i in range(36):
		remo.circle(100)
		remo.left(10)

	remo.color("red")

	for i in range(36):
		remo.circle(80)
		remo.left(10)

	remo.color("yellow")

	for i in range(36):
		remo.circle(60)
		remo.left(10)


	window.exitonclick()
コード例 #3
0
def main():
    global s
    at = clock()
    s = Screen()
    s.bgcolor("black")
    s.tracer(36, 0)
    mn_eck(36, 19)
    et = clock()
    return "Laufzeit: %.3f sec" % (et - at)
コード例 #4
0
class World(object):
    def __init__(self, index, size_x, size_y):
        self.index = index
        self.canvas = Screen()
        self.canvas.setup(size_x, size_y)

    def show_world(self):
        #self.canvas.ontimer(god.slowly_kill_humans(), 100)
        self.canvas.exitonclick()
コード例 #5
0
def main():
    global s, t
    s = Screen()
    s.bgcolor("gray10")
    t = Turtle(visible=False, shape="square")
    t.pu()
    t.speed(0)
    s.tracer(False)
    ta = clock()
    recsquare(256, 0.5, colors)
    tb = clock()
    return "{0:.2f}sec.".format(tb-ta)
コード例 #6
0
ファイル: py_moorhuhn.py プロジェクト: s-kimmer/tesp2016
class MHManager(Turtle):
    """Special Turtle, perform the task to manage the Moorhuhn-GUI.
    """
    def __init__(self, w, h):
        Turtle.__init__(self, visible=False)
        self.screen = Screen()
        self.screen.setup(w, h)
        self.speed(0)
        self.penup()
        self.goto(-WINWIDTH//2 + 50, -WINHEIGHT//2 + 20)
        self.pencolor("yellow")
    def message(self, txt):
        """Output text to graphics window.
        """
        self.clear()
        self.write(txt, font=("Courier", 18, "bold"))
コード例 #7
0
def main():
    global screen, red, green, blue
    screen = Screen()
    screen.delay(0)
    screen.setworldcoordinates(-1, -0.3, 3, 1.3)

    red = ColorTurtle(0, .5)
    green = ColorTurtle(1, .5)
    blue = ColorTurtle(2, .5)
    setbgcolor()

    writer = Turtle()
    writer.ht()
    writer.pu()
    writer.goto(1,1.15)
    writer.write("DRAG!",align="center",font=("Arial",30,("bold","italic")))
    return "EVENTLOOP"
コード例 #8
0
def main():
    global s, sun
    s = Screen()
    s.setup(800, 600, 50, 50)
    s.screensize(750, 550)
    createPlanetShape()
    ## setup gravitational system
    s.setworldcoordinates(-hfw*4/3, -hfw, hfw*4/3, hfw)
    gs = GravSys()
    sun = Star(mS, Vec2D(0.,0.), Vec2D(0.,0.), gs, "circle")
    sun.color("yellow")
    sun.turtlesize(1.8)
    sun.pu()
    earth = Star(mE, Vec2D(rE,0.), Vec2D(0.,vE), gs, "planet")
    earth.pencolor("green")
    earth.shapesize(0.8)
    mercury = Star(mME, Vec2D(0., perihelME), Vec2D(-perihelvME, 0),
                                                        gs, "planet")
    mercury.pencolor("blue")
    mercury.shapesize(0.5)
    venus = Star(mVE, Vec2D(-rVE, 0.), Vec2D(0., -vVE), gs, "planet")
    venus.pencolor("blue")
    venus.shapesize(0.65)
    mars = Star(mMA, Vec2D(0., -rMA), Vec2D(vMA, 0.), gs, "planet")
    mars.pencolor("blue")
    mars.shapesize(0.45)
    gs.init()
    gs.start()
    return "Done!"
コード例 #9
0
def main():
    global screen
    screen = Screen()
    screen.colormode(255)
    p = Turtle()
    p.ht()
    screen.tracer(75,0)
    u = doit1(6, Turtle(undobuffersize=1))
    s = doit2(7, Turtle(undobuffersize=1))
    t = doit3(5, Turtle(undobuffersize=1))
    v = doit4(6, Turtle(undobuffersize=1))
    w = doit5(5, Turtle(undobuffersize=1))
    a = clock()
    while True:
        done = 0
        for b in u,s,t,v,w:
            try:
                next(b)
            except:
                done += 1
        if done == 5:
            break

    screen.tracer(1,10)
    b = clock()
    return "runtime: {0:.2f} sec.".format(b-a)
コード例 #10
0
def draw_art():
    window = Screen()
    window.bgcolor('cyan')
    angie = Turtle()
    angie.shape('turtle')
    angie.color('blue')
    angie.speed(2000)

  #  angie.left(105)
    for j in range(80):
        angie.right(5)
        draw_rhombus(angie, 100)

    angie.left(90)
    angie.forward(300)

    # Close window
    window.exitonclick()
コード例 #11
0
ファイル: mazegraphics.py プロジェクト: skroah/pythonmaze
 def __init__(self, config):
     self.width = config.getValueAsInt("maze", "maze_size")
     self.height = config.getValueAsInt("maze", "maze_size")
     self.bg_color = config.getValue("maze", "bg_color")
     self.line_color = config.getValue("maze", "line_color")
     self.line_centroid_color = config.getValue("maze", "line_centroid_color")
     self.forward_centroid_color = config.getValue("maze", "forward_centroid_color")
     self.reverse_centroid_color = config.getValue("maze", "reverse_centroid_color")
     self.path_color = config.getValue("maze", "path_color")
     self.screen = Screen()
     self.setupTurtle(self.width, self.height)
コード例 #12
0
def main():
    swarmSize = 50
    t = Turtle()
    win = Screen()
    win.setworldcoordinates(-600,-600,600,600)
    t.speed(10)
    t.hideturtle()
    t.tracer(15)

    for i in range(swarmSize):
        FocalFish()

    for turn in range(300):
        for schooler in Schooler.swarm:
            schooler.getNewHeading()

        for schooler in Schooler.swarm:
            schooler.setHeadingAndMove()

    win.exitonclick()
コード例 #13
0
ファイル: BoidsExample.py プロジェクト: dschoemehl/Schooling
def main():
    swarmSize = 30
    t = Turtle()
    win = Screen()
    win.setworldcoordinates(-600,-600,600,600)
    t.speed(10)
    t.tracer(15)
    t.hideturtle()

    for i in range(swarmSize):
        Schooler()

    #for turn in range(1000):
    while True:
        try:
            for schooler in Schooler.swarm:
                schooler.moveAllBoidsToNewPositions()
        except KeyboardInterrupt:
            break

    win.exitonclick()
コード例 #14
0
def main():
    ## create compound yellow/blue turtleshape for planets
    s = Screen()
    s.reset()
    s.tracer(0, 0)
    t = Turtle()
    t.ht()
    t.pu()
    t.fd(6)
    t.lt(90)

    t.begin_poly()
    t.circle(6, 180)
    t.end_poly()
    m1 = t.get_poly()

    t.begin_poly()
    t.circle(6,180)
    t.end_poly()
    m2 = t.get_poly()

    planetshape = Shape("compound")
    planetshape.addcomponent(m1,"orange")
    planetshape.addcomponent(m2,"blue")
    s.register_shape("planet", planetshape)
    s.tracer(1,0)

    ## setup gravitational system
    gs = GravSys()
    sun = Star(1000000, Vec(-250,0), Vec(0,-0.35), gs, "circle")
    sun.color("yellow")
    sun.pensize(1.8)
    sun.pu()
    earth = Star(5000, Vec(450,0), Vec(0,70), gs, "planet")
    earth.pencolor("green")
    earth.shapesize(0.8)

    rm=12.0583
    vm=(8.0*5000/rm)**.5
    moon = Star(1, Vec(450+rm,0), Vec(0,70+vm), gs, "planet")
    moon.pencolor("blue")
    moon.shapesize(0.5)
    gs.init()
    gs.start()
    return "Done!"
コード例 #15
0
def main():
    global s, sun
    s = Screen()
    #s.setup(800, 600) 
    #s.screensize(750, 550)
    createPlanetShape()
    ## setup gravitational system
    s.setworldcoordinates(-3.e11, -3e11, 3.e11, 3e11)
    gs = GravSys()
    sun = Star(mS, Vec2D(0.,0.), Vec2D(0.,0.), gs, "circle")
    sun.color("yellow")
    sun.turtlesize(1.8)
    sun.pu()
    earth = Star(mE, Vec2D(rE,0.), Vec2D(0.,vE), gs, "planet")
    earth.pencolor("green")
    earth.shapesize(0.8)
    moon = Star(mM, Vec2D(rE+rM,0.), Vec2D(0.,vE+vM), gs, "planet")
    moon.pencolor("blue")
    moon.shapesize(0.5)
    #gs.init()
    gs.start()
    return "Done!"
コード例 #16
0
def principal():
    janela = Screen()
    janela.setup(800,600)
    janela.title('Digimon, digitais, Digimon são campeões!')
    janela.bgcolor('white')
    carregaimagens('personagens', janela)
    carregaimagens ('digimons', janela)
    carregaimagens('digimonftowners', janela)
    carregaimagens('fundos', janela)
    cria_personagens()
    abertura(janela)
    ato2(janela)
    ato3(janela)
    ato4(janela)
    ato5(janela)
    ato6(janela)
    ato7(janela)
    ato8(janela)
    #finale(janela)
    fechamento(janela)
    debora_animacao(janela)
コード例 #17
0
ファイル: pytetris.py プロジェクト: peterfuchs1/Turtle
 def __init__(self, cols, rows):
     self.cols, self.rows = cols, rows
     self.screen = Screen()
     self.screen.screensize(BLOCKWIDTH * cols - 50, BLOCKWIDTH * rows - 50)
     self.screen.setup(BLOCKWIDTH * cols + 12, BLOCKWIDTH * rows + 12)
     self.screen.title("Turtle Tetris")
     self.screen.bgcolor("black")
     self.writer = Turtle()
     self.writer.ht()
     self.label = None
     self.grid = {}
     self.screen.tracer(False)
     for row in range(rows):
         for col in range(cols):
             self.grid[(col, row)] = TetrisTurtle(col, row)
     self.screen.tracer(True)
     self.brick = TetrisBrick(self)
     self.result = 0
     self.LEVEL = 0.6
     self.keybuffer = KeyBuffer(self.screen, ["Right", "Left", "Up", "Down", "space", "Escape"])
     self.reset()
     self.screen.listen()
     self.t1 = time()
コード例 #18
0
def createPlanetShape():
    s = Screen()
    s.tracer(0, 0)
    t = Turtle()
    t.ht()
    t.pu()
    t.fd(6)
    t.lt(90)
    t.begin_poly()
    t.circle(6, 180)
    t.end_poly()
    m1 = t.get_poly()
    t.begin_poly()
    t.circle(6, 180)
    t.end_poly()
    m2 = t.get_poly()

    planetshape = Shape("compound")
    planetshape.addcomponent(m1, "orange")
    planetshape.addcomponent(m2, "blue")
    s.register_shape("planet", planetshape)
    s.tracer(True, 0)
コード例 #19
0
ファイル: wikipedia.py プロジェクト: 1st1/cpython
def main():
    s = Screen()
    s.bgcolor("black")
    p=Turtle()
    p.speed(0)
    p.hideturtle()
    p.pencolor("red")
    p.pensize(3)

    s.tracer(36,0)

    at = clock()
    mn_eck(p, 36, 19)
    et = clock()
    z1 = et-at

    sleep(1)

    at = clock()
    while any(t.undobufferentries() for t in s.turtles()):
        for t in s.turtles():
            t.undo()
    et = clock()
    return "runtime: %.3f sec" % (z1+et-at)
コード例 #20
0
def main():
    s = Screen()
    s.bgcolor("black")
    p=Turtle()
    p.speed(0)
    p.hideturtle()
    p.pencolor("red")
    p.pensize(3)

    s.tracer(36,0)

    at = clock()
    mn_eck(p, 36, 19)
    et = clock()
    z1 = et-at

    sleep(1)

    at = clock()
    while any([t.undobufferentries() for t in s.turtles()]):
        for t in s.turtles():
            t.undo()
    et = clock()
    return "Laufzeit: {0:.3f} sec".format(z1+et-at)
コード例 #21
0
class TetrisBoard(object):
    def __init__(self, cols, rows):
        self.cols, self.rows = cols, rows
        self.screen = Screen()
        self.screen.screensize(BLOCKWIDTH*cols-50, BLOCKWIDTH*rows-50)
        self.screen.setup(BLOCKWIDTH*cols+12, BLOCKWIDTH*rows+12)
        self.screen.title("Turtle Tetris")
        self.screen.bgcolor("black")
        self.writer = Turtle()
        self.writer.ht()        
        self.label = None
        self.grid = {}
        self.screen.tracer(False)
        for row in range(rows):
            for col in range(cols):
                self.grid[(col, row)] = TetrisTurtle(col, row)
        self.screen.tracer(True)
        self.brick = TetrisBrick(self)
        self.result = 0
        self.LEVEL = 0.6
        self.keybuffer = KeyBuffer(self.screen,
                            ["Right", "Left", "Up", "Down", "space", "Escape"])
        self.reset()
        self.screen.listen()
        self.t1 = time()
        
    def reset(self):
        self.result = 0
        self.LEVEL = 0.600
        self.screen.tracer(False)
        self.writer.clear()
        if self.label:
            self.writer.clearstamp(self.label)
        for x in range(COLUMNS):
            for y in range(ROWS):
                self.grid[(x,y)].fillcolor("")
        self.screen.tracer(True)
        self.state = "NEWBRICK"
        
    def blink(self, y, n=1):
        for _ in range(n):
            for color in ("white", "black"):
                self.screen.tracer(False)
                for x in range(COLUMNS):
                    self.grid[(x,y)].pencolor(color)
                    sleep(self.LEVEL/10.0)
                self.screen.tracer(True)
            
    def display_result(self):
        tb = self
        tb.writer.color("white", "gray20")
        tb.writer.shape("square")
        tb.writer.shapesize(5, 15)
        tb.writer.goto(-4 ,0)
        self.label = tb.writer.stamp()
        tb.writer.goto(-2,3)
        tb.writer.write(str(tb.result) + " rows!",
                        align="center", font = ("Courier", 24, "bold") )
        tb.writer.goto(-2,-22)
        tb.writer.write("New game : <spacebar>",
                        align="center", font = ("Courier", 16, "bold") )
        tb.writer.goto(-2,-42)
        tb.writer.write("Quit : <escape>",
                        align="center", font = ("Courier", 16, "bold") )
        
    def getcolor(self, col, row):
        return self.grid[(col, row)].fillcolor()
    def setcolor(self, col, row, color):
        return self.grid[(col, row)].fillcolor(color)
    def rowfree(self, row):
        return not any([self.getcolor(col, row) for col in range(COLUMNS)])
    def rowfull(self, row):
        return all([self.getcolor(col, row) for col in range(COLUMNS)])

    def cleanup(self, shp):
        try:
            ymax = max([y for (x,y) in shp])
        except ValueError:
            self.state = "FINIS"
            return
        currenty = ymax
        while currenty > 0:
            if self.rowfull(currenty):
                self.blink(currenty, 2)
                self.result += 1
                if self.result == 8:
                    self.LEVEL = 0.4
                elif self.result == 20:
                    self.LEVEL = 0.25
                y = currenty
                while True:
                    self.screen.tracer(False)
                    for c in range(COLUMNS):
                        self.setcolor(c, y, self.getcolor(c, y-1))
                    self.screen.tracer(True)
                    if self.rowfree(y):
                        break
                    else:
                        y -= 1
            else:
                currenty -= 1
        tetris.state = "NEWBRICK"

    def run(self):
        tb = self
        b = self.brick
        ### actions to be done unconditionally
        if tb.state == "NEWBRICK":
            if b.reset():
                self.t1 = time()
                tb.state = "FALL"
            else:
                tb.state = "FINIS"
        t2 = time()
        if tb.state == "FALL" and t2 - self.t1 > self.LEVEL:
            b.down()
            b.apply("Step")
            self.t1 = t2
        ### actions bound to key events
        key = self.keybuffer.getkey()
        if key:
            if tb.state == "FALL":
                if key == "Left":
                    b.shiftleft()
                elif key == "Right":
                    b.shiftright()
                elif key == "Down":
                    b.drop()
                    tb.state = "CLEANUP"
                elif key == "Up":
                    b.turn()
                elif key == "space":
                    tb.state = "BREAK"
                b.apply(key)
            elif tb.state == "BREAK":
                if key == "space":
                    tb.state = "FALL"
            elif tb.state == "ADE":
                if key == "space":
                    tb.reset()
                    tb.state = "NEWBRICK"
                elif key == "Escape":
                    tb.screen.bye()
                
        if tb.state == "CLEANUP":
            tb.cleanup(b.shape1)
        if tb.state == "FINIS":
            tb.display_result()
            tb.state = "ADE"
        self.screen.ontimer(self.run, 100)    
コード例 #22
0
from turtle import Screen
from playertur import PlayerTur
from cars import Car
from scoreboard import Scoreboard
import time

screen = Screen()
screen.setup(width=800, height=600)
screen.title("Welcome to turtle crossing game")
screen.listen()
screen.tracer(0)

tim = PlayerTur()
car = Car()
scoreboard = Scoreboard()

screen.onkey(fun=tim.move_up, key="Up")

game_on = True
while game_on:
    time.sleep(car.speed)
    screen.update()

    car.move()

    car.detect_edge()

    # Detect collision
    for rectangle in car.cars:
        if tim.distance(rectangle) < 28 and rectangle.xcor() >= 0:
            scoreboard.game_over()
コード例 #23
0
from turtle import Turtle, Screen

amy = Turtle()
amy.shape('turtle')
amy.color('purple')

amy.forward(100)

my_screen = Screen()
my_screen.exitonclick()
コード例 #24
0
ファイル: turtle-2.py プロジェクト: ananelson/dexy-blog
        for p in plist:
            p.forward(l)
            q = p.clone()
            p.left(a)
            q.right(a)
            lst.append(p)
            lst.append(q)
        for x in tree(lst, l * f, a, f):
            yield None


def maketree():
    p = Turtle()
    p.pencolor("#697C82")
    p.setundobuffer(None)
    p.hideturtle()
    p.speed(0)
    p.tracer(30, 0)
    p.left(90)
    p.penup()
    p.forward(-210)
    p.pendown()
    t = tree([p], 200, 65, 0.6375)
    for x in t:
        pass


s = Screen()
maketree()
print s.getcanvas().postscript()
コード例 #25
0
ファイル: main.py プロジェクト: jaygandhi129/PongGamePython
from turtle import Screen
from paddle import Paddle
from ball import Ball
import time
from playsound import playsound
from scoreboard import Scoreboard

# Global Variables
BG_COLOR = "black"

screen = Screen()

screen.setup(width=800, height=600)
screen.bgcolor(BG_COLOR)
screen.title("Pong Game")
screen.tracer(0)
screen.listen()

r_paddle = Paddle((350, 0))
l_paddle = Paddle((-350, 0))
ball = Ball()
scoreboard = Scoreboard()

screen.onkeypress(r_paddle.go_up, "Up")
screen.onkeypress(r_paddle.go_down, "Down")
screen.onkeypress(l_paddle.go_up, "w")
screen.onkeypress(l_paddle.go_down, "s")

is_game_on = True

while is_game_on:
コード例 #26
0
ファイル: LysAvogpaa.py プロジェクト: Arxcis/Python-V2016
#!/usr/bin/python
# coding: utf-8

from turtle import Screen
from turtle import Turtle

s = Screen()
s.bgcolor('black')

ikea_lys = Turtle()
bestemors_lys = Turtle()

ikea_lys.shape('circle')
ikea_lys.color('black')
ikea_lys.shapesize(3)
bestemors_lys.shape('circle')
bestemors_lys.color('black')
bestemors_lys.shapesize(3)

class Lampe():
	lyser = False
	turtle = None


	def lag_skilpadde(self):
		""" Lager en egen skilpadde for denne lamen."""
		self.turtle = Turtle()
		self.turtle.penup()
		self.turtle.hideturtle()

		# Gult lys når vi lyser.
コード例 #27
0
    turtle.left(angle)
    hilbert_curve(n - 1, turtle, -angle)
    turtle.forward(1)
    turtle.right(angle)
    hilbert_curve(n - 1, turtle, angle)
    turtle.forward(1)
    hilbert_curve(n - 1, turtle, angle)
    turtle.right(angle)
    turtle.forward(1)
    hilbert_curve(n - 1, turtle, -angle)
    turtle.left(angle)


depth = 5  #int(sys.argv[1])
size = 2**depth

screen = Screen()
screen.setworldcoordinates(0, 0, size, size)

yertle = Turtle('turtle')
yertle.speed('fastest')
yertle.penup()
yertle.goto(0.5, 0.5)
yertle.pendown()

hilbert_curve(depth, yertle)

yertle.hideturtle()
screen.exitonclick()
コード例 #28
0
from random_walk_class import RandomWalk
from polygon_class import Polygon
import turtle
from turtle import Screen
from datetime import datetime

colors = ['#FA9579', '#654062', '#65D6CE', '#FFE9D6']
wn = Screen().setup(300, 300)

for i in range(8):
    for col in colors:
        turtle.color(col)
        random_walk = RandomWalk(turtle, 50, 300, 300)
        random_walk.draw_random_walk()

#for x in range(3, 100):
#    turtle.speed(100)
#    if x%2 == 0:
#        shape = Polygon(10,x)
#        shape.draw()
#    else:
#        shape = Polygon(10,x, 'left')
#        shape.draw()
now = datetime.today().strftime('%Y-%m-%d-%H:%M:%S')

turtle.getcanvas().postscript(
        file=f"step_4_18_300_300_pen_up_0/random_walk_{now}.eps")

random_walk.destroy()
コード例 #29
0
ファイル: test.py プロジェクト: fodare/Python-Codes
"""
Event listeners.

Function as an input
"""

from turtle import Turtle, Screen

tim = Turtle()
screen = Screen()


def move_forward():
    tim.forward(20)


screen.listen()
screen.onkey(key="space", fun=move_forward)
screen.exitonclick()
コード例 #30
0
ファイル: aa.py プロジェクト: NoirChad/GenStickFigure
from turtle import Turtle, Screen
from random import seed, randint

seed()

DELAY = 100  # milliseconds

# setup the output window
picSize = (400, 600)
playGround = Screen()
playGround.screensize(*picSize)

# setup the turtles
bob = Turtle(shape='turtle', visible=False)
bob.penup()
bob.color('red')
bob.speed('slow')

jeff = Turtle(shape='turtle', visible=False)
jeff.penup()
jeff.color('blue')
jeff.speed('normal')

x_quadrant = -picSize[0] // 2, picSize[0] // 2
y_quadrant = -picSize[1] // 2, picSize[1] // 2

# find random positions for the turtles
jeff_xy = randint(*x_quadrant), randint(*y_quadrant)
bob_xy = randint(*x_quadrant), randint(*y_quadrant)

# find a point to move bob to and rotate towards its target location
コード例 #31
0
# Throw rocks in a ocean

from turtle import Turtle, Screen

print("Creating an Ocean")
ocean = Screen()
ocean.title("Let's find Splash")

print("Creating a drawing turtle")
bob = Turtle()
bob.color('purple')
bob.speed(0)


def splash(x, y):
    print("splash at", x, y)
    bob.color('purple')
    bob.goto(x, y)
    bob.circle(50)


ocean.onclick(splash)

bob.ondrag(drag, btn=2)

ocean.listen()
コード例 #32
0
"""
Day 020 of the 100 Days of Code course
Author: Wayne Kwiat
Date: 1/22/2021
"""
from turtle import Screen
from snake import Snake
from food import Food
from scoreboard import Scoreboard
import time

screen = Screen()
screen.setup(width=600, height=600)
screen.bgcolor("black")
screen.title("Welcome to the snake game!")
screen.tracer(0)

snake = Snake()
food = Food()
scoreboard = Scoreboard()

screen.listen()
screen.onkey(snake.up, "Up")
screen.onkey(snake.down, "Down")
screen.onkey(snake.left, "Left")
screen.onkey(snake.right, "Right")

game_is_on = True
while game_is_on:
    screen.update()
    time.sleep(0.1)
コード例 #33
0
def move_right():
    canvas.xview_scroll(1, "units")
    turtle.setx(turtle.xcor() + MAGNIFICATION)


def move_up():
    canvas.yview_scroll(-1, "units")
    turtle.sety(turtle.ycor() + MAGNIFICATION)


def move_down():
    canvas.yview_scroll(1, "units")
    turtle.sety(turtle.ycor() - MAGNIFICATION)


screen = Screen()
width, height = screen.screensize()
screen.screensize(width * MAGNIFICATION, height * MAGNIFICATION)

canvas = screen.getcanvas()
canvas.config(xscrollincrement=str(MAGNIFICATION))
canvas.config(yscrollincrement=str(MAGNIFICATION))

turtle.width(MAGNIFICATION)
turtle.resizemode('auto')

screen.onkey(move_left, "Left")
screen.onkey(move_right, "Right")
screen.onkey(move_up, "Up")
screen.onkey(move_down, "Down")
screen.listen()
コード例 #34
0
ファイル: pong_game.py プロジェクト: Ragnar18/imageResizePy
from turtle import Screen, Turtle
from paddle import Paddle
from ball import Ball
from scoreboard import Scoreboard
import time

screen = Screen()
screen.bgcolor("black")
screen.setup(width=800, height=600)
screen.title("Pong")
screen.tracer(0)

r_paddle = Paddle((350, 0))
l_paddle = Paddle((-350, 0))
ball = Ball()
scoreboard = Scoreboard()

screen.listen()
screen.onkey(r_paddle.go_up, "Up")
screen.onkey(r_paddle.go_down, "Down")
screen.onkey(l_paddle.go_up, "w")
screen.onkey(l_paddle.go_down, "s")

game_is_on = True
while game_is_on:
    time.sleep(ball.move_speed)
    screen.update()
    ball.move()

    if ball.ycor() > 280 or ball.ycor() < -280:
        ball.bounce_y()
コード例 #35
0
from turtle import Turtle, Screen
import time

baseX = -75
baseY = -75
gridlength = 50
boardState = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
buttonStr = ["Play Again", "Exit"]
buttonLoc = []
al = Turtle()
al.shape("turtle")
screen = Screen()
al.speed(7)
playerOneTurn = True
gameOver = False
errorText = ""


def createBoard():
    """Establish the backend and frontend boards"""
    global boardState
    global playerOneTurn
    global gameOver
    boardState = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
    playerOneTurn = True
    gameOver = False
    for x in range(3):
        for y in range(3):
            __createBox(x, y)
    __createLabels()
    __createButtons()
コード例 #36
0
ファイル: asteroids.py プロジェクト: mwoinoski/crs1906
"""
Simple version of the classic Asteroids video game.
Implemented with Turtle graphics from Python standard turtle module.

Adapted from "Python Programming Fundamentals" by Kent Lee
http://knuth.luther.edu/~leekent/IntroToComputing/
"""

from time import sleep

from turtle import Turtle, Screen
import turtle
import random
import math

screen = Screen()
screenMinX = -screen.window_width() / 2
screenMinY = -screen.window_height() / 2
screenMaxX = screen.window_width() / 2
screenMaxY = screen.window_height() / 2

screen.setworldcoordinates(screenMinX, screenMinY, screenMaxX, screenMaxY)
screen.bgcolor("black")

offscreen_x = screenMinX - 100

t = Turtle()
t.penup()
t.ht()
t.speed(0)
t.goto(0, screenMaxY - 20)
コード例 #37
0
from turtle import Turtle
from turtle import Screen

bert = Turtle()
screen = Screen()


def draw_shapes():
    bert.penup()
    bert.left(90)
    bert.forward(100)
    bert.right(90)
    bert.left(180)
    bert.forward(100)
    bert.pendown()
    bert.left(180)

    # Triangle
    for _ in range(3):
        bert.forward(100)
        bert.right(120)

    # Square
    for _ in range(4):
        bert.color('red')
        bert.forward(100)
        bert.right(90)

    # Pentagon
    for _ in range(5):
        bert.color('blue')
コード例 #38
0
class PongGame:
    def __init__(self):
        # Create the Screen Object
        self.screen = Screen()
        self.screen.setup(SCREEN_XCOR, SCREEN_YCOR)
        self.screen.bgcolor("black")
        # Create Screen Cursor; Draw Pong Game Layout
        self.screen_cursor = Turtle()
        self.screen_cursor.ht()
        self.establish_game_layout()
        self.ball_speed = 0.07
        self.screen.tracer(0)

        # Create Score Cursor; Visualize and Update the Score
        self.score_cursor = Turtle()
        self.score_cursor.ht()
        self.score_cursor.color("white")
        self.score_cursor.speed("fastest")
        self.score_cursor.pu()
        self.scores = [0, 0]
        self.update_players_score()

        # Create Paddles Objects
        self.rt_paddle = Turtle()
        self.lt_paddle = Turtle()
        self.init_paddle(LT_PADDLE_POSITION, RT_PADDLE_POSITION)

        # Create Ball Object
        self.ball = Turtle()
        self.x_move = 10
        self.y_move = 10
        self.init_ball()

    def establish_game_layout(self):
        self.screen.title("Pong Game")
        self.screen_cursor.color("white")
        self.screen_cursor.pensize(3)
        self.screen_cursor.penup()
        self.screen_cursor.speed("fastest")
        # Type Game Title
        self.screen_cursor.setposition(x=0, y=(SCREEN_YCOR/2 - Y_MARGIN/1.3))
        self.screen_cursor.write("- Pong Game -", move=False, align="center", font=("Calibri", 30, "bold"))
        # Draw the Pong Table Margins
        self.screen_cursor.setposition((-GAME_XCOR/2), (GAME_YCOR/2))
        self.screen_cursor.pd()
        self.screen_cursor.fd(GAME_XCOR)
        self.screen_cursor.rt(90)
        self.screen_cursor.fd(GAME_YCOR)
        self.screen_cursor.rt(90)
        self.screen_cursor.fd(GAME_XCOR)
        self.screen_cursor.rt(90)
        self.screen_cursor.fd(GAME_YCOR)
        # Draw Dotted line
        self.screen_cursor.pu()
        self.screen_cursor.pensize(1)
        self.screen_cursor.setposition(0, (GAME_YCOR/2))
        self.screen_cursor.setheading(270)
        for i in range(int(GAME_YCOR/10)):
            if i % 2 == 0:
                self.screen_cursor.pd()
            else:
                self.screen_cursor.pu()
            self.screen_cursor.fd(10)

    def update_players_score(self, index=None):
        if index is not None:
            self.scores[index] += 1
        self.score_cursor.clear()
        self.score_cursor.setposition(-50, (GAME_YCOR/2)-70)
        self.score_cursor.write(f"{self.scores[LT_PLAYER]}", move=False, align="center", font=("Courier", 40, "bold"))
        self.score_cursor.setposition(50, (GAME_YCOR/2)-70)
        self.score_cursor.write(f"{self.scores[RT_PLAYER]}", move=False, align="center", font=("Courier", 40, "bold"))

    def init_paddle(self, lt_paddle_position, rt_paddle_position):
        self.lt_paddle.shape("square")
        self.lt_paddle.pu()
        self.lt_paddle.setheading(90)
        self.lt_paddle.shapesize(1, 6)
        self.lt_paddle.color("white")
        self.lt_paddle.setposition(lt_paddle_position)
        self.rt_paddle.shape("square")
        self.rt_paddle.pu()
        self.rt_paddle.setheading(90)
        self.rt_paddle.shapesize(1, 6)
        self.rt_paddle.color("white")
        self.rt_paddle.setposition(rt_paddle_position)

    def init_ball(self):
        self.ball.shape("circle")
        self.ball.pu()
        self.ball.shapesize(1.5, 1.5)
        self.ball.color("lime")

    def move_rt_paddle_up(self):
        if self.rt_paddle.ycor() <= (GAME_YCOR/2 - 80):
            self.rt_paddle.forward(20)

    def move_rt_paddle_down(self):
        if self.rt_paddle.ycor() >= -(GAME_YCOR/2 - 80):
            self.rt_paddle.backward(20)

    def move_lt_paddle_up(self):
        if self.lt_paddle.ycor() <= (GAME_YCOR/2 - 80):
            self.lt_paddle.forward(20)

    def move_lt_paddle_down(self):
        if self.lt_paddle.ycor() >= -(GAME_YCOR/2 - 80):
            self.lt_paddle.backward(20)

    def move_ball(self):
        self.ball.goto((self.ball.xcor()+self.x_move), (self.ball.ycor()+self.y_move))

    def bounce_ball_yAxis(self):
        self.y_move *= -1

    def bounce_ball_xAxis(self):
        self.x_move *= -1

    def reset_ball_position(self):
        # Reverse Ball Direction
        self.x_move *= -1
        # Reset Ball Position and Speed
        self.ball.setposition(0, 0)
        self.ball_speed = 0.12

    def check_hit_wall(self):
        if self.ball.xcor() >= (GAME_XCOR/2 - 10):
            return LT_PLAYER
        elif self.ball.xcor() <= -(GAME_XCOR/2 - 10):
            return RT_PLAYER

        if self.ball.ycor() >= (GAME_YCOR/2 - 30) or \
                self.ball.ycor() <= -(GAME_YCOR/2 - 30):
            self.bounce_ball_yAxis()
            return None

    def check_hit_paddle(self):
        if self.ball.distance(self.rt_paddle) < 60 and self.ball.xcor() > 340 or \
                self.ball.distance(self.lt_paddle) < 60 and self.ball.xcor() < -340:
            # Make Ball move Faster
            self.ball_speed *= 0.9
            # Reverse Ball Direction
            self.bounce_ball_xAxis()
コード例 #39
0
def main():
    # TODO 1: Configure screen
    screen = Screen()
    screen.setup(width=SCREEN_WIDTH, height=SCREEN_HEIGHT)
    screen.bgcolor(SCREEN_BACKGROUND_COLOR)
    screen.tracer(0)

    # Add borders
    border = Border()
    border.createBorder()

    # TODO 2: Configure initial snake
    snake = Snake()
    food = Food()
    scoreboard = Scoreboard()

    # TODO 3: Move the snake
    screen.listen()
    screen.onkey(snake.up, "Up")
    screen.onkey(snake.down, "Down")
    screen.onkey(snake.left, "Left")
    screen.onkey(snake.right, "Right")

    #global paused

    #def unpause():
    #    global paused
    #    paused = not paused

    #screen.onkey(unpause, "p")

    game_is_on = True
    while game_is_on:
        #while paused:
        #    sleep(0.2)
        screen.update()
        sleep(SLEEP_TIME)
        snake.move()

        # TODO 4: Detect collision with food
        snake_food_collision_distance = (
            food.width() + snake.head.width()) / 2 - COLLISION_ERROR
        if snake.head.distance(food) < snake_food_collision_distance:
            scoreboard.score += 1
            snake.add_segment()
            food.refresh()
            for segment in snake.tail:
                while segment.position() == food.position():
                    food.clear()
                    food.refresh()
            scoreboard.refresh()

        # TODO 5: Detect collision with walls
        pass_x_wall = (
            snake.head.xcor() < -SCREEN_WIDTH / 2 + snake.head.width()
            or snake.head.xcor() > SCREEN_WIDTH / 2 - snake.head.width())
        pass_y_wall = (
            snake.head.ycor() < -SCREEN_HEIGHT / 2 + snake.head.width()
            or snake.head.ycor() > SCREEN_HEIGHT / 2 - snake.head.width())
        wall_collision = pass_x_wall or pass_y_wall
        if wall_collision:
            scoreboard.resetHighestScore()
            snake.resetSnake()

        # TODO 6: Detect collision with tail
        tail_head_collision_distance = snake.head.width() - COLLISION_ERROR
        for segment in snake.tail[1:]:
            if segment.distance(snake.head) < tail_head_collision_distance:
                scoreboard.resetHighestScore()
                snake.resetSnake()

    screen.exitonclick()
コード例 #40
0
import time
from turtle import Screen
from player import Player
from car_manager import CarManager
from scoreboard import Scoreboard

screen = Screen()
screen.setup(width=600, height=600)
screen.tracer(0)

player = Player()
car_manager = CarManager()
scoreboard = Scoreboard()

screen.listen()
screen.onkey(player.go_up, "Up")
screen.onkey(player.go_down, "Down")

game_is_on = True
while game_is_on:
    time.sleep(0.1)
    screen.update()

    car_manager.create_cars()
    car_manager.move_cars()

    #detect collision with car
    for car in car_manager.all_cars:
        if car.distance(player) < 20:
            scoreboard.game_over()
            game_is_on = False
コード例 #41
0
ファイル: practice4.py プロジェクト: 0giru/python_practice
from turtle import Turtle, Screen
import random

T = []
is_race_on = False

screen = Screen()
screen.setup(width=500, height=400)

colors = [
    "red", "RosyBrown", "RoyalBlue", "SaddleBrown", "SeaGreen", "SlateBlue"
]

user_bet = screen.textinput("make your bet", "which turtle win the race?")

for i in range(len(colors)):
    turtle = Turtle()
    T.append(turtle)
    T[i].penup()
    T[i].shape("turtle")
    T[i].color(colors[i])
    T[i].goto(-150, -60 + 20 * i)

if user_bet:
    is_race_on = True

while is_race_on:
    for i in T:
        print(i.color())
        random_number = random.randint(0, 20)
        i.forward(random_number)
コード例 #42
0
        self.pu()
        self.goto(c*A, r*A*3**.5/3)
        self.shapesize(SHS, SHS, 1)
        self.D = self.distance(0,0)
        self.e = (1/self.D)*self.pos()
    def setturn(self, phi):
        self.goto(SF*self.D*dsin(90-phi)*self.e)
        self.settiltangle(phi*self.f)
        self.shapesize(SHS*SF)
        if abs(self.c) + abs(self.r) > 2:
            self.fillcolor([x + (1-x)*phi/360 for x in self.basecolor])
            bc = phi/360.
            self.pencolor(bc, bc, bc)
            

s = Screen()
s.reset()
s.tracer(0)
d = Turtle(visible=False)
lines(500)

triangles = []
for c in range(-5,6,2):
    triangles.append(TriTurtle(c, 1, 1))
    triangles.append(TriTurtle(c, -1, 2))
for c in range(-4,5,2):
    triangles.append(TriTurtle(c, 2, 2))
    triangles.append(TriTurtle(c, -2, 1))
    triangles.append(TriTurtle(c, -4, 2))
    triangles.append(TriTurtle(c, 4, 1))
for c in range(-3,4,2):
コード例 #43
0
    t.forward(peso)
    t.left(90)
    t.end_fill()            

A = list() # Cria uma lista vazia
for c in range(7):
    try:
        A.append(int(input('Digite um valor: ')))
    except:
        print('Erro encotrado. Só números inteiros podem ser inseridos.')

cor = list()        # Cria uma lista vazia
cor.append(str(input('Digite a cor da borda: '))) # Cria um elemento para a 1ª posição da lista
cor.append(str(input('Digite a cor do prenchimento: '))) # Cria um elemento para a 2ª posição da lista

tela = Screen()     # Mostra a janela e seus atributos
tela.bgcolor("lightgreen")

touche = Turtle()   # Cria a tartaruga 
touche.pensize(3)
touche.penup()
touche.backward(120)
touche.pendown()

try:
    touche.color(cor[0], cor[1])
except:
    print('Erro encontrado. Você não inseriu uma cor válida.')

for a in A:
    histograma(touche, a)
コード例 #44
0
import time
from turtle import Screen
from player import Player
from car_manager import CarManager
from scoreboard import Scoreboard

screen = Screen()
screen.setup(width=600, height=600)
screen.tracer(0)

player = Player()
car_manager = CarManager()
scoreboard = Scoreboard()

screen.listen()
screen.onkey(player.move, "Up")

game_is_on = True
while game_is_on:
    time.sleep(0.1)
    screen.update()

    car_manager.create_car()
    car_manager.move_cars()

    for car in car_manager.all_cars:
        if car.distance(player) < 20:
            game_is_on = False

    if player.is_at_finish_line():
        player.go_to_start()
コード例 #45
0
import time
from turtle import Screen
from player import Player
from car_manager import CarManager
from scoreboard import Scoreboard

screen = Screen()
screen.setup(width=600, height=600)
screen.bgcolor("white")
screen.tracer(0)

player = Player()

scoreboard = Scoreboard()

cars = CarManager()

game_is_on = True
while game_is_on:
    time.sleep(0.1)
    screen.update()
    collision = cars.generate(player)

    if collision:
        scoreboard.game_over()
        game_is_on = False

    if player.check_pass():
        scoreboard.increase_level()
        cars.accelerate()
コード例 #46
0
from turtle import Screen
from snake import Snake
from food import Food
from scoreboard import Scoreboard
import time

# 0. Game setup

screen = Screen()
screen.setup(width=600, height=600)
screen.bgcolor("black")
screen.title("The UNSW BSOC Experience")
screen.tracer(0)

snake = Snake()
food = Food()
scoreboard = Scoreboard()

# 3. Control the snake

screen.listen()

# Arrow Key Options
screen.onkey(snake.up, "Up")
screen.onkey(snake.down, "Down")
screen.onkey(snake.left, "Left")
screen.onkey(snake.right, "Right")

# WAS Option
screen.onkey(snake.up, "w")
screen.onkey(snake.down, "s")
コード例 #47
0
from turtle import Turtle, Screen
import random
screen = Screen()
screen.setup(width=500, height=400)
colours = ["red", "orange", "green", "blue", "yellow", "purple"]
step = [0, 5, 10]

choice = screen.textinput(title="Who will win?",
                          prompt="Pick a turtle, choose a color: ")


def config_turtle(pick, colour):
    pick.color(colours[colour])
    pick.penup()


def random_step(pick):
    pick.speed("fastest")
    move = random.choice(step)
    pick.forward(move)


t0 = Turtle(shape="turtle")
t1 = Turtle(shape="turtle")
t2 = Turtle(shape="turtle")
t3 = Turtle(shape="turtle")
t4 = Turtle(shape="turtle")
t5 = Turtle(shape="turtle")

turtles = [t0, t1, t2, t3, t4, t5]
コード例 #48
0
 def __init_drawing_window(cls):
     if cls.__screen is None:
         cls.__screen = Screen()
         cls.__screen.bgcolor("black")
         cls.__screen.setup(400, 300)
コード例 #49
0
import turtle
from turtle import Screen

tl = turtle.Turtle()
Screen().setup(height=1.0, width=1.0)


def arbre(n, l):
    if n == 0:
        return
    elif n != 0:
        tl.forward(l)
        tl.left(30)
        arbre(n - 1, l / 1.5)
        tl.right(60)
        arbre(n - 1, l / 1.5)
        tl.left(30)
        tl.backward(l)


arbre(10, 100)
turtle.mainloop()
コード例 #50
0
           tdemo_tangram.py

Inspired by Pawel Boytchev's Elica-Logo
implementation of the tangram game.

Use left mouse button to drag, middle
and right mouse button clicks to turn tiles,
left button doubleclick to flip rhomboid.
"""
from turtle import Turtle, Screen, Vec2D 
from button import Button
import sys, random, time

from tangramdata import tangramdata
sys.setrecursionlimit(20000)
screen = Screen()
screen.tracer(False)
screen.mode("logo")
designer = Turtle(visible=False)
designer.pu()

startdata = tangramdata[0]
tangramdata = tangramdata[1:]
A = 198.0
a = A / 4.0
d = a * 2**.5

def makerhomboidshapes():
    designer.shape("square")
    designer.shapesize(5, 2.5)
    designer.shearfactor(-1)    # needs Python 3.1
コード例 #51
0
ファイル: main.py プロジェクト: gizat/playground
from turtle import Screen
from paddle import Paddle
from ball import Ball
from scoreboard import Scoreboard
import time

screen = Screen()
screen.setup(width=800, height=600)
screen.bgcolor('black')
screen.title('Pong')
screen.tracer(0)

r_paddle = Paddle((350, 0))
l_paddle = Paddle((-350, 0))

ball = Ball()
scoreboard = Scoreboard()

screen.listen()
screen.onkey(r_paddle.up, 'Up')
screen.onkey(r_paddle.down, 'Down')
screen.onkey(l_paddle.up, 'w')
screen.onkey(l_paddle.down, 's')

game_on = True
while game_on:
    time.sleep(ball.move_speed)
    screen.update()
    ball.move()

    # Detect collision with wall
コード例 #52
0
import time
from turtle import Screen
from player import Player
from car_manager import CarManager
from scoreboard import Scoreboard

screen = Screen()
screen.title("Turtle Crossing")
screen.setup(width=600, height=600)

# Turn off the tracer
screen.tracer(0)

turtle_player = Player()

screen.listen()
screen.onkey(fun=turtle_player.move_up, key="Up")

car_manager = CarManager()
scoreboard = Scoreboard()

game_is_on = True
iteration = 0
while game_is_on:
    iteration += 1
    time.sleep(0.1)
    # Screen update every 0.1s
    screen.update()

    car_manager.create_car()
    car_manager.move_cars()
コード例 #53
0
class Time:
    # screen and turtle
    turtle = Turtle()
    turtle.fillcolor('gray')
    turtle.hideturtle()
    turtle.speed(0)
    turtle._delay(0)
    screen = Screen()
    screen.setup(width=600, height=400)
    screen.bgcolor('black')
    n = numbers.Numbers()
    d = digit.digit()

    # other turtles

    t1 = Turtle()
    t1.hideturtle()
    t1.speed(0)
    t1._delay(0)
    t1.fillcolor('white')

    t2 = Turtle()
    t2.hideturtle()
    t2.speed(0)
    t2._delay(0)
    t2.fillcolor('white')

    t3 = Turtle()
    t3.hideturtle()
    t3.speed(0)
    t3._delay(0)
    t3.fillcolor('white')

    t4 = Turtle()
    t4.hideturtle()
    t4.speed(0)
    t4._delay(0)
    t4.fillcolor('white')

    t5 = Turtle()
    t5.hideturtle()
    t5.speed(0)
    t5._delay(0)
    t5.fillcolor('white')

    # now

    def h1(self):
        now = datetime.now()
        h1 = str(now.strftime("%H")[0:1])
        h1 = int(h1)
        return h1

    def h2(self):
        now = datetime.now()
        h2 = str(now.strftime("%H")[1:2])
        h2 = int(h2)
        return h2

    def m1(self):
        now = datetime.now()
        m1 = str(now.strftime("%M")[0:1])
        m1 = int(m1)
        return m1

    def m2(self):
        now = datetime.now()
        m2 = str(now.strftime("%M")[1:2])
        m2 = int(m2)
        return m2

    # keret

    def keret(self, x, width):
        self.turtle.penup()
        self.turtle.begin_fill()
        self.turtle.setheading(90)
        self.turtle.goto(x, -100)
        self.turtle.pendown()
        for i in range(2):
            self.turtle.forward(220)
            self.turtle.left(90)
            self.turtle.forward(width)
            self.turtle.left(90)
        self.turtle.end_fill()

    def fullkeret(self):
        self.keret(-145, width=120)
        self.keret(-25, width=120)
        self.keret(25, width=50)
        self.keret(145, width=120)
        self.keret(265, width=120)

    # numbers selector

    def selector(self, number, size, turtle, x, y):
        if number == 0:
            self.n.number0(size=size, turtle=turtle, x=x, y=y)
        if number == 1:
            self.n.number1(size=size, turtle=turtle, x=x, y=y)
        if number == 2:
            self.n.number2(size=size, turtle=turtle, x=x, y=y)
        if number == 3:
            self.n.number3(size=size, turtle=turtle, x=x, y=y)
        if number == 4:
            self.n.number4(size=size, turtle=turtle, x=x, y=y)
        if number == 5:
            self.n.number5(size=size, turtle=turtle, x=x, y=y)
        if number == 6:
            self.n.number6(size=size, turtle=turtle, x=x, y=y)
        if number == 7:
            self.n.number7(size=size, turtle=turtle, x=x, y=y)
        if number == 8:
            self.n.number8(size=size, turtle=turtle, x=x, y=y)
        if number == 9:
            self.n.number9(size=size, turtle=turtle, x=x, y=y)

    def digit_selector(self, number, size, turtle, x, y):
        if number == 0:
            self.d.num0(size=size, turtle=turtle, x=x, y=y)
        if number == 1:
            self.d.num1(size=size, turtle=turtle, x=x, y=y)
        if number == 2:
            self.d.num2(size=size, turtle=turtle, x=x, y=y)
        if number == 3:
            self.d.num3(size=size, turtle=turtle, x=x, y=y)
        if number == 4:
            self.d.num4(size=size, turtle=turtle, x=x, y=y)
        if number == 5:
            self.d.num5(size=size, turtle=turtle, x=x, y=y)
        if number == 6:
            self.d.num6(size=size, turtle=turtle, x=x, y=y)
        if number == 7:
            self.d.num7(size=size, turtle=turtle, x=x, y=y)
        if number == 8:
            self.d.num8(size=size, turtle=turtle, x=x, y=y)
        if number == 9:
            self.d.num9(size=size, turtle=turtle, x=x, y=y)

    # base event + variables

    oldh1 = 10
    oldh2 = 10
    oldm1 = 10
    oldm2 = 10
    oldsec = 10
    valtozo = 1

    def base_event(self):
        m2 = self.m2()
        if m2 != self.oldm2:
            self.minute2(ido=m2)
            print('minute2 changed')
            self.oldm2 = m2
        m1 = self.m1()
        if m1 != self.oldm1:
            self.minute1(ido=m1)
            print('minute1 changed')
            self.oldm1 = m1
        h1 = self.h1()
        if h1 != self.oldh1:
            self.hour1(ido=h1)
            print('hour1 changed')
            self.oldh1 = h1
        h2 = self.h2()
        if h2 != self.oldh2:
            self.hour2(ido=h2)
            print('hour2 changed')
            self.oldh2 = h2
        self.screen.ontimer(fun=self.base_event, t=100)

    # second

    def second(self):
        now = datetime.now()
        second = str(now.strftime("%S")[1:2])
        second = int(second)
        if second != self.oldsec:
            if self.valtozo == 1:
                self.d.pont(turtle=self.t5, x=25, y=-100)
                self.valtozo = self.valtozo - 1
            else:
                self.t5.clear()
                self.valtozo = self.valtozo + 1
            self.oldsec = second
        self.screen.ontimer(fun=self.second, t=100)

    # writing

    def hour1(self, ido):
        self.t1.clear()
        """self.selector(number=ido, size=100, turtle=self.t1, x=-145, y=-100)"""
        self.digit_selector(number=ido,
                            size=80,
                            turtle=self.t1,
                            x=-145,
                            y=-100)

    def hour2(self, ido):
        self.t2.clear()
        """self.selector(number=ido, size=100, turtle=self.t2, x=-25, y=-100)"""
        self.digit_selector(number=ido, size=80, turtle=self.t2, x=-25, y=-100)

    def minute1(self, ido):
        self.t3.clear()
        """self.selector(number=ido, size=100, turtle=self.t3, x=145, y=-100)"""
        self.digit_selector(number=ido, size=80, turtle=self.t3, x=145, y=-100)

    def minute2(self, ido):
        self.t4.clear()
        """self.selector(number=ido, size=100, turtle=self.t4, x=265, y=-100)"""
        self.digit_selector(number=ido, size=80, turtle=self.t4, x=265, y=-100)

    # init

    def __init__(self):
        self.fullkeret()
        self.base_event()
        self.second()
        self.screen.mainloop()
コード例 #54
0
from turtle import Screen, Turtle

pantalla = Screen()

pantalla.setup(425, 225)
pantalla.screensize(400, 200)

tortuga = Turtle()

tortuga.forward(100)
tortuga.left(90)
tortuga.forward(100)
tortuga.left(90)
tortuga.forward(100)
tortuga.left(90)
tortuga.forward(100)

pantalla.exitonclick()
コード例 #55
0
from turtle import Turtle, Screen
from snake import Snake
from food import Food
from scoreboard import Scoreboard
import time


WIDTH = 600
HEIGHT = 600

WALL_W = WIDTH - 60
WALL_H = HEIGHT - 60

screen = Screen()
screen.bgcolor("black")
screen.setup(WIDTH, HEIGHT)
screen.title("Snake Eater")

outline = Turtle()
outline.color("white")
outline.pencolor("white")
outline.penup()
outline.goto(WALL_W / 2, -WALL_H/2)
outline.pendown()
outline.goto(WALL_W / 2, WALL_H / 2)
outline.goto(-WALL_W / 2, WALL_H / 2)
outline.goto(-WALL_W / 2, -WALL_H / 2)
outline.goto(WALL_W / 2, -WALL_H / 2)

body = []
コード例 #56
0
def main():
    global d, SHS, SF, A
    A = 42  # answer to the ultimate question ... (you know)
    SHS = A / 20.0
    SF = 1.0
    DSF = 1.0038582416
    s = Screen()
    s.setup(800, 600)
    s.reset()
    s.tracer(0)
    d = Turtle(visible=False)
    for i in range(6):
        d.fd(500)
        d.bk(500)
        d.left(60)

    triangles = []
    for c in range(-5, 6, 2):
        if abs(c) != 1:
            triangles.append(TriTurtle(c, 1, 1))
            triangles.append(TriTurtle(c, -1, 2))
    for c in range(-4, 5, 2):
        if c != 0:
            triangles.append(TriTurtle(c, 2, 2))
            triangles.append(TriTurtle(c, -2, 1))
        triangles.append(TriTurtle(c, -4, 2))
        triangles.append(TriTurtle(c, 4, 1))
    for c in range(-3, 4, 2):
        triangles.append(TriTurtle(c, 5, 2))
        triangles.append(TriTurtle(c, -5, 1))
        triangles.append(TriTurtle(c, -7, 2))
        triangles.append(TriTurtle(c, 7, 1))
    for c in range(-2, 3, 2):
        triangles.append(TriTurtle(c, 8, 2))
        triangles.append(TriTurtle(c, -8, 1))
    for c in (-1, 1):
        triangles.append(TriTurtle(c, 1, 1))
        triangles.append(TriTurtle(c, -1, 2))
    triangles.append(TriTurtle(0, 2, 2))
    triangles.append(TriTurtle(0, -2, 1))
    s.tracer(1)

    for phi in range(1, 361):
        SF = SF * DSF
        s.tracer(0)
        for t in triangles:
            t.setturn(phi)
        s.tracer(1)
    return "DONE!"
コード例 #57
0
from turtle import Turtle, Screen
import random

is_race_on = False
screen = Screen()
screen.setup(width=500, height=400)
user_bet = screen.textinput(
    title="Make your bet",
    prompt="Which turtle will win the race? Enter a color: ")
colors = ["red", "orange", "yellow", "green", "blue", "purple"]
turtles = []

for color_index in range(0, len(colors) - 1):
    new_turtle = Turtle(shape="turtle")
    new_turtle.color(colors[color_index])
    new_turtle.penup()
    new_turtle.goto(-230, -100 + color_index * 50)
    turtles.append(new_turtle)

if user_bet:
    is_race_on = True

while is_race_on:

    for turtle in turtles:
        if turtle.xcor() > 230:
            is_race_on = False
            winning_color = turtle.pencolor()
            if user_bet == winning_color:
                print(f"You've won! The {winning_color} turtle is the winner!")
            else:
コード例 #58
0
    print ("PSYCO -- SUPER!!")
except:
    print ("-- psyco not installed - reduced performance --")
    print ("-- Download psyco at http://psyco.sourceforge.net/ --")

# MAX_X and MAX_Y must be odd
MAX_X = 79
MAX_Y = 57
SQUARE_WIDTH = 10 # must be even
FREEROWS = 3
WINHEIGHT = MAX_Y + FREEROWS
MARG_X = 2 + SQUARE_WIDTH//2   
MARG_Y = 8
DM = 10

screen = Screen()

def coords(col, row):
	return ((-MAX_X//2 + col)*SQUARE_WIDTH + MARG_X,
                ((-MAX_Y+ FREEROWS)//2  + row )*SQUARE_WIDTH + MARG_Y)

def cellindices(x, y):
    return ((x-MARG_X + (SQUARE_WIDTH-1)//2)//SQUARE_WIDTH + MAX_X//2 + 1,
            (y-MARG_Y + (SQUARE_WIDTH-1)//2)//SQUARE_WIDTH + (MAX_Y- FREEROWS)//2)

def calccolor(i):
    i = min(20, i)
    return (1.05-i/20., 0., i/20.-0.05)
    
def generate(state):
    NBADDR = ((-1,-1),(-1,0),(-1,1),(0,-1),(0,1),(1,-1),(1,0),(1,1))
コード例 #59
-1
ファイル: py_moorhuhn.py プロジェクト: s-kimmer/tesp2016
 def __init__(self, w, h):
     Turtle.__init__(self, visible=False)
     self.screen = Screen()
     self.screen.setup(w, h)
     self.speed(0)
     self.penup()
     self.goto(-WINWIDTH//2 + 50, -WINHEIGHT//2 + 20)
     self.pencolor("yellow")
コード例 #60
-12
def main():
    t = Turtle()
    my_win = Screen()
    t.width(12)
    t.speed(10)
    t.left(90)
    t.up()
    t.backward(100)
    t.down()
    t.color("brown")
    tree(75, t)
    my_win.exitonclick()