def path(individual , dat , fitness , len_dat):
# 適応度の最大値が何番目かを出力
print("適応度の最大の番地 -> " + str(fitness.index(max(fitness))))
nowKame = dat.ix[individual[fitness.index(max(fitness))]]
# 初期設定
kame = turtle.Turtle()
kame = turtle.shape('turtle')
turtle.screensize(500,1000)
for i in range(len(nowKame)):
if i == 0:
kame = turtle.up()
kame = turtle.goto(nowKame.ix[i , 0] * 2 , nowKame.ix[i , 1] * 2)
kame = turtle.down()
kame = turtle.write("Start")
else:
kame = turtle.setpos(nowKame.ix[i , 0] * 2 , nowKame.ix[i , 1] * 2)
kame = turtle.write(i + 1)
print("exitと入力すると終了します")
while True:
line = input()
if line == "exit":
break
def main():
board_ac=[10,2,3,4,5,6,7,8,9]
turtle.screensize(300,300)
turtle.hideturtle()
go_to(0,0,0)
board()
#players()
win=0
n_jogada=0
player1=input('Player 1:\t')
player2=input('Player 2:\t')
while win!=1:
n_jogada += 1
if check(board_ac) == True:
if (-1)**n_jogada == -1:
win=1
print(player2, 'Ganhou!')
else:
win=1
print(player1, 'Ganhou!')
else:
player_turn(n_jogada, board_ac)
turtle.exitonclick()
def __init__(self, length, width, roomba_step, obstacles=None):
'''
###initialization
'''
self.obstacles = obstacles
self.orient = 0
self.length = length #assume length in m
self.width = width #assume width in m
self.roomba_step = roomba_step#assume in m
self.multiply_factor = 50 #screenstep = multiply_factor * length/width
self.step_l = self.length*self.multiply_factor
self.step_w = self.width*self.multiply_factor
self.roomba_l = self.roomba_step*self.multiply_factor
self.t = turtle.Turtle()
self.t.shape("classic")
turtle.setup(self.step_l+100,self.step_w+100)
turtle.screensize(self.step_l+10, self.step_w+10)
#turtle.bgcolor("orange")
self.t.penup()
self.t.bk(self.step_l/2) # backward()
self.t.lt(90) # left()
self.t.fd(self.step_w/2) # forward()
self.t.rt(90) # right()
self.draw_boundary(self.step_l, self.step_w, self.roomba_l, self.t)
###set pen width
self.t.pendown()
self.t.pencolor("green")
self.t.pensize(self.roomba_l-1)
self.t.fd(self.roomba_l)
def viewer(dna):
'''Display ORFs and GC content for dna.'''
dna = dna.upper() # make everything upper case, just in case
t = turtle.Turtle()
turtle.setup(1440, 240) # make a long, thin window
turtle.screensize(len(dna) * 6, 200) # make the canvas big enough to hold the sequence
# scale coordinate system so one character fits at each point
setworldcoordinates(turtle.getscreen(), 0, 0, len(dna), 6)
turtle.hideturtle()
t.speed(0)
t.tracer(100)
t.hideturtle()
# Draw the sequence across the bottom of the window.
t.up()
for i in range(len(dna)):
t.goto(i, 0)
t.write(dna[i],font=("Helvetica",8,"normal"))
# Draw bars for ORFs in forward reading frames 0, 1, 2.
# Draw the bar for reading frame i at y = i + 1.
t.width(5) # width of the pen for each bar
for i in range(3):
orf(dna, i, t)
t.width(1) # reset the pen width
gcFreq(dna, 20, t) # plot GC content over windows of size 20
turtle.exitonclick()
def __init__(self):
# Janela sobre
self.janSobre = None
# Cor de fundo
self.corFundo = "gray"
turtle.screensize(1000, 700, self.corFundo)
turtle.setup(width=1000, height=700)
turtle.title("cidadeBela - Janela de desenho")
turtle.speed(0)
turtle.tracer(4)
# Definindo variáveis globais
self._tamPadrao = ""
# Listas de prédios
self.predios = ['Casa', 'Hotel']
self.prediosProc = [ 'hotel', 'hotelInv', 'casa', 'casaInv' ]
# Sorteando elementos
self.sorteioPredios = [["casa", 1], ["hotel", 1]]
self.sorteioPrediosInv = [["casaInv", 1], ["hotelInv", 1]]
# Cores dos prédios
self.coresHotel = ["076080190", "255255255", "167064057", "153204255", "000090245",
"201232098", "255058123", "010056150", "130255255", "255255000",
"255000000", "255127042", "000255000", "255170255", "000255170",
"212000255", "170255127", "127212255", "255127127", "255212085",
"212212255", "255255127", "222202144" ]
self.coresCasa = ['209187103', '115155225', '130047006', '255137111', '203229057',
'017130100', '025195159', '204057065', '194082255', '092221159',
'167045055', '238243030', '069241248', '000156228', '159094040',
'048033253', '040209239', '138164253', '190042177', '000122159',
'255255255', '253208201', '245228133']
self.coresLoja = ['255255255', '253208201', '245228133' ]
# Janelas dos prédios
self.janelasHotel = janelas.janelasHotel
self.janelasCasa = janelas.janelasCasa
self.janelasLoja = janelas.janelasLoja
self.janelasTodas = janelas.janelasTodas
# Tetos dos prédios
self.tetosHotel = tetos.tetosHotel
self.tetosCasa = tetos.tetosCasa
self.tetosLoja = tetos.tetosLoja
self.tetosTodas = tetos.tetosTodas
# Portas dos prédios
self.portasHotel = portas.portasHotel
self.portasCasa = portas.portasCasa
self.portasLoja = portas.portasLoja
self.portasTodas = portas.portasTodas
def __init__(self):
turtle.title('Phogo - CRM UAM')
turtle.mode('logo')
turtle.penup()
#turtle.setx(turtle.screensize()[0] // 8)
turtle.screensize(4000, 4000)
def franklinBegin():
turtle.screensize(3000, 3000)
turtle.clearscreen()
turtle.bgcolor('black')
franklin = turtle.Turtle(visible = False)
franklin.color('green', 'green')
franklin.speed(0)
return franklin
def drawcurve(points):
myTurtle = turtle.Turtle(shape="turtle")
turtle.screensize(500,500)
turtle.setworldcoordinates(400,400,500,500)
myTurtle.penup()
y = points[0]
myTurtle.setposition(y[0], y[1])
myTurtle.pendown()
for x in points:
myTurtle.setposition(x[0], x[1])
turtle.getscreen()._root.mainloop()
def initialize(color='brown', smallest=1.0):
'''Prepare to draw a von Koch Snowflake.'''
turtle.setup(400, 300)
turtle.screensize(350, 250)
turtle.clear()
turtle.up()
turtle.goto(-100.0, 55.0)
turtle.setheading(0)
turtle.color(color)
turtle.down()
global smallestLineLength
smallestLineLength = smallest
def koch(l,s,t): #level and size
turtle.screensize(2000,2000)
t.speed(0)
t.up()
t.setpos(-s/2.,-s/3.*math.sin(math.pi/3))
t.down()
t.ht()
turtle.tracer(0,0)
for i in range(3):
kochLine(l,s,t)
t.left(120)
turtle.update()
def main():
turtle.screensize(1000)
for i in range(1,5):
turtle.speed = 2*i
turtle.penup()
turtle.goto(-340,-200) #move to left hand side
turtle.pendown()
koch(i,i*250) #draw a koch snowflake of ordwer i
time.sleep(1)
turtle.bye() #close current window
def DrawSierpinskiTriangle(level, ss=400):
# typical values
turn = 0 # initial turn (0 to start horizontally)
angle=60.0 # in degrees
# Initialize the turtle
turtle.hideturtle()
turtle.screensize(ss,ss)
turtle.penup()
turtle.degrees()
# The starting point on the canvas
fwd0 = float(ss)
point=array([-fwd0/2.0, -fwd0/2.0])
# Setting up the Lindenmayer system
# Assuming that the triangle will be drawn in the following way:
# 1.) Start at a point
# 2.) Draw a straight line - the horizontal line (H)
# 3.) Bend twice by 60 degrees to the left (--)
# 4.) Draw a straight line - the slanted line (X)
# 5.) Bend twice by 60 degrees to the left (--)
# 6.) Draw a straight line - another slanted line (X)
# This produces the triangle in the first level. (so the axiom to begin with is H--X--X)
# 7.) For the next level replace each horizontal line using
# X->XX
# H -> H--X++H++X--H
# The lengths will be halved.
decode = {'-':Left, '+':Right, 'X':Forward, 'H':Forward}
axiom = 'H--X--X'
# Start the drawing
turtle.goto(point[0], point[1])
turtle.pendown()
turtle.hideturtle()
turt=turtle.getpen()
startposition=turt.clone()
# Get the triangle in the Lindenmayer system
fwd = fwd0/(2.0**level)
path = axiom
for i in range(0,level):
path=path.replace('X','XX')
path=path.replace('H','H--X++H++X--H')
# Draw it.
for i in path:
[turn, point, fwd, angle, turt]=decode[i](turn, point, fwd, angle, turt)
def main():
t = turtle.Turtle()
myWin = turtle.Screen()
getscreen().tracer(5, 0)
turtle.screensize(bg='wheat')
t.left(90)
t.up()
t.backward(150)
t.down()
t.color('sienna')
tree(60, t)
petal(100, t)
myWin.exitonclick()
def setupboundingbox():
turtle.reset()
turtle.setup(1100, 1100)
turtle.screensize(canvwidth=1100, canvheight=1100)
turtle.up()
turtle.goto(-500, -500)
turtle.setheading(90)
turtle.down()
turtle.forward(1000)
turtle.right(90)
turtle.forward(1000)
turtle.right(90)
turtle.forward(1000)
turtle.right(90)
turtle.forward(1000)
def drawCloud(words, num = 20):
""" Draws a wordcloud with 20 random words, sized by frequency found in
the WORDS dictionary. """
t.reset()
t.up()
t.hideturtle()
topCounts = sorted([words[word] for word in list(words.keys()) if len(word) > 3])
largest = topCounts[0]
normalized_counts = {}
for item in list(words.keys()):
if len(item) > 3:
newSize = int(float(words[item]) / largest * 24)
normalized_counts[item] = newSize
size = t.screensize()
width_dim = (int(-1 * size[0] / 1.5), int(size[0] / 2))
height_dim = (int(-1 * size[1] / 1.5), int(size[1] / 1.5))
for item in random.sample(list(normalized_counts.keys()), num):
t.goto(random.randint(*width_dim), random.randint(*height_dim))
t.color(random.choice(COLORS))
try:
t.write(item, font = ("Arial", int(normalized_counts[item]), "normal"))
except:
try:
t.write(str(item, errors = 'ignore'), font = ("Arial", int(normalized_counts[item]), "normal"))
except:
pass
def start(width, height, x, y, _delay, _name):
turtle.setup(width+45, height+45)
turtle.screensize(width+15, height+15)
turtle.up()
turtle.goto(x, y)
turtle.pendown()
turtle.shape('turtle')
global canvas
canvas = turtle.getscreen().getcanvas()
canvas.after(_delay, dump)
global delay
delay = _delay
global name
name = os.path.splitext(os.path.basename(_name))[0]
def drawImage(paths):
myTurtle = turtle.Turtle(shape="turtle")
turtle.screensize(2000,2000)
myTurtle.pendown()
myTurtle.penup()
myTurtle.setposition(0, 0)
y = 0
for path in paths:
myTurtle.penup()
temp = path[0]
myTurtle.setposition(temp[0], temp[1])
myTurtle.pendown()
y = 1
for x in paths:
for y in x:
myTurtle.setposition(y[0], y[1])
myTurtle.penup()
turtle.getscreen()._root.mainloop()
def main(wide_dis,height_dis,path):
turtle.screensize(1000,1700)
tu = turtle.Turtle()
tu.hideturtle()
tu.speed(0)
adj_list_edge=get_graph(path)
adj_list=get_adj_list(adj_list_edge)
get_weight(adj_list)
list=sorted(adj_list,key=lambda v:v.weight)
c=create_context(list)
height= c.max_height
for k in c.data:
i=1
wide=len(c.data[k])
for v in c.data[k]:
v.heart=(pos(i,wide,wide_dis),pos(height-k-1,height,height_dis))
i+=1
pair={}
for v in list:
s=None
if v.type=="exclude":
s=draw.Diamond(tu,v.name)
pair[v]=s
else:
s=draw.Square(tu,v.name)
pair[v]=s
start=s.heart2start(v.heart)
s.move(start[0],start[1])
s.draw()
for v in adj_list_edge:
list=adj_list_edge[v]
for iter in list:
s=pair[v]
e=pair[iter[0]]
dis=s.near_shape(e)
l = draw.LineWithArrow(tu,iter[1])
l.draw(dis[0],dis[1])
l.move()
mainloop()
def setScreen(matrix): '''sets the screensize''' dim = (DOTSIZE+1)*len(matrix)+BORDER screensize(dim,dim)
else: tmp = getDirData(int(qactual[1])) if int(qactual[3]) >= 40000: data = getDirData(int(qactual[3])) else: data = int(qactual[3]) addDirData(data, tmp) memoria.freeLocalMemory() ipscope = memoria.getIP() if ipscope[1] != "*work*": memoria.awakeLocalMemory() ip = ipscope[0] current_scope = ipscope[1] if (turtle.pos()[0] < -turtle.screensize()[0]): turtle.hideturtle() turtle.penup() turtle.goto(turtle.screensize()[0], turtle.pos()[1]) turtle.showturtle() elif (turtle.pos()[0] > turtle.screensize()[0]): turtle.hideturtle() turtle.penup() turtle.goto(-turtle.screensize()[0], turtle.pos()[1]) turtle.showturtle() elif (turtle.pos()[1] > turtle.screensize()[1]): turtle.hideturtle() turtle.penup() turtle.goto(turtle.pos()[0], -turtle.screensize()[1]) turtle.showturtle() elif (turtle.pos()[1] < -turtle.screensize()[1]):
import turtle as tl
def star():
tl.color('red', 'yellow')
tl.begin_fill()
while True:
tl.forward(200)
tl.left(170)
if abs(tl.pos()) < 1:
break
tl.end_fill()
tl.done()
def yes_it_is(x, y):
tl.goto(x, y)
tl.write("yes it is!", align='center', font=('Helvetica', 11))
tl.ht()
tl.bgcolor('lightsteelblue')
tl.pencolor('orange')
tl.screensize(300, 300)
tl.write("is this a game?", align='center', font=('Helvetica', 36))
star()
tl.mainloop()
max_temperature = temperatures_list[0]
min_temperature = temperatures_list[1]
if max_temperature < min_temperature:
max_temperature, min_temperature = min_temperature ,max_temperature
for i in range(2, len(temperatures_list)):
if temperatures_list[i] > max_temperature:
max_temperature = temperatures_list[i]
elif temperatures_list[i] < min_temperature:
min_temperature = temperatures_list[i]
d_temperature = max_temperature - min_temperature
dy = 200 / d_temperature
turtle.screensize(800,800)
turtle.setworldcoordinates(0, 0, 800,800)
tess = turtle.Turtle()
tess.color("blue")
tess.pensize(3)
tess.penup()
for i, temperature in enumerate(temperatures_list):
x = i * 20
y = (temperature - min_temperature) * dy + 350
tess.goto(x, y)
tess.pendown()
turtle.done()
parser.add_argument('-n', '--num', help='set number of iterations',
type=int, default=-1)
args = parser.parse_args()
try:
# Import rule module
rule = importlib.import_module(args.module)
# Expand L-system
num = args.num
if (num < 0):
num = rule.n
text = rule.axiom
for _ in range(num):
text = iterate(text, rule.subs)
# Render using turtle graphics
turtle.screensize(canvwidth=2000, canvheight=2000)
turtle.hideturtle()
turtle.speed(0)
for c in text:
if c in rule.graphics:
rule.graphics[c](turtle)
turtle.done()
except ModuleNotFoundError:
print('Invalid rule module. Make sure not to include file extension.')
except turtle.Terminator:
pass
############ ##### ####### # ##### #### ##### ############# #### ###### ######### ####### #### ###############################
#############################################################################################################################################
############################################################# TANK WAR V 1.0 ################################################################
from turtle import bgpic
from turtle import title
from turtle import screensize
from turtle import bgcolor
import turtle as t
from math import*
from random import*
####################### registers shapes for turtle ############################################################################
t.speed('fastest')
title('Tank-War v 1.0 ')
screensize(1024,700)
bgpic('bg.gif')
bgcolor('black')
t.ht()
t.register_shape('30016.gif')
t.register_shape('tankr.gif')
t.register_shape('target1.gif')
##################################### Title and Screen #######################################################################################
splash=t.Turtle()
splash.shape('30016.gif')
ww=t.Turtle()
ww.color('yellow')
ww.ht()
ww.up()
ww.goto(-150,0)
ww.down()
w1, h1 = eval(input("and r1's width and height: "))
x2, y2 = eval(input("Enter r2's center x-, y-coordinates: "))
w2, h2 = eval(input("and r2's width and height: "))
text = None
if abs(x1 - x2) >= (w1 + w2) / 2 \
or abs(y1 - y2) >= (h1 + h2) / 2:
text = "r2 does not overlap r1."
elif abs(x1 - x2) <= (w1 - w2) / 2 \
and abs(y1 - y2) <= (h1 - h2) / 2:
text = "r2 is in r1."
else:
text = "r2 overlaps r1."
font = ("Times", 11)
t.screensize(1920, 1080)
t.penup()
t.goto(x1 + w1 / 2, y1 + h1 / 2)
t.pendown()
for i in range(4):
t.right(90)
t.forward(h1 if i % 2 == 0 else w1)
t.penup()
t.goto(x2 + w2 / 2, y2 + h2 / 2)
t.pendown()
for i in range(4):
t.right(90)
t.forward(h2 if i % 2 == 0 else w2)
# Ch04 > p.115 - Example02
# This program will convert decimal int into binary digits, showing with turtles 0 & 1
import turtle as t
num = 0
swidth, sheight = 1000, 300
curX, curY = 0, 0
if __name__ == "__main__":
t.title("거북이로 2진수 표현하기")
t.shape("turtle")
t.setup(width=swidth + 50, height=sheight + 50)
t.screensize(swidth, sheight)
t.penup()
t.left(90)
num = int(input("숫자를 입력하세요 : "))
binary = bin(num)
curX = swidth / 2
curY = 0
for i in range(len(binary) - 2):
t.goto(curX, curY)
if num & 1:
t.color("red")
t.turtlesize(2)
else:
t.color("blue")
t.turtlesize(1)
t.stamp()
curX -= 50
t.fillcolor("#000000")
t.goto(random.randint(-500, 500), random.randint(-500, 500))
f = random.randint(1, 4)
#t.goto(300,0)
t.pendown()
t.begin_fill()
t.circle(10)
t.end_fill()
t.fd(100)
if (f == 1):
t.rt(100)
t.fd(10)
t.rt(20)
t.fd(10)
t.lt(20)
t.fd(10)
t.lt(100)
if __name__ == "__main__":
screen = turtle.Screen()
t = turtle.Turtle()
turtle.screensize(1000, 700)
turtle.tracer(1, 0)
sub()
for i in range(50):
music()
playsound.playsound("The Beatles - Yellow Submarine.mp3")
screen.exitonclick()
x, y = vec2d[i]
t.penup()
t.goto(x, y)
t.dot(5)
t.pendown()
if __name__ == '__main__':
# initialize a cube object
dirt = Cube()
# the coordinates of the camera (default 0, 0, 0)
# camera = Camera((0, 0, 0))
vec2d = []
vec3d = []
width, height = turtle.screensize()
# the distance between the object and the viewer
k2 = 70
# the distance between the object and the screen
k1 = width * k2 * 3 / 8 / 50
# initial rotation angle
rotX, rotY, rotZ = 0, 0, 0
while True:
t.clear()
# vec3d = rotation(dirt.verticies, rotX, rotY, rotZ, camera)
vec3d = rotation(dirt.verticies, rotX, rotY, rotZ)
vec2d = projection(vec3d, k1, k2)
drawDot(vec2d)
turtle.circle(-padEcart) turtle.end_fill() turtle.up() turtle.goto(0,padEcart) turtle.down() cpt = 2 for decimale in decimales: turtle.left(90) turtle.forward(padEcart) turtle.right(90) turtle.circle(-padEcart*cpt,decimale*padAngle) cpt += 1 decimales = [3,1,4,1,5,9,2,6,5,4] padEcart = 40 turtle.screensize(2000,1500) turtle.begin_fill() turtle.color(0.4,0.4,0.4) turtle.up() turtle.goto(0,11*padEcart+10) turtle.down() turtle.circle(-(11*padEcart)-10) turtle.end_fill() drawAxe(padEcart) drawPI(padEcart,decimales) turtle.exitonclick()
import turtle as t
t.shape('turtle')
t.color('green', 'yellow')
t.screensize(3000, 2000)
t.speed(10)
inp = open('input')
Number = [[0,0] for i in range(12)]
for i in range(1, 11, 1):
num = list(inp.readline().split())
for j in range(len(num)):
num[j] = num[j].split(',')
Number[i] = num
Number[0] = Number[10]
index = [1, 4, 1, 7, 0, 7]
for i in index:
if (i == 1):
t.up()
t.lt(270)
t.fd(50)
t.lt(90)
t.down()
for angle, step in Number[i]:
angle, step = float(angle), float(step)
t.lt(angle)
t.fd(step)
else:
def draw_regular_patterns():
"""Draw multiple shapes and colors using turtle library."""
import turtle
turtle.screensize(800, 800)
color_lst = ["#90C3D4", "#C390D4", "#D4A190", "#A1D490", "#92E85D", "#5DD7E8", "#B35DE8", "#E86E5D", "#34EAED", "#EBF779"]
print ("This program draws squares of many colors.\n")
num_squares = input("\nEnter the number of squares to draw: ")
if not num_squares.isdigit():
print("The number must be an integer and at least 1.\nPlease try again.")
sys.exit(1)
elif int(num_squares) < 1:
print("The number must be an integer and at least 1.\nPlease try again.")
sys.exit(1)
num_squares = int(num_squares)
turtle_man = turtle.Turtle()
x_direction, degree = (100, 90)
x_cor, y_cor = (0, 0)
for i in range(num_squares):
turtle_man.goto(x_cor, y_cor)
turtle_man.begin_fill()
turtle_man.down()
turtle_man.color(color_lst[random.randrange(0,10)])
for j in range(4):
turtle_man.forward(x_direction)
turtle_man.right(degree)
turtle_man.up() # pick up pen
turtle_man.end_fill() # end shape color fill
x_cor += 20
y_cor += 10
#turtle.done()
turtle.clear()
#======================================================================#
# DRAW CIRCLES
#======================================================================#
print ("This program draws circles of many colors.\n")
num_circles = input("\nEnter the number of circles to draw: ")
if not num_circles.isdigit():
print("The number must be an integer and at least 1.\nPlease try again.")
sys.exit(1)
elif int(num_circles) < 1:
print("The number must be an integer and at least 1.\nPlease try again.")
sys.exit(1)
num_circles = int(num_circles)
radius = 20
turtle_circa = turtle.Turtle()
w_cor, z_cor = (0, 0)
for i in range(num_circles):
turtle_circa.goto(w_cor, z_cor)
turtle_circa.begin_fill()
turtle_circa.down()
turtle_circa.color(color_lst[random.randrange(0,10)])
turtle_circa.circle(radius * 10)
turtle_circa.up()
turtle_circa.end_fill()
w_cor += 50
#z_cor += 50
turtle.done()
#ground = -200
#leftpos = -500
t.pu()
t.goto(leftpos, ground)
t.pd()
#t.fd(-500)
castle(castlesize)
t.fd(leftpos * -2)
#kanone
t.color("blue", "green")
cannon()
t.setheading(45)
t.screensize(1600, 800)
castlesize = 100
ground = -200
leftpos = -500
#t.left(70)
speed = 10
play = True
heading = 45
while play:
#t.clear()
t.pu()
t.home()
t.clear()
t.speed(0)
t.pd()
import turtle #turtle 프로그램을 가져오기
## 변수 선언 부분 ##
num, curX, curY = [0] * 3 #입력받을 숫자, 거북이의 X좌표, 거북이의 Y좌표
swidth, sheight = 1000, 300 #거북이 창 화면 크기
## 메인 코드 부분 ##
if __name__ == "__main__": #메인 코드 시작 부분
turtle.title("거북이로 2진수 숫자 표현하기") #거북이 프로그램 제목
turtle.shape("turtle") #거북이 모양
turtle.setup(width=swidth + 50,
height=sheight + 50) #거북이가 이동할 수 있는 범위(1050, 350)
turtle.screensize(swidth, sheight) #거북이 창 화면 크기(1000, 300)
turtle.penup() #거북이 흔적없이 이동
turtle.left(90) #거북이가 90도 왼쪽으로 회전
num_01 = int(input("숫자를 입력해주세요. :")) #숫자를 입력 받는다.
num_02 = int(input("숫자를 입력해주세요. :")) #숫자를 입력 받는다.
num_1 = num_01
binary = bin(num_1) #입력받은 정수를 2진수로 변환하여 binary라는 변수 이름으로 선언한다.
curX = swidth / 2 #초기 위치 중 X좌표를 500으로 설정
curY = 100 #초기 위치 중, Y좌표를 0으로 설정
for i in range(len(binary) - 2): #변환한 2진수의 개수만큼 반복한다.
#len은 길이를 나타냄. 2진수로 변환하면서 생기는 0b로 인하여 -2를 실행.
turtle.goto(curX, curY) #turtle이 (curX, curY) 좌표로 이동한다.
if num_1 & 1: #[비트 연산자] num의 2진수 맨 마지막 자리가 1일 때
turtle.color("red") #거북이의 색을 빨간색으로 바꿔준다.
turtle.turtlesize(2) #거북이의 크기를 2로 조정한다.
import turtle
import random
turtle.screensize(canvwidth=600, canvheight=600, bg=None)
t = turtle.Turtle()
#wn = turtle.Screen()
t.home()
t.speed(0)
x = int(input('Line Length: '))
y = int(input('Line circle redious: '))
z = int(input('Give circle angle: '))
i = 0
J = 0
while i < 1000:
t.fd(x + J)
t.circle(y, z)
i = i + 1
if i == 200: J = x
coin = random.randrange(0, 2)
if coin == 0: # heads
t.left(90)
else: # tails
t.right(90)
#print (t.position())
import turtle # 导入模块
zhufu = turtle.Turtle() # 创建Turtle对象，命名为zhufu
chuangkou = turtle.Screen # 创建窗口
turtle.screensize(400, 300, "green") # 设置窗口长宽，背景色
zhufu.pencolor("green") # 设置画笔颜色
zhufu.hideturtle() # 隐藏箭头
zhufu.setpos(-150, 50) # 移动画笔至坐标 处
zhufu.pencolor("red") # 设置画笔颜色
if True: # 输入5
zhufu.pensize(15)
zhufu.left(180)
zhufu.forward(50)
zhufu.left(90)
zhufu.forward(50)
zhufu.left(90)
zhufu.forward(50)
zhufu.right(90)
zhufu.forward(50)
zhufu.right(90)
zhufu.forward(50)
if True: # 输入2
zhufu.penup() # 抬起画笔
zhufu.setpos(-50, 50) # 移动画笔至坐标 处
zhufu.pendown() # 放下画笔
zhufu.left(180)
zhufu.forward(50)
zhufu.right(90)
zhufu.forward(50)
zhufu.right(90)
zhufu.forward(50)
import turtle
turtle.screensize(1500, 2000)
my_turtle = turtle.Turtle()
#;rectangle
def star(x: int, y: int, angle: int, length: int, color: str):
turtle.pu()
turtle.goto(0, 0)
turtle.setx(x)
turtle.sety(y)
turtle.pd()
turtle.width(3)
turtle.pencolor(color)
turtle.seth(angle)
turtle.fd(length)
star(-200, 200, 0, 400, 'blue')
star(200, 200, -144, 400, 'red')
star(-124, -35, 72, 400, 'green')
star(0, 345, 288, 400, 'black')
star(124, -35, 144, 400, 'purple')
'''
Created on 10/10/2018
@author: Susmitha Shailesh
Pledge: I pledge my honor that I have abided by the Stevens Honor System.
CS115 - Hw 5
'''
import turtle # Needed for graphics
# Ignore 'Undefined variable from import' errors in Eclipse.
'''settings for turtle'''
turtle.speed(0)
turtle.screensize(500, 500, "orange")
turtle.pensize(200)
turtle.pencolor("red")
turtle.penup()
turtle.goto(-150, -100)
turtle.pendown()
turtle.circle(10)
turtle.pensize(150)
turtle.pencolor("yellow")
turtle.penup()
turtle.goto(-150, -100)
turtle.pendown()
turtle.circle(10)
turtle.pencolor("DarkOliveGreen")
turtle.pensize(200)
turtle.penup()
def main():
turtle.screensize(800, 600)
turtle.title('Cartoon')
cartoon = Cartoon()
cartoon.start()
turtle.mainloop()
'''
'''
# 描述: 以给定半径画圆
参数:
radius(半径); 半径为正(负),表示圆心在画笔的左边(右边)画圆
extent(弧度) (optional);
steps (optional) (做半径为radius的圆的内切正多边形,多边形边数为steps)
turtle.circle(radius, extent=None, steps=None)
举例:
circle(50) # 整圆;
circle(50, steps = 3) # 三角形;
circle(120, 180) # 半圆
'''
# screensize(): 参数分别为画布的宽(单位像素), 高, 背景颜色
turtle.screensize(500, 500, "white")
turtle.speed(10) # 设置画笔移动速度,画笔绘制的速度范围[0,10]整数, 数字越大越快
turtle.begin_fill() # 图形准备开始填充
turtle.color('red', 'yellow')
for _ in range(50):
turtle.forward(200) # 向当前画笔方向移动 200 像素长度
turtle.left(170) # 逆时针移动 170°
turtle.end_fill() # 填充完成
turtle.mainloop() # 启动事件循环 -调用Tkinter的mainloop函数。必须是乌龟图形程序中的最后一个语句。
import turtle as tu
import random as rand
import math
radius = 200
tu.hideturtle()
tu.tracer(0, 0)
tu.speed(0)
tu.screensize(500, 500)
tu.penup()
tu.goto(0, -radius)
tu.pendown()
tu.pencolor(0.8, 0.8, 0.8)
tu.circle(radius)
tu.pencolor(0.0, 0.0, 0.0)
tu.penup()
tu.goto(0, 0)
tu.pendown()
for i in range(4):
tu.forward(radius)
tu.left(90)
n = 0
m = 0
vals.append(a) valsarray = np.asarray(vals) valsarray[0] = valsarray[1] + valsarray[0] valsarray = valsarray - valsarray[0] clusterlength = max(valsarray) + 50 offset = -50 #Circle radius for terminator symbol tcircrad = 15 # hide turtle and set draw speed turtle.setup(width=3000, height=1080, startx=0, starty=0) turtle.screensize(3000, 1080) turtle.hideturtle() turtle.speed(10) # line turtle.penup() turtle.right(180) turtle.forward(clusterlength * 0.5) turtle.right(180) turtle.pendown() turtle.pen(pencolor="black", pensize=4) turtle.forward(clusterlength) ## draw orfs turtle.penup()
def core(self):
turtle.screensize(10000,10000)
turtle.clearscreen()
turtle.bgcolor("black")
# select the origin in middle of the map
q = self.n/2
p = self.m/2
# origin
turtle.pencolor("red")
turtle.fill(True)
for _ in range(3): turtle.forward(5); turtle.left(120)
turtle.fill(False)
# init
x = 0
y = 0
#while(self.map[p][q]!=1) :
while(True) :
self.map[p][q]+=1
# current color
t = 0;
if(self.map[p+1][q+1]==1) : t+=1
if(self.map[p+1][q-1]==1) : t+=1
if(self.map[p-1][q-1]==1) : t+=1
if(self.map[p-1][q+1]==1) : t+=1
if(t==0) : turtle.pencolor("white")
if(t==1) : turtle.pencolor("green")
if(t==2) : turtle.pencolor("blue")
if(t==3) : turtle.pencolor("purple")
if(t==4) : turtle.pencolor("red")
# display progression with tk and turtle
self.display(x)
# random value
x = self.randomMode(1)
if(x>0 and x<=90):
p += 1
q += 1
elif(x>90 and x<=180):
p += 1
q -= 1
elif(x>180 and x<=270):
p -= 1
q -= 1
elif(x>270 and x<=360):
p -= 1
q += 1
else : print '>>>> ERROR !!!'
y += 1
print '>>> ESSAI '+str(self.c)
print '>>> Nombre de coups : '+str(y)
(self.s).append(y)
self.v += y
self.c += 1
self.t -= 1
def run():
turtle.screensize(1920,1080)
turtle.penup()
turtle.hideturtle()
point=[]
# point=[[20,20],[50,10],[110,30],[110,80],[50,50],[20,70]]
# point=[[-10,-10],[10,-10],[15,0],[10,10],[-10,10],[-15,0]]
temp = [float(x11.get()), float(y1.get())]
point.append(temp)
temp = [float(x2.get()), float(y2.get())]
point.append(temp)
temp = [float(x3.get()), float(y3.get())]
point.append(temp)
temp = [float(x4.get()), float(y4.get())]
point.append(temp)
temp = [float(x5.get()), float(y5.get())]
point.append(temp)
temp = [float(x6.get()), float(y6.get())]
point.append(temp)
point = [[20, 20], [50, 10], [110, 30], [110, 80], [50, 50], [20, 70]]
#画出原图：
for i in point:
turtle.goto(i[0],i[1])
turtle.pendown()
turtle.goto(point[0][0],point[0][1])
#创建新边表：
newEdgeTable,Y=createNewEdgeTable(point)
miny,maxy=findRange(point)
y=miny
acativeList=[]
while y<=maxy:
#把新边表加进来：
ynum=0
if y in Y:
for i in newEdgeTable:
if i.y==y:
for j in i.l:
acativeList.append(j)
ynum=i.numy
break
acativeList.sort(key=AetNode.op)
for j in acativeList:
print((j.x,j.tx,j.my))
print("****************")
#进行填色：
i=0
flag=True
while i<len(acativeList)-1:
x1=acativeList[i].x
temp=[acativeList[i+1].x,y]
if temp in point and ynum>=1:
ynum-=1
else:
i+=1
if flag:
draw(x1,y,temp[0],y)
flag=not flag
#更新活性边表：
newacativeList=[]
for i in acativeList:
if i.my>y:
i.x+=i.tx
newacativeList.append(i)
acativeList=newacativeList
y+=1
turtle.mainloop()
import turtle
import ctypes
def screen_dimensions():
# A simple function to compute the screen's dimensions.
user32 = ctypes.windll.user32
return user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)
screen_width, screen_height = screen_dimensions()
window_width, window_height = 0.618 * screen_width, 0.8 * screen_height
print(844, 614)
# window = turtle.Screen
turtle.setup(window_width, window_height)
print(turtle.screensize())
# turtle.Screen.setup(width=screen_width, height=screen_height)
def line(A, B, tad, color):
x0, y0, x1, y1 = A[0], A[1], B[0], B[1]
tads_position = tad.position()
tads_color = tad.color()
tad.color(color, color)
tad.penup()
tad.goto(x0, y0)
tad.pendown()
tad.goto(x1, y1)
tad.penup()
tad.goto(tads_position)
def GraficoSobreposicao(linhas_arq):
tempo = calculaTempo(Distancias.obterTempos(linhas_arq))
lst = []
try:
bpm = Distancias.obterBPM(linhas_arq)
b = "b - BPM"
z = "z - Zonas de BPM"
lst.append(max(bpm))
except:
b = ""
z = ""
try:
alt = Distancias.obterAltitudes(linhas_arq)
a = "a - Altitude"
lst.append(max(alt))
except:
a = ""
rit = Distancias.obterListaRitmo(linhas_arq)
tempo_sem_transladar = tempo
tempo = [x / 3 for x in tempo]
tempo = transladarPontos(tempo, 500 - 20)
Chuu = turtle.Turtle()
Chuu.penup()
Chuu.hideturtle()
Chuu.goto(tempo[0], -40)
lst.append(max(rit))
global tela
tela = turtle.Screen()
turtle.screensize(max(tempo) + 50, max(lst) + 1000)
op = tela.textinput(
"Gráficos",
"Quais gráficos deseja visualizar?\n\np - Percurso\n{}\n\nOu combine:\n{}\n{}\nr - Ritmo\n\n"
.format(z, a, b))
while op != None:
if op == "z":
GraficoZonas(bpm, tempo, tempo_sem_transladar)
if op == "p":
GraficoPercurso(linhas_arq)
if "b" in op or "a" in op or "r" in op:
Chuu.write("Legenda:", font=("Arial", 9, "normal"))
desenharEixo(lst, tempo, "", "Tempo")
numerarEixoX(tempo_sem_transladar, tempo)
numerarEixoY(lst, tempo)
if "b" in op:
Chuu.color("red")
Chuu.goto(tempo[0], -80)
Chuu.write("BPM", font=("Arial", 10, "normal"))
Grafico(bpm, tempo, "red")
if "a" in op:
Chuu.color("#006400")
Chuu.goto(tempo[0], -120)
Chuu.write("Altitude", font=("Arial", 10, "normal"))
Grafico(alt, tempo, "#006400")
if "r" in op:
Chuu.color("purple")
Chuu.goto(tempo[0], -160)
Chuu.write("Ritmo", font=("Arial", 10, "normal"))
Grafico(rit, tempo, "purple")
else:
erro = "Opção Inválida.\n"
op = tela.textinput(
"Gráficos",
"{}Quais gráficos deseja visualizar?\n\np - Percurso\n{}\n\nOu combine:\n{}\n{}\nr - Ritmo\n\n"
.format(erro, z, a, b))
if op != None:
tela.clear()
tela.onkey(GraficoSobreposicao(linhas_arq), "Up")
tela.listen()
else:
exit()
turtle.done()
# Créé par Yaya, le 26/10/2020 en Python 3.7
import turtle
turtle.tracer(0, 0) # accélération du tracé
turtle.screensize(50, 50) # taille fenêtre graphique
turtle.pu()
turtle.goto(0, 0)
turtle.pd()
longueur = 10
angle = 120
niter = 2 #boucle
motifInitial = 'F-G-G' # le motif initial creer un triangle
def dessiner(tapis, longueur, angle):
""" réalise une représentation graphique d'un tapis de sierpinski donnée par des chaines de caractères """
for caractere in tapis:
if caractere == '+': turtle.left(angle)
elif caractere == '-': turtle.right(angle)
elif caractere in ['F', 'G']: turtle.forward(longueur)
#dessiner('F', 50, 60)
def triangle(chaine):
nouvelleChaine = '' # on crée une nouvelle chaine de caractères VIDE
for lettre in chaine: # on épelle la chaine de caractères donnée en paramètres
if lettre == 'F': # si dans l'ancienne chaine, il y a un 'F'
# import turtle, and from turtle Turtle and Screen
import turtle
from turtle import Turtle, Screen
# create a new instance of turtle.Pen() - t, new instance of
# turtle.Screen() - screen
t = turtle.Pen()
screen = turtle.Screen()
# set mode to logo, speed to 4, and pensize to 4
turtle.mode('logo')
t.speed(5)
t.pensize(4)
# set screensize to that of full HD monitor, and set turlte window title
turtle.screensize(canvwidth=1920, canvheight=1080)
screen.title("SKETCHY SHAPES: A Shape Maker for Sketchy People")
# define dict of colors to be used for pen color and fill color
# you will notice if you look at the pen, fill, and bg colors, they are based
# on my editor's color scheme - Gruvbox'
pen_fill_colors = {
0: '#fb4934',
1: '#b8bb26',
2: '#fabd2f',
3: '#83a598',
4: '#d3869b',
5: '#8ec07c',
6: '#fe8019',
7: '#cc241d',
8: '#98971a',
# -*- coding: utf-8 -*-
import turtle
import turtlecollide # Importererer turtlecollide.py
import wasd # importerer wasd.py
# Setter størrelsen på turtle-vinduet til 500 x 500 piksler
turtle.screensize(500, 500)
turtlecollide.makeline(250)
# Holder på antall ganger vi præver å bevege oss over linjen
i = 0
def checkrightfaceplant():
#sjekker om turtle passerer forbudt linje
global i
step = 100 # Hvor langt turtle vil bevege seg
# Om vi IKKE kolliderer med linjen
if not turtlecollide.is_colliding(turtle.xcor()+step, 250):
print("You may pass!")
wasd.moveright()
else:
# Vi kolliderte med linjen
print("Thou shall not pass!")
# For å være litt artig, teller vi
# antall ganger vi forsøker å gå over linjen.
# Spillet tar slutt om vi forsøker mer enn 50
# Ganger.
i += 1
def GraficoZonas(lista, tempo, tempo_sem_transladar):
zonas = ["104", "114", "133", "152", "172", "190"]
turtle.screensize(max(tempo) + 50, max(lista) + 50)
turtle.title('Zonas de BPM')
GoWon = turtle.Turtle()
GoWon.color()
GoWon.hideturtle()
GoWon.pensize(2)
GoWon.shapesize(5)
GoWon.penup()
GoWon.goto(-447, -50)
GoWon.write("Zonas de BPM:", font=("Times New Roman", 15, "bold"))
maxi = turtle.Turtle()
maxi.hideturtle()
maxi.color("#E43E3E")
maxi.speed(100)
maxi.penup()
maxi.goto(tempo[0], 171)
maxi.pendown()
retangulo(maxi, tempo_sem_transladar, 19)
maxi.penup()
maxi.goto(-447, -100)
maxi.write('Máxima', font=('Times New Roman', 20, "bold"))
inten = turtle.Turtle()
inten.hideturtle()
inten.color("#EEB543")
inten.speed(100)
inten.penup()
inten.goto(tempo[0], 152)
inten.pendown()
retangulo(inten, tempo_sem_transladar, 20)
inten.penup()
inten.goto(-447, -150)
inten.write('Intensa', font=('Times New Roman', 20, "bold"))
mod = turtle.Turtle()
mod.hideturtle()
mod.color("#4FEE43")
mod.speed(100)
mod.penup()
mod.goto(tempo[0], 133)
mod.pendown()
retangulo(mod, tempo_sem_transladar, 19)
mod.penup()
mod.goto(-447, -200)
mod.write('Moderada', font=('Times New Roman', 20, "bold"))
leve = turtle.Turtle()
leve.hideturtle()
leve.color("#43BAEE")
leve.speed(100)
leve.penup()
leve.goto(tempo[0], 114)
leve.pendown()
retangulo(leve, tempo_sem_transladar, 19)
leve.penup()
leve.goto(-247, -100)
leve.write('Leve', font=('Times New Roman', 20, "bold"))
mtL = turtle.Turtle()
mtL.hideturtle()
mtL.color("#535758")
mtL.speed(100)
mtL.penup()
mtL.goto(tempo[0], 104)
mtL.pendown()
retangulo(mtL, tempo_sem_transladar, 10)
mtL.penup()
mtL.goto(-247, -150)
mtL.write('Muito Leve', font=('Times New Roman', 20, "bold"))
desenharEixo(lista, tempo, "BPM", "Tempo")
numerarEixoYZonas(zonas, tempo, 20)
numerarEixoX(tempo_sem_transladar, tempo)
GoWon.goto(tempo[0], lista[0])
GoWon.pendown()
for x in range(len(lista) - 1):
GoWon.goto(tempo[x], lista[x])
turtle.done()
# ajout du boid boids.append(boid); speeds.append(speed) regle1.append([0, 0]) regle3.append([0, 0]) regle4.append([0, 0]) regle5.append([0, 0]) turtle.tracer(50, 1) turtle.hideturtle() # -- while True: hauteur, largeur = turtle.screensize() # calcul de la position moyenne -- regle 1 for i in range(nombre_oiseaux): centre_x, centre_y = 0, 0 for boid in boids: centre_x += boid.xcor() centre_y += boid.ycor() centre_x /= nombre_oiseaux centre_y /= nombre_oiseaux regle1[i][0] = centre_x - boids[i].xcor() regle1[i][1] = centre_y - boids[i].ycor() # calcul de la vitesse moyenne -- regle 2
import turtle
import random
turtle.screensize(1000, 1000,
"white") #Added to make this work on smaller screens
r1 = random.randint(20, 700)
t1 = (800 - r1) / 2
r2 = random.randint(20, 700)
t2 = (800 - r2) / 2
r3 = random.randint(20, 700)
t3 = (800 - r3) / 2
r4 = random.randint(20, 700)
t4 = (800 - r4) / 2
r5 = random.randint(20, 700)
t5 = (800 - r5) / 2
r6 = random.randint(20, 700)
t6 = (800 - r6) / 2
r7 = random.randint(20, 700)
t7 = (800 - r7) / 2
r8 = random.randint(20, 700)
t8 = (800 - r8) / 2
r9 = random.randint(20, 700)
def lcm(a, b):
"""Compute the lowest common multiple of a and b."""
return a * b / math.gcd(a, b)
math.lcm = lcm
# Setup Turtle ###############################################################
window = Pixels(800)
turtle_global.getscreen().setup(width=int(window),
height=int(window),
startx=None,
starty=None)
turtle_global.screensize(int(window) - 20, int(window) - 20, "black")
turtle_global.hideturtle()
turtle = Turtle()
screen_size = Pixels(turtle.screen.screensize()[0])
world_size = CartesianResolution(900, 900)
Distance.set_conversion_factor(screen_size, world_size.x)
turtle.hideturtle()
turtle.speed(0)
turtle.color("white", "white")
turtle.begin_fill()
turtle.setpos(0, -int(TABLE_RADIUS_MM.pixels()))
turtle.circle(int(TABLE_RADIUS_MM.pixels()))
turtle.setpos(0, 0)
turtle.end_fill()
turtle.color("black", "white")
# Convert theta to radians (it will be reset to degrees before the value is increased)
theta = math.radians(theta)
# The polar equation for an ellipse, with adjustment for the value of angle.
r = xRadius * yRadius / math.sqrt((
(yRadius * math.cos(theta - angle))**2) + (
(xRadius * math.sin(theta - angle))**2))
# Convert the polar result to cartesian format and move.
x = int(r * math.cos(theta)) + xCenter
y = int(r * math.sin(theta)) + yCenter
steve.goto(x, y)
# Initialize the screen, the pen color, and the drawing speed.
turtle.screensize(1100, 625)
turtle.setup(1100, 625)
steve.color('black')
steve.speed(0)
# Move Steve to his initial location.
steve.penup()
steve.setpos(-490, 245)
steve.pendown()
steve.right(90)
# Draw 13 red and white stripes.
for i in range(13):
steve.begin_fill()
if i % 2 != 0:
steve.fillcolor("#FFFFFF")
# 葵花
import turtle
import time
turtle.color("red")
turtle.screensize(800, 600, "grey")
for i in range(40):
turtle.forward(200)
turtle.right(110) # 右转角度
time.sleep(5)
import turtle
from math import sqrt
# 判断是否为素数
def is_prime(num):
for i in range(2, round(sqrt(num))+1):
# 能整除，非素数
if num % i == 0:
return False
return True
# %%
# 定义画布的大小和背景
turtle.setup(0.8, 0.9)
turtle.screensize(100, 100, 'black')
minxv = -50 # 定义起始位置
minyv = -80
maxxv = turtle.window_width()+minxv
maxyv = turtle.window_height()+minyv
turtle.setworldcoordinates(minxv, minyv, maxxv, maxyv)
# 定义画笔的速度
turtle.speed(0)
turtle.Turtle().screen.delay(0)
# 绘制图形的宽度
turtle.pencolor("white")
turtle.pensize(1)
turtle.setheading(-90)
turtle.hideturtle()
# %%
num = 0
i = 0
sql = ""
count = 0
strdata1, strdata2, strdata3, strdata4,strdata5, strdata6, strdata7 = [], [], [], [], [], [], []
##메인 코드 부분##
con = sqlite3.connect("C:/Users/dudqh/오픈소스기초프로젝트/과제9주차") ##DB생성
cur = con.cursor() ##커서생성
#cur.execute("CREATE TABLE ttable(선분 ID int,색상R float,색상G float,색상B int,순번 int,X 좌표 int,Y 좌표 int)")
turtle.title('거북이가 맘대로 다니기(DB)')
turtle.shape('turtle')
turtle.pensize(pSize)
turtle.setup(width=swidth + 30, height=sheight + 30)
turtle.screensize(swidth, sheight)
while (True):
# row = cur.fetchone()
# col = cur.fetchall()
count += 1
data1 = count
data5 = count
r = random.random()
g = random.random()
b = random.random()
data2 = r
data3 = g
self.turt.color('red')
def reset(self):
self.turt.penup()
self.turt.setpos(self.pos)
# 距离计算函数，计算两个人之间的距离
def dis(a, b):
d = math.sqrt((a.x - b.x)**2 + (a.y - b.y)**2)
return d
# turtle的相关设定
turtle.setup(TOTAL_W * 2 + 200, TOTAL_H * 2, 0, 0)
turtle.screensize(TOTAL_W, TOTAL_H)
turtle.clearscreen()
turtle.hideturtle()
turtle.tracer(False)
# 实验的人数参数设定
total_num = 100
infected_num = random.randint(0, total_num) # 这里以随机数确定起始感染人数
healthy_num = total_num - infected_num
# 所有人的数组
persons = []
# 健康人
for i in range(healthy_num):
t1 = person(0)
import turtle
import mbhandler
width,height = turtle.screensize()
mbhandler.init()
colours = [
"Red",
"Green",
"Blue",
"Yellow",
"Purple",
"Cyan"
]
colour = 0
turtle.pencolor(colours[colour])
speed = 0
while True:
mb = mbhandler.queue.get()
x = mb['accelerometer']['x']
y = mb['accelerometer']['y']
a = mb['button_a']['down']
b = mb['button_b']['down']
if abs(x) < 10:
x = 0
if abs(y) < 10:
y = 0
from __future__ import division, print_function
# For sprites, pens, and the timer
import turtle, time
# Setup a Global time.
__TIME = time.time()
# Global answer variable
__ANSWER = ''
# Set a turbo mode checker
__TURBO_ON = False
# Create a 'Sprite'
__SPRITE = turtle.Turtle()
turtle.mode('logo')
__SPRITE.up()
__SPRTIE.speed(10)
# Doesn't account for bigger snap stages.
turtle.screensize(320, 480)
def notImplemented(b):
print(b + " has not been implemented.\n")
###############################################################################
# MOTION BLOCKS #
###############################################################################
"""
The command blocks with dropdowns need functions:
point-towards() -- at least we can probably do mouse-pointer
go-to() -- [same as above]
glide for -- not sure?
if edge, bounce -- probably needs some more code?
def __setScreen(self):
"""set the screen/window depending on view static attributes."""
turtle.resizemode('noresize')
self.width = self.GRID_MARGINLEFT + 2 * self.gridWidth + self.GAP_BETWEEN_GRIDS + self.GRID_MARGINRIGHT
self.height = self.GRID_MARGINTOP + self.gridWidth + self.GRID_MARGINBOTTOM
turtle.setup(width=self.width + 10, height=self.height + 10)
turtle.screensize(self.width, self.height)
turtle.bgpic("Ressources/fire_ocean.gif")
turtle.reset()
