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)
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)
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()
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)
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)
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)
from turtle import Screen, Turtle
from snake import Snake
from food import Food
import time
from scoreboard import Scoreboard
screen = Screen()
screen.setup(width=600, height=600)
screen.title(" 🐍🐍🐍 Snake Game")
screen.colormode(255)
screen.bgcolor((39, 40, 46))
screen.tracer(0)
score = Scoreboard()
snake = Snake()
food = Food()
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)
snake.move()
# Detect collision with food
if snake.head.distance(food) < 15:
food.refresh()
score.increase_score()
snake.direction = 'LEFT'
time.sleep(0.2)
snake.Move()
def right():
global snake
snake.direction = 'RIGHT'
time.sleep(0.2)
snake.Move()
screen = Screen()
screen.setup(800, 350)
screen.title("Snake")
screen.bgcolor("#CDFEFB")
move = Turtle()
move.hideturtle()
move.up()
# Отрисовка рамки
walls = Walls(360, 120)
walls.Draw()
p = Point(-320, 70, '*')
snake = Snake(p, 40, 'RIGHT')
snake.Drow()
foodCreator = FoodCreator(360, 120, '$')
food = foodCreator.CreateFood()
food.Draw()
from turtle import Turtle, Screen
def snowflake(t, iterations, size):
if iterations == 0: # Base Case
t.forward(size)
else:
pass
atuin = Turtle()
window = Screen()
atuin.color("#FFFFFF")
window.bgcolor("#0191C8")
atuin.penup()
atuin.backward(50)
atuin.pendown()
atuin.pensize(4)
num_sides = 3
iterations = 0
for i in range(num_sides):
snowflake(atuin, iterations, 100)
atuin.right(360 / num_sides)
window.exitonclick()
from turtle import Screen
from paddle import Paddle
from ball import Ball
import time
from scoreboard import ScoreBoard
s = Screen()
s.setup(width=800, height=600)
s.bgcolor("black")
s.title("Pong")
s.tracer(0)
r_paddle = Paddle((350, 0))
l_paddle = Paddle((-350, 0))
ball = Ball()
scoreboard = ScoreBoard()
s.listen()
s.onkey(key="Up", fun=r_paddle.up)
s.onkey(key="Down", fun=r_paddle.down)
s.onkey(key="w", fun=l_paddle.up)
s.onkey(key="s", fun=l_paddle.down)
game_on = True
while game_on:
time.sleep(ball.move_speed)
s.update()
ball.move()
#Collision with wall
if ball.ycor() > 280 or ball.ycor() < -280:
import time
from turtle import Screen
from snake import Snake
screen = Screen()
# Set screen width & height
screen.setup(width=600, height=600)
# Set backgroundColor
screen.bgcolor('black')
# Set screen title
screen.title("Classic Snake Game")
# Turn off animation
screen.tracer(0)
snake = Snake()
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:
# Update screen after each segment completes displacement
screen.update()
time.sleep(0.1)
snake.move()
screen.exitonclick()
def main():
screen = Screen()
screen.setup(width=800, height=600)
screen.bgcolor('black')
screen.title('Pong Game')
screen.tracer(0)
score_board = ScoreBoard()
score_board.display_score()
CenterLine()
player1 = Paddle((350, 0))
player2 = Paddle((-350, 0))
ball = Ball()
screen.onkey(player1.move_up, 'Up')
screen.onkey(player1.move_down, 'Down')
screen.onkey(player2.move_up, 'w')
screen.onkey(player2.move_down, 's')
screen.listen()
def game_continue():
if messagebox.askretrycancel("Game Over!!", "Wanna play again? "):
screen.clear()
main()
running = True
while running:
time.sleep(0.05)
screen.update()
if score_board.check_win():
score_board.final_result()
ball.hideturtle()
break
if ball.ispoint_wait:
if ball.point_wait < 50:
ball.point_wait += 1
continue
else:
ball.ispoint_wait = False
ball.point_wait = 1
screen.update()
ball.move()
# for not repeating collision if the distance is small
if player1.is_collided:
if player1.safe_count < 5:
player1.safe_count += 1
else:
player1.is_collided = False
player1.safe_count = 1
elif player2.is_collided:
if player2.safe_count < 5:
player2.safe_count += 1
else:
player2.is_collided = False
player2.safe_count = 1
if ball.ycor() > 265 or ball.ycor() < -270:
ball.wall_collision()
if ball.xcor() < 370 and ball.distance(
player1) < 45 and not player1.is_collided:
ball.paddle_collision()
ball.hit_count += 1
ball.hit = True
player1.is_collided = True
elif ball.xcor() > -370 and ball.distance(
player2) < 45 and not player2.is_collided:
ball.paddle_collision()
ball.hit_count += 1
ball.hit = True
player2.is_collided = True
if ball.hit_count % 2 == 0 and ball.hit_count != 0 and ball.hit:
if ball.bounce_speed < 0:
ball.bounce_speed -= 1.5
else:
ball.bounce_speed += 1.5
ball.bounce_x = ball.bounce_speed
ball.hit = False
if ball.xcor() > 380:
score_board.clear()
score_board.score1 += 1
score_board.display_score()
ball.ispoint_wait = True
ball.ball_reset()
elif ball.xcor() < -380:
score_board.clear()
score_board.score2 += 1
score_board.display_score()
ball.ispoint_wait = True
ball.ball_reset()
screen.update()
time.sleep(1)
game_continue()
screen.bye()
screen.exitonclick()
from turtle import Turtle as t, Screen
import random as r # Return a random integer N such that a <= N <= b. Alias for randrange(a, b+1).
# from turtle import Turtle as t, Screen
wn = Screen()
wn.bgcolor('black')
wn.screensize(2000, 2000)
point = 0
pt = t()
draw = t() # -280, 250 부터
def drawwall():
draw.pencolor("white")
draw.penup()
draw.goto(-280, 250)
draw.pendown()
draw.goto(280, 250)
draw.goto(280, -250)
draw.goto(-280, -250)
draw.goto(-280, 250)
draw.speed(2)
def L(): # 재시작하는 함수
global playing
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") # Change background color
screen.title("My Snake Game") # Title of the screen
screen.tracer(0) # Turn the turtle animation on(1) or off(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)
snake.move()
# Detect collision with food.
if snake.head.distance(food) < 15:
food.refresh()
from turtle import Turtle, Screen
wn = Screen()
wn.bgcolor('lightblue')
spaceship = Turtle()
spaceship.color('red')
spaceship.pendown()
speed = 100
def travel():
spaceship.forward(speed)
wn.ontimer(travel, 10)
wn.onkey(lambda: spaceship.setheading(90), 'Up')
wn.onkey(lambda: spaceship.setheading(180), 'Left')
wn.onkey(lambda: spaceship.setheading(0), 'Right')
wn.onkey(lambda: spaceship.setheading(270), 'Down')
wn.listen()
travel()
wn.mainloop()
from turtle import Turtle, Screen
from paddle import Paddle
from ball import Ball
from scoreboard import Scoreboard
import time
screen = Screen()
screen.setup(width=900, height=700)
screen.bgcolor("orange")
screen.tracer(0)
r_paddle = Paddle(position_of_paddle=(400, 0))
l_paddle = Paddle(position_of_paddle=(-400, 0))
ball = Ball()
score = Scoreboard()
screen.listen()
screen.onkey(fun=r_paddle.go_up, key="Up")
screen.onkey(fun=r_paddle.go_down, key="Down")
screen.onkey(fun=l_paddle.go_up, key="w")
screen.onkey(fun=l_paddle.go_down, key="s")
game_is_on = True
while game_is_on:
time.sleep(ball.move_speed)
screen.update()
ball.move()
# Detecting Collision with the wall.
if ball.ycor() > 330 or ball.ycor() < -330:
ball.bounce_y()
from turtle import Screen
from player import Player
from scoreboard import ScoreBoard
from obstacle import Obstacle
import math
import time
# Constants
OBSTACLE_SPEED = 0.1
GRAVITY = 0.05
OBSTACLES = []
# Create the screen
screen = Screen()
screen.setup(width=800, height=600)
screen.bgcolor("white")
screen.title("Flappy Byrd")
screen.tracer(0)
image = "./images/le_byrd.gif"
screen.addshape(image)
# Initialize player scoreboard and obstacles - Game assets
player = Player(image=image)
scoreboard = ScoreBoard()
obstacles = []
# Respond to clicks
screen.listen()
screen.onkey(player.flap, "Up")
screen.onkey(player.dive, "Down")
from turtle import Turtle, Screen
import turtle
import random
#Setting up the interface
wn = Screen()
wn.title("Monty's Python Game")
wn.setup(width=800, height=800)
wn.bgcolor('green')
#allows the game to move at a smooth speed
wn.tracer(0, 0)
#creating the food the player will move over to score points,
# by creating the food outside of the Snake class, it means each player will be chasing the same food, making the game more two-player orientated and more competitive.
food = turtle.Turtle()
food.penup()
food.goto(60,60)
food.speed(0)
food.shape('circle')
food.color('white')
food.fillcolor('black')
#Creating the class 'Snake', this is the class from which the two player instances will be made from
class Snake:
#the parameters in __init__ are the parameters that allow the player instances to be called, e.g. 'color' allows the instances to be called with different colors so the players know who is who
def __init__(self, goto, color, player, setx, sety):
self.sc = Screen()
from turtle import Screen, Turtle
from random import random, randint
screen = Screen()
width, height = 800, 600
screen.setup(width, height)
screen.delay(0)
screen.title("星空")
screen.bgcolor("#141852")
def draw_rose():
t = Turtle()
t.up()
t.goto(100, 50)
t.down()
t.speed(3)
t.penup()
t.left(90)
t.fd(100)
t.pendown()
t.right(90)
t.fillcolor("red")
t.begin_fill()
t.circle(10, 180)
t.circle(25, 110)
t.left(50)
t.circle(60, 45)
t.circle(20, 170)
t.right(24)
t.fd(30)
from turtle import Screen, Turtle
import time
from serpientes import Serpientes
from comida import Comida
from puntaje import Puntaje
pantalla = Screen()
pantalla.setup(width=600, height=600)
pantalla.bgcolor("black")
pantalla.title("Juego Snake en Python")
pantalla.tracer(0)
serpiente = Serpientes()
comida = Comida()
puntaje = Puntaje()
pantalla.listen()
pantalla.onkey(serpiente.arriba, "Up")
pantalla.onkey(serpiente.abajo, "Down")
pantalla.onkey(serpiente.izquierda, "Left")
pantalla.onkey(serpiente.derecha, "Right")
juego_encendido = True
while juego_encendido:
pantalla.update()
time.sleep(0.1)
serpiente.movimiento()
#Detectar contacto con la comida
if serpiente.head.distance(comida) < 15:
from barriers import Barriers
from enemy_ships import EnemyShips
from enemy_bullet import EnemyBullet
from random import randint
from score_board import Scoreboard
import time
player_bullets = []
enemy_bullets = []
player_ship_x_position = None
enemy_y_position = None
enemy_x_position = None
game_screen = Screen()
Width, Height = 650, 600
game_screen.setup(Width, Height)
game_screen.bgcolor("black")
game_screen.title("Arcade Game")
game_screen.tracer(0)
# Y wall limit
Y_WALL = 300
player_ship = PlayerShip()
barriers = Barriers()
enemy = EnemyShips()
def shot_bullet_player():
global player_bullets, player_ship_x_position
# Player can shoot a Max of 6 bullets at a time
if len(player_bullets) < 6:
from turtle import Screen from paddle import Paddle from ball import Ball from scoreboard import Scoreboard import time BALL_X_MAX = 330 SCREEN_BG_COLOR = 'black' PADDLE_1_POS = (350, 0) PADDLE_2_POS = (-350, 0) screen = Screen() screen.setup(width=800, height=600) screen.bgcolor(SCREEN_BG_COLOR) screen.tracer(0) screen.listen() paddle1 = Paddle(PADDLE_1_POS) paddle2 = Paddle(PADDLE_2_POS) ball = Ball() scoreboard = Scoreboard() ball.create_line() screen.onkey(paddle1.up, 'Up') screen.onkey(paddle2.up, 'w') screen.onkeypress(paddle1.up, 'Up') screen.onkeypress(paddle2.up, 'w') screen.onkey(paddle1.down, 'Down') screen.onkey(paddle2.down, 's') screen.onkeypress(paddle1.down, 'Down') screen.onkeypress(paddle2.down, 's')
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)
from turtle import Screen
import time
from Food import Food
from Snake import Snake
from scoreboard import Scoreboard
screen = Screen()
screen.title('Snake Game')
screen.setup(600,600)
screen.bgcolor('#000')
screen.tracer(0)
snake = Snake()
food = Food()
scoreboard = Scoreboard()
screen.listen()
screen.onkey(snake.up,'Up')
screen.onkey(snake.down,'Down')
screen.onkey(snake.right,'Right')
screen.onkey(snake.left,'Left')
score = 0
game_on = True
while game_on:
screen.update()
time.sleep(0.1)
snake.move()
# collision with food
if snake.t[0].distance(food) < 15:
from turtle import Turtle, Screen
tarty = Turtle()
sfondo = Screen()
sfondo.colormode(255)
R = 0
G = 255
B = 0
sfondo.bgcolor((R, G, B))
tarty.speed(3)
tarty.turtlesize(10)
# quadrato
tarty.goto(-100, -100)
tarty.begin_fill() # inizia un disegno a colore pieno
tarty.color('red')
for i in range(4):
tarty.forward(100)
tarty.left(90)
tarty.end_fill() # finisce il disegno a colore pieno
tarty.penup()
tarty.goto(100, -100)
tarty.pendown()
tarty.begin_fill() # inizia un disegno a colore pieno
tarty.color('blue')
from turtle import Screen
from paddle import Paddle
from field import Field
from score import ScoreBoard
from ball import Ball
import time as t
scr = Screen()
scr.setup(width=800, height=600)
scr.bgcolor("black")
scr.title("Pong")
scr.tracer(0)
scr.listen()
game_end = False
player_1 = Paddle("Player_1")
player_2 = Paddle("Player_2")
field = Field()
score = ScoreBoard()
ball = Ball()
def is_game_over():
global game_end
game_end = True
while not game_end:
scr.update()
start_game = None
doubles = None
wsls = None
DATABASE_NAME = 'system/stats.db'
# # # Game states ####
# 0 - choose game play
# 50 - choose game type
# 100 - choose game size
# 150 - choose players
# 200 - in game
# window screen set up
window = Screen()
window.title("Table tennis scoreboard")
window.bgcolor("black")
window.setup(width=1024, height=600)
window.delay(0)
window.tracer(False)
# turtle set up
pen = Turtle()
pen.speed(0)
pen.color("white")
pen.hideturtle()
pen.penup()
# definitions of game functions
def database_update_singles():
from turtle import Screen
from paddle import Paddle
from ball import Ball
from score import Score
import time
#Configuring the Screen
sc = Screen()
sc.tracer(0) #Don't use animations
sc.bgcolor('black')
sc.title('🏐 Pong')
sc.setup(width=800, height=600)
#Instantiating two padels, scoreboard and a ball
player1 = Paddle(left_panel=False)
player2 = Paddle(left_panel=True)
score = Score()
ball = Ball()
#Key bindings
sc.listen()
sc.onkey(player1.go_up, 'Up')
sc.onkey(player1.go_down, 'Down')
sc.onkey(player2.go_up, 'w')
sc.onkey(player2.go_down, 's')
#Start While Loop
playing = True
while playing:
time.sleep(0.1)
from turtle import Screen, Turtle
from paddle import Paddle
from ball import Ball
from pong_scoreboard import Scoreboard
import time
#set up screen
screen = Screen()
screen.setup(width=800, height=600)
screen.bgcolor("grey")
screen.title("PONG")
screen.tracer(0)
# #make dotted line
# dotted_line = Turtle()
# dotted_line.hideturtle()
# dotted_line.color("white")
# dotted_line.speed("fastest")
# dotted_line.width(5)
# dotted_line.penup()
# dotted_line.goto(x=0, y=290)
# dotted_line.rt(90)
#
#
# for _ in range(18):
# dotted_line.pendown()
# dotted_line.forward(15)
# dotted_line.penup()
# dotted_line.forward(20)
#place paddles and ball on screen
# Todo 1: Classes are paddle, ball, score.
# Todo 2: Tasks are class creation, procedures of hitting walls and bounce
# Todo 3: Another tasks are procedures of missing walls and score increase
from turtle import Screen
from paddle_drawers import Paddle, Drawer, X_SIZE, Y_SIZE
from ball import Ball
import time
# Preparation of the scene.
playground = Screen()
playground.bgcolor("black")
playground.setup(width=X_SIZE, height=Y_SIZE)
playground.title("A game of Pong")
right = Paddle(position="right")
left = Paddle(position="left")
upper_drawer = Drawer("up")
bottom_drawer = Drawer("down")
announcer = Drawer(direction="center")
announcer.write(arg="The ball will be sent out randomly.\n"
"Whoever scores 25 points wins.\n"
"The more points you score,\n"
"the faster ball runs on your side of the field.",
font=("Verdana", 18, "bold"))
time.sleep(2)
playground.listen()
playground.onkey(fun=right.go_up, key="Up")
playground.onkey(fun=right.go_down, key="Down")
playground.onkey(fun=left.go_up, key="w")
import random
from turtle import Turtle, Screen
screen = Screen()
screen.bgcolor('yellow')
caterpillar = Turtle('square', visible=False)
caterpillar.color('red')
caterpillar.speed('fastest')
caterpillar.penup()
leaf_shape = ((0, 0), (14, 2), (18, 6), (20, 20), (6, 18), (2, 14))
screen.register_shape('leaf', leaf_shape)
leaf = Turtle('leaf', visible=False)
leaf.color('green')
leaf.speed('fastest')
leaf.penup()
game_started = False
text_turtle = Turtle(visible=False)
text_turtle.write('Press SPACE to start',
align='center',
font=('Arial', 56, 'bold'))
score_turtle = Turtle(visible=False)
score_turtle.speed('fastest')
score_turtle.penup()
x = (screen.window_width() / 2) - 50
y = (screen.window_height() / 2) - 50
score_turtle.setpos(x, y)
from turtle import Turtle, Screen
from paddle import Paddle
screen = Screen()
screen.setup(width=800, height=600)
screen.bgcolor("Black")
screen.title("Pong")
screen.listen()
screen.tracer(0)
paddle1 = Paddle(350)
paddle2 = Paddle(-350)
screen.onkey(key="Up", fun=paddle1.up)
screen.onkey(key="Down", fun=paddle1.down)
screen.onkey(key="w", fun=paddle2.up)
screen.onkey(key="s", fun=paddle2.down)
is_on = True
while is_on:
screen.update()
screen.exitonclick()
from turtle import Screen
from snake import Snake
from food import Food
from scoreboard import Scroreboard
import time
screen = Screen()
screen.setup(width=600, height=600)
screen.bgcolor("black")
screen.title("Snake Game")
screen.tracer(0)
snake = Snake()
food = Food()
scoreboard = Scroreboard()
game_is_on = True
screen.listen()
screen.onkey(snake.up, "Up")
screen.onkey(snake.down, "Down")
screen.onkey(snake.left, "Left")
screen.onkey(snake.right, "Right")
while game_is_on:
screen.update()
time.sleep(0.1)
snake.move()
if snake.head.distance(food) < 15:
scoreboard.increse_score()
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)
t.color('grey')
t.write("Turtles in Space!!", align="center", font=("Arial", 20))
t.goto(0, screenMaxY - 33)
t.write("Use the arrow keys to move, 'x' to fire, 'q' to quit", align="center")
t.goto(0, 0)
t.color("red")
sides = sides - 1
#bot.clear()
def draw_circle(bot, x, y):
#bot = turtle.Turtle();
#bot.ht()
bot.shape("circle");
bot.color("green");
bot.speed("slowest");
#bot.setpos(x, y)
#bot.st()
bot.circle(50);
bot.clear()
window = Screen();
window.bgcolor("yellow");
#draw_triangle(3, 100, 100)
#draw_square(4, 200, 200)
#draw_circle(300, 300)
# 1. don't show trutle shape.
# 2. we need to draw multiple squres (360/10 = 36 squares)
# 3. each squre we should start with different angle (10 degrees).
# 4. for each square, createa turtle and call square function.
bot = Turtle()
#bot.ht()
bot.color("blue", "green");
bot.speed("fast");
bot.begin_fill()
class MazeGraphics(object):
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)
def setupTurtle(self, width, height):
self.screen.tracer(False)
self.screen.screensize(width, height)
# some basic turtle settings
self.screen.setworldcoordinates(-1, -1, width + 1, height + 1)
self.screen.title("Random Turtle Maze")
self.screen.bgcolor(self.bg_color)
self.screen.delay(None)
self.designer = Turtle(visible=False)
def drawGrid(self):
for i in xrange(0, self.width + 1):
self.drawXLines(i, self.width, self.line_color)
for i in xrange(0, self.height + 1):
self.drawYLines(i, self.width, self.line_color)
self.screen.update()
def drawXLines(self, position, width, color):
self.drawLines(position, 0, width, color, 90)
def drawYLines(self, position, width, color):
self.drawLines(0, position, width, color, 0)
def drawLines(self, xPosition, yPosition, width, color, heading):
self.designer.up()
self.designer.setposition(xPosition, yPosition)
self.designer.color(color)
self.designer.down()
self.designer.setheading(heading)
self.designer.forward(width)
self.designer.up()
def drawCentroid(self, cell, color):
"""
Draw a centroid for animation purposes but then overwrite it.
"""
self.designer.setposition(cell.centroid)
self.designer.dot(5, color)
self.screen.update()
self.designer.dot(5, self.bg_color)
def removeWall(self, posx, posy, heading, color):
"""
We tear down walls to build the maze
"""
self.designer.up()
self.designer.setposition(posx, posy)
self.designer.down()
self.designer.color(color)
self.designer.setheading(heading)
self.designer.forward(1)
self.designer.up()
self.screen.update()
def drawPath(self, cell1, cell2):
"""
This draws a line for the solution as it's worked out.
"""
self.designer.setposition(cell1.centroid)
self.designer.color(self.path_color)
direction = self.getDirection(cell1, cell2)
if direction == "N":
self.designer.setheading(90)
self.designer.down()
self.designer.forward(1)
self.designer.up()
elif direction == "S":
self.designer.setheading(270)
self.designer.down()
self.designer.forward(1)
self.designer.up()
elif direction == "W":
self.designer.setheading(0)
self.designer.down()
self.designer.forward(1)
self.designer.up()
elif direction == "E":
self.designer.setheading(0)
self.designer.down()
self.designer.backward(1)
self.designer.up()
self.drawCentroid(cell2, self.line_centroid_color)
self.screen.update()
def getDirection(self, currCell, nextCell):
direction = None
if nextCell.x < currCell.x:
direction = "E"
elif nextCell.x > currCell.x:
direction = "W"
elif nextCell.y < currCell.y:
direction = "S"
elif nextCell.y > currCell.y:
direction = "N"
return direction
#!/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.
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("light grey")
screen.title("Why did the turtle cross the street?")
screen.tracer(0)
game_is_on = True
turtle = Player()
score = Scoreboard()
car = CarManager()
screen.listen()
screen.onkeypress(turtle.move, "Up")
while game_is_on:
time.sleep(turtle.move_speed)
screen.update()
car.create_car()
car.move_car()
if turtle.ycor() > 280:
score.level_sum()
turtle.start_position()
# Turtle Docs: https://docs.python.org/2.7/library/turtle.html
from turtle import Turtle, Screen
# Create two objects: a Turtle with the name cursor and a Screen called window
cursor = Turtle()
window = Screen()
# Set the window background color to black
window.bgcolor("black")
# Make the cursor ink white, the width of the pen 3, the shape a turtle, and
# move at moderate speed
cursor.color("white")
cursor.width(3)
cursor.shape("turtle") # or "circle", "classic", etc.
cursor.speed(5) # 1 - 10
# Draw a square of side length 100 starting from the home position
cursor.home()
for i in range(4):
print cursor.position()
cursor.forward(100)
cursor.right(90)
print cursor.position()
# Move the turtle to (0, 100) without drawing anything,
# then draw a pentagon
cursor.penup()
cursor.sety(100)
print cursor.position()
def my_method(self, name, msg):
#x = math.cos(math.radians(22.5))*msg.current_distance
#alert = alertdist
print(msg.current_distance)
#print(x)
global flag
global indexflag
global turtle
global screen
if flag ==0:
#x axis
screen = Screen()
turtle = Turtle(visible=False)
screen.bgcolor("black")
turtle.pencolor("green")
turtle.speed(0)
turtle.penup()
axis(turtle, watchdist, 30)
#45 degree
turtle.penup()
turtle.home()
turtle.setheading(45)
axis(turtle, watchdist, 30)
#y axis
turtle.penup()
turtle.home()
turtle.setheading(90)
axis(turtle, watchdist, 30)
#135 degree
turtle.penup()
turtle.home()
turtle.setheading(135)
axis(turtle, watchdist, 30)
# watch circle
turtle.penup()
turtle.home()
turtle.goto(0, -watchdist)
turtle.pendown()
turtle.circle(watchdist)
#alert circle
turtle.penup()
turtle.home()
turtle.goto(0, -alertdist)
turtle.pendown()
turtle.circle(alertdist)
flag = 1
#update dots in graph
global index
if index > 7:
index = 0
#global position0, position1, posiiton2, posiiton3, position4, position5, position6, position7
global position0
if msg.current_distance > alertdist and msg.current_distance <= watchdist:
print("It's sensor: ", repr(index))
turtle.penup()
if index ==0:
#position0 = turtle.posiion()
if indexflag == 0:
indexflag =1
else:
turtle.goto(position0)
turtle.dot(10, "black")
turtle.goto(0, msg.current_distance)
position0 = turtle.position()
turtle.dot(10,"red")
turtle.penup()
elif index ==1:
#position1 = turtle.position()
if indexflag == 0:
indexflag =1
else:
turtle.goto(position0)
turtle.dot(10, "black")
turtle.goto(math.cos(math.radians(45))*msg.current_distance,math.sin(math.radians(45))*msg.current_distance)
position0 = turtle.position()
turtle.dot(10,"red")
turtle.penup()
elif index ==2:
#position2 = turtle.position()
if indexflag == 0:
indexflag = 1
else:
turtle.goto(position0)
turtle.dot(10, "black")
turtle.goto(msg.current_distance,0)
position0 = turtle.position()
turtle.dot(10,"red")
turtle.penup()
elif index ==3:
#position3 = turtle.position()
if indexflag == 0:
indexflag = 1
else:
turtle.goto(position0)
turtle.dot(10, "black")
turtle.goto(math.cos(math.radians(45))*msg.current_distance,-math.sin(math.radians(45))*msg.current_distance)
position0 = turtle.position()
turtle.dot(10,"red")
turtle.penup()
elif index ==4:
#position4 = turtle.position()
if indexflag == 0:
indexflag = 1
else:
turtle.goto(position0)
turtle.dot(10, "black")
turtle.goto(0, -msg.current_distance)
position0 = turtle.position()
turtle.dot(10,"red")
turtle.penup()
elif index ==5:
#position5 = turtle.position()
if indexflag == 0:
indexflag = 1
else:
turtle.goto(position0)
turtle.dot(10, "black")
turtle.goto(-math.cos(math.radians(45))*msg.current_distance, -math.sin(math.radians(45))*msg.current_distance)
position0 = turtle.position()
turtle.dot(10,"red")
turtle.penup()
elif index ==6:
#position6 = turtle.position()
if indexflag == 0:
indexflag = 1
else:
turtle.goto(position0)
turtle.dot(10, "black")
turtle.goto(-msg.current_distance,0)
position0 = turtle.position()
turtle.dot(10,"red")
turtle.penup()
elif index ==7:
#position7 = turtle.position()
if indexflag == 0:
indexflag = 1
else:
turtle.goto(position0)
turtle.dot(10, "black")
turtle.goto(-math.cos(math.radians(45))*msg.current_distance,math.sin(math.radians(45))*msg.current_distance)
position0 = turtle.position()
turtle.dot(10,"red")
turtle.penup()
print("-----------")
vehicle.mode = VehicleMode("BRAKE")
print("it's within the alert distance, control override!")
print("now it's in BRAKE mode")
print("-----------")
else:
print("-----------")
vehicle.mode = VehicleMode("GUIDED")
print("now it's BACK in GUIDED mode")
print("-----------")
index+=1
from turtle import Screen
from Snake import Snake
import time
from Food import Food
from scoreboard import ScoreBoard
sc = Screen()
sc.setup(width=600, height=600)
sc.bgcolor("black")
sc.tracer(0)
sc.title("Snake Game")
snake = Snake()
food = Food()
scores = ScoreBoard()
sc.listen()
sc.onkey(snake.up, "Up")
sc.onkey(snake.down, "Down")
sc.onkey(snake.left, "Left")
sc.onkey(snake.right, "Right")
game = True
while game:
sc.update()
time.sleep(0.1)
snake.move()
if snake.head.distance(food) < 15:
# game will utilize graphics.py as opposed to turtle graphics
from turtle import *
from turtle import Turtle, Screen
from random import *
from math import *
import os
from mpg123 import *
# screen set up
win = Screen()
win.bgcolor("black")
win.title("Frenchie in Space Game")
win.bgpic("Space.gif")
# draw a border
border_pen = Turtle()
border_pen.speed(0)
border_pen.color("white")
border_pen.penup()
border_pen.setposition(-300, -300)
border_pen.pensize(5)
border_pen.pendown()
for side in range(4):
border_pen.fd(600)
border_pen.lt(90)
border_pen.hideturtle()
# register custom graphics to assigned turtles
Screen().register_shape("space_cat.gif")
Screen().register_shape("bone.gif")
Screen().register_shape("frenchie.gif")
from turtle import Screen
from paddle import Paddle
from ball import Ball
import time
from scoreboard import Scoreboard
screen = Screen()
screen.bgcolor("deep pink")
screen.setup(width=800, height=600)
screen.title("Tower Pong")
r_paddle = Paddle((350, 0), "dark green")
l_paddle = Paddle((-350, 0), "blue")
# force_field = Paddle((200, 0), "green")
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()
#Detect collision
if ball.ycor() > 280 or ball.ycor() < -280:
__author__ = 'dmytrol'
from turtle import Screen, Turtle
import math
import random
screen = Screen()
screen.bgcolor(0.9, 0.9, 0.5)
jack = Turtle()
jack.shape("turtle")
def draw_triangle(k):
jack.color(random.random(), random.random(), random.random())
h = math.sqrt(k * k + k * k)
jack.begin_fill()
jack.right(45)
jack.forward(h)
jack.right(135)
jack.forward(k * 2)
jack.right(135)
jack.forward(h)
jack.penup()
jack.goto(0, 0)
jack.right(45)
jack.end_fill()
screen.listen()
def draw_pine_tree():
d = int(screen.textinput("Attention, please!",
